diff --git a/.claude/probe-axes.md b/.claude/probe-axes.md
deleted file mode 100644
index b19a06b0..00000000
--- a/.claude/probe-axes.md
+++ /dev/null
@@ -1,755 +0,0 @@
-# Probe axes: CodoMetis.TypeKit
-
-The `prober` agent reads this file at the start of every round. It says how to write and run a probe
-here, where the claims come from, which external APIs to enumerate, which type shapes to generate,
-what to compare against, and what is intended. Everything specific to this repository lives here;
-the agent itself is generic.
-
-## Harness
-
-Write probes as xunit theories in **`test/CodoMetis.TypeKit.Samples`**, in a folder `Probes/` of the
-scratch copy, one file per claim, class name ending in `Probe`, rows fed through `[MemberData]` from
-the covering array (`prober rows`), read from a JSON file beside the probe. That project is the
-closest thing to a consumer: it references every package, weaves value objects through the real
-fabric, and loads the analyzer as an analyzer. A probe file may declare its own value objects
-(`readonly partial record struct ProbeId : IValue<Guid>;`); the declarations of the type-shape
-catalogue, `tools/probe/corpus/harness/*.g.cs`, are written by the file-based apps of
-`tools/probe/generators/` (`dotnet run tools/probe/generators/<app>.cs -- ...`, its README), never by hand,
-and `GeneratedHarnessTests` in the conventions tests holds each file to its app's output.
-
-- Start a probe with `prober new --claim <id>` and iterate with `prober try --probe <P> [--rows i,j,...]`
-  (tools/Prober/README.md, "Writing a probe"): `new` stages the skeleton in this harness's form, with the
-  claim's obligations quoted and a throwing check each, the probe's own rows and the registry entry; `try`
-  builds the corpus and the staging in the replay's worktree and runs that one probe, printing each row's
-  outcome and recording nothing. Never copy the corpus into a worktree or write a build or sync script.
-- Build and run only through the verdict tool, which pins English output, builds before it tests,
-  names the exit codes and prints failing tests by name with their assertion:
-  `dotnet tools/BuildVerdict/bin/Release/net10.0/build-verdict.dll build test/CodoMetis.TypeKit.Samples`
-  (cold, about 1 to 2 minutes), then `dotnet tools/BuildVerdict/bin/Release/net10.0/build-verdict.dll test
-  --project test/CodoMetis.TypeKit.Samples --filter-class "*Probe"`. Build the tool first, `dotnet build
-  tools/BuildVerdict -c Release`: a fresh worktree has no dll and a stale one refuses (exit 3).
-  The full log is at `$(git rev-parse --absolute-git-dir)/build-verdict-last.log`.
-- Warnings are errors. Add `#pragma warning disable xUnit1051` at the top of a probe that awaits
-  without a cancellation token; an obsolete setting (`IgnoreNullValues`) needs its `SYSLIB` id
-  suppressed. A probe that deliberately uses something the analyzer refuses suppresses that one CMTK
-  id around the line and says why.
-- HTTP probes: `WebApplication.CreateBuilder(new WebApplicationOptions { EnvironmentName =
-  Environments.Production })` (Development adds the developer exception page, and a refusal then
-  arrives as a 500), `builder.WebHost.UseTestServer()`, the JSON options through
-  `builder.Services.ConfigureHttpJsonOptions(...)`, then `app.StartAsync()` and `app.GetTestClient()`.
-  The OpenAPI document is at `/openapi/v1.json` after `builder.Services.AddOpenApi(o => {
-  o.OpenApiVersion = ...; o.AddTypeKit(); })` and `app.MapOpenApi()`. A controller must be `internal`
-  and added through an `IApplicationFeatureProvider<ControllerFeature>`; a public one is discovered by
-  every other host in the project. A host with controllers must put its own converters and resolvers
-  on MVC's `JsonOptions` too, or the document is refused on purpose (`DescribedOptionsAgreement`).
-  `test/CodoMetis.TypeKit.AspNetCore.Tests/ProbeHost.cs` is a working example to copy from.
-- How a row ends: a check returns null or the failure text, and runs through `Rec.Run`, which fails the
-  test for a violation or a harness error and skips it, with its reasons, for any other outcome but a
-  pass; a check that throws ends as a harness error, never a violation, and no seed counts it caught. A check
-  says how it compared with `r.Note(NoteKeys.Name, detail)`. The key, a member of `NoteKeys` in `harness/Row.cs`,
-  alone decides the note's outcome: every key is a pass key but `framework-refuses`, the three-sided
-  differential's expected refusal, and a check that did not apply, refused or could not tell says so through
-  its scope with a citation (below), never a note key. Keys are constants the compiler checks: a new one goes
-  into `NoteKeys` with its outcome on one line, and a string, a misspelled member or a key built from text does
-  not compile (decision 103). A probe outside the namespace `Probes.Shapes` writes `using NoteKeys = Probes.Shapes.NoteKeys;`.
-  Never match a failure's text to excuse it. A difference the framework makes on its own is shown by a
-  baseline in the same row (the document as ASP.NET writes it without `AddTypeKit()`,
-  `Hx.DocRefusedByAspNetAlone`, a refusal compared by exception type and stage as `Sides.Alike` compares one),
-  not by a substring. A document both refuse alike is the framework's refusal for a check that compared nothing
-  else, and leaves a check that compared an answer on the wire first to be judged by that answer. A row that would fail for an open finding calls
-  `r.Skip("F7", why)`, the finding as a string literal: `register` and `publish` refuse a skip whose finding
-  is built from text or is not open in the ledger, naming the file and line. The gate refuses while any row
-  skips, and the replay fails a skip whose finding the ledger has fixed or dismissed.
-- Checks: a comparison is `r.Check("obligation", Baseline.Twin, c => ...)` (or the `async` form), one per
-  obligation of the claim (`claim` for a claim without them), against one baseline of `Baseline` (`Twin`,
-  `Framework`, `RoundTrip`, `Model`, `Refusal`, `Cost`, `Fact("KB-031")`, `Docs("file#anchor")`). The check reads
-  through `c["axis"]` (or the row, inside the body: both read for the check), notes how it compared with
-  `c.Note(NoteKeys.Compared, ...)`, and says why it did not compare with `c.Inapplicable(Cite...)`,
-  `c.Refused(Cite...)` or `c.Inconclusive(reason)`, each returning null. A citation is `Cite.NotPromised("id")` (an
-  entry of the claim's `not-promised`), `Cite.Docs("file#anchor")`, `Cite.Fact("KB-031")` or `Cite.Record("0094")`,
-  written with a string literal; `register`, `publish` and the conventions tests refuse anything else and a
-  citation that names nothing. A failure returned is the check's violation, an exception its harness error (the
-  row's other checks still run), and a pass with no baseline a harness error. A row passes when no check failed
-  and one passed, so a check that did not apply voids no other; the ledger credits each passing check with the
-  axes it read and the row's, never a pair put together from two checks. A seed naming an obligation is caught
-  only by a check naming it.
-- Two-sided checks: the twin is `Entry.Plain`, the wrapped type at the value object's nullability (a class value object over a
-  struct faces the struct made nullable; the closed set faces a string), written by `shapes.cs` beside the value object. Build both
-  sides with `Sides.Twins(position, containing, entry, plain, vo)`, which puts the row's position and containing type around each and
-  throws, a harness error, where the two do not hold the same shape. Under `json.TypeInfoResolver=source-generated-context` the options
-  resolve through `ProbeContext` alone, which lists every shape, position and containing type and each twin, with no reflection behind
-  it; `json.TypeInfoResolverChain=context-then-default` puts the reflection fallback after it. A shape the context does not list is a
-  harness error, never a fallback (tools/probe/generators/README.md, "The twin and the context").
-- EF probes: SQLite in memory (`Data Source=:memory:` with the connection held open). PostgreSQL needs
-  a server and is out of reach.
-- Analyzer probes (what compiles and what CMTK reports): in `test/CodoMetis.TypeKit.Analyzers.Tests`,
-  a `CSharpCompilation` over `RealTypeKit.References` (`AnalyzerTest.cs`) with the analyzers attached,
-  asserting the diagnostics. The type-shape catalogue is the row there, as source text.
-- Native AOT is measured only by `./test/consumer-smoke-test.sh` (minutes, needs clang). Probe it only
-  when the caller asks for it.
-
-## Seeds: every probe shows it can fail
-
-A probe that passes proves something only if it can fail. Every registered probe names one seeded
-product defect ([decision 100](../design/adr/0100-every-probe-is-shown-to-fail-against-a-seeded-defect.md)):
-a patch against `src/` that breaks what its claim promises, in `tools/probe/corpus/seeds/<claim>.patch`,
-and a sentence saying what it breaks, in its registry entry:
-
-```json
-"seed": { "patch": "seeds/L01-json-bytes.patch", "defect": "A dictionary key is written with ToString(), not the wrapped type's key converter and DictionaryKeyPolicy." }
-```
-
-- Write the seed with the probe. Make the defect in `src/` of the scratch copy, take `git diff -- <file>`
-  as the patch, undo it by inverse edit (`git apply -R <patch>`), and register with `prober register ...
-  --seed seeds/<claim>.patch --defect "<sentence>"`. An environment toggle (`"env": {...}`, set for the
-  build and every run) is a seed too, where the product reads one; none does today.
-- Seed the defect the claim is about, the one a consumer would meet: a facet dropped, a refusal that
-  quotes its input, a rule skipped, a key no longer generated. A seed whose build fails proves nothing,
-  and the command counts it as a failure.
-- `prober seeds [--probe P]` applies each seed in a scratch worktree of its own (`replay --where` names
-  it), builds, replays the probe there and requires a row that ends as a violation the unseeded probe
-  does not have; a missed seed fails it. It records no evidence and takes no lock. The worktree is per
-  checkout, so runs in two checkouts (a linked worktree each) never meet, but two runs at once in one
-  checkout share it. One build per seed, so it runs locally, never in CI: after writing a probe or
-  changing its harness, and before a release.
-- Without a build, the prober tests hold the rest on every run (`SeedsTests`): every registered probe
-  has a seed, and its patch touches only `src/` and still applies. A product change that moves the
-  patched lines fails there; make the seed again against the new code.
-- A seed per obligation ([decision 104](../design/adr/0104-a-claim-states-its-obligations-and-each-has-a-seed.md)).
-  A seed that breaks some assertion of a probe shows the probe can fail, not that the claim is checked, so
-  a probe whose claim lists `obligations` carries `seeds`, one per obligation it checks, each a seed as
-  above with an `obligation` naming it; `seed` may name one too. A seed that names none counts only for a
-  claim without `obligations`. Register each with `prober register --probe P --claim C --filter "*P"
-  --obligation <id> --seed seeds/<claim>-<id>.patch --defect "<sentence>"`, the command `prober new` prints
-  for each obligation: it replaces a seed of the entry that names the same obligation and refuses an id the
-  claim does not list. Never edit the staged registry by hand. `prober seeds` runs each seed of a probe on its own and reports it as
-  `P/<obligation>`, in its output and in `seeds-last.json`; `prober status` shows per claim its obligations
-  and the ones no seed names; and `SeedsTests` refuses, without a build, a seed naming an obligation its
-  claim does not list and a listed obligation of a claim with probes that no seed of them names.
-
-## Claim sources
-
-In this order: the root `README.md` ("What TypeKit guarantees" first), `docs/*.md`, the package
-READMEs (`src/*/README.md`), then `design/adr/*.md` for intent. Statements in `docs/` and the READMEs
-are promises to consumers; a design record explains, and decides what is intended.
-
-## Axes
-
-The axes are data, read by `prober universe` (tools/Prober), which builds each claim's
-axes from its surfaces. The prober assigns surfaces to a claim; it does not choose axes.
-
-- **Generated axes** come from `tools/probe/enumerate.cs`, which enumerates by reflection every
-  public settable property of `JsonSerializerOptions` (`json.*`), `OpenApiOptions` (`openapi.*`) and
-  `MvcOptions` (`mvc.*`) at the versions this repository pins. `prober replay` runs it
-  outside the repository (so neither `global.json` nor central package management applies to it), with
-  its package versions taken from `Directory.Packages.props`, whenever a dependency input changes, and
-  `--all` always does. A setting whose type is not a bool or an enum takes its values from `hand` below.
-- Every generated axis is either reached by a surface's pattern or listed under `ignored` with the
-  reason. The script reports any other as **unassigned**: a setting a new framework version added,
-  which needs a decision here.
-- `shape.*` is the type-shape catalogue: the forms a consumer's own type takes. Generate the
-  declarations a round needs with an app of `tools/probe/generators/` (extend one, or add one and its row
-  in `GeneratedHarnessTests`), once per round, as one pairwise set shared by every claim.
-- A claim may drop a surface axis only by quoting the document sentence that limits it (`narrow`).
-- A claim may drop pairs no row can hold, or that the documents do not promise, only with the reason
-  (`exclude`: a list of `{"reason": "...", "pairs": [["a=1", "b=2"], ...]}`): one sentence, citing the docs
-  sentence, the record or the KB fact where one applies. Nothing checks a reason mechanically, so
-  `prober universe` prints each one beside the claim's narrowings for a reviewer, and the prober refuses a
-  claims.json with any field its schema (`tools/Prober/Schemas/claims.schema.json`) does not have
-  ([decision 102](../design/adr/0102-an-exclusion-carries-its-reason.md)).
-- An obligation may say where it does not apply, by the claim's own axis values and a citation
-  (`inapplicable`: a list of `{"axes": {"shape.kind": ["closed-set"]}, "cite": "not-promised:closed-set-has-no-scale"}`,
-  the cite `not-promised:id`, `docs:file#anchor`, `fact:KB-NNN` or `record:NNNN`). `Row.Check` reads the same
-  declarations and records such a check inapplicable before its body runs; a pair no obligation wants is never
-  put in a generated row, and the gate leaves it out as it leaves out an exclusion. A condition only the shape
-  instance decides at run time stays in the check's body as `c.Inapplicable(cite)`.
-- `refused` drops a value the framework itself refuses on its own, so no row wastes its pairs on it. A reason that
-  rests on a verified fact names it (`fact:KB-NNN`), and that fact has a test: `docs-query check` fails
-  `fact-not-executable-cited` for a refused entry, a not-promised entry, an applicability condition or a harness
-  citation of a fact without one ([decision 107](../design/adr/0107-a-cited-fact-is-executable-and-seeds-run-by-footprint.md)).
-  `shape.refused-kind` holds the declarations the generators refuse; only the generation surface takes
-  it, where the refusal is the claim. Each value is a declaration and the id the Generators README's
-  "Build errors" table gives it, declared as C22's probe does (`harness/BuildRefusals.cs`): an unsealed
-  record class; a value object over another value object; over `List<T>`; an abstract record or class with
-  a marker (CMTK1022 since `1ef30be`: the label keeps the id it had when C09's and C11's rows were
-  generated, which carry it); over `object`; over `System.Enum`; a value object named as a member the
-  generators add (`From`, `Parse`, `MinValue`, ...); a closed set named as one of its generated members
-  (`Name`, `All`, `Match`, ...); a value object with a hand-written `operator ==` and `!=` between two of
-  the type. The last five are the refusals of the fixes `53188ed` and `e4b751c`, which no probe reached
-  until C22 (design/finder-benchmark-2026-10-16.md).
-- A claim lists what it promises in `obligations`, one entry per promise a probe can check on its own: an
-  `id`, the `sentence` quoted verbatim from the claim's source and checked as a narrowing is, and the `axes`
-  values it concerns where it is not the whole claim. A claim without the field has one obligation, the
-  claim itself, under the id `claim`. Each obligation of a claim with probes has a seed that names it
-  ([decision 104](../design/adr/0104-a-claim-states-its-obligations-and-each-has-a-seed.md)).
-- What a claim does not promise goes in `not-promised`: an `id`, the `source` (`file#heading`) of the
-  document or record that makes the difference intended, its `sentence`, quoted verbatim and checked against
-  that source, and the `axes` values it concerns. A note of outcome expected-refusal, a narrowing or an
-  applicability condition cites the entry by its id. `prober universe` refuses an obligation or an entry
-  whose sentence its document does not hold, and an id listed twice, naming the claim and the id.
-- `out-of-reach` names a surface no probe reaches, with the reason: one that needs a server, a toolchain
-  or minutes a replay does not have. `prober gaps` prints it beside the settings no surface reaches, the
-  settings without values, the refused shapes and values, and every not-promised entry and narrowing, each
-  with its recorded reason. It is a report for the release checklist and a feature-research round; it
-  decides nothing and runs no model.
-- `http.host` has two values without `[ApiController]`, where MVC infers no `[FromBody]` and answers no
-  automatic 400. `controller-without-ApiController` is for **runtime claims only**: ASP.NET's API explorer
-  leaves such a controller out of the document (docs/aspnet-core.md, "Bind value objects in MVC"), so a
-  document check has nothing there to read. A document (OpenAPI) claim lists `http.host` in its own
-  `axes` in `claims.json` without it. `controller-without-ApiController-visible` hosts the same
-  controllers made visible by an `IApplicationModelConvention` that sets `ApiExplorer.IsVisible = true`
-  (`VisibleToApiExplorer` in the harness), so document checks reach them; every http claim takes it.
-- `process.*` holds what other code in the same process may have done first (2026-10-15: a wrapped
-  type's `TypeConverter` looked up before the value object's parsing broke that parsing).
-
-```json probe-axes
-{
-  "hand": {
-    "json.PropertyNamingPolicy": [
-      "CamelCase",
-      "SnakeCaseLower",
-      "SnakeCaseUpper",
-      "KebabCaseLower",
-      "KebabCaseUpper",
-      "own-upper-case"
-    ],
-    "json.DictionaryKeyPolicy": [
-      "CamelCase",
-      "SnakeCaseLower",
-      "KebabCaseUpper",
-      "own-upper-case"
-    ],
-    "json.ReferenceHandler": [
-      "Preserve",
-      "IgnoreCycles"
-    ],
-    "json.Converters": [
-      "own-for-wrapped",
-      "own-for-value-object",
-      "JsonStringEnumConverter",
-      "StoredJsonConverterFactory"
-    ],
-    "json.TypeInfoResolver": [
-      "source-generated-context",
-      "default-with-renaming-modifier"
-    ],
-    "json.TypeInfoResolverChain": [
-      "context-then-default"
-    ],
-    "json.Encoder": [
-      "UnsafeRelaxedJsonEscaping"
-    ],
-    "json.MaxDepth": [
-      "3"
-    ],
-    "json.DefaultBufferSize": [
-      "1"
-    ],
-    "json.IndentCharacter": [
-      "tab"
-    ],
-    "json.IndentSize": [
-      "1"
-    ],
-    "json.NewLine": [
-      "lf"
-    ],
-    "openapi.CreateSchemaReferenceId": [
-      "own-prefixing",
-      "null-inlines-all"
-    ],
-    "openapi.ShouldInclude": [
-      "default-only"
-    ],
-    "openapi.transformers": [
-      "own-schema-transformer",
-      "own-operation-transformer",
-      "own-document-transformer"
-    ],
-    "mvc.InputFormatters": [
-      "xml-added"
-    ],
-    "mvc.OutputFormatters": [
-      "xml-added"
-    ],
-    "mvc.ModelBinderProviders": [
-      "own-provider-first"
-    ],
-    "mvc.Conventions": [
-      "own-route-prefix"
-    ],
-    "mvc.MaxModelBindingCollectionSize": [
-      "2"
-    ],
-    "mvc.MaxModelValidationErrors": [
-      "1"
-    ],
-    "mvc.MaxValidationDepth": [
-      "1"
-    ]
-  },
-  "ignored": {
-    "json.WriteIndented": "layout only; JSON parity compares under the same options",
-    "json.IndentCharacter": "layout only",
-    "json.IndentSize": "layout only",
-    "json.NewLine": "layout only",
-    "json.DefaultBufferSize": "buffering only; DefaultBufferSize 1 is kept in hand for a stress round on request",
-    "openapi.ShouldInclude": "selects endpoints, never a schema's shape",
-    "mvc.EnableActionInvokers": "invocation pipeline, not binding or formatting",
-    "mvc.EnableEndpointRouting": "TypeKit supports endpoint routing only",
-    "mvc.RequireHttpsPermanent": "transport",
-    "mvc.SslPort": "transport",
-    "mvc.CacheProfiles": "caching headers",
-    "mvc.SuppressAsyncSuffixInActionNames": "action naming",
-    "mvc.SuppressInputFormatterBuffering": "buffering",
-    "mvc.SuppressOutputFormatterBuffering": "buffering",
-    "mvc.MaxIAsyncEnumerableBufferLimit": "streaming",
-    "mvc.MaxModelBindingRecursionDepth": "recursion limit of binding, reached only by self-referencing models",
-    "mvc.ModelMetadataDetailsProviders": "covered by own-provider-first on binders",
-    "mvc.ModelValidatorProviders": "validation providers; TypeKit validates in Create",
-    "mvc.ValueProviderFactories": "value sources; the binding axis covers them"
-  },
-  "axes": {
-    "shape.kind": [
-      "record-struct",
-      "sealed-record-class",
-      "validated-struct",
-      "validated-class",
-      "closed-set"
-    ],
-    "shape.site": [
-      "top-level",
-      "nested-in-class",
-      "nested-in-struct",
-      "nested-two-levels",
-      "in-generic-type"
-    ],
-    "shape.inheritance": [
-      "none",
-      "base-depth-1",
-      "base-depth-2",
-      "base-depth-3",
-      "base-explicit-IEquatable",
-      "explicit-interface-member"
-    ],
-    "shape.wrapped": [
-      "string",
-      "Guid",
-      "int",
-      "long",
-      "byte",
-      "ulong",
-      "decimal",
-      "double",
-      "bool",
-      "char",
-      "DateTime",
-      "DateTimeOffset",
-      "DateOnly",
-      "TimeOnly",
-      "TimeSpan",
-      "enum",
-      "flags-enum",
-      "Uri",
-      "NodaTime.Instant",
-      "own-record-class"
-    ],
-    "shape.position": [
-      "root",
-      "property",
-      "nullable-property",
-      "field",
-      "list-element",
-      "array-element",
-      "immutable-array-element",
-      "read-only-list-element",
-      "dictionary-key",
-      "dictionary-value",
-      "record-ctor-parameter",
-      "required-init",
-      "in-patch",
-      "polymorphic-derived-property"
-    ],
-    "shape.containing": [
-      "class",
-      "record-class",
-      "struct",
-      "record-struct",
-      "generic-type"
-    ],
-    "input.json": [
-      "valid",
-      "refused-by-create",
-      "wrong-token",
-      "null",
-      "empty-string",
-      "at-type-limit",
-      "quoted-number",
-      "escape-sequence",
-      "duplicate-property",
-      "metadata-property"
-    ],
-    "http.host": [
-      "minimal",
-      "mvc",
-      "both",
-      "route-group",
-      "controller-without-ApiController",
-      "controller-without-ApiController-visible"
-    ],
-    "http.binding": [
-      "route",
-      "query",
-      "header",
-      "body",
-      "form",
-      "as-parameters"
-    ],
-    "http.response": [
-      "result-to-http-result",
-      "composed-fault",
-      "two-faults-same-name",
-      "group-with-fault-status",
-      "endpoint-without-faults",
-      "declared-produces-problem"
-    ],
-    "ef.query": [
-      "where-equals",
-      "where-value-compare",
-      "order-by",
-      "contains",
-      "first-or-none",
-      "select",
-      "group-by",
-      "execute-update",
-      "compiled-query",
-      "as-no-tracking"
-    ],
-    "ef.mapping": [
-      "property",
-      "key",
-      "integer-key",
-      "nullable",
-      "owned",
-      "complex",
-      "closed-set"
-    ],
-    "text.entry": [
-      "Parse",
-      "TryParse",
-      "TryFrom",
-      "type-converter",
-      "IParsable",
-      "ISpanParsable",
-      "ToString-format",
-      "TryFormat-short-span"
-    ],
-    "text.culture": [
-      "invariant",
-      "de-DE",
-      "tr-TR",
-      "ar-SA",
-      "globalization-invariant"
-    ],
-    "or.shape": [
-      "Option",
-      "Result-T-E",
-      "Result-E",
-      "Task-of-Result",
-      "ValueTask-of-Result"
-    ],
-    "or.operation": [
-      "Match",
-      "Bind-Map-chain",
-      "query-syntax",
-      "Sequence-Transpose",
-      "Result.Catch",
-      "FirstOrNone",
-      "default-instance",
-      "after-await-elsewhere"
-    ],
-    "shape.refused-kind": [
-      "unsealed-record-class (CMTK1006)",
-      "over-value-object (CMTK1005)",
-      "generic-wrapped (CMTK1005)",
-      "abstract (CMTK1005)",
-      "over-object (CMTK1005)",
-      "over-System.Enum (CMTK1005)",
-      "named-as-generated-member (CMTK1005)",
-      "closed-set-named-as-generated-member (CMTK1021)",
-      "equality-operator (CMTK1011)"
-    ],
-    "process.converter-lookup": [
-      "none",
-      "wrapped-type-converter-looked-up-first"
-    ],
-    "http.nullability": [
-      "as-declared",
-      "nullable"
-    ]
-  },
-  "surfaces": {
-    "json": {
-      "axes": [
-        "json.*",
-        "shape.kind",
-        "shape.wrapped",
-        "shape.position",
-        "shape.containing",
-        "input.json"
-      ],
-      "watched": [
-        "src/CodoMetis.TypeKit.Generators",
-        "src/CodoMetis.TypeKit/ValueObjects",
-        "src/CodoMetis.TypeKit/DecimalJsonConverters.cs",
-        "src/CodoMetis.TypeKit/Patch.cs"
-      ]
-    },
-    "http": {
-      "axes": [
-        "json.*",
-        "openapi.*",
-        "mvc.*",
-        "http.*",
-        "process.*",
-        "shape.kind",
-        "shape.wrapped",
-        "shape.position",
-        "shape.containing",
-        "input.json"
-      ],
-      "watched": [
-        "src/CodoMetis.TypeKit.AspNetCore",
-        "src/CodoMetis.TypeKit/Fault.cs",
-        "src/CodoMetis.TypeKit/FaultOfSets.cs",
-        "src/CodoMetis.TypeKit.Generators"
-      ]
-    },
-    "ef": {
-      "axes": [
-        "ef.*",
-        "shape.kind",
-        "shape.wrapped",
-        "shape.site"
-      ],
-      "watched": [
-        "src/CodoMetis.TypeKit.EntityFrameworkCore",
-        "src/CodoMetis.TypeKit.Generators"
-      ]
-    },
-    "text": {
-      "axes": [
-        "text.*",
-        "process.*",
-        "shape.kind",
-        "shape.wrapped"
-      ],
-      "watched": [
-        "src/CodoMetis.TypeKit/StringTextExtensions.cs",
-        "src/CodoMetis.TypeKit/TextFault.cs",
-        "src/CodoMetis.TypeKit.Generators"
-      ]
-    },
-    "generation": {
-      "axes": [
-        "shape.*"
-      ],
-      "watched": [
-        "src/CodoMetis.TypeKit.Generators",
-        "src/CodoMetis.TypeKit/ValueObjects"
-      ]
-    },
-    "option-result": {
-      "axes": [
-        "or.*",
-        "shape.wrapped"
-      ],
-      "watched": [
-        "src/CodoMetis.TypeKit/Option.cs",
-        "src/CodoMetis.TypeKit/OptionExtensions.cs",
-        "src/CodoMetis.TypeKit/Result.cs",
-        "src/CodoMetis.TypeKit/ResultT.cs",
-        "src/CodoMetis.TypeKit/ResultExtensions.cs",
-        "src/CodoMetis.TypeKit/SequenceOptionExtensions.cs",
-        "src/CodoMetis.TypeKit/ValueTypeOptionExtensions.cs"
-      ]
-    },
-    "analyzers": {
-      "axes": [
-        "shape.*"
-      ],
-      "watched": [
-        "src/CodoMetis.TypeKit.Analyzers",
-        "src/CodoMetis.TypeKit/TypeArgumentConstraints.cs"
-      ]
-    },
-    "logging": {
-      "axes": [
-        "shape.kind",
-        "shape.wrapped",
-        "input.json"
-      ],
-      "watched": [
-        "src/CodoMetis.TypeKit.Serilog",
-        "src/CodoMetis.TypeKit/Refusals.cs"
-      ]
-    }
-  },
-  "out-of-reach": {
-    "postgresql": "needs a server; the EF probes run SQLite in memory, and the EF translation claims are checked by translation alone",
-    "native-aot": "measured only by the consumer smoke test (tools/ConsumerSmokeTest), minutes and a platform linker; no probe publishes with Native AOT"
-  },
-  "refused": {
-    "shape.site": {
-      "in-generic-type": "CMTK1005: the generators refuse a value object nested in a generic type at build (Generators README, Build errors)"
-    },
-    "json.ReadCommentHandling": {
-      "Allow": "System.Text.Json refuses it on the options object"
-    },
-    "json.DefaultIgnoreCondition": {
-      "Always": "System.Text.Json refuses it on the options object"
-    }
-  },
-  "replay": {
-    "project": "test/CodoMetis.TypeKit.Samples",
-    "probeDir": "test/CodoMetis.TypeKit.Samples/Probes",
-    "prepare": [
-      [
-        "dotnet",
-        "build",
-        "tools/BuildVerdict",
-        "-c",
-        "Release",
-        "-nologo",
-        "-v:q"
-      ]
-    ],
-    "build": [
-      "dotnet",
-      "tools/BuildVerdict/bin/Release/net10.0/build-verdict.dll",
-      "build",
-      "{project}"
-    ],
-    "test": [
-      "dotnet",
-      "tools/BuildVerdict/bin/Release/net10.0/build-verdict.dll",
-      "test",
-      "--no-build",
-      "--project",
-      "{project}",
-      "--filter-class",
-      "{filter}",
-      "--",
-      "--results-directory",
-      "{results}"
-    ],
-    "coverage": [
-      "--coverage",
-      "--coverage-output-format",
-      "cobertura",
-      "--coverage-output",
-      "{cobertura}"
-    ],
-    "families": {
-      "http": [
-        "http"
-      ],
-      "ef": [
-        "ef"
-      ],
-      "json": [
-        "json"
-      ],
-      "text": [
-        "text",
-        "logging"
-      ],
-      "build": [
-        "generation",
-        "analyzers",
-        "option-result"
-      ]
-    },
-    "include": [
-      "src"
-    ],
-    "compileTimeFootprint": [
-      "src/CodoMetis.TypeKit.Generators",
-      "Directory.Packages.props",
-      "Directory.Build.props",
-      "global.json",
-      "test/CodoMetis.TypeKit.Samples/CodoMetis.TypeKit.Samples.csproj"
-    ],
-    "coverageTargets": "<Project>\n  <ItemGroup Condition=\"'$(MSBuildProjectName)' == 'CodoMetis.TypeKit.Samples'\">\n    <PackageReference Include=\"Microsoft.Testing.Extensions.CodeCoverage\" VersionOverride=\"18.12.0\" />\n  </ItemGroup>\n</Project>\n",
-    "toolchain": {
-      "dotnet": [
-        "dotnet",
-        "--version"
-      ]
-    },
-    "enumerate": {
-      "script": "tools/probe/enumerate.cs",
-      "inputs": [
-        "Directory.Packages.props",
-        "global.json"
-      ]
-    }
-  }
-}
-```
-
-
-## Oracles this repository promises
-
-- **JSON parity (differential).** A shape with a value object and the same shape with the wrapped
-  type, serialized under the same options, give the same bytes, and each reads the other's JSON.
-  `test/CodoMetis.TypeKit.Generators.Tests/JsonParityTests.cs` shows the pattern.
-- **Schema parity (differential).** The OpenAPI schema of a value-object property equals the one
-  ASP.NET Core publishes for the wrapped type in the same position, in every document version.
-- **Wire and document agree (differential).** The statuses and problem types a fault response sends
-  are the ones the document lists for that operation, in both hosting models.
-- **Column parity (differential).** The EF model gives a value-object property the wrapped type's
-  column type, and a query over `.Value` translates to the same SQL as the query over the wrapped
-  property.
-- **One set of rules (differential).** `TryFrom`, `Parse`, `TryParse`, the JSON converter, the type
-  converter and `FromKnownGood` accept exactly what `Create` accepts, and every refusal names the
-  fault `Create` returned.
-- **No refusal quotes the input (exception).** Put a sentinel such as `SECRET-7f3a` in refused input;
-  it must not appear in any exception message, inner exception, `ToString()`, ProblemDetails body or
-  log line. The one exception is a dictionary key in `JsonException.Path`.
-- **Off the wire (exception).** `Option` and `Result` throw `NotSupportedException` from
-  System.Text.Json in both directions, in every position, unless the application registered its
-  own converter.
-- **Equality (metamorphic).** Equal value objects have equal hash codes, `CompareTo` is zero exactly
-  when `Equals` is true, and both agree with the wrapped type's, through every base in the
-  inheritance chain.
-- **Round trip (metamorphic).** `Parse(x.ToString())`, a JSON write then read, and a column write
-  then read give back an equal value object.
-- **Loud, not silent (exception).** A declaration that cannot be generated fails the build with a
-  CMTK id; it never compiles into a type with nothing in it.
-
-## Intended: a refusal or difference here is a pass
-
-- A `DateTime` is written as UTC; number handling set by an attribute on the containing type reaches
-  no converter (README, "What TypeKit guarantees").
-- A struct value object refuses a JSON `null`.
-- A rejected dictionary key appears in `JsonException.Path`, and so in MVC's 400.
-- Under a source-generated context, a value object over an enum needs the enum listed in the context.
-- A validated value object has no `From`; an abstract value object fails with CMTK1022, and a generic
-  wrapped type with CMTK1005.
-- A missing `Option` property, and an empty collection or dictionary of `Option` or `Result`, pass
-  through System.Text.Json without an exception, since no converter runs (a wording question for the
-  README, raised 2026-10-15, not a finding).
-- The EF Core package and `StoredJsonConverterFactory` skip validation by design.
-- A host whose MVC and minimal-API JSON options describe a type differently has its document refused
-  (`DescribedOptionsAgreement`).
-- System.Text.Json refusing a combination of its own options with an exception of its own (for
-  example `IgnoreNullValues` together with a `DefaultIgnoreCondition`).
-- Anything a record in `design/adr/` decides. Search the records before calling a refusal a finding.
-- Findings already reported by `code-analyst` are in
-  `.claude/agent-memory-local/code-analyst/review-2-1-0-findings.md`. Do not report them again.
-
-## Budget
-
-Twelve claims a round unless the caller says otherwise. One build of the Samples project serves them
-all; group the round's probes there.
diff --git a/.claude/settings.json b/.claude/settings.json
index 5429aeeb..4c835160 100644
--- a/.claude/settings.json
+++ b/.claude/settings.json
@@ -11,7 +11,7 @@
           },
           {
             "type": "command",
-            "command": "dotnet build tools/AgentTools.slnf -c Release -nologo -v q -tl:off -clp:NoSummary >/dev/null 2>&1 || PATH=\"/usr/local/share/dotnet:$PATH\" dotnet build tools/AgentTools.slnf -c Release -nologo -v q -tl:off -clp:NoSummary || echo \"Session start: the tools in $PWD (build-verdict, prober, docs-query, consumer-smoke-test) did not build with the dotnet on PATH, nor with the installer's in /usr/local/share/dotnet; a dotnet without the SDK global.json pins is the usual cause. Run dotnet build tools/AgentTools.slnf -c Release to see why, and before using them.\"",
+            "command": "dotnet build tools/AgentTools.slnf -c Release -nologo -v q -tl:off -clp:NoSummary >/dev/null 2>&1 || PATH=\"/usr/local/share/dotnet:$PATH\" dotnet build tools/AgentTools.slnf -c Release -nologo -v q -tl:off -clp:NoSummary || echo \"Session start: the tools in $PWD (build-verdict, docs-query, consumer-smoke-test, pr-hygiene) did not build with the dotnet on PATH, nor with the installer's in /usr/local/share/dotnet; a dotnet without the SDK global.json pins is the usual cause. Run dotnet build tools/AgentTools.slnf -c Release to see why, and before using them.\"",
             "timeout": 300
           }
         ]
diff --git a/.claude/skills/probe-triage/SKILL.md b/.claude/skills/probe-triage/SKILL.md
deleted file mode 100644
index 1373245c..00000000
--- a/.claude/skills/probe-triage/SKILL.md
+++ /dev/null
@@ -1,261 +0,0 @@
----
-name: probe-triage
-description: Decide what one failing probe row means, by four questions in a fixed order — a harness error, a pinned framework fact, an intended difference the claim does not promise, or a finding for the code-analyst — stopping at the first that applies and recording the step where the corpus keeps it. Use for every failing row at the end of a probing round, for a `prober status` finding (`R-<probe>-<sha>`, `F<n>`), for a row a replay or `prober try` printed as failed, and whenever someone asks whether a probe failure is real.
----
-
-# Probe triage
-
-A failing row is a question, not a finding. Most of what the prober has cost went into answering it by
-judgement, mid-round: the gate round of 2026-10-16 wrote 18 probes, found two product defects and about
-ten harness traps, and left five failing rows of C07 untriaged. This skill answers the question by
-lookup, in a fixed order, so two people (or a person and an agent) reach the same answer for the same
-row, and the answer is written where the next replay and the next reader find it.
-
-**The order is the rule.** Ask the four questions in turn and stop at the first that applies. Do not skip
-ahead because a row "looks like" a product bug: a harness that compares unlike things produces the most
-convincing product bugs there are. Every outcome names its step, `triage 1` to `triage 4`.
-
-The writer of a probe never decides what a refusal means. The probe checks; this skill decides.
-
-## Before the steps: get the row, and make it fail again
-
-You start from one of these:
-
-- **A finding id** from `prober status`: `R-<probe>-<sha>` (the replay saw a probe that passed with the
-  same identity fail) or `F<n>`. Its last line in the branch's `findings.jsonl` names the probe and the
-  commit. The state directory, `$STATE` below, is `PROBE_STATE_DIR` when set, else the main checkout's
-  `.claude/agent-memory-local/prober/`; the branch's directory is `branches/<branch, / as ->/`.
-- **A row a run printed:** `prober try` and `prober replay` print the failed probe and how each row ended.
-  A replay that says "fails after a change to its corpus, axes, environment or this tool; triage the probe,
-  not the product" opened no finding: start at step 1 and expect to stop there.
-- **A row's evidence line:** the line `Rec.Run` writes, or the probe's evidence after a replay:
-
-  ```bash
-  jq '.rows["358"] | {category, reasons, applied}' "$STATE/branches/release-2.2.0/evidence/BaseProbe.json"
-  ```
-
-From it, write down: the claim, the probe, the row's index, its category (`violation`, `harness-error`,
-`inconclusive`), its reasons, and the settings that applied. Then run the row at HEAD, three times:
-
-```bash
-dotnet tools/Prober/bin/Release/net10.0/prober.dll try --probe BaseProbe --rows 358
-dotnet tools/Prober/bin/Release/net10.0/prober.dll try --probe BaseProbe --rows 358 --no-build   # twice more
-```
-
-A row that passes at HEAD was fixed meanwhile: say so with the commit, and stop. A row that does not
-fail every time is flaky, and flaky is not a finding: record it as `flaky` (a round's ledger line, or
-your report) and stop. Only a
-row that fails every time goes on to step 1.
-
-## 1. Is it a harness error?
-
-**It applies when** the row's reasons carry `harness-error`, or the failure comes from the harness rather
-than from the product:
-
-- the category is `harness-error`: a check threw (`UNEXPECTED <Exception>: ...`, which decision 103 makes
-  a harness error and never a violation), a check `prober new` staged and nobody wrote, or the equivalence
-  precondition (`inputs not equivalent: wrapped [...] vs value object [...]`), which says the two sides
-  were not the same shape and so were never comparable;
-- a 404 on a bind route, a context type the source-generated `ProbeContext` does not list, a host that did
-  not start for a reason the row's settings do not explain;
-- a `violation` whose whole difference lies in something the harness built or named rather than something
-  TypeKit wrote: a component or route name made from the twin's own type name, a twin at another
-  nullability, kind or position than the value object (concept H2), an input the harness placed
-  differently on each side. Read the two sides' answers in the reasons, or in the full log of the `try`
-  run, and find the first byte that differs. If it is the harness's, this step applies.
-
-**Then** fix the harness so the row compares like with like, and run the row again. No finding is filed.
-A row that now fails with a different difference starts again at step 1.
-
-**Record:**
-
-- the harness fix, as a `test:` commit whose body names the row and says `triage 1`: what the harness
-  did and what it does now (94554b3 is the model). In a round, the fix goes to the staging's `harness/`
-  and the round's report says it; the session that publishes commits it;
-- with a finding id, a line appended to the branch's `findings.jsonl`:
-
-  ```json
-  {"schemaVersion":1,"id":"R-BaseProbe-1a2b3c4","status":"withdrawn","reason":"triage 1 harness-error: the /schema/ endpoint had no twin at the value object's nullability; fixed in 94554b3"}
-  ```
-
-## 2. Does a fact at the pinned version explain it?
-
-**It applies when** a fact in `design/knowledge/` says the framework, without TypeKit, does what the row
-saw: the same refusal at the same operation, or the same document, at the version the repository pins.
-A fact about the framework explains a row only where the framework alone makes the difference. A fact
-that describes how the framework treats the wrapped type, while the value object differs from it, does
-not explain the row; it is the evidence of step 4.
-
-**Check with** the framework, the setting and the operation the row names:
-
-```bash
-dotnet tools/DocsQuery/bin/Release/net10.0/docs-query.dll find controller API explorer document visible --kind fact
-dotnet tools/DocsQuery/bin/Release/net10.0/docs-query.dll entry KB-002
-dotnet tools/DocsQuery/bin/Release/net10.0/docs-query.dll check      # no fact-behind or fact-ahead for it
-```
-
-A miss of `find` proves nothing: try the setting's own name and the exception type too. Read the fact's
-frontmatter. It is **executable** when its `test:` line names a test under `test/CodoMetis.TypeKit.Facts`
-(`test: test/CodoMetis.TypeKit.Facts/KB002.cs`). Run that test:
-
-```bash
-dotnet tools/BuildVerdict/bin/Release/net10.0/build-verdict.dll test --project test/CodoMetis.TypeKit.Facts --filter-class "*KB002"
-```
-
-**Then:**
-
-- **An executable fact that passes and explains the row** makes it a framework refusal. The check is
-  changed to cite the fact, no finding is filed.
-- **A fact whose pin is stale**, or whose test fails, settles nothing until it is verified again
-  (decision 93). Verify it first.
-- **A fact without a test** (`test: none, ...` or `prose`) that would explain the row is a research task:
-  measure the behaviour in `test/CodoMetis.TypeKit.Facts` as `KB<NNN>.cs`, give the fact its `test:`
-  line, then cite it. A fact without a test may be cited in a reason and nothing more: it never prunes a
-  row and never excuses one.
-- **No fact, but the row's own baseline shows the framework alone doing it** (the document
-  `Hx.DocRefusedByAspNetAlone` refuses for ASP.NET alone too, or the wrapped type alone refuses under the
-  same options): that is a new framework behaviour. It becomes a new fact with its test under
-  `design/knowledge/` (its README, "Adding one"), never a new note key. Then cite it.
-- Otherwise go to step 3.
-
-**Record:**
-
-- the citation, where the corpus holds one: a `not-promised` entry of the claim whose `source` is the
-  fact's file and whose `sentence` is quoted from it (step 3's form), an `exclude` group whose `reason`
-  names `KB-NNN`, or a value in the axes file's `refused` object whose text names `KB-NNN`, or the check's
-  own `Cite.Fact("KB-NNN")`;
-- with a finding id:
-
-  ```bash
-  dotnet tools/Prober/bin/Release/net10.0/prober.dll dismiss --id R-C03ComposedProbe-1a2b3c4 --reason "triage 2 fact KB-002: a controller without [ApiController] is missing from the document for ASP.NET alone, so the row's document part has nothing to check"
-  ```
-
-  `dismiss` stages the line; `prober publish` puts it in `tools/probe/corpus/dismissed.jsonl`;
-- in a round, a fact to measure goes in the report under "Facts to measure", with the row and the
-  configuration. The agent writes no test; the session that takes the report does.
-
-## 3. Does the claim say it does not promise this?
-
-**It applies when** a `not-promised` entry of the row's claim covers the row's settings, or a sentence of
-the docs or of a decision record says the difference is intended.
-
-**Check with** the claim's entries and narrowings, and the docs:
-
-```bash
-dotnet tools/Prober/bin/Release/net10.0/prober.dll gaps | grep 'C07-fault-responses-blanket'
-jq '.[] | select(.id == "C07-fault-responses-blanket") | {narrow, "not-promised"}' tools/probe/corpus/claims.json
-dotnet tools/DocsQuery/bin/Release/net10.0/docs-query.dll find nullable value object schema null --top 5
-```
-
-An entry covers the row when each of its `axes` values is among the row's applied settings. A docs
-sentence counts only when it says this difference, in this place, is intended. Your sense that it "must be
-on purpose" does not count, and neither does the axes file's "Intended" list alone: an item there that no
-document or record states is a gap of this step, not an answer.
-
-**Then:**
-
-- **An entry covers it:** the difference is intended. The row's check cites the entry by its id, no
-  finding is filed.
-- **A document or record says so, but the claim has no entry:** that is a docs or claims gap, filed as
-  `docs:` work, no finding. Add the entry; if the consumer docs do not say it plainly, add the sentence
-  first (the `plain-docs` skill), then quote it.
-- **Two documents disagree,** or a record calls intended what a consumer page promises: not this step's
-  to settle. It goes to the code-analyst as a question (step 4's hand-off, "a contradiction").
-- Otherwise go to step 4.
-
-**Record:**
-
-- the entry, in `claims.json` (in a round, the staging's `claims.json`), in the form of
-  `tools/Prober/Schemas/claims.schema.json`. `universe` refuses a sentence its `source` does not hold:
-
-  ```json
-  "not-promised": [
-    {
-      "id": "invariant-globalization-refuses-as-text",
-      "source": "docs/text.md#globalization-invariant-mode",
-      "sentence": "So `AsText()` throws `PlatformNotSupportedException` there, on its first call, whatever the string.",
-      "axes": { "text.culture": ["globalization-invariant"], "entry": ["AsText", "AsOptionalText"] }
-    }
-  ]
-  ```
-
-  committed as `docs:` with the sentence it quotes, beside any docs change;
-- with a finding id:
-
-  ```bash
-  dotnet tools/Prober/bin/Release/net10.0/prober.dll dismiss --id R-C02OptionalTextProbe-1a2b3c4 --reason "triage 3 not-promised C02-optional-text/invariant-globalization-refuses-as-text"
-  ```
-
-  and for a gap, `--reason "triage 3 docs-gap: <the sentence or record>; entry <id> to add"`.
-
-## 4. A finding: hand it to the code-analyst
-
-Only a row that none of steps 1 to 3 explains gets here. It is still not a finding until the
-`code-analyst` agent, which reads the product path and seeds the defect in a scratch copy, confirms it.
-
-**Prepare the hand-off:**
-
-- **The row**: claim, probe, index, commit, category, the reasons, the settings that applied.
-- **The shrunk row**, from the harness's `Shrinker`. There is no prober command for it yet. Run it in the
-  replay's worktree, which the `try` above has just built with the corpus overlaid:
-
-  ```bash
-  WT=$(dotnet tools/Prober/bin/Release/net10.0/prober.dll replay --where | awk '/^replay:/ {print $2}')
-  cd "$WT" && PROBE_SHRINK="C07-fault-responses-blanket:358:baseline" \
-    dotnet "$OLDPWD/tools/BuildVerdict/bin/Release/net10.0/build-verdict.dll" test --no-build \
-      --project test/CodoMetis.TypeKit.Samples --filter-class "Probes.ShrinkProbe"
-  cat /tmp/shrink.txt
-  ```
-
-  `PROBE_SHRINK` is `<rows>:<index,...>:<check>`: the rows file the probe reads (`Rows.Data("...")` in the
-  probe), the rows, and the check, `baseline` for the HTTP calibration or a name registered in
-  `ShrinkChecks.All` (C03, C05, L02, L03, L04). A check with no name there is handed over unshrunk, and
-  the hand-off says so.
-- **The obligation** the failing check serves: its id and sentence from the claim's `obligations` (the
-  probe's header quotes them). When the check serves none of the claim's obligations, say so: "none
-  listed; the check holds <document#heading>: <sentence>". That is itself something for the analyst to
-  report (below).
-- **Each side's answer**: the wrapped twin's with TypeKit, the value object's with TypeKit, and the
-  framework alone where the row ran it, each as the reasons or the log give it.
-- **Why steps 1 to 3 did not apply**, one line each, with the facts and entries you looked at.
-
-**Hand it over** with the Agent tool, `subagent_type: code-analyst`, and a prompt that starts
-`Target: triage hand-off` and carries the five items above. The analyst reads the path the row exercised,
-reproduces it outside the probe, seeds the defect, and answers Confirmed, Likely or Question. Where you
-cannot start an agent (the `prober` agent started as a subagent), put the hand-off in your report under
-"For code-analyst", marked "awaiting confirmation", file nothing, and let the caller hand it over.
-
-**Then:**
-
-- **Confirmed:** file `F<n>`, the next number not used in the branch's `findings.jsonl` or the corpus's
-  `dismissed.jsonl`. The fix is a `fix:` commit with the regression test the analyst named (the
-  `verify-the-guard` skill: revert it, then the variants), ending with `Defect-Class:` and
-  `Found-By: PR`, and its body names the analyst's confirmation. 6866822 is the model.
-- **Likely or Question:** no `F<n>`. The row stays failing, and the question goes to the maintainer in
-  the round's report under "For code-analyst", with the analyst's answer.
-- **A missing obligation** the analyst reports (a check that holds a promise no claim lists): it is filed
-  as claims work, the obligation added to the claim whose source states it, or a new claim, with its seed
-  (decision 104).
-
-**Record**, only after the analyst confirms, a line appended to the branch's `findings.jsonl`, with the
-shrunk probe kept in the memory's `open/`:
-
-```json
-{"schemaVersion":1,"id":"F3","claim":"C07-fault-responses-blanket","status":"open","commit":"00d3b8f6...","probe":"open/F3NullableBodySchemaProbe.cs","reason":"triage 4 finding: an MVC [FromBody] VO? over ulong writes oneOf[null, {type:[integer,string]}] where ulong? writes [null,integer,string]; confirmed by code-analyst 2026-10-16"}
-```
-
-An `R-` finding that became `F<n>` gets a `withdrawn` line whose reason is `triage 4 finding: filed as F<n>`,
-so one defect is open once.
-
-## What each step leaves behind
-
-| Step | Finding | Change | Commit |
-|---|---|---|---|
-| 1 harness error | `withdrawn`, `triage 1 harness-error: ...` | the harness | `test:` |
-| 2 fact | `prober dismiss`, `triage 2 fact KB-NNN: ...` | the check cites the fact; a new fact gets its test first | `test:` for the citation, `docs:` or `test:` for the fact |
-| 3 not promised | `prober dismiss`, `triage 3 not-promised <claim>/<entry>` or `triage 3 docs-gap: ...` | the `not-promised` entry, the docs sentence | `docs:` |
-| 4 finding | `F<n>` open, `triage 4 finding: ...; confirmed by code-analyst` | the fix and its test | `fix:` with `Found-By: PR` |
-
-A row without a finding id leaves the change and the commit alone. Every reason starts with
-`triage <step>`, so `grep '"triage [123]' findings.jsonl dismissed.jsonl` counts what the rounds cost
-and what they found.
diff --git a/.claude/skills/verify-the-guard/SKILL.md b/.claude/skills/verify-the-guard/SKILL.md
index 1db2c705..b83c563d 100644
--- a/.claude/skills/verify-the-guard/SKILL.md
+++ b/.claude/skills/verify-the-guard/SKILL.md
@@ -51,8 +51,8 @@ before it is reported done:
    | `AIS`, what a type argument is | `TypeArgumentKinds`, beside it, 79 kinds and 37 pairs: classes to delegates, arrays, `dynamic`, interfaces, the abstract bases, a type built from a parameter, a parameter under each constraint and attribute, and pairs | An oracle per constraint over what each kind is, from the rule's docs, run as `TypeArgumentConstraintKindTests` runs CMTK0010 |
    | `AIS`, any other input | The kinds the rule registers (`Register*Action`), plus method groups, crefs, extension blocks (method, property, static member, operator, the lowered call), generic attributes, `nameof`, null-conditional access, lambdas, local functions and generated code (`GeneratedCodeTests`) | No catalogue yet: build it in `Variants/` on `TypeArgumentSites`' pattern, the subject from the rule and the shapes from the catalogue |
    | `EFT`, a key or a query of the EF satellite | `KeyShapes`, `QueryShapes` and `WrappedKinds` in `test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/Variants/`: 13 key shapes (alone, each mapping's root, abstract or not, the dependents whose key is a foreign key, composite, configured) by 13 wrapped types on three providers; 22 wrapped types, own orderings included, by accessor, site (column, nullable, collection element, captured list, navigation, JSON, query filter), converter (TypeKit's, named, three foreign forms) and operation | A differential against the same entity over the wrapped type, with the docs' departures as the oracle, run as `KeyGenerationVariantTests` and `QueryTranslationVariantTests` do; a new case is a new value of an axis |
-   | `GTS` | The `shape.*` axes of `.claude/probe-axes.md` and the Samples' value objects | One declaration per value of each axis the fixed code reads (kind, site, inheritance at least), or the rows of the claim that covers it: `prober rows --claim C --full` |
-   | `FCI` | The settings of the API the fix touches: the `json.*`, `openapi.*`, `mvc.*` axes | The claim's pairwise rows, `prober rows --claim C`, as a theory or as the claim's probe |
+   | `GTS` | The declaration shapes of `test/oracles/axes.md` and the Samples' value objects | One declaration per value of each axis the fixed code reads (kind, site, inheritance at least) |
+   | `FCI` | The settings of the API the fix touches: the JSON, OpenAPI and host axes of `test/oracles/axes.md` | A theory over every value of the axes the fix reads, or a probe class over their product (`test/oracles/axes.md`) |
 
    Run every shape both ways where the catalogue has two: the breaking input reported (or refused)
    once, the meeting one never. A false report is a sibling as much as a silence is.
diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json
index 4d3e20e4..94e23d85 100644
--- a/.config/dotnet-tools.json
+++ b/.config/dotnet-tools.json
@@ -8,6 +8,13 @@
         "dotnet-CycloneDX"
       ],
       "rollForward": false
+    },
+    "docfx": {
+      "version": "2.81.0",
+      "commands": [
+        "docfx"
+      ],
+      "rollForward": false
     }
   }
 }
diff --git a/.github/ISSUE_TEMPLATE/bug.yml b/.github/ISSUE_TEMPLATE/bug.yml
new file mode 100644
index 00000000..7c8e76a5
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug.yml
@@ -0,0 +1,69 @@
+name: Bug
+description: Something compiles but does less than it should, throws when it shouldn't, or doesn't refuse when it should.
+labels: [bug]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        The bugs that matter most here don't crash. A value object builds but was never generated, a
+        failed `Result` goes unnoticed, an analyzer stops reporting, a column reads back a value the
+        type would have refused. If that's what you found, please say so below. It decides how soon
+        the fix ships.
+  - type: dropdown
+    id: package
+    attributes:
+      label: Package
+      multiple: true
+      options:
+        - CodoMetis.TypeKit
+        - CodoMetis.TypeKit.Analyzers
+        - CodoMetis.TypeKit.Generators
+        - CodoMetis.TypeKit.EntityFrameworkCore
+        - CodoMetis.TypeKit.AspNetCore
+        - CodoMetis.TypeKit.Serilog
+        - CodoMetis.TypeKit.Testing
+    validations:
+      required: true
+  - type: input
+    id: version
+    attributes:
+      label: Version
+      placeholder: "2.2.0"
+    validations:
+      required: true
+  - type: dropdown
+    id: failure
+    attributes:
+      label: How does it fail?
+      options:
+        - Silently. It compiles or answers, and does less than it appears to
+        - Loudly. It throws, fails the build or reports a diagnostic where it should work
+        - I'm not sure
+    validations:
+      required: true
+  - type: textarea
+    id: repro
+    attributes:
+      label: What you ran
+      description: The smallest code that shows it. For EF Core, include the query and the SQL it translated to; for JSON or OpenAPI, the payload or the schema.
+      render: csharp
+    validations:
+      required: true
+  - type: textarea
+    id: actual
+    attributes:
+      label: What you got
+    validations:
+      required: true
+  - type: textarea
+    id: expected
+    attributes:
+      label: What you expected
+      description: If a docs page or a README says what should happen, link it.
+    validations:
+      required: true
+  - type: input
+    id: environment
+    attributes:
+      label: Environment
+      description: .NET SDK version, OS, whether you publish with Native AOT, and the database provider if EF Core is involved.
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 00000000..d99c7094
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Security report
+    url: https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/security/advisories/new
+    about: Report a vulnerability privately, as SECURITY.md describes. Please don't open a public issue for it.
diff --git a/.github/ISSUE_TEMPLATE/enhancement.yml b/.github/ISSUE_TEMPLATE/enhancement.yml
new file mode 100644
index 00000000..eb3cb593
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/enhancement.yml
@@ -0,0 +1,28 @@
+name: Enhancement
+description: A new member, generated feature, analyzer rule, satellite or option.
+labels: [enhancement]
+body:
+  - type: textarea
+    id: problem
+    attributes:
+      label: What you're trying to do
+      description: The task, not the API. What do you write today, and why doesn't it work?
+    validations:
+      required: true
+  - type: textarea
+    id: proposal
+    attributes:
+      label: What you'd like
+      description: A sketch of the code you'd write with it.
+      render: csharp
+  - type: dropdown
+    id: breaking
+    attributes:
+      label: Does it change something that compiles or works today?
+      description: A change to an existing signature, a generated member, a wire form or a diagnostic's severity needs a major version, even if the new behaviour is better.
+      options:
+        - No, it only adds
+        - Yes, existing code would compile or behave differently
+        - I'm not sure
+    validations:
+      required: true
diff --git a/.github/ISSUE_TEMPLATE/epic.yml b/.github/ISSUE_TEMPLATE/epic.yml
new file mode 100644
index 00000000..b408153d
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/epic.yml
@@ -0,0 +1,28 @@
+name: Epic
+description: A release or a theme. Its sub-issues are the work. (Maintainers.)
+title: "Epic: "
+labels: [epic]
+body:
+  - type: textarea
+    id: goal
+    attributes:
+      label: Goal
+      description: What is true when this is done, in one or two sentences. For a release, link its section of design/roadmap.md.
+    validations:
+      required: true
+  - type: textarea
+    id: scope
+    attributes:
+      label: In scope and out of scope
+    validations:
+      required: true
+  - type: textarea
+    id: done
+    attributes:
+      label: Done when
+      description: Every sub-issue is closed, plus anything that isn't an issue (a tag, a published package, a doc).
+    validations:
+      required: true
+  - type: markdown
+    attributes:
+      value: Add the work as sub-issues once this exists. For a release, set the milestone on the epic and on every sub-issue.
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
new file mode 100644
index 00000000..bd2c952d
--- /dev/null
+++ b/.github/pull_request_template.md
@@ -0,0 +1,22 @@
+Closes #
+
+<!--
+Give this PR the same labels and milestone as the issue it closes: one type (bug, enhancement,
+documentation, tests, chore), the package/* and area/* it touches, severity/* on a bug, and silent,
+breaking or stacked where they apply. The legend is in CONTRIBUTING.md, "Issues and
+labels". CI fails a PR with no type label, a bug with no severity, a missing closing reference, a
+branch whose <type>/ disagrees with its type label, a PR into release/<version> without that
+milestone, or a breaking PR into anything but a major.
+-->
+
+## Problem
+
+<!-- What was wrong or missing, and what a consumer would have seen. -->
+
+## Change
+
+<!-- What changed, file by file where it helps. -->
+
+## Tests
+
+<!-- What proves it. For a fix: the test, that it fails with the fix reverted, and the variants it ran across. -->
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
new file mode 100644
index 00000000..d13c205b
--- /dev/null
+++ b/.github/workflows/docs.yml
@@ -0,0 +1,139 @@
+# Builds the docs site from the guides in docs/, the root README, the package READMEs, the changelog and the API of
+# the run-time packages, and publishes it to GitHub Pages from main (#115, design/adr/0116-the-docs-site-is-docfx-built-from-main.md):
+#
+#   https://caffeinatedcoder.github.io/CodoMetis.TypeKit/
+#
+# Only main is published, because main is the released state: topics merge into release/<version>, which merges into
+# main when it is tagged, so the site always describes the version `dotnet add package` installs. A release branch
+# is never published. A second line under its own path (/2.x/, /3.x/) waits until two lines are supported at once;
+# CONTRIBUTING.md ("The docs site") says how one would be added.
+#
+# A pull request into main or a release branch that touches what a page is built from builds the site and publishes
+# nothing. DocFX runs with warnings as errors, so a link to a missing page, a missing heading or a missing file of the
+# repository fails the pull request rather than the deployment.
+#
+# The pages are the Markdown files as they are: nothing copies or edits them, so ReadmeSampleTests and
+# OracleCatalogueTests hold the text readers see. A link to a file of the repository that is not a page (design/,
+# CONTRIBUTING.md) becomes a GitHub address at the built commit in site/template, at build time.
+#
+# Pages is configured to deploy from GitHub Actions (Settings > Pages > Source), the one setting no workflow can make.
+#
+# Actions are pinned to commit SHAs, as in dotnet.yml.
+
+name: Docs
+
+# Everything a page is built from: the Markdown, the XML docs in src/, the site's config, and the SDK and tool pins.
+# Keep the two lists the same.
+on:
+  push:
+    branches: [ "main" ]
+    paths:
+      - "*.md"
+      - "LICENSE"
+      - "docs/**"
+      - "design/**"
+      - "src/**"
+      - "site/**"
+      - "global.json"
+      - "Directory.Build.props"
+      - "Directory.Packages.props"
+      - ".config/dotnet-tools.json"
+      - ".github/workflows/docs.yml"
+  pull_request:
+    branches: [ "main", "release/**" ]
+    paths:
+      - "*.md"
+      - "LICENSE"
+      - "docs/**"
+      - "design/**"
+      - "src/**"
+      - "site/**"
+      - "global.json"
+      - "Directory.Build.props"
+      - "Directory.Packages.props"
+      - ".config/dotnet-tools.json"
+      - ".github/workflows/docs.yml"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+defaults:
+  run:
+    shell: bash
+
+# A pull request's run is superseded by its next push. Publishing runs queue instead, so a deployment is never
+# cancelled halfway and the last one to finish publishes the latest main.
+concurrency:
+  group: ${{ github.event_name == 'pull_request' && format('docs-{0}', github.ref) || 'docs-publish' }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+env:
+  DOTNET_NOLOGO: true
+  DOTNET_CLI_TELEMETRY_OPTOUT: true
+  DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true
+
+jobs:
+  build:
+    name: Build the site
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+
+    steps:
+      - uses: actions/checkout@d23441a48e516b6c34aea4fa41551a30e30af803 # v6.1.0
+        with:
+          persist-credentials: false
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@26b0ec14cb23fa6904739307f278c14f94c95bf1 # v5.4.0
+        with:
+          global-json-file: global.json
+
+      # The API pages are read from published assemblies, which carry the XML docs and every dependency DocFX needs
+      # to resolve a signature. The packages are the ones site/docfx.json names, so the two cannot disagree.
+      - name: Publish the run-time packages
+        run: |
+          for assembly in $(jq -r '.metadata[].src[].files[]' site/docfx.json); do
+            dotnet publish "src/${assembly%.dll}" -c Release -o site/obj/pub
+          done
+
+      - name: Build the site, warnings as errors
+        run: |
+          dotnet tool restore
+          dotnet docfx site/docfx.json --warningsAsErrors --metadata _commit="$GITHUB_SHA"
+
+      # The members of C# 14 extension blocks are listed as extension methods, on their static class and on the type
+      # they extend: measured with DocFX 2.81.0 (decision 116). A DocFX that stops listing them fails here, not on
+      # a reader who finds Option<T>'s page without its combinators.
+      - name: The extension-block members are listed
+        run: |
+          grep -qF '  - CodoMetis.TypeKit.Option`1.CodoMetis.TypeKit.Option.Select``2(' site/obj/api/CodoMetis.TypeKit.Option-1.yml
+          grep -qF '  - CodoMetis.TypeKit.Result`2.CodoMetis.TypeKit.Result.Select``3(' site/obj/api/CodoMetis.TypeKit.Result-2.yml
+
+      # The files a link of a page names to be checked, which the site links on GitHub instead (site/template).
+      - name: Leave the repository's own files out
+        run: rm -rf site/obj/_site/_repository
+
+      - uses: actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9 # v5.0.0
+        if: github.event_name != 'pull_request' && github.ref == 'refs/heads/main'
+        with:
+          path: site/obj/_site
+
+  publish:
+    name: Publish
+    needs: build
+    if: github.event_name != 'pull_request' && github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    permissions:
+      pages: write
+      id-token: write
+    environment:
+      name: github-pages
+      url: ${{ steps.deploy.outputs.page_url }}
+
+    steps:
+      - uses: actions/configure-pages@45bfe0192ca1faeb007ade9deae92b16b8254a0d # v6.0.0
+
+      - id: deploy
+        uses: actions/deploy-pages@368f82528645a54fb793d4d04e342629a3f51346 # v5.0.1
diff --git a/.github/workflows/dotnet.yml b/.github/workflows/dotnet.yml
index 0924e153..ea2bc800 100644
--- a/.github/workflows/dotnet.yml
+++ b/.github/workflows/dotnet.yml
@@ -1,6 +1,10 @@
-# Build, test and pack on every push to main or a release branch and every PR into one; a PR packs
-# only when its diff can change a package (the changes job). Topics
-# merge into release/<version> and the release branch into main
+# Build, test and pack on every push to main or a release branch and every PR into one, in lanes: the Linux
+# test leg always, the Windows leg and the pack (Pack and Consumer) when the change can affect them, and the
+# macOS leg only in a run that selects nothing.
+# tools/CiLanes selects them from the changed paths in the changes job, and the CI job judges the run: every
+# selected job passed and every other was skipped (design/adr/0113-ci-runs-the-lanes-a-change-can-affect.md).
+# A PR into main, a push to main, a dispatch, the nightly run (nightly.yml) and the release (release.yml calls
+# this workflow) run every lane. Topics merge into release/<version> and the release branch into main
 # (design/adr/0094-topic-branches-into-a-release-branch-and-fix-trailers.md).
 #
 # The tests run on Linux, Windows and macOS: a contributor needs git and the pinned SDK on any of
@@ -27,6 +31,8 @@ on:
   pull_request:
     branches: [ "main", "release/**" ]
   workflow_dispatch:
+  # release.yml runs every lane before it verifies. Its event is the tag's push, which selects every lane.
+  workflow_call:
 
 permissions:
   contents: read
@@ -35,9 +41,11 @@ defaults:
   run:
     shell: bash
 
-# A new push to a PR makes the in-flight run pointless; main is never cancelled.
+# A new push to a PR makes the in-flight run pointless; main is never cancelled. The prefix keeps a call from
+# release.yml out of its caller's group: a called workflow's github.workflow is the caller's name, and groups
+# ignore case, so without it both would be release-<tag> and the call would wait for its caller (KB-043).
 concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
+  group: ci-${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 
 env:
@@ -46,16 +54,17 @@ env:
   DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true
 
 jobs:
-  # Whether this run can change a package or a trimmed consumer: on a push and in the release always, on
-  # a pull request only when the diff against the base branch touches a shipping project, a build
-  # property file, a project file, the SDK pin, the package versions, a workflow or the smoke test
-  # itself. The pack and consumer jobs below run on that answer; the deciding paths are in this job's log.
+  # Which lanes this run needs, from the paths it changes (tools/CiLanes, design/adr/0113): a PR into a release
+  # branch against its base, a push to one against the commit it replaced, every other run every lane. The job
+  # summary lists each path's class. A diff that fails fails this job, and the CI job with it, never skips a lane.
   changes:
     name: Changes
     runs-on: ubuntu-latest
-    timeout-minutes: 5
+    timeout-minutes: 10
     outputs:
-      product: ${{ steps.product.outputs.product }}
+      legs: ${{ steps.select.outputs.legs }}
+      pack: ${{ steps.select.outputs.pack }}
+      suite: ${{ steps.select.outputs.suite }}
 
     steps:
       # The whole history: the diff is against the base branch, which a shallow clone has not fetched.
@@ -63,47 +72,38 @@ jobs:
         with:
           fetch-depth: 0
 
-      # Bash runs with -e; `git diff` of a base branch that was not fetched fails the job rather than
-      # answering false, so a broken diff can never skip the pack.
-      - name: Can the diff change a package?
-        id: product
-        run: |
-          if [ "$GITHUB_EVENT_NAME" != pull_request ]; then
-            echo "product=true" >> "$GITHUB_OUTPUT"
-            echo "A $GITHUB_EVENT_NAME: the packages and the consumer are always built."
-            exit 0
-          fi
-          git diff --name-only "origin/$GITHUB_BASE_REF...HEAD" > changed-paths.txt
-          product=false
-          while IFS= read -r path; do
-            case "$path" in
-              global.json) reason='global.json' ;;
-              Directory.Packages.props) reason='Directory.Packages.props' ;;
-              src/*) reason='src/' ;;
-              Directory.*.props|*/Directory.*.props) reason='Directory.*.props' ;;
-              Directory.*.targets|*/Directory.*.targets) reason='Directory.*.targets' ;;
-              *.csproj) reason='*.csproj' ;;
-              .github/workflows/*) reason='.github/workflows/' ;;
-              tools/ConsumerSmokeTest/*) reason='tools/ConsumerSmokeTest/' ;;
-              *) continue ;;
-            esac
-            echo "$path ($reason)"
-            product=true
-          done < changed-paths.txt
-          echo "product=$product" >> "$GITHUB_OUTPUT"
-          if [ "$product" = true ]; then
-            echo "The paths above can change a package or a trimmed consumer: the packages and the consumer are built."
-          else
-            echo "No changed path can change a package or a trimmed consumer: the pack and consumer jobs are skipped."
-          fi
+      - name: Setup .NET
+        uses: actions/setup-dotnet@26b0ec14cb23fa6904739307f278c14f94c95bf1 # v5.4.0
+        with:
+          global-json-file: global.json
 
+      # A tool project, run as its built dll (design/adr/0092).
+      - name: Build the selection
+        run: dotnet build tools/CiLanes -c Release
+
+      - name: Select the lanes
+        id: select
+        env:
+          BASE_REF: ${{ github.base_ref }}
+          BEFORE: ${{ github.event.before }}
+        run: >
+          dotnet tools/CiLanes/bin/Release/net10.0/ci-lanes.dll select
+          --event "$GITHUB_EVENT_NAME" --ref "$GITHUB_REF" --base "$BASE_REF" --before "$BEFORE"
+          --output "$GITHUB_OUTPUT" --summary "$GITHUB_STEP_SUMMARY"
+
+  # The legs the changes job selected: Linux in every run, Windows when the change can affect it, macOS only in a
+  # run that selects nothing. A prose-only change builds and runs test/Prose.slnf alone, the test projects that
+  # read prose (ProseReaderTests holds the set); anything else, the whole solution.
   test:
     name: Test (${{ matrix.os }})
     runs-on: ${{ matrix.os }}
+    needs: changes
+    env:
+      SOLUTION: ${{ needs.changes.outputs.suite == 'prose' && 'test/Prose.slnf' || 'CodoMetis.TypeKit.slnx' }}
     strategy:
       fail-fast: false
       matrix:
-        os: [ ubuntu-latest, windows-latest, macos-latest ]
+        os: ${{ fromJSON(needs.changes.outputs.legs) }}
 
     steps:
       # The whole history and its tags: CommitTrailerTests reads the fix commits since v2.1.0, and
@@ -118,19 +118,19 @@ jobs:
           global-json-file: global.json
 
       - name: Restore
-        run: dotnet restore CodoMetis.TypeKit.slnx
+        run: dotnet restore "$SOLUTION"
 
       - name: Build
-        run: dotnet build CodoMetis.TypeKit.slnx -c Release --no-restore
+        run: dotnet build "$SOLUTION" -c Release --no-restore
 
-      # The EF Core round trips start a PostgreSQL container. Ubuntu runners have Docker; macOS
-      # runners have none and Windows runners run only Windows containers, so those legs leave the
-      # one class that needs it out.
+      # The EF Core tests on PostgreSQL and SQL Server, and the SQL Server facts, start a Linux container.
+      # Ubuntu runners have Docker; macOS runners have none and Windows runners run only Windows
+      # containers, so those legs leave out the classes that need it, the trait Needs=Docker.
       - name: Test
         run: >
-          dotnet test --solution CodoMetis.TypeKit.slnx -c Release --no-build
+          dotnet test --solution "$SOLUTION" -c Release --no-build
           --report-xunit-trx --results-directory TestResults
-          ${{ runner.os != 'Linux' && '--filter-not-class "*PostgreSqlRoundTripTests"' || '' }}
+          ${{ runner.os != 'Linux' && '--filter-not-trait "Needs=Docker"' || '' }}
 
       - name: Upload test results
         uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
@@ -140,153 +140,16 @@ jobs:
           path: TestResults/**/*.trx
           if-no-files-found: ignore
 
-  # The probe corpus (tools/probe/corpus), replayed with no model, split by family into legs that run at
-  # once, each running its probes as many at a time as the runner has cores (design/adr/0101, which amends
-  # 0096). On a push the whole corpus is replayed from an empty state, with coverage, and the merged state
-  # is saved for the pull requests into this branch. On a pull request the base branch's saved state is
-  # restored and only the probes whose identity or footprint the branch changed are replayed, judged
-  # against the base's footprints, without coverage, since nothing of that state is kept; with no saved
-  # state every probe runs, as from an empty state. A failing probe fails its leg and the run. Linux only:
-  # the probes test documented claims, not the platform, and the test job's three legs test the prober.
-  probes:
-    name: Probe replay (${{ matrix.family }})
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    strategy:
-      fail-fast: false
-      matrix:
-        # The families of the axes file's replay configuration, every one: ReleaseWiringTests holds this
-        # list to that, and `prober replay --family` refuses while a probe's surface is in no family.
-        family: [ http, ef, json, text, build ]
-
-    steps:
-      # The whole history: the replay adds a git worktree at HEAD, and `universe` reads the claims
-      # against origin/main.
-      - uses: actions/checkout@d23441a48e516b6c34aea4fa41551a30e30af803 # v6.1.0
-        with:
-          fetch-depth: 0
-
-      - name: Setup .NET
-        uses: actions/setup-dotnet@26b0ec14cb23fa6904739307f278c14f94c95bf1 # v5.4.0
-        with:
-          global-json-file: global.json
-
-      # The prober's state and its replay worktree, in this job's own temporary directory, never a
-      # developer's (the default without PROBE_STATE_DIR). The state is the branch's: on a pull request
-      # the base branch's, so that its saved footprints decide what the branch stales.
-      - name: Prober state directory
-        run: |
-          echo "PROBE_STATE_DIR=$RUNNER_TEMP/probe-state" >> "$GITHUB_ENV"
-          echo "PROBE_CACHE_DIR=$RUNNER_TEMP/probe-cache" >> "$GITHUB_ENV"
-          echo "PROBE_BRANCH=${{ github.event_name == 'pull_request' && github.base_ref || github.ref_name }}" >> "$GITHUB_ENV"
-
-      # The base branch's state as its last green push saved it; the newest entry under the prefix. With
-      # none (the first run, or an evicted entry) the replay starts empty and runs every probe.
-      - name: Restore the base branch's probe state
-        if: github.event_name == 'pull_request'
-        uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
-        with:
-          path: ${{ runner.temp }}/probe-state
-          key: probe-state-${{ github.base_ref }}-${{ github.sha }}
-          restore-keys: probe-state-${{ github.base_ref }}-
-
-      # The prober is a tool project, run as its built dll (design/adr/0092).
-      - name: Build the prober
-        run: dotnet build tools/Prober -c Release
-
-      # Bash runs with -e, so the exit code of the replay is the step's.
-      - name: Replay the family's probes
-        run: |
-          if [ "$GITHUB_EVENT_NAME" = pull_request ]; then
-            dotnet tools/Prober/bin/Release/net10.0/prober.dll replay --branch "$PROBE_BRANCH" --family "${{ matrix.family }}" --no-footprint
-          else
-            dotnet tools/Prober/bin/Release/net10.0/prober.dll replay --all --branch "$PROBE_BRANCH" --family "${{ matrix.family }}"
-          fi
-
-      # The leg's state, for the merge below and for triage of a failure.
-      - name: Upload the leg's state
-        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
-        if: always()
-        with:
-          name: probe-state-${{ matrix.family }}
-          path: ${{ runner.temp }}/probe-state
-          if-no-files-found: error
-
-  # The legs' states joined into one: `prober merge` refuses while a registered probe was in no leg and
-  # fails when a leg did, so this job is red whenever the replay is. Then the status in the job summary,
-  # and on a push the merged state saved for the branch's pull requests.
-  probe-status:
-    name: Probe status
-    runs-on: ubuntu-latest
-    needs: probes
-    if: always()
-    timeout-minutes: 15
-
-    steps:
-      - uses: actions/checkout@d23441a48e516b6c34aea4fa41551a30e30af803 # v6.1.0
-        with:
-          fetch-depth: 0
-
-      - name: Setup .NET
-        uses: actions/setup-dotnet@26b0ec14cb23fa6904739307f278c14f94c95bf1 # v5.4.0
-        with:
-          global-json-file: global.json
-
-      - name: Prober state directory
-        run: |
-          echo "PROBE_STATE_DIR=$RUNNER_TEMP/probe-state" >> "$GITHUB_ENV"
-          echo "PROBE_CACHE_DIR=$RUNNER_TEMP/probe-cache" >> "$GITHUB_ENV"
-          echo "PROBE_BRANCH=${{ github.event_name == 'pull_request' && github.base_ref || github.ref_name }}" >> "$GITHUB_ENV"
-
-      - name: Download the legs' states
-        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
-        with:
-          pattern: probe-state-*
-          path: ${{ runner.temp }}/probe-legs
-
-      - name: Build the prober
-        run: dotnet build tools/Prober -c Release
-
-      - name: Merge the legs
-        run: dotnet tools/Prober/bin/Release/net10.0/prober.dll merge --branch "$PROBE_BRANCH" --from "$RUNNER_TEMP"/probe-legs/probe-state-*
-
-      # A report: the documented claims' pair coverage and the open findings, in the job summary. It
-      # fails only when the prober cannot read the claims. `universe` builds what `status` reads.
-      - name: Probe status
-        if: always()
-        run: |
-          dotnet tools/Prober/bin/Release/net10.0/prober.dll universe --branch "$PROBE_BRANCH" > /dev/null
-          dotnet tools/Prober/bin/Release/net10.0/prober.dll status --branch "$PROBE_BRANCH" | tee status.txt
-          { echo '### Probe status'; echo; echo '```text'; cat status.txt; echo '```'; } >> "$GITHUB_STEP_SUMMARY"
-
-      # The branch's state after a green push: what its pull requests replay against. A red push saves
-      # nothing, so a pull request judges against the last green state and replays more.
-      - name: Save the branch's probe state
-        if: github.event_name == 'push'
-        uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
-        with:
-          path: ${{ runner.temp }}/probe-state
-          key: probe-state-${{ github.ref_name }}-${{ github.sha }}
-
-      # The merged evidence of every probe, for triage of a failure.
-      - name: Upload the probe state
-        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
-        if: always()
-        with:
-          name: probe-state
-          path: ${{ runner.temp }}/probe-state
-          if-no-files-found: ignore
-
   # The pack catches a package that names a README it does not pack and a broken SBOM step, and the two
   # smoke tests a consumer that no longer restores, compiles or publishes with Native AOT against the
-  # packed feed and against one packed on the spot. A pull request that touches none of the paths the
-  # changes job lists cannot change any of them, so it skips both, while every push and the release
-  # (release.yml) still run them.
+  # packed feed and against one packed on the spot. Both run when the changes job selects the pack lane,
+  # beside the test legs rather than after them: neither reads the tests' outcome, and the CI job requires
+  # all of them. The release (release.yml) runs them again on what it publishes.
   pack:
     name: Pack
     runs-on: ubuntu-latest
-    needs: [ test, changes ]
-    if: needs.changes.outputs.product == 'true'
+    needs: [ changes ]
+    if: needs.changes.outputs.pack == 'true'
 
     steps:
       - uses: actions/checkout@d23441a48e516b6c34aea4fa41551a30e30af803 # v6.1.0
@@ -342,8 +205,8 @@ jobs:
   consumer:
     name: Consumer smoke test
     runs-on: ubuntu-latest
-    needs: [ test, changes ]
-    if: needs.changes.outputs.product == 'true'
+    needs: [ changes ]
+    if: needs.changes.outputs.pack == 'true'
 
     steps:
       - uses: actions/checkout@d23441a48e516b6c34aea4fa41551a30e30af803 # v6.1.0
@@ -364,3 +227,32 @@ jobs:
 
       - name: Consumer smoke test, packing its own feed
         run: dotnet tools/ConsumerSmokeTest/bin/Release/net10.0/consumer-smoke-test.dll
+
+  # The one required build check: every job the changes job selected succeeded and every other was skipped
+  # (tools/CiLanes gate, design/adr/0113). A skipped job reads as a passing required check, so the legs
+  # themselves cannot be required once they may be skipped (KB-043). Under always(), so a failed selection or a
+  # cancelled leg fails this job rather than skipping it, and a skipped CI is never what a merge sees.
+  ci:
+    name: CI
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    needs: [ changes, test, pack, consumer ]
+    if: always()
+
+    steps:
+      - uses: actions/checkout@d23441a48e516b6c34aea4fa41551a30e30af803 # v6.1.0
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@26b0ec14cb23fa6904739307f278c14f94c95bf1 # v5.4.0
+        with:
+          global-json-file: global.json
+
+      - name: Build the gate
+        run: dotnet build tools/CiLanes -c Release
+
+      - name: Every selected job passed, every other was skipped
+        env:
+          NEEDS: ${{ toJSON(needs) }}
+        run: |
+          printf '%s' "$NEEDS" > "$RUNNER_TEMP/needs.json"
+          dotnet tools/CiLanes/bin/Release/net10.0/ci-lanes.dll gate "$RUNNER_TEMP/needs.json" --summary "$GITHUB_STEP_SUMMARY"
diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
new file mode 100644
index 00000000..9fb10832
--- /dev/null
+++ b/.github/workflows/nightly.yml
@@ -0,0 +1,48 @@
+# Runs the build workflow with every lane, once a night, on main and on every release branch
+# (design/adr/0113-ci-runs-the-lanes-a-change-can-affect.md). Pull requests into a release branch run only the
+# lanes their changes can affect, so this is where the runner images, the SDK band global.json admits, the
+# PostgreSQL image and nuget.org's packages in the smoke consumers are met when nothing is pushed.
+#
+# It dispatches dotnet.yml rather than running it: a schedule runs only from the default branch, and a dispatch
+# runs on the branch it names. Events the GITHUB_TOKEN raises start no run, except a dispatch (KB-043), which is
+# why the job needs actions: write and nothing more. GitHub turns a public repository's schedule off after 60
+# days without activity, so nothing depends on this: the release calls dotnet.yml itself.
+
+name: Nightly
+
+on:
+  schedule:
+    - cron: "17 3 * * *"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  dispatch:
+    name: Dispatch the build workflow
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+
+    permissions:
+      actions: write   # dispatch dotnet.yml; nothing else
+
+    steps:
+      - name: Dispatch dotnet.yml on main and every release branch
+        env:
+          GH_TOKEN: ${{ github.token }}
+          GH_REPO: ${{ github.repository }}
+        run: |
+          branches="$(gh api "repos/$GH_REPO/branches" --paginate --jq '.[].name | select(. == "main" or startswith("release/"))')"
+          if [[ -z "$branches" ]]; then
+            echo "::error::No main or release/* branch to dispatch the build workflow on."
+            exit 1
+          fi
+          while IFS= read -r branch; do
+            echo "==> dotnet.yml on $branch"
+            gh workflow run dotnet.yml --ref "$branch"
+          done <<< "$branches"
diff --git a/.github/workflows/pr-hygiene.yml b/.github/workflows/pr-hygiene.yml
new file mode 100644
index 00000000..53caa3d1
--- /dev/null
+++ b/.github/workflows/pr-hygiene.yml
@@ -0,0 +1,60 @@
+# Every pull request into main or a release branch carries one type label, a severity if it is a bug,
+# the milestone of the release it goes into, a branch named <type>/<slug> that agrees with its type, and a
+# closing reference to the issue it resolves; a breaking one goes into a major (CONTRIBUTING.md, "Issues and
+# labels"; design/adr/0109-work-is-tracked-as-labelled-issues-and-ci-checks-each-pull-request.md). The rules
+# live in tools/PrHygiene, a tool project like the others (design/adr/0092), which reads the event payload
+# alone: no token, nothing of the pull request's code run, and runnable locally on a saved payload.
+#
+# Triggered on label, milestone and description edits as well as pushes, so adding what is missing turns
+# the check green without a new commit. `pull_request`, not `pull_request_target`: a pull request from a
+# fork runs with a read-only token and never sees a secret, and builds the tool from its own checkout,
+# which can only weaken the check on that pull request's own run, where a reviewer reads the diff.
+#
+# No concurrency group: every event's run completes (#144). The check takes seconds and reads only its
+# payload, so cancelling a superseded run saves nothing, and a run cancelled while its job was going leaves
+# a cancelled check run, which blocks a required check (#141, #142). Measured on 2026-10-29 on two draft
+# pull requests whose labels, milestone and body were set within seconds of opening them, five events each:
+#   - a group with cancel-in-progress: false still cancels: a newer pending run replaces the older pending
+#     one, and three of four runs were cancelled. Nothing was blocked, since a run cancelled before its job
+#     started leaves no check run, but the runs the check is meant to have are missing;
+#   - no group: all five ran, none was cancelled. Earlier runs failed (their payload had no labels yet) and
+#     the pull request was CLEAN once CI passed: the newest run decides the required check, not the last to
+#     finish. With the first run held back 75 s to finish after the one that succeeded, it was CLEAN too.
+# A run reads the payload of its own event, so a pull request that fails here is fixed by an event after the
+# fix, or by re-running the newest run.
+#
+# Actions are pinned to commit SHAs, as in dotnet.yml.
+
+name: PR hygiene
+
+on:
+  pull_request:
+    branches: [ "main", "release/**" ]
+    types: [ opened, edited, reopened, synchronize, labeled, unlabeled, milestoned, demilestoned ]
+
+permissions:
+  contents: read
+
+env:
+  DOTNET_NOLOGO: true
+  DOTNET_CLI_TELEMETRY_OPTOUT: true
+  DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true
+
+jobs:
+  check:
+    name: Labels and issue link
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@d23441a48e516b6c34aea4fa41551a30e30af803 # v6.1.0
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@26b0ec14cb23fa6904739307f278c14f94c95bf1 # v5.4.0
+        with:
+          global-json-file: global.json
+
+      - name: Build the check
+        run: dotnet build tools/PrHygiene -c Release
+
+      - name: Check labels, milestone, branch and issue link
+        run: dotnet tools/PrHygiene/bin/Release/net10.0/pr-hygiene.dll "$GITHUB_EVENT_PATH"
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 2d9df4a8..22930355 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -12,7 +12,10 @@
 # validates it against a policy configured there, and issues an API key valid for one hour. A
 # compromise of this repository's secrets yields nothing that can publish.
 #
-# Three jobs on purpose: everything that can fail runs unattended, only the push waits behind the
+# First the build workflow, called with every lane (dotnet.yml under workflow_call; design/adr/0113): the
+# Windows and macOS legs and both smoke-test modes, which a pull request may have skipped.
+#
+# Then three jobs on purpose: everything that can fail runs unattended, only the push waits behind the
 # environment's approval gate, and the GitHub release is created afterwards. A reviewer is asked
 # once the full suite has already passed, and no OIDC token is minted until they approve. The job
 # that can mint a token cannot write to the repository, and the job that can write to the repository
@@ -66,9 +69,17 @@ env:
   NUGET_SOURCE: https://api.nuget.org/v3/index.json
 
 jobs:
+  # Every lane of the build workflow, on the commit this run publishes. Its jobs show as "CI / ...".
+  ci:
+    name: CI
+    uses: ./.github/workflows/dotnet.yml
+    permissions:
+      contents: read
+
   verify:
     name: Verify and pack
     runs-on: ubuntu-latest
+    needs: ci
 
     permissions:
       contents: read   # deliberately nothing more: this job runs unattended and must not mint a token
@@ -131,47 +142,11 @@ jobs:
         run: dotnet build CodoMetis.TypeKit.slnx -c Release
 
       # The full suite gates the release, the conventions project included: it holds the analyzer
-      # release tracking to the changelog, and this workflow to the names above.
+      # release tracking to the changelog, this workflow to the names above, and the oracle catalogue
+      # (test/oracles) to the documents, the public surface and its seeds (design/adr/0112).
       - name: Test
         run: dotnet test --solution CodoMetis.TypeKit.slnx -c Release --no-build
 
-      # The prober's state and its replay worktree, in this job's own temporary directory, never a
-      # developer's (the default without PROBE_STATE_DIR).
-      - name: Prober state directory
-        run: |
-          echo "PROBE_STATE_DIR=$RUNNER_TEMP/probe-state" >> "$GITHUB_ENV"
-          echo "PROBE_CACHE_DIR=$RUNNER_TEMP/probe-cache" >> "$GITHUB_ENV"
-
-      # Every probe of the corpus, with no model, as CI replays it on every push (design/adr/0096). A probe
-      # that fails fails the release, like a test. The Build above built the prober. Every probe's seeds are
-      # shown caught before the tag, locally, by `prober seeds --all` (AGENTS.md, Releasing): a build per seed,
-      # which this job does not pay (design/adr/0100), and --all because a run without it skips the probes
-      # unchanged since their seeds were caught (design/adr/0107).
-      - name: Replay every probe
-        run: dotnet tools/Prober/bin/Release/net10.0/prober.dll replay --all
-
-      # The release gate, against the previous release: on a tag push `git describe` alone would name the
-      # tag being released and compare the commit with itself. It binds from 2.2.0 (design/adr/0097): a
-      # refusal fails the release, as any other exit does. A refusal is answered by a probe, a fix or a
-      # reviewed waiver in tools/probe/corpus/waivers.json, never by editing this step.
-      - name: Probe gate
-        env:
-          VERSION: ${{ steps.version.outputs.version }}
-        run: |
-          since="$(git describe --tags --abbrev=0 --exclude "v$VERSION")"
-          code=0
-          dotnet tools/Prober/bin/Release/net10.0/prober.dll gate --since "$since" > gate.txt 2>&1 || code=$?
-          cat gate.txt
-          case "$code" in
-            0) verdict="passes" ;;
-            1) verdict="refused"
-               echo "::error::The probe gate refused $VERSION since $since; see the job summary." ;;
-            *) verdict="did not run (exit $code)"
-               echo "::error::The probe gate did not run (exit $code)." ;;
-          esac
-          { echo "### Probe gate since $since: $verdict"; echo; echo '```text'; cat gate.txt; echo '```'; } >> "$GITHUB_STEP_SUMMARY"
-          exit "$code"
-
       - name: Pack
         run: dotnet pack CodoMetis.TypeKit.slnx -c Release --no-build -o dist
 
diff --git a/AGENTS.md b/AGENTS.md
index 06300ff6..ae2b6c1e 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -62,53 +62,27 @@ dotnet test --project test/CodoMetis.TypeKit.Conventions.Tests --filter-method "
 dotnet build spikes/FabricSpike/FabricSpike.slnx      # the fabric spike, standalone
 dotnet tools/ConsumerSmokeTest/bin/Release/net10.0/consumer-smoke-test.dll   # the packages, installed into throwaway consumers, one published with Native AOT (needs the platform linker); build it with -c Release first
 dotnet tools/BuildVerdict/bin/Release/net10.0/build-verdict.dll test [--project P] [--filter-class C] [--filter-method M] [-- flags]   # an agent's build and test: a verdict, not the transcript
+dotnet tools/PrHygiene/bin/Release/net10.0/pr-hygiene.dll event.json   # a PR's labels, milestone, branch and issue link, as CI's PR hygiene check reads them from the payload
+dotnet tools/CiLanes/bin/Release/net10.0/ci-lanes.dll classify <path>...   # the CI lanes a changed path selects (Linux, Windows, the pack; macOS only on the release's runs), as CI's changes job decides them
 ```
 
-The probing tool, prober (`tools/Prober`, started as its built dll like docs-query). These need no
-model, no login and no API key, and run in CI as anywhere: the `probes` legs of `dotnet.yml` replay
-the corpus by family, every probe on a push and the probes the branch stales on a pull request, judged
-against the base branch's saved state, and `probe-status` merges the legs and reports
-([decision 101](design/adr/0101-ci-replays-by-family-and-footprint.md)); `release.yml` runs `replay --all`
-and `gate` before it packs ([decision 96](design/adr/0096-ci-replays-every-probe-and-the-release-runs-the-gate.md)):
+The oracle kit's local tool, which needs no model and never runs in CI
+([test/oracles/README.md](test/oracles/README.md)):
 
 ```bash
-dotnet tools/Prober/bin/Release/net10.0/prober.dll status    # coverage of the branch's documented claims, open findings
-dotnet tools/Prober/bin/Release/net10.0/prober.dll replay    # re-run the probes whose identity or footprint changed
-dotnet tools/Prober/bin/Release/net10.0/prober.dll gate      # the release gate, from the tracked corpus and a replay
+dotnet tools/Oracles/bin/Release/net10.0/oracles.dll status          # the worklist: unheld claims, unread waivers, unseeded oracles, candidates
+dotnet tools/Oracles/bin/Release/net10.0/oracles.dll seeds [filter]  # each seed: a copy of the tree, the patch, one project built, one class run
 ```
 
-Proving that each probe can fail needs no model either, but builds once per seed, so it runs locally
-only ([decision 100](design/adr/0100-every-probe-is-shown-to-fail-against-a-seeded-defect.md)), and only for the
-probes changed since their seeds were last caught; a release runs `--all`
-([decision 107](design/adr/0107-a-cited-fact-is-executable-and-seeds-run-by-footprint.md)):
-
-```bash
-dotnet tools/Prober/bin/Release/net10.0/prober.dll seeds     # each probe's seeded defect, applied in a scratch worktree, must fail it
-```
-
-Exploration needs a model and runs locally only, never in CI:
-
-```bash
-dotnet tools/Prober/bin/Release/net10.0/prober.dll round explore --minutes 10 --claims 2
-```
-
-An agent runs builds and tests through `tools/BuildVerdict`, run as its built dll (`build
-[<project|slnx>]` or `test`). It prints the exit code named, each diagnostic code once with its remedy
-from `tools/BuildVerdict/build-verdict-remedies.tsv`, and the failing tests with their assertion; the
-full log is `$GIT_DIR/build-verdict-last.log`. A code it prints as UNMAPPED gets a row once its fix is
-known. In an agent's Bash tool, `tools/BashGuard` (registered in `.claude/settings.json`) refuses
-`dotnet build` of anything but a tool, `dotnet test` and `dotnet msbuild` (a `-getProperty`/`-getItem` query
-without a target excepted), and the verdict piped into
-`head` or `tail`, and prints the verdict's form of the command. The raw commands above are for a
-terminal.
-
-Both are tool projects under `tools/` (design/adr/0092): BCL only, in the solution, each with its
-tests (`tools/BuildVerdict.Tests`, `tools/BashGuard.Tests`), and run from `bin/Release`, which
-`.claude/settings.json` builds at session start: the guard in the main checkout, every other tool
-(`tools/AgentTools.slnf`) in the session's own, a worktree included, with the SDK installer's `dotnet`
-when the one on PATH lacks the pinned SDK; a session start that builds nothing says so in your context
-(design/adr/0105). Each records the sources it was built from and refuses to run from others, naming
-the command that rebuilds it: `dotnet build tools/<Name> -c Release`, which the guard lets through.
+An agent builds and tests through `tools/BuildVerdict` (`build [<project|slnx>]` or `test`). It prints a
+verdict: the exit code named, each diagnostic once with its remedy from
+`tools/BuildVerdict/build-verdict-remedies.tsv` (give an UNMAPPED code a row once its fix is known), and the
+failing tests; the full log is `$GIT_DIR/build-verdict-last.log`. In an agent's Bash tool, `tools/BashGuard`
+refuses the raw `dotnet build`, `dotnet test` and `dotnet msbuild` and prints the verdict's form of the command;
+the raw commands above are for a terminal. The tools run from `bin/Release`, built at session start in the
+session's own checkout ([decision 105](design/adr/0105-every-tool-is-built-in-the-session-s-checkout.md)).
+A tool built from other sources refuses to run and names the command that rebuilds it,
+`dotnet build tools/<Name> -c Release`.
 
 The SDK is pinned in `global.json` (10.0.4xx band, `latestPatch`). Tests run on Microsoft Testing
 Platform (xunit.v3 4.x), so `dotnet test` takes `--solution`/`--project`, and TRX output is
@@ -131,33 +105,16 @@ here, so it leads and the source decides.
   before researching what ASP.NET, System.Text.Json, EF Core, the runtime or the platform do, and a new
   `design/knowledge/` entry when research settles one that something here turned on
   ([decision 93](design/adr/0093-verified-facts-are-pinned-dated-and-executable-where-they-can-be.md)).
-- **An empty result proves nothing.** Fall back to text search when the graph is unavailable, stale
-  or silent, and never conclude "unused", "no other caller" or "safe to change" from it alone.
-  Measured on 2026-10-13, the graph:
-  - finds types, interfaces, enums and ordinary methods, a type's implementers through generic
-    interfaces (84 of the Samples' 88 value objects), and the callers of an ordinary method across
-    files;
-  - has no node for a member of a C# 14 `extension(...)` block, which holds most of the `Option` and
-    `Result` extensions (`Choose`, `FirstOrNone`, `Transpose`, `Sequence`, the continuations of a
-    `Task<Result<...>>`) and `AsText`, and puts the calls inside one on the file;
-  - has nothing Metalama generates: none of the tests' 222 `.From(` calls has an edge, nor has a call
-    to `TryFrom`, `FromKnownGood`, `Parse` or a converter, and a template an aspect introduces by
-    `nameof` looks unreferenced. Read woven code as the Generators README's "Reading the generated
-    code" says;
-  - misses a reference that is not a call: a DI registration, a type argument, `typeof`, an attribute;
-  - resolves a call on a generic instance poorly (`Option<T>.Match` has one resolved caller, where
-    the repository writes `.Match(` about 200 times across its types) and guesses wrong callers: a low-confidence `suffix_match` edge, or a same-named method of another API
-    (Metalama's `Diagnostics.Report` listed as calling `GeneratedCode.Report`). Overloads share one
-    node.
-- **Refresh it**, since it does not follow the working tree: `index_repository` with the repository
-  root as `repo_path` and `name: "CodoMetis.TypeKit"`, at the start of a session and after a branch
-  switch, a rebase, a merge or a pull (about 6 s). Without `name` it starts a second project under a
-  derived name. `index_status` reports the checkout's HEAD, not the commit the graph was built from,
-  so refresh rather than check.
-- It indexes `spikes/` and leaves out `.claude/`, `bin` and `obj`, so an agent in a worktree under
-  `.claude/worktrees/` reads the main checkout's graph, not its own: index the worktree under a name
-  of its own and delete that project when done, or search the source. `.codebase-memory/`, the
-  tool's local artifact, is ignored by git.
+- **An empty result proves nothing.** The graph has no node for a member of a C# 14 `extension(...)`
+  block (most of the `Option` and `Result` extensions), nothing Metalama generates (no `.From(` or
+  `TryFrom` call has an edge), and no reference that is not a call; it resolves calls on a generic
+  instance poorly and guesses wrong callers ([design/code-graph.md](design/code-graph.md) has the
+  measurements). Fall back to text search, and never conclude "unused", "no other caller" or "safe to
+  change" from it alone.
+- **Refresh it**, since it does not follow the working tree: `index_repository` with the repository root
+  as `repo_path` and `name: "CodoMetis.TypeKit"`, at the start of a session and after a branch switch, a
+  rebase, a merge or a pull. A worktree under `.claude/worktrees/` isn't indexed: index it under a name of
+  its own and delete that project when done, or search the source.
 
 The way into the docs is docs-query (`dotnet tools/DocsQuery/bin/Release/net10.0/docs-query.dll`,
 [its README](tools/DocsQuery/README.md)): `entry`, `cites`, `cited-by`, `list`, `claims` and `check`
@@ -221,6 +178,20 @@ the whole page. A ranked miss proves nothing.
   analyzer that stops firing, or a converter that materialises `default` are this repo's
   characteristic failures. Prefer a diagnostic or an exception to a plausible result.
 
+## Issues
+Work is tracked as GitHub issues, not as lists in docs or memory
+([decision 109](design/adr/0109-work-is-tracked-as-labelled-issues-and-ci-checks-each-pull-request.md)):
+open the issue before starting the work. The labels, the epics and what a PR carries are CONTRIBUTING's
+"Issues and labels" and "Pull requests"; `gh label list` is the source, and a label is never invented.
+What trips agents here:
+- A release's work is a native sub-issue of its `epic`, with the version's milestone:
+  `gh issue create --parent N --milestone M`. A finding belongs to the release it ships in.
+- Name the branch from the type label before the first push (`feat/`, `fix/`, `docs/`, `test/`, `build/`,
+  never `chore/`): PR hygiene fails a `<type>/` that disagrees, and renaming a pushed head closes its PR.
+- A topic merges into its release branch, where `Closes` closes nothing: close its issue by hand on merge,
+  with a comment linking the PR.
+- When the work changes what an issue says (its scope, its state, a measured fact), edit the issue.
+
 ## Workflow
 1. Read `design/plan.md`, the roadmap, the decision records and the design note for the area you
    touch, and the relevant spike README, before starting. A decision is changed by a new record.
@@ -242,53 +213,19 @@ the whole page. A ranked miss proves nothing.
    tables of [decision 94](design/adr/0094-topic-branches-into-a-release-branch-and-fix-trailers.md)
    (`CommitTrailerTests`). Work happens on a `<type>/<slug>` branch from `release/<version>`, reaches it
    by a PR, and every merge is a merge commit: never squash or rebase a pushed branch.
-7. **Probes replay themselves; exploring is a separate, capped, local job.** Consumer probes check the
-   claims in `docs/` and the READMEs, pairwise over the axes in
-   [.claude/probe-axes.md](.claude/probe-axes.md); they, their rows, the claims and the waivers are the
-   corpus in `tools/probe/corpus/`, tracked like tests.
-   - **Replay** runs in CI on every push and pull request, every probe from an empty state, and a probe
-     that fails fails the job. Locally it runs after every commit from a git `post-commit` hook, in the
-     background and with no model: `prober replay` re-runs only the probes whose identity or coverage
-     footprint the commit changed, and blocks nothing. Read `prober status` before your next change. A probe that passed with
-     the same identity and fails now is an open finding `R-<probe>-<sha>`, fixed like any failing test.
-     The hook is opt-in, per clone and untracked: put this in `$(git rev-parse --git-common-dir)/hooks/post-commit`
-     and make it executable (Git for Windows runs it through its own `sh`):
-
-     ```sh
-     #!/bin/sh
-     [ -f tools/Prober/Prober.csproj ] && nohup dotnet tools/Prober/bin/Release/net10.0/prober.dll replay > "$(git rev-parse --git-dir)/prober-replay-last.log" 2>&1 < /dev/null &
-     exit 0
-     ```
-   - **Explore** when a feature lands or `status` shows a claim without probes: `/probe explore`, the
-     `prober` agent under `prober round`, whose time and claim cap the tool enforces. Never in CI. Its
-     probes land in its staging; `prober publish` moves them into the corpus, committed as `test:`.
-   - **Full sweep** on request (`/probe full`) or nightly, locally: the whole corpus replayed, the axes
-     derived again, then exploration up to the cap. A report, not a gate.
-   - A probe that found a bug becomes a test in the suite (steps 3 and 4); a dismissed finding is recorded with
-     `prober dismiss` and the reason. An intended difference a probe accepts cites the sentence of the
-     docs, the record, or the verified fact (`KB-NNN`, `design/knowledge/`) that makes it intended.
+7. **Hold what the documents promise** ([decision 112](design/adr/0112-the-prober-gives-way-to-valueranges-oracle-kit.md),
+   [test/oracles/README.md](test/oracles/README.md) for the files and how to add an oracle). A new public member,
+   or a new promise in `docs/` or a README, gets a claim in `test/oracles/claims.json`, quoted verbatim and naming
+   the test that holds it, or a waiver in `surface-waivers.json` that says why it needs none; a claim is reworded
+   with its document. A new oracle is registered in `oracles.json` with a seed, shown caught by
+   `oracles seeds <defect>`. A disagreement nobody fixes yet goes to `candidates.json` with its issue, never into
+   an assertion that hides it, and a combination a finding names joins `axes.md`.
 
 ## Releasing
 
-Before `git tag`, replay the whole probe corpus and run the gate, and show every probe's seeds caught (locally, a
-build per seed; without `--all` it runs only the probes changed since their seeds were last caught, decision 107):
-
-```bash
-dotnet tools/Prober/bin/Release/net10.0/prober.dll replay --all
-dotnet tools/Prober/bin/Release/net10.0/prober.dll gate
-dotnet tools/Prober/bin/Release/net10.0/prober.dll seeds --all
-```
-
-The gate never starts a model and needs nothing but the tracked corpus and a replay, so the release
-workflow runs it after `replay --all`, with `PROBE_STATE_DIR` in the job's temporary directory and
-`--since` the previous release's tag, reports its verdict in the job summary, and fails the release on a
-refusal. It refuses while a finding is open, a probe has not
-passed at its current identity, or a claim touched since the last tag has pairwise combinations no
-probe covers; it lists what is missing. Every obligation is met by a probe in the corpus, written by
-hand or by a round, or by a reviewed waiver in `tools/probe/corpus/waivers.json` (claim, reason,
-reviewer).
-
-**The gate binds from 2.2.0**
-([decision 97](design/adr/0097-2-2-0-is-a-consolidation-release-and-the-gate-binds.md)). Never tag
-2.2.0 or a later version over a refusal without the user's word, which is a waiver naming them as its
-reviewer. Answer a refusal with a probe, a fix or such a waiver, never by editing the workflow's step.
+Follow CONTRIBUTING's "Releasing". Its step 1 runs locally, before `git tag`, and is the one easy to skip:
+`oracles seeds` shows every seed caught, and `docs-query due --nuget` lists the competitor facts to re-read. On an
+arm64 Mac set `TYPEKIT_MSSQL_IMAGE=mcr.microsoft.com/azure-sql-edge:latest`, or the SQL Server oracles are `ERROR`
+([decision 117](design/adr/0117-a-seed-is-caught-against-a-passing-baseline.md)). A seed that is not caught is
+answered by a stronger oracle or a better seed, never by deleting it, and an `ERROR` by fixing the environment or
+the baseline, never by reading it as caught.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 19cb7e37..6422f6ab 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,64 +10,94 @@ A version's heading reads `## <version> — Unreleased` until the release is pre
 the release date. The release workflow refuses a tag whose section still says `Unreleased`, and the
 section is the GitHub release's notes.
 
-## 2.3.0 — Unreleased
+## 2.3.0 — 2026-10-29
+
+### Added
+
+- AspNetCore: `FaultResponse.WithoutFaultName()` answers a member without naming it: no `fault`, no `rule` and no member description in the problem, so two causes on one status look alike; the document says that status names no fault, and `IFaultFeature.NameWithheld` tells the host ([Faults a client must not tell apart](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.3.0/src/CodoMetis.TypeKit.AspNetCore/README.md#faults-a-client-must-not-tell-apart)).
+- `Result.CatchAsync` takes a call that returns a `ValueTask`, `stream.ReadAsync(buffer)` without `.AsTask()`; an `async` lambda binds as before ([An exception as an outcome](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.3.0/docs/result.md#an-exception-as-an-outcome)).
+- `TraverseAsync` on `Option<T>` and `Patch<T>`: an asynchronous check of an optional input or a patch field, with a token form; nothing is called without a value ([Collect many results](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.3.0/docs/result.md#collect-many-results)).
+- `Choose()`, `Choose(selector)`, `SequenceAsync` and `TraverseAsync` read an `IAsyncEnumerable<T>`, in order and without a list first; the token reaches the stream, nothing is read after the first error, and the enumerator is disposed however they stop ([Chain steps](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.3.0/src/CodoMetis.TypeKit/README.md#chain-steps)).
+- `Fault<TFault>.Cause`: `Fault.Of(reason, detail, exception)` keeps the exception underneath for your log; equality and `ToString()` leave it out, and `ToHttpResult()` hands it to the host as `IFaultFeature.Cause` and `FaultProblem<TFault>.Cause`, never into the problem ([What failed underneath](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.3.0/src/CodoMetis.TypeKit.AspNetCore/README.md#what-failed-underneath)).
+- Testing: every assertion works on a `Task` or `ValueTask` of what it checks, `await service.FindAsync(id).ShouldBeSome()`; a task that throws fails the test with its own exception, and an assertion left without `await` is reported (CMTK0003): through `ConfigureAwait` or `WaitAsync`, in a branch of a `?:`, `??` or `switch`, and handed to `Task.WhenAll`, `Task.Run` or `Task.WhenEach` and dropped, or to `Task.WhenAny` or `Task.WaitAny`, nested at any depth, or awaited in an `async` lambda whose `catch` throws again or can't catch it ([CodoMetis.TypeKit.Testing](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.3.0/src/CodoMetis.TypeKit.Testing/README.md)).
+- OpenAPI: `AddTypeKit(typeKit => typeKit.InlineValueObjects = true)` describes every value object in place by its underlying type's schema, in every position and in OpenAPI 3.1, 3.0 and 2.0, with no component of its own; closed sets keep theirs, and without the setting the document is unchanged ([Describe value objects as plain types](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.3.0/docs/aspnet-core.md#describe-value-objects-as-plain-types)).
+- Analyzers: CMTK0009 warns at `FirstOrNone`, `SingleOrNone` or `FirstOrError` on a query given a `Func` variable or a method group, which binds to the `IEnumerable<T>` overload and reads every row; a lambda at the call or an `Expression` stays silent ([A condition that reads every row](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.3.0/src/CodoMetis.TypeKit.Analyzers/README.md#a-condition-that-reads-every-row)).
+- Docs: the guides, the package READMEs, the changelog and the API of every run-time package as one site with a menu and search, built from the latest release ([caffeinatedcoder.github.io/CodoMetis.TypeKit](https://caffeinatedcoder.github.io/CodoMetis.TypeKit/)).
+- Analyzers: a validated value object without `Create` gets a code fix, **Add Create**, that writes a `Create` accepting every value, ready for your rules ([Add Create](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.3.0/src/CodoMetis.TypeKit.Analyzers/README.md#add-create)).
+- Docs: a walkthrough follows one orders service from request to response, saying what changes at each boundary; the service is a sample that CI builds from the packages and runs, and the answers the page states are checked against it ([Walkthrough](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.3.0/docs/walkthrough.md)).
+- Docs: the root README and the Generators README show, folded, the code the generators write for `OrderId`, `Email` and a closed set; a test holds each block to what the build emits ([Declare a value object](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.3.0/src/CodoMetis.TypeKit.Generators/README.md#declare-a-value-object)).
+- EF Core: queries, keys and round trips are tested on a real SQL Server, and the README says what differs there from memory: text compared ignoring case, Guids sorted by their last group, `decimal(18,2)` by default, a `TimeSpan` under a day, `Greatest` from compatibility level 160 ([On SQL Server](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.3.0/src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#on-sql-server)).
+
+### Changed
+
+- Analyzers: CMTK0003 now reports four forms that code built on 2.2.0 can contain, so your build can fail with it when you upgrade. They are a `Task.WhenAny` of `Result` tasks you don't hold (dropped, awaited, waited for or returned as a plain `Task`), a dropped `Task.WhenEach` of them, `Wait()` on a `?:`, `??` or `switch` of them, and an array of them written in a `Task.WaitAll` or `Task.WaitAny` call. Each one loses results that nobody reads: handle them, or discard them with `_ =`. An awaited `Task.WhenAny` of tasks you hold is no longer reported ([What a new version may change](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.3.0/src/CodoMetis.TypeKit.Analyzers/README.md#configuration)).
+- EF Core: a default value-object key over `ulong` gets a temporary value at `Add`, as a plain `ulong` key does, where it threw `OverflowException` on SQL Server and PostgreSQL; a `char` key configured `ValueGeneratedOnAdd()` gets a temporary `char` on SQL Server, not a character of a GUID string. HiLo and your own generator still come first. A compiled model made with `--nativeaot`, and a key you configure with `ValueObjectConverter` yourself, still throw ([Keys](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.3.0/src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys)).
+- Packages: nuget.org's Release Notes tab and Visual Studio's Updates tab show the version's section of this changelog, as plain text, where they showed a link to the file.
+- Changelog: a released version's links name its tag, `blob/v2.2.0/`, so its notes open the pages as they were released, not as they read on `main` today.
+- Comparison: SuperStrong.Types 1.0.0 joins the value-object table, Thinktecture.Runtime.Extensions is compared at 10.6.0 and LanguageExt at 5.0.0-beta-78, and the page's facts are re-read before every release ([How it compares](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.3.0/docs/comparison.md)).
+- README: introduces TypeKit by example, a one-line `OrderId`, a validated `Email`, an `Option` lookup and a `Result` chain, and thanks Vogen, which inspired the value objects; every README says what Metalama is where it first names it ([CodoMetis.TypeKit](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.3.0/README.md#what-you-get)).
+
+### Fixed
+
+- Generators: the aspects keep no compilation objects in static fields, which in an IDE that keeps Metalama's process across edits held every earlier compilation in memory.
+- Generators: a generated `TryParse(string?, IFormatProvider?, out)` ends at its `return`; the unreachable statements after it are gone from the woven code ([Reading the generated code](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.3.0/src/CodoMetis.TypeKit.Generators/README.md#reading-the-generated-code)).
 
 ## 2.2.0 — 2026-10-18
 
 ### Fixed
 
-- Generators: a value object over `string` implements `ISpanParsable`, as `string` does, and its span `Parse` runs `Create` as `Parse` does; a span `Parse` you wrote on one now fails the build (CMTK1011) ([What is generated](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.Generators/README.md#what-is-generated)).
-- EF Core: a query or a query filter that orders a value object with its own `CompareTo` through `EF.Functions.Greatest` or `Least`, or through a row-value comparison such as Npgsql's `EF.Functions.GreaterThan((o.Priority, o.Id), (priority, id))`, is refused and names the value object, where it used to order by the column ([Queries](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries)).
-- OpenAPI: a route, query or header parameter of a type a converter describes, such as a `decimal` under `DecimalStringJsonConverter`, is what ASP.NET writes without the converter: an OpenAPI 2.0 document builds, and a nullable one no longer admits `null` ([Parameters aren't JSON](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
-- OpenAPI: a query or header array of a type a converter describes, such as `decimal[]` or `decimal?[]` under `DecimalStringJsonConverter`, keeps its `items`, which are what ASP.NET writes for the element without the converter ([Parameters aren't JSON](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
-- OpenAPI: a value object over a type a converter describes, such as `Money : IValue<decimal>` under `DecimalStringJsonConverter`, is what ASP.NET writes for the underlying type without the converter as a route, query, header or form parameter and as a query or header array's items, no longer its JSON spelling; where value objects are components, such a parameter is written in place ([Parameters aren't JSON](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
-- OpenAPI: the default of a parameter of a type a converter describes, or of a value object over one, such as `[DefaultValue(typeof(decimal), "1.5")]` under `DecimalStringJsonConverter`, is written as ASP.NET writes it without the converter, `1.5`, not `"1.5"` ([Parameters aren't JSON](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
-- OpenAPI: a non-abstract `[JsonPolymorphic]` base's own branch (`{Base}Base`) describes its value objects, patches, closed sets and described types as the derived types' branches do, where it had `{}` and a list without `items`, in OpenAPI 3.1, 3.0 and 2.0 ([What the document says](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
-- OpenAPI: a list or dictionary of a nullable value object whose converter a described one replaces, such as `List<Amount?>` under a converter that writes cents, admits `null` in its elements where value objects are components ([A described type](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
-- OpenAPI: a nullable value-object property where value objects are components is the component or `null` wherever the underlying type's property admits `null`: get-only, a field, typed by a type parameter, under `[MaybeNull]` or `[DisallowNull]`, or without nullable annotations, where it was the bare reference; under OpenAPI 2.0 it's ASP.NET's `x-nullable` without the reference there too, as a settable one already was ([What the document says](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
-- OpenAPI: a nullable value object is its wrapped type at the same nullability in every position: an MVC `[FromBody] Quantity?` admits `null` inside its schema as `int?` does, and, where value objects are inlined, a query, header or form parameter no longer admits `null`, nor does a body, response or element of a nullable struct over `string` or `Uri` ([What the document says](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
-- OpenAPI: a nullable value object over an enum written by name lists `null` among its values as a route, query, header or form parameter, as the enum's own `DayOfWeek?` does; where value objects alone are inlined, a nullable one over an enum no longer puts a second null-or inside a body's or a response's, and as an element or a dictionary value keeps its type in OpenAPI 2.0 ([What the document says](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
-- OpenAPI: a problem response an endpoint declares as `application/json`, such as `Produces<ProblemDetails>(404)` or `[ProducesResponseType<ProblemDetails>(404)]`, describes `fault` and `rule` and names its problem types, and keeps its media type; so does one of a type derived from `ProblemDetails`, such as `ProducesValidationProblem(404)` ([A Result as a response](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.AspNetCore/README.md#a-result-as-a-response)).
-- EF Core: a key over a `Guid` or a `string` configured `ValueGeneratedOnAdd()` is generated as the plain key is, not as a random Guid: a version 7 Guid, or its text, on PostgreSQL, and a Guid sequential in SQL Server's order there ([Keys](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys)).
+- Generators: a value object over `string` implements `ISpanParsable`, as `string` does, and its span `Parse` runs `Create` as `Parse` does; a span `Parse` you wrote on one now fails the build (CMTK1011) ([What is generated](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.2.0/src/CodoMetis.TypeKit.Generators/README.md#what-is-generated)).
+- EF Core: a query or a query filter that orders a value object with its own `CompareTo` through `EF.Functions.Greatest` or `Least`, or through a row-value comparison such as Npgsql's `EF.Functions.GreaterThan((o.Priority, o.Id), (priority, id))`, is refused and names the value object, where it used to order by the column ([Queries](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.2.0/src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries)).
+- OpenAPI: a route, query or header parameter of a type a converter describes, such as a `decimal` under `DecimalStringJsonConverter`, is what ASP.NET writes without the converter: an OpenAPI 2.0 document builds, and a nullable one no longer admits `null` ([Parameters aren't JSON](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.2.0/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
+- OpenAPI: a query or header array of a type a converter describes, such as `decimal[]` or `decimal?[]` under `DecimalStringJsonConverter`, keeps its `items`, which are what ASP.NET writes for the element without the converter ([Parameters aren't JSON](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.2.0/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
+- OpenAPI: a value object over a type a converter describes, such as `Money : IValue<decimal>` under `DecimalStringJsonConverter`, is what ASP.NET writes for the underlying type without the converter as a route, query, header or form parameter and as a query or header array's items, no longer its JSON spelling; where value objects are components, such a parameter is written in place ([Parameters aren't JSON](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.2.0/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
+- OpenAPI: the default of a parameter of a type a converter describes, or of a value object over one, such as `[DefaultValue(typeof(decimal), "1.5")]` under `DecimalStringJsonConverter`, is written as ASP.NET writes it without the converter, `1.5`, not `"1.5"` ([Parameters aren't JSON](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.2.0/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
+- OpenAPI: a non-abstract `[JsonPolymorphic]` base's own branch (`{Base}Base`) describes its value objects, patches, closed sets and described types as the derived types' branches do, where it had `{}` and a list without `items`, in OpenAPI 3.1, 3.0 and 2.0 ([What the document says](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.2.0/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
+- OpenAPI: a list or dictionary of a nullable value object whose converter a described one replaces, such as `List<Amount?>` under a converter that writes cents, admits `null` in its elements where value objects are components ([A described type](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.2.0/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
+- OpenAPI: a nullable value-object property where value objects are components is the component or `null` wherever the underlying type's property admits `null`: get-only, a field, typed by a type parameter, under `[MaybeNull]` or `[DisallowNull]`, or without nullable annotations, where it was the bare reference; under OpenAPI 2.0 it's ASP.NET's `x-nullable` without the reference there too, as a settable one already was ([What the document says](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.2.0/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
+- OpenAPI: a nullable value object is its wrapped type at the same nullability in every position: an MVC `[FromBody] Quantity?` admits `null` inside its schema as `int?` does, and, where value objects are inlined, a query, header or form parameter no longer admits `null`, nor does a body, response or element of a nullable struct over `string` or `Uri` ([What the document says](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.2.0/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
+- OpenAPI: a nullable value object over an enum written by name lists `null` among its values as a route, query, header or form parameter, as the enum's own `DayOfWeek?` does; where value objects alone are inlined, a nullable one over an enum no longer puts a second null-or inside a body's or a response's, and as an element or a dictionary value keeps its type in OpenAPI 2.0 ([What the document says](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.2.0/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
+- OpenAPI: a problem response an endpoint declares as `application/json`, such as `Produces<ProblemDetails>(404)` or `[ProducesResponseType<ProblemDetails>(404)]`, describes `fault` and `rule` and names its problem types, and keeps its media type; so does one of a type derived from `ProblemDetails`, such as `ProducesValidationProblem(404)` ([A Result as a response](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.2.0/src/CodoMetis.TypeKit.AspNetCore/README.md#a-result-as-a-response)).
+- EF Core: a key over a `Guid` or a `string` configured `ValueGeneratedOnAdd()` is generated as the plain key is, not as a random Guid: a version 7 Guid, or its text, on PostgreSQL, and a Guid sequential in SQL Server's order there ([Keys](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.2.0/src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys)).
 
 ## 2.1.0 — 2026-10-15
 
 Still `net10.0` and Metalama 2026.1. What builds or runs differently, and what to write instead:
-[Migrating from 2.0 to 2.1](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/docs/migrating-to-2-1.md).
+[Migrating from 2.0 to 2.1](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/250f11ae0a838e3ad68e3c7cce091028b504ea25/docs/migrating-to-2-1.md).
 
 ### Added
 
-- **Decimals in one spelling**: `DecimalNumberJsonConverter` and `DecimalStringJsonConverter` write the smallest scale, keys included, and read either token ([JSON](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/docs/json.md#decimals-in-one-spelling)).
-- **Converters that say what they write**: `IDescribedJsonConverter` and `JsonSchemaDescriptions`; the schema exporter (`DescribedJsonSchema`) and `AddTypeKit()` describe them everywhere ([JSON](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/docs/json.md#describing-what-a-converter-writes)).
-- **The rule that refused**: `Fault.Of(reason).WithRule(member)` names an enum's or a closed set's member, written as the problem's `rule` and on `IFaultFeature` ([The rule that refused](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.AspNetCore/README.md#the-rule-that-refused)).
-- **`FaultKind.PreconditionFailed`** (412) and **`FaultKind.Malformed`** (400), answered with no mapping ([closed sets as faults](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.AspNetCore/README.md#a-closed-set-as-the-fault-type)).
-- **CMTK0014** (Warning): a `FaultKind` or `ConstructorAccessibility` that names no member, such as `(FaultKind)9` or `default` ([CMTK0014](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0014)).
-- **`AsOptionalText()`/`AsOptionalIdentifier()`**: a blank is no text, a hidden character still `Hidden` ([Written text](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/docs/text.md#required-and-optional)).
-- **Faults of several types**: `Fault<T1, T2>` and `Fault<T1, T2, T3>`, each answered as its type is mapped ([Faults of several types](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.AspNetCore/README.md#faults-of-several-types)).
-- **`WithoutFaults`** and `[WithoutFaults<T>]`: a route leaves out of its document the members it never answers with, and reporting one throws ([Leaving out what a route cannot answer](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.AspNetCore/README.md#leaving-out-what-a-route-cannot-answer)).
-- **CMTK1023** (Warning): a base record's `Equals`, `GetHashCode` or `IEquatable`, which the value object's equality no longer calls ([Build errors](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.Generators/README.md#build-errors)).
-- **`[Interface]`, `[Unsealed]`, `[ValueObject]`, `[ClosedSet]`, `[FlagsEnum]`, `[ReadOnlyStruct]`** (CMTK0010): six more kinds a type argument can be required to be ([Type constraints](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/docs/type-constraints.md#the-kind-of-a-type-argument)).
-- **CMTK0010 at the methods the compiler calls for you**: a `foreach`'s `GetEnumerator`, an `await`'s `GetAwaiter`, a `Deconstruct`, and a collection expression's `Add` or builder, for every attribute but 2.0's four ([Type constraints](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/docs/type-constraints.md)).
-- **`[Distinct]` and `[Unrelated]`** (CMTK0010): two type arguments that must differ, or must not derive from, implement or box to each other ([Type constraints](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/docs/type-constraints.md#two-parameters-apart)).
-- **One mapping for every fault set**: `AddFaultResponses()` by kind, or `AddFaultResponses(fault => …)` over `IFault`, for each set with no mapping of its own ([Every fault set at once](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.AspNetCore/README.md#every-fault-set-at-once)).
-- **Testing: `ShouldHold(reason)`** on `Fault<T1, T2>` and `Fault<T1, T2, T3>` hands back the fault it holds ([CodoMetis.TypeKit.Testing](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.Testing/README.md)).
+- **Decimals in one spelling**: `DecimalNumberJsonConverter` and `DecimalStringJsonConverter` write the smallest scale, keys included, and read either token ([JSON](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/docs/json.md#decimals-in-one-spelling)).
+- **Converters that say what they write**: `IDescribedJsonConverter` and `JsonSchemaDescriptions`; the schema exporter (`DescribedJsonSchema`) and `AddTypeKit()` describe them everywhere ([JSON](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/docs/json.md#describing-what-a-converter-writes)).
+- **The rule that refused**: `Fault.Of(reason).WithRule(member)` names an enum's or a closed set's member, written as the problem's `rule` and on `IFaultFeature` ([The rule that refused](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/src/CodoMetis.TypeKit.AspNetCore/README.md#the-rule-that-refused)).
+- **`FaultKind.PreconditionFailed`** (412) and **`FaultKind.Malformed`** (400), answered with no mapping ([closed sets as faults](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/src/CodoMetis.TypeKit.AspNetCore/README.md#a-closed-set-as-the-fault-type)).
+- **CMTK0014** (Warning): a `FaultKind` or `ConstructorAccessibility` that names no member, such as `(FaultKind)9` or `default` ([CMTK0014](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0014)).
+- **`AsOptionalText()`/`AsOptionalIdentifier()`**: a blank is no text, a hidden character still `Hidden` ([Written text](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/docs/text.md#required-and-optional)).
+- **Faults of several types**: `Fault<T1, T2>` and `Fault<T1, T2, T3>`, each answered as its type is mapped ([Faults of several types](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/src/CodoMetis.TypeKit.AspNetCore/README.md#faults-of-several-types)).
+- **`WithoutFaults`** and `[WithoutFaults<T>]`: a route leaves out of its document the members it never answers with, and reporting one throws ([Leaving out what a route cannot answer](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/src/CodoMetis.TypeKit.AspNetCore/README.md#leaving-out-what-a-route-cannot-answer)).
+- **CMTK1023** (Warning): a base record's `Equals`, `GetHashCode` or `IEquatable`, which the value object's equality no longer calls ([Build errors](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/src/CodoMetis.TypeKit.Generators/README.md#build-errors)).
+- **`[Interface]`, `[Unsealed]`, `[ValueObject]`, `[ClosedSet]`, `[FlagsEnum]`, `[ReadOnlyStruct]`** (CMTK0010): six more kinds a type argument can be required to be ([Type constraints](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/docs/type-constraints.md#the-kind-of-a-type-argument)).
+- **CMTK0010 at the methods the compiler calls for you**: a `foreach`'s `GetEnumerator`, an `await`'s `GetAwaiter`, a `Deconstruct`, and a collection expression's `Add` or builder, for every attribute but 2.0's four ([Type constraints](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/docs/type-constraints.md)).
+- **`[Distinct]` and `[Unrelated]`** (CMTK0010): two type arguments that must differ, or must not derive from, implement or box to each other ([Type constraints](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/docs/type-constraints.md#two-parameters-apart)).
+- **One mapping for every fault set**: `AddFaultResponses()` by kind, or `AddFaultResponses(fault => …)` over `IFault`, for each set with no mapping of its own ([Every fault set at once](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/src/CodoMetis.TypeKit.AspNetCore/README.md#every-fault-set-at-once)).
+- **Testing: `ShouldHold(reason)`** on `Fault<T1, T2>` and `Fault<T1, T2, T3>` hands back the fault it holds ([CodoMetis.TypeKit.Testing](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/src/CodoMetis.TypeKit.Testing/README.md)).
 
 ### Changed
 
 - The OpenAPI problem schema describes `rule` beside `fault`: regenerate clients.
-- A host whose endpoint answers two fault types that write one fault name logs a warning at startup naming both; 3.0.0 refuses it ([Faults of several types](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.AspNetCore/README.md#faults-of-several-types)).
+- A host whose endpoint answers two fault types that write one fault name logs a warning at startup naming both; 3.0.0 refuses it ([Faults of several types](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/src/CodoMetis.TypeKit.AspNetCore/README.md#faults-of-several-types)).
 - The new attributes in the `CodoMetis.TypeKit` namespace (`[ValueObject]`, `[Interface]`, …) can be ambiguous beside another library's of the same name (CS0104): qualify or alias one.
-- OpenAPI: in a host with controllers, a document whose MVC and minimal-API JSON options write a type differently is refused, naming what differs ([OpenAPI](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
+- OpenAPI: in a host with controllers, a document whose MVC and minimal-API JSON options write a type differently is refused, naming what differs ([OpenAPI](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
 
 ### Fixed
 
-- OpenAPI: a value object or closed set the JSON options write with a converter of their own is described as that converter says, or as ASP.NET writes it, not as its wrapped type ([OpenAPI](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
-- OpenAPI: a `Patch<T>` the serializer requires stays `required`; under `RespectRequiredConstructorParameters`, declare patches as `init` properties ([Merge patches](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/docs/merge-patches.md#required-constructor-parameters)).
+- OpenAPI: a value object or closed set the JSON options write with a converter of their own is described as that converter says, or as ASP.NET writes it, not as its wrapped type ([OpenAPI](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says)).
+- OpenAPI: a `Patch<T>` the serializer requires stays `required`; under `RespectRequiredConstructorParameters`, declare patches as `init` properties ([Merge patches](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/docs/merge-patches.md#required-constructor-parameters)).
 - OpenAPI: a `WithFaultStatus` on the builder `MapControllers()` returns reaches the document, as it reached the response.
 - OpenAPI: a problem response an endpoint declares itself (`ProducesProblem`, `[ProducesResponseType]`) describes `fault`, and names its problem types.
 - OpenAPI: an operation with fault responses lists every status ascending, the ones its endpoint declares itself among them; where an endpoint declares its own, the document's response order changes, so update snapshot tests.
 - Over a base record, a value object's equality is its wrapped value's, in a collection of the base too, whatever equality the base declares.
-- Under `ReferenceHandler.Preserve`, a value object over a type that could hold an `$id` throws `NotSupportedException` instead of writing a duplicate `$id` ([JSON](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.Generators/README.md#json)).
+- Under `ReferenceHandler.Preserve`, a value object over a type that could hold an `$id` throws `NotSupportedException` instead of writing a duplicate `$id` ([JSON](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.1.0/src/CodoMetis.TypeKit.Generators/README.md#json)).
 - A wrapped type's `Parse` whose result can't be assigned to it, or that takes its text by `ref`, or an abstract class's string constructor, no longer breaks the build; the value object has no parsing.
 - A value object over a NodaTime type parses after MVC bound a plain one first; it threw `TypeInitializationException` for the rest of the process.
 - OpenAPI: an MVC action binding a complex type from the route under a name of its own (`[FromRoute(Name = "id")]`) no longer fails the whole document with `AddTypeKit()`.
@@ -75,7 +105,7 @@ Still `net10.0` and Metalama 2026.1. What builds or runs differently, and what t
 ## 2.0.0 — 2026-10-14
 
 Still `net10.0` and Metalama 2026.1. What builds or runs differently, and what to write instead:
-[Migrating from 1.5 to 2.0](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/docs/migrating-to-2.md).
+[Migrating from 1.5 to 2.0](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/v2.0.0/docs/migrating-to-2.md).
 
 ### Breaking
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 8f94af09..4cc44779 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -20,9 +20,13 @@ a file-based app (`dotnet run tools/x.cs`) or a tool project under `tools/`, nev
 ([decision 92](design/adr/0092-repository-tooling-is-dotnet-and-ci-needs-no-ai.md)). Two tasks need one
 thing more each:
 
-- **Docker, running** (Docker Desktop, OrbStack, Colima), for the PostgreSQL round-trip tests, which
-  start a Linux container through Testcontainers. Without it those fail with
-  `DockerUnavailableException`, and every other test passes.
+- **Docker, running** (Docker Desktop, OrbStack, Colima), for the EF Core tests on PostgreSQL and SQL
+  Server and the SQL Server facts, which start a Linux container through Testcontainers and carry the
+  trait `Needs=Docker`. Without it those fail with `DockerUnavailableException`, and every other test
+  passes; `--filter-not-trait "Needs=Docker"` leaves them out. SQL Server's image is amd64 only: on an
+  arm64 Mac it starts under Rosetta, not under QEMU (OrbStack's default without Rosetta), so set
+  `TYPEKIT_MSSQL_IMAGE=mcr.microsoft.com/azure-sql-edge:latest` there, whose older engine runs natively;
+  CI runs SQL Server 2022.
 - **The platform's native toolchain** for the smoke test, which publishes two consumers with Native
   AOT, a web host and a console application with EF Core: Xcode's command-line tools on macOS
   (`xcode-select --install`), `clang` and `zlib1g-dev` on Debian and Ubuntu, MSVC's C++ build tools
@@ -70,7 +74,7 @@ test that passes both with and without the fix is not a regression test. See
 
 **A bug fix covers its siblings.** Name the class of input the defect lives in, and run the fix's test
 across that class's variant catalogue: every shape through which a type argument reaches a parameter
-(`test/CodoMetis.TypeKit.Analyzers.Tests/Variants/`), every declaration shape of `.claude/probe-axes.md`,
+(`test/CodoMetis.TypeKit.Analyzers.Tests/Variants/`), every declaration shape the generation tests vary (`test/oracles/axes.md`),
 every setting of the framework option the fix touches. Fix what fails there too, rather than leave it
 for the next review ([decision 95](design/adr/0095-a-fix-is-tested-across-its-input-class.md)).
 
@@ -88,6 +92,56 @@ string, an assembly-name prefix or a type-name list will be asked to replace it.
 **Prefer a loud failure to a silent one.** Where the package cannot do something correctly, it
 should fail the build or throw with an actionable message.
 
+## Issues and labels
+
+Use the **Bug** or **Enhancement** form. The bug form asks whether the failure is silent or loud, because a
+silent one, code that compiles and does less than it appears to, is the failure this repository exists to
+prevent.
+
+Each release is an `epic` issue with a milestone of its version (`2.3.0`), and its work is attached as
+sub-issues with the same milestone; a theme that spans releases is an `epic` without one. The plan stays in
+[design/roadmap.md](design/roadmap.md), which an epic links rather than copies
+([decision 109](design/adr/0109-work-is-tracked-as-labelled-issues-and-ci-checks-each-pull-request.md)).
+A maintainer sets the labels when triaging, and a pull request gets the same labels and milestone as the
+issue it closes:
+
+| Label | Means |
+|---|---|
+| `bug`, `enhancement`, `documentation`, `tests`, `chore` | The type. Exactly one |
+| `severity/critical` | Data loss, or silently wrong results, in common use |
+| `severity/high` | Wrong results, a crash or a failed build in a realistic scenario |
+| `severity/medium` | An inconsistency or a failure in a narrow scenario |
+| `severity/low` | A cosmetic, message or documentation-level difference |
+| `silent` | A bug that compiles or answers and does less than it appears to |
+| `breaking` | Changes a signature, a generated member, a wire form or a diagnostic's severity: needs a major |
+| `found-by/prober` | Found by the prober, before it was retired (decision 112); kept for the issues it labels |
+| `stacked` | Based on another open pull request: merge in order |
+| `epic` | A release or a theme; its sub-issues are the work |
+| `package/core`, `package/analyzers`, `package/generators`, `package/efcore`, `package/aspnetcore`, `package/serilog`, `package/testing` | The package it affects |
+| `area/option-result` | `Option`, `Result` and their extensions |
+| `area/value-objects` | The value-object contracts and what the aspects generate for them |
+| `area/json` | System.Text.Json wire forms, values and dictionary keys |
+| `area/aot` | Native AOT and trimming |
+| `area/parsing` | `Parse`, `TryParse`, formatting and the type converter |
+| `area/release` | Versioning, changelogs, packaging and release wiring |
+| `area/tooling` | The repository's tools: the verdict, the guard, docs-query, the oracle kit, the smoke test |
+
+A bug carries exactly one severity. CI's "PR hygiene" check reads each pull request into `main` or a release
+branch and fails it with no type label, a bug with no severity, `silent` on anything but a bug, no closing
+reference, a branch whose `<type>/` disagrees with its type label (`feat` is `enhancement`, `fix` is `bug`,
+`docs` is `documentation`, `test` is `tests`, the rest `chore`), a pull request into `release/<version>`
+without that milestone, or `breaking` on a release that is not a major. It turns green when you add what is
+missing, without a new commit. To run it on a saved payload:
+
+```bash
+dotnet build tools/PrHygiene -c Release
+dotnet tools/PrHygiene/bin/Release/net10.0/pr-hygiene.dll path/to/event.json
+```
+
+`Closes #12` closes an issue only when the pull request merges into `main`, and topics merge into a release
+branch, so close the issue by hand when your topic merges, with a comment linking the pull request. The
+release's pull request into `main` closes its epic.
+
 ## Pull requests
 
 Work for the next version goes into its release branch, `release/<version>` (`release/2.2.0`), not
@@ -96,7 +150,9 @@ Branch from it as `<type>/<slug>`, where the type is your main commit's (`feat/
 `build/…`), and open the PR against it. PRs are merged with a merge commit, never squashed or rebased:
 the design records cite commits by hash.
 
-- One concern per PR, with the reasoning in the description rather than only in the diff.
+- One concern per PR, closing one issue, with its labels and milestone ([above](#issues-and-labels)).
+  The description follows the template: `Closes #n`, then Problem, Change and Tests, with the reasoning
+  there rather than only in the diff.
 - Full suite green.
 - User-visible changes get a changelog entry.
 - Match the surrounding style. Comments explain *why*, especially where behaviour is load-bearing
@@ -116,23 +172,87 @@ the design records cite commits by hash.
 The packages share one version and are released together, only through
 `.github/workflows/release.yml` (see [SECURITY.md](SECURITY.md)).
 
-1. In `CHANGELOG.md`, replace `Unreleased` in the version's heading with today's date
-   (`## 1.0.0 — 2026-10-01`). The section becomes the GitHub release's notes.
-2. Move the rules in `src/CodoMetis.TypeKit.Analyzers/AnalyzerReleases.Unshipped.md` to
+1. Check what the documents rest on, locally:
+   - Show every oracle seed caught: `dotnet tools/Oracles/bin/Release/net10.0/oracles.dll seeds` (a baseline with
+     no seed, then a build of one project per seed; [test/oracles/README.md](test/oracles/README.md)). It exits 0
+     only when every oracle passes without its seed and fails with it. An `ERROR` (exit 4) is an environment or a
+     baseline to fix, such as a SQL Server container that never started, never a seed to accept.
+   - Re-read the competitor facts that are due: `dotnet tools/DocsQuery/bin/Release/net10.0/docs-query.dll due --nuget`
+     lists each `design/knowledge/` entry pinned `external` whose `verified:` date is more than six months old, or
+     whose pinned package NuGet has a later release of. Read each again at the latest release, from its source and
+     release notes, then move its pins and `verified:` date, or correct it, and correct `docs/comparison.md` with it:
+     the version a table names, the cells, and the page's list of dates. Check every TypeKit cell of the page
+     against the release branch, and name the version being released in TypeKit's columns and the root README's
+     Status. The listing runs by hand and never in CI, because a build mustn't fail just because time passed.
+2. In `CHANGELOG.md`, replace `Unreleased` in the version's heading with today's date
+   (`## 1.0.0 — 2026-10-01`). The section becomes the GitHub release's notes, and every package's
+   release notes on nuget.org: pack writes it into each nuspec as plain text, and fails while the
+   section is missing, empty or over nuget.org's 35,000 characters (`PackageReleaseNotesTests`).
+   Point the section's links at the version's tag, `blob/v<version>/` in place of `blob/main/`, so
+   they open the pages as they were released; `ChangelogTests` fails on a dated section that links
+   anything but its tag or a full commit id.
+3. Move the rules in `src/CodoMetis.TypeKit.Analyzers/AnalyzerReleases.Unshipped.md` to
    `AnalyzerReleases.Shipped.md`, under `## Release <version>`. Their ids and severities are public
-   contract from then on. `ChangelogTests` fails until steps 1 and 2 agree.
-3. Commit on the release branch, open its PR into `main`, and merge it with a merge commit. Tag that
-   merge commit and push the tag: `git tag v1.0.0 && git push origin v1.0.0`. The workflow checks the tag
-   against `Version` and the dated heading, runs the suite and the smoke test, and waits for approval
-   in the `nuget` environment before pushing. Delete the release branch once the tag is pushed.
-4. Afterwards: raise `Version` in `Directory.Build.props`, set `PackageValidationBaselineVersion` to
+   contract from then on. `ChangelogTests` fails until steps 2 and 3 agree. A release that ships no
+   rule gets the header alone, and loses it when the next release adds its own: the analyzer build
+   refuses any header after an empty release (RS2007).
+4. Commit on the release branch, open its PR into `main` (`chore` and `area/release`, the version's
+   milestone, `Closes #<epic>`), and merge it with a merge commit. Tag that
+   merge commit and push the tag: `git tag v1.0.0 && git push origin v1.0.0`. The workflow runs every
+   lane of the build workflow (Linux, Windows and macOS, the pack and both smoke tests), checks the tag
+   against `Version` and the dated heading, runs the suite and the smoke test on what it packs, and waits
+   for approval in the `nuget` environment before pushing. Delete the release branch once the tag is pushed.
+5. Afterwards: raise `Version` in `Directory.Build.props`, set `PackageValidationBaselineVersion` to
    the version just released, so ApiCompat guards the public surface from then on, and open a new
    `## <version> — Unreleased` section. `ChangelogTests` fails while the baseline trails the last
-   version the changelog dates. Once that is on `main`, cut the next `release/<version>` from it and
-   push it.
+   version the changelog dates, and pack while the new section is empty, so open it with its first
+   line. Once that is on `main`, cut the next `release/<version>` from it and
+   push it, and open the version's milestone and its `epic` issue.
 
 `workflow_dispatch` with `dry_run` (the default) rehearses everything but the push.
 
+## The docs site
+
+The guides in `docs/`, the root README, the package READMEs, the changelog and the API pages of the
+run-time packages are published to GitHub Pages, at
+[caffeinatedcoder.github.io/CodoMetis.TypeKit](https://caffeinatedcoder.github.io/CodoMetis.TypeKit/), by
+`.github/workflows/docs.yml` with DocFX
+([decision 116](design/adr/0116-the-docs-site-is-docfx-built-from-main.md)).
+
+- **Only `main` is published**, on every push to it, so the site always shows the latest release: the
+  release's PR into `main` publishes it. A release branch is never published.
+- **The pages are the files as they are.** Nothing copies or edits them for the site. The menu is
+  `site/toc.yml`: a new guide goes into the README's Documentation table and into the menu's Guides, in
+  the same order, and `DocsSiteTests` fails until both list it. A new run-time package goes into
+  `site/docfx.json`'s `metadata`, or into `DocsSiteTests.WithoutApiPages` with the reason it has no API
+  pages.
+- **Links are checked on every pull request** that touches what a page is built from. DocFX runs with
+  `--warningsAsErrors`, so a link to a missing page, heading or file fails the PR. A link to a file that
+  is not a page (`design/`, this file) becomes a GitHub address at the built commit, at build time
+  (`site/template/conceptual.extension.js`).
+- **Pages is configured** to deploy from GitHub Actions (Settings > Pages > Source), the one setting a
+  workflow cannot make.
+
+To build the site locally (`jq` reads the packages from `site/docfx.json`) and serve it at
+http://localhost:8080:
+
+```bash
+for assembly in $(jq -r '.metadata[].src[].files[]' site/docfx.json); do dotnet publish "src/${assembly%.dll}" -c Release -o site/obj/pub; done
+dotnet tool restore
+dotnet docfx site/docfx.json --warningsAsErrors --metadata _commit="$(git rev-parse HEAD)" --serve
+```
+
+**A second line**, such as `3.x` beside `2.x`, waits until two lines are supported at once. GitHub Pages
+serves one artifact per repository, so each deployment then carries every line:
+
+1. Build each line from its own branch into its own folder (`/2.x/`, `/3.x/`), with `main`'s
+   `site/` config, as a matrix in the build job; DocFX's `_appTitle` names the line.
+2. Assemble the folders into one artifact with a root `index.html` that redirects to the default line,
+   the latest release, and deploy that.
+3. Start the workflow from both branches. A push to the older line's branch cannot run a workflow that
+   branch lacks, so run on `workflow_run` of the build workflow there, and check that line out by name,
+   never by the triggering run's SHA. CodoMetis.ValueRanges' `docs.yml` does this for its two lines.
+
 ## AI-assisted development
 
 A substantial portion of this codebase was written with AI assistance, using
diff --git a/CodoMetis.TypeKit.slnx b/CodoMetis.TypeKit.slnx
index a53f69b2..429e119e 100644
--- a/CodoMetis.TypeKit.slnx
+++ b/CodoMetis.TypeKit.slnx
@@ -13,6 +13,7 @@
     <Project Path="test/CodoMetis.TypeKit.Analyzers.Tests/CodoMetis.TypeKit.Analyzers.Tests.csproj" />
     <Project Path="test/CodoMetis.TypeKit.BashGuard.Tests/CodoMetis.TypeKit.BashGuard.Tests.csproj" />
     <Project Path="test/CodoMetis.TypeKit.BuildVerdict.Tests/CodoMetis.TypeKit.BuildVerdict.Tests.csproj" />
+    <Project Path="test/CodoMetis.TypeKit.CiLanes.Tests/CodoMetis.TypeKit.CiLanes.Tests.csproj" />
     <Project Path="test/CodoMetis.TypeKit.AspNetCore.Tests/CodoMetis.TypeKit.AspNetCore.Tests.csproj" />
     <Project Path="test/CodoMetis.TypeKit.Conventions.Tests/CodoMetis.TypeKit.Conventions.Tests.csproj" />
     <Project Path="test/CodoMetis.TypeKit.DocsQuery.Tests/CodoMetis.TypeKit.DocsQuery.Tests.csproj" />
@@ -20,7 +21,8 @@
     <Project Path="test/CodoMetis.TypeKit.Facts/CodoMetis.TypeKit.Facts.csproj" />
     <Project Path="test/CodoMetis.TypeKit.Generators.Probes/CodoMetis.TypeKit.Generators.Probes.csproj" />
     <Project Path="test/CodoMetis.TypeKit.Generators.Tests/CodoMetis.TypeKit.Generators.Tests.csproj" />
-    <Project Path="test/CodoMetis.TypeKit.Prober.Tests/CodoMetis.TypeKit.Prober.Tests.csproj" />
+    <Project Path="test/CodoMetis.TypeKit.Oracles.Tests/CodoMetis.TypeKit.Oracles.Tests.csproj" />
+    <Project Path="test/CodoMetis.TypeKit.PrHygiene.Tests/CodoMetis.TypeKit.PrHygiene.Tests.csproj" />
     <Project Path="test/CodoMetis.TypeKit.Samples/CodoMetis.TypeKit.Samples.csproj" />
     <Project Path="test/CodoMetis.TypeKit.Serilog.Tests/CodoMetis.TypeKit.Serilog.Tests.csproj" />
     <Project Path="test/CodoMetis.TypeKit.Testing.Tests/CodoMetis.TypeKit.Testing.Tests.csproj" />
@@ -29,9 +31,11 @@
   <Folder Name="/tools/">
     <Project Path="tools/BashGuard/BashGuard.csproj" />
     <Project Path="tools/BuildVerdict/BuildVerdict.csproj" />
+    <Project Path="tools/CiLanes/CiLanes.csproj" />
     <Project Path="tools/ConsumerSmokeTest/ConsumerSmokeTest.csproj" />
     <Project Path="tools/DocsQuery/DocsQuery.csproj" />
-    <Project Path="tools/Prober/Prober.csproj" />
+    <Project Path="tools/Oracles/Oracles.csproj" />
+    <Project Path="tools/PrHygiene/PrHygiene.csproj" />
   </Folder>
   <Folder Name="/benchmarks/">
     <Project Path="benchmarks/CodoMetis.TypeKit.Benchmarks/CodoMetis.TypeKit.Benchmarks.csproj" />
diff --git a/Directory.Build.props b/Directory.Build.props
index 3f40888e..4883433f 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -4,7 +4,6 @@
         <Authors>CaffeinatedCoder</Authors>
         <Copyright>Copyright (c) 2026 CaffeinatedCoder</Copyright>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
-        <PackageReleaseNotes>https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/CHANGELOG.md</PackageReleaseNotes>
         <PackageProjectUrl>https://github.com/CaffeinatedCoder/CodoMetis.TypeKit</PackageProjectUrl>
         <RepositoryUrl>https://github.com/CaffeinatedCoder/CodoMetis.TypeKit</RepositoryUrl>
         <RepositoryType>git</RepositoryType>
diff --git a/Directory.Packages.props b/Directory.Packages.props
index bcebbd99..699da861 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -50,14 +50,15 @@
     <PackageVersion Include="NodaTime.Serialization.SystemTextJson" Version="1.4.0" />
     <!--
             The EF satellite's tests: SQLite for the model, Npgsql for SQL and the round trips, SQL Server
-            for its model alone (key generation, built without a server), and EF's design-time services
-            to write the migration snapshot a model is compared with.
+            for its model, the round trips and the query catalogue, PostgreSQL and SQL Server each in a
+            container, and EF's design-time services to write the migration snapshot a model is compared with.
         -->
     <PackageVersion Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.12" />
     <PackageVersion Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.12" />
     <PackageVersion Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="10.0.3" />
     <PackageVersion Include="Microsoft.EntityFrameworkCore.SqlServer" Version="10.0.12" />
     <PackageVersion Include="Testcontainers.PostgreSql" Version="4.16.0" />
+    <PackageVersion Include="Testcontainers" Version="4.16.0" />
     <!-- The Serilog README's sample writes to the console, as a reader's setup would. -->
     <PackageVersion Include="Serilog.Sinks.Console" Version="6.1.1" />
     <!-- The ASP.NET Core satellite's tests: a probe host whose OpenAPI document they read. -->
diff --git a/README.md b/README.md
index f4204584..04d5db6f 100644
--- a/README.md
+++ b/README.md
@@ -9,51 +9,38 @@ Strong types for .NET 10, with one set of rules from the request to the database
 
 ## What you get
 
-**Value objects in one line**
-- **Declare it, the rest is generated.** `OrderId : IValue<Guid>` gets its constructor, equality,
-  comparison, parsing, formatting, JSON converter and type converter at compile time.
-- **Validation in one place.** Write `Create` once, and JSON, route binding, parsing and `TryFrom`
-  all run it. Nothing skips it by accident.
-- **A drop-in for primitives.** The JSON, the database column and the OpenAPI schema are the same as
-  the underlying type's. It works for strings, numbers, `Guid`, dates, enums, `Uri`, NodaTime types
-  and your own types.
-- **Smart enums.** One line per member gives you parsing by name, JSON as the name, an OpenAPI string
-  enum and a text column. `Match` breaks the build when a member is added and not handled.
-
-**Option and Result you can't misuse**
-- No `.Value` to forget a check on. A `default` value is a compile error, and an ignored `Result`
-  is flagged.
-- Pipelines, async chains, collecting many results, and `Result.Catch` for code that throws.
-- Neither type serializes silently to `{}`. The serializer refuses them, so a missing value can't
-  reach the wire unnoticed.
-
-**ASP.NET Core and EF Core, with nothing to register per type**
-- **EF Core:** value objects map to plain columns and keys, identity keys included, and `.Value` in
-  a LINQ query becomes plain SQL.
-- **ASP.NET Core:** return a `Result` from an endpoint and its errors become problem-details
-  responses. The OpenAPI document shows each value object as its underlying type, plus the error
-  responses an endpoint can return.
-- **JSON Merge Patch:** `Patch<T>` tells "absent", "null" and "a value" apart.
-
-**Mistakes caught at build time**
-- Analyzers flag default values, ignored results, bypassed validation, and generic type arguments
-  that break declared constraints (`[Sealed]`, `[Distinct]` and more). They also run in Razor files.
-- A declaration that can't be generated fails the build with its name on it, instead of compiling
-  into an empty type.
-
-**Ready for production**
-- **Native AOT and trimming** in every run-time package, checked in CI by publishing real apps as
-  native binaries ([what it asks of you](docs/native-aot.md)).
-- **Secrets stay out of logs.** Error messages never quote the input, and Serilog logs a value
-  object as it prints itself.
-- **Test assertions** for `Option`, `Result` and `Patch<T>`, with no dependency on a test framework.
-- **Take only what you need.** The `Option`/`Result` package brings no code generator with it.
+TypeKit is built around three things:
+
+- **Value objects, generated for you.** You declare an `OrderId` in one line, and the rest is
+  written at compile time.
+- **`Option`** for a value that may be missing.
+- **`Result`** for an operation that can fail.
+
+The value objects work with System.Text.Json, EF Core and ASP.NET Core, with nothing to register per
+type.
+
+### Value objects
 
-Two value objects, the second one validated:
+An order id is one line:
 
 ```csharp
 public readonly partial record struct OrderId : IValue<Guid>;
+```
+
+When you build, the generators fill in everything an `OrderId` needs to stand in for a `Guid`:
+
+- **Make one and read it back** with `From` and `Value`. Two ids are equal when their `Guid`s are.
+- **Sort and compare them** through `IComparable` and the `<`, `<=`, `>` and `>=` operators.
+- **Bind one from a route or a query string,** because `Parse`, `TryParse` and `ToString` are there,
+  span forms included.
+- **Send it and store it** through its JSON converter and its type converter.
+
+The JSON, the database column and the OpenAPI schema are the same as the underlying type's. So you
+can change a `Guid` property to an `OrderId` without changing your API or your tables.
 
+When a value has rules, you write them once, in `Create`:
+
+```csharp
 public readonly partial record struct Email : IValidatedValue<Email, string, EmailFault>
 {
     public static Result<Email, EmailFault> Create(string value) =>
@@ -61,105 +48,146 @@ public readonly partial record struct Email : IValidatedValue<Email, string, Ema
 }
 ```
 
-That is the whole declaration. The generators add the field, the constructor, `Value`, the
-factories, value equality, a JSON converter, `IParsable`, `IFormattable`, `IComparable`, a
-`TypeConverter` and the companions that make `.Value` work inside an EF Core query. Every way into
-`Email`, whether JSON, a route parameter or a call to `TryFrom`, applies the one `Create` you wrote.
-A value object can wrap a primitive, a `Guid`, a date, an enum, a `Uri`, a NodaTime type or a type of
-your own, and it can be declared inside another type.
+JSON, route binding, parsing and the generated `TryFrom` all run your `Create`. So an `Email` that
+breaks your rules can't get in through any of them. A value object can wrap a string, a number, a
+`Guid`, a date, an enum, a `Uri`, a NodaTime type or a type of your own.
 
-A closed set, the smart enum, is declared the same way, one line per member:
+Then you create one in the way that fits the input:
 
 ```csharp
-public sealed partial class OrderStatus : IClosedSet<OrderStatus>
-{
-    public static readonly OrderStatus Open = new();
-    public static readonly OrderStatus Shipped = new();
-    public static readonly OrderStatus Cancelled = new();
-}
+var id = OrderId.New();                                   // a version 7 Guid
+
+Result<Email, EmailFault> created = Email.Create(input);  // the fault says which rule refused it
+Option<Email> maybe = Email.TryFrom(input);               // is it valid?
+Email known = Email.FromKnownGood("ops@example.com");     // a literal you vouch for; throws otherwise
+
+JsonSerializer.Serialize(known);                          // "ops@example.com"
+JsonSerializer.Deserialize<Email>("\"nobody\"");          // JsonException naming Email and NoAt, never the text
+Email.Parse("ops@example.com", null);                     // IParsable, so it binds as a route or query parameter
 ```
 
-The generators add `All`, parsing by name, JSON as the name, an OpenAPI string enum and a text
-column in EF Core, with nothing registered per set. `Match` takes one required delegate per member,
-so a member added later fails every call until it is handled.
+- **`Create`** when you want to know which rule failed.
+- **`TryFrom`** when yes or no is enough.
+- **`FromKnownGood`** for a value you vouch for, such as a literal. It throws if you were wrong.
 
-The base package also gives you:
+A struct always has a public parameterless constructor, and C# won't let you take it away. So the
+analyzers make `new OrderId()` and `default(OrderId)` build errors (CMTK0001). An array created with
+a length, whose slots all start out as `default`, gets a warning (CMTK0005).
 
-- **`Patch<T>`**, a field of a JSON Merge Patch: absent, null or a value.
-- **`Result.Catch`**, which turns an exception into a result.
-- **`AsText()` and `AsIdentifier()`**, which check text a person wrote and a value another system
-  issued.
-- **`[Sealed]`, `[Concrete]` and `[RequireParameterlessConstructor]`**, constraints that C# has no
-  `where` clause for. The analyzers check them.
+<details>
+<summary>What the generators write for <code>OrderId</code>, trimmed</summary>
 
-## Packages
+<!-- not compiled: generated code for Root/IntroSamples.cs, trimmed (GeneratedCodeBlockTests) -->
+```csharp
+public readonly partial record struct OrderId : IValue<Guid>, IValueObject<OrderId, Guid>, IParsable<OrderId>, IComparable<OrderId>
+{
+    private readonly Guid _value;
 
-| Package | What it does | Metalama |
-|---|---|---|
-| [CodoMetis.TypeKit](src/CodoMetis.TypeKit/README.md) | `Option<T>`, `Result<T, TError>` and `Result<TError>`, the interfaces value objects are built on, `Patch<T>`, and the text guards `AsText()` and `AsIdentifier()`. Brings the analyzers that check them | no |
-| [CodoMetis.TypeKit.Analyzers](src/CodoMetis.TypeKit.Analyzers/README.md) | Build-time checks, CMTK0001 to CMTK0014. They arrive with the base package and run in Razor components too. They flag:<br>- a `default` value object, `Option` or `Result`, written in your code or handed out by `FirstOrDefault` and its kind<br>- a value object nothing generates<br>- an ignored result<br>- skipped validation<br>- a comparison of two value objects' values<br>- a type argument that breaks `[Abstract]`, `[Sealed]`, `[Record]`, `[Concrete]`, `[Interface]`, `[Unsealed]`, `[ValueObject]`, `[ClosedSet]`, `[FlagsEnum]` or `[ReadOnlyStruct]` on its parameter, or two that `[Distinct]` or `[Unrelated]` keep apart<br>- a type without the constructor its host will look for<br>- a closed-set `Match` bound by position, and a closed-set member written after it was named<br>- a `FaultKind` or `ConstructorAccessibility` that names no member | no |
-| [CodoMetis.TypeKit.Generators](src/CodoMetis.TypeKit.Generators/README.md) | Generates your value objects at compile time. Add it to the project that declares them | yes |
-| [CodoMetis.TypeKit.EntityFrameworkCore](src/CodoMetis.TypeKit.EntityFrameworkCore/README.md) | Maps value objects to columns with nothing to register per type, and makes `.Value` work in LINQ | no |
-| [CodoMetis.TypeKit.AspNetCore](src/CodoMetis.TypeKit.AspNetCore/README.md) | Shows value objects in the OpenAPI document with the schema of their underlying type. Returns a `Result` as the response, and a fault as problem details | no |
-| [CodoMetis.TypeKit.Serilog](src/CodoMetis.TypeKit.Serilog/README.md) | Logs value objects as what they print, also where Serilog destructures them, so a value masked by its `ToString()` stays masked | no |
-| [CodoMetis.TypeKit.Testing](src/CodoMetis.TypeKit.Testing/README.md) | Test assertions for `Option`, `Result` and `Patch<T>`. They hand back the value or the error, and fail saying what the outcome was. No test framework needed | no |
+    private OrderId(Guid value)
+    {
+        _value = value;
+    }
 
-Take only what you need. If you only want `Option` and `Result`, the base package brings no code
-generator with it. You take Metalama on once, on purpose, by adding `CodoMetis.TypeKit.Generators` to
-your domain project.
+    public Guid Value
+    {
+        get { return _value; }
+    }
 
-The EF Core and ASP.NET Core packages work at run time through the interfaces. So a host that maps
-value objects from a referenced domain assembly needs no generator itself.
+    public static OrderId From(Guid value)
+    {
+        return new OrderId(value);
+    }
 
-## Quick start
+    public int CompareTo(OrderId other)
+    {
+        return Comparer<Guid>.Default.Compare(Value, other.Value);
+    }
 
-Add the generators to your domain project, which brings the base package along. Add the EF Core
-package to your data project, if you have one.
+    public override readonly string ToString()
+    {
+        return ToString(null, CultureInfo.InvariantCulture);
+    }
 
-```bash
-dotnet add package CodoMetis.TypeKit.Generators      # the domain project: brings CodoMetis.TypeKit along
-dotnet add package CodoMetis.TypeKit.EntityFrameworkCore   # the data project, if there is one
+    // Also: Parse and TryParse, the formatting interfaces, the comparison operators,
+    // a JSON converter and a type converter, each nested in the type.
+}
 ```
 
-Declare a value object with its validation:
+The [Generators README](src/CodoMetis.TypeKit.Generators/README.md#what-is-generated) lists every
+member, and says how to read the full generated code of your own types.
 
-```csharp
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.ValueObjects;
+</details>
 
-public enum EmailFault { Blank, NoAt }
+### Option
 
-public readonly partial record struct Email : IValidatedValue<Email, string, EmailFault>
-{
-    public static Result<Email, EmailFault> Create(string value)
-    {
-        if (string.IsNullOrWhiteSpace(value)) return Result.Error(EmailFault.Blank);
-        if (!value.Contains('@')) return Result.Error(EmailFault.NoAt);
+An `Option<T>` holds a value or nothing. Use it instead of `null` where a value may be missing:
 
-        return new Email(value.Trim());
-    }
-}
+```csharp
+Option<Customer> found = customers.FirstOrNone(c => c.Email == email);
+
+string greeting = found.Match(
+    customer => $"Welcome back, {customer.Email}",
+    () => "Please sign up first");
 ```
 
-Then use it:
+What it gives you:
+
+- **No `.Value` to forget a check on.** You reach the value through `Match`, `TryGetValue` and the
+  other members, and each one asks what should happen when there is nothing.
+- **No null in disguise.** `Option.Some(null)` throws, and writing `default(Option<T>)` fails the
+  build (CMTK0001).
+
+### Result
+
+A `Result<T, TError>` holds a value, or an error of a type you choose. Use it for failures you expect,
+such as invalid input, instead of an exception:
 
 ```csharp
-var id = OrderId.New();                                   // a version 7 Guid
+Result<Customer, SignUpFault> signedUp = Email.Create(input)
+    .MapError(_ => SignUpFault.InvalidEmail)
+    .Ensure(email => !customers.Exists(c => c.Email == email), SignUpFault.EmailTaken)
+    .Map(email => new Customer(CustomerId.New(), email));
+
+string reply = signedUp.Match(
+    customer => $"Welcome, {customer.Email}",
+    fault => $"Sign-up failed: {fault}");
+```
 
-Result<Email, EmailFault> created = Email.Create(input);  // the fault says which rule refused it
-Option<Email> maybe = Email.TryFrom(input);               // is it valid?
-Email known = Email.FromKnownGood("ops@example.com");     // a literal you vouch for; throws otherwise
+Each step runs only while everything before it succeeded. The first error skips the rest and ends up
+in `Match`.
 
-string reply = created.Match(
-    email => $"Welcome, {email}",
-    fault => $"Please check the address ({fault})");
+What it gives you:
 
-JsonSerializer.Serialize(known);                          // "ops@example.com"
-JsonSerializer.Deserialize<Email>("\"nobody\"");          // JsonException naming Email and NoAt, never the text
-Email.Parse("ops@example.com", null);                     // IParsable, so it binds as a route or query parameter
+- **The error is part of the signature.** Whoever calls your method sees what can go wrong, and has
+  to handle it to get the value.
+- **A result you ignore is reported** (CMTK0003).
+- **Errors become HTTP responses.** Return `ToHttpResult()` from an endpoint, and an error becomes
+  a problem-details response.
+- **Exceptions become results** where you want them to, with `Result.Catch`.
+
+`Option` and `Result` never end up on the wire by accident: System.Text.Json rejects both, rather
+than writing `{}`.
+
+### Smart enums
+
+A closed set is an enum whose members can carry data. You declare it one line per member:
+
+```csharp
+public sealed partial class OrderStatus : IClosedSet<OrderStatus>
+{
+    public static readonly OrderStatus Open = new();
+    public static readonly OrderStatus Shipped = new();
+    public static readonly OrderStatus Cancelled = new();
+}
 ```
 
-Set up EF Core and OpenAPI once, for every value object:
+You get `All`, parsing by name, JSON as the name, an OpenAPI string enum and a text column in EF
+Core. `Match` takes one required delegate per member, so a member added later fails every call until
+you handle it ([Closed sets](docs/closed-sets.md)).
+
+### EF Core and ASP.NET Core
+
+You set them up once, for every value object:
 
 ```csharp
 services.AddDbContext<ShopDb>(options => options.UseNpgsql(connectionString).UseTypeKit());
@@ -169,15 +197,41 @@ db.Customers.Where(c => c.Email.Value.EndsWith("@example.com"));        // WHERE
 services.AddOpenApi(options => options.AddTypeKit());                    // OrderId: {"type":"string","format":"uuid"}
 ```
 
+Value objects map to plain columns and keys, identity keys included, and `.Value` in a LINQ query
+becomes plain SQL ([EF Core](docs/ef-core.md)). The OpenAPI document shows each value object as its
+underlying type, plus the error responses an endpoint can return ([ASP.NET Core](docs/aspnet-core.md)).
+
+### And also
+
+- **JSON Merge Patch.** `Patch<T>` tells "absent", "null" and "a value" apart
+  ([Merge patches](docs/merge-patches.md)).
+- **Checks for written text.** `AsText()` and `AsIdentifier()` check text a person typed and an id
+  another system issued ([Written text](docs/text.md)).
+- **Mistakes caught at build time.** Analyzers flag default values, ignored results, skipped
+  validation, and type arguments that break constraints C# can't express (`[Sealed]`, `[Distinct]`
+  and more). They also run in Razor files. A declaration that can't be generated fails the build with
+  its name on it.
+- **Native AOT and trimming** in every run-time package, checked in CI by publishing real apps as
+  native binaries ([Native AOT](docs/native-aot.md)).
+- **Secrets stay out of logs.** Error messages never quote the input, and Serilog logs a value object
+  as it prints itself ([Logging and secrets](docs/logging-and-secrets.md)).
+- **Test assertions** for `Option`, `Result` and `Patch<T>`, with no dependency on a test framework
+  ([Testing](docs/testing.md)).
+
 ## Documentation
 
-The pages below are guides, one topic each, built around examples. The package READMEs above are
-the reference for each package: what it adds, how to set it up, and the rules it follows. Every
+The pages below are guides, one topic each, built around examples. The package READMEs, listed
+under [Packages](#packages), are the reference for each package: what it adds, how to set it up, and the rules it follows. Every
 exception message and analyzer help link points into them. Every C# block in the guides and the
 READMEs is compiled, and the outputs it states are tested.
 
+You can also read all of it as one website, with a menu, search and the API of every run-time
+package: [caffeinatedcoder.github.io/CodoMetis.TypeKit](https://caffeinatedcoder.github.io/CodoMetis.TypeKit/).
+It shows the latest release.
+
 | Page | Covers |
 |---|---|
+| [Walkthrough](docs/walkthrough.md) | One orders service from request to response: value objects bound, validated, stored, queried, patched, logged and described, and what changes at each boundary |
 | [Value objects](docs/value-objects.md) | Declare one, pick a struct or a class, validate input, design its errors, pick the right factory, write your own members, generic code |
 | [Closed sets](docs/closed-sets.md) | Smart enums that carry data: declare one, handle every member with `Match`, send it as JSON, store it as a text column, read it from configuration, use one as an error type, and when an enum is still the right choice |
 | [Option](docs/option.md) | A value or nothing: create one, get the value out, combine options, convert at the boundary, and every public member |
@@ -195,6 +249,34 @@ READMEs is compiled, and the outputs it states are tested.
 | [Migrating from 1.5 to 2.0](docs/migrating-to-2.md) | Move a project from 1.5 to 2.0: dropped results as build errors, queries that now run in the database or throw, names 2.0 adds, fault responses, Native AOT |
 | [How it compares](docs/comparison.md) | When another library fits better, and feature tables against the value-object, result and smart-enum libraries, versioned and dated |
 
+## Packages
+
+One package uses [Metalama](https://postsharp.net/metalama), a framework that generates C# code at
+compile time from templates written in C#. TypeKit's generators are built on it. The last column
+shows which package brings it.
+
+| Package | What it does | Metalama |
+|---|---|---|
+| [CodoMetis.TypeKit](src/CodoMetis.TypeKit/README.md) | `Option<T>`, `Result<T, TError>` and `Result<TError>`, the interfaces value objects are built on, `Patch<T>`, and the text guards `AsText()` and `AsIdentifier()`. Brings the analyzers that check them | no |
+| [CodoMetis.TypeKit.Analyzers](src/CodoMetis.TypeKit.Analyzers/README.md) | Build-time checks, CMTK0001 to CMTK0014. They arrive with the base package and run in Razor components too. They flag:<br>- a `default` value object, `Option` or `Result`, written in your code or handed out by `FirstOrDefault` and its kind<br>- a value object nothing generates<br>- an ignored result<br>- skipped validation<br>- a comparison of two value objects' values<br>- a type argument that breaks `[Abstract]`, `[Sealed]`, `[Record]`, `[Concrete]`, `[Interface]`, `[Unsealed]`, `[ValueObject]`, `[ClosedSet]`, `[FlagsEnum]` or `[ReadOnlyStruct]` on its parameter, or two that `[Distinct]` or `[Unrelated]` keep apart<br>- a type without the constructor its host will look for<br>- a closed-set `Match` bound by position, and a closed-set member written after it was named<br>- a `FaultKind` or `ConstructorAccessibility` that names no member | no |
+| [CodoMetis.TypeKit.Generators](src/CodoMetis.TypeKit.Generators/README.md) | Generates your value objects at compile time. Add it to the project that declares them | yes |
+| [CodoMetis.TypeKit.EntityFrameworkCore](src/CodoMetis.TypeKit.EntityFrameworkCore/README.md) | Maps value objects to columns with nothing to register per type, and makes `.Value` work in LINQ | no |
+| [CodoMetis.TypeKit.AspNetCore](src/CodoMetis.TypeKit.AspNetCore/README.md) | Shows value objects in the OpenAPI document with the schema of their underlying type. Returns a `Result` as the response, and a fault as problem details | no |
+| [CodoMetis.TypeKit.Serilog](src/CodoMetis.TypeKit.Serilog/README.md) | Logs value objects as what they print, also where Serilog destructures them, so a value masked by its `ToString()` stays masked | no |
+| [CodoMetis.TypeKit.Testing](src/CodoMetis.TypeKit.Testing/README.md) | Test assertions for `Option`, `Result` and `Patch<T>`. They hand back the value or the error, and fail saying what the outcome was. No test framework needed | no |
+
+Take only what you need. If you only want `Option` and `Result`, the base package brings no code
+generator with it. You take Metalama on once, on purpose, by adding `CodoMetis.TypeKit.Generators` to
+your domain project:
+
+```bash
+dotnet add package CodoMetis.TypeKit.Generators      # the domain project: brings CodoMetis.TypeKit along
+dotnet add package CodoMetis.TypeKit.EntityFrameworkCore   # the data project, if there is one
+```
+
+The EF Core and ASP.NET Core packages work at run time through the interfaces. So a host that maps
+value objects from a referenced domain assembly needs no generator itself.
+
 ## What TypeKit guarantees
 
 - **No `.Value` on `Option` or `Result`.** You reach the content through `Match`, `TryGetValue` and
@@ -266,8 +348,8 @@ Good libraries exist for both halves of TypeKit. TypeKit fits when you want:
 
 [How it compares](docs/comparison.md) says what to choose instead when TypeKit doesn't meet your
 need. It also has detailed tables against Vogen, Thinktecture.Runtime.Extensions, StronglyTypedId,
-LanguageExt, CSharpFunctionalExtensions, ErrorOr, Ardalis.SmartEnum and Intellenum, with versions
-and dates.
+SuperStrong.Types, LanguageExt, CSharpFunctionalExtensions, ErrorOr, Ardalis.SmartEnum and
+Intellenum, with versions and dates.
 
 ## Built with Metalama
 
@@ -293,7 +375,7 @@ your projects. Thanks to the Metalama team.
 
 ## Status
 
-2.1.0 is the current version. 1.0.0, released on 28 September 2026, was the first.
+2.3.0 is the current version. 1.0.0, released on 28 September 2026, was the first.
 [Migrating from 2.0 to 2.1](docs/migrating-to-2-1.md) lists what builds or runs differently since 2.0,
 and [Migrating from 1.5 to 2.0](docs/migrating-to-2.md) what changed since 1.5.
 
@@ -304,7 +386,7 @@ one.
 
 [CHANGELOG.md](CHANGELOG.md) lists what each version changed. The design notes, the decision records
 and the roadmap are under [design/](design/plan.md). The measurements that decided the design are in
-[spikes/](spikes/).
+[spikes/](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/tree/main/spikes).
 
 ## Building
 
@@ -323,6 +405,14 @@ Docker. Everything else runs without it.
 Much of the code was written with AI assistance, under the maintainer's direction and review.
 [CONTRIBUTING.md](CONTRIBUTING.md#ai-assisted-development) says what that does and doesn't mean.
 
+## Acknowledgements
+
+TypeKit's value objects owe a great deal to [Vogen](https://github.com/SteveDunn/Vogen) by Steve
+Dunn. Much of how they are generated started as an idea from Vogen. Thank you, Steve.
+
+The generators themselves run on [Metalama](https://postsharp.net/metalama), and
+[Built with Metalama](#built-with-metalama) says what that makes possible.
+
 ## License
 
 [MIT](LICENSE)
diff --git a/design/adr/0109-work-is-tracked-as-labelled-issues-and-ci-checks-each-pull-request.md b/design/adr/0109-work-is-tracked-as-labelled-issues-and-ci-checks-each-pull-request.md
new file mode 100644
index 00000000..2844b560
--- /dev/null
+++ b/design/adr/0109-work-is-tracked-as-labelled-issues-and-ci-checks-each-pull-request.md
@@ -0,0 +1,88 @@
+# 0109. Work is tracked as labelled issues under a release epic, and CI checks each pull request's labels, milestone, branch and issue link
+
+Date: 2026-10-18
+Status: accepted
+
+Context: 2026-10-18, after the release of 2.2.0. The repository had 66 pull requests and not one issue: none
+of the 66 descriptions closed an issue, and the repository had no milestone and no label beyond GitHub's
+defaults and Dependabot's two. Work was planned in [the roadmap](../roadmap.md) and recorded in the commits,
+the decision records and [the fix history](../fix-history.md), so what was open, what a pull request was for
+and which release it belonged to could be read only from files and branch names. CodoMetis.ValueRanges, the
+sibling library, tracks its work as labelled issues and has a CI check that holds each pull request to its
+labels and its issue; this repository adopts the same scheme, fitted to its own branches (decision 94) and
+its own tooling (decision 92).
+
+## Decision
+
+**Work is tracked as issues.** A bug, an enhancement, a follow-up, a finding from a review or a probe: each is
+an issue, opened before the work starts, through one of the forms in `.github/ISSUE_TEMPLATE/` (Bug,
+Enhancement, Epic; no blank issues, and a security report goes to the private advisory form).
+
+**A release is an epic.** Each version has an `epic` issue and a milestone of the same name (`2.3.0`); its work
+is attached as native sub-issues and carries the milestone. A theme that spans releases is an `epic` without a
+milestone. [The roadmap](../roadmap.md) stays the plan and the decision records the reasons: an epic links its
+section of the roadmap rather than copying it, and there is no roadmap issue.
+
+**Labels, on issues and pull requests alike**, as ValueRanges has them:
+
+| Label | Means |
+|---|---|
+| `bug`, `enhancement`, `documentation`, `tests`, `chore` | The type, exactly one |
+| `severity/critical`, `severity/high`, `severity/medium`, `severity/low` | How bad a bug is, exactly one on a bug |
+| `silent` | A bug that compiles or answers and does less than it appears to |
+| `breaking` | Changes a signature, a generated member, a wire form or a diagnostic's severity: needs a major |
+| `found-by/prober` | Found by the prober; the fix's commit carries `Found-By: PR` |
+| `stacked` | Based on another open pull request |
+| `epic` | A release or a theme; its sub-issues are the work |
+| `package/core`, `package/analyzers`, `package/generators`, `package/efcore`, `package/aspnetcore`, `package/serilog`, `package/testing` | The package affected, one per package |
+| `area/option-result`, `area/value-objects`, `area/json`, `area/aot`, `area/parsing`, `area/release`, `area/tooling` | The cross-cutting area |
+
+ValueRanges' `found-by/oracle` is `found-by/prober` here, its oracles' counterpart; its `roadmap` label has no
+counterpart, there being no roadmap issue. The legend a contributor reads is CONTRIBUTING's "Issues and labels".
+
+**A pull request carries its issue's labels and milestone** and opens with a closing keyword (`Closes #12`),
+from the template in `.github/pull_request_template.md`: Problem, Change, Tests. Since `Closes` closes an issue
+only on a merge into `main`, and a topic merges into its release branch, the issue is closed by hand when its
+topic merges, with a comment linking the pull request; the release's pull request into `main` closes its epic.
+
+**Held by CI.** `.github/workflows/pr-hygiene.yml` runs on every pull request into `main` or a release branch,
+and again when its labels, milestone or description change. It runs `tools/PrHygiene`, a tool project under
+decision 92 (BCL only, tested in `test/CodoMetis.TypeKit.PrHygiene.Tests`), on the event payload alone, and
+fails a pull request that has
+
+- not exactly one type label, or a bug without exactly one severity, or `silent` on anything but a bug;
+- no closing reference in its description;
+- a head branch not named `<type>/<slug>` (decision 94), or whose type disagrees with its type label: `feat` is
+  `enhancement`, `fix` is `bug`, `docs` is `documentation`, `test` is `tests`, and `build`, `refactor`, `spike`
+  and `release` are `chore`;
+- a base `release/<version>`, or a head `release/<version>` into `main`, without the milestone `<version>`;
+- the label `breaking` and a release branch that is not a major (`x.0.0`).
+
+ValueRanges' script checks the first two; the branch and milestone rules hold decision 94's naming and the
+release a pull request belongs to, which here are visible in the payload. Its rule for a `silent` fix in a minor
+has no counterpart, since this repository ships no "changed answers" section; its rule that a breaking change
+waits for a major is the one above. Dependabot's pull requests are not checked.
+
+Its job, "Labels and issue link", is a required status check: on `main` in its branch protection, beside
+the test, pack and smoke-test jobs, and on `release/**` through the ruleset "Release branches: PR hygiene",
+which does not apply to creating a branch, so a release branch is still cut by a push.
+
+## Consequences
+
+- What is open, and in which release, is a GitHub query rather than a reading of the roadmap.
+- The labels count what the commit trailers count from the other side: `found-by/prober` beside `Found-By: PR`,
+  and the severity a trailer does not record.
+- A pull request that misses a label fails a check that turns green when the label is added, without a commit.
+- A pull request from a fork builds the check from its own checkout, so it can weaken the check on its own run
+  only, where the reviewer reads the diff; the workflow uses `pull_request`, never `pull_request_target`, and has
+  a read-only token.
+
+## Evidence
+
+- Counted on 2026-10-18 with `gh`: 66 pull requests, 0 issues, 0 milestones; 0 of the 66 descriptions match
+  GitHub's closing keywords.
+- CodoMetis.ValueRanges at 1da4fa8: `.github/ISSUE_TEMPLATE/{bug,enhancement,epic,config}.yml`,
+  `.github/pull_request_template.md`, `.github/workflows/pr-hygiene.yml` and `.github/scripts/pr-hygiene.sh`,
+  and its 35 labels.
+- The check's rules were each proved by deleting the rule from `tools/PrHygiene` and watching its cases fail
+  (12 seeds, each caught).
diff --git a/design/adr/0110-catchasync-takes-a-valuetask-at-a-lower-priority.md b/design/adr/0110-catchasync-takes-a-valuetask-at-a-lower-priority.md
new file mode 100644
index 00000000..eb62b342
--- /dev/null
+++ b/design/adr/0110-catchasync-takes-a-valuetask-at-a-lower-priority.md
@@ -0,0 +1,37 @@
+# 0110. `CatchAsync` takes a `ValueTask` at a lower overload priority, and `TraverseAsync` reaches `Option` and `Patch`
+
+Date: 2026-10-28
+Status: accepted
+
+Context: 2026-10-28, issue #88, the 2.3.0 roadmap item "`CatchAsync` over a `ValueTask`, and
+`TraverseAsync` on `Option` and `Patch`". [Decision 30](0030-asynchronous-callbacks-return-task.md)
+left `ValueTask` overloads out because beside the `Task` ones every `async` lambda became ambiguous
+(CS0121). Since then a `ValueTask` reached `CatchAsync` only through `.AsTask()` or an `async`
+lambda, and `stream.ReadAsync(buffer)`, the commonest `ValueTask` call, was the README's example
+of the detour. C# 13's `[OverloadResolutionPriority]` removes the ambiguity: among the applicable
+candidates of one type, the ones of lower priority drop out.
+
+## Decision
+
+**`CatchAsync` has four `ValueTask` forms**, over `Func<ValueTask<T>>` and `Func<ValueTask>`, valued and
+command, wide and narrowed to one exception type, each `[OverloadResolutionPriority(-1)]`. They catch as
+the `Task` forms do: an exception thrown before the task or after its first `await`, a timeout as the
+error, a cancellation and an `AggregateException` of cancellations passed through, a null value and a task
+of a task refused. They return `Task<Result<…>>`, as every asynchronous member does.
+
+Measured in `CatchAsyncValueTaskTests`, compiled as a consumer: an `async` lambda, valued or command,
+with or without type arguments, a lambda that only throws with its type argument spelled, and a delegate
+or method group over a `Task` all bind to the `Task` form, as before the `ValueTask` forms existed; a lambda
+or method group over a `ValueTask` binds to the new form. Without the attribute the first group is CS0121.
+
+**`Catch` keeps refusing a `ValueTask` at run time.** A compile-time refusal beside `Catch<T>(Func<T>)`
+is now possible the same way, but it would turn a call that builds today into a build error, which is a
+major version's change, as a new rule at Error severity is.
+
+**Decision 30 stands for callbacks.** `TapAsync`, `MapAsync` and the rest take `Task`; a lambda given
+to a callback is usually `async`, and it already binds to the `Task` form.
+
+**`TraverseAsync` on `Option<T>` and `Patch<T>`**, over `Func<T, Task<Result<TResult, TError>>>` and its
+`CancellationToken` form, is the synchronous `Traverse` with the operation awaited: `None`, a clear and
+an absent field call nothing and check no token, as the sequence's `TraverseAsync` checks nothing over
+an empty sequence; with a value the token is checked before the operation and handed to it.
diff --git a/design/adr/0111-a-mapping-can-withhold-the-fault-name.md b/design/adr/0111-a-mapping-can-withhold-the-fault-name.md
new file mode 100644
index 00000000..0db61a8d
--- /dev/null
+++ b/design/adr/0111-a-mapping-can-withhold-the-fault-name.md
@@ -0,0 +1,37 @@
+# 0111. A mapping can withhold a fault's name from its problem
+
+Date: 2026-10-28
+Status: accepted
+
+Context: 2026-10-28, issue #85, the 2.3.0 roadmap item that [decision 64](0064-fault-name-reaches-client-causes-not-told-apart-one-fault.md)
+named: an additive opt-in that withholds the `fault` name for chosen members or a whole fault type, so two
+causes can share a status without a mapping at the boundary.
+
+## Decision
+
+**The opt-in is part of the response a mapping gives a member**: `FaultResponse.WithoutFaultName()`, beside
+`WithType` and `WithTitle`, and `FaultResponse.NamesFault` reads it. A mapping already answers member by
+member, so chosen members are `fault => fault is SignInFault.Locked ? 403 : FaultResponse.Status(401).WithoutFaultName()`
+and a whole type is the same call for every member. An endpoint's `WithFaultStatus` changes the status and
+keeps the choice; there is no endpoint-level switch, since what a client may know about a fault is the host's
+decision about the fault, not about a route.
+
+**A withheld member's problem names nothing of the member.** It has no `fault` and no `rule`, the rule naming
+the cause as surely as the member does. Its `detail` is the occurrence's alone (`Fault<TFault>.Detail`): a fault
+set member's description, which otherwise stands in for a missing detail, is per member, and is left out with
+the name. So two withheld members with the same status, `type` and `title` write the same problem but for the
+detail the application wrote at the occurrence. A `type` or `title` the mapping gives one and not the other
+tells them apart, and is the host's to give.
+
+**The host still sees the fault.** `IFaultFeature` carries the name and the rule as before, and gains
+`NameWithheld`, a default member, so a `CustomizeProblemDetails` that copies the name into the problem can see
+it would undo the mapping.
+
+**The document says it.** The problem schema is shared and its `fault` stays optional; a response whose every
+fault, across the fault types the endpoint answers with, withholds its name has " The problem names no fault."
+at the end of its description. A status a named member shares keeps its description. The startup check that
+warns of two fault types writing one name counts only the members that write it.
+
+Rejected: a separate registration (`WithholdFaultNames<TFault>()`), which a second place to read would make a
+mapping's response depend on; and an attribute on the fault's member, which puts an HTTP decision into the
+domain that declares the fault, as decision 64 rejected.
diff --git a/design/adr/0112-the-prober-gives-way-to-valueranges-oracle-kit.md b/design/adr/0112-the-prober-gives-way-to-valueranges-oracle-kit.md
new file mode 100644
index 00000000..ec65b332
--- /dev/null
+++ b/design/adr/0112-the-prober-gives-way-to-valueranges-oracle-kit.md
@@ -0,0 +1,55 @@
+# 0112. The prober gives way to CodoMetis.ValueRanges' oracle kit
+
+Date: 2026-10-28
+Status: accepted
+
+Context: 2026-10-28, issue #97, while 2.3.0's features landed. The prober (`tools/Prober`, about 5,500 lines) held
+44 claims with 169 obligations, 38 probes over pairwise covering arrays, a ledger, a replay by footprint in CI and
+a release gate ([decisions 96](0096-ci-replays-every-probe-and-the-release-runs-the-gate.md),
+[99](0099-a-probe-row-says-how-it-ended.md) to [104](0104-a-claim-states-its-obligations-and-each-has-a-seed.md),
+[107](0107-a-cited-fact-is-executable-and-seeds-run-by-footprint.md) and
+[108](0108-a-probe-check-earns-credit-against-a-baseline-and-ws2-closes.md)). Its seeds cost a build of the whole
+probe harness each: 170 seeds at about four minutes, so a release's `prober seeds --all` took roughly eleven hours.
+One change to the fault responses, #85, staled 23 seeds of five probes, about ninety minutes, and a checkout
+whose ledger had never recorded a catch wanted all 170. CodoMetis.ValueRanges had taken the same approach and kept
+the parts that pay for themselves (its `docs/oracles.md`): no covering arrays, no ledger, no replay footprints, no
+agent, with the sweeps as ordinary tests.
+
+## Decision
+
+**The prober is retired.** The tool, its tests, the corpus under `tools/probe/`, its 170 seeds, the `probes` and
+`probe-status` jobs of `dotnet.yml`, the replay and gate steps of `release.yml`, `.claude/probe-axes.md`, the
+`probe-triage` skill and the probe conventions tests are removed. DocsQuery's verified facts stay
+([decision 93](0093-verified-facts-are-pinned-dated-and-executable-where-they-can-be.md)), fixtures included; its
+check of the facts the corpus cited goes with the corpus.
+
+**ValueRanges' oracle kit takes its place**, under `test/oracles/` (its README is the manual):
+
+- `claims.json`: one entry per sentence a consumer-facing document promises, its source heading, the sentence
+  verbatim, the oracle kind, the public members it is about and the test classes that hold it. The first
+  catalogue is the prober's obligations, one claim per distinct sentence, 150 in all, 112 of them held by a test
+  named for it; an empty `heldBy` is the worklist.
+- `surface-waivers.json`: every public member of the five run-time libraries is named by a claim or waived with a
+  reason. Members whose documents the prober never read are waived as `unread:`, naming #98, which reads them.
+- `oracles.json` and `seeds/*.patch`: the oracles are ordinary test classes (five at first: `JsonParityTests`,
+  `NullDelegateTests`, `AsynchronousContextTests`, `NotWireTypeTests`, `KeyGenerationVariantTests`), each with a
+  seed in `src/`. CI checks, without building, that every oracle has a seed and every seed applies.
+- `candidates.json`: known disagreements, each tied to an issue, so a sweep stays green without hiding them.
+- `axes.md`: written by hand, what a consumer varies and the pairs no test varies yet.
+
+`test/CodoMetis.TypeKit.Oracles.Tests` holds the catalogue, in a project of its own because the surface is read by
+reflection over the libraries, which the conventions project does not reference. `tools/Oracles` is the local tool,
+a tool project like the others ([decision 92](0092-repository-tooling-is-dotnet-and-ci-needs-no-ai.md)): `seeds`
+copies the working tree, applies one seed, builds the oracle's project alone and runs its class alone, in minutes,
+and `status` prints the worklist. The seed verdict is one file compiled into both.
+
+**The release runs the suite, which holds the catalogue, and no gate.** Decision 97's gate, which bound from
+2.2.0, is withdrawn with the replay it read; 2.2.0 shipped under it. Before a tag, `oracles seeds` shows every seed
+caught, as `prober seeds --all` did, at a fraction of the cost.
+
+Superseded: decisions 96, 99, 100, 101, 102, 103, 104 and 108; decision 107 but for its fixture rule, which
+DocsQuery keeps; and the gate of decision 97.
+
+Rejected: keeping the prober and dropping only its seeds, since the replay, the footprints and the gate carried the
+same weight; and porting the 38 probes as they were, since their harness compiled consumer projects per row. A probe
+that found a bug is ported as an ordinary oracle class when its area is next touched, with its seed.
diff --git a/design/adr/0113-ci-runs-the-lanes-a-change-can-affect.md b/design/adr/0113-ci-runs-the-lanes-a-change-can-affect.md
new file mode 100644
index 00000000..6eb9ebc8
--- /dev/null
+++ b/design/adr/0113-ci-runs-the-lanes-a-change-can-affect.md
@@ -0,0 +1,138 @@
+# 0113. CI runs the lanes a change can affect, a gate job decides the merge, and the release runs every lane
+
+Date: 2026-10-29
+Status: accepted
+
+Context: 2026-10-29, issue #118, with #70, #71, #73, #74 and #117 as its parts. Since the prober left CI
+([decision 112](0112-the-prober-gives-way-to-valueranges-oracle-kit.md)), the build workflow had five jobs, and
+every pull request into a release branch ran all of them whatever it changed. Its `changes` job skipped Pack and
+Consumer when no listed path changed, but it failed open, missed a rename's source and missed two inputs (#70).
+GitHub reads a skipped job as a passing required check, so nothing told a deliberate skip from an accidental one
+(#71). Pack and Consumer waited for the whole test matrix (#117). The release ran neither the Windows and macOS
+legs nor the smoke test's own-feed mode, and nothing ran CI unless something was pushed (#74). The maintainer's
+view: the three-platform build, packing and the consumer smoke test are mostly release work, and a pull request
+that changes only prose should not pay for them. Over the 150 runs before this decision, a Windows or macOS leg
+failed with Linux passing three times. Two of those were prober tooling. One was a defect in `src/`: the analyzer's
+code fix wrote CRLF beside LF in a Windows checkout (f9f64e5). macOS never failed alone.
+
+## Decision
+
+**Four lanes.** Every run has the Linux test leg, which runs the whole suite (a prose-only change, the prose suite
+below): the conventions, the compiled docs samples, the oracle catalogue and the PostgreSQL round trips. The
+`windows` lane is the Windows test leg. The `macos` lane is the macOS test leg, which only the runs that select
+nothing get. The `pack` lane is the Pack job (pack, the smoke test against the packed feed, the SBOMs) and the
+Consumer job (the smoke test packing its own feed). The Windows and macOS legs test the repository's own handling
+of paths, line endings and child processes, not the .NET runtime, so Windows runs where code does that itself, and
+macOS, which adds a case-insensitive file system and caught nothing alone, waits for the release's checks.
+
+**A changed path selects lanes by its class.** The first class whose pattern matches decides. A path that no
+class names selects every lane a selection can (all but macOS), so a new kind of file costs time rather than
+coverage:
+
+| Class | Paths | Lanes |
+|---|---|---|
+| changelog | `CHANGELOG.md` | Linux, pack: the packages' release notes are its section (#75), read by a property function that no evaluation lists |
+| source text | `src/CodoMetis.TypeKit.Analyzers/**`, `src/CodoMetis.TypeKit.Generators/**` | Linux, Windows, pack: the packages that write or edit source text, whose line endings a Windows checkout changes |
+| package | `src/**` | Linux, pack: the run-time packages, which use the runtime's own paths and text |
+| smoke test | `tools/ConsumerSmokeTest/**`, `tools/Shared/**`, `tools/Directory.Build.*`, `tools/CiLanes/**` | Linux, Windows, pack: the smoke test's own sources and what it compiles in, and the selection itself |
+| prose | `docs/**`, `design/**`, `.github/ISSUE_TEMPLATE/**`, `**/*.md` | Linux, with the prose suite when every path is prose |
+| code no package reads | `test/**`, `spikes/**`, `tools/**` | Linux, Windows: they handle paths, line endings and child processes themselves |
+| anything else | the build files (`Directory.*.props`/`targets`, `Directory.Packages.props`, `global.json`), `.config/`, the workflows, `benchmarks/`, `.claude/`, any path not listed | Linux, Windows, pack |
+
+**Which runs select.** A pull request into `release/**` and a push to `release/**` are selected by their diff,
+`git diff --name-only --no-renames -z`: a pull request against `origin/<base>...HEAD`, a push against the commit
+it replaced (`github.event.before`). A push that creates the branch, or whose previous commit the clone does not
+have, runs every lane, macOS included. So does every other run: a pull request into `main` (the release's), a push
+to `main`, a dispatch, the nightly run and the call from `release.yml`. A diff that names no path also runs every
+lane.
+
+**A prose-only change runs the prose suite.** When every changed path is prose, the Linux leg restores, builds and
+tests `test/Prose.slnf` instead of the solution: the conventions tests, the samples, the docs-query tests and the
+oracle tests, the four projects that read prose, and the woven probes the conventions tests read. Measured on the
+first docs-only run, the whole suite's test step took 3.6 min, set by projects that read no prose: EF Core 2m44,
+conventions 1m50, analyzers 1m40, ASP.NET Core 1m32. `ProseReaderTests` holds the set: a test project outside it
+whose sources name `docs`, `design`, `.github`, a path under one of them, or a Markdown file outside `src/` fails it,
+unless the file is waived with the reason it reads nothing. A package's README is classed with its package, so the
+analyzer, generator, core and ASP.NET Core tests that read theirs stay outside the set.
+
+**The selection is `tools/CiLanes`**, a tool project under [decision
+92](0092-repository-tooling-is-dotnet-and-ci-needs-no-ai.md). Its `select` command answers `legs` (the test
+matrix, a JSON array of one, two or three runners), `pack` (`true` or `false`) and `suite` (`prose` or `full`),
+and writes each path's class to the job summary. Its `classify` command answers the same table for paths given on
+the command line. A conventions test runs `classify` over every file MSBuild evaluates for each shipping project
+and the smoke test, items and imports both, and fails a file that does not select `pack`.
+
+**A gate job, `CI`, decides the merge.** It needs every other job, runs under `always()`, and runs `ci-lanes gate`
+on `toJSON(needs)`. It passes only when `changes` succeeded, its `legs` is exactly one of the three matrices it
+writes (Linux; Linux and Windows; all three), its `pack` exactly `true` or `false`, its `suite` exactly `prose` or
+`full`, and `prose` only beside the Linux leg alone and no pack, the test matrix succeeded, and Pack and Consumer
+succeeded when selected and were skipped when not. A failed selection, a cancelled leg, a misspelled output and a
+selected job that was skipped each fail it. A job the gate's table does not know also fails it, and a conventions
+test holds `CI`'s `needs` to every other job of the workflow. Once `CI` reports on `release/2.3.0` and `main`, the
+required checks on `main` become `CI` and `Labels and issue link`, and the release-branch ruleset adds `CI`. Every
+selected leg blocks.
+
+**Pack and Consumer need only `changes`.** They start beside the test legs and no longer wait for them; the gate
+still requires both (#117).
+
+**Before the Windows and macOS legs may skip, a Linux conventions test refuses non-portable file names** (#73). It
+fails a character Windows refuses (`<>:"|?*\` and controls), a segment ending in a dot or a space, a reserved
+device name, two paths equal under case folding and Unicode normalization, and a path longer than 160 characters,
+so a prose-only change cannot break the Windows checkout unseen.
+
+**The release runs every lane before it verifies.** `dotnet.yml` is also `on: workflow_call`, and `release.yml`'s
+`ci` job calls it; `verify` needs `ci`. A called workflow takes its caller's `github.workflow`, and concurrency
+groups ignore case (KB-043), so `dotnet.yml`'s group is `ci-${{ github.workflow }}-${{ github.ref }}`. Without the
+prefix the call would share the group `release-<tag>` with its caller and wait on it.
+
+**A nightly run.** `nightly.yml` runs on a schedule and on dispatch. It dispatches `dotnet.yml` on `main` and on
+every `release/*` branch, each a full run. A schedule runs only from the default branch, so it starts once 2.3.0
+merges into `main`. GitHub turns a public repository's schedules off after 60 days without activity, so nothing
+depends on it: the release calls the workflow itself.
+
+## Consequences
+
+- A prose-only pull request runs Changes, the Linux leg and the gate. A change to a run-time package adds the pack,
+  a test or tool change adds Windows, and a change to the analyzers, the generators, the smoke test, the build or
+  the workflows runs Linux, Windows and the pack.
+- No selected run has the macOS leg. A defect only macOS shows (a case collision the file-name test misses, a
+  symlinked temporary directory) surfaces on the release's pull request into `main`, the nightly run or the
+  release.
+- A line-ending or path defect in a run-time package other than the analyzers and generators is tested on Windows
+  only by those same runs. None has been seen.
+- Merging a topic into its release branch selects again by the merge's own diff, so a docs merge is cheap on push
+  as well.
+- Prose read by a test on Windows or macOS (a README whose stated outputs a sample test reads) is tested there
+  only by the release's pull request into `main`, the nightly run and the release. The repository has no
+  `.gitattributes`, so Windows checks such files out with CRLF. A prose change that breaks a test only under CRLF
+  surfaces on the release pull request, not on its own.
+- Every run builds `tools/CiLanes` twice, in Changes and in the gate. Measured on the first runs, the Changes job
+  took 0.3 min and the gate 0.2. That is the cost of selecting in C# under decision 92 rather than in a shell `case`.
+- A prose-only change compiles none of the tests that read no prose, so a document that breaks one of them (by a
+  read nobody declared, which `ProseReaderTests` looks for in the sources' literals) surfaces on the next run that is
+  not prose-only.
+- A path class is changed here, by a new record, and in `tools/CiLanes` together. The conventions test reads the
+  build, not this table.
+
+## Evidence
+
+The 11 successful runs of `dotnet.yml` since the prober left (2026-10-28 21:08 to 2026-10-29 08:21 UTC), from
+`gh run view`'s job timings:
+
+| Job | Median | Max |
+|---|---|---|
+| Changes | 0.1 min | 0.1 |
+| Test (ubuntu-latest) | 6.3 min | 7.0 |
+| Test (windows-latest) | 8.5 min | 9.3 |
+| Test (macos-latest) | 7.2 min | 15.2 |
+| Pack | 6.2 min | 6.6 |
+| Consumer smoke test | 5.7 min | 6.3 |
+
+Wall clock was 15.0 min median (12.6 to 21.4) and 33 runner-minutes. Over the last 150 runs, those where a
+Windows or macOS leg failed and the Linux leg passed were 38927646009 and 38929696748 (prober tooling, both
+Windows) and 40827936927 (the analyzer's code fix, Windows, fixed by f9f64e5). The critical path was the slowest test leg
+followed by Pack. Within a leg, the build took 1.2 to 2.1 min and the tests 3.1 to 5.5 min. Pack's smoke test took
+3.0 to 3.7 min, and Consumer's 3.2 to 3.6. The repository is public, so the minutes cost nothing, and the target is
+wall clock.
+
+The before and after runs of a docs-only change and of a `src/` change are recorded on #118 and its pull request.
diff --git a/design/adr/0114-a-value-object-s-temporary-number-is-its-wrapped-type-s.md b/design/adr/0114-a-value-object-s-temporary-number-is-its-wrapped-type-s.md
new file mode 100644
index 00000000..c136f65a
--- /dev/null
+++ b/design/adr/0114-a-value-object-s-temporary-number-is-its-wrapped-type-s.md
@@ -0,0 +1,59 @@
+# 0114. A value object's temporary number is its wrapped type's, carried by its converter's mapping hints
+
+Date: 2026-10-29
+Status: accepted
+
+Context: [#86](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/issues/86), the roadmap's 2.3.0 item;
+[EF Core](../ef-core.md); supersedes the `ulong` half of [decision 63](0063-char-keys-application-assigned-ulong-documented.md).
+
+Decision 63 left a default value-object key over `ulong` throwing `OverflowException` at `Add` on SQL
+Server and PostgreSQL, whose column is a `decimal`, and ruled out three routes to a temporary `ulong`: a
+delegate given to `HasValueGenerator` (refused by `dbcontext optimize`), a factory type on the property
+(it comes before the providers' HiLo), and a type mapping's own factory (no public setter on the
+provider's mapping). Read in EF Core 10.0.12's source, the cause is narrower than the column: EF gives a
+generated property a temporary number by its type mapping's CLR type
+(`TemporaryNumberValueGeneratorFactory.Create`), which for a value object is the value object, so it
+falls back to the converter's provider type, the column's `decimal`. A plain `ulong` key's mapping says
+`ulong`.
+
+**A value object over a number gets the temporary values a property of its wrapped type gets.** The
+converter `UseTypeKit()` composes carries `ConverterMappingHints` with a value generator factory, which
+`CoreTypeMapping` takes into the value object's mapping where the provider's has none. That is the fourth
+route, and the only one in the right place: `ValueGeneratorSelector` consults a mapping's factory after a
+factory on the property, and the SQL Server and PostgreSQL selectors choose HiLo before either. So an
+application's own generator and HiLo still come first, as for a plain key.
+
+- The numbers are EF's list (`RelationalValueGeneratorSelector.FindForType`): every integer type, `char`
+  included, and `decimal`, `float` and `double`. Where the column is of the wrapped type, the factory
+  returns EF's own temporary generator, as before; where the provider stores the wrapped type as another,
+  it asks the provider for a key of the wrapped type generated on add, in a model of its own, as the Guid
+  and string keys' generator already does.
+- **Siblings, found by the variant catalogue** (`KeyGenerationVariantTests`, configured `ValueGeneratedOnAdd()`
+  over every key kind on three providers): a key over `char` configured on add got one character of a GUID
+  string on SQL Server, from the column's `nvarchar(1)`; it now gets a temporary `char`, as a plain one does.
+  The catalogue's two pinned departures are gone.
+- **A compiled model keeps it, except under `--nativeaot`.** `dbcontext optimize` leaves the type mappings to
+  be found when the model is first used, where the plugin composes them. `--nativeaot` writes each mapping
+  out as code (`SqlServerDecimalTypeMapping.Default.Clone(converter: new ValueConverter<UInt64Key, decimal>(…))`),
+  and a factory in the hints is a delegate it cannot write: a default `ulong` key still throws at `Add`
+  there, and `ValueGeneratedNever()` remains the workaround. A test pins it.
+- **Nor does a converter the application names.** `HasConversion<ValueObjectConverter<UInt64Key, ulong>>()` builds the
+  mapping on the public converter, which carries no hints, and the key, declared generated, still throws at `Add`.
+  Hints on that converter would make `dbcontext optimize` write the mapping of every property that names it out as
+  code (`CSharpRuntimeModelCodeGenerator`, a converter with hints), which loses the factory there too, so it is
+  documented and pinned instead.
+- `ConverterMappingHints.ValueGeneratorFactory` is marked `[Obsolete]` without a message in EF Core 10; the
+  constructor parameter is not. A later EF that removes it fails the tests that hold this, not silently.
+- PostgreSQL's provider refuses HiLo on a `ulong` key, plain or value object ("Sequences can only be used
+  with integer properties"), so only SQL Server's HiLo is tested for one.
+
+Measured with EF Core 10.0.12, Npgsql 10.0.3 and SQL Server's provider 10.0.12, at `Add` and in the
+selector, no database opened. EF caches a property's generator by the model's id
+(`ValueGeneratorCache.CacheKey`), which a compiled model keeps from the model it was written from: a test
+that builds a model twice in one service provider reads the first one's generator, so the compiled-model
+tests each get a service provider of their own.
+
+`KeyGenerationTests` holds it: a default `ulong` key gets the temporary values a plain one does on three
+providers, SQL Server's HiLo is still chosen, an application's generator still wins, a compiled model gives
+the temporary value, and a `--nativeaot` one still throws. Without the hints, seven of them fail; with the
+factory set on the property instead, the HiLo test fails.
diff --git a/design/adr/0115-value-objects-can-be-inlined-everywhere.md b/design/adr/0115-value-objects-can-be-inlined-everywhere.md
new file mode 100644
index 00000000..b56608cd
--- /dev/null
+++ b/design/adr/0115-value-objects-can-be-inlined-everywhere.md
@@ -0,0 +1,71 @@
+# 0115. A setting of `AddTypeKit` writes every value object in place, with no component of its own
+
+Date: 2026-10-29
+Status: accepted
+
+Context: [#83](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/issues/83), in the 2.3.0 epic;
+[OpenAPI](../openapi.md). With `AddTypeKit()` a value object in a JSON position keeps a component named after it
+([decision 24](0024-nested-value-objects-named-after-nesting.md)), and a parameter is written in place where ASP.NET
+writes one of the wrapped type so, or where the value object wraps a type the options describe
+([decision 106](0106-a-parameter-of-a-value-object-over-a-described-type-is-inlined.md)). Some clients want plain
+types: a generator that makes a class of every component gets a `CustomerId` wrapper where the application wanted a
+`string`, and under OpenAPI 2.0 a nullable property of a component loses its type
+([KB-026](../knowledge/KB-026-openapi-2-nullable-component-property-loses-its-reference.md)).
+
+A host could already inline value objects with a `CreateSchemaReferenceId` of its own, set after `AddTypeKit()`,
+that returned `null` for every type carrying `GeneratedValueObjectAttribute`: the package README showed that
+predicate, and the transformer's inline path, nullable positions included, was measured and tested through it. It
+asks the host to reflect over a `CompilerServices` attribute, and it replaces the delegate `AddTypeKit()` installed,
+so a closed set lost its nesting-chain name and decision 55's check with it.
+
+## Decision
+
+**`AddTypeKit(typeKit => typeKit.InlineValueObjects = true)` writes every value object in place.** An overload of
+`AddTypeKit` takes an `Action<TypeKitOpenApiOptions>`; the setting is off by default, and `AddTypeKit()`, or the
+overload with the setting off, writes the document it wrote before, byte for byte. A settings object rather than a
+`bool` parameter leaves room for a second setting without another overload, and it is per document, as `AddTypeKit`
+is per `OpenApiOptions`.
+
+**It is done where the names are given.** The `CreateSchemaReferenceId` that `AddTypeKit` wraps answers `null` for a
+value object, or the `Nullable<T>` of one, before it asks the host's delegate. Every position then takes the path a
+host's own `null` took: a property, a body, a response, a list's or a dictionary's elements, a parameter and an element
+of a query or header array, at any depth, each the wrapped type's schema in place, and a nullable value object admits
+null in its own schema as a nullable property of the wrapped type does
+([decision 36](0036-nullable-value-object-admits-null-openapi.md)). A dictionary keyed by a value object is the one
+keyed by the wrapped type, since ASP.NET describes no key.
+
+**Value objects only.** A closed set keeps its component, and so does the type a value object wraps where ASP.NET makes
+it one (an enum): the value object holds that component's content in place, as with the host's predicate.
+A closed set is an enum of its own names, not a wrapper of another type's schema, and inlining the wrapped types would
+be `CreateSchemaReferenceId = _ => null`, which ASP.NET already offers.
+
+**With decision 55**, an inlined value object claims no name: a nested value object and a top-level one of its chain's
+name are two schemas in place, not a refusal. A closed set still claims its name, and a document in which two types
+claim one is still refused. A name the host's own delegate gives a value object is not used; one it gives any other
+type is kept, as before. A delegate set after `AddTypeKit` replaces the setting, as it replaces the naming.
+
+**With decision 106**, the setting leaves nothing to decide: where no value object is a component, its JSON positions
+and its parameters share no schema, so a parameter over a described type is written in place as a parameter, and its
+JSON positions as the converter writes them, each where it is used.
+
+## Consequences
+
+- The package README's predicate gives way to the setting in the documents. It still works, and
+  `InlinedValueObjectTests`, `HostConfigurationTests`, `DescribedParameterTests` and `PolymorphicBaseTests` keep holding
+  a host's own `null`.
+- `SchemaTests` holds each value-object property to the wrapped type's under both settings, in OpenAPI 3.1, 3.0 and 2.0;
+  inlined, the nullable properties, the containers and the nested containers too, whose controls were added. It is
+  registered as an oracle, with the seed `inline-value-objects-ignored`.
+- `NullablePositionTests`' `inline-value-objects` mode is the setting, in every position and version it already ran.
+- `InlineValueObjectsSettingTests` holds the rest: no component of a value object in any version, the default document
+  unchanged, a later plain `AddTypeKit()` keeping them inlined, the host's names for other types, and decision 55's
+  claims.
+
+## Evidence
+
+- At the change: `SchemaTests`, `NullablePositionTests` and `InlineValueObjectsSettingTests` 705 green.
+- With the setting ignored (the `null` taken out): 169 of 522 fail: 92 inline rows of `SchemaTests` (all but the
+  dictionary keyed by a value object, in each version), 72 `inline-value-objects` rows of `NullablePositionTests`, and
+  five of `InlineValueObjectsSettingTests`. `oracles seeds inline-value-objects-ignored`: caught, 92 of 164.
+- With the setting on by default: 70 of 174 fail, every component row of `SchemaTests` and the default-document test
+  in each version.
diff --git a/design/adr/0116-the-docs-site-is-docfx-built-from-main.md b/design/adr/0116-the-docs-site-is-docfx-built-from-main.md
new file mode 100644
index 00000000..2aae3b3c
--- /dev/null
+++ b/design/adr/0116-the-docs-site-is-docfx-built-from-main.md
@@ -0,0 +1,67 @@
+# 0116. The docs site is DocFX, built from main, from the sources as they are
+
+Date: 2026-10-29
+Status: accepted
+
+Context: [#115](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/issues/115); CodoMetis.ValueRanges chose DocFX
+in its spike ([CaffeinatedCoder/CodoMetis.ValueRanges#417](https://github.com/CaffeinatedCoder/CodoMetis.ValueRanges/issues/417));
+[decision 113](0113-ci-runs-the-lanes-a-change-can-affect.md) holds the CI lanes this adds a path to.
+
+The guides in `docs/`, the root README and the package READMEs could only be read as Markdown on GitHub: no
+navigation beyond the README's Documentation table, no search across them, and the XML docs of every public
+member shown only by an IDE.
+
+**The site is DocFX, publishing to GitHub Pages from `main` alone.** `.github/workflows/docs.yml` builds
+`docs/*.md`, `README.md`, `src/*/README.md`, `CHANGELOG.md` and the API pages of the run-time packages
+(`CodoMetis.TypeKit`, `.EntityFrameworkCore`, `.AspNetCore`, `.Serilog`, `.Testing`) and deploys them on a push to
+`main`, which is the released state: topics merge into `release/<version>`, which merges into `main` when it is
+tagged. A release branch is never published, so the site always describes the version `dotnet add package`
+installs. The Analyzers' surface is their rules and the Generators' is what they generate into a consumer, so
+their READMEs are their reference and they get no API pages. DocFX is pinned in `.config/dotnet-tools.json`
+(2.81.0) and configured in `site/docfx.json`, inside the repository because DocFX refuses a content root outside
+its base directory. A second line (`/2.x/`, `/3.x/`) waits until two are supported at once; CONTRIBUTING.md says
+how one would be added.
+
+**The pages are the files as they are.** Nothing copies or edits a page for the site, so `ReadmeSampleTests` and
+`OracleCatalogueTests` hold the text a reader sees. A link between two pages resolves as written, since every
+page is a site page. A link to a file of the repository that is not a page (`design/`, `CONTRIBUTING.md`,
+`AGENTS.md`, `SECURITY.md`, `LICENSE`) becomes a GitHub address at the built commit, rewritten by
+`site/template/conceptual.extension.js` at build time. Those files are the build's resources, under `_repository/`,
+so DocFX checks that each exists; the workflow then deletes them from the output. A link to a directory names no
+file DocFX can check, so the README's one link to `spikes/` became an absolute address on `main`, which
+`DocumentationLinkTests` checks.
+
+**A pull request that touches a page checks its links.** On a pull request into `main` or a release branch whose
+paths a page is built from (`*.md`, `docs/`, `design/`, `src/`, `site/`, the SDK and tool pins), the workflow runs
+the whole build with `--warningsAsErrors` and publishes nothing. Measured on 2026-10-29: a seeded link to a missing
+page (`InvalidFileLink`), to a missing heading of a page (`InvalidBookmark`) and to a missing design record
+(`InvalidFileLink`, through the resources) each fail the build; without them it reports no warning. An anchor into
+a file that is not a page is left to `DocumentationLinkTests`, which reads every anchor as GitHub derives it.
+
+**`site/**` is prose** in `tools/CiLanes`: the docs workflow and the conventions tests read it, and nothing is
+built from it, so a change to it alone runs the prose suite. `ProseReaderTests` counts a literal naming `site` as
+prose, so no test outside `test/Prose.slnf` reads it unseen. The workflow itself is a workflow, which decision 113
+already classes as anything else. `DocsSiteTests` holds the menu (`site/toc.yml`) to the README's Documentation
+table, in its order, and to every shipping package's README, and the API pages to every run-time package.
+
+**The spike: DocFX lists the members of C# 14 extension blocks.** `src/` holds 35 `extension(...)` blocks, which
+carry most of the `Option` and `Result` extensions, `AsText` and the `IQueryable` helpers, and ValueRanges had none.
+Measured with DocFX 2.81.0 on the published assemblies:
+
+- Every instance member of a block is listed on its static class as the extension method the compiler lowers it
+  to, with its XML docs: `Option.FirstOrNone<T>(this IEnumerable<T> source)`, `StringTextExtensions.AsText(this
+  string? text)`: 37 extension methods on `Option` and 52 on `Result`.
+- The type a block extends lists them under "Extension Methods": `Option<T>`'s page shows `Select`, `SelectMany`,
+  `Where`, `Zip`, `ToResult` and `Result.Traverse`. A member whose constraints the open type does not meet is
+  left out there, as for any extension method: `OrDefault()` (`where T : struct`) and `OrNull()`
+  (`where T : class`) are on `Option`'s page only.
+- The signature shown is the lowered one, `this in Option<T> a`, not the `extension(...)` block it is declared in.
+- The one static member of a block, `GuidValueExtensions.New()`, is listed as `New<TSelf>()` with its constraints,
+  on `GuidValueExtensions` only, not as `OrderId.New()` on the value objects it serves.
+
+So the API pages ship. The workflow fails if `Option<T>`'s or `Result<T, TError>`'s page stops listing its
+extension-block `Select`, so a DocFX update that loses them fails there, not on a reader.
+
+**Pages is configured** to deploy from GitHub Actions (Settings > Pages > Source), the one setting no workflow can
+make: on 2026-10-29 the API reports `build_type: workflow` at `https://caffeinatedcoder.github.io/CodoMetis.TypeKit/`.
+The first deployment follows the 2.3.0 release's merge into `main`.
diff --git a/design/adr/0117-a-seed-is-caught-against-a-passing-baseline.md b/design/adr/0117-a-seed-is-caught-against-a-passing-baseline.md
new file mode 100644
index 00000000..637f323c
--- /dev/null
+++ b/design/adr/0117-a-seed-is-caught-against-a-passing-baseline.md
@@ -0,0 +1,54 @@
+# 0117. A seed is caught against a passing baseline, by a test of its own
+
+Date: 2026-10-29
+Status: accepted
+
+Context: [#151](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/issues/151), found by the 2.3.0 pre-release
+review. [Decision 112](0112-the-prober-gives-way-to-valueranges-oracle-kit.md) made `oracles seeds` the release's
+proof that every oracle can fail; [decision 108](0108-a-probe-check-earns-credit-against-a-baseline-and-ws2-closes.md)
+had held the prober it replaced to a baseline, and the port did not carry that over.
+
+`oracles seeds` credited a seed whenever one test of its oracle failed with a row that was not a known candidate,
+whatever the failure was. On an arm64 Mac, SQL Server 2022 under QEMU stops before it is ready, so the SQL Server
+collection fixture throws `ContainerNotRunningException` in `InitializeAsync` and every test of both SQL Server
+oracles fails, with and without a seed. The tool reported both seeds `CAUGHT` (10,071 of 10,071 and 170 of 170 tests
+failing) and exited 0, ending `every seed is caught`, while no query or insert under review had run.
+
+**A seed is caught only when its oracle passes without it and fails with it, in a test of its own.** `oracles seeds`
+first runs every oracle the selected seeds name on a copy of the tree with no seed, built and filtered as the seeded
+runs are, in the same process and environment. An oracle that does not pass there (a run that never reached its
+tests, or a test that fails on a row that is not a known candidate) makes each of its pairs `ERROR`, and is not run
+with the seed. A baseline whose only failures are known candidates passes, since an unfiled candidate fails its sweep
+until it is filed.
+
+**A run that did not reach the tests' own code is `ERROR`, never `CAUGHT`, with or without the seed.** What the TRX
+holds decides it, measured with xunit.v3 4.0.2 on Microsoft Testing Platform on 2026-10-29, one class per kind of
+failure:
+
+- A class, collection or assembly fixture that throws in its constructor or `InitializeAsync` fails every test that
+  uses it, each with xunit's own message (`Collection fixture type 'T' threw in InitializeAsync`, the fixture's
+  exception on the next line, the stack only an inner one). xunit.v3.core 4.0.2 holds four more setup messages of
+  the same kind: unresolved constructor arguments, more than one public constructor, constructor parameters without
+  fixture data, and a type it cannot create. A failed test whose message begins with one of them is setup.
+- A fixture that throws in `Dispose` or `DisposeAsync` fails no test: the TRX counts it as an `error` in its
+  `Counters` and holds no result for it. A nonzero `error`, `aborted`, `timeout` or `disconnected` counter is an error.
+- A test host that crashes (`Environment.FailFast`) writes no TRX and exits 134. Microsoft Testing Platform exits 0
+  when every test passes and 2 when one fails; any other exit code, or no TRX, is an error.
+- A run whose every test is skipped ran nothing, and is an error.
+- A failure in the test class's own constructor or `InitializeAsync` is written like one in the test's body: the
+  exception's message, and a stack trace under the test's code. It counts as the test's: the oracles build there
+  what they assert on (`KeyGenerationVariantTests` opens its connection in its constructor), and the baseline has
+  shown that it passes without the seed.
+
+The rule is one file, `test/oracles/SeedVerdict.cs`, compiled into the tool and into `SeedVerdictTests`, which hold
+it on TRX documents of the measured shape. With the setup check and the baseline taken out, the dead fixture of #151
+reads as caught again and three of those tests fail.
+
+**`ERROR` exits 4**, beside 1 for a seed missed, so a release script tells a seed that needs a stronger oracle from an
+environment that needs fixing. A release on an arm64 Mac runs `oracles seeds` with `TYPEKIT_MSSQL_IMAGE` naming
+Azure SQL Edge, as the suite does (CONTRIBUTING's Docker bullet).
+
+Rejected: telling a setup failure apart by its stack trace (a frame of `InitializeAsync`, a constructor), since a
+test's own exception passes through product code whose frames carry the same names, and xunit writes the fixture
+cases in fixed words of its own; and requiring the seeded run to fail on the rows the baseline passed, row by row,
+since a test's rows are not in the TRX and the baseline already rules out a failure that does not depend on the seed.
diff --git a/design/adr/0118-an-error-may-learn-a-form-only-new-api-can-write.md b/design/adr/0118-an-error-may-learn-a-form-only-new-api-can-write.md
new file mode 100644
index 00000000..7bb3e799
--- /dev/null
+++ b/design/adr/0118-an-error-may-learn-a-form-only-new-api-can-write.md
@@ -0,0 +1,49 @@
+# 0118. An Error may learn, in a minor version, a form only that version's new API can write
+
+Date: 2026-10-29
+Status: accepted
+
+Context: 2026-10-29, issue #153, found by the pre-release sweep of `release/2.3.0` at `99c6032`; refines
+[decision 34](0034-errors-fixed-within-major-version-warnings.md). 2.3.0 gives every assertion of
+`CodoMetis.TypeKit.Testing` a form on a `Task` or `ValueTask` of what it checks (#87), and CMTK0003, an
+Error since 2.0.0 ([decision 50](0050-warnings-cmtk0003-alone-becomes-error-2.md)), reports such an
+assertion left without `await` (`IgnoredOutcomeAnalyzer.IsPendingAssertion`): it fails the test only through
+the task it returns, so the dropped task passes whatever the value is. Decision 34 says an Error that
+reports more waits for a major version, and the Analyzers README promised the same, so the 2.3.0 analyzer
+contradicted the 2.3.0 README with no record of why.
+
+## Decision
+
+**An Error may report, in a minor version, a form that only an API new in that same version can write.**
+Decision 34 keeps Errors fixed within a major so that an update never fails a build that worked before.
+A form that needs the new API to be written cannot occur in code that built on the previous version, so
+reporting it fails no such build. The rule holds when every reported form calls the new API itself; a
+form that merely sits beside it, or that a name alone recognises, does not qualify.
+
+**What qualifies in 2.3.0.** CMTK0003's dropped pending assertion: an expression statement that drops,
+without `await`, the task an assertion of `CodoMetis.TypeKit.Testing` returns on a `Task` or `ValueTask`.
+The rule knows the assertion by the package's own assembly (`TypeKitSymbols.IsTestingAssembly`), so a
+consumer's extension of the same name on a pending result, which may have built on 2.2.0, stays silent
+(`IgnoredOutcomeAnalyzerTests.A_task_of_another_assembly_s_extension_on_a_pending_value_is_silent`). No
+preview of 2.3.0 was published (nuget.org lists 2.2.0 as the latest of both packages on 2026-10-29), so
+no build on these assertions exists before the tag.
+
+**It covers #152's forms.** The same assertions passed through `ConfigureAwait` or `WaitAsync` of a plain
+`Task`, and reached through a branch of a `?:`, a `??` or a `switch` expression, are written only with
+the same new API, so their reach widens before the tag under this decision.
+
+**The forms freeze at the tag.** Once 2.3.0 ships, its API is no longer new: a further form of these
+assertions, or of any other 2.3.0 API, that CMTK0003 learns afterwards waits for a major version, as
+decision 34 says. A Warning or an Info may still learn more forms in any minor version.
+
+**One exception in 2.3.0, taken by the maintainer.** #159: CMTK0003 also reports a `Task.WhenAny` of tasks
+of results dropped without `await`, converted to a plain `Task` or waited for with `Wait`, which code built
+on 2.2.0 can contain. The maintainer took it into 2.3.0 on 2026-10-29, before the tag: such a statement
+loses every result in any build, so the report finds a defect, never correct code. A `WhenAny` of tasks the
+caller holds completes with one of them and stays silent. The Analyzers README names the exception beside
+the rule.
+
+**Decision 34 stands otherwise.** A new rule ships at Warning or Info in a minor version, and an Error
+that reports more of the code a consumer could already write waits for a major. The Analyzers README's
+"What a new version may change" states both, and claim `T01-an-error-learns-only-new-api-forms` in
+`test/oracles/claims.json` quotes the exception.
diff --git a/design/adr/0119-a-gap-found-before-the-tag-ships-in-that-release.md b/design/adr/0119-a-gap-found-before-the-tag-ships-in-that-release.md
new file mode 100644
index 00000000..b48c8fd0
--- /dev/null
+++ b/design/adr/0119-a-gap-found-before-the-tag-ships-in-that-release.md
@@ -0,0 +1,40 @@
+# 0119. A gap an Error has, found before the tag, ships in that release
+
+Date: 2026-10-29
+Status: accepted
+
+Context: 2026-10-29, the sweep of CMTK0003 before 2.3.0 was tagged (#152, #157, #159 to #162); refines
+[decision 34](0034-errors-fixed-within-major-version-warnings.md) and
+[decision 118](0118-an-error-may-learn-a-form-only-new-api-can-write.md). Decision 118 lets a minor version's
+Error report forms that only that version's new API can write, and names one exception the maintainer took
+into 2.3.0: a dropped `Task.WhenAny` of tasks of results (#159). The sweep that followed found three more
+forms of the same kind, each written with APIs 2.2.0 had. The maintainer decided, in these words: "decision
+0119 widens 0118 to 'a gap found before the tag ships in that release'".
+
+## Decision
+
+**A form an Error misses, found before its version is tagged, is reported in that version**, when the form
+loses what the rule protects in every build that contains it. A build that worked on the previous minor
+version can then fail on update. The failure names a defect, never correct code, and the changelog's
+Changed section says which forms and what to write instead. Decision 34 keeps an Error fixed within a major
+so that an update never fails correct code; it does not keep a defect found before the tag unreported for a
+major version.
+
+**What 2.3.0 reports that 2.2.0 code can contain**, CMTK0003 on tasks of results:
+
+- a `Task.WhenAny` of tasks the statement made, dropped, awaited, waited for or converted to a plain `Task`
+  (#159): `Tasks.PendingOutcome` looked one task deep, and the `Task<Task<Result>>` hid the result;
+- `Wait()` on a `?:`, `??` or `switch` expression, at each branch's call (#160): `AnalyzeWait` read only the
+  statement's own call, where every other path goes through `Producers`;
+- an array of them written in a `Task.WaitAll` or `Task.WaitAny` call (#161), which converts whole, so no
+  element's call was converted on its own;
+- a dropped `Task.WhenEach` of them (#162), which yields the tasks it was given.
+
+**It relaxes too.** A `Task.WhenAny` of tasks the caller holds completes with one of them and loses nothing.
+2.2.0 reported it awaited; 2.3.0 is silent on it.
+
+**The rule stops at the tag.** Once a version is tagged, decision 34 holds for it: an Error that reports
+more code its major version could already write waits for the next major, 3.0.0 for 2.x. Decision 118
+stands for forms only a minor version's new API writes, and its one exception is this decision's first
+case. The Analyzers README's "What a new version may change" lists each form a minor version reports that
+the previous one's code can contain.
diff --git a/design/adr/0120-a-net11-0-target-and-documented-floor-raises-join-a-minor.md b/design/adr/0120-a-net11-0-target-and-documented-floor-raises-join-a-minor.md
new file mode 100644
index 00000000..e96d7ea2
--- /dev/null
+++ b/design/adr/0120-a-net11-0-target-and-documented-floor-raises-join-a-minor.md
@@ -0,0 +1,203 @@
+# 0120. A `net11.0` target and a documented dependency-floor raise join a 2.x minor, and so may a C# 15 union; 3.0.0 stays the change of an existing contract
+
+Date: 2026-10-29
+Status: accepted
+
+Context: 2026-10-29, issue #169; refines [decision 44](0044-2-0-0-net10-0-metalama.md). Decision 44 says a
+`net11.0` target is additive and joins a 2.x minor when a feature needs it, and that unions and the `net10.0`
+drop are 3.0.0, timed to .NET 12 LTS. The maintainer asked what making 3.0.0 the .NET 11 release would
+change, and decided, in these words: "stick to the original plans regarding 3.0.0, add details to new 2.x
+minors and .NET 11 related specifics". On Metalama 2027, and on floor raises in general, the maintainer decided
+the same day (see the first rule and the Metalama paragraph). .NET 11 is a release candidate (SDK 11.0.100-rc.1 measured here, RC2
+named in [KB-046](../knowledge/KB-046-csharp-15-unions-ship-with-the-net-11-sdk.md)), with general
+availability expected in November 2026.
+
+## Decision
+
+**3.0.0 stays timed as decision 44 and the roadmap have it:** the `net10.0` drop, and `Option` and `Result`
+becoming C# 15 unions if the spike allows it, at .NET 12 LTS (November 2027) or at the end of .NET 10's
+support, whichever its consumers need. A 3.0.0 for .NET 11 was considered and refused. A `net11.0`-only major
+strands the consumers on the .NET 10 LTS line, supported to November 2028, which is the argument that refused
+a `net11.0`-only 2.0.0. And nothing .NET 11 offers needs a break: unions in `Option` and `Result` wait for the
+spike the roadmap names, since the compiler-made union types have a public `object? Value` and are serialized
+by System.Text.Json. The version number names the API, never the runtime.
+
+**What 3.0.0 holds is a change to an existing contract, never an addition.** Decision 44 puts "unions in the
+public surface" in 3.0.0 as "two contracts under one version", which is true of a union that replaces or
+retypes an existing member, and of `Option` or `Result` becoming unions: their identity, their serialization
+and their pattern matching would differ between two versions of the same member. A union that is new, and
+exists on `net11.0` only, is an addition like any other, and may join a 2.x minor (second rule below). A minor
+that fixes bugs for every consumer and adds to `net11.0` alone is a plain 2.x minor.
+
+**A `net11.0` asset joins a 2.x minor when a feature needs it, on these rules.** No patch adds a target. The next
+minor after the one in flight carries it; the number is not reserved here.
+
+1. **A dependency floor may rise in a minor, documented, on every target or on `net11.0` alone.** It is a
+   dependency update with an unchanged public API, which the Semantic Versioning FAQ calls compatible, leaving the
+   conflict to whoever references the dependency at a lower version. The conflict is real, and measured: an
+   application on `net11.0` that holds EF Core 10 (or Microsoft.AspNetCore.OpenApi 10) while the `net11.0` group
+   requires 11 fails restore with NU1605, an error by default (below). So a raise:
+   - has a reason, a feature, a fix or a supported version, and is the lowest floor that does the work;
+   - is a release decision named in the changelog "Changed": the dependency, the old and the new floor, the
+     targets it covers, who it reaches (a project that references the dependency at a lower version) and both
+     ways out (raise that reference, or stay on the previous minor);
+   - changes no public API and no generated member; a consequence beyond the restore (a compiler, a language
+     version, a supported IDE, a translation, a schema) is assessed on its own and documented, as Metalama's is
+     below;
+   - is shown by the smoke test: a consumer that holds the lower version gets the NU1605 the changelog
+     describes. The satellites may compile against EF Core 11 and OpenAPI 11 and require them in the `net11.0`
+     group.
+2. **Its public surface is a superset of `net10.0`'s, and a shared member behaves the same on both.** A member
+   only `net11.0` has is available on that target alone, and the changelog says so. That includes members that
+   use C# 15 unions or `closed` types: the `net10.0` asset has none of them, and a `net11.0` consumer who does
+   not use them is untouched. One who uses them on `LangVersion` 14 gets CS9327, an error, never a different
+   answer (measured below). What stays out of a 2.x minor is a change to a member both targets have: its
+   signature, its return type, its serialization or its behaviour on one target. Two conditions on a union
+   member are this repository's own and are decided by the unions spike the roadmap names, not by the version:
+   it gives no path to the content of an `Option` or `Result` past `Match` and `TryGetValue` (a compiler-made
+   union has a public `object? Value`), and it is not written by System.Text.Json where `Option` and `Result`
+   refuse it. A project that has the Generators package, on Metalama 2026.1, can neither declare nor match a
+   union (measured below), so until 2.5.0 a union member reaches the consumers without the Generators package
+   and those that reference Metalama 2027 themselves.
+3. **Generated members are the same on every target.** The generators run in the consumer's compiler whatever
+   the asset, and a value object's generated surface is the contract. A member that exists on one target only
+   would make a consumer that multi-targets see two value objects under one name; any member the generators
+   introduce on `net11.0` is introduced on `net10.0` too, or not at all.
+4. **`LangVersion` stays 14 for `net10.0`, and is 15 for `net11.0` once its code uses a C# 15 feature**, in an
+   implementation or in a new member's signature. The consumer needs nothing from the compiler the assembly was
+   built with, except to use a union or a `closed` type, which needs C# 15 and says so (CS9327). In a project
+   that has the Generators package, Metalama's compiler sets the language version, not the SDK: 14 on both
+   targets with Metalama 2026.1, 15 on `net11.0` with 2027 (measured below). Generated code compiles under both.
+5. **Each target is run, not assumed:** the tests, the Native AOT smoke run and package validation per target,
+   and the smoke test's consumer on `net11.0` that holds the lower satellite versions.
+
+**The SDK comes first.** `global.json` pins SDK 10.0.4xx, because a different Roslyn band can change what
+Metalama and the analyzers emit. A `net11.0` target needs SDK 11, which changes the compiler under the `net10.0`
+assets too, and a consumer on SDK 11 meets it already with the 2.x `net10.0` asset. Before any `net11.0`
+target, a spike with no release attached (#170) measures on an SDK 11 compiler: the build and tests, the packed
+`net10.0` assets unchanged, a consumer on SDK 11 building and weaving, and the smoke test's SDK 11 lane. The
+pin moves by a record of its own, after the SDK is generally available. The pin protects the packages that
+Metalama does not touch and this repository's own build: in a project woven by Metalama the SDK does not choose
+the compiler either, Metalama's does, so what such a project compiles with follows the Metalama year.
+
+**Metalama is one version for every target of a release, and TypeKit follows the maintained Metalama year in a
+minor.** The Generators package stays on Metalama 2026.1 in 2.3 and 2.4, and 2.5.0 moves both targets to 2027.0
+once it is stable. Other floors may differ between targets (first rule); this one never does: NuGet resolves one
+`Metalama.Framework` per project, that version brings the engine and Metalama's compiler, and different floors
+per target would give a consumer that multi-targets two compilers for its two inner builds (LAMA0054 refuses a
+project whose `Metalama.Framework` is newer than its engine). The raise itself is the first rule applied to the
+dependency with the widest reach: Metalama is also the compiler of the consumer's woven projects, so it carries
+the extra consequences below.
+
+It is not new. 1.5.0, a minor, raised the floor from 2026.1.28 to 2026.1.29 (`CHANGELOG.md`, 1.5.0 "Changed"),
+the same restore mechanism in a smaller step, because ADR 4 follows the only line Metalama's MIT maintenance
+covers, the latest `YYYY.N`. Semantic Versioning's FAQ calls an update of a library's own dependencies with an
+unchanged public API compatible, and leaves the conflicts to the dependents. The maintainer decided the move,
+in these words: "every consumer that somehow needs Metalama 2026.x pinned for whatever he wants to achieve is
+hitting TypeKit's version ceiling, so can continue using any TypeKit version that still allows any Metalama
+2026 version; from 2.5.0 by depending my own packages on Metalama 2027 this is a clear, transparent ceiling".
+Holding 2026.1 has a cost too: on SDK 11 it reports LAMA0617, its Razor analyzer needing a Roslyn newer than
+the one it bundles (the review of 2026-10-29; a warning, falling back to the SDK 10 Razor compiler).
+
+**What a consumer sees is not only a restore error.** A project that references `Metalama.Framework` 2026.1
+directly gets NU1605, loud, with a one-line way out (raise it) or the line it already has (TypeKit 2.4.x). The
+rest is quieter, and the documents say so:
+
+- a woven `net11.0` project moves from C# 14 to C# 15, with C# 15's own breaking changes (`union` and `closed`
+  become contextual keywords, `with(...)` in a collection expression binds differently);
+- an IDE host Metalama 2027 does not support shows no Metalama diagnostics, code lens or generated code, and
+  Visual Studio 2022 gets a LAMA0602 warning at build (Metalama's platform support document);
+- Metalama 2027 needs .NET SDK 10 or newer and declares 11 as its newest, so 3.0.0, or any SDK 12 build, will
+  need Metalama 2028;
+- a consumer on `Metalama.Patterns` or `Metalama.Extensions` 2026.1 has a floor and no ceiling, so it resolves to
+  Framework 2027 with no restore error (inferred; the manifest format is 1 in both, so LAMA0061 should not
+  fire; the mix is untested).
+
+The move holds when:
+
+1. **Metalama 2027.0 is stable.** A stable package should not depend on a prerelease: NU5104 is a warning, and
+   an error under the warnings-as-errors this repository sets.
+2. **A build with no Metalama license passes** in CI against it, as `dotnet.yml` has every job on 2026.1, and in
+   a clean container. The preview passed in a clean container (below); the general-availability build is
+   repeated, then a CI branch with the floor raised. A conventions test keeps `Metalama.Licensing`, whose
+   description says it fails a build without a valid license, out of the restore output.
+3. **The weaving review and the smoke test run on 2027.0:** a consumer on Metalama 2027 beside the packages,
+   one with a direct 2026.1 reference that shows the NU1605 the changelog describes, one on `Metalama.Patterns`
+   2026.1, and the design-time experience in Visual Studio, Rider and VS Code, which no command line shows.
+   The `[Durable]` placeholder in `ValueObjectAspect.Templates.cs` returns with the upgrade.
+4. **The ceiling is written where a consumer reads it:** 2.5.0's changelog "Changed" and the Generators README
+   name the Metalama version and both ways out, the language-version change on `net11.0`, the minimum IDE
+   versions with the silent failure named, and what Metalama 2027 drops (Visual Studio 2022, .NET SDK 8 and 9).
+5. **The line below the ceiling is declared:** whether 2.4.x gets patches after 2.5.0, and whether Metalama
+   2026.1 is still maintained then. ADR 4 says MIT maintenance covers only the latest `YYYY.N`, while Metalama's
+   versioning policy page, as summarised, lists 2026.1 as a long-term release; the two are not reconciled.
+
+A consumer that needs Metalama 2027 before TypeKit moves does not wait: a direct reference beside 2.x weaves
+(measured below, on the command line only). Metalama checks an order, not equality: compile-time code from
+another version is accepted when its manifest format matches (LAMA0061; both read in the 2026.1.31 and
+2027.0.4-preview sources by the research of 2026-10-29).
+
+**The 2.x line after 3.0.0** is decided with 3.0.0, not here.
+
+## Evidence
+
+SDK 11.0.100-rc.1.26425.128, a throwaway package `FloorLib` 1.0.0 with a `net10.0` group requiring
+`Newtonsoft.Json >= 12.0.3` and a `net11.0` group requiring `>= 13.0.3`. An application that references
+`Newtonsoft.Json 12.0.3` directly and `FloorLib`:
+
+- on `net11.0`: `NU1605`, "Detected package downgrade: Newtonsoft.Json from 13.0.3 to 12.0.3", with the path
+  `App -> FloorLib 1.0.0 -> Newtonsoft.Json (>= 13.0.3)`; an error under the SDK's defaults;
+- on `net10.0`: restores.
+
+A library with `net10.0` (`LangVersion` 14) and `net11.0` assets, whose `net11.0` asset alone declares
+`public union Pet(Cat, Dog)` and a method returning it, consumed by:
+
+- `net11.0`, C# 15 by default, with an exhaustive `switch` over the union: builds;
+- `net11.0` with `LangVersion` 14, holding the union in a `var` and printing it: builds;
+- `net11.0` with `LangVersion` 14, pattern matching on it: `CS9327`, "The feature 'unions' is not available in
+  C# 14.0. Use language version 15.0 or greater";
+- `net10.0`: builds, and sees only the shared members.
+
+The SDK needs no `preview` flag for any of it (RC1), as [KB-046](../knowledge/KB-046-csharp-15-unions-ship-with-the-net-11-sdk.md)
+says of RC2. So a union is addable on `net11.0` in a minor. What measurement one cannot make from this repository
+yet is the unions spike's: what `Option` and `Result` may offer a union without losing the guarantees above.
+
+**Metalama.** `net11.0` console projects on SDK 11.0.100-rc.1 with the 2.2.0 packages (Metalama 2026.1), a
+value object declared and used:
+
+- no union anywhere: builds and weaves;
+- a `union` declared in the project: `CS0106`, `CS8803` and `CS1001`, since Metalama's compiler runs the project
+  at language version 14, where unions are still a preview feature (the same declaration compiles with no
+  Metalama);
+- a union returned by a `net11.0`-only library: holding it builds; matching on it: `CS8652`, "unions are in
+  preview", where the same match compiles without Metalama.
+
+The same project with a direct `Metalama.Framework 2027.0.4-preview` reference beside the 2.2.0 packages
+weaves the value object, and a declared union with a `switch` over it builds and runs. `#error version` in the same
+projects names the compiler: Metalama's `2026.1.20` at language version 14.0 on `net10.0` and on `net11.0`, and
+`2027.0.4-preview` at 15.0 on `net11.0`, whatever the SDK. One limit on my runs: this machine has a Metalama
+license entry for 2027.0 in its licensing file and compiler servers were already running, so they say nothing
+about a build without a license. CI on 2026.1 does (`dotnet.yml`, every job runs with no Metalama license on
+the machine), and so did the review's run in a clean `mcr.microsoft.com/dotnet/sdk:10.0` container with
+`UseSharedCompilation=false` and warnings as errors: a `net10.0` application with the 2.2.0 packages and
+`Metalama.Framework 2027.0.4-preview` restored, wove and ran (`From`, `Parse`, JSON), and created no licensing
+file; the same with 2026.1.30. Not established: the general-availability build, the IDEs, and
+`Metalama.Patterns` beside it.
+
+Adding a target is not additive for a consumer on a lower version of a dependency, though. The roadmap's "EF Core
+11 and Microsoft.AspNetCore.OpenApi 11 in the satellites" is that case. It is allowed and documented under the
+first rule, and the test lane of that rule shows it.
+
+## Consequences
+
+- The roadmap's `net11.0` item names these rules, and its 3.0.0 item is unchanged except that it says what a
+  union may do in a 2.x minor. Decision 44's "unions in the public surface are 3.0.0" is narrowed here to a
+  union that changes an existing member; the maintainer's reading of Microsoft's compatibility guidance
+  (a newer target may add to an older one's surface), checked against the measurement above.
+- Decision 44 stands; its index row says it is refined here.
+- Metalama 2026.1 and the 2.2.0 packages build and weave a `net11.0` project on SDK 11 RC1 (measured above).
+  What #170 still owns is the rest of the SDK 11 spike, the general-availability SDKs and `rc.3` packages, the
+  analyzers on that compiler, the NU1605 measurement repeated there, and the license-free build on Metalama 2027.
+- The roadmap's Metalama 2027.0 item becomes 2.5.0 (#173), on the conditions above. Its old test, "a minor if a
+  consumer's own aspects still build and weave", missed the restore error of a direct lower reference, the
+  language-version change and the IDE hosts.
diff --git a/design/adr/README.md b/design/adr/README.md
index b4692bc5..245695ff 100644
--- a/design/adr/README.md
+++ b/design/adr/README.md
@@ -36,11 +36,11 @@ per area ([design](../plan.md)) link to the records they rest on.
 | [0027](0027-no-refusal-quotes-input.md) | No refusal quotes the input | 2026-09-28 | accepted |
 | [0028](0028-seams-declared-everything-else-refused.md) | Seams are declared, everything else refused | 2026-09-28 | accepted |
 | [0029](0029-only-result-terror-converts-bool.md) | Only `Result<TError>` converts to `bool` | 2026-09-28 | accepted |
-| [0030](0030-asynchronous-callbacks-return-task.md) | Asynchronous callbacks return `Task` | 2026-09-28 | accepted |
+| [0030](0030-asynchronous-callbacks-return-task.md) | Asynchronous callbacks return `Task` | 2026-09-28 | accepted; `CatchAsync` takes a `ValueTask` by [0110](0110-catchasync-takes-a-valuetask-at-a-lower-priority.md) |
 | [0031](0031-no-extension-object-unconstrained-t.md) | No extension on `object` or on an unconstrained `T` | 2026-09-28 | accepted |
 | [0032](0032-value-object-holds-wrapped-value-alone.md) | A value object holds its wrapped value alone, and its equality is that value's | 2026-09-28 | accepted |
 | [0033](0033-analyzers-run-code-metalama-transformed.md) | The analyzers run on the code Metalama transformed | 2026-09-28 | accepted |
-| [0034](0034-errors-fixed-within-major-version-warnings.md) | Errors are fixed within a major version; Warnings may learn | 2026-09-28 | accepted |
+| [0034](0034-errors-fixed-within-major-version-warnings.md) | Errors are fixed within a major version; Warnings may learn | 2026-09-28 | accepted; refined by [0118](0118-an-error-may-learn-a-form-only-new-api-can-write.md) |
 | [0035](0035-sqlite-s-autoincrement-application-s-line.md) | SQLite's autoincrement is the application's line, not the convention's | 2026-09-28 | accepted |
 | [0036](0036-nullable-value-object-admits-null-openapi.md) | A nullable value object admits null in the OpenAPI document wherever it appears | 2026-09-28 | accepted |
 | [0037](0037-refusal-s-message-landing-page.md) | A refusal's message is its landing page | 2026-09-28 | accepted |
@@ -50,7 +50,7 @@ per area ([design](../plan.md)) link to the records they rest on.
 | [0041](0041-sensitive-value-object-declares-tostring-serilog.md) | A sensitive value object is one that declares `ToString()`; Serilog gets a satellite | 2026-10-11 | accepted |
 | [0042](0042-2-0-0-next-release-bundles.md) | 2.0.0 is the next release, and it bundles the 1.x candidates | 2026-10-12 | accepted |
 | [0043](0043-exceptions-type-argument-constraints-constructor-guarantee.md) | Exceptions, type-argument constraints, a constructor guarantee and the text guards join 2.0.0 | 2026-10-13 | accepted |
-| [0044](0044-2-0-0-net10-0-metalama.md) | 2.0.0 is `net10.0` on Metalama 2026.1; the version number names the API, never the runtime | 2026-10-13 | accepted |
+| [0044](0044-2-0-0-net10-0-metalama.md) | 2.0.0 is `net10.0` on Metalama 2026.1; the version number names the API, never the runtime | 2026-10-13 | accepted; refined by [0120](0120-a-net11-0-target-and-documented-floor-raises-join-a-minor.md) |
 | [0045](0045-topic-pages-docs-compiled-like-readmes.md) | Topic pages in `docs/`, compiled like the READMEs; the plan in `design/` | 2026-10-13 | accepted |
 | [0046](0046-timeout-caught-result-catch-error.md) | A timeout caught by `Result.Catch` is the error | 2026-10-13 | accepted |
 | [0047](0047-firstornone-query-runs-query.md) | `FirstOrNone` on a query runs in the query | 2026-10-13 | accepted |
@@ -69,8 +69,8 @@ per area ([design](../plan.md)) link to the records they rest on.
 | [0060](0060-value-object-over-closed-set-generated-in-full.md) | A value object over a closed set is generated in full wherever the set is declared | 2026-10-13 | accepted |
 | [0061](0061-scope-s-fault-status-applies-where-fault-type-answered.md) | A scope's fault status applies where its fault type is answered | 2026-10-13 | accepted |
 | [0062](0062-asynchronous-callbacks-run-where-awaited-task-completed.md) | An asynchronous callback runs where the task it waited for completed | 2026-10-13 | accepted |
-| [0063](0063-char-keys-application-assigned-ulong-documented.md) | A key over `char` is the application's to assign; a default key over `ulong` throws at `Add` | 2026-10-13 | accepted; to 2.3 by [0097](0097-2-2-0-is-a-consolidation-release-and-the-gate-binds.md) |
-| [0064](0064-fault-name-reaches-client-causes-not-told-apart-one-fault.md) | A fault's name reaches the client; causes it must not tell apart are one fault | 2026-10-13 | accepted; its opt-in moved to 2.2 by [0088](0088-2-1-0-ships-without-its-open-roadmap-items.md); to 2.3 by [0097](0097-2-2-0-is-a-consolidation-release-and-the-gate-binds.md) |
+| [0063](0063-char-keys-application-assigned-ulong-documented.md) | A key over `char` is the application's to assign; a default key over `ulong` throws at `Add` | 2026-10-13 | accepted; to 2.3 by [0097](0097-2-2-0-is-a-consolidation-release-and-the-gate-binds.md); its `ulong` half superseded by [0114](0114-a-value-object-s-temporary-number-is-its-wrapped-type-s.md) |
+| [0064](0064-fault-name-reaches-client-causes-not-told-apart-one-fault.md) | A fault's name reaches the client; causes it must not tell apart are one fault | 2026-10-13 | accepted; its opt-in moved to 2.2 by [0088](0088-2-1-0-ships-without-its-open-roadmap-items.md); to 2.3 by [0097](0097-2-2-0-is-a-consolidation-release-and-the-gate-binds.md); the opt-in is [0111](0111-a-mapping-can-withhold-the-fault-name.md) |
 | [0065](0065-2-0-0-ships-without-preview.md) | 2.0.0 ships without a preview | 2026-10-14 | accepted |
 | [0066](0066-precondition-failed-malformed-fault-kinds.md) | Two more fault kinds: `PreconditionFailed` (412) and `Malformed` (400) | 2026-10-14 | accepted |
 | [0067](0067-rule-that-refused-on-fault.md) | A fault names the rule that refused, as a member of a fixed set | 2026-10-14 | accepted |
@@ -102,16 +102,28 @@ per area ([design](../plan.md)) link to the records they rest on.
 | [0093](0093-verified-facts-are-pinned-dated-and-executable-where-they-can-be.md) | Verified facts are pinned, dated and executable where they can be: one fact per file in `design/knowledge/`, a characterization test per observable fact, and `docs-query check` holding the pins to what is installed | 2026-10-15 | accepted; a cited fact is executable and an answer is a fixture beside the test by [0107](0107-a-cited-fact-is-executable-and-seeds-run-by-footprint.md) |
 | [0094](0094-topic-branches-into-a-release-branch-and-fix-trailers.md) | From 2.2.0, topic branches merge into a release branch with merge commits only, and every `fix:` commit carries `Defect-Class:` and `Found-By:` trailers, held by a test | 2026-10-15 | accepted |
 | [0095](0095-a-fix-is-tested-across-its-input-class.md) | A fix is tested across its input class: the fixer names the class, runs the fix's test over that class's variant catalogue (`TypeArgumentSites` for a type argument, the `shape.*` axes, the settings axes) and fixes the siblings it finds; `Found-By: VA` | 2026-10-15 | accepted |
-| [0096](0096-ci-replays-every-probe-and-the-release-runs-the-gate.md) | CI replays every probe, from an empty state, on every push and pull request, and a failing probe fails the run; the release replays them and runs the gate before it packs, the gate advisory; held by `ReleaseWiringTests` | 2026-10-15 | accepted; the gate binds from 2.2.0 by [0097](0097-2-2-0-is-a-consolidation-release-and-the-gate-binds.md); the build workflow's replay runs by family and footprint by [0101](0101-ci-replays-by-family-and-footprint.md) |
-| [0097](0097-2-2-0-is-a-consolidation-release-and-the-gate-binds.md) | 2.2.0 is a consolidation release: no public API, its additive items move to 2.3.0, and the probe gate binds from it | 2026-10-15 | accepted |
+| [0096](0096-ci-replays-every-probe-and-the-release-runs-the-gate.md) | CI replays every probe, from an empty state, on every push and pull request, and a failing probe fails the run; the release replays them and runs the gate before it packs, the gate advisory; held by `ReleaseWiringTests` | 2026-10-15 | superseded by [0112](0112-the-prober-gives-way-to-valueranges-oracle-kit.md) |
+| [0097](0097-2-2-0-is-a-consolidation-release-and-the-gate-binds.md) | 2.2.0 is a consolidation release: no public API, its additive items move to 2.3.0, and the probe gate binds from it | 2026-10-15 | accepted; the gate withdrawn by [0112](0112-the-prober-gives-way-to-valueranges-oracle-kit.md) |
 | [0098](0098-a-null-passes-no-comparison-in-a-query.md) | A nullable record-class value object compared with `<`, `<=`, `>` or `>=` in a query answers as SQL does, leaving out its null rows; documented, not refused | 2026-10-15 | accepted |
-| [0099](0099-a-probe-row-says-how-it-ended.md) | A probe row says how it ended: notes are a closed catalogue of keys and outcomes, a row that earned nothing is a skipped test labelled with its settings, a skip for a finding fails the replay once the finding is fixed and the gate while it stands, and a refused document is judged against ASP.NET alone | 2026-10-15 | accepted; note keys are a typed catalogue the compiler checks by [0103](0103-a-harness-error-is-never-a-catch-and-note-keys-are-constants.md); a refused document is compared by type and stage, and earns nothing in a check that compared nothing else, by [0108](0108-a-probe-check-earns-credit-against-a-baseline-and-ws2-closes.md) |
-| [0100](0100-every-probe-is-shown-to-fail-against-a-seeded-defect.md) | Every registered probe names a seeded product defect, and `prober seeds` (local, a build per seed) requires a violation it causes; the prober tests hold that every seed exists and applies; pairwise coverage is a floor, three-way combinations belong to the variant catalogue | 2026-10-15 | accepted; a seed per obligation of a claim by [0104](0104-a-claim-states-its-obligations-and-each-has-a-seed.md); seeds run by footprint, a release `--all`, by [0107](0107-a-cited-fact-is-executable-and-seeds-run-by-footprint.md) |
-| [0101](0101-ci-replays-by-family-and-footprint.md) | The build workflow replays the probes in legs by family, each running its probes in parallel, under a time limit: a push every probe with coverage and the merged state saved, a pull request only the probes it stales against its base branch's saved state and without a footprint; `prober merge` joins the legs and refuses a probe no leg saw | 2026-10-16 | accepted |
-| [0102](0102-an-exclusion-carries-its-reason.md) | Each `exclude` entry of claims.json is a required one-sentence reason and its pairs; the prober refuses a claims file its schema does not match, naming the claim and the field, so an invented reason field is refused; `prober universe` prints each exclusion's reason beside the claim's narrowings; the prober writes JSON with only JSON's own escapes, so an unchanged publish leaves a tracked file as it is | 2026-10-16 | accepted |
-| [0103](0103-a-harness-error-is-never-a-catch-and-note-keys-are-constants.md) | A harness error is never a catch: `Rec.Run` ends a row whose check throws as a harness error, not a violation, and `prober seeds` credits only a violation no harness error raised; note keys are members of a typed `NoteKeys` the compiler checks, and `register`, `publish` and a conventions test refuse a note or a skip whose key or finding is not written out | 2026-10-16 | accepted |
-| [0104](0104-a-claim-states-its-obligations-and-each-has-a-seed.md) | A claim lists its `obligations`, each a sentence quoted verbatim from its source, and what it does not promise in `not-promised`, each quoted from the document or record that makes it intended; a claim without the field has one obligation, `claim`; a probe carries a seed per obligation it checks, and the check without a build refuses a seed naming an unlisted obligation and a listed obligation no seed names; `status` shows each claim's obligations, and `prober gaps` reports what the corpus leaves out, deciding nothing | 2026-10-16 | accepted; `gaps` reads the last replay's evidence too by [0108](0108-a-probe-check-earns-credit-against-a-baseline-and-ws2-closes.md) |
+| [0099](0099-a-probe-row-says-how-it-ended.md) | A probe row says how it ended: notes are a closed catalogue of keys and outcomes, a row that earned nothing is a skipped test labelled with its settings, a skip for a finding fails the replay once the finding is fixed and the gate while it stands, and a refused document is judged against ASP.NET alone | 2026-10-15 | superseded by [0112](0112-the-prober-gives-way-to-valueranges-oracle-kit.md) |
+| [0100](0100-every-probe-is-shown-to-fail-against-a-seeded-defect.md) | Every registered probe names a seeded product defect, and `prober seeds` (local, a build per seed) requires a violation it causes; the prober tests hold that every seed exists and applies; pairwise coverage is a floor, three-way combinations belong to the variant catalogue | 2026-10-15 | superseded by [0112](0112-the-prober-gives-way-to-valueranges-oracle-kit.md) |
+| [0101](0101-ci-replays-by-family-and-footprint.md) | The build workflow replays the probes in legs by family, each running its probes in parallel, under a time limit: a push every probe with coverage and the merged state saved, a pull request only the probes it stales against its base branch's saved state and without a footprint; `prober merge` joins the legs and refuses a probe no leg saw | 2026-10-16 | superseded by [0112](0112-the-prober-gives-way-to-valueranges-oracle-kit.md) |
+| [0102](0102-an-exclusion-carries-its-reason.md) | Each `exclude` entry of claims.json is a required one-sentence reason and its pairs; the prober refuses a claims file its schema does not match, naming the claim and the field, so an invented reason field is refused; `prober universe` prints each exclusion's reason beside the claim's narrowings; the prober writes JSON with only JSON's own escapes, so an unchanged publish leaves a tracked file as it is | 2026-10-16 | superseded by [0112](0112-the-prober-gives-way-to-valueranges-oracle-kit.md) |
+| [0103](0103-a-harness-error-is-never-a-catch-and-note-keys-are-constants.md) | A harness error is never a catch: `Rec.Run` ends a row whose check throws as a harness error, not a violation, and `prober seeds` credits only a violation no harness error raised; note keys are members of a typed `NoteKeys` the compiler checks, and `register`, `publish` and a conventions test refuse a note or a skip whose key or finding is not written out | 2026-10-16 | superseded by [0112](0112-the-prober-gives-way-to-valueranges-oracle-kit.md) |
+| [0104](0104-a-claim-states-its-obligations-and-each-has-a-seed.md) | A claim lists its `obligations`, each a sentence quoted verbatim from its source, and what it does not promise in `not-promised`, each quoted from the document or record that makes it intended; a claim without the field has one obligation, `claim`; a probe carries a seed per obligation it checks, and the check without a build refuses a seed naming an unlisted obligation and a listed obligation no seed names; `status` shows each claim's obligations, and `prober gaps` reports what the corpus leaves out, deciding nothing | 2026-10-16 | superseded by [0112](0112-the-prober-gives-way-to-valueranges-oracle-kit.md) |
 | [0105](0105-every-tool-is-built-in-the-session-s-checkout.md) | SessionStart builds the guard in `$CLAUDE_PROJECT_DIR` and every other tool, through `tools/AgentTools.slnf`, in the session's own checkout; a hook, the prober, the smoke test and the verdict fall back to the SDK installer's `dotnet` when the one on PATH lacks the pinned SDK, and a session start that builds nothing tells the agent; the guard lets `dotnet msbuild -getProperty/-getItem` without a target through | 2026-10-17 | accepted |
 | [0106](0106-a-parameter-of-a-value-object-over-a-described-type-is-inlined.md) | A value object over a type the JSON options describe is written inline as a route, query, header or form parameter and as an element of a query or header array, where value objects are components: the component is its JSON positions'; every other value object keeps its reference; the schema below a parameter is asked for with the parameter's source and type alone | 2026-10-17 | accepted |
-| [0107](0107-a-cited-fact-is-executable-and-seeds-run-by-footprint.md) | A fact that prunes or excuses a row is executable: `docs-query check` fails `fact-not-executable-cited` where a refused entry, a not-promised entry, an obligation's declaration or the harness cites a fact without its test; a fact's measured answer is `KBNNN.fixture.json` beside its test, named by `fixture:`, read by a BCL-only reader the harness will use; `prober seeds` runs only the probes whose seeds identity or product footprint changed since every seed was caught, and a release runs `--all` | 2026-10-17 | accepted |
-| [0108](0108-a-probe-check-earns-credit-against-a-baseline-and-ws2-closes.md) | A probe row runs a check per obligation, each against a baseline, and the ledger credits checks; an excuse is a closed citation, applicability is declared on the obligation, the http, json and text harness compares three sides by exception type and stage, decision 99's refused document among them, and the twins and the context are generated with the shapes; `NoteKeys` keeps its pass keys and `framework-refuses`; `prober fix`, a covering array that places no blocked pair, and `gaps` listing the pairs no passing check read both axes of; WS2 closes, and WS3 to WS6 are dropped | 2026-10-17 | accepted; the gate passed on release/2.2.0 on 2026-10-18 (#62, with the fix #63 for the finding F4 the regenerated C21 rows raised) |
+| [0107](0107-a-cited-fact-is-executable-and-seeds-run-by-footprint.md) | A fact that prunes or excuses a row is executable: `docs-query check` fails `fact-not-executable-cited` where a refused entry, a not-promised entry, an obligation's declaration or the harness cites a fact without its test; a fact's measured answer is `KBNNN.fixture.json` beside its test, named by `fixture:`, read by a BCL-only reader the harness will use; `prober seeds` runs only the probes whose seeds identity or product footprint changed since every seed was caught, and a release runs `--all` | 2026-10-17 | accepted in part: its fixture rule stands; the rest superseded by [0112](0112-the-prober-gives-way-to-valueranges-oracle-kit.md) |
+| [0108](0108-a-probe-check-earns-credit-against-a-baseline-and-ws2-closes.md) | A probe row runs a check per obligation, each against a baseline, and the ledger credits checks; an excuse is a closed citation, applicability is declared on the obligation, the http, json and text harness compares three sides by exception type and stage, decision 99's refused document among them, and the twins and the context are generated with the shapes; `NoteKeys` keeps its pass keys and `framework-refuses`; `prober fix`, a covering array that places no blocked pair, and `gaps` listing the pairs no passing check read both axes of; WS2 closes, and WS3 to WS6 are dropped | 2026-10-17 | superseded by [0112](0112-the-prober-gives-way-to-valueranges-oracle-kit.md) |
+| [0109](0109-work-is-tracked-as-labelled-issues-and-ci-checks-each-pull-request.md) | Work is tracked as issues through the forms in `.github/ISSUE_TEMPLATE/`; a release is an `epic` with a milestone of its version and its work as sub-issues, beside the roadmap; issues and pull requests carry ValueRanges' labels (one type, a severity on a bug, `package/*`, `area/*`, `silent`, `breaking`, `found-by/prober`, `stacked`); a pull request opens with `Closes #n` and carries its issue's labels and milestone; `pr-hygiene.yml` runs `tools/PrHygiene` on the payload and fails a missing type, severity or closing reference, a branch whose `<type>/` disagrees with its type label, a pull request into `release/<version>` without that milestone, and a `breaking` one into anything but a major | 2026-10-18 | accepted; its required build checks replaced by `CI` in [0113](0113-ci-runs-the-lanes-a-change-can-affect.md) |
+| [0110](0110-catchasync-takes-a-valuetask-at-a-lower-priority.md) | `CatchAsync` has `ValueTask` forms marked `[OverloadResolutionPriority(-1)]`, so an `async` lambda binds to the `Task` form as before (measured); `Catch` refuses a `ValueTask` at run time still; `TraverseAsync` on `Option<T>` and `Patch<T>` awaits the one operation, and calls nothing and checks no token without a value | 2026-10-28 | accepted |
+| [0111](0111-a-mapping-can-withhold-the-fault-name.md) | A mapping withholds a member's name with `FaultResponse.WithoutFaultName()`: its problem has no `fault`, no `rule` and no member description as its detail; `IFaultFeature.NameWithheld` tells the host; a response whose every fault withholds its name is described as naming none; the same-name warning counts only members that write their name | 2026-10-28 | accepted |
+| [0112](0112-the-prober-gives-way-to-valueranges-oracle-kit.md) | The prober, its corpus, its seeds, the CI replay and the release gate are retired for CodoMetis.ValueRanges' oracle kit under `test/oracles/`: claims quoted verbatim and held by named tests, every public member claimed or waived, oracles as ordinary test classes each with a seed CI checks applies, candidates, and a hand-written axes file; `tools/Oracles seeds` builds one project and runs one class per seed | 2026-10-28 | accepted |
+| [0113](0113-ci-runs-the-lanes-a-change-can-affect.md) | CI runs the lanes a change can affect: each changed path selects Linux, Windows and the pack by its class in `tools/CiLanes` (Windows for the analyzers, the generators, tests and tools; the pack for the packages), a path no class names selects all three, a prose-only change runs only the test projects that read prose (`test/Prose.slnf`), and only a pull request into `main`, a push to `main`, the nightly and the release run macOS; a gate job, `CI`, over every job is the required check; a convention test refuses non-portable file names; `release.yml` calls the build workflow before it verifies | 2026-10-29 | accepted |
+| [0114](0114-a-value-object-s-temporary-number-is-its-wrapped-type-s.md) | A value object over a number gets the temporary values a property of its wrapped type gets, from a factory in its converter's mapping hints, which EF consults after a generator on the property and after HiLo: a default `ulong` key no longer throws at `Add`, and a `char` key configured on add gets a temporary `char` on SQL Server; under `--nativeaot` the factory is lost and a default `ulong` key still throws | 2026-10-29 | accepted |
+| [0115](0115-value-objects-can-be-inlined-everywhere.md) | `AddTypeKit(typeKit => typeKit.InlineValueObjects = true)` writes every value object in place, by its wrapped type's schema, in every position and version, with no component of its own; off by default, the document unchanged; closed sets and wrapped enums keep their components; an inlined value object claims no name (decision 55) and shares no schema between its JSON positions and its parameters (decision 106) | 2026-10-29 | accepted |
+| [0116](0116-the-docs-site-is-docfx-built-from-main.md) | The docs site is DocFX, published to GitHub Pages from `main` alone: the guides, the READMEs, the changelog and the API pages of the run-time packages, from the files as they are; a link to a file that is not a page becomes a GitHub address at the built commit; a pull request touching a page builds it with warnings as errors; `site/**` is prose; DocFX 2.81.0 lists the members of C# 14 extension blocks as extension methods | 2026-10-29 | accepted |
+| [0117](0117-a-seed-is-caught-against-a-passing-baseline.md) | `oracles seeds` credits a seed only when its oracle passes without it, in a baseline run with the same build and filter, and fails with it in a test of its own; a run that never reached the tests (a fixture xunit could not set up, an error counted outside any test, a crashed host, no TRX, every test skipped) or a failing baseline is `ERROR`, exit 4, never `CAUGHT` | 2026-10-29 | accepted |
+| [0118](0118-an-error-may-learn-a-form-only-new-api-can-write.md) | An Error may report, in a minor version, a form that only an API new in that version can write, since no build that worked before contains it: CMTK0003's dropped assertion of `CodoMetis.TypeKit.Testing` on a `Task` or `ValueTask` in 2.3.0, its `ConfigureAwait`, `WaitAsync` and branch forms (#152) included, known by the package's assembly; the forms freeze at the tag; refines decision 34; one exception the maintainer took into 2.3.0, a dropped `Task.WhenAny` of tasks of results (#159) | 2026-10-29 | accepted; widened by [0119](0119-a-gap-found-before-the-tag-ships-in-that-release.md) |
+| [0119](0119-a-gap-found-before-the-tag-ships-in-that-release.md) | A form an Error misses, found before its version is tagged, is reported in that version when it loses what the rule protects in every build, though code built on the previous minor can contain it: 2.3.0's CMTK0003 on a `Task.WhenAny` of results (#159), `Wait()` on a branch (#160), an array in `Task.WaitAll`/`WaitAny` (#161), a dropped `Task.WhenEach` (#162), and a `WhenAny` of held tasks silent; the rule stops at the tag, after which decision 34 holds; refines 34 and 118 | 2026-10-29 | accepted |
+| [0120](0120-a-net11-0-target-and-documented-floor-raises-join-a-minor.md) | A `net11.0` target joins a 2.x minor when a feature needs it, and a dependency floor may rise in a minor, on every target or on `net11.0` alone, if it is documented (the Semantic Versioning FAQ calls a dependency update with an unchanged public API compatible; a project that references the dependency lower gets NU1605, measured on SDK 11 RC1, so the changelog names the floor, who it reaches and both ways out, and the smoke test shows it); a union new on `net11.0` is an addition and may join a 2.x minor (a `LangVersion` 14 consumer who matches on it gets CS9327, and on Metalama 2026.1 CS8652, measured); Metalama is one version for every target and TypeKit follows the maintained Metalama year in a minor: 2.3 and 2.4 stay on 2026.1 and 2.5.0 moves both targets to 2027.0 once stable (a direct 2026.1 reference gets NU1605 and stays on 2.4.x; a woven `net11.0` project goes from C# 14 to 15; conditions: a license-free CI and clean-container build, the ceiling and the 2.4.x line documented); the SDK 11 spike comes first (#170); 3.0.0 stays the `net10.0` drop and a change of an existing contract, timed to .NET 12 LTS, and .NET 11 is no reason for a major; refines decision 44 | 2026-10-29 | accepted |
diff --git a/design/analyzers.md b/design/analyzers.md
index e5a61fce..a1054091 100644
--- a/design/analyzers.md
+++ b/design/analyzers.md
@@ -33,18 +33,19 @@ exist.
 |---|---|---|---|
 | CMTK0001 | No `default`/`default(T)`/`new()`/`new T()` of a value object or a `[RequireCustomInitialization]` type. An operand of `==`/`!=`, or an argument of a call whose name has the word `Equal`, `Equals` or `Compare` or ends in `Be` (`ThrowIfEqual`, `Assert.NotEqual`, `ShouldNotBe`), is exempt: a guard check is the only defence against the defaults the rule cannot see. So is a `default` assigned to an `out` parameter of a method returning `bool`, the Try pattern. Where a sibling branch does not bind (same-project value objects), the target type is taken from the enclosing conditional, switch arm or collection | Error | shipped in 1.0.0 |
 | CMTK0002 | Type implements `IValue<>`/`IValidatedValue<,,>`, but the compilation does not reference `CodoMetis.TypeKit.Generators`, so it is never woven | Error | shipped in 1.0.0 |
-| CMTK0003 | `Result`/`Option` a call returns, dropped by an expression statement, awaited or not, or a `Task` of one converted to a plain `Task` (`Task Cancel() => CancelAsync();`); `_ =` opts out. `Tap`, `TapAsync`, `TapError` and `TapErrorAsync` on a stored result or task are exempt, since they return their receiver, and so is a chain of them on one (`r.Tap(log).TapError(warn)`, `(await pending).Tap(log)`, `pending.WaitAsync(t).TapAsync(log)`), measured as an Error's false report before 2.0.0 was tagged; so is such a tap converted to a plain `Task` or waited for (`Task Log() => pending.TapAsync(log);`, `held.TapAsync(log).Wait()`), on a `Result` and on a `Task` of one, which an independent review found reported on 2026-10-14. Also a collection of results the statement made (an array, `ICollection<T>` or `IReadOnlyCollection<T>`, such as `await Task.WhenAll(ids.Select(orders.CancelAsync))`), and a method group of a `Task<Result>` method converted to a delegate returning `Task`; tasks held in variables are silent, and so is a lazy `IEnumerable<T>`, where nothing has run, unless a call that was given no result returned it and the statement materialises it. Also `Wait` on a task the expression made, tasks of results the statement made converted to plain ones (`Task.WaitAll`, `WaitAny`), and a `foreach` or `await foreach` over results its header made whose body never reads the iteration variable; a variable named `_` opts out. CA1806 can only enforce this per method name, not per return type | Error | shipped in 1.0.0 at Warning; Error in 2.0.0 ([decision 50](adr/0050-warnings-cmtk0003-alone-becomes-error-2.md)), its 1.x gaps closed first |
+| CMTK0003 | `Result`/`Option` a call returns, dropped by an expression statement, awaited or not, or a `Task` of one converted to a plain `Task` (`Task Cancel() => CancelAsync();`); `_ =` opts out. `Tap`, `TapAsync`, `TapError` and `TapErrorAsync` on a stored result or task are exempt, since they return their receiver, and so is a chain of them on one (`r.Tap(log).TapError(warn)`, `(await pending).Tap(log)`, `pending.WaitAsync(t).TapAsync(log)`), measured as an Error's false report before 2.0.0 was tagged; so is such a tap converted to a plain `Task` or waited for (`Task Log() => pending.TapAsync(log);`, `held.TapAsync(log).Wait()`), on a `Result` and on a `Task` of one, which an independent review found reported on 2026-10-14. Also a collection of results the statement made (an array, `ICollection<T>` or `IReadOnlyCollection<T>`, such as `await Task.WhenAll(ids.Select(orders.CancelAsync))`), and a method group of a `Task<Result>` method converted to a delegate returning `Task`; tasks held in variables are silent, and so is a lazy `IEnumerable<T>`, where nothing has run, unless a call that was given no result returned it and the statement materialises it. Also `Wait` on a task the expression made, tasks of results the statement made converted to plain ones (`Task.WaitAll`, `WaitAny`), and a `foreach` or `await foreach` over results its header made whose body never reads the iteration variable; a variable named `_` opts out. From 2.3.0, an assertion of `CodoMetis.TypeKit.Testing` on a `Task` or `ValueTask` of what it checks, dropped by an expression statement without `await`: `service.FindAsync(id).ShouldBeNone();`, the lowered static call, through `?.`, the body of a lambda that returns nothing, through `ConfigureAwait` or `WaitAsync` of the `Task` or `Task<T>` it returns (every overload), and at each branch of a `?:`, `??` or `switch` expression so passed through, judged by the path every dropped call takes (#152); handed to `Task.WhenAll`, `Task.Run` or `Task.WhenEach` whose task is dropped, or to `Task.WhenAny` or `Task.WaitAny` in any use, as arguments, an array, a collection expression, a `Select`, a query, a `ToList`, a method group or an `async` lambda that awaits it with no `catch` between that keeps its failure, and a `WhenAny` of them converted to a plain `Task` or waited for, and a loop that never reads the assertions its header made (#157); `Task.WaitAll` throws, so it is silent. A combinator inside another is judged by how deep its task holds the failure: `WhenAll` and `Run` fault with a task that faults, `WhenAny`, `WhenEach` and an `async` lambda that returns the task complete with it as a value, each `await` unwraps one, and an awaited, waited-for or converted combinator observes only a failure at depth 0, so `await Task.WhenAll(Task.WhenAny(…))` and `await Task.Run(() => Task.WhenAny(…))` report, at any depth, and `await await Task.WhenAny(…)` is silent (#165). A `catch` keeps the failure only when its `try` block throws it, its type is or is a base of `TypeKitAssertionException` (resolved in the Testing assembly), and its handler can complete, which a constant `false` filter leaves unreachable: `catch { throw; }`, a log and `throw;`, `throw new …`, `catch (OperationCanceledException)` and `when (false)` hand it on and report; a filter that is no constant counts as keeping it, since an Error reports only a failure lost whatever the filter answers (#166). It fails the test only through its task. Known by the package's assembly, so a consumer's extension of the same name on a pending result is silent; awaited, held, returned or discarded with `_ =`, it is silent too, and so are held tasks combined. Also from 2.3.0, on tasks of results, forms 2.2.0 code can contain: a `Task.WhenAny` of tasks the statement made, in any use (#159; of held tasks it is silent, where 2.2.0 reported it awaited), `Wait()` on a `?:`, `??` or `switch` (#160), an array written in `Task.WaitAll` or `Task.WaitAny` (#161) and a dropped `Task.WhenEach` (#162). All held by `DroppedTaskVariantTests` over `Variants/DroppedTaskShapes`, 1837 cases. CA1806 can only enforce this per method name, not per return type | Error | shipped in 1.0.0 at Warning; Error in 2.0.0 ([decision 50](adr/0050-warnings-cmtk0003-alone-becomes-error-2.md)), its 1.x gaps closed first; the dropped pending assertion in 2.3.0, a form only 2.3.0's API writes ([decision 118](adr/0118-an-error-may-learn-a-form-only-new-api-can-write.md)), its nested combinators and catches (#165, #166) included; the 2.2-writable forms #159 to #162 in 2.3.0, gaps found before the tag ([decision 119](adr/0119-a-gap-found-before-the-tag-ships-in-that-release.md)) |
 | CMTK0004 | `IValueObjectMaterializer<,>.Materialize`, `ValueObjectConverter<,>.Materialize` or a hand-written value object's public `Materialize`, called or referenced (expression trees included). The satellite's own call is compiled in the satellite; EF's compiled model is generated code, whose diagnostics are not reported (measured: reported, it is six errors in the smoke test's AOT consumer). `StoredJsonConverterFactory` goes through `IStoredJsonConverterSource`, not `Materialize` | Error | shipped in 1.0.0 |
 | CMTK0005 | `new T[n]`, `stackalloc T[n]`, `GC.AllocateUninitializedArray/AllocateArray<T>` or `Array.Resize` of a no-default struct: every new slot starts as `default`. A constant length of zero (for `Array.Resize` and the `GC` methods too) or initial elements are silent | Warning | shipped in 1.0.0 |
 | CMTK0006 | Field or auto-property of a no-default struct type in a class that no initializer, `required` or constructor sets; a non-public parameterless constructor (EF, serializers) and a record's copy constructor are exempt. Measured 2026-09-28 on the repository's EF entities and request types: 12 of 12 reports on settable properties of a type with only the implicit constructor, each a real way to a default. `required`, the fix the message names where it compiles, works with EF's compiled model, precompiled queries and Native AOT (the smoke test rerun with it). A `[SetsRequiredMembers]` constructor must assign the `required` members it promises | Warning | shipped in 1.0.0 |
 | CMTK0007 | `FromKnownGood` given a value straight from a parameter of the enclosing method or lambda, or a member or element of one. A value the code produced itself is legitimate and silent; a parameter copied into a local first is not seen. Info, since test theories and helpers that only receive constants are reported too | Info | shipped in 1.0.0 |
 | CMTK0008 | The wrapped values of two different value objects compared (`==`, `!=`, ordering, `Equals`, `CompareTo`) through `.Value`, `?.Value`, `GetValue()` or `ValueOrNull()`: the typed ids unwrapped into the bug they prevent. Recognised by syntax, since `.Value` of a same-project value object does not bind where analyzers run. Also `string.Equals`, `object.Equals`, a comparer's `Equals`, `string.Compare`/`CompareOrdinal` over two such values (the forms MA0006 rewrites `==` into), and two value objects of different types through `Equals(object)`, which is always false. Also a LINQ join on two such values: a query's `join … on a.Value equals b.Value`, with or without `into`, and `Join`/`GroupJoin`/`LeftJoin`/`RightJoin` of `Enumerable`, `Queryable` and `AsyncEnumerable` whose key selectors are lambdas returning them, resolved by symbol, with the candidates where a key selector does not bind; a composite key is not looked into. A raw value on one side, or an explicit cast, is silent | Warning | shipped in 1.0.0 |
-| CMTK0009 | A call that returns the `default` of a no-default struct when it finds nothing: `Enumerable`/`Queryable` `FirstOrDefault`, `LastOrDefault`, `SingleOrDefault`, `ElementAtOrDefault`, `DefaultIfEmpty` without a default value, `Nullable<T>.GetValueOrDefault()`, `GetValueOrDefault(dictionary, key)`, `Activator.CreateInstance`, `RuntimeHelpers.GetUninitializedObject`, and `Option.OrDefault()`. The message names `FirstOrNone`, `GetValueOrNone` or `Or`. Warning, since a sequence checked for emptiness first is correct. Also `ImmutableArray`'s own, `Find`/`FindLast` of `List<T>`, `Array` and `ImmutableList<T>`, `ImmutableDictionary.GetValueOrDefault` and the immutable builders', and the async `FirstOrDefaultAsync`, `LastOrDefaultAsync`, `SingleOrDefaultAsync` and `ElementAtOrDefaultAsync` of `System.Linq.AsyncEnumerable` and EF Core, whose type is the method's type argument; EF Core's only where the project references it | Warning | shipped in 1.0.0 |
+| CMTK0009 | A call that returns the `default` of a no-default struct when it finds nothing: `Enumerable`/`Queryable` `FirstOrDefault`, `LastOrDefault`, `SingleOrDefault`, `ElementAtOrDefault`, `DefaultIfEmpty` without a default value, `Nullable<T>.GetValueOrDefault()`, `GetValueOrDefault(dictionary, key)`, `Activator.CreateInstance`, `RuntimeHelpers.GetUninitializedObject`, and `Option.OrDefault()`. The message names `FirstOrNone`, `GetValueOrNone` or `Or`. Warning, since a sequence checked for emptiness first is correct. Also `ImmutableArray`'s own, `Find`/`FindLast` of `List<T>`, `Array` and `ImmutableList<T>`, `ImmutableDictionary.GetValueOrDefault` and the immutable builders', and the async `FirstOrDefaultAsync`, `LastOrDefaultAsync`, `SingleOrDefaultAsync` and `ElementAtOrDefaultAsync` of `System.Linq.AsyncEnumerable` and EF Core, whose type is the method's type argument; EF Core's only where the project references it. From 2.3.0, with a message of its own, `FirstOrNone`, `SingleOrNone`, `LastOrNone`, `FirstOrError` and `LastOrError` on a receiver that is an `IQueryable<T>` (an implementer or a type parameter constrained to one included) bound to the `IEnumerable<T>` overload because the condition is a delegate: a `Func` variable, field or property, a method group, an anonymous method, a call that returns one. A receiver typed as a sequence, `AsEnumerable()` or a cast, is silent; no code fix, since the condition's rewrite is the author's (#129) | Warning | shipped in 1.0.0 |
 | CMTK0010 | A type argument that breaks a constraint attribute on its parameter (`[Abstract]`, `[Sealed]`, `[Record]`, `[Concrete]`; from 2.1.0 also `[Interface]`, `[Unsealed]`, `[ValueObject]`, `[ClosedSet]`, `[FlagsEnum]`, `[ReadOnlyStruct]`, [decision 81](adr/0081-six-more-kinds-of-type-argument.md), the two marker ones proved by a bound to the marker, the other four by the attribute alone; an interface is no value object, [decision 85](adr/0085-an-interface-is-no-value-object.md); a proof reads what a closed use can be, [decision 84](adr/0084-cmtk0010-proofs-read-what-a-closed-use-can-be.md)), or a pair of arguments for two parameters marked `[Distinct]` or `[Unrelated]` (2.1.0, [decision 79](adr/0079-distinct-and-unrelated-type-parameters.md)) that are one symbol (nullable annotations aside, `dynamic` as `object`) or related by an implicit identity, reference or boxing conversion either way, reported once at the later argument, a forwarding pair a breach unless both carry the attribute in one generic or their C# constraints admit no common (or no related) type, at any closed use: a base type, an implemented interface, a member type, a local, a `typeof`, a call with its type arguments written (at the argument) or inferred (at the call), a method group whose arguments the delegate infers (at the group). A type parameter forwarded without the same attribute is a breach too, unless its C# constraints leave it no breaking argument: `struct`/`unmanaged` or a bound proving `[Sealed]` proves `[Sealed]`; `new()` or whatever proves `[Sealed]` proves `[Concrete]`; a bound that is or proves a record proves `[Record]` (CS8865); nothing but the attribute proves `[Abstract]`. `[Concrete]` accepts an enum, a delegate and `dynamic`, as `new()` and `struct` do for an enum. A default interface method reached through a derived interface carries its own constraint once: it was its own implementation there, and the rule recursed until the compiler's stack overflowed (an independent review, 2026-10-14). Both settled 2026-10-13 before the tag, measured as false reports (an enum, a delegate, `dynamic`; six forwarding forms) with no miss among their neighbours. The open generic in its own body and an unbound `typeof` are silent. Reflection is out of reach | Error | built 2026-10-13 for 2.0.0 (phase 13), a major, so Error is within [decision 34](adr/0034-errors-fixed-within-major-version-warnings.md) |
 | CMTK0011 | A concrete class implementing or deriving from a type marked `[RequireParameterlessConstructor]`, directly or through another type, without a parameterless constructor of the required accessibility; a class declaring no constructor satisfies `Public`. A struct is never reported (decided 2026-10-13, before the tag): its parameterless constructor, implicit or declared, is public and can be nothing else (CS8958), so it satisfies `Public` as it is, and under any other accessibility the rule reported an Error only a suppression could answer, and the fix wrote a constructor that did not compile. A wrong accessibility is reported at the constructor. The code fix, the package's first, in `CodoMetis.TypeKit.Analyzers.CodeFixes.dll` beside the analyzer, writes or changes the constructor; a type with a primary constructor in any of its parts gets none (CS8862), nor, since 2026-10-14, one whose implicit `base()` binds to nothing (CS7036, CS0122, CS0121), which a review found the fix writing. It writes its own trivia and asks no formatter, which laid out the whole type again and wrote the machine's line endings: doc comments, attributes, comments and the members' layout stay, added lines take the members' indentation and the brace's line ending, a one-line type gets the constructor on its line | Error | built 2026-10-13 for 2.0.0 (phase 13) |
 | CMTK0012 | A closed set's generated `Match` given an argument by position: every parameter is a `Func<TResult>` in declaration order, so reordering two members swapped their branches and compiled. Bound, only the generated signature counts; unbound (the declaring project, before weaving), a call named `Match` on a closed set with one argument per member, its names the generators' rule (the member's name, first letter lower-cased, a keyword escaped). The code fix names every argument after the parameter it binds to now | Error | built 2026-10-13 for 2.0.0 (phase 13), after a review found the swap |
 | CMTK0013 | A closed set's member written outside its declaration: an assignment, compound or `??=`, a deconstruction, an increment, a `ref` or `out` argument, or a writable `ref` taken to it, each also through a `ref` conditional (`(flag ? ref Open : ref Closed) = x`, found by the review of the rule itself). A `ref readonly` local or field reassigned to a member reads it and is silent (a false report found by the weaving review, 2026-10-14). C# allows such a write only in the set's static constructor and static field initializers, which run before (initializers) or after (the constructor's body) the generated initializer that names the members and fills `All`; either way an instance answered to another member's name, `Match` took another's branch, and `All` disagreed with `Parse`. An analyzer, not the aspect: Metalama 2026.1's code model gives no operations of a constructor body, and a textual scan would miss a deconstruction or a `ref` | Error | built 2026-10-14 for 2.0.0, a major, after a review reproduced the swap against the packed generators |
 | CMTK0014 | A `FaultKind` or `ConstructorAccessibility` constant that names no member: a conversion, a `default`, or a folded binary or unary expression or constant conditional, judged only at the outermost, so an operand folded into a member is silent; one only compared (equality, relational, pattern, `case`) is a guard. The members are read from the enum's fields, never listed ([decision 70](adr/0070-undefined-enum-value-warning.md)) | Warning | built 2026-10-14 for 2.1.0 |
+| — | Add Create: the fix for the compiler's CS0535 where the missing member is `IValidatedValue`'s `Create`, matched by the message's `.Create(` (one CS0535 per missing member, at the base type that brings it, the contract or an interface deriving from it) and by the symbols: `TSelf` the type itself, no member `Create` taking a `T`. It writes a public static `Create` that returns `new TSelf(value)`, its types spelled minimally at the type, and lays it out with its own trivia as CMTK0011's fix does (`TypeLayout`); a body on one line that holds members gets none. Swept over `TypeArgumentKinds` for the wrapped type and the fault and over the declaration shapes (`MissingCreateVariantTests`); the Generators README's block is its output, compiled and generated by the Samples (#82) | — | built 2026-10-29 for 2.3.0 |
 | — | Code fixes for the aspect's shape diagnostics CMTK1000–1002 (missing `partial`/`record`/`readonly`) | — | proposed. The aspect keeps its own error as a backstop |
 
 **Rules that read calls see the source before weaving (measured 2026-09-28).** Metalama runs
@@ -77,5 +78,7 @@ still runs on the source, where the name-based forms above remain the reach.
 **Release discipline.** Keep `AnalyzerReleases.Shipped/Unshipped.md` tracking (RS2008). A new rule
 ships at Warning or Info in a minor version and is raised to Error only in a major. Consumers
 build with warnings as errors, so a new Error rule in a minor version would break their builds on
-update. Within a major version an Error never reports more than it did; a Warning or Info may learn
-more forms in a minor version ([decision 34](adr/0034-errors-fixed-within-major-version-warnings.md), stated in the analyzer README).
+update. Within a major version an Error never reports more than it did, unless the form is one only
+that minor version's new API can write ([decision 118](adr/0118-an-error-may-learn-a-form-only-new-api-can-write.md)),
+or a gap found before the version's tag ([decision 119](adr/0119-a-gap-found-before-the-tag-ships-in-that-release.md));
+a Warning or Info may learn more forms in a minor version ([decision 34](adr/0034-errors-fixed-within-major-version-warnings.md), stated in the analyzer README).
diff --git a/design/code-graph.md b/design/code-graph.md
new file mode 100644
index 00000000..0928df8c
--- /dev/null
+++ b/design/code-graph.md
@@ -0,0 +1,35 @@
+# The code graph
+
+The codebase-memory MCP server keeps a graph of this repository, the project `CodoMetis.TypeKit`.
+[AGENTS.md](../AGENTS.md), "Finding code", says how to use it: the graph leads and the source decides.
+This note holds what that rests on: what the graph was measured to find and miss.
+
+## What it finds and misses
+
+Measured on 2026-10-13, the graph:
+
+- finds types, interfaces, enums and ordinary methods, a type's implementers through generic interfaces
+  (84 of the Samples' 88 value objects), and the callers of an ordinary method across files;
+- has no node for a member of a C# 14 `extension(...)` block, which holds most of the `Option` and `Result`
+  extensions (`Choose`, `FirstOrNone`, `Transpose`, `Sequence`, the continuations of a `Task<Result<...>>`)
+  and `AsText`, and puts the calls inside one on the file;
+- has nothing Metalama generates: none of the tests' 222 `.From(` calls has an edge, nor has a call to
+  `TryFrom`, `FromKnownGood`, `Parse` or a converter, and a template an aspect introduces by `nameof` looks
+  unreferenced. Read woven code as the Generators README's "Reading the generated code" says;
+- misses a reference that is not a call: a DI registration, a type argument, `typeof`, an attribute;
+- resolves a call on a generic instance poorly (`Option<T>.Match` has one resolved caller, where the
+  repository writes `.Match(` about 200 times across its types) and guesses wrong callers: a low-confidence
+  `suffix_match` edge, or a same-named method of another API (Metalama's `Diagnostics.Report` listed as
+  calling `GeneratedCode.Report`). Overloads share one node.
+
+## Keeping it current
+
+The graph does not follow the working tree. `index_repository` with the repository root as `repo_path` and
+`name: "CodoMetis.TypeKit"` refreshes it in about 6 s; without `name` it starts a second project under a
+derived name. `index_status` reports the checkout's HEAD, not the commit the graph was built from, so
+refresh rather than check.
+
+It indexes `spikes/` and leaves out `.claude/`, `bin` and `obj`. So an agent in a worktree under
+`.claude/worktrees/` reads the main checkout's graph, not its own: it indexes the worktree under a name of
+its own and deletes that project when done, or searches the source. `.codebase-memory/`, the tool's local
+artifact, is ignored by git.
diff --git a/design/ef-core.md b/design/ef-core.md
index b1b3a94b..f83a23f2 100644
--- a/design/ef-core.md
+++ b/design/ef-core.md
@@ -108,11 +108,13 @@
       leaves out (read from the model; no SQL Server here). On SQL Server the value object's key, declared generated, got a permanent
       character of a GUID string at `Add`, which was stored. It is `Never`, as in 1.5.1; an explicit
       `ValueGeneratedOnAdd()` or value generator still applies. A default `'\0'` is stored as it is.
-    - **A default key over `ulong` throws `OverflowException` at `Add`** on SQL Server and PostgreSQL,
-      whose column is a `decimal`: EF's temporary `decimal` is negative. A plain `ulong` key gets a
-      temporary `ulong`. It stays declared generated, since it fails loudly and a fix needs a value
-      generator per key that a compiled model can write and that leaves HiLo alone; the workaround is
-      `ValueGeneratedNever()` and an assigned key, which a test pins with the exception.
+    - **A default key over `ulong` threw `OverflowException` at `Add`** on SQL Server and PostgreSQL,
+      whose column is a `decimal`: EF's temporary `decimal` is negative. Since 2.3.0 ([decision 114](adr/0114-a-value-object-s-temporary-number-is-its-wrapped-type-s.md))
+      a value object over a number gets the temporary values of its wrapped type, from a factory in its
+      converter's mapping hints, which EF consults after a generator on the property and after HiLo
+      ([KB-047](knowledge/KB-047-a-converter-s-hints-factory-comes-after-hilo.md)). The same reaches a `char`
+      key configured on add, which got a character of a GUID string on SQL Server. `--nativeaot` writes the
+      mappings out as code without the factory, so there a default `ulong` key still throws, and a test pins it.
 - **Conventions for the wrapped type do not reach a value object.** `ConfigureConventions`
   (`Properties<decimal>()`) matches the property's CLR type; the README says to configure the value
   object (`Properties<Amount>()`). Measured 2026-09-28 for precision, maximum length, column type and
diff --git a/design/finder-benchmark-2026-10-16.md b/design/finder-benchmark-2026-10-16.md
index 66b433ad..3d1b016c 100644
--- a/design/finder-benchmark-2026-10-16.md
+++ b/design/finder-benchmark-2026-10-16.md
@@ -57,7 +57,7 @@ violates (L01's row #242 ends inconclusive, seeded and unseeded alike). A probe
 `prober seeds` counts a catch ([decision 103](adr/0103-a-harness-error-is-never-a-catch-and-note-keys-are-constants.md)):
 a row that ends as a violation, raised no harness error, and does not violate unseeded. A seed was run
 against the probes of the surfaces its fix touched (the surfaces in `claims.json`, matched to the files
-the fix changed by the `watched` paths of [.claude/probe-axes.md](../.claude/probe-axes.md); a
+the fix changed by the `watched` paths of `.claude/probe-axes.md` (retired by [decision 112](adr/0112-the-prober-gives-way-to-valueranges-oracle-kit.md)); a
 Generators fix took the generation, text and JSON probes): HTTP 12 probes, EF 16, generators 13,
 Option/Result 8. To save builds, the seeds of one surface ran together first and each probe that failed
 was then run on each seed alone; every catch attributed this way is a single seed's, and a probe that
diff --git a/design/knowledge/KB-012-thinktecture-value-objects.md b/design/knowledge/KB-012-thinktecture-value-objects.md
index ce16a7bb..b1e85e19 100644
--- a/design/knowledge/KB-012-thinktecture-value-objects.md
+++ b/design/knowledge/KB-012-thinktecture-value-objects.md
@@ -1,20 +1,23 @@
 ---
-verified: 2026-09-28
+verified: 2026-10-29
 pins:
-  - external Thinktecture.Runtime.Extensions 10.5.0
-source: the Thinktecture.Runtime.Extensions repository at tag 10.5.0 and its nuspecs on api.nuget.org, read by a research agent
+  - external Thinktecture.Runtime.Extensions 10.6.0
+source: the Thinktecture.Runtime.Extensions repository at tag 10.6.0 (commit e3f41f7a), its release notes from 10.5.0 to 10.6.0, and its nuspecs and nupkgs on api.nuget.org, read by a research agent; first read at 10.5.0 on 2026-09-28
 turned-on: the Thinktecture column of the value-object table and the rows of "Choose something else when" that name it in docs/comparison.md
 test: none, a competitor's feature, read from its source and package
 ---
 
-# KB-012. Thinktecture.Runtime.Extensions 10.5.0 declares value objects, smart enums and unions by attribute, for net8.0 and net9.0
+# KB-012. Thinktecture.Runtime.Extensions 10.6.0 declares value objects, smart enums and unions by attribute, for net8.0 and net9.0
 
 - Declared by attribute on a partial type: `[ValueObject<T>]`, `[ComplexValueObject]` (several members),
   `[SmartEnum<T>]` and `[Union]`.
 - Validation is a `ValidateFactoryArguments` partial method.
 - EF Core through a package per EF Core version (8, 9, 10). JSON through System.Text.Json, Newtonsoft.Json and
-  MessagePack packages.
-- Targets `net8.0` and `net9.0`. License BSD-3-Clause.
+  MessagePack packages. Packages for ASP.NET Core, Swashbuckle and Serilog too.
+- Targets `net8.0` and `net9.0`, no `net10.0`. License BSD-3-Clause (the license file's text; the nuspec names no
+  SPDX id). Generated by Roslyn incremental source generators.
+- 10.6.0 (2026-10-19) changed only Swashbuckle files and dependency floors since 10.5.1; 10.5.0 added enum types
+  as smart-enum keys.
 
-Its OpenAPI and Native AOT facts, at 10.5.1, are [KB-013](KB-013-thinktecture-openapi-and-native-aot.md); its
-smart enums, [KB-022](KB-022-thinktecture-smart-enums.md).
+Its OpenAPI and Native AOT facts are [KB-013](KB-013-thinktecture-openapi-and-native-aot.md); its smart enums,
+[KB-022](KB-022-thinktecture-smart-enums.md).
diff --git a/design/knowledge/KB-013-thinktecture-openapi-and-native-aot.md b/design/knowledge/KB-013-thinktecture-openapi-and-native-aot.md
index 5ccae436..2f1034e4 100644
--- a/design/knowledge/KB-013-thinktecture-openapi-and-native-aot.md
+++ b/design/knowledge/KB-013-thinktecture-openapi-and-native-aot.md
@@ -1,16 +1,19 @@
 ---
-verified: 2026-10-14
+verified: 2026-10-29
 pins:
-  - external Thinktecture.Runtime.Extensions 10.5.1
-source: the Thinktecture.Runtime.Extensions repository at tag 10.5.1 (its Swashbuckle package and project files), read without running anything
+  - external Thinktecture.Runtime.Extensions 10.6.0
+source: the Thinktecture.Runtime.Extensions repository at tag 10.6.0 (its Swashbuckle package and project files) and the 10.6.0 release notes, read without running anything; first read at 10.5.1 on 2026-10-14
 turned-on: the OpenAPI, host converter, Native AOT and targets rows of the value-object table in docs/comparison.md
 test: none, a competitor's feature, read from its source and package
 ---
 
-# KB-013. Thinktecture.Runtime.Extensions 10.5.1 documents OpenAPI through Swashbuckle alone, and does not declare Native AOT compatibility
+# KB-013. Thinktecture.Runtime.Extensions 10.6.0 documents OpenAPI through Swashbuckle alone, and does not declare Native AOT compatibility
 
-- OpenAPI is a Swashbuckle package only, with `type` and `format` copied from Swashbuckle's static table; nothing
-  for Microsoft.AspNetCore.OpenApi. A smart enum's listed values are written with the host's JSON options.
+- OpenAPI is a Swashbuckle package only, with `type` and `format` copied from the schema Swashbuckle generates for
+  the key type; nothing for Microsoft.AspNetCore.OpenApi.
+- A smart enum's listed values are written with the host's JSON options: since 10.6.0, MVC's `JsonOptions` when MVC
+  is registered, otherwise the Minimal API (`Http.Json`) options, as Swashbuckle 10.3 resolves them. A
+  `JsonSerializerOptions` registered in the service provider is no longer used.
 - A converter the host registers is not reflected in type and format.
 - The Swashbuckle and ASP.NET Core packages target `net8.0` only; the core and JSON packages `net8.0` and `net9.0`.
-- No package declares `IsAotCompatible`.
+- No package declares `IsAotCompatible` or `IsTrimmable`.
diff --git a/design/knowledge/KB-015-languageext-option.md b/design/knowledge/KB-015-languageext-option.md
index a3032c50..a1580b22 100644
--- a/design/knowledge/KB-015-languageext-option.md
+++ b/design/knowledge/KB-015-languageext-option.md
@@ -1,16 +1,19 @@
 ---
-verified: 2026-09-28
+verified: 2026-10-29
 pins:
   - external LanguageExt.Core 4.4.9
-  - external LanguageExt.Core 5.0.0-beta-77
-source: the language-ext repository at tags 4.4.9 and 5.0.0-beta-77 and their nuspecs on api.nuget.org, read by a research agent
+  - external LanguageExt.Core 5.0.0-beta-78
+source: the language-ext repository at 4.4.9 (commit 1551a092, its nuspec's) and at tag v5.0.0-beta-78, the beta-78 release notes, and their nuspecs and nupkgs on api.nuget.org, read by a research agent; first read at 4.4.9 and 5.0.0-beta-77 on 2026-09-28
 turned-on: the LanguageExt column of the Option and Result table in docs/comparison.md, and decision 5 (pure Option and Result, not a LanguageExt-style framework)
 test: none, a competitor's feature, read from its source and package
 ---
 
 # KB-015. LanguageExt has no public `.Value` on `Option`, and its `default` is `None`, in 4.4.9 and in the 5.0 beta
 
-- `Option` has no public `.Value`; the content is reached through `Match`, `IfNone` and the like. `default(Option<T>)`
-  is `None`. Both hold in 4.4.9 and 5.0.0-beta-77, so neither is a difference from TypeKit.
+- `Option` has no public `.Value` (its field is `internal`); the content is reached through `Match`, `IfNone` and
+  the like. `default(Option<T>)` is `None`. Both hold in 4.4.9 and 5.0.0-beta-78, so neither is a difference from
+  TypeKit.
 - No System.Text.Json converter of its own, and no analyzer.
-- 4.4.9 targets `netstandard2.0`; 5.0.0-beta-77 targets `net10.0` only.
+- 4.4.9 targets `netstandard2.0`; 5.0.0-beta-78 targets `net10.0` only.
+- 4.4.9 (2024-06-26) is still the latest stable release. 5.0.0-beta-78 (2026-10-09) fixes one bug and leaves
+  `Option` as beta-77 had it.
diff --git a/design/knowledge/KB-022-thinktecture-smart-enums.md b/design/knowledge/KB-022-thinktecture-smart-enums.md
index ca53071b..c9e937aa 100644
--- a/design/knowledge/KB-022-thinktecture-smart-enums.md
+++ b/design/knowledge/KB-022-thinktecture-smart-enums.md
@@ -1,20 +1,23 @@
 ---
-verified: 2026-10-13
+verified: 2026-10-29
 pins:
-  - external Thinktecture.Runtime.Extensions 10.5.1
-source: the Thinktecture.Runtime.Extensions repository at tag 10.5.1 and its nuspecs on api.nuget.org, read by a research agent
+  - external Thinktecture.Runtime.Extensions 10.6.0
+source: the Thinktecture.Runtime.Extensions repository at tag 10.6.0 (its generators, attributes and README), its release notes from 10.5.1 to 10.6.0, and its nuspecs on api.nuget.org, read by a research agent; first read at 10.5.1 on 2026-10-13
 turned-on: the closed-set table and the smart-enum row of "Choose something else when" in docs/comparison.md, and decision 51 (a closed set parses ignoring case only on request)
 test: none, a competitor's feature, read from its source and package
 ---
 
-# KB-022. Thinktecture.Runtime.Extensions 10.5.1 smart enums have a key apart from the identifier, a `Switch` over every member, and look keys up ignoring case
+# KB-022. Thinktecture.Runtime.Extensions 10.6.0 smart enums have a key apart from the identifier, a `Switch` over every member, and look keys up ignoring case
 
 - `[SmartEnum<TKey>]` on a partial class, each member `new("KEY")`; declared properties become constructor
-  parameters.
-- Generated `Switch` and `Map` take every member as a required argument.
+  parameters. The key can be an enum type since 10.5.0.
+- Generated `Switch` and `Map` take every member as a required argument by default.
+  `SwitchMapMethodsGeneration.DefaultWithPartialOverloads` also generates `SwitchPartially` and `MapPartially`,
+  where a member may be left out for a default.
 - `Get` and `TryGet`; string keys compare `OrdinalIgnoreCase` by default (ordinal on request through
   `[KeyMemberEqualityComparer<...>]`). A case clash throws `ArgumentException` on the first lookup.
 - JSON and MessagePack in separate packages, the wire is the key. EF Core through a package per EF Core version
   with `UseThinktectureValueConverters()`, the column is the key. OpenAPI through a Swashbuckle package.
 - TTRESG analyzers, with refactorings. The key can differ from the identifier.
-- Released 2026-10-08. Targets `net8.0` and `net9.0`. License BSD-3-Clause.
+- 10.6.0 released 2026-10-19, with no generator, analyzer or attribute change since 10.5.1. Targets `net8.0` and
+  `net9.0`. License BSD-3-Clause.
diff --git a/design/knowledge/KB-043-github-actions-skips-concurrency-and-dispatch.md b/design/knowledge/KB-043-github-actions-skips-concurrency-and-dispatch.md
new file mode 100644
index 00000000..ac259d30
--- /dev/null
+++ b/design/knowledge/KB-043-github-actions-skips-concurrency-and-dispatch.md
@@ -0,0 +1,24 @@
+---
+verified: 2026-10-29
+pins:
+  - external GitHub-Actions 2026-10-29
+source: docs.github.com, "Using conditions to control job execution", "Control the concurrency of workflows and jobs", "Reuse workflows" and "Triggering a workflow" (events triggered by the GITHUB_TOKEN), and "Disabling and enabling a workflow", read through Context7 on 2026-10-29; the skipped-required-check rule as issue 70 states it, not reproduced on a live pull request
+turned-on: decision 113 (the gate job, the concurrency group of dotnet.yml under release.yml's call, and the nightly dispatch)
+test: none, a hosted service's behaviour, read from its documentation
+---
+
+# KB-043. On GitHub Actions, a skipped job passes a required check, concurrency groups ignore case and a called workflow takes its caller's name, and the GITHUB_TOKEN can dispatch a workflow
+
+- **A skipped job reports Success.** A job skipped by its `if`, or because a job it needs failed, does not
+  block a merge even if it is a required check. A required check cannot tell a deliberate skip from an
+  accidental one. A job that judges the others under `always()` can.
+- **A concurrency group's name ignores case.** `prod` and `Prod` are the same group.
+- **A called workflow uses its caller's name in `${{ github.workflow }}`.** A reusable workflow whose
+  workflow-level group is `${{ github.workflow }}-${{ github.ref }}`, called from a workflow whose group is
+  `release-${{ github.ref }}`, shares that group with its caller (the names differ only in case) and waits
+  for it.
+- **The GITHUB_TOKEN can start a run by dispatch.** Events the GITHUB_TOKEN triggers create no new workflow
+  run, except `workflow_dispatch` and `repository_dispatch`, which always do. So a scheduled job with
+  `actions: write` can dispatch the build workflow on other branches.
+- **A schedule stops.** In a public repository, GitHub turns scheduled workflows off after 60 days without
+  repository activity, and a schedule runs only from the default branch.
diff --git a/design/knowledge/KB-044-superstrong-types.md b/design/knowledge/KB-044-superstrong-types.md
new file mode 100644
index 00000000..68b94445
--- /dev/null
+++ b/design/knowledge/KB-044-superstrong-types.md
@@ -0,0 +1,31 @@
+---
+verified: 2026-10-29
+pins:
+  - external SuperStrong.Types 1.0.0
+source: the SuperStrong.Types repository at tag v1.0.0 (commit 1d059e0) and its nuspecs on api.nuget.org, read by a research agent and spot-checked (2026-10-29)
+turned-on: the SuperStrong.Types column of the value-object table in docs/comparison.md
+test: none, a competitor's feature, read from its source and package
+---
+
+# KB-044. SuperStrong.Types 1.0.0 is an attribute on a partial class, validated everywhere it creates a value, with no Native AOT declaration
+
+- Released 2026-07-21 (1.0.0-alpha.1 on 2026-06-14). Packages: `SuperStrong.Types` (the generator, analyzers and code
+  fixes ship inside it), `.EntityFrameworkCore`, `.AspNetCore.OpenApi`, `.HotChocolate` and `.NewtonsoftJson`, all 1.0.0.
+- Declared by `[StrongType<TPrimitive>]` (or `[StrongType<TPrimitive, TTemplate>]` for a shared definition) on a
+  `partial class`. The attribute targets classes only, and a record, a base type other than `object` or an abstract
+  class fails the build (SST003, SST004, SST006).
+- Validation is a `Define()` method returning a definition built from validators (`IsPositive()`, `HasMaxLength()`,
+  `MatchesRegex()` and others). `From` throws `StrongTypeValidationException`, `TryFrom` returns `false`. Parsing, the
+  System.Text.Json and Newtonsoft.Json converters, the type converter, the EF Core value converter (reads included) and
+  Hot Chocolate's input coercion all go through `From` or `TryFrom`.
+- EF Core: `UseStrongTypes()` adds a type-mapping plugin for every strong type, nothing per type. A query interceptor
+  translates `AsPrimitive()` (filter, projection, ordering, aggregates).
+- OpenAPI: Microsoft.AspNetCore.OpenApi only, opt-in, `AddStrongTypes(representation)`: the underlying type's schema
+  inline, or a named component with the underlying type's `type` and `format`. Both come from
+  `GetOrCreateSchemaAsync` for the underlying type, and no code of its own describes a converter the host
+  registers (read from its code; not run against such a converter).
+- System.Text.Json is built in (a generated `[JsonConverter]` that writes the underlying value under the host's
+  options); Newtonsoft.Json is opt-in, registered on the settings.
+- One analyzer: SST005 (Warning), `Equals(T)` and `GetHashCode()` declared together. None reports `default` or `new()`.
+- No `IsAotCompatible` or `IsTrimmable` in any project file, and no Native AOT step in CI. No `Option`, `Result` or smart
+  enum. Targets `net10.0`; a Roslyn incremental source generator; license MIT.
diff --git a/design/knowledge/KB-045-first-releases-of-the-compared-libraries.md b/design/knowledge/KB-045-first-releases-of-the-compared-libraries.md
new file mode 100644
index 00000000..074bb9ab
--- /dev/null
+++ b/design/knowledge/KB-045-first-releases-of-the-compared-libraries.md
@@ -0,0 +1,28 @@
+---
+verified: 2026-10-29
+pins:
+  - external NuGet registration data of the compared libraries, 2026-10-29
+source: the registration index of each package on api.nuget.org (registration5-gz-semver2), earliest and latest listed publish dates, read 2026-10-29
+turned-on: the "long release history" row of "Choose something else when" in docs/comparison.md
+test: none, a competitor's release history, read from NuGet
+---
+
+# KB-045. The compared libraries were first published on NuGet between 2015 and 2026
+
+First listed version and its date, and the latest listed version, on 2026-10-29:
+
+| Package | First | Latest |
+|---|---|---|
+| LanguageExt.Core | 1.7.5, 2015-12-09 | 5.0.0-beta-78, 2026-10-09 |
+| OneOf | 1.0.5, 2016-01-12 | 3.0.271, 2024-05-16 |
+| CSharpFunctionalExtensions | 1.0.1, 2016-06-20 | 3.7.0, 2026-03-02 |
+| FluentResults | 0.5.0, 2017-05-01 | 4.0.0, 2025-06-29 |
+| Ardalis.SmartEnum | 1.0.0, 2017-12-01 | 8.2.0, 2024-11-19 |
+| Thinktecture.Runtime.Extensions | 0.1.0-beta1, 2018-02-11 | 10.6.0, 2026-10-19 |
+| StronglyTypedId | 0.1.2, 2019-06-05 | 1.0.0-beta08, 2024-04-25 |
+| Vogen | 1.0.1, 2021-12-01 | 8.0.7, 2026-07-21 |
+| ErrorOr | 0.0.2, 2022-05-31 | 2.1.1, 2026-05-15 |
+| Intellenum | 0.0.1-alpha.1, 2023-03-12 | 2.0.1, 2025-09-30 |
+| SuperStrong.Types | 1.0.0-alpha.1, 2026-06-14 | 1.0.0, 2026-07-21 |
+
+A first publish date says how long a package has been released, not how widely it is used in production.
diff --git a/design/knowledge/KB-046-csharp-15-unions-ship-with-the-net-11-sdk.md b/design/knowledge/KB-046-csharp-15-unions-ship-with-the-net-11-sdk.md
new file mode 100644
index 00000000..1e9b07db
--- /dev/null
+++ b/design/knowledge/KB-046-csharp-15-unions-ship-with-the-net-11-sdk.md
@@ -0,0 +1,18 @@
+---
+verified: 2026-10-29
+pins:
+  - external C# 15 and the .NET 11 SDK, release candidate 2
+source: Microsoft Learn, "What's new in C# 15" (updated 2026-10-23, docs commit 433547d), and the .NET blog's "Explore union types in C# 15" (2026-04-02), read 2026-10-29
+turned-on: the C# union types row of "Choose something else when" in docs/comparison.md
+test: none, a language feature's release status, read from Microsoft's documentation
+---
+
+# KB-046. C# 15's union types and closed hierarchies need no preview flag in the .NET 11 SDK, which is still prerelease
+
+- Union types (`public union Pet(Cat, Dog, Bird);`) and closed hierarchies (`closed` on a class) are C# 15 features,
+  with exhaustive `switch` checking.
+- C# 15 is the default language version for `net11.0` in the .NET 11 SDK, and except for memory safety its features
+  need no `<LangVersion>preview</LangVersion>`.
+- The .NET 11 SDK is still prerelease. Microsoft Learn's .NET 11 overview (updated 2026-10-21, docs commit 015d8a2) was
+  last updated for release candidate 2, and expects general availability in November 2026.
+- Unions first appeared as a preview feature in .NET 11 Preview 2 (the .NET blog, 2026-04-02).
diff --git a/design/knowledge/KB-047-a-converter-s-hints-factory-comes-after-hilo.md b/design/knowledge/KB-047-a-converter-s-hints-factory-comes-after-hilo.md
new file mode 100644
index 00000000..7ac610f0
--- /dev/null
+++ b/design/knowledge/KB-047-a-converter-s-hints-factory-comes-after-hilo.md
@@ -0,0 +1,23 @@
+---
+verified: 2026-10-29
+pins:
+  - Microsoft.EntityFrameworkCore.Relational 10.0.12
+  - Npgsql.EntityFrameworkCore.PostgreSQL 10.0.3
+source: EF Core's source at v10.0.12 (ValueGeneratorSelector.CreateFromFactory and TryCreate, RelationalValueGeneratorSelector.FindForType, TemporaryNumberValueGeneratorFactory.Create, the CoreTypeMapping constructor, SqlServerValueGeneratorSelector.TrySelect) and Npgsql's at v10.0.3 (NpgsqlValueGeneratorSelector.TrySelect), read 2026-10-29; measured with plain EF Core and Npgsql, no database opened
+turned-on: decision 114, the temporary value of a value-object key over a number (#86)
+test: test/CodoMetis.TypeKit.Facts/KB047.cs
+---
+
+# KB-047. EF Core consults a converter's mapping-hints value generator after a property's generator and after HiLo
+
+- EF Core chooses a temporary number for a generated property by its type mapping's CLR type, then by its
+  converter's provider type (`TemporaryNumberValueGeneratorFactory.Create`). A key of a type that is no number,
+  converted to a `decimal` column, gets a negative temporary `decimal`, and a conversion back to `ulong` throws
+  `OverflowException` at `Add`.
+- A type mapping built on a converter takes the value generator factory of the converter's `ConverterMappingHints`
+  where the mapping has none of its own (the `CoreTypeMapping` constructor).
+- `ValueGeneratorSelector` uses a generator configured on the property first, then the type mapping's factory, then
+  its own choice. The SQL Server and Npgsql selectors choose HiLo before calling it, for a property without a
+  generator of its own.
+- `ConverterMappingHints.ValueGeneratorFactory` is marked `[Obsolete]` without a message; the constructor parameter
+  that sets it is not.
diff --git a/design/knowledge/KB-048-sql-server-compares-text-ignoring-case.md b/design/knowledge/KB-048-sql-server-compares-text-ignoring-case.md
new file mode 100644
index 00000000..9e001cae
--- /dev/null
+++ b/design/knowledge/KB-048-sql-server-compares-text-ignoring-case.md
@@ -0,0 +1,21 @@
+---
+verified: 2026-10-29
+pins:
+  - external SQL-Server 2022
+  - Microsoft.EntityFrameworkCore.SqlServer 10.0.12
+source: https://learn.microsoft.com/sql/t-sql/language-elements/string-comparison-assignment ("Transact-SQL considers the strings 'abc' and 'abc ' to be equivalent for most comparison operations") and EF Core's Entity Properties page, whose example configures "a SQL Server column to be case-insensitive" with SQL_Latin1_General_CP1_CI_AS; measured with plain EF Core on the mssql/server 2022 image, whose databases take that collation
+turned-on: the SQL Server query catalogue's text cases (SqlServerQueryVariantTests, issue 81), where a text or char value object compared, ordered or aggregated answers in another order than memory's ordinal one, and the EF README's "Ordering in SQL follows the database's collation", extended to comparison
+test: test/CodoMetis.TypeKit.Facts/KB048.cs
+---
+
+# KB-048. SQL Server compares and orders text ignoring case, and trailing spaces
+
+A `nvarchar` column holding `alpha`, `Bravo` and `charlie`, under the default collation
+`SQL_Latin1_General_CP1_CI_AS`:
+
+- `Where(n => n.Name == "BRAVO")` finds `Bravo`, and `n.Name == "alpha  "` finds `alpha`;
+- `upper.Contains(n.Name)` over `["ALPHA"]` finds `alpha`, and `StartsWith("b")` finds `Bravo`;
+- `OrderBy(n => n.Name)` gives `["alpha", "Bravo", "charlie"]`, where ordinal order is `["Bravo", "alpha", "charlie"]`;
+- `OrderBy(n => EF.Functions.Collate(n.Name, "Latin1_General_BIN2"))` gives the ordinal order.
+
+So a query over text matches and orders rows that ordinal comparison in memory keeps apart.
diff --git a/design/knowledge/KB-049-sql-server-orders-a-uniqueidentifier-by-its-last-group.md b/design/knowledge/KB-049-sql-server-orders-a-uniqueidentifier-by-its-last-group.md
new file mode 100644
index 00000000..a070c3e1
--- /dev/null
+++ b/design/knowledge/KB-049-sql-server-orders-a-uniqueidentifier-by-its-last-group.md
@@ -0,0 +1,16 @@
+---
+verified: 2026-10-29
+pins:
+  - external SQL-Server 2022
+  - Microsoft.EntityFrameworkCore.SqlServer 10.0.12
+source: https://learn.microsoft.com/sql/connect/ado-net/sql/compare-guid-uniqueidentifier-values (SqlGuid "implements CompareTo using SQL Server behavior, in the last six bytes of a value are most significant", where Guid "evaluates all 16 bytes"), measured with plain EF Core on the mssql/server 2022 image
+turned-on: the SQL Server query catalogue's Guid cases (SqlServerQueryVariantTests, issue 81), where a Guid value object compared, ordered or aggregated answers in another order than memory's, and the catalogue's Guid values, which ascend by their first group and not by their last
+test: test/CodoMetis.TypeKit.Facts/KB049.cs
+---
+
+# KB-049. SQL Server orders a `uniqueidentifier` by its last group first
+
+Three Guids that ascend in memory by their first group, `00000001-…-000000000003`, `00000002-…-000000000001` and
+`00000003-…-000000000002`, order on SQL Server by their last group: `OrderBy` answers the second, the third, then the
+first, `Min` the second, and `< first` finds the other two. `Guid.CompareTo` compares the first group first, so
+an ordering, a comparison or a `Min` or `Max` over Guids answers otherwise in memory.
diff --git a/design/knowledge/KB-050-a-decimal-is-decimal-18-2-on-sql-server.md b/design/knowledge/KB-050-a-decimal-is-decimal-18-2-on-sql-server.md
new file mode 100644
index 00000000..82f5e266
--- /dev/null
+++ b/design/knowledge/KB-050-a-decimal-is-decimal-18-2-on-sql-server.md
@@ -0,0 +1,15 @@
+---
+verified: 2026-10-29
+pins:
+  - external SQL-Server 2022
+  - Microsoft.EntityFrameworkCore.SqlServer 10.0.12
+source: measured with plain EF Core on the mssql/server 2022 image, the model's column type and the values read back. EF's documentation names no default precision, and SQL Server's precision page no rounding on write
+turned-on: the SQL Server query catalogue's decimal cases and the key catalogue's decimal keys (SqlServerQueryVariantTests, SqlServerKeyVariantTests, issue 81), which read 10.00 where memory holds 10, and the EF README's HavePrecision guidance for SQL Server
+test: test/CodoMetis.TypeKit.Facts/KB050.cs
+---
+
+# KB-050. A `decimal` is a `decimal(18,2)` on SQL Server, read back at scale 2 and rounded on write
+
+A `decimal` property without `HasPrecision` is a `decimal(18,2)` column. Written as `10m`, `1.005m` and
+`-0.004m`, the values read back as `10.00m`, `1.01m` and `0.00m`: every value at scale 2, which is equal to
+`10m` but prints `"10.00"`, and more fractional digits rounded half away from zero, without an error.
diff --git a/design/knowledge/KB-051-sql-server-s-time-holds-less-than-a-day.md b/design/knowledge/KB-051-sql-server-s-time-holds-less-than-a-day.md
new file mode 100644
index 00000000..503a0f9b
--- /dev/null
+++ b/design/knowledge/KB-051-sql-server-s-time-holds-less-than-a-day.md
@@ -0,0 +1,16 @@
+---
+verified: 2026-10-29
+pins:
+  - external SQL-Server 2022
+  - Microsoft.EntityFrameworkCore.SqlServer 10.0.12
+source: https://learn.microsoft.com/sql/t-sql/data-types/time-transact-sql (its range, 00:00:00.0000000 through 23:59:59.9999999), measured with plain EF Core on the mssql/server 2022 image, the column type, the refusal and the JSON read
+turned-on: the SQL Server query catalogue's TimeSpan cases (SqlServerQueryVariantTests, issue 81), whose 1.02:00:00 is refused in a column and read as 01:02:00 from a JSON column, and the EF README's TimeSpan warning for SQL Server
+test: test/CodoMetis.TypeKit.Facts/KB051.cs
+---
+
+# KB-051. SQL Server's `time` holds less than a day, so a longer `TimeSpan` is refused in a column and misread in JSON
+
+EF maps a `TimeSpan` to `time`. `SaveChanges` of `TimeSpan.FromHours(26)` into such a column throws a
+`DbUpdateException`. In a JSON column (`OwnsOne(…).ToJson()`) the same value is written as its text, `"1.02:00:00"`;
+an entity read whole has `1.02:00:00`, but a query that reads the property (`Select(h => h.Doc.Length)`) converts
+the text to `time` and answers `01:02:00`, without an error.
diff --git a/design/knowledge/KB-052-sql-server-takes-no-max-of-a-bit.md b/design/knowledge/KB-052-sql-server-takes-no-max-of-a-bit.md
new file mode 100644
index 00000000..9f36d912
--- /dev/null
+++ b/design/knowledge/KB-052-sql-server-takes-no-max-of-a-bit.md
@@ -0,0 +1,14 @@
+---
+verified: 2026-10-29
+pins:
+  - external SQL-Server 2022
+  - Microsoft.EntityFrameworkCore.SqlServer 10.0.12
+source: https://learn.microsoft.com/sql/t-sql/functions/max-transact-sql (MAX "can be used with numeric, char, nchar, varchar, nvarchar, uniqueidentifier, or datetime columns, but not with bit columns"), measured with plain EF Core on the mssql/server 2022 image
+turned-on: the SQL Server query catalogue's bool cases (SqlServerQueryVariantTests, issue 81), where a Max or Min of a bool value object is refused for the wrapped type too
+test: test/CodoMetis.TypeKit.Facts/KB052.cs
+---
+
+# KB-052. SQL Server takes neither `MAX` nor `MIN` of a `bit`
+
+EF translates `Max(f => f.Flag)` and `Min` of a `bool` column to `MAX` and `MIN` of a `bit`, and SQL Server refuses
+them: a `SqlException`, "Operand data type bit is invalid for max operator" (`min` for `MIN`).
diff --git a/design/knowledge/KB-053-greatest-and-least-need-compatibility-level-160.md b/design/knowledge/KB-053-greatest-and-least-need-compatibility-level-160.md
new file mode 100644
index 00000000..b698279d
--- /dev/null
+++ b/design/knowledge/KB-053-greatest-and-least-need-compatibility-level-160.md
@@ -0,0 +1,15 @@
+---
+verified: 2026-10-29
+pins:
+  - Microsoft.EntityFrameworkCore.SqlServer 10.0.12
+source: measured with plain EF Core, no server opened, ToQueryString at EF's default level, at 150 and at 160. EF's SQL Server function-mappings page (learn.microsoft.com/ef/core/providers/sql-server/functions) lists Math.Max as GREATEST from EF Core 9.0 and names no level
+turned-on: the SQL Server query catalogue's Greatest and Least cases (SqlServerQueryVariantTests, issue 81), refused at EF's default level and translated, as the wrapped type's are, at 160
+test: test/CodoMetis.TypeKit.Facts/KB053.cs
+---
+
+# KB-053. EF translates `Greatest` and `Least` on SQL Server only from compatibility level 160
+
+Under `UseSqlServer` at EF's default compatibility level, or at 150, `Where(p => EF.Functions.Greatest(p.Left, p.Right) > 2)`
+is refused, "could not be translated", and `Select(p => EF.Functions.Least(p.Left, p.Right))` reads the two columns and
+calls `Least` in memory, where it throws "switched to client-evaluation" when the query runs. With
+`UseCompatibilityLevel(160)` both translate to `GREATEST` and `LEAST`.
diff --git a/design/knowledge/KB-054-datetime2-keeps-every-tick-and-forgets-the-kind.md b/design/knowledge/KB-054-datetime2-keeps-every-tick-and-forgets-the-kind.md
new file mode 100644
index 00000000..00aaf090
--- /dev/null
+++ b/design/knowledge/KB-054-datetime2-keeps-every-tick-and-forgets-the-kind.md
@@ -0,0 +1,15 @@
+---
+verified: 2026-10-29
+pins:
+  - external SQL-Server 2022
+  - Microsoft.EntityFrameworkCore.SqlServer 10.0.12
+source: EF Core's Entity Properties page ("the SQL Server provider maps DateTime properties to datetime2(7) columns"), measured with plain EF Core on the mssql/server 2022 image
+turned-on: the SQL Server round trips (SqlServerRoundTripTests, issue 81), where a DateTime value object written as UTC reads back equal, with every tick and without its kind, as a plain DateTime does
+test: test/CodoMetis.TypeKit.Facts/KB054.cs
+---
+
+# KB-054. `datetime2` keeps every tick of a `DateTime`, and reads it back without its kind
+
+EF maps a `DateTime` to `datetime2`, precision 7 unless configured, so nothing is rounded: a value with 1234567 extra
+ticks reads back with all of them. A `DateTime` written as UTC reads back with `Kind` Unspecified, and equal, since
+`DateTime` equality ignores the kind. A `DateTimeOffset` (`datetimeoffset`) keeps its ticks and its offset.
diff --git a/design/knowledge/README.md b/design/knowledge/README.md
index cdcad740..c9e4b6fd 100644
--- a/design/knowledge/README.md
+++ b/design/knowledge/README.md
@@ -12,7 +12,9 @@ re-verified; `docs-query check` lists the stale ones.
 
 **Adding one.** Only what something here turned on (a decision, a fix, a probe's verdict), pinned and
 falsifiable, checked against a primary source. A competitor's feature is a fact too, pinned
-`external {name} {version}`: no check compares it, so it is as fresh as its date. Take the next number, copy an
+`external {name} {version}`: `check` never compares it, so it is as fresh as its date, and `docs-query due --nuget`
+lists the ones to re-read before a release (CONTRIBUTING, "Releasing"): verified more than six months ago, or pinned
+to a package NuGet has a later release of. Take the next number, copy an
 entry's frontmatter, write the test first where a test can observe it, and add a row below.
 
 **A fact that prunes or excuses is executable** ([decision 107](../adr/0107-a-cited-fact-is-executable-and-seeds-run-by-footprint.md)).
@@ -40,17 +42,17 @@ test and later for the harness's `Baseline.Fact`.
 | [KB-009](KB-009-a-modifier-s-converter-wins-over-the-attribute.md) | A resolver modifier's `CustomConverter` writes a property over its `[JsonConverter]` | SDK 10.0.4xx | `KB009` |
 | [KB-010](KB-010-vogen-declaring-validating-storing.md) | Vogen 8.0.7 declares a value object by attribute, validates through `Validate`, and targets .NET Standard 2.0 | Vogen 8.0.7, 9.0.0-beta.2 | prose |
 | [KB-011](KB-011-vogen-openapi-and-native-aot.md) | Vogen 8.0.7 generates OpenAPI schemas only on request, from a built-in type table, and does not declare Native AOT compatibility | Vogen 8.0.7, 9.0.0-beta.2 | prose |
-| [KB-012](KB-012-thinktecture-value-objects.md) | Thinktecture.Runtime.Extensions 10.5.0 declares value objects, smart enums and unions by attribute, for net8.0 and net9.0 | Thinktecture 10.5.0 | prose |
-| [KB-013](KB-013-thinktecture-openapi-and-native-aot.md) | Thinktecture.Runtime.Extensions 10.5.1 documents OpenAPI through Swashbuckle alone, and does not declare Native AOT compatibility | Thinktecture 10.5.1 | prose |
+| [KB-012](KB-012-thinktecture-value-objects.md) | Thinktecture.Runtime.Extensions 10.6.0 declares value objects, smart enums and unions by attribute, for net8.0 and net9.0 | Thinktecture 10.6.0 | prose |
+| [KB-013](KB-013-thinktecture-openapi-and-native-aot.md) | Thinktecture.Runtime.Extensions 10.6.0 documents OpenAPI through Swashbuckle alone, and does not declare Native AOT compatibility | Thinktecture 10.6.0 | prose |
 | [KB-014](KB-014-stronglytypedid.md) | StronglyTypedId 1.0.0-beta08 is an attribute on a partial struct, with no validation, analyzers or OpenAPI support | StronglyTypedId 1.0.0-beta08 | prose |
-| [KB-015](KB-015-languageext-option.md) | LanguageExt has no public `.Value` on `Option`, and its `default` is `None`, in 4.4.9 and the 5.0 beta | LanguageExt 4.4.9, 5.0.0-beta-77 | prose |
+| [KB-015](KB-015-languageext-option.md) | LanguageExt has no public `.Value` on `Option`, and its `default` is `None`, in 4.4.9 and the 5.0 beta | LanguageExt 4.4.9, 5.0.0-beta-78 | prose |
 | [KB-016](KB-016-csharpfunctionalextensions.md) | CSharpFunctionalExtensions 3.7.0 throws from `.Value` on a failure, and its `default(Result<T>)` is a success | CSharpFunctionalExtensions 3.7.0 | prose |
 | [KB-017](KB-017-erroror.md) | ErrorOr 2.1.1 returns `default` from `.Value` on an error, and its `default` instance is a success | ErrorOr 2.1.1 | prose |
 | [KB-018](KB-018-fluentresults.md) | FluentResults 4.0.0 results are classes that carry reasons, errors and successes, and an error can name its cause | FluentResults 4.0.0 | prose |
 | [KB-019](KB-019-oneof.md) | OneOf 3.0.271 is a readonly struct whose `default` is its first case | OneOf 3.0.271 | prose |
 | [KB-020](KB-020-ardalis-smartenum.md) | Ardalis.SmartEnum 8.2.0 is a run-time base class, finds its members by reflection, and requires no member in `When` | Ardalis.SmartEnum 8.2.0 | prose |
 | [KB-021](KB-021-intellenum.md) | Intellenum 2.0.1 has one underlying value per member, and its case-insensitive lookup answers the first declared | Intellenum 2.0.1 | prose |
-| [KB-022](KB-022-thinktecture-smart-enums.md) | Thinktecture.Runtime.Extensions 10.5.1 smart enums have a key apart from the identifier, a `Switch` over every member, and look keys up ignoring case | Thinktecture 10.5.1 | prose |
+| [KB-022](KB-022-thinktecture-smart-enums.md) | Thinktecture.Runtime.Extensions 10.6.0 smart enums have a key apart from the identifier, a `Switch` over every member, and look keys up ignoring case | Thinktecture 10.6.0 | prose |
 | [KB-023](KB-023-a-converter-cannot-describe-its-schema.md) | A JSON converter of one's own cannot say what it writes: the schema exporter writes the empty schema, ASP.NET only a format | OpenApi 10.0.12, SDK 10.0.4xx | `KB023` |
 | [KB-024](KB-024-no-library-constrains-type-arguments-by-kind.md) | No .NET library constrains a type argument to be abstract, sealed, a record or concrete, or two arguments to differ | AdvancedGenericTypeConstraints 0.4.1, RossLean.GenericsAnalyzer 1.4.0 | prose |
 | [KB-025](KB-025-the-coverage-collector-rewrites-assemblies-on-disk.md) | The code coverage collector instruments the assemblies on disk, so test hosts started together from one output directory corrupt each other, and its in-memory mode records no coverage on macOS arm64 | Microsoft.Testing.Extensions.CodeCoverage 18.12.0, SDK 10.0.4xx | prose |
@@ -71,3 +73,15 @@ test and later for the harness's `Baseline.Fact`.
 | [KB-040](KB-040-a-converter-is-charged-a-level-of-max-depth.md) | Under `MaxDepth`, System.Text.Json refuses a value a converter of one's own writes at the limit, where its own converter writes it | SDK 10.0.4xx | `KB040` |
 | [KB-041](KB-041-mvc-cannot-write-its-400-under-a-context-without-validation-problem-details.md) | MVC cannot write its automatic 400 under a source-generated context that does not list `ValidationProblemDetails` | SDK 10.0.4xx | `KB041` |
 | [KB-042](KB-042-a-char-schema-is-refused-under-write-as-string.md) | Under `NumberHandling` with `WriteAsString`, ASP.NET refuses the OpenAPI document of an endpoint whose schema holds a `char` | OpenApi 10.0.12, SDK 10.0.4xx | `KB042` |
+| [KB-043](KB-043-github-actions-skips-concurrency-and-dispatch.md) | On GitHub Actions, a skipped job passes a required check, concurrency groups ignore case and a called workflow takes its caller's `github.workflow`, and the GITHUB_TOKEN can dispatch a workflow | external GitHub-Actions 2026-10-29 | prose |
+| [KB-044](KB-044-superstrong-types.md) | SuperStrong.Types 1.0.0 is an attribute on a partial class, validated everywhere it creates a value, with no Native AOT declaration | SuperStrong.Types 1.0.0 | prose |
+| [KB-045](KB-045-first-releases-of-the-compared-libraries.md) | The compared libraries were first published on NuGet between 2015 and 2026 | NuGet, 2026-10-29 | prose |
+| [KB-046](KB-046-csharp-15-unions-ship-with-the-net-11-sdk.md) | C# 15's union types and closed hierarchies need no preview flag in the .NET 11 SDK, which is still prerelease | .NET 11 SDK RC 2 | prose |
+| [KB-047](KB-047-a-converter-s-hints-factory-comes-after-hilo.md) | EF Core consults a converter's mapping-hints value generator after a property's generator and after HiLo, and gives a key that is no number the temporary number of its column | EF Core 10.0.12, Npgsql 10.0.3 | `KB047` |
+| [KB-048](KB-048-sql-server-compares-text-ignoring-case.md) | Under SQL Server's default collation text compares and orders ignoring case and trailing spaces: `==`, `IN` and `LIKE` match rows that differ in case | SQL Server 2022, EF SqlServer 10.0.12 | `KB048`, with Docker |
+| [KB-049](KB-049-sql-server-orders-a-uniqueidentifier-by-its-last-group.md) | SQL Server orders a `uniqueidentifier` by its last group first, where `Guid.CompareTo` starts at the first | SQL Server 2022, EF SqlServer 10.0.12 | `KB049`, with Docker |
+| [KB-050](KB-050-a-decimal-is-decimal-18-2-on-sql-server.md) | A `decimal` is a `decimal(18,2)` on SQL Server: every value reads back at scale 2, more digits rounded on write | SQL Server 2022, EF SqlServer 10.0.12 | `KB050`, with Docker |
+| [KB-051](KB-051-sql-server-s-time-holds-less-than-a-day.md) | SQL Server's `time` holds less than a day: a longer `TimeSpan` is refused in a column, and read by a query as another value from JSON | SQL Server 2022, EF SqlServer 10.0.12 | `KB051`, with Docker |
+| [KB-052](KB-052-sql-server-takes-no-max-of-a-bit.md) | SQL Server takes neither `MAX` nor `MIN` of a `bit` | SQL Server 2022, EF SqlServer 10.0.12 | `KB052`, with Docker |
+| [KB-053](KB-053-greatest-and-least-need-compatibility-level-160.md) | EF translates `Greatest` and `Least` on SQL Server only from compatibility level 160 | EF SqlServer 10.0.12 | `KB053` |
+| [KB-054](KB-054-datetime2-keeps-every-tick-and-forgets-the-kind.md) | `datetime2` keeps every tick of a `DateTime` and reads it back with `Kind` Unspecified | SQL Server 2022, EF SqlServer 10.0.12 | `KB054`, with Docker |
diff --git a/design/native-aot.md b/design/native-aot.md
index 78bdf5fa..36da59f0 100644
--- a/design/native-aot.md
+++ b/design/native-aot.md
@@ -39,6 +39,7 @@ host, EF Core through `dotnet ef dbcontext optimize --precompile-queries --nativ
   unchanged (measured with `DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=1`, which leaves the
   `System.Globalization.Invariant` switch unset). `AsText()` asks once whether a decomposed letter
   composes, and throws `PlatformNotSupportedException` where it does not; `InvariantGlobalizationTests`
-  runs the test assembly again in that mode. The smoke test's consumers do not call `AsText()`.
+  runs the test assembly again in that mode. The smoke test's `aot` consumers do not call `AsText()`; its
+  `walkthrough` consumer does, on the JIT, without that mode.
 - **Third-party packages** report their own warnings (NodaTime.Serialization.SystemTextJson 1.4.0,
   EF Core). The smoke test asserts only that none names a CodoMetis package or a woven value object.
diff --git a/design/openapi.md b/design/openapi.md
index d17eb87a..3f1927b2 100644
--- a/design/openapi.md
+++ b/design/openapi.md
@@ -75,7 +75,9 @@ position, and the change lands in the hoisted component.
   default name is named after its nesting chain (`ShopId`, as its companion class is `ShopIdExtensions`);
   a name the host's own delegate chose, or `null` for an inlined value object, is kept. A name that
   is also another type's, `Order.Status` beside a top-level `OrderStatus`, refuses the document
-  ([decision 55](adr/0055-component-name-claimed-twice-refused.md)).
+  ([decision 55](adr/0055-component-name-claimed-twice-refused.md)). With `InlineValueObjects`, the wrapper answers
+  `null` for every value object before the host's delegate, so no value object is a component or claims a name, and
+  closed sets keep theirs ([decision 115](adr/0115-value-objects-can-be-inlined-everywhere.md)).
 - **Fault responses** ([decision 49](adr/0049-fault-responses-client-can-act.md)): an operation
   transformer adds a problem response per status an endpoint answers its fault type with, referring to
   the problem schema the host's `CreateSchemaReferenceId` names (the shared `ProblemDetails`
diff --git a/design/option-result.md b/design/option-result.md
index cc443135..07930acb 100644
--- a/design/option-result.md
+++ b/design/option-result.md
@@ -53,8 +53,9 @@ is the value-less shape. Anything that turns this into a second LanguageExt is o
   occurrence. It is made by `Fault.Of` alone, and comparing it with a bare reason is refused, since a
   fault with a detail never equals one
   ([decision 53](adr/0053-fault-made-by-fault-of-alone.md)); `Reason` is what a caller compares.
-  A `Cause` beside them joins 2.1 ([decision 52](adr/0052-cause-on-fault-joins-2-1.md)), and so does
-  `Rule`, the qualified name of the enum or closed-set member that refused, which the problem carries
+  A `Cause` beside them (2.3.0) is an exception for the log, which equality and printing leave out
+  and no problem carries ([decision 52](adr/0052-cause-on-fault-joins-2-1.md)). `Rule` (2.1.0) is the
+  qualified name of the enum or closed-set member that refused, which the problem carries
   as `rule` ([decision 67](adr/0067-rule-that-refused-on-fault.md)); equality compares the rule's type,
   since two types' rules can read alike ([decision 72](adr/0072-rule-identity-is-its-type.md)).
 - **`Fault<T1, T2>` and `Fault<T1, T2, T3>` (2.1.0)** hold one fault of one of several types, so a
@@ -75,7 +76,8 @@ is the value-less shape. Anything that turns this into a second LanguageExt is o
   non-goals exclude. A zip still inspects every argument, so an uninitialized one after an error
   throws. Callbacks return `Task` ([decision 30](adr/0030-asynchronous-callbacks-return-task.md)): `TapAsync` and `TapErrorAsync` take a
   `Func<…, Task>` beside the `Action`, so an `async` lambda is awaited; a `ValueTask` one needs
-  `.AsTask()`.
+  `.AsTask()`. `CatchAsync` is no callback and takes a `ValueTask` too, at a lower overload priority,
+  so an `async` lambda still binds to its `Task` form ([decision 110](adr/0110-catchasync-takes-a-valuetask-at-a-lower-priority.md)).
 - **A callback runs where the task it waited for completed (decided 2026-10-13,
   [decision 62](adr/0062-asynchronous-callbacks-run-where-awaited-task-completed.md)).** Every `await`
   in the package is `ConfigureAwait(false)`, so nothing resumes on the caller's
@@ -84,7 +86,19 @@ is the value-less shape. Anything that turns this into a second LanguageExt is o
   once on it, so in a UI or a Blazor component a callback that touches dispatcher-bound state works or
   fails by timing. That is documented rather than changed: await the task and call the synchronous
   combinator, or marshal inside the callback. `AsynchronousContextTests` holds every public member
-  that returns a task to it.
+  that returns a task or an async stream to it.
+- **Async streams (2.3.0, #128).** `Choose()` and `Choose(selector)` over an `IAsyncEnumerable<T>`
+  return one, lazily, the caller's token reaching the source through `[EnumeratorCancellation]`.
+  `SequenceAsync(cancellationToken)` and `TraverseAsync` over one read the next element only after the
+  one before it succeeded, check a token they are given before each read and each operation, and
+  dispose the enumerator on every exit. Measured 2026-10-29 against .NET 10's
+  `System.Linq.AsyncEnumerable` and EF Core 10.0.12: no name binds ambiguously beside its operators,
+  and a `T[]` or a `DbSet<T>` (which EF Core 10 does not convert to `IAsyncEnumerable<T>`) still binds
+  to the sequence members. A type that implements both `IEnumerable<T>` and `IAsyncEnumerable<T>` is
+  ambiguous (CS0121) for `Choose(selector)` and `TraverseAsync`, as it is for the BCL's own `Where`. That
+  is left as the BCL leaves it, not settled by an overload priority: a silent pick of either reading is
+  worse than a compile error. CMTK0003 reports a dropped `SequenceAsync` by its type, as it does
+  `TraverseAsync`, with no change to the analyzer.
 
 **Decided 2026-09-27: an uninitialized `Result` throws.**
 - A `default` result is `State == Uninitialized`. If the branching members tested only
diff --git a/design/plan.md b/design/plan.md
index 9000757b..9a76a937 100644
--- a/design/plan.md
+++ b/design/plan.md
@@ -23,6 +23,8 @@ you touch; the rest is reference.
 | [Fix history](fix-history.md) | Every `fix:` to 2026-10-15 by defect class, finder, sibling chain and release escape: the baseline for reviewing | when the classification is run again |
 | [Mutation survivors, 2026-10-16](mutation-2026-10-16.md) | The first Stryker.NET run, on the Serilog satellite: counts per package, each survivor read as a missing assertion or an equivalent mutant, and the valid mutants the compile lost | one dated page per run |
 | [Finder benchmark, 2026-10-16](finder-benchmark-2026-10-16.md) | The 24 release escapes put back as seeds: which test, probe row or nothing detects each, totals per finder as applied, reached and detected, and the accounting every probe round and analyst run reports | one dated page per run |
+| [Oracles](../test/oracles/README.md) | What the documents promise as claims held by named tests, every public member claimed or waived, the oracle classes and their seeds, the candidates and the axes a consumer varies ([decision 112](adr/0112-the-prober-gives-way-to-valueranges-oracle-kit.md)) | with each feature and each promise a document gains |
+| [The code graph](code-graph.md) | What the codebase-memory graph was measured to find and miss, and how to keep it current; AGENTS.md's "Finding code" rests on it | when the graph is measured again |
 | [Probing without the tooling](probing-without-tooling.md) | How BLite applied the probing concept by hand, with no prober, covering array or ledger: what each tool function became, the process as it ran, the issues and PRs it produced, and an adoption guide for trying the same here without the tooling | copied 2026-10-18; as the method is tried here |
 
 The spikes that decided something are in [spikes/](../spikes/), each with a README stating the
diff --git a/design/roadmap.md b/design/roadmap.md
index 716f8ba0..11d478ed 100644
--- a/design/roadmap.md
+++ b/design/roadmap.md
@@ -3,7 +3,8 @@
 What is open, and nothing else. Done work is in the [changelog](../CHANGELOG.md) and in git. Each
 item names the decision that scoped it, or the review that found it. A Warning may learn and a
 refusal may relax in any minor version; an Error that reports more waits for a major
-([decision 34](adr/0034-errors-fixed-within-major-version-warnings.md)).
+([decision 34](adr/0034-errors-fixed-within-major-version-warnings.md)), unless only that minor version's
+new API can write the form ([decision 118](adr/0118-an-error-may-learn-a-form-only-new-api-can-write.md)).
 
 ## 2.2.0, consolidation
 
@@ -15,31 +16,25 @@ defect, a cost or a missing guard may land here; one that adds surface waits for
   ([decision 108](adr/0108-a-probe-check-earns-credit-against-a-baseline-and-ws2-closes.md)).
   WS3 (beyond pairs), WS4 (the mutation nightly), the second half of WS5 (the finder benchmark at equal budgets) and
   WS6 (PostgreSQL in CI) were dropped on 2026-10-17 by the maintainer's decision, and are not scheduled.
-- The generated-surface snapshot under "Generators" below.
 
 ## 2.3.0, additive
 
 Decided, moved to 2.2 when 2.1.0 shipped without them ([decision 88](adr/0088-2-1-0-ships-without-its-open-roadmap-items.md)),
 and then to 2.3 when 2.2.0 became a consolidation release ([decision 97](adr/0097-2-2-0-is-a-consolidation-release-and-the-gate-binds.md)).
 
-- An optional `Cause` on `Fault<TFault>`, an exception kept beside the reason and the detail for the
-  log and the fault feature, never written to the problem; `Fault.Of(reason, detail, cause)`, and a
-  `MapError` from a `Result<T, Exception>` that keeps the exception ([decision 52](adr/0052-cause-on-fault-joins-2-1.md)).
-- An opt-in that withholds the `fault` name from the response for chosen members or a whole fault
-  type, so two causes can share a status without a mapping at the boundary
-  ([decision 64](adr/0064-fault-name-reaches-client-causes-not-told-apart-one-fault.md)).
-- A default value-object key over `ulong` generated as a plain one is, which needs a per-key value
-  generator a compiled model can write ([decision 63](adr/0063-char-keys-application-assigned-ulong-documented.md)).
-- Testing: async assertions.
-- `CatchAsync` over a `ValueTask`, and `TraverseAsync` on `Option` and `Patch`.
+Its one item, a default `ulong` key, landed ([decision 114](adr/0114-a-value-object-s-temporary-number-is-its-wrapped-type-s.md));
+what else 2.3.0 ships is tracked in its epic.
 
 ## Gaps, in any 2.x
 
 Small, each closable in a minor version. Found by the reviews named.
 
+- A default `ulong` value-object key in a compiled model made with `--nativeaot`, which writes the type mappings out as
+  code without the factory their converters' hints carry, or configured with `ValueObjectConverter` by hand, whose
+  mapping has none: both still throw at `Add` where the column is a `decimal`
+  ([decision 114](adr/0114-a-value-object-s-temporary-number-is-its-wrapped-type-s.md)).
+
 **Analyzers**
-- CMTK0009, a Warning, reports `FirstOrNone`, `SingleOrNone` and `FirstOrError` on an `IQueryable<T>`
-  given a `Func<T, bool>` or a method group, which binds to the sequence overload and reads every row.
 - CMTK0003: `WhenAny` over held tasks; an async expression-bodied member in the IDE, where Metalama
   has not run; and decide whether a tap on a property or an indexer, and a result a cache's
   `GetOrAdd` still holds, are drops, which it reports today.
@@ -49,11 +44,6 @@ Small, each closable in a minor version. Found by the reviews named.
 
 **Generators**
 - A C# keyword in a namespace or a member name fails with LAMA0041, not a CMTK error.
-- Package validation compares the packages' own public surface, not what the generators write into a
-  consumer: a `Parse` that 2.1.0's prerelease stopped generating (a wrapped `Parse` returning a type with
-  an implicit conversion) broke a consumer's call with CS0117 and passed ApiCompat. Snapshot the
-  generated public members of the test corpus' value objects, and fail a change that removes one
-  without a decision (review of 2026-10-14).
 
 **Run time**
 - The Serilog policy ignores `ToMaximumStringLength`.
@@ -68,12 +58,24 @@ Small, each closable in a minor version. Found by the reviews named.
   converters' trimming warnings decide whether it is a package ([decision 71](adr/0071-converters-say-what-they-write.md)).
 - A stable external name for a closed-set member, apart from its C# identifier: parsing, JSON, EF,
   OpenAPI and the fault identifiers at once (proposed in the review of 2026-10-13).
-- The Metalama 2027.0 upgrade, once it is stable (`2027.0.4-preview` on 2026-10-14;
-  [decision 4](adr/0004-metalama-2026-1-x-latest-stable.md)): a minor if a consumer's own aspects beside
-  the packed generators still build and weave, measured as the fabric spike measured 2026.1 against the
-  2027.0 preview, and a major otherwise; `[Durable]` returns to the `_value` placeholder with it.
-- A `net11.0` target beside `net10.0`, in a 2.x minor when a feature needs it ([decision 44](adr/0044-2-0-0-net10-0-metalama.md)): EF Core 11
-  and Microsoft.AspNetCore.OpenApi 11 in the satellites, and a Native AOT smoke run per target.
+- The Metalama 2027.0 upgrade, in 2.5.0 (#173), once 2027.0 is stable (`2027.0.4-preview` on 2026-10-14;
+  [decision 4](adr/0004-metalama-2026-1-x-latest-stable.md)), for both targets at once and with 2.3 and 2.4 on
+  2026.1 ([decision 120](adr/0120-a-net11-0-target-and-documented-floor-raises-join-a-minor.md)). It raises a floor in
+  a minor, which decision 120 allows when documented: a project that references `Metalama.Framework` 2026.1
+  directly gets NU1605 and stays on TypeKit 2.4.x or raises its reference, and a woven `net11.0` project moves
+  from C# 14 to 15. Its conditions: a build with no Metalama license passes in CI and a clean container on 2027
+  (#170), the weaving review and the smoke test run on it, the changelog and the Generators README name the
+  ceiling, the language-version change, the supported IDEs and what Metalama 2027 drops, and the release notes
+  say whether 2.4.x is patched. `[Durable]` returns to the `_value` placeholder with it.
+- A `net11.0` target beside `net10.0`, in a 2.x minor when a feature needs it ([decision 44](adr/0044-2-0-0-net10-0-metalama.md)),
+  on the terms of [decision 120](adr/0120-a-net11-0-target-and-documented-floor-raises-join-a-minor.md): a higher
+  floor in the `net11.0` group (EF Core 11 and Microsoft.AspNetCore.OpenApi 11 in the satellites) allowed when the
+  changelog names it, who it reaches (an application that holds the lower version gets NU1605) and both ways out,
+  and the smoke test shows it; the same generated members on every target; `LangVersion` 14 for `net10.0` and 15 for
+  `net11.0` once it uses a C# 15 feature, a union a new `net11.0`-only member among them; the tests, a Native AOT
+  smoke run and package validation per target. First the spike on an SDK 11
+  compiler, no release attached (#170): `global.json` pins SDK 10.0.4xx because the Roslyn band changes what
+  Metalama emits, and the SDK is generally available in November 2026.
 
 ## Blocked upstream
 
@@ -93,8 +95,11 @@ Small, each closable in a minor version. Found by the reviews named.
   warning ([decision 90](adr/0090-faults-alike-are-a-warning-until-3-0.md)).
 - CMTK1023, a base record's equality that the generated one does not call, becomes an Error
   ([decision 75](adr/0075-equality-over-base-record-generated.md)).
-- C# 15 unions and the `net10.0` drop, timed to .NET 12 LTS (November 2027) or to the end of .NET
-  10's life, whichever its consumers need ([decision 44](adr/0044-2-0-0-net10-0-metalama.md)). The compiler-made union types have a public
+- The `net10.0` drop, and a change of `Option` or `Result` into C# 15 unions, timed to .NET 12 LTS (November
+  2027) or to the end of .NET 10's life, whichever its consumers need ([decision 44](adr/0044-2-0-0-net10-0-metalama.md),
+  kept for .NET 11 by [decision 120](adr/0120-a-net11-0-target-and-documented-floor-raises-join-a-minor.md): .NET 11
+  is not a reason for a major, and a change to a member both targets have is). A union that is new on `net11.0`
+  is an addition, and may join a 2.x minor. The compiler-made union types have a public
   `object? Value` and are serialized by System.Text.Json, so `Option` and `Result` take part in their
-  pattern matching only after a spike shows neither returns, on a branch of its own with no release
-  attached.
+  pattern matching, in either release, only after a spike shows neither returns, on a branch of its own with no
+  release attached.
diff --git a/design/test-strategy.md b/design/test-strategy.md
index 7e1da4d4..4a85ae9b 100644
--- a/design/test-strategy.md
+++ b/design/test-strategy.md
@@ -55,7 +55,7 @@
    attributes, implementations reached through another declaration, methods bound by pattern, crefs and
    `nameof`, and generated code, each run with an argument that breaks the rule's constraint and one that
    meets it. CMTK0010 runs it under three constraints (`TypeArgumentConstraintVariantTests`). For a
-   generated type the class is the `shape.*` axes of `.claude/probe-axes.md`, for a framework option the
+   generated type the class is the declaration shapes of `test/oracles/axes.md`, for a framework option the
    settings axes. Measured: at the origin of CMTK0010's chain of fourteen fixes the catalogue fails on 20
    sites, each fixed by a later member of the chain; seeded, without the rule's method-group and property
    registrations, 15 cases fail.
diff --git a/docs/aspnet-core.md b/docs/aspnet-core.md
index eb69da25..f2c6af01 100644
--- a/docs/aspnet-core.md
+++ b/docs/aspnet-core.md
@@ -246,6 +246,43 @@ string. A client generated from the document then has the member it matches on.
   ends up in the value object's shared component, and from there it applies to every other use of
   that value object.
 
+## Describe value objects as plain types
+
+Some clients work better without a type per value object. A generator that turns each component into a
+class gives you a `CustomerId` wrapper where you wanted a `string`. Turn on `InlineValueObjects`, and
+every value object is described in place by the schema of the type inside it:
+
+```csharp
+builder.Services.AddOpenApi(options => options.AddTypeKit(typeKit => typeKit.InlineValueObjects = true));
+```
+
+The `CustomerDto` from above then has plain properties, and the document has no `CustomerId` or `Email`
+component:
+
+```json
+"CustomerDto": { "type": "object", "properties": {
+    "id": { "type": "string", "format": "uuid" },
+    "email": { "type": "string" },
+    "name": { "type": "string" } } }
+```
+
+The same goes for every place a value object appears: a body, a response, a list's elements, a
+dictionary's values, a route, query or header parameter, and anything nested in those. Each one gets
+exactly the schema the underlying type gets in that place.
+
+**Good to know**
+
+- **Without the setting, nothing changes.** `AddTypeKit()` writes the same document as before, with a
+  component per value object.
+- **A nullable value object allows null in its own schema**, as a nullable property of the underlying
+  type does. That holds under OpenAPI 2.0 too, where a nullable property of a component loses its type.
+- **Closed sets keep their components**, and so does an enum inside a value object. The value object's
+  schema holds the enum's content in place.
+- **Two value objects with one name no longer clash.** Neither has a component, so neither needs a
+  name of its own.
+- **Your own `CreateSchemaReferenceId` still names your other types** when you set it before
+  `AddTypeKit`. One set after `AddTypeKit` replaces TypeKit's naming, and this setting with it.
+
 ## Native AOT
 
 The transformer and `ToHttpResult()` are trim- and AOT-safe, and the smoke test publishes a host
diff --git a/docs/comparison.md b/docs/comparison.md
index b3839b83..a14ce08b 100644
--- a/docs/comparison.md
+++ b/docs/comparison.md
@@ -13,6 +13,8 @@ Every fact here was read from each library's source, at the release named in the
   where one is in preview.
 - **13 October 2026** for closed sets.
 - **14 October 2026**, again, for OpenAPI and Native AOT.
+- **29 October 2026** for SuperStrong.Types. Again for Thinktecture.Runtime.Extensions, at 10.6.0, and
+  LanguageExt, at 5.0.0-beta-78. And again for TypeKit's own columns, at 2.3.0.
 
 What was read for each library, and when, is kept in the repository's
 [verified facts](../design/knowledge/README.md). Each table below lists the entries it rests on.
@@ -25,7 +27,8 @@ If something here is wrong or has changed, please open an issue.
 |---|---|---|
 | .NET Framework, .NET Standard or a .NET before 10 | Vogen for value objects; CSharpFunctionalExtensions, ErrorOr or FluentResults for results | TypeKit targets .NET 10 only. These ship for .NET Standard 2.0 |
 | Newtonsoft.Json, Dapper, LINQ to DB, MongoDB, Orleans, ServiceStack or protobuf-net for value objects | Vogen | It ships an opt-in integration for each. TypeKit covers System.Text.Json, EF Core and ASP.NET Core |
-| A plain Roslyn source generator in the build rather than Metalama | Vogen or Thinktecture.Runtime.Extensions | TypeKit's generators run on Metalama (open source, no license key) in the project that declares value objects |
+| GraphQL with Hot Chocolate, or Newtonsoft.Json, for value objects on .NET 10 | SuperStrong.Types | It ships a package for each. TypeKit covers System.Text.Json, EF Core and ASP.NET Core |
+| A plain Roslyn source generator in the build rather than Metalama | Vogen, Thinktecture.Runtime.Extensions or SuperStrong.Types | TypeKit's generators run on Metalama (open source, no license key) in the project that declares value objects |
 | Value objects of several members, or discriminated unions | Thinktecture.Runtime.Extensions | It has `[ComplexValueObject]` and `[Union]`. A TypeKit value object wraps exactly one value. Its closed sets are the smart enums |
 | Several errors per failure, of typed kinds | ErrorOr | An `ErrorOr<T>` carries a list of errors. A TypeKit `Result` carries one `TError`, which can be a list of your own |
 | A cause nested under an error, metadata per occurrence, or success messages | FluentResults | Its results carry reasons, errors and successes. An error can name what caused it, and both take metadata. A TypeKit `Result` carries one `TError`. A `Fault<TFault>` is one reason from a fixed set, with a sentence about the occurrence and the rule that rejected the value. A closed-set fault carries a kind and constant data. `Catch` carries an exception as the whole error. Nothing attaches a cause to a fault, and a success carries only its value |
@@ -33,39 +36,41 @@ If something here is wrong or has changed, please open an issue.
 | Unions of arbitrary types | OneOf | `OneOf<T0, T1, ...>` is general-purpose. TypeKit has only `Option` and `Result` |
 | A `Result` on the wire | CSharpFunctionalExtensions | It ships opt-in System.Text.Json converters for its `Result`. TypeKit rejects serializing `Option` and `Result`, by design |
 | A smart enum whose JSON or column is a number, or whose wire name differs from its C# identifier | Ardalis.SmartEnum, Intellenum or Thinktecture.Runtime.Extensions | A TypeKit closed set is its member's name everywhere, and the name is the field's |
-| Only your own closed set of outcomes, on .NET 11 | C#'s union types | They arrive with .NET 11 |
-| Years of production use behind the library | Any of the above | TypeKit is new: 1.0.0 shipped in September 2026 |
+| Only your own closed set of outcomes, on .NET 11 | C# 15's union types or closed hierarchies | They need no preview flag in the .NET 11 SDK, which was still a release candidate on 29 October 2026 |
+| A long release history behind the library | LanguageExt, OneOf, CSharpFunctionalExtensions, FluentResults, Ardalis.SmartEnum, Thinktecture.Runtime.Extensions or Vogen | Each was first published on NuGet between 2015 and 2021. TypeKit is new: 1.0.0 shipped in September 2026, and SuperStrong.Types 1.0.0 in July 2026 |
 
-Sources: FluentResults [KB-018](../design/knowledge/KB-018-fluentresults.md), OneOf [KB-019](../design/knowledge/KB-019-oneof.md), and the entries under each table below.
+Sources: FluentResults [KB-018](../design/knowledge/KB-018-fluentresults.md), OneOf [KB-019](../design/knowledge/KB-019-oneof.md), first releases [KB-045](../design/knowledge/KB-045-first-releases-of-the-compared-libraries.md), C# 15 [KB-046](../design/knowledge/KB-046-csharp-15-unions-ship-with-the-net-11-sdk.md), and the entries under each table below.
 
 ## Value objects in detail
 
-| | TypeKit 2.1.0 | Vogen 8.0.7 (the 9.0.0-beta.2 tag the same; not on NuGet) | Thinktecture.Runtime.Extensions 10.5.0 (OpenAPI and AOT: 10.5.1) | StronglyTypedId 1.0.0-beta08 |
-|---|---|---|---|---|
-| Declared by | Implementing `IValue<T>` or `IValidatedValue<...>` on a `partial record` | `[ValueObject<T>]` on a partial type | `[ValueObject<T>]`, `[ComplexValueObject]` or `[SmartEnum<T>]` on a partial type | `[StronglyTypedId]` on a partial struct |
-| Validation | `Create` returns a `Result`, and every generated way of creating a value runs it | `Validate` returns a `Validation`. `From` throws | A `ValidateFactoryArguments` partial method | None |
-| EF Core | `UseTypeKit()` maps every value object, nothing per type. `.Value` in a query translates to the column | A generated converter per value object, which you register. Comparing with a primitive in a query is an error (VOG034) | Packages per EF Core version (8, 9, 10) | Through a template of your own |
-| OpenAPI | Microsoft.AspNetCore.OpenApi: the schema ASP.NET publishes for the underlying type, under the host's JSON options | Opt-in, off by default: a generated schema transformer, with type and format from a built-in table. Swashbuckle support | Swashbuckle filters only, with type and format from Swashbuckle's table | None built in |
-| A JSON converter the host registers, such as a decimal written as a string | Described as it writes, wherever it applies. Either the converter says what it writes (`IDescribedJsonConverter`), or the options say it for that converter (`JsonSchemaDescriptions`). A document that would describe different JSON from what the controllers write is rejected | Not reflected: the table's type and format stay | Not reflected for type and format. A smart enum's listed values are written with the host's options | None built in |
-| Native AOT | Declared (`IsAotCompatible`). On every CI build, a consumer with value objects, JSON, OpenAPI and EF Core is published with Native AOT | Not declared. Its docs say the Swashbuckle schema filter needs reflection that Native AOT lacks | Not declared | Not declared |
-| JSON | System.Text.Json, byte for byte the underlying type's JSON | System.Text.Json by default. Newtonsoft.Json and more, opt-in | System.Text.Json, Newtonsoft.Json, MessagePack | System.Text.Json (more through templates) |
-| Targets | `net10.0` | `netstandard2.0`, .NET Framework projects included | `net8.0`, `net9.0`. The ASP.NET Core and Swashbuckle packages `net8.0` only | `netstandard2.0` |
-| Generated by | Metalama, in the declaring project | A Roslyn source generator | Roslyn source generators | A Roslyn source generator |
-| License | MIT | Apache-2.0 | BSD-3-Clause | MIT |
+| | TypeKit 2.3.0 | Vogen 8.0.7 (the 9.0.0-beta.2 tag the same; not on NuGet) | Thinktecture.Runtime.Extensions 10.6.0 | StronglyTypedId 1.0.0-beta08 | SuperStrong.Types 1.0.0 |
+|---|---|---|---|---|---|
+| Declared by | Implementing `IValue<T>` or `IValidatedValue<...>` on a `partial record` | `[ValueObject<T>]` on a partial type | `[ValueObject<T>]`, `[ComplexValueObject]` or `[SmartEnum<T>]` on a partial type | `[StronglyTypedId]` on a partial struct | `[StrongType<T>]` on a partial class, not a record or a struct |
+| Validation | `Create` returns a `Result`, and every generated way of creating a value runs it | `Validate` returns a `Validation`. `From` throws | A `ValidateFactoryArguments` partial method | None | A `Define()` method built from validators such as `IsPositive()`. `From` throws, `TryFrom` returns `false`, and JSON, parsing, the type converter and EF Core reads run it |
+| EF Core | `UseTypeKit()` maps every value object, nothing per type. `.Value` in a query translates to the column | A generated converter per value object, which you register. Comparing with a primitive in a query is an error (VOG034) | Packages per EF Core version (8, 9, 10) | Through a template of your own | `UseStrongTypes()` maps every strong type, nothing per type. `AsPrimitive()` in a query translates to the column |
+| OpenAPI | Microsoft.AspNetCore.OpenApi: the schema ASP.NET publishes for the underlying type, under the host's JSON options | Opt-in, off by default: a generated schema transformer, with type and format from a built-in table. Swashbuckle support | Swashbuckle filters only, with type and format from Swashbuckle's table | None built in | Microsoft.AspNetCore.OpenApi, opt-in: the schema ASP.NET publishes for the underlying type, inline or as a named component |
+| A JSON converter the host registers, such as a decimal written as a string | Described as it writes, wherever it applies. Either the converter says what it writes (`IDescribedJsonConverter`), or the options say it for that converter (`JsonSchemaDescriptions`). A document that would describe different JSON from what the controllers write is rejected | Not reflected: the table's type and format stay | Not reflected for type and format. A smart enum's listed values are written with the host's MVC or Minimal API JSON options | None built in | Nothing of its own describes it: the schema is the one ASP.NET publishes for the underlying type. Read from its code, not run |
+| Native AOT | Declared (`IsAotCompatible`). On every CI build, a consumer with value objects, JSON, OpenAPI and EF Core is published with Native AOT | Not declared. Its docs say the Swashbuckle schema filter needs reflection that Native AOT lacks | Not declared | Not declared | Not declared |
+| JSON | System.Text.Json, byte for byte the underlying type's JSON | System.Text.Json by default. Newtonsoft.Json and more, opt-in | System.Text.Json, Newtonsoft.Json, MessagePack | System.Text.Json (more through templates) | System.Text.Json, the underlying type's JSON. Newtonsoft.Json, opt-in |
+| Other integrations | Serilog, and test assertions. Nothing for another serializer, ORM or GraphQL | Opt-in packages for Newtonsoft.Json, Dapper, LINQ to DB, MongoDB, Orleans, ServiceStack and protobuf-net | Packages for ASP.NET Core, Swashbuckle, Newtonsoft.Json, MessagePack and Serilog | Templates for EF Core, Newtonsoft.Json and others | Packages for Hot Chocolate (GraphQL) and Newtonsoft.Json |
+| Targets | `net10.0` | `netstandard2.0`, .NET Framework projects included | `net8.0`, `net9.0`. The ASP.NET Core and Swashbuckle packages `net8.0` only | `netstandard2.0` | `net10.0` |
+| Generated by | Metalama, in the declaring project | A Roslyn source generator | Roslyn source generators | A Roslyn source generator | A Roslyn source generator |
+| License | MIT | Apache-2.0 | BSD-3-Clause | MIT | MIT |
 
 Sources: Vogen [KB-010](../design/knowledge/KB-010-vogen-declaring-validating-storing.md) and [KB-011](../design/knowledge/KB-011-vogen-openapi-and-native-aot.md), Thinktecture.Runtime.Extensions [KB-012](../design/knowledge/KB-012-thinktecture-value-objects.md) and [KB-013](../design/knowledge/KB-013-thinktecture-openapi-and-native-aot.md),
-StronglyTypedId [KB-014](../design/knowledge/KB-014-stronglytypedid.md).
+StronglyTypedId [KB-014](../design/knowledge/KB-014-stronglytypedid.md), SuperStrong.Types [KB-044](../design/knowledge/KB-044-superstrong-types.md).
 
 **A gap none of them fills.** ASP.NET Core and System.Text.Json's schema exporter can't see through
 a JSON converter you write yourself ([KB-023](../design/knowledge/KB-023-a-converter-cannot-describe-its-schema.md)). They write it as the empty schema, or with only the `format` its
 CLR type maps to. The serializer has a hook for a converter to describe itself, but it is internal.
 The proposal to make it public ([dotnet/runtime#105769](https://github.com/dotnet/runtime/issues/105769))
-is open, without a release. None of the libraries above fills that gap, so with any of them, a
-converter you register means describing it in the document by hand, type by type.
+is open, without a release. None of the value-object libraries in the table above, at the versions
+named, has code of its own that describes such a converter. So with any of them, a converter you
+register means describing it in the document by hand, type by type.
 
 ## Option and Result in detail
 
-| | TypeKit 2.1.0 | LanguageExt 4.4.9 (5.0.0-beta-77) | CSharpFunctionalExtensions 3.7.0 | ErrorOr 2.1.1 |
+| | TypeKit 2.3.0 | LanguageExt 4.4.9 (5.0.0-beta-78) | CSharpFunctionalExtensions 3.7.0 | ErrorOr 2.1.1 |
 |---|---|---|---|---|
 | Reaching the value | `Match`, `TryGetValue` and the combinators. No `.Value` | `Match`, `IfNone` and the like. No public `.Value` on `Option` | `.Value`, which throws on a failure | `.Value`, which returns `default` on an error |
 | A `default` instance | `Option`: `None`. `Result`: throws when used, and fails the build when written in code (CMTK0001) | `Option`: `None` | `Maybe`: none. `Result<T>`: a success holding `default(T)` | A success holding `default(T)` |
@@ -77,11 +82,11 @@ Sources: LanguageExt [KB-015](../design/knowledge/KB-015-languageext-option.md),
 
 ## Closed sets in detail
 
-| | TypeKit 2.1.0 | Ardalis.SmartEnum 8.2.0 | Intellenum 2.0.1 | Thinktecture.Runtime.Extensions 10.5.1 |
+| | TypeKit 2.3.0 | Ardalis.SmartEnum 8.2.0 | Intellenum 2.0.1 | Thinktecture.Runtime.Extensions 10.6.0 |
 |---|---|---|---|---|
 | Declared by | Implementing `IClosedSet<TSelf>` on a `sealed partial class`, one `public static readonly` field per member | Deriving from `SmartEnum<TEnum>`, each member `new("Name", value)` | `[Intellenum]` on a partial class. Members as fields, `[Member]` attributes or a static constructor | `[SmartEnum<TKey>]` on a partial class, each member `new("KEY")` |
 | Data on a member | Properties, set through the private constructor | The subclass's own fields | One underlying value. Richer data through a custom underlying type | Declared properties, which become constructor parameters |
-| Deciding by member | `Match`, one required delegate per member, every argument named (CMTK0012) | `When(...).Then(...)`. Nothing requires every member | A `switch` over `.Value` with generated constants. Nothing requires every member | Generated `Switch` and `Map`, every member a required argument |
+| Deciding by member | `Match`, one required delegate per member, every argument named (CMTK0012) | `When(...).Then(...)`. Nothing requires every member | A `switch` over `.Value` with generated constants. Nothing requires every member | Generated `Switch` and `Map`, every member a required argument. Overloads that leave members to a default, on request |
 | Parsing by name | `Parse` and `TryParse`, ordinal. `ignoreCase: true` on request, and two members differing only in case fail the build (CMTK1021) | `FromName` and `TryFromName`, ordinal. `ignoreCase` on request. A case clash throws at the first such lookup | `FromName` and `TryFromName`, ordinal. `ignoreCase` on request, and the first declared member answers | `Get` and `TryGet`, ignoring case by default. A case clash throws at the first lookup |
 | JSON | System.Text.Json, the name, nothing registered | A separate package per serializer, a converter attribute per type. The name or the value | Generated into your assembly. The value, as an `enum` writes it | A separate package per serializer. The key |
 | EF Core | `UseTypeKit()`, a text column of the name, nothing per set | A separate package, a convention or per model. The value | An opt-in generated converter, registered per property. The value | A separate package per EF version, `UseThinktectureValueConverters()`. The key |
diff --git a/docs/ef-core.md b/docs/ef-core.md
index a2f5159c..9e31d8e9 100644
--- a/docs/ef-core.md
+++ b/docs/ef-core.md
@@ -130,9 +130,11 @@ A composite key of value objects is `HasKey(x => new { x.Order, x.Line })`, as f
 
 - **A key over `char` is always yours to assign**, on every provider, since none generates one. A
   default `'\0'` is stored as it is, so assign a meaningful character.
-- **A key over `ulong` needs `ValueGeneratedNever()` on SQL Server and PostgreSQL.** Their column is a
-  `decimal`, so adding the entity with the key's default value throws `OverflowException` at `Add`.
-  Configure `ValueGeneratedNever()` and assign the key.
+- **Under Native AOT, a key over `ulong` needs `ValueGeneratedNever()` on SQL Server and PostgreSQL.**
+  Their column is a `decimal`, and in a compiled model made with `--nativeaot`, adding the entity with
+  the key's default value throws `OverflowException` at `Add`. The same goes for a key you configure
+  with `ValueObjectConverter` yourself. Configure `ValueGeneratedNever()` and assign the key.
+  Otherwise it gets a temporary value, as a plain `ulong` key does.
 - **Inheritance hierarchies.** The root of a TPH or TPT hierarchy is generated too. Under TPC, as for
   an `int` key, it's generated only where the provider has a sequence for the hierarchy (PostgreSQL,
   SQL Server), not on SQLite.
@@ -221,7 +223,7 @@ To get one element of a query as an option, use `FirstOrNone`, `SingleOrNone` or
 - **Write the condition as a lambda at the call**, or hold it as an `Expression<Func<T, bool>>`. Only
   then does it run in the database. A `Func<T, bool>` variable or a method group binds the synchronous
   methods to their overloads on a sequence. Those read every row of the table and run the condition
-  in memory, without a warning.
+  in memory, and the analyzer warns at the call (CMTK0009).
 
 ## Compiled models
 
@@ -264,8 +266,8 @@ The block under [Keys](#keys) is the whole setup:
 
 EF's in-memory provider won't work. It has no relational type mapping, so nothing is mapped there.
 
-This repository tests the mapping on SQLite and PostgreSQL, and every family of underlying types makes
-a round trip through a real PostgreSQL.
+This repository tests the mapping on SQLite, PostgreSQL and SQL Server, and every family of underlying
+types makes a round trip through a real PostgreSQL and a real SQL Server.
 
 ## If something does not map
 
diff --git a/docs/migrating-to-2.md b/docs/migrating-to-2.md
index 8ec91c0a..3d0934f1 100644
--- a/docs/migrating-to-2.md
+++ b/docs/migrating-to-2.md
@@ -159,8 +159,9 @@ key column.
 - **On SQL Server**, the migrations generator rejects the change for all four types ("To change the
   IDENTITY property of a column, the column needs to be dropped and recreated").
 - **A key over `ulong`** isn't generated on PostgreSQL, because `numeric(20,0)` has no identity.
-  Adding an entity with a default `ulong` key throws `OverflowException` at `Add`, on PostgreSQL and
-  SQL Server alike, where 1.5 stored 0.
+  From 2.0.0 to 2.2.0, adding an entity with a default `ulong` key threw `OverflowException` at
+  `Add`, on PostgreSQL and SQL Server alike, where 1.5 stored 0. From 2.3.0 it gets a temporary value,
+  as a plain `ulong` key does, except in a compiled model made with `--nativeaot`.
 
 To keep 1.5's behaviour for any of these keys, configure `ValueGeneratedNever()` on it and assign the
 key yourself.
diff --git a/docs/option.md b/docs/option.md
index 17b08be5..82be3447 100644
--- a/docs/option.md
+++ b/docs/option.md
@@ -52,8 +52,8 @@ compile, because a query has no last row until you order it.
 
 The predicate runs in the database only when it is an expression, which a lambda written at the call
 is. A `Func<T, bool>` held in a variable, or a method group, binds to the sequence overload instead.
-That reads every row and checks the condition in memory, with no warning. Pass an
-`Expression<Func<T, bool>>` there.
+That reads every row and checks the condition in memory, and the analyzer warns at the call
+(CMTK0009). Pass an `Expression<Func<T, bool>>` there.
 
 **Good to know**
 
@@ -189,6 +189,7 @@ elements `Choose(selector)` reads may be null, and only what the selector finds
 | `GetValueOrNone(key)` | `IReadOnlyDictionary<TKey, TValue>` | `Option<TValue>` |
 | `Choose(selector)` | `IEnumerable<T>`, its elements nullable or not | the values the selector answers `Some` for, in order and lazily: a filter and a map in one |
 | `Choose()` | `IEnumerable<Option<T>>` | the values of the options that hold one, in order and lazily |
+| `Choose(selector)`, `Choose()` | `IAsyncEnumerable<T>`, `IAsyncEnumerable<Option<T>>` | the same, as an `IAsyncEnumerable` of the values as they arrive; the token given to `WithCancellation` reaches the stream |
 | `IsSome()`, `IsNone()` | `Option<T>` | `bool` |
 | `Match(onSome, onNone)` | `Option<T>` | what the branch returns |
 | `TryGetValue(out value)` | `Option<T>` | `bool`; `value` is non-null when true |
diff --git a/docs/result.md b/docs/result.md
index 3aca7781..0ba9d4f0 100644
--- a/docs/result.md
+++ b/docs/result.md
@@ -230,10 +230,15 @@ token before each operation and hands it on. A cancellation propagates as an exc
 become an error. When the operations may all run at once, use `Task.WhenAll` over their tasks and
 `Sequence()` over what it returns.
 
+On an `Option` or a `Patch`, `TraverseAsync` runs the operation once, when there is a value. `None`,
+a clear and an absent field call nothing and pass through.
+
 ```csharp
 Result<IReadOnlyList<Reservation>, CheckoutFault> reserved = await carts.TraverseAsync(checkout.ReserveAsync);     // one at a time, in order; nothing starts after a fault
 Result<CheckoutFault> charged = await totals.TraverseAsync(checkout.ChargeAsync);                                   // a command per element, likewise
 Result<IReadOnlyList<Cart>, CheckoutFault> found = await ids.TraverseAsync(checkout.LoadCartAsync, cancellationToken);   // the token checked before each, and handed to it
+Result<Option<Cart>, CheckoutFault> saved = await savedCart.TraverseAsync(checkout.FindCartAsync);           // None calls nothing; a value is looked up
+Result<Patch<Cart>, CheckoutFault> moved = await movedTo.TraverseAsync(checkout.FindCartAsync);              // a clear or an absence passes through
 ```
 
 ## An exception as an outcome
@@ -257,7 +262,7 @@ An exception is for the code that called, not for a client. `ToHttpResult()` doe
 - **Name both type arguments to narrow.** `Catch<T, TException>` spells both, since C# infers all
   type arguments or none.
 - **Use `CatchAsync` for a task.** It awaits the task, so an exception thrown after the task's first
-  `await` is the error too. Passing a delegate that returns a `Task` to `Catch` fails to compile, and
+  `await` is the error too. A `ValueTask` works the same way: `Result.CatchAsync(() => stream.ReadAsync(buffer))`. Passing a delegate that returns a `Task` to `Catch` fails to compile, and
   the error names `CatchAsync`. The task's exception would otherwise be thrown after `Catch` had
   returned.
 - **A cancellation is not an outcome.** An `OperationCanceledException` passes through every
@@ -311,15 +316,18 @@ throughout.
 | implicit from `T`, `Success<T>`, `Error<TError>` | `Result<T, TError>` | a bare value is a success; a bare error is not, since it could be either |
 | implicit from `TError`, `Success`, `Error<TError>` | `Result<TError>` | a bare error converts, and so does the marker |
 | `Catch(action)`, `Catch<T, TException>(action)`, `Catch<TException>(action)` | `Result` | `Result<T, Exception>` or `Result<Exception>`; narrowed to one exception type |
-| `CatchAsync(action)` and the same type-argument forms | `Result` | the same, awaiting the task |
+| `CatchAsync(action)` and the same type-argument forms | `Result` | the same, awaiting the `Task` or `ValueTask` |
 | `ToResult(error)` | `Option<T>` | `Result<T, TError>` |
 | `FirstOrError(predicate, error)`, `LastOrError(predicate, error)` | `IEnumerable<T>`; `FirstOrError` on `IQueryable<T>` too | the first or last match, or the error; on a query the provider runs the predicate, and `LastOrError` is a compile error |
 | `Traverse(selector)` | `IEnumerable<T>` | `Result<IReadOnlyList<TResult>, TError>`, or `Result<TError>` for a command selector; stops at the first error |
 | `Traverse(selector)` | `Option<T>` | `Result<Option<TResult>, TError>`: an optional input validated when present |
 | `Traverse(selector)` | `Patch<T>` | `Result<Patch<TResult>, TError>`: a patch field validated when it carries a value; a clear or an absence passes through |
 | `TraverseAsync(selector)`, `TraverseAsync(selector, cancellationToken)` | `IEnumerable<T>` | as `Traverse`, one operation awaited at a time; nothing starts after an error, or once the token is cancelled |
+| `TraverseAsync(selector)`, `TraverseAsync(selector, cancellationToken)` | `IAsyncEnumerable<T>` | as over `IEnumerable<T>`; nothing more is read after an error, and the token reaches the stream too |
+| `TraverseAsync(selector)`, `TraverseAsync(selector, cancellationToken)` | `Option<T>`, `Patch<T>` | as `Traverse`, the operation awaited; nothing is called without a value |
 | `Transpose()` | `Option<Result<T, TError>>`, `Result<Option<T>, TError>` | the one turned inside out: `None` is a success without a value, an error stays the error |
 | `Sequence()` | `IEnumerable<Result<T, TError>>`, `IEnumerable<Result<TError>>` | the list of values, or the first error |
+| `SequenceAsync()`, `SequenceAsync(cancellationToken)` | `IAsyncEnumerable<Result<T, TError>>`, `IAsyncEnumerable<Result<TError>>` | the same, awaited; nothing more is read after the first error, and the token reaches the stream |
 
 **Reaching the outcome**
 
diff --git a/docs/testing.md b/docs/testing.md
index 9b8cb278..8c670f85 100644
--- a/docs/testing.md
+++ b/docs/testing.md
@@ -167,3 +167,5 @@ The analyzers run in test projects as they do everywhere else.
   Neither is a `default` assigned to the `out` parameter of a `Try` method.
 - **A dropped `Result` is reported (CMTK0003)**, in a test too. Write `_ = ProductCode.Create(input);`
   to show the drop is meant.
+- **So is an assertion on a task you don't await (CMTK0003).** `service.FindAsync(id).ShouldBeSome();`
+  without `await` passes whatever the task holds.
diff --git a/docs/value-objects.md b/docs/value-objects.md
index 76f8cc6f..d31036e4 100644
--- a/docs/value-objects.md
+++ b/docs/value-objects.md
@@ -8,7 +8,9 @@ This page helps you design them: pick a struct or a class, write the validation,
 error carries, and call the right factory. The
 [Generators README](../src/CodoMetis.TypeKit.Generators/README.md) lists everything that is
 generated, member by member, and every build error. The interfaces themselves are in the
-[base README](../src/CodoMetis.TypeKit/README.md#value-objects).
+[base README](../src/CodoMetis.TypeKit/README.md#value-objects). To see value objects cross every
+boundary of one service, from the request to the database, the log and back, read the
+[Walkthrough](walkthrough.md).
 
 Reference `CodoMetis.TypeKit.Generators` in the project that declares value objects. The examples
 import `CodoMetis.TypeKit` and `CodoMetis.TypeKit.ValueObjects`.
diff --git a/docs/walkthrough.md b/docs/walkthrough.md
new file mode 100644
index 00000000..5d4e2304
--- /dev/null
+++ b/docs/walkthrough.md
@@ -0,0 +1,369 @@
+# Walkthrough: one orders service
+
+This page follows one small orders service from the request to the database and back. Each guide
+covers one boundary. Here you see one e-mail address cross all of them, and at each step what
+happens to it, or that nothing does.
+
+The service is a minimal API on SQLite. It uses the generators, the EF Core package, the ASP.NET Core
+package and the Serilog package. Its code is a sample application. CI runs it on every change, and
+builds it from the packed packages too, so every answer below is one it really gives:
+[Orders.cs](../tools/ConsumerSmokeTest/Consumers/walkthrough/Orders.cs),
+[OrderEndpoints.cs](../tools/ConsumerSmokeTest/Consumers/walkthrough/OrderEndpoints.cs),
+[Program.cs](../tools/ConsumerSmokeTest/Consumers/walkthrough/Program.cs), and the requests in
+[Tour.cs](../tools/ConsumerSmokeTest/Consumers/walkthrough/Tour.cs).
+
+| Step | What happens to the e-mail address |
+|---|---|
+| [Declare the values](#declare-the-values) | `Create` trims it, composes it and checks it, once |
+| [Store them](#store-them) | it becomes a plain `TEXT` column |
+| [Place an order](#place-an-order) | JSON reads it through `Create` and writes it back as a string. The log masks it |
+| [Reject what doesn't fit](#reject-what-doesnt-fit) | a rejected value gets a 400 that never quotes it |
+| [Find an order](#find-an-order) | nothing: an `Option` becomes a 404 |
+| [Query on `.Value`](#query-on-value) | nothing: `.Value` is the column in SQL |
+| [Change an order](#change-an-order) | a `Patch<T>` reads each field through its own `Create` |
+| [Read the OpenAPI document](#read-the-openapi-document) | it is described as the string it is |
+
+## Declare the values
+
+```csharp
+public readonly partial record struct OrderId : IValue<Guid>;
+
+public enum EmailFault { Blank, Hidden, NoAt }
+
+public readonly partial record struct Email : IValidatedValue<Email, string, EmailFault>
+{
+    public static Result<Email, EmailFault> Create(string value) =>
+        value.AsText()                                                                    // trimmed, composed, no hidden characters
+             .MapError(fault => fault == TextFault.Blank ? EmailFault.Blank : EmailFault.Hidden)
+             .Ensure(text => text.IndexOf('@') > 0, EmailFault.NoAt)
+             .Map(text => new Email(text));
+
+    public override string ToString() => $"{Value[0]}***{Value[Value.IndexOf('@')..]}";   // what a log shows
+}
+
+public enum QuantityFault { NotPositive }
+
+public readonly partial record struct Quantity : IValidatedValue<Quantity, int, QuantityFault>
+{
+    public static Result<Quantity, QuantityFault> Create(int value) =>
+        value > 0 ? new Quantity(value) : Result.Error(QuantityFault.NotPositive);
+}
+
+public sealed partial class OrderStatus : IClosedSet<OrderStatus>
+{
+    public static readonly OrderStatus Placed = new();
+    public static readonly OrderStatus Shipped = new();
+    public static readonly OrderStatus Cancelled = new();
+}
+```
+
+These are the service's whole domain:
+
+- **`OrderId`** wraps a `Guid`. `OrderId.New()` makes a version 7 one.
+- **`Email`** is validated. Its `Create` runs the text guard `AsText()`, which trims the address,
+  composes it to one spelling and rejects hidden characters. Then it checks for an `@`. Every way an
+  `Email` gets created runs this `Create`: JSON, a route or query value, `TryFrom`.
+- **`Email.ToString()`** masks the address. The generators keep a `ToString()` you write, and every
+  log line prints it.
+- **`Quantity`** rejects zero and less.
+- **`OrderStatus`** is a closed set: an enum whose members are instances, written as their names.
+
+The [Value objects](value-objects.md), [Written text](text.md) and [Closed sets](closed-sets.md)
+guides cover each kind.
+
+## Store them
+
+```csharp
+public sealed class Order
+{
+    public required OrderId Id { get; init; }
+    public required Email Email { get; set; }
+    public required Quantity Quantity { get; set; }
+    public required OrderStatus Status { get; set; }
+}
+
+public sealed class OrdersDb(DbContextOptions<OrdersDb> options) : DbContext(options)
+{
+    public DbSet<Order> Orders => Set<Order>();
+}
+```
+
+The entity uses the value objects as its properties, with nothing to register per type.
+`Program.cs` sets up the host. `UseTypeKit()` maps each value object to a column of the type inside
+it, and `EnsureCreated()` shows the table that comes of it. `MapOrders()` maps the endpoints the next
+sections show.
+
+```csharp
+using CodoMetis.TypeKit.AspNetCore;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Serilog;
+using Walkthrough;
+```
+
+```csharp
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddOpenApi(options => options.AddTypeKit());
+builder.Services.AddFaultResponses<OrderFault>(fault => fault switch
+{
+    OrderFault.NotFound => StatusCodes.Status404NotFound,
+    OrderFault.AlreadyShipped or OrderFault.Cancelled => StatusCodes.Status409Conflict,
+    OrderFault.Cleared => StatusCodes.Status422UnprocessableEntity,
+    _ => throw new ArgumentOutOfRangeException(nameof(fault)),
+});
+builder.Services.ConfigureHttpJsonOptions(options => options.SerializerOptions.RespectRequiredConstructorParameters = true);
+
+var connection = new SqliteConnection("Data Source=:memory:");   // the database lives as long as this connection is open
+connection.Open();
+builder.Services.AddDbContext<OrdersDb>(options => options.UseSqlite(connection).UseTypeKit()
+    .LogTo(Console.WriteLine, [RelationalEventId.CommandExecuted]));
+
+builder.Services.AddSingleton<Serilog.ILogger>(new LoggerConfiguration()
+    .Destructure.WithTypeKit()
+    .WriteTo.Console(outputTemplate: "[{Level:u3}] {Message:lj}{NewLine}")
+    .CreateLogger());
+```
+
+```csharp
+var app = builder.Build();
+app.UseStatusCodePages();
+app.MapOpenApi();
+app.MapOrders();
+
+using (var scope = app.Services.CreateScope())
+{
+    scope.ServiceProvider.GetRequiredService<OrdersDb>().Database.EnsureCreated();
+    // CREATE TABLE "Orders" (
+    //     "Id" TEXT NOT NULL CONSTRAINT "PK_Orders" PRIMARY KEY,
+    //     "Email" TEXT NOT NULL,
+    //     "Quantity" INTEGER NOT NULL,
+    //     "Status" TEXT NOT NULL
+    // );
+}
+```
+
+What changes here: a value object becomes its underlying type. The id is a `TEXT` key, as a `Guid` is
+on SQLite, and the quantity an `INTEGER`. The status is its member's name. Reading a row back skips
+`Create`, because the service wrote that value itself ([EF Core](ef-core.md)).
+
+**Good to know**
+
+- **The database lives in one open connection.** SQLite in memory keeps a database as long as its
+  connection is open, so the service opens one and keeps it. Your own service passes a connection
+  string instead.
+- **`LogTo` prints the SQL** that EF Core runs, which is how this page shows it.
+- **`RespectRequiredConstructorParameters`** makes a body that leaves out `email` a 400. Without it,
+  the `Email` would be `default`, an address that never went through `Create`
+  ([ASP.NET Core](aspnet-core.md#what-a-refused-value-answers)).
+
+## Place an order
+
+```csharp
+public sealed record PlaceOrder(Email Email, Quantity Quantity);
+
+public sealed record OrderView(OrderId Id, Email Email, Quantity Quantity, OrderStatus Status)
+{
+    public static OrderView Of(Order order) => new(order.Id, order.Email, order.Quantity, order.Status);
+}
+
+public enum OrderFault { NotFound, AlreadyShipped, Cancelled, Cleared }
+```
+
+```csharp
+app.MapPost("/orders", async (PlaceOrder request, OrdersDb db, Serilog.ILogger log) =>
+{
+    var order = new Order { Id = OrderId.New(), Email = request.Email, Quantity = request.Quantity, Status = OrderStatus.Placed };
+    db.Orders.Add(order);
+    await db.SaveChangesAsync();
+
+    var view = OrderView.Of(order);
+    log.Information("Placed {@Order}", view);   // Placed {"Id": "…", "Email": "a***@example.com", "Quantity": "2", "Status": "Placed", "$type": "OrderView"}
+    return TypedResults.Created($"/orders/{order.Id}", view);
+});
+```
+
+The requests are in [Tour.cs](../tools/ConsumerSmokeTest/Consumers/walkthrough/Tour.cs). `Send`
+sends one and returns an `Answer`: its status and its body. The comment after each request is what it
+gets back, with `…` for an id. The client sends the address with spaces around it:
+
+```csharp
+Answer placed = await Send("POST", "/orders", """{"email":"  ann@example.com ","quantity":2}""");   // 201 {"id":"…","email":"ann@example.com","quantity":2,"status":"Placed"}
+OrderId id = JsonSerializer.Deserialize<OrderView>(placed.Body, JsonSerializerOptions.Web)!.Id;
+```
+
+Here the address crosses three boundaries:
+
+- **On the way in**, the JSON converter calls `Create`. So the handler receives `ann@example.com`,
+  trimmed, and never sees the spaces.
+- **On the way out**, the JSON is the underlying type's: `"email":"ann@example.com"`, a plain
+  string, and the closed set is its name ([JSON](json.md)).
+- **In the log**, the address is masked. Serilog destructures `{@Order}` by its properties, and
+  `Destructure.WithTypeKit()` logs each value object as what its `ToString()` prints. Without it,
+  Serilog would read `Value` and log the address ([Logging and secrets](logging-and-secrets.md)).
+
+The client reads the answer back into the same types. Its id is an `OrderId` again.
+
+## Reject what doesn't fit
+
+```csharp
+Answer noAt = await Send("POST", "/orders", """{"email":"ann","quantity":2}""");   // 400 {"type":"https://tools.ietf.org/html/rfc9110#section-15.5.1","title":"Bad Request","status":400,"traceId":"…"}
+Answer noEmail = await Send("POST", "/orders", """{"quantity":2}""");              // 400 {"type":"https://tools.ietf.org/html/rfc9110#section-15.5.1","title":"Bad Request","status":400,"traceId":"…"}
+Answer notAnId = await Send("GET", "/orders/42");                                  // 400 {"type":"https://tools.ietf.org/html/rfc9110#section-15.5.1","title":"Bad Request","status":400,"traceId":"…"}
+Answer noneAtAll = await Send("GET", "/orders?minimum=0");                         // 400 {"type":"https://tools.ietf.org/html/rfc9110#section-15.5.1","title":"Bad Request","status":400,"traceId":"…"}
+```
+
+Each of these is a 400 with problem details, and none of them quotes what the client sent:
+
+- **A body** that `Create` rejects throws a `JsonException` that names `Email` and `NoAt`, never the
+  text. The handler never runs.
+- **A body without `email`** is rejected because of `RespectRequiredConstructorParameters`.
+- **A route value** that isn't an `OrderId`, and **a query value** that `Create` rejects, fail the
+  generated `TryParse`.
+
+`UseStatusCodePages()` gives these empty 400s their problem body. The body is ASP.NET's own and
+names neither the field nor the rule. ASP.NET logs the reason.
+
+## Find an order
+
+```csharp
+app.MapGet("/orders/{id}", async (OrderId id, OrdersDb db) =>
+    (await db.Orders.FirstOrNoneAsync(order => order.Id == id))   // an Option: the order, or none
+        .ToResult(OrderFault.NotFound)
+        .Map(OrderView.Of)
+        .ToHttpResult())
+   .WithoutFaults(OrderFault.AlreadyShipped, OrderFault.Cancelled, OrderFault.Cleared);   // finding one reports only NotFound
+```
+
+```csharp
+Answer found = await Send("GET", $"/orders/{id}");               // 200 {"id":"…","email":"ann@example.com","quantity":2,"status":"Placed"}
+Answer missing = await Send("GET", $"/orders/{OrderId.New()}");   // 404 {"type":"https://tools.ietf.org/html/rfc9110#section-15.5.5","title":"Not Found","status":404,"fault":"NotFound","traceId":"…"}
+```
+
+`FirstOrNoneAsync` asks the database for one row and returns an `Option`, so there is no `null` to
+forget. `ToResult` turns a missing order into the error `NotFound`, and `ToHttpResult()` answers it
+with the status the setup maps it to, as problem details. The `fault` member names the error, so a
+client can tell a missing order from any other 404 ([Result](result.md),
+[ASP.NET Core](aspnet-core.md#a-result-as-a-response)).
+
+`WithoutFaults` lists the errors this endpoint never reports. The OpenAPI document then shows only
+the 404 for it, where it would otherwise list every status `OrderFault` maps to.
+
+Nothing changes for the id here. The route value becomes an `OrderId` through `TryParse`, and the
+query compares it with the key column.
+
+**Good to know**
+
+- **ASP0020 is a false alarm here.** The service declares its value objects in the web project, so
+  ASP.NET's route analyzer reads `OrderId` before the generators make it parsable. `OrderEndpoints.cs`
+  suppresses the warning. Value objects in a domain project of their own need nothing
+  ([ASP.NET Core](aspnet-core.md#bind-value-objects-in-a-minimal-api)).
+
+## Query on `.Value`
+
+```csharp
+app.MapGet("/orders", async (Quantity minimum, OrdersDb db) =>
+    await db.Orders.Where(order => order.Quantity.Value >= minimum.Value)   // WHERE "o"."Quantity" >= @minimum_Value
+                   .Select(order => OrderView.Of(order))
+                   .ToListAsync());
+```
+
+```csharp
+Answer atLeastTwo = await Send("GET", "/orders?minimum=2");   // 200 [{"id":"…","email":"ann@example.com","quantity":2,"status":"Placed"}]
+Answer atLeastFive = await Send("GET", "/orders?minimum=5");  // 200 []
+```
+
+`minimum` comes from the query string, through `Create`. In the query, `order.Quantity.Value` is the
+`Quantity` column itself, so the comparison runs in the database. `.Value` works the same way in memory
+and in SQL ([EF Core](ef-core.md)).
+
+## Change an order
+
+```csharp
+public sealed record OrderPatch
+{
+    public Patch<Quantity> Quantity { get; init; }
+    public Patch<OrderStatus> Status { get; init; }
+}
+
+public static class OrderPatching
+{
+    public static Result<Order, OrderFault> Apply(this Order order, OrderPatch patch)
+    {
+        if (order.Status == OrderStatus.Shipped) return Result.Error(OrderFault.AlreadyShipped);
+        if (order.Status == OrderStatus.Cancelled) return Result.Error(OrderFault.Cancelled);
+        if (patch.Quantity.State == PatchState.Null || patch.Status.State == PatchState.Null) return Result.Error(OrderFault.Cleared);   // neither field can be cleared
+
+        patch.Quantity.Tap(quantity => order.Quantity = quantity);
+        patch.Status.Tap(status => order.Status = status);
+        return order;
+    }
+}
+```
+
+```csharp
+app.MapPatch("/orders/{id}", async (OrderId id, OrderPatch patch, OrdersDb db) =>
+{
+    var changed = (await db.Orders.FirstOrNoneAsync(order => order.Id == id))
+        .ToResult(OrderFault.NotFound)
+        .Bind(order => order.Apply(patch));
+    await db.SaveChangesAsync();
+    return changed.Map(OrderView.Of).ToHttpResult();
+});
+```
+
+```csharp
+Answer three = await Send("PATCH", $"/orders/{id}", """{"quantity":3}""");        // 200 {"id":"…","email":"ann@example.com","quantity":3,"status":"Placed"}
+Answer zero = await Send("PATCH", $"/orders/{id}", """{"quantity":0}""");         // 400 {"type":"https://tools.ietf.org/html/rfc9110#section-15.5.1","title":"Bad Request","status":400,"traceId":"…"}
+Answer cleared = await Send("PATCH", $"/orders/{id}", """{"quantity":null}""");   // 422 {"type":"https://tools.ietf.org/html/rfc4918#section-11.2","title":"Unprocessable Entity","status":422,"fault":"Cleared","traceId":"…"}
+Answer shipped = await Send("PATCH", $"/orders/{id}", """{"status":"Shipped"}""");   // 200 {"id":"…","email":"ann@example.com","quantity":3,"status":"Shipped"}
+Answer tooLate = await Send("PATCH", $"/orders/{id}", """{"quantity":4}""");      // 409 {"type":"https://tools.ietf.org/html/rfc9110#section-15.5.10","title":"Conflict","status":409,"fault":"AlreadyShipped","traceId":"…"}
+```
+
+A `Patch<T>` tells apart a field the request left out, a field set to `null`, and a new value. Each
+field reads its value through its own `Create`, so `{"quantity":0}` is a 400 like any other body.
+`Apply` decides what a `null` means. Here neither field can be cleared, so a clear gets the error
+`Cleared`. A shipped order changes no more, and gets `AlreadyShipped`
+([Merge patches](merge-patches.md)).
+
+`Bind` runs `Apply` only on an order that was found, so one `ToHttpResult()` answers every error.
+
+## Read the OpenAPI document
+
+```csharp
+JsonNode document = JsonNode.Parse(await http.GetStringAsync("/openapi/v1.json"))!;
+JsonNode schemas = document["components"]!["schemas"]!;
+JsonNode find = document["paths"]!["/orders/{id}"]!["get"]!;
+
+string idParameter = find["parameters"]![0]!["schema"]!.ToJsonString();                         // {"type":"string","format":"uuid"}
+string findAnswers = string.Join(",", find["responses"]!.AsObject().Select(answer => answer.Key));   // 200,404
+string emailSchema = schemas["Email"]!.ToJsonString();                                             // {"type":"string"}
+string statusSchema = schemas["OrderStatus"]!.ToJsonString();                                      // {"enum":["Placed","Shipped","Cancelled"],"type":"string"}
+string patchType = schemas["OrderPatch"]!["properties"]!["quantity"]!["type"]!.ToJsonString();    // ["null","integer","string"]
+```
+
+`AddTypeKit()` describes every value object as the schema of the type inside it:
+
+- **The route's `id`** is a `uuid` string, as a `Guid` parameter would be.
+- **The errors** are listed beside the success: `GET /orders/{id}` answers 200 or 404.
+- **`Email`** is a string in a body, and keeps a component of its own.
+- **The closed set** is a string enum of its names.
+- **A patch field** is its underlying type's schema, and may also be `null`. The `string` is
+  ASP.NET's own: a minimal API reads a number from a string too.
+
+So a client generated from the document sends and receives plain strings and numbers
+([ASP.NET Core](aspnet-core.md#see-value-objects-in-the-openapi-document)).
+
+## What changes where
+
+| Boundary | The e-mail address there |
+|---|---|
+| `Create` | trimmed and composed, or rejected |
+| JSON, in a request or a response | the string itself |
+| A route or query value | read by the generated `TryParse`, which calls `Create` |
+| The database | a `TEXT` column, read back without `Create` |
+| A LINQ query | `.Value` is the column |
+| A rejected request | a 400 that names neither the value nor the rule |
+| A log line | what `ToString()` prints: masked |
+| The OpenAPI document | a string |
diff --git a/site/docfx.json b/site/docfx.json
new file mode 100644
index 00000000..0dbd56ab
--- /dev/null
+++ b/site/docfx.json
@@ -0,0 +1,40 @@
+{
+  "$schema": "https://raw.githubusercontent.com/dotnet/docfx/main/schemas/docfx.schema.json",
+  "metadata": [
+    {
+      "src": [
+        {
+          "src": "obj/pub",
+          "files": [
+            "CodoMetis.TypeKit.dll",
+            "CodoMetis.TypeKit.EntityFrameworkCore.dll",
+            "CodoMetis.TypeKit.AspNetCore.dll",
+            "CodoMetis.TypeKit.Serilog.dll",
+            "CodoMetis.TypeKit.Testing.dll"
+          ]
+        }
+      ],
+      "dest": "obj/api"
+    }
+  ],
+  "build": {
+    "content": [
+      { "files": [ "index.md", "toc.yml" ] },
+      { "src": "obj/api", "dest": "api", "files": [ "**.yml" ] },
+      { "src": "..", "files": [ "README.md", "CHANGELOG.md", "docs/*.md", "src/*/README.md" ] }
+    ],
+    "resource": [
+      { "src": "..", "dest": "_repository", "files": [ "design/**", "CONTRIBUTING.md", "SECURITY.md", "AGENTS.md", "LICENSE", "tools/ConsumerSmokeTest/Consumers/walkthrough/*.cs" ] }
+    ],
+    "output": "obj/_site",
+    "template": [ "default", "modern", "template" ],
+    "globalMetadata": {
+      "_appTitle": "CodoMetis.TypeKit",
+      "_appName": "CodoMetis.TypeKit",
+      "_appFooter": "MIT licensed. <a href=\"https://github.com/CaffeinatedCoder/CodoMetis.TypeKit\">GitHub</a>",
+      "_enableSearch": true,
+      "_disableContribution": true,
+      "_repository": "https://github.com/CaffeinatedCoder/CodoMetis.TypeKit"
+    }
+  }
+}
diff --git a/site/index.md b/site/index.md
new file mode 100644
index 00000000..a9560a15
--- /dev/null
+++ b/site/index.md
@@ -0,0 +1,3 @@
+---
+redirect_url: README.html
+---
diff --git a/site/template/conceptual.extension.js b/site/template/conceptual.extension.js
new file mode 100644
index 00000000..21f604c4
--- /dev/null
+++ b/site/template/conceptual.extension.js
@@ -0,0 +1,28 @@
+// A link from a page to a file of the repository that is not a page of the site (a design note, a decision record,
+// CONTRIBUTING.md, spikes/) becomes a GitHub address at the commit the site is built from (#115). The sources are
+// never edited for the site.
+//
+// DocFX hands this script each page's HTML with its links still rooted at site/ (`~/../design/plan.md`), before it
+// resolves and checks them. A link to a page is left as it is, so DocFX checks it and its anchor and fails the build
+// with --warningsAsErrors when either is broken; a link rewritten here is checked by DocumentationLinkTests instead.
+// The patterns are the content globs of site/docfx.json: change the two together.
+var pages = [/^README\.md$/, /^CHANGELOG\.md$/, /^docs\/[^\/]+\.md$/, /^src\/[^\/]+\/README\.md$/];
+
+exports.preTransform = function (model) {
+  return model;
+};
+
+exports.postTransform = function (model) {
+  var commit = model._commit;
+  if (!commit) {
+    throw new Error('site/template: no commit to link the repository at. Pass --metadata _commit=<sha>, as CONTRIBUTING.md shows.');
+  }
+
+  model.conceptual = model.conceptual.replace(/href="~\/\.\.\/([^"#]*)(#[^"]*)?"/g, function (link, path, anchor) {
+    if (pages.some(function (page) { return page.test(path); })) return link;
+
+    var kind = path === '' || path.charAt(path.length - 1) === '/' ? 'tree' : 'blob';
+    return 'href="' + model._repository + '/' + kind + '/' + commit + '/' + path + (anchor || '') + '"';
+  });
+  return model;
+};
diff --git a/site/toc.yml b/site/toc.yml
new file mode 100644
index 00000000..e18bfb5f
--- /dev/null
+++ b/site/toc.yml
@@ -0,0 +1,58 @@
+- name: Home
+  href: ../README.md
+- name: Guides
+  items:
+    - name: Walkthrough
+      href: ../docs/walkthrough.md
+    - name: Value objects
+      href: ../docs/value-objects.md
+    - name: Closed sets
+      href: ../docs/closed-sets.md
+    - name: Option
+      href: ../docs/option.md
+    - name: Result
+      href: ../docs/result.md
+    - name: Written text
+      href: ../docs/text.md
+    - name: Type constraints
+      href: ../docs/type-constraints.md
+    - name: Merge patches
+      href: ../docs/merge-patches.md
+    - name: JSON
+      href: ../docs/json.md
+    - name: EF Core
+      href: ../docs/ef-core.md
+    - name: ASP.NET Core
+      href: ../docs/aspnet-core.md
+    - name: Native AOT
+      href: ../docs/native-aot.md
+    - name: Logging and secrets
+      href: ../docs/logging-and-secrets.md
+    - name: Testing
+      href: ../docs/testing.md
+    - name: Migrating from 2.0 to 2.1
+      href: ../docs/migrating-to-2-1.md
+    - name: Migrating from 1.5 to 2.0
+      href: ../docs/migrating-to-2.md
+    - name: How it compares
+      href: ../docs/comparison.md
+- name: Reference
+  items:
+    - name: CodoMetis.TypeKit
+      href: ../src/CodoMetis.TypeKit/README.md
+    - name: CodoMetis.TypeKit.Analyzers
+      href: ../src/CodoMetis.TypeKit.Analyzers/README.md
+    - name: CodoMetis.TypeKit.Generators
+      href: ../src/CodoMetis.TypeKit.Generators/README.md
+    - name: CodoMetis.TypeKit.EntityFrameworkCore
+      href: ../src/CodoMetis.TypeKit.EntityFrameworkCore/README.md
+    - name: CodoMetis.TypeKit.AspNetCore
+      href: ../src/CodoMetis.TypeKit.AspNetCore/README.md
+    - name: CodoMetis.TypeKit.Serilog
+      href: ../src/CodoMetis.TypeKit.Serilog/README.md
+    - name: CodoMetis.TypeKit.Testing
+      href: ../src/CodoMetis.TypeKit.Testing/README.md
+- name: API
+  href: obj/api/
+- name: Changelog
+  href: ../CHANGELOG.md
diff --git a/spikes/AspectTestingSpike/AspectTests/AspectTests.csproj b/spikes/AspectTestingSpike/AspectTests/AspectTests.csproj
new file mode 100644
index 00000000..c5438dd2
--- /dev/null
+++ b/spikes/AspectTestingSpike/AspectTests/AspectTests.csproj
@@ -0,0 +1,41 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <!--
+      A Metalama snapshot-test project: every .cs file is a test input, its .t.cs the expected woven
+      output. Metalama.Testing.AspectTesting sets MetalamaEnabled=false here and runs the pipeline
+      itself, per file, inside an xunit v2 test framework of its own. Versions are pinned inline:
+      spikes/Directory.Packages.props switches central management off.
+    -->
+    <PropertyGroup>
+        <OutputType>Library</OutputType>
+        <IsPackable>false</IsPackable>
+        <IsTestProject>true</IsTestProject>
+    </PropertyGroup>
+
+    <!--
+      The package switches Metalama off for this project, so its own compilation sees the inputs
+      unwoven: a closed set then fails with CS0535 (All, Name, QualifiedName, TryParse missing). The
+      inputs are test data, compiled only by the test framework, with the pipeline on.
+    -->
+    <ItemGroup>
+        <Compile Remove="**/*.cs" />
+        <None Include="**/*.cs" Exclude="bin/**;obj/**" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+        <PackageReference Include="xunit" Version="2.9.3" />
+        <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+        <PackageReference Include="Metalama.Framework" Version="2026.1.30" />
+        <PackageReference Include="Metalama.Testing.AspectTesting" Version="2026.1.30" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <!-- The real generators: the internal aspects and the TransitiveProjectFabric that applies them. -->
+        <ProjectReference Include="../../../src/CodoMetis.TypeKit.Generators/CodoMetis.TypeKit.Generators.csproj" />
+    </ItemGroup>
+
+</Project>
diff --git a/spikes/AspectTestingSpike/AspectTests/Email.EmailExtensions.i.cs b/spikes/AspectTestingSpike/AspectTests/Email.EmailExtensions.i.cs
new file mode 100644
index 00000000..f0aab30f
--- /dev/null
+++ b/spikes/AspectTestingSpike/AspectTests/Email.EmailExtensions.i.cs
@@ -0,0 +1,19 @@
+namespace AspectTestingSpike
+{
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static partial class EmailExtensions
+  {
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    [global::CodoMetis.TypeKit.CompilerServices.TranslatedAsWrappedValueAttribute]
+    public static global::System.String GetValue(this global::AspectTestingSpike.Email instance)
+    {
+      return (global::System.String)instance.Value;
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    [global::CodoMetis.TypeKit.CompilerServices.TranslatedAsWrappedValueAttribute]
+    public static global::System.String? ValueOrNull(this global::AspectTestingSpike.Email? instance)
+    {
+      return (global::System.String? )instance?.Value;
+    }
+  }
+}
\ No newline at end of file
diff --git a/spikes/AspectTestingSpike/AspectTests/Email.cs b/spikes/AspectTestingSpike/AspectTests/Email.cs
new file mode 100644
index 00000000..f11aa9c3
--- /dev/null
+++ b/spikes/AspectTestingSpike/AspectTests/Email.cs
@@ -0,0 +1,17 @@
+using CodoMetis.TypeKit;
+using CodoMetis.TypeKit.ValueObjects;
+
+namespace AspectTestingSpike;
+
+public enum EmailFault { Blank, NoAt }
+
+public readonly partial record struct Email : IValidatedValue<Email, string, EmailFault>
+{
+    public static Result<Email, EmailFault> Create(string value)
+    {
+        if (string.IsNullOrWhiteSpace(value)) return Result.Error(EmailFault.Blank);
+        if (!value.Contains('@')) return Result.Error(EmailFault.NoAt);
+
+        return new Email(value.Trim());
+    }
+}
diff --git a/spikes/AspectTestingSpike/AspectTests/Email.t.cs b/spikes/AspectTestingSpike/AspectTests/Email.t.cs
new file mode 100644
index 00000000..572c00ab
--- /dev/null
+++ b/spikes/AspectTestingSpike/AspectTests/Email.t.cs
@@ -0,0 +1,350 @@
+using CodoMetis.TypeKit;
+using CodoMetis.TypeKit.ValueObjects;
+namespace AspectTestingSpike;
+public enum EmailFault
+{
+  Blank,
+  NoAt
+}
+[global::CodoMetis.TypeKit.CompilerServices.GeneratedValueObjectAttribute<global::AspectTestingSpike.Email, global::System.String>]
+[global::System.Text.Json.Serialization.JsonConverterAttribute(typeof(global::AspectTestingSpike.Email.EmailJsonConverter))]
+[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+[global::System.ComponentModel.TypeConverterAttribute(typeof(global::AspectTestingSpike.Email.EmailTypeConverter))]
+public readonly partial record struct Email : IValidatedValue<Email, string, EmailFault>, global::CodoMetis.TypeKit.ValueObjects.IValueObjectMaterializer<global::AspectTestingSpike.Email, global::System.String>, global::CodoMetis.TypeKit.ValueObjects.IValueObject<global::AspectTestingSpike.Email, global::System.String>, global::System.Numerics.IEqualityOperators<global::AspectTestingSpike.Email, global::AspectTestingSpike.Email, global::System.Boolean>, global::System.IParsable<global::AspectTestingSpike.Email>, global::System.ISpanParsable<global::AspectTestingSpike.Email>, global::System.IFormattable, global::System.IComparable<global::AspectTestingSpike.Email>, global::System.IComparable, global::System.Numerics.IComparisonOperators<global::AspectTestingSpike.Email, global::AspectTestingSpike.Email, global::System.Boolean>, global::System.IConvertible
+{
+  public static Result<Email, EmailFault> Create(string value)
+  {
+    if (string.IsNullOrWhiteSpace(value))
+      return Result.Error(EmailFault.Blank);
+    if (!value.Contains('@'))
+      return Result.Error(EmailFault.NoAt);
+    return new Email(value.Trim());
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  private readonly global::System.String _value;
+  [global::System.Diagnostics.DebuggerHiddenAttribute]
+  [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Never)]
+  [global::System.Diagnostics.DebuggerStepThroughAttribute]
+  public Email()
+  {
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  [global::System.Diagnostics.DebuggerStepThroughAttribute]
+  private Email(global::System.String value)
+  {
+    this._value = value;
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public global::System.String Value
+  {
+    get
+    {
+      return (global::System.String)this._value;
+    }
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public global::System.Int32 CompareTo(global::AspectTestingSpike.Email other)
+  {
+    return (global::System.Int32)(int)global::System.String.CompareOrdinal(this.Value, other.Value);
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public global::System.Int32 CompareTo(global::System.Object? obj)
+  {
+    if (obj is null)
+      return (global::System.Int32)1;
+    if (!(bool)obj is global::AspectTestingSpike.Email __comparand)
+      throw new global::System.ArgumentException("Object must be of type Email.", nameof(obj));
+    return (global::System.Int32)this.CompareTo(__comparand);
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::AspectTestingSpike.Email FromKnownGood(global::System.String value, [global::System.Runtime.CompilerServices.CallerArgumentExpressionAttribute("value")] global::System.String? source = null)
+  {
+    return (global::AspectTestingSpike.Email)global::CodoMetis.TypeKit.CompilerServices.GeneratedFactories.OrInvalidOperationException(global::AspectTestingSpike.Email.Create(value), source);
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  global::System.TypeCode global::System.IConvertible.GetTypeCode()
+  {
+    return (global::System.TypeCode)global::System.Convert.GetTypeCode((object? )this.Value);
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  static global::AspectTestingSpike.Email global::CodoMetis.TypeKit.ValueObjects.IValueObjectMaterializer<global::AspectTestingSpike.Email, global::System.String>.Materialize(global::System.String value)
+  {
+    return new global::AspectTestingSpike.Email(value);
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::AspectTestingSpike.Email Parse(global::System.String s, global::System.IFormatProvider? provider)
+  {
+    global::System.ArgumentNullException.ThrowIfNull(s);
+    return __FromText(s);
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::AspectTestingSpike.Email Parse(global::System.ReadOnlySpan<global::System.Char> s, global::System.IFormatProvider? provider)
+  {
+    return __FromText((global::CodoMetis.TypeKit.CompilerServices.GeneratedParsing.TryParseSpan<global::System.String>(s, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture), out var __parsed) ? __parsed : throw global::CodoMetis.TypeKit.CompilerServices.GeneratedParsing.Unreadable<global::AspectTestingSpike.Email, global::System.String>()));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public global::CodoMetis.TypeKit.Result<global::AspectTestingSpike.Email, global::AspectTestingSpike.EmailFault> Revalidate()
+  {
+    return (global::CodoMetis.TypeKit.Result<global::AspectTestingSpike.Email, global::AspectTestingSpike.EmailFault>)global::AspectTestingSpike.Email.Create(this.Value);
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  global::System.Boolean global::System.IConvertible.ToBoolean(global::System.IFormatProvider? provider)
+  {
+    return global::System.Convert.ToBoolean((object? )this.Value, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  global::System.Byte global::System.IConvertible.ToByte(global::System.IFormatProvider? provider)
+  {
+    return global::System.Convert.ToByte((object? )this.Value, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  global::System.Char global::System.IConvertible.ToChar(global::System.IFormatProvider? provider)
+  {
+    return global::System.Convert.ToChar((object? )this.Value, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  global::System.DateTime global::System.IConvertible.ToDateTime(global::System.IFormatProvider? provider)
+  {
+    return global::System.Convert.ToDateTime((object? )this.Value, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  global::System.Decimal global::System.IConvertible.ToDecimal(global::System.IFormatProvider? provider)
+  {
+    return global::System.Convert.ToDecimal((object? )this.Value, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  global::System.Double global::System.IConvertible.ToDouble(global::System.IFormatProvider? provider)
+  {
+    return global::System.Convert.ToDouble((object? )this.Value, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  global::System.Int16 global::System.IConvertible.ToInt16(global::System.IFormatProvider? provider)
+  {
+    return global::System.Convert.ToInt16((object? )this.Value, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  global::System.Int32 global::System.IConvertible.ToInt32(global::System.IFormatProvider? provider)
+  {
+    return global::System.Convert.ToInt32((object? )this.Value, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  global::System.Int64 global::System.IConvertible.ToInt64(global::System.IFormatProvider? provider)
+  {
+    return global::System.Convert.ToInt64((object? )this.Value, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  global::System.SByte global::System.IConvertible.ToSByte(global::System.IFormatProvider? provider)
+  {
+    return global::System.Convert.ToSByte((object? )this.Value, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  global::System.Single global::System.IConvertible.ToSingle(global::System.IFormatProvider? provider)
+  {
+    return global::System.Convert.ToSingle((object? )this.Value, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  global::System.String global::System.IConvertible.ToString(global::System.IFormatProvider? provider)
+  {
+    return (global::System.String)(string)global::System.Convert.ToString((object? )this.Value, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public global::System.String ToString(global::System.String? format, global::System.IFormatProvider? formatProvider)
+  {
+    return (global::System.String)(string)(this.Value ?? string.Empty);
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  global::System.Object global::System.IConvertible.ToType(global::System.Type conversionType, global::System.IFormatProvider? provider)
+  {
+    if ((bool)(conversionType == typeof(global::AspectTestingSpike.Email) || conversionType == typeof(object)))
+      return this;
+    if (conversionType == typeof(global::System.String))
+      return global::System.Convert.ToString((object? )this.Value, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture));
+    return global::System.Convert.ChangeType((object? )this.Value, conversionType, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture))!;
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  global::System.UInt16 global::System.IConvertible.ToUInt16(global::System.IFormatProvider? provider)
+  {
+    return global::System.Convert.ToUInt16((object? )this.Value, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  global::System.UInt32 global::System.IConvertible.ToUInt32(global::System.IFormatProvider? provider)
+  {
+    return global::System.Convert.ToUInt32((object? )this.Value, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  global::System.UInt64 global::System.IConvertible.ToUInt64(global::System.IFormatProvider? provider)
+  {
+    return global::System.Convert.ToUInt64((object? )this.Value, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::CodoMetis.TypeKit.Option<global::AspectTestingSpike.Email> TryFrom(global::System.String value)
+  {
+    return (global::CodoMetis.TypeKit.Option<global::AspectTestingSpike.Email>)global::CodoMetis.TypeKit.Result.ToOption(global::AspectTestingSpike.Email.Create(value));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::System.Boolean TryParse([global::System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] global::System.String? s, global::System.IFormatProvider? provider, [global::System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out global::AspectTestingSpike.Email result)
+  {
+    result = default(global::AspectTestingSpike.Email);
+    return (global::System.Boolean)(bool)(s is not null && __TryFromText(s, out result));
+    global::System.String __inner;
+    try
+    {
+      __inner = s;
+    }
+    catch (global::System.FormatException)
+    {
+      return false;
+    }
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::System.Boolean TryParse(global::System.ReadOnlySpan<global::System.Char> s, global::System.IFormatProvider? provider, [global::System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out global::AspectTestingSpike.Email result)
+  {
+    result = default(global::AspectTestingSpike.Email);
+    return (global::System.Boolean)(bool)(global::CodoMetis.TypeKit.CompilerServices.GeneratedParsing.TryParseSpan<global::System.String>(s, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture), out var innerValue) && __TryFromText(innerValue, out result));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Never)]
+  [global::System.Diagnostics.DebuggerStepThroughAttribute]
+  private static global::AspectTestingSpike.Email __FromJson(global::System.String value, global::System.Boolean materialize)
+  {
+    if (materialize)
+      return new global::AspectTestingSpike.Email(value);
+    return (global::AspectTestingSpike.Email)global::CodoMetis.TypeKit.CompilerServices.GeneratedFactories.OrJsonException(global::AspectTestingSpike.Email.Create(value));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Never)]
+  [global::System.Diagnostics.DebuggerStepThroughAttribute]
+  private static global::AspectTestingSpike.Email __FromText(global::System.String value)
+  {
+    return (global::AspectTestingSpike.Email)global::CodoMetis.TypeKit.CompilerServices.GeneratedFactories.OrFormatException(global::AspectTestingSpike.Email.Create(value));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Never)]
+  [global::System.Diagnostics.DebuggerStepThroughAttribute]
+  private static global::System.Boolean __TryFromText(global::System.String value, out global::AspectTestingSpike.Email result)
+  {
+    result = default(global::AspectTestingSpike.Email);
+    return (global::System.Boolean)(bool)global::AspectTestingSpike.Email.Create(value).TryGetValue(out result, out _);
+  }
+  [global::System.Runtime.CompilerServices.MethodImplAttribute(global::System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::System.Boolean operator>(global::AspectTestingSpike.Email left, global::AspectTestingSpike.Email right)
+  {
+    return (global::System.Boolean)(bool)left.CompareTo(right) > 0;
+  }
+  [global::System.Runtime.CompilerServices.MethodImplAttribute(global::System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::System.Boolean operator >=(global::AspectTestingSpike.Email left, global::AspectTestingSpike.Email right)
+  {
+    return (global::System.Boolean)(bool)left.CompareTo(right) >= 0;
+  }
+  [global::System.Runtime.CompilerServices.MethodImplAttribute(global::System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::System.Boolean operator <(global::AspectTestingSpike.Email left, global::AspectTestingSpike.Email right)
+  {
+    return (global::System.Boolean)(bool)left.CompareTo(right) < 0;
+  }
+  [global::System.Runtime.CompilerServices.MethodImplAttribute(global::System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::System.Boolean operator <=(global::AspectTestingSpike.Email left, global::AspectTestingSpike.Email right)
+  {
+    return (global::System.Boolean)(bool)left.CompareTo(right) <= 0;
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public partial class EmailJsonConverter : global::System.Text.Json.Serialization.JsonConverter<global::AspectTestingSpike.Email>, global::CodoMetis.TypeKit.CompilerServices.IStoredJsonConverterSource
+  {
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    private global::CodoMetis.TypeKit.CompilerServices.GeneratedJsonPlan<global::System.String>? __jsonPlan;
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    private readonly global::System.Boolean _materialize;
+    public EmailJsonConverter()
+    {
+    }
+    private EmailJsonConverter(global::System.Boolean materialize)
+    {
+      this._materialize = materialize;
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    global::System.Text.Json.Serialization.JsonConverter global::CodoMetis.TypeKit.CompilerServices.IStoredJsonConverterSource.CreateStoredJsonConverter(global::CodoMetis.TypeKit.ValueObjects.StoredJsonConverterFactory factory)
+    {
+      global::System.ArgumentNullException.ThrowIfNull(factory);
+      return new global::AspectTestingSpike.Email.EmailJsonConverter(true);
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override global::AspectTestingSpike.Email Read(ref global::System.Text.Json.Utf8JsonReader reader, global::System.Type typeToConvert, global::System.Text.Json.JsonSerializerOptions options)
+    {
+      if (reader.TokenType == global::System.Text.Json.JsonTokenType.Null)
+        throw (global::System.Exception)global::CodoMetis.TypeKit.CompilerServices.GeneratedJson.NullToken<global::AspectTestingSpike.Email>();
+      return global::AspectTestingSpike.Email.__FromJson((this.__jsonPlan is { } __plan && global::System.Object.ReferenceEquals(__plan.Options, options) ? __plan : this.__jsonPlan = global::CodoMetis.TypeKit.CompilerServices.GeneratedJsonPlan<global::System.String>.For(options, global::System.Text.Json.Serialization.Metadata.JsonMetadataServices.StringConverter)).Read<global::AspectTestingSpike.Email>(ref reader, options), (global::System.Boolean)this._materialize);
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override global::AspectTestingSpike.Email ReadAsPropertyName(ref global::System.Text.Json.Utf8JsonReader reader, global::System.Type typeToConvert, global::System.Text.Json.JsonSerializerOptions options)
+    {
+      return global::AspectTestingSpike.Email.__FromJson((this.__jsonPlan is { } __plan && global::System.Object.ReferenceEquals(__plan.Options, options) ? __plan : this.__jsonPlan = global::CodoMetis.TypeKit.CompilerServices.GeneratedJsonPlan<global::System.String>.For(options, global::System.Text.Json.Serialization.Metadata.JsonMetadataServices.StringConverter)).ReadKey<global::AspectTestingSpike.Email>(ref reader, options), (global::System.Boolean)this._materialize);
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override void Write(global::System.Text.Json.Utf8JsonWriter writer, global::AspectTestingSpike.Email value, global::System.Text.Json.JsonSerializerOptions options)
+    {
+      (this.__jsonPlan is { } __plan && global::System.Object.ReferenceEquals(__plan.Options, options) ? __plan : this.__jsonPlan = global::CodoMetis.TypeKit.CompilerServices.GeneratedJsonPlan<global::System.String>.For(options, global::System.Text.Json.Serialization.Metadata.JsonMetadataServices.StringConverter)).Write(writer, value!.Value, options);
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override void WriteAsPropertyName(global::System.Text.Json.Utf8JsonWriter writer, global::AspectTestingSpike.Email value, global::System.Text.Json.JsonSerializerOptions options)
+    {
+      (this.__jsonPlan is { } __plan && global::System.Object.ReferenceEquals(__plan.Options, options) ? __plan : this.__jsonPlan = global::CodoMetis.TypeKit.CompilerServices.GeneratedJsonPlan<global::System.String>.For(options, global::System.Text.Json.Serialization.Metadata.JsonMetadataServices.StringConverter)).WriteKey(writer, value!.Value, options);
+    }
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public partial class EmailTypeConverter : global::System.ComponentModel.TypeConverter
+  {
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override global::System.Boolean CanConvertFrom(global::System.ComponentModel.ITypeDescriptorContext? context, global::System.Type sourceType)
+    {
+      return (global::System.Boolean)(sourceType == typeof(global::System.String) || base.CanConvertFrom(context, sourceType));
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override global::System.Boolean CanConvertTo(global::System.ComponentModel.ITypeDescriptorContext? context, global::System.Type? destinationType)
+    {
+      return (global::System.Boolean)(destinationType == typeof(global::System.String) || base.CanConvertTo(context, destinationType));
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override global::System.Object? ConvertFrom(global::System.ComponentModel.ITypeDescriptorContext? context, global::System.Globalization.CultureInfo? culture, global::System.Object value)
+    {
+      if (value is string s)
+      {
+        global::System.IFormatProvider provider;
+        if (culture == null)
+        {
+          provider = global::System.Globalization.CultureInfo.InvariantCulture;
+        }
+        else
+        {
+          provider = culture;
+        }
+        return global::AspectTestingSpike.Email.Parse(s, provider);
+      }
+      return (global::System.Object? )base.ConvertFrom(context, culture, value);
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override global::System.Object? ConvertTo(global::System.ComponentModel.ITypeDescriptorContext? context, global::System.Globalization.CultureInfo? culture, global::System.Object? value, global::System.Type destinationType)
+    {
+      if (destinationType == typeof(global::System.String) && value is not null)
+      {
+        global::System.IFormatProvider provider;
+        if (culture == null)
+        {
+          provider = global::System.Globalization.CultureInfo.InvariantCulture;
+        }
+        else
+        {
+          provider = culture;
+        }
+        return (((global::AspectTestingSpike.Email)value).Value ?? string.Empty);
+      }
+      return (global::System.Object? )base.ConvertTo(context, culture, value, destinationType);
+    }
+  }
+  public override readonly global::System.String ToString()
+  {
+    return (global::System.String)this.ToString(null, global::System.Globalization.CultureInfo.InvariantCulture);
+  }
+}
\ No newline at end of file
diff --git a/spikes/AspectTestingSpike/AspectTests/NotReadonly.cs b/spikes/AspectTestingSpike/AspectTests/NotReadonly.cs
new file mode 100644
index 00000000..9ced8315
--- /dev/null
+++ b/spikes/AspectTestingSpike/AspectTests/NotReadonly.cs
@@ -0,0 +1,6 @@
+using CodoMetis.TypeKit.ValueObjects;
+
+namespace AspectTestingSpike;
+
+// A refusal: not readonly, so CMTK1002 and nothing generated.
+public partial record struct Draft : IValue<int>;
diff --git a/spikes/AspectTestingSpike/AspectTests/NotReadonly.t.cs b/spikes/AspectTestingSpike/AspectTests/NotReadonly.t.cs
new file mode 100644
index 00000000..4ad4c4dd
--- /dev/null
+++ b/spikes/AspectTestingSpike/AspectTests/NotReadonly.t.cs
@@ -0,0 +1 @@
+// Error CMTK1002 on `Draft`: `'Draft' is a value object and must be declared readonly. See https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.Generators/README.md#build-errors`
\ No newline at end of file
diff --git a/spikes/AspectTestingSpike/AspectTests/OrderId.OrderIdExtensions.i.cs b/spikes/AspectTestingSpike/AspectTests/OrderId.OrderIdExtensions.i.cs
new file mode 100644
index 00000000..3244ebfc
--- /dev/null
+++ b/spikes/AspectTestingSpike/AspectTests/OrderId.OrderIdExtensions.i.cs
@@ -0,0 +1,19 @@
+namespace AspectTestingSpike
+{
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static partial class OrderIdExtensions
+  {
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    [global::CodoMetis.TypeKit.CompilerServices.TranslatedAsWrappedValueAttribute]
+    public static global::System.Guid GetValue(this global::AspectTestingSpike.OrderId instance)
+    {
+      return (global::System.Guid)instance.Value;
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    [global::CodoMetis.TypeKit.CompilerServices.TranslatedAsWrappedValueAttribute]
+    public static global::System.Guid? ValueOrNull(this global::AspectTestingSpike.OrderId? instance)
+    {
+      return (global::System.Guid? )instance?.Value;
+    }
+  }
+}
\ No newline at end of file
diff --git a/spikes/AspectTestingSpike/AspectTests/OrderId.cs b/spikes/AspectTestingSpike/AspectTests/OrderId.cs
new file mode 100644
index 00000000..8e29d8ac
--- /dev/null
+++ b/spikes/AspectTestingSpike/AspectTests/OrderId.cs
@@ -0,0 +1,5 @@
+using CodoMetis.TypeKit.ValueObjects;
+
+namespace AspectTestingSpike;
+
+public readonly partial record struct OrderId : IValue<Guid>;
diff --git a/spikes/AspectTestingSpike/AspectTests/OrderId.t.cs b/spikes/AspectTestingSpike/AspectTests/OrderId.t.cs
new file mode 100644
index 00000000..899b62bb
--- /dev/null
+++ b/spikes/AspectTestingSpike/AspectTests/OrderId.t.cs
@@ -0,0 +1,259 @@
+using CodoMetis.TypeKit.ValueObjects;
+namespace AspectTestingSpike;
+[global::CodoMetis.TypeKit.CompilerServices.GeneratedValueObjectAttribute<global::AspectTestingSpike.OrderId, global::System.Guid>]
+[global::System.Text.Json.Serialization.JsonConverterAttribute(typeof(global::AspectTestingSpike.OrderId.OrderIdJsonConverter))]
+[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+[global::System.ComponentModel.TypeConverterAttribute(typeof(global::AspectTestingSpike.OrderId.OrderIdTypeConverter))]
+public readonly partial record struct OrderId : IValue<Guid>, global::CodoMetis.TypeKit.ValueObjects.IValueObjectMaterializer<global::AspectTestingSpike.OrderId, global::System.Guid>, global::CodoMetis.TypeKit.ValueObjects.IValueObject<global::AspectTestingSpike.OrderId, global::System.Guid>, global::CodoMetis.TypeKit.ValueObjects.IPlainValueObject<global::AspectTestingSpike.OrderId, global::System.Guid>, global::System.Numerics.IEqualityOperators<global::AspectTestingSpike.OrderId, global::AspectTestingSpike.OrderId, global::System.Boolean>, global::System.IParsable<global::AspectTestingSpike.OrderId>, global::System.ISpanParsable<global::AspectTestingSpike.OrderId>, global::System.IUtf8SpanParsable<global::AspectTestingSpike.OrderId>, global::System.IFormattable, global::System.ISpanFormattable, global::System.IUtf8SpanFormattable, global::System.IComparable<global::AspectTestingSpike.OrderId>, global::System.IComparable, global::System.Numerics.IComparisonOperators<global::AspectTestingSpike.OrderId, global::AspectTestingSpike.OrderId, global::System.Boolean>
+{
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  private readonly global::System.Guid _value;
+  [global::System.Diagnostics.DebuggerHiddenAttribute]
+  [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Never)]
+  [global::System.Diagnostics.DebuggerStepThroughAttribute]
+  public OrderId()
+  {
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  [global::System.Diagnostics.DebuggerStepThroughAttribute]
+  private OrderId(global::System.Guid value)
+  {
+    this._value = value;
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public global::System.Guid Value
+  {
+    get
+    {
+      return (global::System.Guid)this._value;
+    }
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public global::System.Int32 CompareTo(global::AspectTestingSpike.OrderId other)
+  {
+    return (global::System.Int32)(int)global::System.Collections.Generic.Comparer<global::System.Guid>.Default.Compare(this.Value, other.Value);
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public global::System.Int32 CompareTo(global::System.Object? obj)
+  {
+    if (obj is null)
+      return (global::System.Int32)1;
+    if (!(bool)obj is global::AspectTestingSpike.OrderId __comparand)
+      throw new global::System.ArgumentException("Object must be of type OrderId.", nameof(obj));
+    return (global::System.Int32)this.CompareTo(__comparand);
+  }
+  [global::System.Runtime.CompilerServices.MethodImplAttribute(global::System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::AspectTestingSpike.OrderId From(global::System.Guid value)
+  {
+    return new global::AspectTestingSpike.OrderId(value);
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  static global::AspectTestingSpike.OrderId global::CodoMetis.TypeKit.ValueObjects.IValueObjectMaterializer<global::AspectTestingSpike.OrderId, global::System.Guid>.Materialize(global::System.Guid value)
+  {
+    return new global::AspectTestingSpike.OrderId(value);
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::AspectTestingSpike.OrderId Parse(global::System.String s, global::System.IFormatProvider? provider)
+  {
+    global::System.ArgumentNullException.ThrowIfNull(s);
+    return __FromText((global::CodoMetis.TypeKit.CompilerServices.GeneratedParsing.TryParseSpan<global::System.Guid>(s, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture), out var __parsed) ? __parsed : throw global::CodoMetis.TypeKit.CompilerServices.GeneratedParsing.Unreadable<global::AspectTestingSpike.OrderId, global::System.Guid>()));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::AspectTestingSpike.OrderId Parse(global::System.ReadOnlySpan<global::System.Char> s, global::System.IFormatProvider? provider)
+  {
+    return __FromText((global::CodoMetis.TypeKit.CompilerServices.GeneratedParsing.TryParseSpan<global::System.Guid>(s, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture), out var __parsed) ? __parsed : throw global::CodoMetis.TypeKit.CompilerServices.GeneratedParsing.Unreadable<global::AspectTestingSpike.OrderId, global::System.Guid>()));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::AspectTestingSpike.OrderId Parse(global::System.ReadOnlySpan<global::System.Byte> utf8Text, global::System.IFormatProvider? provider)
+  {
+    return __FromText(global::CodoMetis.TypeKit.CompilerServices.GeneratedParsing.TryParseUtf8<global::System.Guid>(utf8Text, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture), out var __parsed) ? __parsed : throw global::CodoMetis.TypeKit.CompilerServices.GeneratedParsing.Unreadable<global::AspectTestingSpike.OrderId, global::System.Guid>());
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public global::System.String ToString(global::System.String? format, global::System.IFormatProvider? formatProvider)
+  {
+    return (global::System.String)(string)global::CodoMetis.TypeKit.CompilerServices.GeneratedFormatting.ToString(this.Value, format, formatProvider ?? global::System.Globalization.CultureInfo.InvariantCulture);
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public global::System.Boolean TryFormat(global::System.Span<global::System.Char> destination, out global::System.Int32 charsWritten, global::System.ReadOnlySpan<global::System.Char> format, global::System.IFormatProvider? provider)
+  {
+    charsWritten = 0;
+    return (global::System.Boolean)(bool)global::CodoMetis.TypeKit.CompilerServices.GeneratedFormatting.TryFormat(this.Value, destination, out charsWritten, format, provider ?? global::System.Globalization.CultureInfo.InvariantCulture);
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public global::System.Boolean TryFormat(global::System.Span<global::System.Byte> utf8Destination, out global::System.Int32 bytesWritten, global::System.ReadOnlySpan<global::System.Char> format, global::System.IFormatProvider? provider)
+  {
+    bytesWritten = 0;
+    return (global::System.Boolean)(bool)global::CodoMetis.TypeKit.CompilerServices.GeneratedFormatting.TryFormatUtf8(this.Value, utf8Destination, out bytesWritten, format, provider ?? global::System.Globalization.CultureInfo.InvariantCulture);
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::System.Boolean TryParse([global::System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] global::System.String? s, global::System.IFormatProvider? provider, [global::System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out global::AspectTestingSpike.OrderId result)
+  {
+    result = default(global::AspectTestingSpike.OrderId);
+    return (global::System.Boolean)(bool)(global::CodoMetis.TypeKit.CompilerServices.GeneratedParsing.TryParseSpan<global::System.Guid>(s, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture), out var innerValue) && __TryFromText(innerValue, out result));
+    global::System.Guid __inner;
+    try
+    {
+      __inner = (global::CodoMetis.TypeKit.CompilerServices.GeneratedParsing.TryParseSpan<global::System.Guid>(s, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture), out var __parsed) ? __parsed : throw global::CodoMetis.TypeKit.CompilerServices.GeneratedParsing.Unreadable<global::AspectTestingSpike.OrderId, global::System.Guid>());
+    }
+    catch (global::System.FormatException)
+    {
+      return false;
+    }
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::System.Boolean TryParse(global::System.ReadOnlySpan<global::System.Char> s, global::System.IFormatProvider? provider, [global::System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out global::AspectTestingSpike.OrderId result)
+  {
+    result = default(global::AspectTestingSpike.OrderId);
+    return (global::System.Boolean)(bool)(global::CodoMetis.TypeKit.CompilerServices.GeneratedParsing.TryParseSpan<global::System.Guid>(s, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture), out var innerValue) && __TryFromText(innerValue, out result));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::System.Boolean TryParse(global::System.ReadOnlySpan<global::System.Byte> utf8Text, global::System.IFormatProvider? provider, [global::System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out global::AspectTestingSpike.OrderId result)
+  {
+    result = default(global::AspectTestingSpike.OrderId);
+    return (global::System.Boolean)(bool)(global::CodoMetis.TypeKit.CompilerServices.GeneratedParsing.TryParseUtf8<global::System.Guid>(utf8Text, (provider ?? global::System.Globalization.CultureInfo.InvariantCulture), out var innerValue) && __TryFromText(innerValue, out result));
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Never)]
+  [global::System.Diagnostics.DebuggerStepThroughAttribute]
+  private static global::AspectTestingSpike.OrderId __FromJson(global::System.Guid value, global::System.Boolean materialize)
+  {
+    return new global::AspectTestingSpike.OrderId(value);
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Never)]
+  [global::System.Diagnostics.DebuggerStepThroughAttribute]
+  private static global::AspectTestingSpike.OrderId __FromText(global::System.Guid value)
+  {
+    return new global::AspectTestingSpike.OrderId(value);
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Never)]
+  [global::System.Diagnostics.DebuggerStepThroughAttribute]
+  private static global::System.Boolean __TryFromText(global::System.Guid value, out global::AspectTestingSpike.OrderId result)
+  {
+    result = new global::AspectTestingSpike.OrderId(value);
+    return (global::System.Boolean)true;
+  }
+  [global::System.Runtime.CompilerServices.MethodImplAttribute(global::System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::System.Boolean operator>(global::AspectTestingSpike.OrderId left, global::AspectTestingSpike.OrderId right)
+  {
+    return (global::System.Boolean)(bool)left.CompareTo(right) > 0;
+  }
+  [global::System.Runtime.CompilerServices.MethodImplAttribute(global::System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::System.Boolean operator >=(global::AspectTestingSpike.OrderId left, global::AspectTestingSpike.OrderId right)
+  {
+    return (global::System.Boolean)(bool)left.CompareTo(right) >= 0;
+  }
+  [global::System.Runtime.CompilerServices.MethodImplAttribute(global::System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::System.Boolean operator <(global::AspectTestingSpike.OrderId left, global::AspectTestingSpike.OrderId right)
+  {
+    return (global::System.Boolean)(bool)left.CompareTo(right) < 0;
+  }
+  [global::System.Runtime.CompilerServices.MethodImplAttribute(global::System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::System.Boolean operator <=(global::AspectTestingSpike.OrderId left, global::AspectTestingSpike.OrderId right)
+  {
+    return (global::System.Boolean)(bool)left.CompareTo(right) <= 0;
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public partial class OrderIdJsonConverter : global::System.Text.Json.Serialization.JsonConverter<global::AspectTestingSpike.OrderId>, global::CodoMetis.TypeKit.CompilerServices.IStoredJsonConverterSource
+  {
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    private global::CodoMetis.TypeKit.CompilerServices.GeneratedJsonPlan<global::System.Guid>? __jsonPlan;
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    private readonly global::System.Boolean _materialize;
+    public OrderIdJsonConverter()
+    {
+    }
+    private OrderIdJsonConverter(global::System.Boolean materialize)
+    {
+      this._materialize = materialize;
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    global::System.Text.Json.Serialization.JsonConverter global::CodoMetis.TypeKit.CompilerServices.IStoredJsonConverterSource.CreateStoredJsonConverter(global::CodoMetis.TypeKit.ValueObjects.StoredJsonConverterFactory factory)
+    {
+      global::System.ArgumentNullException.ThrowIfNull(factory);
+      return new global::AspectTestingSpike.OrderId.OrderIdJsonConverter(true);
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override global::AspectTestingSpike.OrderId Read(ref global::System.Text.Json.Utf8JsonReader reader, global::System.Type typeToConvert, global::System.Text.Json.JsonSerializerOptions options)
+    {
+      if (reader.TokenType == global::System.Text.Json.JsonTokenType.Null)
+        throw (global::System.Exception)global::CodoMetis.TypeKit.CompilerServices.GeneratedJson.NullToken<global::AspectTestingSpike.OrderId>();
+      return global::AspectTestingSpike.OrderId.__FromJson((this.__jsonPlan is { } __plan && global::System.Object.ReferenceEquals(__plan.Options, options) ? __plan : this.__jsonPlan = global::CodoMetis.TypeKit.CompilerServices.GeneratedJsonPlan<global::System.Guid>.For(options, global::System.Text.Json.Serialization.Metadata.JsonMetadataServices.GuidConverter)).Read<global::AspectTestingSpike.OrderId>(ref reader, options), (global::System.Boolean)this._materialize);
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override global::AspectTestingSpike.OrderId ReadAsPropertyName(ref global::System.Text.Json.Utf8JsonReader reader, global::System.Type typeToConvert, global::System.Text.Json.JsonSerializerOptions options)
+    {
+      return global::AspectTestingSpike.OrderId.__FromJson((this.__jsonPlan is { } __plan && global::System.Object.ReferenceEquals(__plan.Options, options) ? __plan : this.__jsonPlan = global::CodoMetis.TypeKit.CompilerServices.GeneratedJsonPlan<global::System.Guid>.For(options, global::System.Text.Json.Serialization.Metadata.JsonMetadataServices.GuidConverter)).ReadKey<global::AspectTestingSpike.OrderId>(ref reader, options), (global::System.Boolean)this._materialize);
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override void Write(global::System.Text.Json.Utf8JsonWriter writer, global::AspectTestingSpike.OrderId value, global::System.Text.Json.JsonSerializerOptions options)
+    {
+      (this.__jsonPlan is { } __plan && global::System.Object.ReferenceEquals(__plan.Options, options) ? __plan : this.__jsonPlan = global::CodoMetis.TypeKit.CompilerServices.GeneratedJsonPlan<global::System.Guid>.For(options, global::System.Text.Json.Serialization.Metadata.JsonMetadataServices.GuidConverter)).Write(writer, value!.Value, options);
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override void WriteAsPropertyName(global::System.Text.Json.Utf8JsonWriter writer, global::AspectTestingSpike.OrderId value, global::System.Text.Json.JsonSerializerOptions options)
+    {
+      (this.__jsonPlan is { } __plan && global::System.Object.ReferenceEquals(__plan.Options, options) ? __plan : this.__jsonPlan = global::CodoMetis.TypeKit.CompilerServices.GeneratedJsonPlan<global::System.Guid>.For(options, global::System.Text.Json.Serialization.Metadata.JsonMetadataServices.GuidConverter)).WriteKey(writer, value!.Value, options);
+    }
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public partial class OrderIdTypeConverter : global::System.ComponentModel.TypeConverter
+  {
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override global::System.Boolean CanConvertFrom(global::System.ComponentModel.ITypeDescriptorContext? context, global::System.Type sourceType)
+    {
+      return (global::System.Boolean)(sourceType == typeof(global::System.String) || base.CanConvertFrom(context, sourceType));
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override global::System.Boolean CanConvertTo(global::System.ComponentModel.ITypeDescriptorContext? context, global::System.Type? destinationType)
+    {
+      return (global::System.Boolean)(destinationType == typeof(global::System.String) || base.CanConvertTo(context, destinationType));
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override global::System.Object? ConvertFrom(global::System.ComponentModel.ITypeDescriptorContext? context, global::System.Globalization.CultureInfo? culture, global::System.Object value)
+    {
+      if (value is string s)
+      {
+        global::System.IFormatProvider provider;
+        if (culture == null)
+        {
+          provider = global::System.Globalization.CultureInfo.InvariantCulture;
+        }
+        else
+        {
+          provider = culture;
+        }
+        return global::AspectTestingSpike.OrderId.Parse(s, provider);
+      }
+      return (global::System.Object? )base.ConvertFrom(context, culture, value);
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override global::System.Object? ConvertTo(global::System.ComponentModel.ITypeDescriptorContext? context, global::System.Globalization.CultureInfo? culture, global::System.Object? value, global::System.Type destinationType)
+    {
+      if (destinationType == typeof(global::System.String) && value is not null)
+      {
+        global::System.IFormatProvider provider;
+        if (culture == null)
+        {
+          provider = global::System.Globalization.CultureInfo.InvariantCulture;
+        }
+        else
+        {
+          provider = culture;
+        }
+        return global::CodoMetis.TypeKit.CompilerServices.GeneratedFormatting.ToString(((global::AspectTestingSpike.OrderId)value).Value, null, provider);
+      }
+      return (global::System.Object? )base.ConvertTo(context, culture, value, destinationType);
+    }
+  }
+  public override readonly global::System.String ToString()
+  {
+    return (global::System.String)this.ToString(null, global::System.Globalization.CultureInfo.InvariantCulture);
+  }
+}
\ No newline at end of file
diff --git a/spikes/AspectTestingSpike/AspectTests/OrderStatus.cs b/spikes/AspectTestingSpike/AspectTests/OrderStatus.cs
new file mode 100644
index 00000000..368ca24a
--- /dev/null
+++ b/spikes/AspectTestingSpike/AspectTests/OrderStatus.cs
@@ -0,0 +1,10 @@
+using CodoMetis.TypeKit.ClosedSets;
+
+namespace AspectTestingSpike;
+
+public sealed partial class OrderStatus : IClosedSet<OrderStatus>
+{
+    public static readonly OrderStatus Open = new();
+    public static readonly OrderStatus Shipped = new();
+    public static readonly OrderStatus Cancelled = new();
+}
diff --git a/spikes/AspectTestingSpike/AspectTests/OrderStatus.t.cs b/spikes/AspectTestingSpike/AspectTests/OrderStatus.t.cs
new file mode 100644
index 00000000..e4d61029
--- /dev/null
+++ b/spikes/AspectTestingSpike/AspectTests/OrderStatus.t.cs
@@ -0,0 +1,236 @@
+using CodoMetis.TypeKit.ClosedSets;
+namespace AspectTestingSpike;
+[global::System.Text.Json.Serialization.JsonConverterAttribute(typeof(global::AspectTestingSpike.OrderStatus.OrderStatusJsonConverter))]
+[global::System.ComponentModel.TypeConverterAttribute(typeof(global::AspectTestingSpike.OrderStatus.OrderStatusTypeConverter))]
+[global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSetAttribute<global::AspectTestingSpike.OrderStatus>]
+[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+public sealed partial class OrderStatus : IClosedSet<OrderStatus>, global::System.IParsable<global::AspectTestingSpike.OrderStatus>
+{
+  public static readonly OrderStatus Open = new();
+  public static readonly OrderStatus Shipped = new();
+  public static readonly OrderStatus Cancelled = new();
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  private static readonly global::System.Collections.Generic.IReadOnlyList<global::AspectTestingSpike.OrderStatus> _all = null !;
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  private global::System.String _name = null !;
+  static OrderStatus()
+  {
+    global::AspectTestingSpike.OrderStatus.Open._name = "Open";
+    global::AspectTestingSpike.OrderStatus.Shipped._name = "Shipped";
+    global::AspectTestingSpike.OrderStatus.Cancelled._name = "Cancelled";
+    global::AspectTestingSpike.OrderStatus._all = global::System.Array.AsReadOnly(new global::AspectTestingSpike.OrderStatus[] { global::AspectTestingSpike.OrderStatus.Open, global::AspectTestingSpike.OrderStatus.Shipped, global::AspectTestingSpike.OrderStatus.Cancelled });
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  private OrderStatus()
+  {
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::System.Collections.Generic.IReadOnlyList<global::AspectTestingSpike.OrderStatus> All
+  {
+    get
+    {
+      return (global::System.Collections.Generic.IReadOnlyList<global::AspectTestingSpike.OrderStatus>)(global::AspectTestingSpike.OrderStatus._all ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus"));
+    }
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public global::System.String Name
+  {
+    get
+    {
+      return (global::System.String)(this._name ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.NotAMember("OrderStatus"));
+    }
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public global::System.String QualifiedName
+  {
+    get
+    {
+      return (global::System.String)("OrderStatus." + this.Name);
+    }
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public TResult Match<TResult>(global::System.Func<TResult> open, global::System.Func<TResult> shipped, global::System.Func<TResult> cancelled)
+  {
+    global::System.ArgumentNullException.ThrowIfNull(open, "open");
+    global::System.ArgumentNullException.ThrowIfNull(shipped, "shipped");
+    global::System.ArgumentNullException.ThrowIfNull(cancelled, "cancelled");
+    if (global::System.Object.ReferenceEquals(this, global::AspectTestingSpike.OrderStatus.Open))
+      return (TResult)open.Invoke();
+    if (global::System.Object.ReferenceEquals(this, global::AspectTestingSpike.OrderStatus.Shipped))
+      return (TResult)shipped.Invoke();
+    if (global::System.Object.ReferenceEquals(this, global::AspectTestingSpike.OrderStatus.Cancelled))
+      return (TResult)cancelled.Invoke();
+    throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.NotAMember("OrderStatus");
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  static global::AspectTestingSpike.OrderStatus global::System.IParsable<global::AspectTestingSpike.OrderStatus>.Parse(global::System.String s, global::System.IFormatProvider? provider)
+  {
+    global::System.ArgumentNullException.ThrowIfNull(s);
+    return (global::AspectTestingSpike.OrderStatus)global::AspectTestingSpike.OrderStatus.Parse(s);
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::AspectTestingSpike.OrderStatus Parse(global::System.String? name)
+  {
+    if (name == "Open")
+      return (global::AspectTestingSpike.OrderStatus)(global::AspectTestingSpike.OrderStatus.Open ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus"));
+    if (name == "Shipped")
+      return (global::AspectTestingSpike.OrderStatus)(global::AspectTestingSpike.OrderStatus.Shipped ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus"));
+    if (name == "Cancelled")
+      return (global::AspectTestingSpike.OrderStatus)(global::AspectTestingSpike.OrderStatus.Cancelled ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus"));
+    throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.NoMember("OrderStatus");
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::AspectTestingSpike.OrderStatus Parse(global::System.String? name, global::System.Boolean ignoreCase)
+  {
+    var comparison = ignoreCase ? global::System.StringComparison.OrdinalIgnoreCase : global::System.StringComparison.Ordinal;
+    if (string.Equals(name, "Open", comparison))
+      return (global::AspectTestingSpike.OrderStatus)(global::AspectTestingSpike.OrderStatus.Open ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus"));
+    if (string.Equals(name, "Shipped", comparison))
+      return (global::AspectTestingSpike.OrderStatus)(global::AspectTestingSpike.OrderStatus.Shipped ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus"));
+    if (string.Equals(name, "Cancelled", comparison))
+      return (global::AspectTestingSpike.OrderStatus)(global::AspectTestingSpike.OrderStatus.Cancelled ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus"));
+    throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.NoMember("OrderStatus");
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public override global::System.String ToString()
+  {
+    return (global::System.String)this.Name;
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  static global::System.Boolean global::System.IParsable<global::AspectTestingSpike.OrderStatus>.TryParse([global::System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] global::System.String? s, global::System.IFormatProvider? provider, [global::System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out global::AspectTestingSpike.OrderStatus result)
+  {
+    if (s == "Open")
+    {
+      result = global::AspectTestingSpike.OrderStatus.Open ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus");
+      return (global::System.Boolean)true;
+    }
+    if (s == "Shipped")
+    {
+      result = global::AspectTestingSpike.OrderStatus.Shipped ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus");
+      return (global::System.Boolean)true;
+    }
+    if (s == "Cancelled")
+    {
+      result = global::AspectTestingSpike.OrderStatus.Cancelled ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus");
+      return (global::System.Boolean)true;
+    }
+    result = null !;
+    return (global::System.Boolean)false;
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::System.Boolean TryParse([global::System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] global::System.String? name, [global::System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out global::AspectTestingSpike.OrderStatus? member)
+  {
+    if (name == "Open")
+    {
+      member = global::AspectTestingSpike.OrderStatus.Open ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus");
+      return (global::System.Boolean)true;
+    }
+    if (name == "Shipped")
+    {
+      member = global::AspectTestingSpike.OrderStatus.Shipped ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus");
+      return (global::System.Boolean)true;
+    }
+    if (name == "Cancelled")
+    {
+      member = global::AspectTestingSpike.OrderStatus.Cancelled ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus");
+      return (global::System.Boolean)true;
+    }
+    member = null;
+    return (global::System.Boolean)false;
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public static global::System.Boolean TryParse([global::System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] global::System.String? name, global::System.Boolean ignoreCase, [global::System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out global::AspectTestingSpike.OrderStatus? member)
+  {
+    var comparison = ignoreCase ? global::System.StringComparison.OrdinalIgnoreCase : global::System.StringComparison.Ordinal;
+    if (string.Equals(name, "Open", comparison))
+    {
+      member = global::AspectTestingSpike.OrderStatus.Open ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus");
+      return (global::System.Boolean)true;
+    }
+    if (string.Equals(name, "Shipped", comparison))
+    {
+      member = global::AspectTestingSpike.OrderStatus.Shipped ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus");
+      return (global::System.Boolean)true;
+    }
+    if (string.Equals(name, "Cancelled", comparison))
+    {
+      member = global::AspectTestingSpike.OrderStatus.Cancelled ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus");
+      return (global::System.Boolean)true;
+    }
+    member = null;
+    return (global::System.Boolean)false;
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public sealed class OrderStatusJsonConverter : global::System.Text.Json.Serialization.JsonConverter<global::AspectTestingSpike.OrderStatus>
+  {
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override global::AspectTestingSpike.OrderStatus Read(ref global::System.Text.Json.Utf8JsonReader reader, global::System.Type typeToConvert, global::System.Text.Json.JsonSerializerOptions options)
+    {
+      var name = reader.TokenType == global::System.Text.Json.JsonTokenType.String ? reader.GetString() : null;
+      if (name is not null)
+      {
+        if (name == "Open")
+          return (global::AspectTestingSpike.OrderStatus)(global::AspectTestingSpike.OrderStatus.Open ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus"));
+        if (name == "Shipped")
+          return (global::AspectTestingSpike.OrderStatus)(global::AspectTestingSpike.OrderStatus.Shipped ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus"));
+        if (name == "Cancelled")
+          return (global::AspectTestingSpike.OrderStatus)(global::AspectTestingSpike.OrderStatus.Cancelled ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus"));
+      }
+      throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.NoMemberInJson("OrderStatus");
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override global::AspectTestingSpike.OrderStatus ReadAsPropertyName(ref global::System.Text.Json.Utf8JsonReader reader, global::System.Type typeToConvert, global::System.Text.Json.JsonSerializerOptions options)
+    {
+      var name = reader.GetString();
+      if (name == "Open")
+        return (global::AspectTestingSpike.OrderStatus)(global::AspectTestingSpike.OrderStatus.Open ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus"));
+      if (name == "Shipped")
+        return (global::AspectTestingSpike.OrderStatus)(global::AspectTestingSpike.OrderStatus.Shipped ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus"));
+      if (name == "Cancelled")
+        return (global::AspectTestingSpike.OrderStatus)(global::AspectTestingSpike.OrderStatus.Cancelled ?? throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.StillInitializing("OrderStatus"));
+      throw global::CodoMetis.TypeKit.CompilerServices.GeneratedClosedSets.NoMemberInJson("OrderStatus");
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override void Write(global::System.Text.Json.Utf8JsonWriter writer, global::AspectTestingSpike.OrderStatus value, global::System.Text.Json.JsonSerializerOptions options)
+    {
+      writer.WriteStringValue((string)value.Name);
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override void WriteAsPropertyName(global::System.Text.Json.Utf8JsonWriter writer, global::AspectTestingSpike.OrderStatus value, global::System.Text.Json.JsonSerializerOptions options)
+    {
+      writer.WritePropertyName((string)value.Name);
+    }
+  }
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+  public sealed class OrderStatusTypeConverter : global::System.ComponentModel.TypeConverter
+  {
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override global::System.Boolean CanConvertFrom(global::System.ComponentModel.ITypeDescriptorContext? context, global::System.Type sourceType)
+    {
+      return (global::System.Boolean)(sourceType == typeof(global::System.String) || base.CanConvertFrom(context, sourceType));
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override global::System.Boolean CanConvertTo(global::System.ComponentModel.ITypeDescriptorContext? context, global::System.Type? destinationType)
+    {
+      return (global::System.Boolean)(destinationType == typeof(global::System.String) || base.CanConvertTo(context, destinationType));
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override global::System.Object? ConvertFrom(global::System.ComponentModel.ITypeDescriptorContext? context, global::System.Globalization.CultureInfo? culture, global::System.Object value)
+    {
+      if (value is string s)
+      {
+        return global::AspectTestingSpike.OrderStatus.Parse(s);
+      }
+      return (global::System.Object? )base.ConvertFrom(context, culture, value);
+    }
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+    public override global::System.Object? ConvertTo(global::System.ComponentModel.ITypeDescriptorContext? context, global::System.Globalization.CultureInfo? culture, global::System.Object? value, global::System.Type destinationType)
+    {
+      if (destinationType == typeof(global::System.String) && value is not null)
+      {
+        return ((global::AspectTestingSpike.OrderStatus)value).Name;
+      }
+      return (global::System.Object? )base.ConvertTo(context, culture, value, destinationType);
+    }
+  }
+}
\ No newline at end of file
diff --git a/spikes/AspectTestingSpike/Directory.Build.props b/spikes/AspectTestingSpike/Directory.Build.props
new file mode 100644
index 00000000..742cd979
--- /dev/null
+++ b/spikes/AspectTestingSpike/Directory.Build.props
@@ -0,0 +1,13 @@
+<Project>
+    <!--
+      Self-contained spike: nothing above this folder is inherited. The root props would make warnings
+      errors and demand XML documentation of the test inputs. The generators project referenced below
+      keeps its own props, so it builds exactly as in the solution.
+    -->
+    <PropertyGroup>
+        <TargetFramework>net10.0</TargetFramework>
+        <LangVersion>14</LangVersion>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+</Project>
diff --git a/spikes/AspectTestingSpike/README.md b/spikes/AspectTestingSpike/README.md
new file mode 100644
index 00000000..440d02fe
--- /dev/null
+++ b/spikes/AspectTestingSpike/README.md
@@ -0,0 +1,124 @@
+# Spike: Metalama.Testing.AspectTesting beside xunit.v3 on Microsoft Testing Platform
+
+**Question.** Can `Metalama.Testing.AspectTesting` 2026.1.30 (MIT) test this repository's aspects? It
+runs on xunit v2 (it depends on `xunit.extensibility.core`, `xunit.extensibility.execution` and
+`xunit.assert` 2.9.3), and this repository runs xunit.v3 4.0.2 on Microsoft Testing Platform, chosen for
+`dotnet test` by `"test": {"runner": "Microsoft.Testing.Platform"}` in the root `global.json`. In detail:
+
+1. Can an aspect-test project live in a project of its own and run its tests, and with which runner?
+2. Added to `CodoMetis.TypeKit.slnx`, would `dotnet test --solution` still run the rest?
+3. If not, can it run as a separate command, locally and in CI?
+4. Does it test the real `src/CodoMetis.TypeKit.Generators`, whose aspects are `internal` and applied by a
+   `TransitiveProjectFabric`, through a project reference rather than a copy?
+5. What do the expected files look like for a plain value object, a validated one and a closed set, and
+   can a reviewer verify one by eye? (GitHub issue #93; the motivation is the reviewer.)
+
+**Answer: it works, beside the solution, not inside its test run.** Measured 2026-10-28 on macOS arm64,
+.NET SDK 10.0.403 (the root pin 10.0.402 with `latestPatch`), Metalama.Framework and
+Metalama.Testing.AspectTesting 2026.1.30, xunit 2.9.3, xunit.runner.visualstudio 3.1.5,
+Microsoft.NET.Test.Sdk 17.14.1 (VSTest 18.7.0).
+
+1. Yes, as an xunit v2 project on VSTest, which needs a `global.json` of its own: the root one makes
+   `dotnet test` refuse it. With this folder's `global.json` (the same SDK pin, no `test` key),
+   `dotnet test` run from this folder passes 4 of 4.
+2. No. One VSTest project in the solution makes `dotnet test --solution` refuse the whole run, before
+   building, and no test of the other projects runs. Marked `IsTestProject=false`, the project is skipped
+   by the solution's test run, which then runs the rest, but VSTest's `dotnet test` then also runs
+   nothing and exits 0.
+3. Yes, as a separate command: `dotnet test` from this folder, or `dotnet vstest` on the built dll from
+   anywhere. CI would need one more step with `working-directory` set to this folder. That is
+   plausible but was not run in CI.
+4. Yes. The project references the real generators project, and the fabric applies inside the test
+   framework's compilation of each input file: the closed set, the plain value object and the validated
+   one come out fully woven, and a refusal comes out as its CMTK diagnostic. A defect seeded in a scratch
+   copy of `src/` fails the two tests whose output it changes.
+5. The expected files have 235 to 349 lines each (15 to 23 KB) for an input of 5 to 17 lines. They are
+   formatted, one member per block, so one member can be checked by eye. A whole file cannot, because
+   it has every generated member in full, with every name fully qualified. Reading them turned up dead
+   code after a `return` in every generated `TryParse(string?, …)` (finding 12).
+
+## Layout
+
+| Path | Role |
+|---|---|
+| `global.json` | The root SDK pin without the `test` key, so `dotnet test` run from here uses VSTest |
+| `Directory.Build.props` | Stops the root props (warnings as errors, documentation, package validation) from reaching the spike |
+| `AspectTests/AspectTests.csproj` | xunit 2.9.3, Microsoft.NET.Test.Sdk, xunit.runner.visualstudio, Metalama.Testing.AspectTesting, and a project reference to `src/CodoMetis.TypeKit.Generators`. Versions are inline (`spikes/Directory.Packages.props` turns central management off) |
+| `AspectTests/OrderId.cs` → `OrderId.t.cs`, `OrderId.OrderIdExtensions.i.cs` | A plain value object, `IValue<Guid>`, and the companion class it gets |
+| `AspectTests/Email.cs` → `Email.t.cs`, `Email.EmailExtensions.i.cs` | The root README's validated `Email : IValidatedValue<Email, string, EmailFault>` |
+| `AspectTests/OrderStatus.cs` → `OrderStatus.t.cs` | The root README's closed set |
+| `AspectTests/NotReadonly.cs` → `NotReadonly.t.cs` | A refusal: a value object that is not `readonly` (CMTK1002) |
+
+Every `.cs` file that is not a `.t.cs` or `.i.cs` is a test case, and its `.t.cs` holds the expected
+output. A type that the aspects introduce in a file of its own gets a `.i.cs` file. Both kinds of file
+are compared.
+
+## Running it
+
+```bash
+cd spikes/AspectTestingSpike
+dotnet test AspectTests/AspectTests.csproj        # VSTest, through this folder's global.json: 4 passed
+
+# from anywhere, once built
+dotnet vstest spikes/AspectTestingSpike/AspectTests/bin/Debug/net10.0/AspectTests.dll
+```
+
+A new or changed case writes its actual output to `AspectTests/obj/transformed/net10.0/`. On the first
+run the framework creates a placeholder `.t.cs` (and `.i.cs`) that holds a `// TODO` line, so the test
+fails. Accept the output by copying it over, which is what the package's `AcceptTestOutput` target does
+(`dotnet build -t:AcceptTestOutput`). Commit first, then review the diff.
+
+## Findings
+
+| # | Claim | Result | Evidence |
+|---|---|---|---|
+| 1 | The package works on xunit v2 and VSTest, not xunit.v3 or MTP | measured | Its nuspec's dependencies for `net8.0` are `xunit.assert`, `xunit.extensibility.core` and `xunit.extensibility.execution` 2.9.3. Its `build/….targets` registers `Xunit.TestFrameworkAttribute("Metalama.Testing.AspectTesting.AspectTestFramework", …)`, an xunit v2 extension point. The 2026.1 documentation's sample project uses `Microsoft.NET.Test.Sdk`, `xunit` 2.x and `xunit.runner.visualstudio` ([snapshot-testing.md, release/2026.1](https://github.com/metalama/metalama.documentation/blob/release/2026.1/content/conceptual/aspects/testing/snapshot-testing.md)) |
+| 2 | Under the root `global.json`, `dotnet test` refuses the project | measured | `dotnet test --project spikes/AspectTestingSpike/AspectTests/AspectTests.csproj` from the root: exit 1, `global.json defines test runner to be Microsoft.Testing.Platform. All projects must use that test runner. The following test projects are using VSTest test runner: AspectTests.csproj`. The same through `build-verdict test --project …`, which always runs from the root |
+| 3 | With this folder's `global.json`, `dotnet test` from this folder runs it | measured | exit 0, `Passed! - Failed: 0, Passed: 4, Skipped: 0, Total: 4, Duration: 3 s`. The SDK reads the `global.json` nearest the current directory, so the same command from the root is finding 2 |
+| 4 | `dotnet vstest` runs the built dll from the root, whatever `global.json` says | measured | exit 0, `Passed! - Failed: 0, Passed: 4` (with `IsTestProject` `false` and `true` alike) |
+| 5 | One VSTest project in the solution stops `dotnet test --solution` for every project | measured on a scratch `.slnx` at the root (`tools/PrHygiene`, `test/CodoMetis.TypeKit.PrHygiene.Tests`, this project): exit 1, the message of finding 2, nothing built and no test run. The control, the same `.slnx` without this project: exit 0, 41 passed. The real `CodoMetis.TypeKit.slnx` was not changed |
+| 6 | `IsTestProject=false` hides it from the solution's test run | measured on the same `.slnx`: exit 0, 41 passed. `AspectTests` is neither built nor named by `dotnet test`. `build-verdict build` of that `.slnx` builds it (7 projects) |
+| 7 | …and VSTest's `dotnet test` on it then runs nothing and exits 0 | measured: from this folder, `dotnet test AspectTests/AspectTests.csproj` prints the restore and stops, exit 0, no test line. `-p:IsTestProject=true` brings back 4 passed. Setting it `false` only when `$(SolutionName)` is set does not help: the solution's test run still names the project as VSTest (exit 1, the message of finding 2) |
+| 8 | The project's own compilation cannot hold the inputs | measured: the package sets `MetalamaEnabled=False` for the project, so the C# compiler sees the inputs unwoven, and the closed set fails with CS0535 (`All`, `Name`, `QualifiedName`, `TryParse` not implemented). The inputs are removed from `Compile`. The framework still finds them in the folder, as the documentation says it does with every file. The documented alternative, `#if METALAMA` around code that uses introduced members, does not help a declaration whose interface needs those members |
+| 9 | The internal aspects and the `TransitiveProjectFabric` of the real generators apply in each test's compilation | measured: `OrderStatus.t.cs` has `_all`, `_name`, the static constructor naming each member, `All`, `Parse`, `TryParse`, the JSON and type converters. `OrderId.t.cs` and `Email.t.cs` have `_value`, the constructors, `Value`, `From`, `TryFrom`, `FromKnownGood`, parsing, formatting, comparison and converters, and each a `.i.cs` with its `GetValue` / `ValueOrNull` companion class. The project lists no compile-time assembly (`compile-time-assemblies.txt` is empty), so the framework reads the fabric from the referenced `CodoMetis.TypeKit.Generators.dll` in `assemblies.txt` (218 references) |
+| 10 | An aspect diagnostic is part of the expected output | measured: `NotReadonly.t.cs` is the one line ``// Error CMTK1002 on `Draft`: `'Draft' is a value object and must be declared readonly. See …` ``, with no code. An expected error is a passing test |
+| 11 | The tests catch a change in the generators | measured twice. Editing one name in the expected `Email.EmailExtensions.i.cs` fails `Email` (`Expected: …GetValu(this… Actual: …GetValue(this…`). In a scratch copy of `src/` and this spike, outside the repository, `ValueObjectParsableAspect.Provider` was seeded to ignore the caller's provider. That failed `OrderId` and `Email` and passed `OrderStatus` and `NotReadonly`, which do not parse through it (`Failed: 2, Passed: 2`, 7 changed lines in `OrderId.t.cs`). The repository's `src/` was not touched |
+| 12 | Reading the snapshot shows what a test of behaviour does not | measured: every generated `TryParse(string?, IFormatProvider?, out …)` has an unreachable block after its `return`, a `__inner` declaration and a `try { __inner = …; } catch (FormatException) { return false; }`. It is in `OrderId.t.cs`, in `Email.t.cs`, and in the woven probes (`test/CodoMetis.TypeKit.Generators.Probes/obj/Debug/net10.0/metalama/Probes.cs`, `ProbeId`), so it is the real output, not the framework's. Its source is `ValueObjectParsableAspect.Templates.cs`, `TryParseTemplate`: the two `meta.InsertStatement` calls come after a compile-time `if (…) return …;` and are still emitted after the `return` |
+| 13 | Size of the expected outputs | measured, with LF line endings: `OrderId.t.cs` 258 lines (19,721 bytes, longest line 1,078 characters, the base list of 14 interfaces), `Email.t.cs` 349 (23,264 bytes), `OrderStatus.t.cs` 235 (15,520 bytes), each `.i.cs` 18. 47 to 62 lines per file are longer than 120 characters. `[CompilerGenerated]` appears 25 to 52 times per file, `(global::System.Boolean)(bool)` 7 to 9 times |
+| 14 | The output is reformatted, the input included | measured: the hand-written `Create` comes back with its `if` statements reformatted, and every member is on lines of its own. The woven file that the build writes (`MetalamaEmitCompilerTransformedFiles`, as the probes do) puts a member's attributes, signature and first statement on one line |
+| 15 | Line endings do not matter to the comparison | measured on macOS: the framework wrote its output with CRLF, and git stores it with LF (`core.autocrlf`). With the expected files converted to LF, as a checkout gives them, the tests still pass (4 of 4). On Windows and Linux it was not run |
+| 16 | Cost | measured: 4 tests in 2 to 3 s once built. The project builds the four `src/` projects it needs, in Debug |
+
+## Consequences for the design
+
+**A. It cannot join the solution's test run.** With MTP selected in the root `global.json`, a VSTest
+project in the solution stops the whole test run (finding 5). The ways around that leave the project
+built but untested, and a project that runs nothing and exits 0 is the failure this repository is most
+wary of (finding 7). The aspect tests are a command of their own: `dotnet test` from this folder,
+which has its own `global.json`, or `dotnet vstest` on the built dll. Only an MTP host for xunit v2
+would remove the split. One exists on nuget.org (`YTest.MTP.XUnit2` 1.0.3). It is third-party, was not
+tried, and nothing here shows it can host Metalama's custom test framework.
+
+**B. CI would need one step and a check that it ran.** The step is `dotnet test
+AspectTests/AspectTests.csproj` with `working-directory: spikes/AspectTestingSpike` (or wherever the
+project ends up), after `setup-dotnet` with the root `global.json`, whose SDK is the same. Not run in
+CI. Line endings do not matter to the comparison (finding 15), but whether the output is otherwise the
+same on Windows and Linux was not measured. The CI matrix has both.
+
+**C. It answers "what does the generator emit", at a reviewer's scale per member.** It tests the real
+generators through the real fabric (findings 9 to 11), so it adds to the woven probes, the build
+outcomes and `GeneratedSurface.verified.txt` without a copy of anything. A change to a template shows
+up as a diff of the lines it changed, which is what issue #93 asks for. A whole `.t.cs` is too long to
+verify by eye (finding 13), but a diff is short: the seeded defect changed 7 lines. Finding 12 shows the
+reading finds things.
+
+**D. The output is too verbose for the READMEs as it is.** Issue #92's generated-code blocks would need a
+trimmed, simplified excerpt. The fully qualified names, the cast noise and a 1,079-character base list
+are not what a consumer should read. A snapshot could be the source the excerpt is checked against.
+
+**E. Still open.**
+- Whether `// <target>` (trim the output to the marked declarations, per the documentation) or the
+  HTML writer makes a whole file reviewable.
+- Expected output on Windows and Linux (B).
+- The IDE: Rider needs its xunit adapter configured to discover these tests (per the documentation),
+  and was not tried.
diff --git a/spikes/AspectTestingSpike/global.json b/spikes/AspectTestingSpike/global.json
new file mode 100644
index 00000000..0b257e34
--- /dev/null
+++ b/spikes/AspectTestingSpike/global.json
@@ -0,0 +1,13 @@
+{
+  "//": [
+    "The repository's SDK pin, without its test key: Metalama.Testing.AspectTesting runs on xunit v2",
+    "through VSTest, which dotnet test refuses once global.json selects Microsoft.Testing.Platform.",
+    "dotnet reads the global.json nearest the current directory, so this one applies only to a",
+    "command run from this folder or below."
+  ],
+  "sdk": {
+    "version": "10.0.402",
+    "rollForward": "latestPatch",
+    "allowPrerelease": false
+  }
+}
diff --git a/src/CodoMetis.TypeKit.Analyzers/AnalyzerReleases.Shipped.md b/src/CodoMetis.TypeKit.Analyzers/AnalyzerReleases.Shipped.md
index 7721d6b8..10d875a9 100644
--- a/src/CodoMetis.TypeKit.Analyzers/AnalyzerReleases.Shipped.md
+++ b/src/CodoMetis.TypeKit.Analyzers/AnalyzerReleases.Shipped.md
@@ -62,4 +62,4 @@ Rule ID | Category | Severity | Notes
 --------|----------|----------|-------------------------------------------------------------
 CMTK0014 | Usage | Warning | UndefinedEnumValueAnalyzer, a FaultKind or ConstructorAccessibility that names no member
 
-## Release 2.2.0
+## Release 2.3.0
diff --git a/src/CodoMetis.TypeKit.Analyzers/CodeFixes/MissingCreateCodeFixProvider.cs b/src/CodoMetis.TypeKit.Analyzers/CodeFixes/MissingCreateCodeFixProvider.cs
new file mode 100644
index 00000000..a6922c6b
--- /dev/null
+++ b/src/CodoMetis.TypeKit.Analyzers/CodeFixes/MissingCreateCodeFixProvider.cs
@@ -0,0 +1,245 @@
+using System.Collections.Immutable;
+using System.Composition;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+
+namespace CodoMetis.TypeKit.Analyzers;
+
+/// <summary>
+/// The fix for a validated value object that lacks <c>Create</c>, the one member of
+/// <c>IValidatedValue&lt;TSelf, T, TFault&gt;</c> written by hand: the compiler's CS0535 at the
+/// interface. It writes <c>Create</c> as a public static method that accepts every value, for the
+/// author to add the rules to.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Offered where the interface's <c>TSelf</c> is the type itself and no member of the type named
+/// <c>Create</c> takes a <c>T</c>, which would clash with the one written. The types are spelled as
+/// they are named at the type, so a fault or a wrapped type of another namespace is qualified, and
+/// the body builds the instance with the private constructor the generators add.
+/// </para>
+/// <para>
+/// Like the fix for CMTK0011 it writes its own trivia and asks no formatter: <c>Create</c> becomes the
+/// first member, indented as the members are; a declaration ending in <c>;</c>, or an empty body on one
+/// line, gets a body on lines of its own. A body on one line that holds members gets no fix.
+/// </para>
+/// </remarks>
+[ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(MissingCreateCodeFixProvider))]
+[Shared]
+public sealed class MissingCreateCodeFixProvider : CodeFixProvider
+{
+    /// <summary>The compiler's "does not implement interface member", which a missing <c>Create</c> is.</summary>
+    public const string DiagnosticId = "CS0535";
+
+    /// <summary>The metadata name of the validated value-object contract; held to the real type by its tests.</summary>
+    public const string ValidatedValueMetadataName = "CodoMetis.TypeKit.ValueObjects.IValidatedValue`3";
+
+    /// <summary>The member the fix writes; held to the contract's by its tests.</summary>
+    public const string CreateName = "Create";
+
+    /// <inheritdoc/>
+    public override ImmutableArray<string> FixableDiagnosticIds => [DiagnosticId];
+
+    /// <inheritdoc/>
+    public override FixAllProvider GetFixAllProvider() => WellKnownFixAllProviders.BatchFixer;
+
+    /// <inheritdoc/>
+    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+        if (root is null) return;
+
+        var model = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
+        if (model is null) return;
+
+        var validated = model.Compilation.GetTypesByMetadataName(ValidatedValueMetadataName);
+        if (validated.IsEmpty) return;
+
+        foreach (var diagnostic in context.Diagnostics)
+        {
+            // One CS0535 per missing member, each at the base type that brings it: only the one for
+            // Create, which the message names whatever the language.
+            if (diagnostic.GetMessage(CultureInfo.InvariantCulture).IndexOf($".{CreateName}(", System.StringComparison.Ordinal) < 0) continue;
+
+            var node = root.FindNode(diagnostic.Location.SourceSpan);
+            if (node.FirstAncestorOrSelf<BaseTypeSyntax>() is not { } written) continue;
+            if (node.FirstAncestorOrSelf<TypeDeclarationSyntax>() is not { } type || !CanLayOut(type)) continue;
+            if (model.GetDeclaredSymbol(type, context.CancellationToken) is not { } self) continue;
+            if (!Brings(model.GetTypeInfo(written.Type, context.CancellationToken).Type, validated)) continue;
+            if (MissingCreate(self, validated) is not { } create) continue;
+
+            var position = type.OpenBraceToken.IsKind(SyntaxKind.OpenBraceToken) && !type.OpenBraceToken.IsMissing
+                ? type.OpenBraceToken.Span.End
+                : type.Identifier.SpanStart;
+
+            context.RegisterCodeFix(
+                CodeAction.Create(
+                    "Add Create",
+                    cancellationToken => AddCreateAsync(context.Document, root, type, Signature(create, self, model, position), cancellationToken),
+                    equivalenceKey: nameof(MissingCreateCodeFixProvider)),
+                diagnostic);
+        }
+    }
+
+    /// <summary>Whether the base type written is the contract, or an interface that derives from it.</summary>
+    private static bool Brings(ITypeSymbol? written, ImmutableArray<INamedTypeSymbol> validated) =>
+        written is INamedTypeSymbol named
+     && (IsValidated(named, validated) || named.AllInterfaces.Any(candidate => IsValidated(candidate, validated)));
+
+    private static bool IsValidated(INamedTypeSymbol type, ImmutableArray<INamedTypeSymbol> validated) =>
+        validated.Contains(type.OriginalDefinition, SymbolEqualityComparer.Default);
+
+    /// <summary>
+    /// The contract's <c>Create</c> that the type leaves unimplemented, closed over the type's arguments,
+    /// or <see langword="null"/>: where <c>TSelf</c> is another type, the instance to return is not this
+    /// type's to build, and a member of the type named <c>Create</c> taking a <c>T</c> would clash.
+    /// </summary>
+    private static IMethodSymbol? MissingCreate(INamedTypeSymbol self, ImmutableArray<INamedTypeSymbol> validated)
+    {
+        foreach (var contract in self.AllInterfaces.Where(candidate => IsValidated(candidate, validated)))
+        {
+            if (!SymbolEqualityComparer.Default.Equals(contract.TypeArguments[0], self)) continue;
+
+            var create = contract.GetMembers(CreateName).OfType<IMethodSymbol>().FirstOrDefault(method => method.IsStatic && method.Parameters.Length == 1);
+            if (create is null || self.FindImplementationForInterfaceMember(create) is not null) continue;
+
+            var wrapped = create.Parameters[0].Type;
+            var clash   = self.GetMembers(CreateName).OfType<IMethodSymbol>()
+                              .Any(method => method.Parameters.Length == 1 && SymbolEqualityComparer.Default.Equals(method.Parameters[0].Type, wrapped));
+
+            return clash ? null : create;
+        }
+
+        return null;
+    }
+
+    /// <summary>What the method is made of, its types spelled as the type's own code would name them.</summary>
+    private static Parts Signature(IMethodSymbol create, INamedTypeSymbol self, SemanticModel model, int position)
+    {
+        var parameter = create.Parameters[0];
+        var fault     = ((INamedTypeSymbol)create.ReturnType).TypeArguments[1];
+
+        // A fault that is an enum names its first member in the comment, the shape a rule takes.
+        var example = fault is INamedTypeSymbol { TypeKind: TypeKind.Enum } enumeration
+                   && enumeration.GetMembers().OfType<IFieldSymbol>().FirstOrDefault(field => field.HasConstantValue) is { } member
+            ? $"{fault.ToMinimalDisplayString(model, position)}.{Escaped(member.Name)}"
+            : "...";
+
+        return new Parts(
+            create.ReturnType.ToMinimalDisplayString(model, position),
+            parameter.Type.ToMinimalDisplayString(model, position),
+            Escaped(parameter.Name),
+            self.ToMinimalDisplayString(model, position),
+            example);
+    }
+
+    private static string Escaped(string name) => SyntaxFacts.GetKeywordKind(name) == SyntaxKind.None ? name : "@" + name;
+
+    /// <summary>
+    /// Whether the fix can lay the method out: in a body of several lines, an empty body on one line, or a
+    /// declaration ending in <c>;</c>, whose line starts with the type, not a body on one line that holds
+    /// members.
+    /// </summary>
+    private static bool CanLayOut(TypeDeclarationSyntax type)
+    {
+        if (!HasBody(type)) return true;
+        return type.Members.Count == 0 || type.OpenBraceToken.TrailingTrivia.Any(trivia => trivia.IsKind(SyntaxKind.EndOfLineTrivia));
+    }
+
+    private static bool HasBody(TypeDeclarationSyntax type) =>
+        type.OpenBraceToken.IsKind(SyntaxKind.OpenBraceToken) && !type.OpenBraceToken.IsMissing;
+
+    private static async Task<Document> AddCreateAsync(Document document, SyntaxNode root, TypeDeclarationSyntax type, Parts parts, CancellationToken cancellationToken)
+    {
+        var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
+        return document.WithSyntaxRoot(root.ReplaceNode(type, WithCreate(type, parts, text)));
+    }
+
+    /// <summary>
+    /// The type with <c>Create</c> as its first member. In a body of several lines it goes on lines of
+    /// its own, indented as the members are and ending as the brace's line does, a blank line before the
+    /// next member. A declaration ending in <c>;</c>, or an empty body on one line, gets a body on lines of
+    /// its own at the type's indentation, ending as the line of the <c>;</c> or the brace does, or the
+    /// nearest line before it, the <c>;</c>'s trivia, a comment included, kept after it.
+    /// </summary>
+    private static TypeDeclarationSyntax WithCreate(TypeDeclarationSyntax type, Parts parts, SourceText text)
+    {
+        var end = HasBody(type) ? type.OpenBraceToken.TrailingTrivia.LastOrDefault(trivia => trivia.IsKind(SyntaxKind.EndOfLineTrivia)) : default;
+
+        if (end.IsKind(SyntaxKind.EndOfLineTrivia))
+        {
+            var eol    = end.ToString();
+            var indent = TypeLayout.MemberIndentation(type, text);
+            var outer  = TypeLayout.Indentation(text, type.CloseBraceToken.SpanStart) ?? "";
+            var unit   = indent.Length > outer.Length && indent.StartsWith(outer, System.StringComparison.Ordinal) ? indent.Substring(outer.Length) : TypeLayout.Unit(indent, text);
+            var after  = type.Members.Count > 0 ? SyntaxFactory.TriviaList(SyntaxFactory.EndOfLine(eol), SyntaxFactory.EndOfLine(eol)) : SyntaxFactory.TriviaList(SyntaxFactory.EndOfLine(eol));
+
+            return type.WithMembers(type.Members.Insert(0, Method(parts, indent, unit, eol, after)));
+        }
+
+        // A body opened here: the brace on a line of its own at the type's indentation.
+        var typeIndent = TypeLayout.Indentation(text, type.SpanStart) ?? "";
+        var unitHere   = TypeLayout.Unit(typeIndent, text);
+        var ending     = HasBody(type) ? type.CloseBraceToken : type.SemicolonToken;
+        var lineEnd    = TypeLayout.LineEndingAt(text, ending.SpanStart);
+        var closing    = ending.TrailingTrivia;
+        var last       = (HasBody(type) ? type.OpenBraceToken : type.SemicolonToken).GetPreviousToken();
+
+        var opened = type.ReplaceToken(last, last.WithTrailingTrivia(last.TrailingTrivia.Where(trivia => !trivia.IsKind(SyntaxKind.WhitespaceTrivia))));
+        var lead   = SyntaxFactory.TriviaList(SyntaxFactory.EndOfLine(lineEnd)).AddRange(Whitespace(typeIndent));
+        var open   = SyntaxFactory.Token(lead, SyntaxKind.OpenBraceToken, SyntaxFactory.TriviaList(SyntaxFactory.EndOfLine(lineEnd)));
+        var close  = SyntaxFactory.Token(Whitespace(typeIndent), SyntaxKind.CloseBraceToken, closing);
+
+        return opened.WithSemicolonToken(default)
+                     .WithOpenBraceToken(open)
+                     .WithMembers(SyntaxFactory.SingletonList(Method(parts, typeIndent + unitHere, unitHere, lineEnd, SyntaxFactory.TriviaList(SyntaxFactory.EndOfLine(lineEnd)))))
+                     .WithCloseBraceToken(close);
+    }
+
+    /// <summary>
+    /// <c>Create</c> parsed from its text, so every token carries the trivia written there and none is
+    /// elastic trivia a code action's cleanup would lay out again.
+    /// </summary>
+    private static MemberDeclarationSyntax Method(Parts parts, string indent, string unit, string eol, SyntaxTriviaList trailing)
+    {
+        var source =
+            $"public static {parts.Returns} {CreateName}({parts.Wrapped} {parts.Parameter}){eol}"
+          + $"{indent}{{{eol}"
+          + $"{indent}{unit}// Add your rules: if (...) return Result.Error({parts.Example});{eol}"
+          + $"{indent}{unit}return new {parts.Self}({parts.Parameter});{eol}"
+          + $"{indent}}}";
+
+        return (SyntaxFactory.ParseMemberDeclaration(source) ?? throw new System.InvalidOperationException($"'{source}' does not parse as a method."))
+               .WithLeadingTrivia(Whitespace(indent))
+               .WithTrailingTrivia(trailing);
+    }
+
+    private static SyntaxTriviaList Whitespace(string indent) =>
+        indent.Length == 0 ? SyntaxFactory.TriviaList() : SyntaxFactory.TriviaList(SyntaxFactory.Whitespace(indent));
+
+    private sealed class Parts
+    {
+        public Parts(string returns, string wrapped, string parameter, string self, string example)
+        {
+            Returns   = returns;
+            Wrapped   = wrapped;
+            Parameter = parameter;
+            Self      = self;
+            Example   = example;
+        }
+
+        public string Returns { get; }
+        public string Wrapped { get; }
+        public string Parameter { get; }
+        public string Self { get; }
+        public string Example { get; }
+    }
+}
diff --git a/src/CodoMetis.TypeKit.Analyzers/CodeFixes/RequiredParameterlessConstructorCodeFixProvider.cs b/src/CodoMetis.TypeKit.Analyzers/CodeFixes/RequiredParameterlessConstructorCodeFixProvider.cs
index a39d4023..f0558366 100644
--- a/src/CodoMetis.TypeKit.Analyzers/CodeFixes/RequiredParameterlessConstructorCodeFixProvider.cs
+++ b/src/CodoMetis.TypeKit.Analyzers/CodeFixes/RequiredParameterlessConstructorCodeFixProvider.cs
@@ -191,7 +191,7 @@ private static TypeDeclarationSyntax WithConstructor(TypeDeclarationSyntax type,
 
         // The line ending of the brace the constructor follows, so a CRLF file stays CRLF.
         var eol      = end.ToString();
-        var indent   = MemberIndentation(type, text);
+        var indent   = TypeLayout.MemberIndentation(type, text);
         var leading  = indent.Length == 0 ? SyntaxFactory.TriviaList() : SyntaxFactory.TriviaList(SyntaxFactory.Whitespace(indent));
         var trailing = type.Members.Count > 0
             ? SyntaxFactory.TriviaList(SyntaxFactory.EndOfLine(eol), SyntaxFactory.EndOfLine(eol))
@@ -209,31 +209,6 @@ private static MemberDeclarationSyntax Constructor(string source, SyntaxTriviaLi
             .WithLeadingTrivia(leading)
             .WithTrailingTrivia(trailing);
 
-    /// <summary>
-    /// The indentation of the first member's line; without a member, the closing brace's, or the
-    /// type's, one level deeper, a tab where the file indents with tabs.
-    /// </summary>
-    private static string MemberIndentation(TypeDeclarationSyntax type, SourceText text)
-    {
-        if (type.Members.Count > 0 && Indentation(text, type.Members[0].SpanStart) is { } member) return member;
-
-        var outer = Indentation(text, type.CloseBraceToken.SpanStart) ?? Indentation(text, type.SpanStart) ?? "";
-        var tabs  = outer.IndexOf('\t') >= 0 || text.Lines.Any(line => line.Span.Length > 0 && text[line.Start] == '\t');
-
-        return outer + (tabs ? "\t" : "    ");
-    }
-
-    /// <summary>The whitespace that starts the line of <paramref name="position"/>, or <see langword="null"/> when anything else stands before it.</summary>
-    private static string? Indentation(SourceText text, int position)
-    {
-        var line = text.Lines.GetLineFromPosition(position);
-        var end  = line.Start;
-
-        while (end < position && text[end] is ' ' or '\t') end++;
-
-        return end == position ? text.ToString(TextSpan.FromBounds(line.Start, end)) : null;
-    }
-
     /// <summary>The accessibility's keywords, the first led by <paramref name="leading"/>, the last followed by <paramref name="trailing"/>.</summary>
     private static IEnumerable<SyntaxToken> Keywords(Accessibility accessibility, SyntaxTriviaList leading, SyntaxTriviaList trailing)
     {
diff --git a/src/CodoMetis.TypeKit.Analyzers/CodeFixes/TypeLayout.cs b/src/CodoMetis.TypeKit.Analyzers/CodeFixes/TypeLayout.cs
new file mode 100644
index 00000000..68eebada
--- /dev/null
+++ b/src/CodoMetis.TypeKit.Analyzers/CodeFixes/TypeLayout.cs
@@ -0,0 +1,55 @@
+using System.Linq;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+
+namespace CodoMetis.TypeKit.Analyzers;
+
+/// <summary>
+/// How a type's members are laid out, read from the text, for a fix that adds one and asks no
+/// formatter.
+/// </summary>
+internal static class TypeLayout
+{
+    /// <summary>
+    /// The indentation of the first member's line; without a member, the closing brace's, or the
+    /// type's, one level deeper, a tab where the file indents with tabs.
+    /// </summary>
+    public static string MemberIndentation(TypeDeclarationSyntax type, SourceText text)
+    {
+        if (type.Members.Count > 0 && Indentation(text, type.Members[0].SpanStart) is { } member) return member;
+
+        var outer = Indentation(text, type.CloseBraceToken.SpanStart) ?? Indentation(text, type.SpanStart) ?? "";
+        return outer + Unit(outer, text);
+    }
+
+    /// <summary>One level of indentation: a tab where the file indents with tabs, otherwise four spaces.</summary>
+    public static string Unit(string indentation, SourceText text) =>
+        indentation.IndexOf('\t') >= 0 || text.Lines.Any(line => line.Span.Length > 0 && text[line.Start] == '\t') ? "\t" : "    ";
+
+    /// <summary>The whitespace that starts the line of <paramref name="position"/>, or <see langword="null"/> when anything else stands before it.</summary>
+    public static string? Indentation(SourceText text, int position)
+    {
+        var line = text.Lines.GetLineFromPosition(position);
+        var end  = line.Start;
+
+        while (end < position && text[end] is ' ' or '\t') end++;
+
+        return end == position ? text.ToString(TextSpan.FromBounds(line.Start, end)) : null;
+    }
+
+    /// <summary>
+    /// The line ending of the line holding <paramref name="position"/>, or of the nearest line before it
+    /// that has one, so lines added there end as their neighbours do in a file whose endings are mixed;
+    /// LF in a file of one line.
+    /// </summary>
+    public static string LineEndingAt(SourceText text, int position)
+    {
+        for (var number = text.Lines.GetLineFromPosition(position).LineNumber; number >= 0; number--)
+        {
+            var line = text.Lines[number];
+            if (line.EndIncludingLineBreak > line.End) return text.ToString(TextSpan.FromBounds(line.End, line.EndIncludingLineBreak));
+        }
+
+        return "\n";
+    }
+}
diff --git a/src/CodoMetis.TypeKit.Analyzers/DefaultProducingCallAnalyzer.cs b/src/CodoMetis.TypeKit.Analyzers/DefaultProducingCallAnalyzer.cs
index 34e5e66f..23cde09d 100644
--- a/src/CodoMetis.TypeKit.Analyzers/DefaultProducingCallAnalyzer.cs
+++ b/src/CodoMetis.TypeKit.Analyzers/DefaultProducingCallAnalyzer.cs
@@ -41,6 +41,15 @@ namespace CodoMetis.TypeKit.Analyzers;
 /// where the generated <c>TryFrom</c> does not bind and neither does <c>OrDefault</c> on it;
 /// <c>X.TryFrom(…).OrDefault()</c> is recognised there by name.
 /// </para>
+/// <para>
+/// With a message of its own, the rule also reports <c>FirstOrNone</c>, <c>SingleOrNone</c>,
+/// <c>LastOrNone</c>, <c>FirstOrError</c> and <c>LastOrError</c> called on a query with a delegate for
+/// a condition: a <c>Func</c> variable, a field, a method group, an anonymous method, a call that
+/// returns one. The query's overloads take an expression, so the call binds to the sequence's, which
+/// reads the whole query and runs the condition in memory. A lambda written at the call and an
+/// <c>Expression</c> bind to the query's, and a receiver typed as a sequence (<c>AsEnumerable()</c>,
+/// a cast) reads the query in full on purpose.
+/// </para>
 /// </remarks>
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public sealed class DefaultProducingCallAnalyzer : DiagnosticAnalyzer
@@ -56,10 +65,22 @@ public sealed class DefaultProducingCallAnalyzer : DiagnosticAnalyzer
         helpLinkUri: DiagnosticIds.HelpLink(DiagnosticIds.DefaultProducingCall)
     );
 
+    /// <summary>A delegate condition on a query, which binds the call to its sequence overload.</summary>
+    private static readonly DiagnosticDescriptor QueryDelegateRule = new(
+        DiagnosticIds.DefaultProducingCall,
+        title: "A delegate condition reads the whole query",
+        messageFormat: "'{0}' on the query binds to its IEnumerable<T> overload, since the condition is a '{1}' and not an expression: it reads every row and runs the condition in memory. {2}.",
+        category: "Usage",
+        DiagnosticSeverity.Warning,
+        isEnabledByDefault: true,
+        description: "FirstOrNone, SingleOrNone and FirstOrError on an IQueryable<T> take the condition as an Expression<Func<T, bool>>, which the query provider runs. A Func held in a variable, a field, a method group or a call that returns one is no expression, so the call binds to the overload on IEnumerable<T>: the query is read in full and the condition runs in memory, on every row.",
+        helpLinkUri: DiagnosticIds.HelpLink(DiagnosticIds.DefaultProducingCall)
+    );
+
     private const string TryFrom = "TryFrom";
 
     /// <inheritdoc/>
-    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => [Rule];
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => [Rule, QueryDelegateRule];
 
     /// <inheritdoc/>
     public override void Initialize(AnalysisContext context)
@@ -71,6 +92,11 @@ public override void Initialize(AnalysisContext context)
         {
             if (TypeKitSymbols.Resolve(start.Compilation) is not { } symbols) return;
 
+            var queryable = start.Compilation.GetTypeByMetadataName("System.Linq.IQueryable`1");
+            var func      = start.Compilation.GetTypeByMetadataName("System.Func`2");
+            if (queryable is not null && func is not null && QueryDelegateForms(symbols, func) is { Count: > 0 } delegates)
+                start.RegisterOperationAction(operation => AnalyzeQueryDelegate(operation, delegates, queryable, func), OperationKind.Invocation);
+
             var forms = Forms(start.Compilation, symbols);
             if (forms.Count == 0) return;
 
@@ -81,6 +107,77 @@ public override void Initialize(AnalysisContext context)
         });
     }
 
+    /// <summary>
+    /// <c>query.FirstOrNone(isBeta)</c>: a sequence overload that takes a <c>Func</c>, called on a
+    /// receiver that is a query before the implicit conversion to <c>IEnumerable&lt;T&gt;</c>.
+    /// </summary>
+    private static void AnalyzeQueryDelegate(OperationAnalysisContext context, Dictionary<IMethodSymbol, string> forms, INamedTypeSymbol queryable, INamedTypeSymbol func)
+    {
+        var invocation = (IInvocationOperation)context.Operation;
+        var method     = invocation.TargetMethod;
+
+        if (!forms.TryGetValue(method.OriginalDefinition, out var advice)) return;
+
+        // An extension block's member has its receiver as the instance; the static form, Option.FirstOrNone(query, f),
+        // and the block's implementation have it as the first argument.
+        var receiver = invocation.Instance ?? invocation.Arguments.FirstOrDefault(argument => argument.Parameter?.Ordinal == 0)?.Value;
+
+        // Only the conversion the compiler wrote: a cast to IEnumerable<T> reads the query in full on purpose.
+        while (receiver is IConversionOperation { IsImplicit: true } conversion) receiver = conversion.Operand;
+
+        if (receiver?.Type is not { } type || !IsQuery(type, queryable)) return;
+
+        var condition = method.Parameters.First(parameter => IsFunc(parameter.Type, func)).Type;
+        var element   = ((INamedTypeSymbol)condition).TypeArguments[0].ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
+
+        context.Report(Diagnostic.Create(
+            QueryDelegateRule,
+            invocation.Syntax.GetLocation(),
+            method.Name,
+            condition.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat),
+            string.Format(advice, element)));
+    }
+
+    /// <summary>Whether <paramref name="type"/> is an <c>IQueryable&lt;T&gt;</c>, implements one, or is a type parameter constrained to one.</summary>
+    private static bool IsQuery(ITypeSymbol type, INamedTypeSymbol queryable) =>
+        type switch
+        {
+            ITypeParameterSymbol parameter => parameter.ConstraintTypes.Any(constraint => IsQuery(constraint, queryable)),
+            _ => SymbolEqualityComparer.Default.Equals(type.OriginalDefinition, queryable)
+              || type.AllInterfaces.Any(candidate => SymbolEqualityComparer.Default.Equals(candidate.OriginalDefinition, queryable))
+        };
+
+    private static bool IsFunc(ITypeSymbol type, INamedTypeSymbol func) => SymbolEqualityComparer.Default.Equals(type.OriginalDefinition, func);
+
+    /// <summary>
+    /// The sequence overloads that take a <c>Func</c> condition and have a query twin that takes an
+    /// expression, by original definition, with the advice for each, <c>{0}</c> for the element type. The
+    /// Last forms' twins on a query refuse to compile, so their advice is to take the first instead.
+    /// </summary>
+    private static Dictionary<IMethodSymbol, string> QueryDelegateForms(TypeKitSymbols symbols, INamedTypeSymbol func)
+    {
+        var forms = new Dictionary<IMethodSymbol, string>(SymbolEqualityComparer.Default);
+
+        const string asExpression = "Write the condition as a lambda at the call, or hold it as an Expression<Func<{0}, bool>>, so that the query runs it, or call AsEnumerable() first to read every row on purpose";
+
+        foreach (var (methods, advice) in new[]
+                 {
+                     (symbols.OptionClassMethods("FirstOrNone"), asExpression),
+                     (symbols.OptionClassMethods("SingleOrNone"), asExpression),
+                     (symbols.ResultClassMethods("FirstOrError"), asExpression),
+                     (symbols.OptionClassMethods("LastOrNone"), "A query has no last element until it is ordered: order it the other way and use FirstOrNone with the condition as a lambda, or call AsEnumerable() first to read every row on purpose"),
+                     (symbols.ResultClassMethods("LastOrError"), "A query has no last element until it is ordered: order it the other way and use FirstOrError with the condition as a lambda, or call AsEnumerable() first to read every row on purpose"),
+                 })
+        {
+            foreach (var method in methods)
+            {
+                if (method.Parameters.Any(parameter => IsFunc(parameter.Type, func))) forms[method] = advice;
+            }
+        }
+
+        return forms;
+    }
+
     private static void Analyze(OperationAnalysisContext context, TypeKitSymbols symbols, Dictionary<IMethodSymbol, Form> forms)
     {
         var invocation = (IInvocationOperation)context.Operation;
diff --git a/src/CodoMetis.TypeKit.Analyzers/IgnoredOutcomeAnalyzer.cs b/src/CodoMetis.TypeKit.Analyzers/IgnoredOutcomeAnalyzer.cs
index af95757e..230f9ab5 100644
--- a/src/CodoMetis.TypeKit.Analyzers/IgnoredOutcomeAnalyzer.cs
+++ b/src/CodoMetis.TypeKit.Analyzers/IgnoredOutcomeAnalyzer.cs
@@ -147,12 +147,178 @@ private static void Analyze(OperationAnalysisContext context, TypeKitSymbols sym
             // pass-through stands between them; a branch's call keeps its own.
             var own  = ReferenceEquals(invocation, passedOn);
             var type = own && ReferenceEquals(invocation, dropped) ? expression.Type : awaited is null ? invocation.Type : tasks.Awaited(invocation.Type);
-            if (DroppedOutcome(type, invocation, symbols, tasks) is not { } outcome) continue;
+
+            var outcome = DroppedOutcome(type, invocation, symbols, tasks) ?? DroppedAssertion(invocation, awaited is not null, tasks);
+            if (outcome is null) continue;
 
             context.Report(Diagnostic.Create(Rule, (own ? expression : invocation).Syntax.GetLocation(), outcome, invocation.TargetMethod.Name));
         }
     }
 
+    /// <summary>
+    /// The task that fails a test, dropped, or awaited where <paramref name="awaited"/> says so (the caller
+    /// of a conversion to a plain <c>Task</c> and <c>Wait</c> wait for it too): <c>pending.ShouldBeSuccess();</c>
+    /// asserts nothing, since the assertion fails the test only through its task (<see cref="IsPendingAssertion"/>).
+    /// Nor does <c>Task.WhenAll(first.ShouldBeNone(), second.ShouldBeNone());</c> or <c>Task.Run(() =&gt;
+    /// pending.ShouldBeNone());</c>, whose task faults when an assertion fails, or <c>Task.WhenAny</c> of them,
+    /// awaited or not, whose task completes with the first to finish and leaves every failure unobserved, when
+    /// the statement made an assertion it hands on (<see cref="Tasks.PassesOnFailure"/>). Awaited, a <c>WhenAll</c>
+    /// or a <c>Run</c> observes only a failure it was handed as a fault: <c>await Task.WhenAll(Task.WhenAny(…))</c>
+    /// completes with the faulted assertion as its value (<see cref="HandsOn"/>'s depth).
+    /// </summary>
+    private static string? DroppedAssertion(IInvocationOperation invocation, bool awaited, Tasks tasks)
+    {
+        var method = invocation.TargetMethod;
+
+        var dropped = IsPendingAssertion(method, tasks) ? !awaited
+                    : tasks.PassesOnFailure(method) is { } faults
+                   && invocation.Arguments.Any(argument => MadeAssertions(argument.Value, tasks).Any(made => !awaited || !faults || made.Depth > 0));
+
+        if (!dropped) return null;
+
+        // Task.WhenEach(first.ShouldBeNone(), second.ShouldBeNone()) yields them unobserved.
+        return tasks.ElementOfSequence(invocation.Type) is { } element ? $"sequence of {element.Name}s" : invocation.Type?.Name ?? "Task";
+    }
+
+    /// <summary>
+    /// The assertions <paramref name="value"/> makes and hands on the task of, <see cref="Producers"/>' way, as
+    /// an element of an array or a collection, or from a lambda or a method group a call that returns tasks was
+    /// given: <c>new[] { a.ShouldBeNone(), b.ShouldBeNone() }</c>, <c>ids.Select(id =&gt; Find(id).ShouldBeNone())</c>,
+    /// <c>pending.Select(OptionAssertions.ShouldBeNone)</c>, <c>ids.Select(async id =&gt; await Find(id).ShouldBeNone())</c>.
+    /// An assertion assigned or discarded in it keeps its own task, and one awaited fails only the
+    /// <c>async</c> lambda it is in, which is handed on in its place. Each comes with the depth
+    /// <see cref="HandsOn"/> finds it at.
+    /// </summary>
+    private static IEnumerable<(IOperation Assertion, string Name, int Depth)> MadeAssertions(IOperation value, Tasks tasks)
+    {
+        foreach (var operation in value.DescendantsAndSelf())
+        {
+            var method = operation switch
+            {
+                IInvocationOperation call            => call.TargetMethod,
+                IMethodReferenceOperation reference => reference.Method,
+                _                                   => null,
+            };
+
+            if (method is not null && IsPendingAssertion(method, tasks) && HandsOn(operation, value, method, tasks) is { } depth) yield return (operation, method.Name, depth);
+        }
+    }
+
+    /// <summary>
+    /// How deep <paramref name="root"/> holds the failure of <paramref name="operation"/>'s assertion, or
+    /// <see langword="null"/> where it is not handed on, or observed on the way: 0 where root's task faults with
+    /// it, as a <c>WhenAll</c>'s or a <c>Run</c>'s does; one more for each task that completes with it as a value
+    /// instead, a <c>WhenAny</c>'s or a <c>WhenEach</c>'s, or an <c>async</c> lambda's that returns it; one fewer
+    /// for each <c>await</c> on the way that unwraps such a task. An <c>await</c> of the faulting task fails the
+    /// <c>async</c> lambda it is in, which is followed in its place.
+    /// </summary>
+    private static int? HandsOn(IOperation operation, IOperation root, IMethodSymbol assertion, Tasks tasks)
+    {
+        var depth = 0;
+
+        for (var current = operation; !ReferenceEquals(current, root);)
+        {
+            var parent = current.Parent!;
+
+            // await Task.WhenAny(pending.ShouldBeNone(), …) completes with the assertion's task, still unobserved;
+            // await pending.ShouldBeNone() fails the async lambda it is in, unless a catch on the way keeps the failure.
+            if (parent is IAwaitOperation)
+            {
+                if (depth > 0)
+                {
+                    depth--;
+                    current = parent;
+                }
+                else if (EnclosingAsyncFunction(current, root, assertion) is { } function) current = function;
+                else return null;
+
+                continue;
+            }
+
+            var handsOn = parent switch
+            {
+                IConversionOperation or IConditionalOperation or ICoalesceOperation or ISwitchExpressionArmOperation or ISwitchExpressionOperation => true,
+                IArrayInitializerOperation or IArrayCreationOperation or ICollectionExpressionOperation or IArgumentOperation                     => true,
+                IReturnOperation or IBlockOperation or IAnonymousFunctionOperation or IDelegateCreationOperation or ITranslatedQueryOperation     => true,
+                IInvocationOperation call when ReferenceEquals(call.Instance, current)                                                              => tasks.PassesOn(call),
+                IInvocationOperation call                                                                                                           => tasks.HoldsTasks(call.Type),
+                _                                                                                                                                   => false,
+            };
+
+            if (!handsOn) return null;
+
+            // async () => Task.WhenAny(…) and Task.WhenAny(…) complete with the tasks they were given.
+            if (parent is IAnonymousFunctionOperation { Symbol.IsAsync: true }
+             || parent is IInvocationOperation combinator && !ReferenceEquals(combinator.Instance, current) && tasks.PassesOnFailure(combinator.TargetMethod) == false)
+                depth++;
+
+            current = parent;
+        }
+
+        return depth;
+    }
+
+    /// <summary>
+    /// The <c>async</c> lambda or anonymous method inside <paramref name="root"/> that <paramref name="operation"/>
+    /// fails, with no <c>catch</c> between them that keeps the failure of <paramref name="assertion"/> (<see cref="Keeps"/>).
+    /// A <c>catch</c> keeps only what its <c>try</c> block throws, not what its handlers or its <c>finally</c> do.
+    /// </summary>
+    private static IOperation? EnclosingAsyncFunction(IOperation operation, IOperation root, IMethodSymbol assertion)
+    {
+        for (IOperation? child = operation, current = operation.Parent; current is not null && !ReferenceEquals(current, root); child = current, current = current.Parent)
+        {
+            switch (current)
+            {
+                case ITryOperation attempt when ReferenceEquals(child, attempt.Body) && attempt.Catches.Any(clause => Keeps(clause, assertion)):
+                    return null;
+                case IAnonymousFunctionOperation function:
+                    return function.Symbol.IsAsync ? function : null;
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Whether <paramref name="clause"/> takes the failure of <paramref name="assertion"/> and keeps it: its type can
+    /// hold the <c>TypeKitAssertionException</c> the assertion throws, and its handler can complete, where
+    /// <c>catch { throw; }</c>, a log and <c>throw;</c>, or a <c>throw new …</c> hand the failure on. A constant
+    /// <c>false</c> filter leaves the handler unreachable, so it never completes either. A filter that is no
+    /// constant, <c>when (Expected(e))</c>, may take it and counts as taking it: an Error reports only a failure that
+    /// is lost whatever the filter answers.
+    /// </summary>
+    private static bool Keeps(ICatchClauseOperation clause, IMethodSymbol assertion)
+    {
+        if (TypeKitSymbols.AssertionException(assertion.ContainingAssembly) is { } thrown && !IsOrDerivesFrom(thrown, clause.ExceptionType)) return false;
+
+        return clause.Handler is not { Syntax: BlockSyntax handler, SemanticModel: { } model }
+            || model.AnalyzeControlFlow(handler) is not { Succeeded: true, EndPointIsReachable: false, ExitPoints.IsEmpty: true };
+    }
+
+    private static bool IsOrDerivesFrom(ITypeSymbol? type, ITypeSymbol? ancestor)
+    {
+        for (; type is not null; type = type.BaseType)
+        {
+            if (SymbolEqualityComparer.Default.Equals(type, ancestor)) return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// An assertion of CodoMetis.TypeKit.Testing on a <c>Task</c> or <c>ValueTask</c> of the value it
+    /// asserts on, <c>await service.FindAsync(id).ShouldBeSome()</c>: it awaits the value and fails the
+    /// test through the task it returns, so that task dropped unawaited passes whatever the value is.
+    /// It is judged as every dropped call is, through <see cref="Producers"/>: passed through
+    /// <c>ConfigureAwait</c> or <c>WaitAsync</c>, or reached through a branch of a conditional, a
+    /// <c>??</c> or a <c>switch</c> expression. Every such assertion is new in 2.3, so reporting its drop
+    /// breaks no build that worked before (design/adr/0118).
+    /// </summary>
+    private static bool IsPendingAssertion(IMethodSymbol method, Tasks tasks) =>
+        TypeKitSymbols.IsTestingAssembly(method.ContainingAssembly)
+     && (method.ReducedFrom ?? method).Parameters is { Length: > 0 } parameters
+     && tasks.Awaited(parameters[0].Type) is not null;
+
     /// <summary>
     /// The calls whose values <paramref name="operation"/> drops as one: the call itself, or each
     /// branch's call of a conditional or a <c>switch</c> expression, through implicit conversions,
@@ -195,6 +361,10 @@ private static IEnumerable<IInvocationOperation> Producers(IOperation operation,
         if ((symbols.OutcomeName(type) ?? tasks.PendingOutcome(type, symbols)) is { } outcome)
             return ReturnsItsStoredReceiver(invocation, symbols, tasks) ? null : outcome;
 
+        // Task.WhenEach(first.CancelAsync(), second.CancelAsync()) yields the tasks it was given, results and all.
+        if (tasks.PassesOnFailure(invocation.TargetMethod) == false && tasks.SequenceOutcome(type, symbols) is { } element)
+            return DroppedHolder($"sequence of {element}s", invocation, symbols, tasks);
+
         return DroppedHolder(tasks.HolderOutcome(type, symbols) ?? tasks.HolderOutcome(tasks.Awaited(type), symbols), invocation, symbols, tasks);
     }
 
@@ -251,6 +421,21 @@ private static void AnalyzeConversion(OperationAnalysisContext context, TypeKitS
         var toPlainTask = SymbolEqualityComparer.Default.Equals(conversion.Type, tasks.Plain);
         if (!toPlainTask && !tasks.HoldsPlainTasks(conversion.Type)) return;
 
+        // Task.WaitAll(new[] { first.CancelAsync(), second.CancelAsync() }) converts the array of tasks whole:
+        // each element's call is converted as if alone.
+        if (!toPlainTask && Unwrap(conversion.Operand) is IArrayCreationOperation { Initializer.ElementValues: var elements })
+        {
+            foreach (var element in elements)
+            foreach (var invocation in Producers(element, tasks))
+            {
+                if (ReturnsItsStoredReceiver(invocation, symbols, tasks) || tasks.PendingOutcome(invocation.Type, symbols) is not { } pending) continue;
+
+                context.Report(Diagnostic.Create(Rule, invocation.Syntax.GetLocation(), pending, invocation.TargetMethod.Name));
+            }
+
+            return;
+        }
+
         // The call, or each branch's call where a conditional or a switch expression was converted whole.
         // A pass-through between the conversion and the call, LoadAsync().WaitAsync(t), is reported whole.
         var passedOn = tasks.PassedOn(conversion.Operand);
@@ -258,9 +443,11 @@ private static void AnalyzeConversion(OperationAnalysisContext context, TypeKitS
         foreach (var invocation in Producers(conversion.Operand, tasks))
         {
             // held.TapAsync(log) returns the task of a result the caller still holds.
+            // Task Check() => Task.WhenAny(a.ShouldBeNone(), b.ShouldBeNone()); is awaited as a task that never faults.
             var outcome = toPlainTask
                 ? (ReturnsItsStoredReceiver(invocation, symbols, tasks) ? null : tasks.PendingOutcome(invocation.Type, symbols))
                ?? DroppedHolder(tasks.HolderOutcome(tasks.Awaited(invocation.Type), symbols), invocation, symbols, tasks)
+               ?? DroppedAssertion(invocation, awaited: true, tasks)
                 : DroppedCollection(tasks.PendingOutcome(tasks.ElementOfSequence(invocation.Type), symbols), invocation, symbols, tasks);
 
             if (outcome is null) continue;
@@ -274,40 +461,70 @@ private static void AnalyzeConversion(OperationAnalysisContext context, TypeKitS
     /// <c>Wait</c> on a task of a result, or of a collection of results, that the expression made:
     /// <c>orders.CancelAsync(id).Wait()</c> blocks until the result exists and hands it to nobody,
     /// whether the statement drops what <c>Wait</c> returns or an <c>if</c> reads it. A task still held,
-    /// or a tap on one, keeps its result.
+    /// or a tap on one, keeps its result. Each branch of a conditional, a <c>??</c> or a <c>switch</c>
+    /// expression is its own call, as in a dropped statement. <c>Wait</c> on a <c>Task.WhenAny</c> of
+    /// assertions waits for the first and never sees a failure, and so does <c>Task.WaitAny</c>.
     /// </summary>
     private static void AnalyzeWait(OperationAnalysisContext context, TypeKitSymbols symbols, Tasks tasks)
     {
         var wait = (IInvocationOperation)context.Operation;
 
-        if (wait.TargetMethod is not { Name: "Wait", IsStatic: false } method || !SymbolEqualityComparer.Default.Equals(method.ContainingType, tasks.Plain)) return;
-        if (wait.Instance is null || tasks.PassedOn(wait.Instance) is not IInvocationOperation invocation) return;
+        if (wait.TargetMethod is not { Name: "Wait" or "WaitAny" } method || !SymbolEqualityComparer.Default.Equals(method.ContainingType, tasks.Plain)) return;
 
-        if (ReturnsItsStoredReceiver(invocation, symbols, tasks)) return;
+        // Task.WaitAny(a.ShouldBeNone(), b.ShouldBeNone()) returns an index and leaves every failure
+        // unobserved; Task.WaitAll throws them. Tasks of results are its conversions' (AnalyzeConversion).
+        if (method.IsStatic)
+        {
+            if (method.Name != "WaitAny") return;
 
-        var outcome = tasks.PendingOutcome(invocation.Type, symbols)
-                   ?? DroppedHolder(tasks.HolderOutcome(tasks.Awaited(invocation.Type), symbols), invocation, symbols, tasks);
-        if (outcome is null) return;
+            foreach (var argument in wait.Arguments.Where(argument => argument.Parameter?.Ordinal == 0))
+            foreach (var (assertion, name, _) in MadeAssertions(argument.Value, tasks))
+                context.Report(Diagnostic.Create(Rule, assertion.Syntax.GetLocation(), "Task", name));
+
+            return;
+        }
 
-        context.Report(Diagnostic.Create(Rule, wait.Syntax.GetLocation(), outcome, invocation.TargetMethod.Name));
+        if (method.Name != "Wait" || wait.Instance is null) return;
+
+        // The task's own call is reported at the Wait, each branch's call at the branch.
+        var passedOn = tasks.PassedOn(wait.Instance);
+
+        foreach (var invocation in Producers(wait.Instance, tasks))
+        {
+            if (ReturnsItsStoredReceiver(invocation, symbols, tasks)) continue;
+
+            var outcome = tasks.PendingOutcome(invocation.Type, symbols)
+                       ?? DroppedHolder(tasks.HolderOutcome(tasks.Awaited(invocation.Type), symbols), invocation, symbols, tasks)
+                       ?? DroppedAssertion(invocation, awaited: true, tasks);
+            if (outcome is null) continue;
+
+            context.Report(Diagnostic.Create(Rule, (ReferenceEquals(invocation, passedOn) ? wait : invocation).Syntax.GetLocation(), outcome, invocation.TargetMethod.Name));
+        }
     }
 
     /// <summary>
     /// A <c>foreach</c> or <c>await foreach</c> over results, or tasks of them, that its header made,
     /// whose body never reads the iteration variable: <c>await foreach (var outcome in
-    /// orders.CancelEachAsync(ids)) { }</c> runs every cancellation and drops every result. A variable
+    /// orders.CancelEachAsync(ids)) { }</c> runs every cancellation and drops every result. So does one
+    /// over assertions the header made, <c>Task.WhenEach</c> of them or a <c>Select</c>, whose failures nobody
+    /// sees. A variable
     /// named <c>_</c> says the drop is intended; a collection held in a variable, a parameter or a field
     /// keeps its results.
     /// </summary>
     private static void AnalyzeLoop(OperationAnalysisContext context, TypeKitSymbols symbols, Tasks tasks)
     {
         if (context.Operation is not IForEachLoopOperation { LoopControlVariable: IVariableDeclaratorOperation { Symbol: { Name: not "_" } variable } } loop) return;
-        if ((symbols.OutcomeName(variable.Type) ?? tasks.PendingOutcome(variable.Type, symbols)) is not { } outcome) return;
-        if (Unwrap(loop.Collection) is not IInvocationOperation invocation || !MadeResults(invocation, symbols, tasks)) return;
+        if (Unwrap(loop.Collection) is not IInvocationOperation invocation) return;
+
+        // foreach (var check in pending.Select(p => p.ShouldBeNone())) { } makes every assertion and observes none.
+        var outcome = (symbols.OutcomeName(variable.Type) ?? tasks.PendingOutcome(variable.Type, symbols)) is { } element
+            ? MadeResults(invocation, symbols, tasks) ? $"sequence of {element}s" : null
+            : tasks.IsTask(variable.Type) && MadeAssertions(invocation, tasks).Any() ? $"sequence of {variable.Type.Name}s" : null;
+        if (outcome is null) return;
 
         if (loop.Body.Descendants().OfType<ILocalReferenceOperation>().Any(reference => SymbolEqualityComparer.Default.Equals(reference.Local, variable))) return;
 
-        context.Report(Diagnostic.Create(Rule, invocation.Syntax.GetLocation(), $"sequence of {outcome}s", invocation.TargetMethod.Name));
+        context.Report(Diagnostic.Create(Rule, invocation.Syntax.GetLocation(), outcome, invocation.TargetMethod.Name));
     }
 
     /// <summary>
@@ -368,7 +585,8 @@ private static IOperation Unwrap(IOperation operation) =>
     /// <summary>
     /// A call that returns its receiver unchanged, on a receiver the caller still holds: the
     /// outcome's own <c>Tap</c>, <c>TapAsync</c>, <c>TapError</c> and <c>TapErrorAsync</c>, and the
-    /// <c>Task</c> continuations <c>TapAsync</c> and <c>TapErrorAsync</c>, which return the task's result as it was.
+    /// <c>Task</c> continuations <c>TapAsync</c> and <c>TapErrorAsync</c>, which return the task's result as it was;
+    /// and <c>Task.WhenAny</c> of tasks the caller still holds, which completes with one of them.
     /// </summary>
     private static bool ReturnsItsStoredReceiver(IInvocationOperation invocation, TypeKitSymbols symbols, Tasks tasks)
     {
@@ -382,9 +600,22 @@ private static bool ReturnsItsStoredReceiver(IInvocationOperation invocation, Ty
         if (method.Name is "TapAsync" or "TapErrorAsync" && symbols.IsDeclaredByResultClass(method))
             return IsStored(invocation.Instance ?? invocation.Arguments.FirstOrDefault(argument => argument.Parameter?.Ordinal == 0)?.Value, symbols, tasks);
 
+        // Task.WhenAny(first, second) completes with one of the tasks it was given, results and all.
+        if (tasks.PassesOnFailure(method) == false)
+            return invocation.Arguments.All(argument => Elements(argument.Value).All(element => IsStored(element, symbols, tasks)));
+
         return false;
     }
 
+    /// <summary>The elements of an array or a collection written out, such as a <c>params</c> argument's, or the value itself.</summary>
+    private static IEnumerable<IOperation> Elements(IOperation value) =>
+        Unwrap(value) switch
+        {
+            IArrayCreationOperation { Initializer.ElementValues: var elements } => elements,
+            ICollectionExpressionOperation { Elements: var elements }           => elements,
+            var other                                                           => [other],
+        };
+
     /// <summary>
     /// Whether the caller still holds <paramref name="receiver"/>: a local, a parameter or a field; a
     /// tap that returned such a receiver, so that <c>r.Tap(log).TapError(warn)</c> holds at every link;
@@ -429,16 +660,40 @@ public IOperation PassedOn(IOperation operation)
         }
 
         /// <summary>
-        /// <c>ConfigureAwait</c> and <c>WaitAsync</c> of <c>Task&lt;T&gt;</c> or <c>ValueTask&lt;T&gt;</c>,
-        /// every overload: each completes with the task's own result and makes none.
+        /// <c>ConfigureAwait</c> and <c>WaitAsync</c> of <c>Task</c>, <c>Task&lt;T&gt;</c> or
+        /// <c>ValueTask&lt;T&gt;</c>, every overload: each completes as the task does, with its own result,
+        /// and makes none. A plain <c>Task</c> carries no result, but it can be the one an assertion of
+        /// CodoMetis.TypeKit.Testing returns (<see cref="IsPendingAssertion"/>).
         /// </summary>
         public bool PassesOn(IInvocationOperation call) =>
             call.TargetMethod is { IsStatic: false, Name: "ConfigureAwait" or "WaitAsync" } method
          && (SymbolEqualityComparer.Default.Equals(method.ContainingType.OriginalDefinition, generic)
-          || SymbolEqualityComparer.Default.Equals(method.ContainingType.OriginalDefinition, genericValueTask));
+          || SymbolEqualityComparer.Default.Equals(method.ContainingType.OriginalDefinition, genericValueTask)
+          || SymbolEqualityComparer.Default.Equals(method.ContainingType, Plain));
+
+        /// <summary>
+        /// For a method that hands on the tasks it is given: <see langword="true"/> for <c>Task.WhenAll</c> and
+        /// <c>Task.Run</c>, whose task faults when one of them has; <see langword="false"/> for
+        /// <c>Task.WhenAny</c>, whose task completes with the first and never faults, and <c>Task.WhenEach</c>,
+        /// which yields them as they complete, faulted or not; <see langword="null"/> for any other method.
+        /// </summary>
+        public bool? PassesOnFailure(IMethodSymbol method) =>
+            method is { IsStatic: true, Name: "WhenAll" or "WhenAny" or "WhenEach" or "Run" } && SymbolEqualityComparer.Default.Equals(method.ContainingType, Plain)
+                ? method.Name is "WhenAll" or "Run"
+                : null;
+
+        /// <summary>Whether a value of <paramref name="type"/> is a task, or a collection or a sequence of them.</summary>
+        public bool HoldsTasks(ITypeSymbol? type) =>
+            IsTask(type) || IsTask(ElementOfSequence(type));
 
-        /// <summary>A <c>Task</c> or <c>ValueTask</c> of a result, not awaited: the result is dropped with it.</summary>
-        public string? PendingOutcome(ITypeSymbol? type, TypeKitSymbols symbols) => symbols.OutcomeName(Awaited(type));
+        public bool IsTask(ITypeSymbol? type) => SymbolEqualityComparer.Default.Equals(type, Plain) || Awaited(type) is not null;
+
+        /// <summary>
+        /// A <c>Task</c> or <c>ValueTask</c> of a result, not awaited: the result is dropped with it. So is a task
+        /// of one, such as the <c>Task&lt;Task&lt;Result&lt;…&gt;&gt;&gt;</c> of <c>Task.WhenAny</c>, which completes
+        /// with a task of a result.
+        /// </summary>
+        public string? PendingOutcome(ITypeSymbol? type, TypeKitSymbols symbols) => symbols.OutcomeName(Awaited(type)) ?? symbols.OutcomeName(Awaited(Awaited(type)));
 
         /// <summary>What a <c>Task&lt;T&gt;</c> or <c>ValueTask&lt;T&gt;</c> completes with, or <see langword="null"/> for any other type.</summary>
         public ITypeSymbol? Awaited(ITypeSymbol? type) =>
diff --git a/src/CodoMetis.TypeKit.Analyzers/README.md b/src/CodoMetis.TypeKit.Analyzers/README.md
index 88816f9c..b78e309d 100644
--- a/src/CodoMetis.TypeKit.Analyzers/README.md
+++ b/src/CodoMetis.TypeKit.Analyzers/README.md
@@ -28,13 +28,13 @@ project. The two packages share a version and move together.
 |---|---|---|
 | CMTK0001 | Error | `default`, `default(T)`, `new T()`, `new()` and `new T { }` of a value object, an `Option`, a `Result`, or a struct marked `[RequireCustomInitialization]`. Also through a type parameter whose constraints make it one of those. Not reported: a default that is only compared (`id == default`, `id.Equals(default)`, `ThrowIfEqual(id, default)`, `Assert.NotEqual(default, id)`), which is a guard, and one assigned to an `out` parameter of a Try method that returns `bool`. |
 | CMTK0002 | Error | A type implements `IValue<T>`, `IValidatedValue<,,>` or `IClosedSet<TSelf>`, but the compilation doesn't reference `CodoMetis.TypeKit.Generators`. So nothing is generated for it: no field, no `Value`, no factory, or for a closed set no name and no `Match`. |
-| CMTK0003 | Error | A `Result` or `Option` that a call returns, or a collection or a tuple of them that the statement made, dropped. It counts as dropped as a statement, awaited or not; when its `Task` is converted to a plain `Task`, also where a method group is the conversion; through `Wait`; in a loop that never reads it; and in a branch of a conditional, a `switch` expression or a `??` that picked the call. `_` says you mean the drop. |
+| CMTK0003 | Error | A `Result` or `Option` that a call returns, or a collection or a tuple of them that the statement made, dropped. It counts as dropped as a statement, awaited or not; when its `Task` is converted to a plain `Task`, also where a method group is the conversion; through `Wait`; in a loop that never reads it; and in a branch of a conditional, a `switch` expression or a `??` that picked the call. Also an assertion of `CodoMetis.TypeKit.Testing` on a task, left without `await`. `_` says you mean the drop. |
 | CMTK0004 | Error | `Materialize`, which rebuilds a value object without its rules, called or referenced anywhere but the EF Core package. |
 | CMTK0005 | Warning | An array or span of a value object, `Option`, `Result` or `[RequireCustomInitialization]` struct created with a length, so every slot starts as `default`. A constant length of zero isn't reported. |
 | CMTK0006 | Warning | A field or auto-property of such a type, in a class, that no initializer, `required` or constructor sets. Also a `required` one that a `[SetsRequiredMembers]` constructor doesn't set. |
 | CMTK0007 | Info | `FromKnownGood` given a value that comes straight from a parameter. |
 | CMTK0008 | Warning | The values inside two different value objects compared, `order.CustomerId.Value == product.Id.Value`, or the two value objects themselves compared through `Equals(object)`. |
-| CMTK0009 | Warning | A call that returns the `default` of such a type when it finds nothing: `FirstOrDefault()`, `GetValueOrDefault()`, `Option<T>.OrDefault()` and their kind. |
+| CMTK0009 | Warning | A call that returns the `default` of such a type when it finds nothing: `FirstOrDefault()`, `GetValueOrDefault()`, `Option<T>.OrDefault()` and their kind. Also `FirstOrNone`, `SingleOrNone` or `FirstOrError` on a query given a delegate, which reads every row. |
 | CMTK0010 | Error | A type argument that breaks a constraint its parameter declares by attribute: `[Abstract]`, `[Sealed]`, `[Record]`, `[Concrete]`, `[Interface]`, `[Unsealed]`, `[ValueObject]`, `[ClosedSet]`, `[FlagsEnum]` or `[ReadOnlyStruct]`. Also a pair of arguments for two parameters marked `[Distinct]` or `[Unrelated]` that are one type, or related by inheritance, implementation or boxing, reported once at the later argument. Checked at any closed use, written or inferred: a base type, a member, a parameter, a local, a `typeof`, an attribute, a call or a method group, a member of a generic extension block, whose arguments the receiver gives, and a method the compiler calls for a `foreach`, an `await`, a deconstruction, a positional pattern or a collection expression (there, `[Abstract]`, `[Sealed]`, `[Record]` and `[Concrete]` join in 3.0.0). A type parameter passed on without the attribute is a breach too. A method that implements an interface's method, or overrides one, carries the constraint of what it implements, a static one and one a base class declares included. |
 | CMTK0011 | Error | A concrete class that derives from or implements a type marked `[RequireParameterlessConstructor]`, directly or through another, without a parameterless constructor of the accessibility it asks for. A struct is never reported: its parameterless constructor is public and can be nothing else. The code fix writes or changes the constructor. |
 | CMTK0012 | Error | A closed set's `Match` given an argument by position. It binds to whichever member is declared at that place, so reordering the members swaps the branches. The code fix names every argument. |
@@ -47,6 +47,9 @@ them.
 
 Every rule also runs in `.razor` and `.cshtml` files (see [Generated code](#generated-code-and-razor)).
 
+One code fix answers the compiler instead of a rule: [Add Create](#add-create) writes the `Create` a
+validated value object is missing.
+
 ## CMTK0001
 
 A `default` value object wraps `default(T)` and passed no rule. A `default` result is neither a
@@ -136,7 +139,8 @@ it as they treat a value object.
 A value object in a project without the generators would compile with nothing in it. This rule turns
 that into an error.
 
-The generators apply through a transitive project fabric, not an attribute on the interfaces, which
+The generators are built on [Metalama](https://postsharp.net/metalama), which generates C# code at
+compile time from templates written in C#. They apply through a transitive project fabric, not an attribute on the interfaces, which
 keeps the base package free of Metalama. The price is that a project that sees the interfaces but
 not the generators compiles a value object with nothing in it, silently. A closed set fails to
 compile there anyway, on the interface members nobody implemented, and the rule says why.
@@ -182,6 +186,29 @@ call's: `await orders.CancelAsync(id).ConfigureAwait(false);` is reported, namin
 explicit cast, to `Task` or to the delegate type, says you mean the drop. A `ValueTask<T>` has no
 conversion to `ValueTask`.
 
+**Assertions on a task.** An assertion of `CodoMetis.TypeKit.Testing` on a `Task` or `ValueTask`,
+such as `service.FindAsync(id).ShouldBeSome()`, fails the test only through the task it returns.
+Left without `await`, the test passes whatever the task holds, and C# warns only in an `async`
+method. CMTK0003 reports the line, naming the assertion. It also reports an assertion passed through
+`ConfigureAwait` or `WaitAsync`, and one in a branch of a `?:`, `??` or `switch` expression, as it does
+for a dropped result. The rule knows these assertions by the package's own assembly, so an extension of
+yours on a pending result is left alone.
+
+Handing assertions on doesn't hide them either. You get the report when you hand assertions to
+`Task.WhenAll`, `Task.Run` or `Task.WhenEach` and drop what it returns. You get it for `Task.WhenAny` and
+`Task.WaitAny` of them even when you wait, because those finish with the first task and never show a
+failure. It covers an array of them, a `Select`, a query, an `async` lambda that awaits one, and a method
+group such as `pending.Select(OptionAssertions.ShouldBeNone)`. `Task.WaitAll` throws the failures, so it is
+silent. So is a loop over assertions that reads each one.
+
+Nesting doesn't hide them. A `Task.WhenAny` inside a `Task.WhenAll` or a `Task.Run` is reported even when you
+await the outer task, because that task succeeds with the failed assertion as its value:
+`await Task.WhenAll(Task.WhenAny(first.ShouldBeNone(), second.ShouldBeNone()))` passes while both assertions
+fail. `await await Task.WhenAny(…)` throws the first failure, so it is silent. A `catch` around an awaited
+assertion in an `async` lambda hides the failure only when it can keep it. A `catch` that throws again, one for
+another exception, such as `catch (OperationCanceledException)`, and one with a `when (false)` filter are
+reported. A filter the rule can't work out, such as `when (Expected(e))`, counts as catching the failure.
+
 **Collections.** A collection of results is dropped as silently as one result:
 
 ```csharp
@@ -226,10 +253,16 @@ await foreach (var _ in orders.CancelEachAsync(ids)) { }         // a variable n
 ```
 
 - **`Wait`** is reported on a task the expression made, whether the statement drops the `bool` a
-  timeout overload returns or an `if` reads it.
+  timeout overload returns or an `if` reads it. On a `?:`, `??` or `switch` expression, each branch's
+  call is reported, as when you drop it.
 - **`Task.WaitAll` and `Task.WaitAny`** take plain tasks. So tasks of results that the statement made
-  are converted and their results dropped, as one task's conversion is. An explicit cast to the plain
-  tasks' type says you mean that drop.
+  are converted and their results dropped, as one task's conversion is. That includes an array you
+  write in the call, `Task.WaitAll(new[] { orders.CancelAsync(first), orders.CancelAsync(second) })`. An
+  explicit cast to the plain tasks' type says you mean that drop.
+- **`Task.WhenAny`** finishes with one of the tasks you give it, so every other result is lost. A
+  `WhenAny` of tasks the statement made is reported whether you drop it, await it, wait for it or return
+  it as a plain `Task`. Of tasks you still hold, it hands back one of yours, and is silent.
+- **`Task.WhenEach`** of tasks the statement made, dropped, is reported as a sequence of results.
 - **A `foreach` or `await foreach`** is reported when its header made the results, by the rule above,
   and its body never reads the iteration variable.
 
@@ -399,6 +432,44 @@ ordinary value. EF Core's forms are recognised in any project that references EF
 It's a warning, because code that checks the sequence isn't empty first is correct, and the rule
 can't tell.
 
+### A condition that reads every row
+
+CMTK0009 also warns when a lookup on a query would read the whole table:
+
+```csharp
+Func<Order, bool> isOpen = o => o.Open;
+var first = db.Orders.FirstOrNone(isOpen);           // CMTK0009: binds to the IEnumerable<T> overload and reads every row
+var found = db.Orders.FirstOrNone(o => o.Open);      // the database runs the condition and returns one row
+```
+
+`FirstOrNone`, `SingleOrNone` and `FirstOrError` on an `IQueryable<T>` take the condition as an
+`Expression<Func<T, bool>>`, which the database runs. A delegate is no expression. So the call binds to
+the overload on `IEnumerable<T>`, which reads every row and runs the condition in memory. The rule
+reports that call, and its message names the overload it fell to.
+
+Reported, on any receiver that is a query (`IQueryable<T>`, a `DbSet<T>`, a type parameter constrained
+to one), when the condition is:
+
+- a `Func<T, bool>` in a variable, a parameter, a field or a property;
+- a method group, such as `IsOpen`;
+- an anonymous method, `delegate (Order o) { ... }`;
+- a call that returns a `Func`, or a lambda cast to one.
+
+`LastOrNone` and `LastOrError` are reported as well. On a query they don't compile with a lambda, and a
+delegate there reads every row in the same way.
+
+To fix it, write the condition as a lambda at the call, or hold it as an `Expression<Func<T, bool>>`.
+To read every row on purpose, call `AsEnumerable()` first, and the rule stays silent.
+
+**Good to know**
+
+- **A query held as an `IEnumerable<T>` is a sequence to the rule.** Once your code converts it, the
+  rule can't tell that a query is underneath, so `IEnumerable<Order> all = db.Orders;` followed by
+  `all.FirstOrNone(isOpen)` isn't reported.
+- **There is no code fix.** The fix depends on your condition. A method group wrapped in a lambda
+  binds to the query's overload, but the database can't run your method, so EF Core throws when the
+  query runs.
+
 ## CMTK0010
 
 Put an attribute on a type parameter to ask for what C# can't, such as an abstract or a sealed type.
@@ -661,6 +732,23 @@ The members are read from the enum itself, so a member that a newer base package
 here too. An enum of your application's own isn't this rule's job. A fault that no member names is
 rejected where `ToHttpResult()` turns it into a response, and `WithRule` throws for one.
 
+## Add Create
+
+A type that declares `IValidatedValue<TSelf, T, TFault>` and has no `Create` fails to build with CS0535.
+The package's fix for that error, **Add Create**, writes the method for you, as the [Generators
+README](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.Generators/README.md#declare-a-value-object)
+shows. It accepts every value until you add your rules. The types are spelled as your file names them,
+so a type from a namespace the file doesn't import is qualified. `Create` goes in as the type's first
+member, indented as the other members are. A declaration that ends in `;` gets a body.
+
+The fix isn't offered in these cases:
+
+- **`TSelf` is another type.** The value to return isn't this type's to build.
+- **The type already has a `Create` that takes a `T`**, static or not. A second one wouldn't compile, so
+  correct the one that's there.
+- **The type's body is on one line and already holds members.** Put the body on lines of its own, and the
+  fix is offered.
+
 ## Configuration
 
 You set a rule's severity in `.editorconfig`, as usual: `dotnet_diagnostic.CMTK0001.severity = warning`.
@@ -691,11 +779,28 @@ but a suppression to say so:
 - a sequence known not to be empty (CMTK0009);
 - a comparison of two identities that really are shared (CMTK0008).
 
-**What a new version may change.** Within a major version, an Error never reports more than it did.
-A new Error rule, or an Error that reports more, waits for the next major version. A Warning or an
-Info may learn more forms in a minor version, such as another method that returns a default instance
-for CMTK0009. In a build that treats warnings as errors, such an update can report code that built
-before, as a newer compiler's warnings can.
+**What a new version may change.** Within a major version, an update never makes an Error report code
+that built before. A new Error rule, or an Error that reports more of the code you could already write,
+waits for the next major version. A minor version may teach an Error a form that only its own new API can
+write. In 2.3.0, CMTK0003 reports a `CodoMetis.TypeKit.Testing` assertion on a `Task` or `ValueTask` left
+without `await`, and those assertions are new in 2.3.0. Your code from before the update can't contain
+one, so it builds as before.
+
+2.3.0 makes an exception for a few forms that code from before 2.3.0 can contain. Each one loses every
+result, so the build points at a real bug. CMTK0003 now also reports these, for tasks of results:
+
+- `Task.WhenAny` of tasks you don't hold, dropped, awaited, waited for or returned as a plain `Task`;
+- a `Task.WhenEach` of them that you drop;
+- `Wait()` on a `?:`, `??` or `switch` expression of them;
+- an array of them that you write in a `Task.WaitAll` or `Task.WaitAny` call.
+
+Handle the results, or discard what you mean to drop with `_ =`. Only a gap found before a version's tag
+is closed this way. After the tag, an Error that reports more of the code you could already write waits
+for the next major version.
+
+A Warning or an Info may learn more forms in a minor version, such as another method that returns a
+default instance for CMTK0009. In a build that treats warnings as errors, such an update can report code
+that built before, as a newer compiler's warnings can.
 
 ## Generated code and Razor
 
diff --git a/src/CodoMetis.TypeKit.Analyzers/TypeKitSymbols.cs b/src/CodoMetis.TypeKit.Analyzers/TypeKitSymbols.cs
index 93f02155..6952b38d 100644
--- a/src/CodoMetis.TypeKit.Analyzers/TypeKitSymbols.cs
+++ b/src/CodoMetis.TypeKit.Analyzers/TypeKitSymbols.cs
@@ -52,6 +52,12 @@ internal sealed class TypeKitSymbols
     /// </summary>
     private const string GeneratorsAssembly = "CodoMetis.TypeKit.Generators";
 
+    /// <summary>
+    /// The assembly of the test assertions, whose assertions on a pending value fail a test only through
+    /// the task they return. This is the package's own identity, which a consumer cannot rename.
+    /// </summary>
+    private const string TestingAssembly = "CodoMetis.TypeKit.Testing";
+
     private const string Materialize = "Materialize";
 
     private readonly ImmutableArray<INamedTypeSymbol> _valueMarkers;
@@ -108,6 +114,16 @@ private TypeKitSymbols(
         _computeRestriction          = ComputeRestriction;
     }
 
+    /// <summary>The exception every assertion of CodoMetis.TypeKit.Testing fails with, by its metadata name in that assembly.</summary>
+    private const string AssertionExceptionName = "CodoMetis.TypeKit.Testing.TypeKitAssertionException";
+
+    /// <summary>Whether <paramref name="assembly"/> is CodoMetis.TypeKit.Testing.</summary>
+    public static bool IsTestingAssembly(IAssemblySymbol? assembly) =>
+        assembly is not null && string.Equals(assembly.Name, TestingAssembly, StringComparison.Ordinal);
+
+    /// <summary>The exception the assertions of <paramref name="testing"/>, CodoMetis.TypeKit.Testing, fail with.</summary>
+    public static INamedTypeSymbol? AssertionException(IAssemblySymbol testing) => testing.GetTypeByMetadataName(AssertionExceptionName);
+
     /// <summary>Whether the compilation references CodoMetis.TypeKit.Generators.</summary>
     public bool ReferencesGenerators { get; }
 
@@ -256,10 +272,15 @@ private static IEnumerable<UsingDirectiveSyntax> UsingsOf(SyntaxNode node) =>
     /// declares, in both forms a call can bind to: the extension block's member, which
     /// <c>option.OrDefault()</c> binds to, and its implementation, which <c>Option.OrDefault(option)</c> binds to.
     /// </summary>
-    public IEnumerable<IMethodSymbol> OptionClassMethods(string name) =>
-        _optionClasses.SelectMany(type => type.GetMembers(name)
-                                              .Concat(type.GetTypeMembers().Where(nested => nested.IsExtension).SelectMany(block => block.GetMembers(name))))
-                      .OfType<IMethodSymbol>();
+    public IEnumerable<IMethodSymbol> OptionClassMethods(string name) => ClassMethods(_optionClasses, name);
+
+    /// <summary>The methods named <paramref name="name"/> that the package's <c>Result</c> static class declares, as <see cref="OptionClassMethods"/> finds them.</summary>
+    public IEnumerable<IMethodSymbol> ResultClassMethods(string name) => ClassMethods(_resultClasses, name);
+
+    private static IEnumerable<IMethodSymbol> ClassMethods(ImmutableArray<INamedTypeSymbol> classes, string name) =>
+        classes.SelectMany(type => type.GetMembers(name)
+                                       .Concat(type.GetTypeMembers().Where(nested => nested.IsExtension).SelectMany(block => block.GetMembers(name))))
+               .OfType<IMethodSymbol>();
 
     private static bool IsDeclaredBy(IMethodSymbol method, ImmutableArray<INamedTypeSymbol> classes)
     {
diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs
index f9919a21..1aa6711f 100644
--- a/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs
+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs
@@ -31,11 +31,12 @@ namespace CodoMetis.TypeKit.AspNetCore;
 public sealed class FaultProblem<TFault> : IResult, IEndpointMetadataProvider
     where TFault : notnull
 {
-    internal FaultProblem(TFault fault, string? detail = null, string? rule = null)
+    internal FaultProblem(TFault fault, string? detail = null, string? rule = null, Exception? cause = null)
     {
         Fault = fault;
         Detail = detail;
         Rule = rule;
+        Cause = cause;
     }
 
     /// <summary>The fault this response reports.</summary>
@@ -47,6 +48,12 @@ internal FaultProblem(TFault fault, string? detail = null, string? rule = null)
     /// <summary>The rule that refused, <c>EmailFault.NoAt</c>, where the result carried a <see cref="Fault{TFault}"/> naming one.</summary>
     public string? Rule { get; }
 
+    /// <summary>
+    /// The exception that caused the fault, where the result carried a <see cref="Fault{TFault}"/> with one
+    /// (<see cref="Fault{TFault}.Cause"/>): for the log, and never written into the problem.
+    /// </summary>
+    public Exception? Cause { get; }
+
     /// <inheritdoc />
     public async Task ExecuteAsync(HttpContext httpContext)
     {
@@ -64,15 +71,17 @@ public async Task ExecuteAsync(HttpContext httpContext)
 
         var status = endpoint is not null ? FaultStatuses.Override(endpoint.Metadata, Fault, responses.Type) ?? answer.Status : answer.Status;
         var name = httpContext.RequestServices.GetService<IOptions<FaultResponseOptions>>()?.Value.QualifiedFaultNames == true ? answer.QualifiedName : answer.Name;
-        var detail = Detail ?? answer.Description;
+        // A withheld name takes the member's description with it, which names the member as surely.
+        var detail = answer.Named ? Detail ?? answer.Description : Detail;
 
         // Present only while this problem is written, so a CustomizeProblemDetails that reads it sees it
         // for this problem and for no other the request writes.
         var features = httpContext.Features;
         var previous = features.Get<IFaultFeature>();
-        features.Set<IFaultFeature>(new FaultFeature(typeof(TFault), Fault, name, detail, Rule));
-        var extensions = new Dictionary<string, object?> { [FaultResponsesOperationTransformer.FaultMember] = name };
-        if (Rule is not null) extensions[FaultResponsesOperationTransformer.RuleMember] = Rule;
+        features.Set<IFaultFeature>(new FaultFeature(typeof(TFault), Fault, name, detail, Rule, !answer.Named, Cause));
+        var extensions = new Dictionary<string, object?>();
+        if (answer.Named) extensions[FaultResponsesOperationTransformer.FaultMember] = name;
+        if (answer.Named && Rule is not null) extensions[FaultResponsesOperationTransformer.RuleMember] = Rule;
         try
         {
             await TypedResults.Problem(
@@ -103,7 +112,7 @@ static void IEndpointMetadataProvider.PopulateMetadata(MethodInfo method, Endpoi
         builder.Metadata.Add(FaultResponsesMetadata<TFault>.Instance);
     }
 
-    private sealed record FaultFeature(Type FaultType, object Fault, string Name, string? Detail, string? Rule) : IFaultFeature;
+    private sealed record FaultFeature(Type FaultType, object Fault, string Name, string? Detail, string? Rule, bool NameWithheld, Exception? Cause) : IFaultFeature;
 }
 
 /// <summary>
@@ -120,7 +129,10 @@ public interface IFaultFeature
     /// <summary>The fault: the enum member or the closed set's member.</summary>
     object Fault { get; }
 
-    /// <summary>The name the problem's <c>fault</c> member carries, qualified where the host asks for it.</summary>
+    /// <summary>
+    /// The name the problem's <c>fault</c> member carries, qualified where the host asks for it, or would carry
+    /// where the mapping withholds it (<see cref="NameWithheld"/>).
+    /// </summary>
     string Name { get; }
 
     /// <summary>The problem's <c>detail</c>, or <see langword="null"/>.</summary>
@@ -129,6 +141,22 @@ public interface IFaultFeature
     /// <summary>The problem's <c>rule</c>, the rule that refused (<see cref="Fault{TFault}.Rule"/>), or <see langword="null"/>.</summary>
     /// <remarks>Implemented by default as <see langword="null"/>, so an implementation of the host's own, a test's, still builds.</remarks>
     string? Rule => null;
+
+    /// <summary>
+    /// Whether the mapping withholds the fault's name from the problem (<c>FaultResponse.WithoutFaultName()</c>):
+    /// the problem then has no <c>fault</c> and no <c>rule</c>, and a <c>CustomizeProblemDetails</c> that writes
+    /// <see cref="Name"/> or <see cref="Rule"/> into it tells the client what the mapping keeps from it.
+    /// </summary>
+    /// <remarks>Implemented by default as <see langword="false"/>, so an implementation of the host's own still builds.</remarks>
+    bool NameWithheld => false;
+
+    /// <summary>
+    /// The exception that caused the fault (<see cref="Fault{TFault}.Cause"/>), or <see langword="null"/>: for
+    /// the host's log. The problem never carries it, and a <c>CustomizeProblemDetails</c> that copies it into
+    /// one tells the client what failed underneath.
+    /// </summary>
+    /// <remarks>Implemented by default as <see langword="null"/>, so an implementation of the host's own, a test's, still builds.</remarks>
+    Exception? Cause => null;
 }
 
 /// <summary>How <c>ToHttpResult()</c> writes a problem: <c>services.Configure&lt;FaultResponseOptions&gt;(options =&gt; …)</c>.</summary>
diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponse.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponse.cs
index fac2b51d..a6779f05 100644
--- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponse.cs
+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponse.cs
@@ -20,11 +20,12 @@ namespace CodoMetis.TypeKit.AspNetCore;
 /// </remarks>
 public sealed class FaultResponse
 {
-    private FaultResponse(int statusCode, Uri? type, string? title)
+    private FaultResponse(int statusCode, Uri? type, string? title, bool namesFault = true)
     {
         StatusCode = statusCode;
         Type = type;
         Title = title;
+        NamesFault = namesFault;
     }
 
     /// <summary>The HTTP status.</summary>
@@ -36,6 +37,12 @@ private FaultResponse(int statusCode, Uri? type, string? title)
     /// <summary>The problem's <c>title</c>, or <see langword="null"/> for the status's own.</summary>
     public string? Title { get; }
 
+    /// <summary>
+    /// Whether the problem names the fault in its <c>fault</c> member, and the rule that refused in its
+    /// <c>rule</c>. True unless <see cref="WithoutFaultName"/> withholds them.
+    /// </summary>
+    public bool NamesFault { get; }
+
     /// <summary>A response with <paramref name="statusCode"/>, and the status's own <c>type</c> and <c>title</c>.</summary>
     /// <param name="statusCode">The HTTP status, 400 to 599, checked where the faults are mapped.</param>
     /// <returns>The response.</returns>
@@ -76,7 +83,7 @@ private FaultResponse(int statusCode, Uri? type, string? title)
     public FaultResponse WithType(Uri type)
     {
         ArgumentNullException.ThrowIfNull(type);
-        return new(StatusCode, type, Title);
+        return new(StatusCode, type, Title, NamesFault);
     }
 
     /// <summary>
@@ -93,9 +100,29 @@ public FaultResponse WithType(Uri type)
     public FaultResponse WithTitle(string title)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(title);
-        return new(StatusCode, Type, title);
+        return new(StatusCode, Type, title, NamesFault);
     }
 
+    /// <summary>
+    /// The same response without the fault's name, for faults a client must not tell apart: a sign-in's
+    /// <c>fault => FaultResponse.Status(401).WithoutFaultName()</c> answers an unknown user and a wrong
+    /// password alike.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The problem has no <c>fault</c> and no <c>rule</c> member, and its <c>detail</c> is only what the
+    /// occurrence says (<see cref="Fault{TFault}.Detail"/>): a fault set member's description, which
+    /// otherwise stands in for it, names the member as surely as its name does. Two members answered so,
+    /// with the same status, <c>type</c> and <c>title</c>, write the same problem but for the detail the
+    /// application wrote. The host still sees the fault, through <c>IFaultFeature</c>, to log it.
+    /// </para>
+    /// <para>
+    /// The document says it: a response whose every fault withholds its name is described as naming none.
+    /// </para>
+    /// </remarks>
+    /// <returns>A new response.</returns>
+    public FaultResponse WithoutFaultName() => new(StatusCode, Type, Title, namesFault: false);
+
     /// <summary>A bare status as a response, so a mapping can return <c>404</c> where it needs nothing else.</summary>
     /// <param name="statusCode">The HTTP status.</param>
     public static implicit operator FaultResponse(int statusCode) => Status(statusCode);
diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
index 45c20b08..5c6ba8d7 100644
--- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
@@ -124,7 +124,7 @@ public static FaultResponses<TFault> Map(FaultType<TFault> type, Func<TFault, Fa
                     "A fault is answered as problem details; a success is the value of the Result." + FaultRefusals.Mapping,
                     parameter);
 
-            answers[fault] = new Answer(response.StatusCode, response.Type is { } problemType ? FaultResponse.Written(problemType) : null, response.Title, type.NameOf(fault), type.QualifiedNameOf(fault), FaultType<TFault>.DescriptionOf(fault));
+            answers[fault] = new Answer(response.StatusCode, response.Type is { } problemType ? FaultResponse.Written(problemType) : null, response.Title, type.NameOf(fault), type.QualifiedNameOf(fault), FaultType<TFault>.DescriptionOf(fault), response.NamesFault);
         }
 
         return new FaultResponses<TFault>(type, answers);
@@ -155,6 +155,14 @@ [.. AnsweredBy(endpointMetadata).Where(fault => StatusOf(fault, endpointMetadata
                                         .OfType<string>()
                                         .Distinct()];
 
+    /// <summary>
+    /// Whether a member the endpoint answers with <paramref name="status"/> names its fault: <see langword="true"/>
+    /// where one does, <see langword="false"/> where every one withholds it, <see langword="null"/> where none
+    /// is answered with it.
+    /// </summary>
+    public bool? NamesAt(int status, IReadOnlyList<object> endpointMetadata) =>
+        AnsweredBy(endpointMetadata).Where(fault => StatusOf(fault, endpointMetadata) == status).Select(fault => (bool?)_answers[fault].Named).Max();
+
     /// <summary>The members an endpoint answers with: every member, but those its metadata leaves out.</summary>
     public IEnumerable<TFault> AnsweredBy(IReadOnlyList<object> endpointMetadata) =>
         Type.Members.Where(fault => FaultExclusions.Excluding(endpointMetadata, fault, Type) is null);
@@ -178,7 +186,7 @@ public static InvalidOperationException Unmapped() =>
     /// The mapped answer for one member: what the problem says, before an endpoint changes its status. Its
     /// <c>Type</c> is the problem's <c>type</c> as the response and the document write it (<see cref="FaultResponse.Written"/>).
     /// </summary>
-    internal sealed record Answer(int Status, string? Type, string? Title, string Name, string QualifiedName, string? Description);
+    internal sealed record Answer(int Status, string? Type, string? Title, string Name, string QualifiedName, string? Description, bool Named);
 }
 
 /// <summary>
@@ -197,6 +205,9 @@ internal abstract class FaultResponsesMetadata
     /// <summary>The problem types listed for <paramref name="status"/>.</summary>
     public abstract IReadOnlyList<string> Types(IServiceProvider services, int status, IReadOnlyList<object> endpointMetadata);
 
+    /// <summary>Whether a member answered with <paramref name="status"/> names its fault (<see cref="FaultResponses{TFault}.NamesAt"/>).</summary>
+    public abstract bool? NamesAt(IServiceProvider services, int status, IReadOnlyList<object> endpointMetadata);
+
     /// <summary>
     /// What is wrong with the endpoint's declarations for this fault type: a status or a member left out that
     /// names no member.
@@ -211,8 +222,8 @@ internal abstract class FaultResponsesMetadata
     public abstract IEnumerable<(IFaultDeclaration Status, string Member, string Message)> StatusesLeftOut(IServiceProvider services, IReadOnlyList<object> endpointMetadata);
 
     /// <summary>
-    /// The name and the qualified name of each member the endpoint answers with, those it leaves out aside, or
-    /// none where the host mapped no status.
+    /// The name and the qualified name of each member the endpoint answers with and names in the problem, those it
+    /// leaves out and those whose name it withholds aside, or none where the host mapped no status.
     /// </summary>
     public abstract IEnumerable<(string Name, string QualifiedName)> Names(IServiceProvider services, IReadOnlyList<object> endpointMetadata);
 }
@@ -233,6 +244,9 @@ private FaultResponsesMetadata() { }
     public override IReadOnlyList<string> Types(IServiceProvider services, int status, IReadOnlyList<object> endpointMetadata) =>
         Responses(services)?.TypesOf(status, endpointMetadata) ?? [];
 
+    public override bool? NamesAt(IServiceProvider services, int status, IReadOnlyList<object> endpointMetadata) =>
+        Responses(services)?.NamesAt(status, endpointMetadata);
+
     public override IEnumerable<string> Problems(IServiceProvider services, IReadOnlyList<object> endpointMetadata)
     {
         if (Responses(services) is not { } responses) yield break;
@@ -264,7 +278,7 @@ public override IEnumerable<string> Problems(IServiceProvider services, IReadOnl
 
     public override IEnumerable<(string Name, string QualifiedName)> Names(IServiceProvider services, IReadOnlyList<object> endpointMetadata) =>
         Responses(services) is { } responses
-            ? responses.AnsweredBy(endpointMetadata).Select(fault => (responses.Type.NameOf(fault), responses.Type.QualifiedNameOf(fault)))
+            ? responses.AnsweredBy(endpointMetadata).Where(fault => responses.Of(fault).Named).Select(fault => (responses.Type.NameOf(fault), responses.Type.QualifiedNameOf(fault)))
             : [];
 
     private static FaultResponses<TFault>? Responses(IServiceProvider services) => FaultResponses<TFault>.Of(services);
diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
index 8e936ee6..50f033f1 100644
--- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
@@ -89,6 +89,7 @@ public async Task TransformAsync(OpenApiOperation operation, OpenApiOperationTra
         // Every fault type the endpoint answers with, a Fault<T1, T2>'s each: a status two of them share is one
         // response, which lists the problem types of both, and the statuses come in ascending order.
         var answered = new SortedDictionary<int, List<string>>();
+        var named = new HashSet<int>();
         foreach (var metadata in endpointMetadata.OfType<FaultResponsesMetadata>().Distinct())
         {
             var statuses = metadata.Statuses(context.ApplicationServices, endpointMetadata)
@@ -100,6 +101,7 @@ public async Task TransformAsync(OpenApiOperation operation, OpenApiOperationTra
             {
                 if (!answered.TryGetValue(status, out var types)) answered[status] = types = [];
                 types.AddRange(metadata.Types(context.ApplicationServices, status, endpointMetadata).Except(types, StringComparer.Ordinal).ToList());
+                if (metadata.NamesAt(context.ApplicationServices, status, endpointMetadata) == true) named.Add(status);
             }
         }
 
@@ -122,7 +124,7 @@ public async Task TransformAsync(OpenApiOperation operation, OpenApiOperationTra
                     touched = true;
                     foreach (var schema in schemas) WithFault(schema, Qualified(context));
                     if (string.IsNullOrEmpty(response.Description) || response.Description == ReasonPhrases.GetReasonPhrase(status))
-                        response.Description = Description(status, types);
+                        response.Description = Description(status, types, named.Contains(status));
                 }
 
                 continue;
@@ -131,7 +133,7 @@ public async Task TransformAsync(OpenApiOperation operation, OpenApiOperationTra
             problem ??= await ProblemSchemaAsync(context, cancellationToken);
             operation.Responses[key] = new OpenApiResponse
             {
-                Description = Description(status, types),
+                Description = Description(status, types, named.Contains(status)),
                 Content = new Dictionary<string, OpenApiMediaType> { ["application/problem+json"] = new() { Schema = problem } },
             };
             touched = true;
@@ -195,10 +197,19 @@ private static (int Status, int Range) Rank(string key) =>
         return schemas;
     }
 
-    private static string Description(int status, List<string> types) =>
-        types.Count == 0
+    /// <summary>
+    /// The status's reason phrase, the problem types where the mapping gives any, and, where every fault
+    /// answered with the status withholds its name, that the problem names none: the shared schema's
+    /// <c>fault</c> is optional, and the description says which responses never carry it.
+    /// </summary>
+    private static string Description(int status, List<string> types, bool named) =>
+        (types.Count == 0
             ? ReasonPhrases.GetReasonPhrase(status)
-            : $"{ReasonPhrases.GetReasonPhrase(status)}. Problem types: {string.Join(", ", types)}";
+            : $"{ReasonPhrases.GetReasonPhrase(status)}. Problem types: {string.Join(", ", types)}")
+      + (named ? "" : $". {WithheldDescription}");
+
+    /// <summary>What a response's description says where every fault answered with its status withholds its name.</summary>
+    internal const string WithheldDescription = "The problem names no fault.";
 
     private static bool Qualified(OpenApiOperationTransformerContext context) =>
         context.ApplicationServices.GetService<IOptions<FaultResponseOptions>>()?.Value.QualifiedFaultNames == true;
diff --git a/src/CodoMetis.TypeKit.AspNetCore/README.md b/src/CodoMetis.TypeKit.AspNetCore/README.md
index 0428cc4a..231481f0 100644
--- a/src/CodoMetis.TypeKit.AspNetCore/README.md
+++ b/src/CodoMetis.TypeKit.AspNetCore/README.md
@@ -98,29 +98,20 @@ element schema, so `Quantity` gets no component at all, and both parameters are
   name, and describes both as the first it meets. A name your own `CreateSchemaReferenceId` gives,
   set before `AddTypeKit()`, is kept. So give one of them its own name there, or rename one.
 
-  To have value objects inlined instead, return `null` for them, the nullable ones included, after
-  `AddTypeKit()`:
+  To have value objects described in place instead, with no component of their own, turn on
+  `InlineValueObjects`: `options.AddTypeKit(typeKit => typeKit.InlineValueObjects = true)`.
+  [Describe value objects as plain types](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/docs/aspnet-core.md#describe-value-objects-as-plain-types)
+  shows the document you get.
 
-  ```csharp
-  using System.Reflection;
-  using CodoMetis.TypeKit.CompilerServices;   // GeneratedValueObjectAttribute, on every value object
-
-  options.AddTypeKit();
-  options.CreateSchemaReferenceId = type =>
-      (Nullable.GetUnderlyingType(type.Type) ?? type.Type).GetCustomAttribute<GeneratedValueObjectAttribute>() is not null
-          ? null
-          : OpenApiOptions.CreateDefaultSchemaReferenceId(type);
-  ```
-
-  Inlined, a nullable value object or closed set allows null in its own schema, wherever a
-  referenced one allows it around its reference. A closed set's property is then the enum of its
-  names plus null.
+  Inlined, a nullable value object allows null in its own schema, wherever a referenced one allows it
+  around its reference. Closed sets keep their components with the setting. A host that inlines them
+  with its own `CreateSchemaReferenceId` gets a closed set's property as the enum of its names plus null.
 
   OpenAPI 2.0 can't put null around a reference. ASP.NET writes a nullable property of any component as
   `{"allOf":[{"x-nullable":true}]}` there, without the reference. So under 2.0 a nullable value-object
   property loses its type, where the underlying type's nullable property keeps it. A nullable element of
-  a list or a dictionary loses its type the same way, since it's the component or null too. Inline value
-  objects if your 2.0 document needs it.
+  a list or a dictionary loses its type the same way, since it's the component or null too. Turn on
+  `InlineValueObjects` if your 2.0 document needs it.
 
 - **Put rules in `Create`, not on the property.** A validation attribute on a value-object property
   (`[MaxLength]`, `[Range]`) ends up in the value object's shared component, as ASP.NET does for any
@@ -439,6 +430,35 @@ document stay the error's.
   error's name, the rule is your application's vocabulary. So give rule types distinct names, for
   instance by nesting a rule in its value object: `Email.Rule.Blank`.
 
+### What failed underneath
+
+When an exception causes the error, keep it in the `Fault<TFault>` as its cause. Your log gets the
+exception, and the client gets the same problem as before:
+
+```csharp
+Result<Account, Fault<AccountFault>> saved = Result.Catch<Account, UniqueViolationException>(() => store.Save(account))
+    .MapError(e => Fault.Of(AccountFault.EmailTaken, "Another account took the address a moment ago.", e));
+```
+
+`IFaultFeature.Cause` hands the exception to your `CustomizeProblemDetails`, so you can log it with
+the response it led to:
+
+```csharp
+builder.Services.AddProblemDetails(options => options.CustomizeProblemDetails = context =>
+{
+    if (context.HttpContext.Features.Get<IFaultFeature>() is { Cause: { } cause } fault)
+        context.HttpContext.RequestServices.GetRequiredService<ILoggerFactory>().CreateLogger("Faults")
+            .LogWarning(cause, "Answered {Fault} for an exception", fault.Name);   // your log gets the exception, the client doesn't
+});
+```
+
+- **The cause stays out of the response.** The problem has the same members with a cause as without
+  one, and names neither the exception's type nor its message. If your `CustomizeProblemDetails`
+  copies it into the problem, the client learns what failed underneath.
+- **`FaultProblem<TFault>.Cause`** holds it too, for a test or a filter that reads the result before
+  it's written.
+- **It's one exception, not a chain.** An `AggregateException` is fine as the cause.
+
 ### Faults of several types
 
 Some rejections mean the same on every route: a change that raced the request, or a version that
@@ -601,7 +621,7 @@ works in the same place. A `Result<TError>` takes a factory without a value:
 ### What the host adds to a problem
 
 While `ToHttpResult()` writes a problem, the request carries an `IFaultFeature`. It holds the error
-type, the error, the name the problem gives it, its detail and its rule. Your
+type, the error, the name the problem gives it, its detail, its rule and its cause. Your
 `CustomizeProblemDetails` reads it to add what the package doesn't name. No other problem the request
 writes has it.
 
@@ -655,6 +675,24 @@ Both causes then get the same answer: status, `type`, `title`, `fault` and `deta
 its two errors for its own use, such as a log or a lockout count. A `Fault<TFault>`'s detail stays
 behind with them.
 
+Or keep the domain's errors all the way, and leave their name out of the response.
+`WithoutFaultName()` in the mapping does that, for the members you choose or for every one:
+
+```csharp
+builder.Services.AddFaultResponses<SignInFault>(_ => FaultResponse.Status(StatusCodes.Status401Unauthorized).WithoutFaultName());
+
+app.MapPost("/login", (Credentials credentials) => accounts.SignIn(credentials).ToHttpResult());   // no fault, no rule
+```
+
+- **The problem says nothing of the member**: no `fault`, no `rule`, and no fault set member's
+  description as its `detail`. A detail you write on the `Fault<TFault>` still goes out, so keep it
+  the same for both.
+- **Give them the same `type` and `title`**, or those tell them apart instead.
+- **Your host still sees the fault.** `IFaultFeature` carries its name, and `NameWithheld` says the
+  mapping keeps it from the client, so don't copy it into the problem in `CustomizeProblemDetails`.
+- **The document says it.** A response whose every fault withholds its name ends its description with
+  "The problem names no fault."
+
 ## NodaTime
 
 ASP.NET can't see through NodaTime's JSON converters. Once they're on the host's JSON options, it
diff --git a/src/CodoMetis.TypeKit.AspNetCore/TypeKitHttpResultExtensions.cs b/src/CodoMetis.TypeKit.AspNetCore/TypeKitHttpResultExtensions.cs
index 6df36fb1..efbe6b09 100644
--- a/src/CodoMetis.TypeKit.AspNetCore/TypeKitHttpResultExtensions.cs
+++ b/src/CodoMetis.TypeKit.AspNetCore/TypeKitHttpResultExtensions.cs
@@ -97,7 +97,7 @@ public static Results<Ok<T>, FaultProblem<TFault>> ToHttpResult<T, TFault>(this
         where TFault : notnull =>
         result.Match<Results<Ok<T>, FaultProblem<TFault>>>(
             static value => TypedResults.Ok(value),
-            static fault => new FaultProblem<TFault>(fault.Reason, fault.Detail, fault.Rule));
+            static fault => new FaultProblem<TFault>(fault.Reason, fault.Detail, fault.Rule, fault.Cause));
 
     /// <summary>A success as <c>204 No Content</c>; a fault as problem details for its reason, with its detail.</summary>
     /// <param name="result">The outcome of the operation the endpoint ran.</param>
@@ -106,7 +106,7 @@ public static Results<NoContent, FaultProblem<TFault>> ToHttpResult<TFault>(this
         where TFault : notnull =>
         result.Match<Results<NoContent, FaultProblem<TFault>>>(
             static () => TypedResults.NoContent(),
-            static fault => new FaultProblem<TFault>(fault.Reason, fault.Detail, fault.Rule));
+            static fault => new FaultProblem<TFault>(fault.Reason, fault.Detail, fault.Rule, fault.Cause));
 
     /// <summary>A success as the response <paramref name="success"/> makes of its value; a fault as problem details for its reason, with its detail.</summary>
     /// <param name="result">The outcome of the operation the endpoint ran.</param>
@@ -118,7 +118,7 @@ public static Results<NoContent, FaultProblem<TFault>> ToHttpResult<TFault>(this
         where TSuccess : IResult
     {
         ArgumentNullException.ThrowIfNull(success);
-        return result.Match<Results<TSuccess, FaultProblem<TFault>>>(value => success(value), static fault => new FaultProblem<TFault>(fault.Reason, fault.Detail, fault.Rule));
+        return result.Match<Results<TSuccess, FaultProblem<TFault>>>(value => success(value), static fault => new FaultProblem<TFault>(fault.Reason, fault.Detail, fault.Rule, fault.Cause));
     }
 
     /// <summary>A success as the response <paramref name="success"/> makes; a fault as problem details for its reason, with its detail.</summary>
@@ -130,7 +130,7 @@ public static Results<NoContent, FaultProblem<TFault>> ToHttpResult<TFault>(this
         where TSuccess : IResult
     {
         ArgumentNullException.ThrowIfNull(success);
-        return result.Match<Results<TSuccess, FaultProblem<TFault>>>(() => success(), static fault => new FaultProblem<TFault>(fault.Reason, fault.Detail, fault.Rule));
+        return result.Match<Results<TSuccess, FaultProblem<TFault>>>(() => success(), static fault => new FaultProblem<TFault>(fault.Reason, fault.Detail, fault.Rule, fault.Cause));
     }
 
     /// <summary>A success as <c>200 OK</c> with its value; a fault of either type as problem details for its reason, with its detail.</summary>
@@ -249,7 +249,7 @@ public static Results<NoContent, FaultProblem<T1>, FaultProblem<T2>, FaultProble
             static fault => fault.Match<Results<TSuccess, FaultProblem<T1>, FaultProblem<T2>, FaultProblem<T3>>>(static f => Problem(f), static f => Problem(f), static f => Problem(f)));
     }
 
-    private static FaultProblem<TFault> Problem<TFault>(Fault<TFault> fault) where TFault : notnull => new(fault.Reason, fault.Detail, fault.Rule);
+    private static FaultProblem<TFault> Problem<TFault>(Fault<TFault> fault) where TFault : notnull => new(fault.Reason, fault.Detail, fault.Rule, fault.Cause);
 }
 
 /// <summary>Turns a <c>Result</c> whose fault is a closed set into the HTTP response an endpoint returns, as <see cref="TypeKitHttpResultExtensions"/> does for an enum.</summary>
diff --git a/src/CodoMetis.TypeKit.AspNetCore/TypeKitOpenApiOptions.cs b/src/CodoMetis.TypeKit.AspNetCore/TypeKitOpenApiOptions.cs
new file mode 100644
index 00000000..0d545900
--- /dev/null
+++ b/src/CodoMetis.TypeKit.AspNetCore/TypeKitOpenApiOptions.cs
@@ -0,0 +1,19 @@
+namespace CodoMetis.TypeKit.AspNetCore;
+
+/// <summary>How <c>AddTypeKit()</c> describes value objects: <c>options.AddTypeKit(typeKit =&gt; …)</c>.</summary>
+public sealed class TypeKitOpenApiOptions
+{
+    /// <summary>
+    /// Whether every value object is described in place, by its wrapped type's schema, rather than as a component
+    /// named after it: as a property, a request or response body, a list's or a dictionary's elements, a parameter,
+    /// and below any of them. The document then holds no component of a value object, and a nullable one admits null
+    /// in its own schema, as a nullable property of the wrapped type does. Off by default: each value object keeps its
+    /// component.
+    /// </summary>
+    /// <remarks>
+    /// A closed set and the type a value object wraps (an enum, a record) keep the component ASP.NET gives them. A
+    /// <see cref="Microsoft.AspNetCore.OpenApi.OpenApiOptions.CreateSchemaReferenceId"/> of the host's own set before
+    /// <c>AddTypeKit</c> still names every other type; one set after it replaces this, as it replaces the naming.
+    /// </remarks>
+    public bool InlineValueObjects { get; set; }
+}
diff --git a/src/CodoMetis.TypeKit.AspNetCore/TypeKitOpenApiOptionsExtensions.cs b/src/CodoMetis.TypeKit.AspNetCore/TypeKitOpenApiOptionsExtensions.cs
index 3fefa91c..cfc39515 100644
--- a/src/CodoMetis.TypeKit.AspNetCore/TypeKitOpenApiOptionsExtensions.cs
+++ b/src/CodoMetis.TypeKit.AspNetCore/TypeKitOpenApiOptionsExtensions.cs
@@ -45,11 +45,29 @@ public static class TypeKitOpenApiOptionsExtensions
     /// </remarks>
     /// <param name="options">The options of one OpenAPI document.</param>
     /// <returns>The same options.</returns>
-    public static OpenApiOptions AddTypeKit(this OpenApiOptions options)
+    public static OpenApiOptions AddTypeKit(this OpenApiOptions options) => AddTypeKit(options, static _ => { });
+
+    /// <summary>
+    /// Describes every value object in the document with the schema of the type it wraps, as
+    /// <see cref="AddTypeKit(OpenApiOptions)"/> does, with the settings <paramref name="configure"/> chooses.
+    /// </summary>
+    /// <remarks>
+    /// With <see cref="TypeKitOpenApiOptions.InlineValueObjects"/>, a value object is written in place wherever it
+    /// appears, and no component is named after one. Without a setting, the document is the one
+    /// <see cref="AddTypeKit(OpenApiOptions)"/> writes.
+    /// </remarks>
+    /// <param name="options">The options of one OpenAPI document.</param>
+    /// <param name="configure">Chooses the settings.</param>
+    /// <returns>The same options.</returns>
+    public static OpenApiOptions AddTypeKit(this OpenApiOptions options, Action<TypeKitOpenApiOptions> configure)
     {
         ArgumentNullException.ThrowIfNull(options);
+        ArgumentNullException.ThrowIfNull(configure);
+
+        var settings = new TypeKitOpenApiOptions();
+        configure(settings);
 
-        ValueObjectSchemaReferenceIds.Apply(options);
+        ValueObjectSchemaReferenceIds.Apply(options, settings.InlineValueObjects);
         PatchSchemaTransformer.Apply(options);
 
         return options.AddSchemaTransformer<ValueObjectSchemaTransformer>()
diff --git a/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaReferenceIds.cs b/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaReferenceIds.cs
index c26af7c0..f129a3fb 100644
--- a/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaReferenceIds.cs
+++ b/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaReferenceIds.cs
@@ -7,7 +7,7 @@ namespace CodoMetis.TypeKit.AspNetCore;
 /// Names a nested value object's or closed set's component after its whole nesting chain:
 /// <c>Shop.Id</c> is <c>ShopId</c>, as its generated companion class is <c>ShopIdExtensions</c>, and
 /// <c>Order.Status</c> is <c>OrderStatus</c>. Refuses a document in which such a name is also another
-/// type's.
+/// type's. With <see cref="TypeKitOpenApiOptions.InlineValueObjects"/>, gives a value object no component.
 /// </summary>
 /// <remarks>
 /// <para>
@@ -33,19 +33,27 @@ namespace CodoMetis.TypeKit.AspNetCore;
 /// documents are two sets of components. A type's name is the same on every call, so a document
 /// generated again, or two generated at once, claim the same names.
 /// </para>
+/// <para>
+/// Inlined, a value object, or the <see cref="Nullable{T}"/> of one, has no name whatever the host's own delegate
+/// says, so it claims none: two value objects of one name can no longer share a component, and a closed set or any
+/// other type keeps its name and its claim as before
+/// ([decision 115](design/adr/0115-value-objects-can-be-inlined-everywhere.md)).
+/// </para>
 /// </remarks>
 internal static class ValueObjectSchemaReferenceIds
 {
-    public static void Apply(OpenApiOptions options)
+    public static void Apply(OpenApiOptions options, bool inlineValueObjects)
     {
         var inner = options.CreateSchemaReferenceId;
         var claims = new ConcurrentDictionary<string, Claim>(StringComparer.Ordinal);
 
         options.CreateSchemaReferenceId = type =>
         {
+            var claimant = Nullable.GetUnderlyingType(type.Type) ?? type.Type;
+            if (inlineValueObjects && ValueObjectTypes.IsValueObject(claimant)) return null;
+
             if (inner(type) is not { } id) return null;
 
-            var claimant = Nullable.GetUnderlyingType(type.Type) ?? type.Type;
             var renamed = claimant.IsNested
                        && (ValueObjectTypes.IsValueObject(claimant) || ClosedSetSchemaTransformer.Describe(claimant) is not null)
                        && id == OpenApiOptions.CreateDefaultSchemaReferenceId(type);
diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/README.md b/src/CodoMetis.TypeKit.EntityFrameworkCore/README.md
index 1e56ef6f..47641fc3 100644
--- a/src/CodoMetis.TypeKit.EntityFrameworkCore/README.md
+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/README.md
@@ -87,8 +87,9 @@ Server it's an identity column, so switching an `int` key to a value object chan
 Where the provider has no identity for the type, the key isn't generated, just as a plain one isn't.
 On PostgreSQL, for example, a `ulong` is a `numeric(20,0)`, which can't be an identity.
 
-There are two exceptions. EF picks the generator that fills a value object's key at `Add` by the
-column's type, not by the underlying type:
+At `Add`, a key that is generated gets the same temporary value a plain key of the underlying type
+gets, also where the column is of another type, such as the `decimal` that holds a `ulong`. HiLo and a
+value generator of your own still come first. There are two exceptions:
 
 - **A key over `char` is yours to assign.** It's never generated, on any provider, because none
   generates a `char` key. PostgreSQL rejects an identity on `character(1)`, SQLite an `AUTOINCREMENT`
@@ -97,10 +98,13 @@ column's type, not by the underlying type:
   value, but it doesn't check that you set a meaningful one. A default key, `'\0'`, is stored as it
   is, and a second such row fails on the primary key. `ValueGeneratedOnAdd()` or a value generator of
   your own on the property still applies.
-- **A default key over `ulong` throws at `Add` where the column is a `decimal`** (SQL Server,
-  PostgreSQL). EF's temporary value for the column is a negative `decimal`, and converting it back
-  throws `OverflowException`. A plain `ulong` key gets a temporary `ulong` instead. Configure
-  `ValueGeneratedNever()` on such a key and assign it.
+- **A default key over `ulong` can still throw at `Add`** where the column is a `decimal` (SQL
+  Server, PostgreSQL), in two cases. One is a compiled model made with `dotnet ef dbcontext optimize
+  --nativeaot`, which writes each column's mapping out as code and loses what gives the key a
+  temporary `ulong`. The other is a key you configure with `ValueObjectConverter` yourself. EF's
+  temporary value for the column is then a negative `decimal`, and converting it back throws
+  `OverflowException`. Otherwise the key gets a temporary `ulong`, as a plain one does. In those two
+  cases, configure `ValueGeneratedNever()` on the key and assign it.
 
 A key over a `Guid` is yours to assign, `Id = OrderId.New()` (a version 7 Guid, which sorts by
 creation time), and EF inserts it as given. To have EF generate it instead, configure
@@ -212,9 +216,34 @@ instead, which works everywhere and may add a cast:
   and stays allowed. A query filter (`HasQueryFilter`, named or not) that does the same fails when
   the model is built, naming the entity type, since it applies to every query of that type.
 
-The mapping is tested on SQLite and PostgreSQL. The SQL of each translation is pinned on PostgreSQL,
-every family of underlying types makes a round trip through a real PostgreSQL, and key generation is
-also checked in SQL Server's model.
+### On SQL Server
+
+A value object behaves on SQL Server as the type inside it does there. That isn't always how it
+behaves in memory:
+
+- **Text compares ignoring case.** Under SQL Server's default collation, `o.Note == note`,
+  `notes.Contains(o.Note)` and `StartsWith` also match text that differs in case or in trailing
+  spaces. `OrderBy` sorts ignoring case too. In memory, a value object over text equals only the same
+  text, exactly. Where case matters, give the column a binary collation:
+  `UseCollation("Latin1_General_BIN2")`.
+- **Guids sort by their last group.** SQL Server orders a `uniqueidentifier` by its last six bytes
+  first. So `OrderBy`, `<` and `Min` over Guids come out in another order than in memory.
+- **A `decimal` without a precision is a `decimal(18,2)`.** It reads back with two decimal places:
+  `10m` comes back as `10.00m`, which is equal but prints `10.00`. More decimal places are rounded
+  when the value is written. Configure the precision you need, on the property with `HasPrecision`
+  or for every such value object with `configurationBuilder.Properties<Amount>().HavePrecision(18, 4)`.
+- **A `TimeSpan` must be shorter than a day.** It's stored as `time`. A longer one fails
+  `SaveChanges` in a column. In a JSON column it's stored, but a query that reads it gets another
+  value, `01:02:00` for `1.02:00:00`, without an error. Store a longer duration as a number instead,
+  such as a value object over the seconds as a `long`.
+- **`EF.Functions.Greatest` and `Least` need compatibility level 160.** Configure it with
+  `UseSqlServer(connectionString, sql => sql.UseCompatibilityLevel(160))`. Below it, EF refuses them.
+- **A `DateTime` comes back without its kind.** `datetime2` keeps every tick, and a UTC value reads
+  back with `Kind` `Unspecified`. It's still equal to the value you wrote.
+
+The mapping is tested on SQLite, PostgreSQL and SQL Server. The SQL of each translation is pinned on
+PostgreSQL. Every family of underlying types makes a round trip through a real PostgreSQL and a real
+SQL Server, and every query and key shape of the test catalogue runs on the real SQL Server too.
 
 ## An Option for nothing found
 
@@ -237,8 +266,10 @@ These ask the database for one row and let it run the condition:
 - **The condition must be an expression.** A lambda written at the call is one. A
   `Func<Order, bool>` held in a variable, or a method group, binds `FirstOrNone`, `SingleOrNone` and
   `FirstOrError` to their overloads on a sequence. Then every row is read and the condition runs in
-  memory, without a warning. Hold an `Expression<Func<Order, bool>>` instead. `FirstOrNoneAsync`
-  takes only an expression, so a `Func` there doesn't compile.
+  memory, and the analyzer warns at the call
+  ([CMTK0009](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.Analyzers/README.md#a-condition-that-reads-every-row)).
+  Hold an `Expression<Func<Order, bool>>` instead. `FirstOrNoneAsync` takes only an expression, so a
+  `Func` there doesn't compile.
 - **`LastOrNone` and `LastOrError` on a query don't compile.** A query has no last row until it's
   ordered. So order it the other way and take the first, or call `AsEnumerable()` to read every row
   on purpose.
diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
index c64d73ee..68def304 100644
--- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
@@ -30,10 +30,10 @@ namespace CodoMetis.TypeKit.EntityFrameworkCore;
 /// it is: nothing checks that the application set a meaningful character.
 /// </description></item>
 /// <item><description>
-/// A key over <see cref="ulong"/> stays declared generated, as a plain one is, and fails loudly where the
-/// column is a <c>decimal</c> (SQL Server, PostgreSQL): a default key throws <see cref="OverflowException"/>
-/// at <c>Add</c>, from EF's negative temporary <c>decimal</c>. <c>ValueGeneratedNever()</c> and an
-/// assigned key are the workaround.
+/// A key over <see cref="ulong"/> stays declared generated, as a plain one is. Where the column is a
+/// <c>decimal</c> (SQL Server, PostgreSQL), its temporary value at <c>Add</c> is a <see cref="ulong"/>,
+/// from the factory its converter's mapping hints carry (<see cref="ValueObjectMapping"/>, decision
+/// 114), except in a <c>--nativeaot</c> compiled model, where it still throws <see cref="OverflowException"/>.
 /// </description></item>
 /// </list>
 /// <para>
diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectMapping.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectMapping.cs
index 6bf15311..01950dd1 100644
--- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectMapping.cs
+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectMapping.cs
@@ -3,7 +3,9 @@
 using System.Reflection;
 using CodoMetis.TypeKit.CompilerServices;
 using CodoMetis.TypeKit.ValueObjects;
+using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Query;
+using Microsoft.EntityFrameworkCore.ValueGeneration;
 using Microsoft.EntityFrameworkCore.Storage;
 using Microsoft.EntityFrameworkCore.Storage.Json;
 using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
@@ -68,8 +70,35 @@ private sealed class Of<TValueObject, T> : ValueObjectMapping
         where TValueObject : IValueObject<TValueObject, T>, IValueObjectMaterializer<TValueObject, T>
         where T : notnull
     {
-        public override ValueConverter Converter { get; } =
-            new ValueConverter<TValueObject, T>(ValueObjectConverter<TValueObject, T>.ToProvider, ValueObjectConverter<TValueObject, T>.FromProvider);
+        public Of() =>
+            Converter = new ValueConverter<TValueObject, T>(
+                ValueObjectConverter<TValueObject, T>.ToProvider,
+                ValueObjectConverter<TValueObject, T>.FromProvider,
+                IsTemporaryNumber ? new ConverterMappingHints(valueGeneratorFactory: TemporaryNumber) : null);
+
+        public override ValueConverter Converter { get; }
+
+        /// <summary>
+        /// The types EF gives a generated property a temporary number of (<c>RelationalValueGeneratorSelector.FindForType</c>
+        /// in EF Core 10), chosen by the property's type mapping: for a value object that is its own, so EF fell back to
+        /// the column's type, and a key over <see cref="ulong"/> got a negative temporary <see cref="decimal"/> where the
+        /// column is one, which threw <see cref="OverflowException"/> converted back.
+        /// </summary>
+        private static readonly bool IsTemporaryNumber =
+            typeof(T) == typeof(int) || typeof(T) == typeof(long) || typeof(T) == typeof(short) || typeof(T) == typeof(byte)
+         || typeof(T) == typeof(char) || typeof(T) == typeof(ulong) || typeof(T) == typeof(uint) || typeof(T) == typeof(ushort)
+         || typeof(T) == typeof(sbyte) || typeof(T) == typeof(decimal) || typeof(T) == typeof(float) || typeof(T) == typeof(double);
+
+        /// <summary>
+        /// The temporary values a property of the wrapped type gets, as the value object: EF's own where the column is of
+        /// the wrapped type, as before, and the provider's for a key of the wrapped type where it is stored as another.
+        /// A type mapping's factory, which EF consults after a generator configured on the property and after the
+        /// providers' HiLo, and which a mapping built on the converter takes from its hints (decision 114).
+        /// </summary>
+        private ValueGenerator TemporaryNumber(IProperty property, IEntityType entityType) =>
+            property.GetTypeMapping().Converter?.ProviderClrType == typeof(T)
+                ? new WrappedTypeValueGenerator(Converter, new TemporaryNumberValueGeneratorFactory().Create(property, entityType))
+                : new WrappedTypeValueGenerator(Converter, WrappedTypeValueGenerator.ProviderGenerator<T>);
 
         private static readonly MethodInfo ProviderValue = ((MethodCallExpression)ValueObjectConverter<TValueObject, T>.ToProvider.Body).Method;
 
diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/WrappedTypeValueGeneratorFactory.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/WrappedTypeValueGeneratorFactory.cs
index c97f3bef..c6e564d1 100644
--- a/src/CodoMetis.TypeKit.EntityFrameworkCore/WrappedTypeValueGeneratorFactory.cs
+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/WrappedTypeValueGeneratorFactory.cs
@@ -41,7 +41,9 @@ public override ValueGenerator Create(IProperty property, ITypeBase typeBase)
 
         return ValueObjectTypes.Describe(Nullable.GetUnderlyingType(property.ClrType) ?? property.ClrType) is { } valueObject
             && WrappedTypeValueGenerator.Generates(valueObject.WrappedType)
-                   ? new WrappedTypeValueGenerator(ValueObjectMapping.For(valueObject).Converter, valueObject.WrappedType)
+                   ? new WrappedTypeValueGenerator(
+                         ValueObjectMapping.For(valueObject).Converter,
+                         valueObject.WrappedType == typeof(Guid) ? WrappedTypeValueGenerator.ProviderGenerator<Guid> : WrappedTypeValueGenerator.ProviderGenerator<string>)
                    : throw new InvalidOperationException(
                          $"{property.DeclaringType.DisplayName()}.{property.Name} is no value object over a Guid or a string, so it has no generator of its wrapped type's.");
     }
@@ -52,10 +54,15 @@ public override ValueGenerator Create(IProperty property, ITypeBase typeBase)
 /// The provider is asked once, at the first value, about a key of the wrapped type in a model of its own,
 /// built with the context's conventions.
 /// </summary>
-internal sealed class WrappedTypeValueGenerator(ValueConverter converter, Type wrapped) : ValueGenerator
+internal sealed class WrappedTypeValueGenerator(ValueConverter converter, Func<DbContext, ValueGenerator> providerGenerator) : ValueGenerator
 {
     private ValueGenerator? _provider;
 
+    /// <summary>A generator of the wrapped type's values already chosen, its values converted to the value object.</summary>
+    public WrappedTypeValueGenerator(ValueConverter converter, ValueGenerator provider)
+        : this(converter, _ => provider) =>
+        _provider = provider;
+
     /// <summary>The wrapped types whose generator the providers choose by the property's CLR type.</summary>
     public static bool Generates(Type wrapped) => wrapped == typeof(Guid) || wrapped == typeof(string);
 
@@ -64,35 +71,28 @@ internal sealed class WrappedTypeValueGenerator(ValueConverter converter, Type w
         _provider?.GeneratesTemporaryValues
      ?? throw new InvalidOperationException("Whether a value object's generated value is temporary is known only once one is generated.");
 
-    /// <remarks>None of EF's or the providers' generators of a Guid or a string makes stable values.</remarks>
+    /// <remarks>None of EF's or the providers' generators of a Guid, a string or a temporary number makes stable values.</remarks>
     public override bool GeneratesStableValues => false;
 
     protected override object? NextValue(EntityEntry entry) =>
-        converter.ConvertFromProvider((_provider ??= ProviderGenerator(entry.Context, wrapped)).Next(entry));
+        converter.ConvertFromProvider((_provider ??= providerGenerator(entry.Context)).Next(entry));
 
-    private static ValueGenerator ProviderGenerator(DbContext context, Type wrapped)
+    /// <summary>The generator the provider gives a key of <typeparamref name="T"/> generated on add.</summary>
+    public static ValueGenerator ProviderGenerator<T>(DbContext context)
     {
         var modelBuilder = new ModelBuilder(context.GetService<IConventionSetBuilder>().CreateConventionSet(), context.GetService<ModelDependencies>());
-        if (wrapped == typeof(Guid))
-            modelBuilder.Entity<GuidKey>().Property(key => key.Id).ValueGeneratedOnAdd();
-        else
-            modelBuilder.Entity<StringKey>().Property(key => key.Id).ValueGeneratedOnAdd();
+        modelBuilder.Entity<Key<T>>().Property(key => key.Id).ValueGeneratedOnAdd();
 
         var model = context.GetService<IModelRuntimeInitializer>().Initialize(modelBuilder.FinalizeModel(), designTime: false, validationLogger: null);
-        var entityType = model.FindEntityType(wrapped == typeof(Guid) ? typeof(GuidKey) : typeof(StringKey))!;
+        var entityType = model.FindEntityType(typeof(Key<T>))!;
 
         return context.GetService<IValueGeneratorSelector>().TrySelect(entityType.FindPrimaryKey()!.Properties[0], entityType, out var generator) && generator is not null
                    ? generator
-                   : throw new InvalidOperationException($"The provider has no generator for a key of {wrapped.Name} generated on add.");
-    }
-
-    private sealed class GuidKey
-    {
-        public Guid Id { get; set; }
+                   : throw new InvalidOperationException($"The provider has no generator for a key of {typeof(T).Name} generated on add.");
     }
 
-    private sealed class StringKey
+    private sealed class Key<T>
     {
-        public string Id { get; set; } = "";
+        public T Id { get; set; } = default!;
     }
 }
diff --git a/src/CodoMetis.TypeKit.Generators/CodeAnnotations.cs b/src/CodoMetis.TypeKit.Generators/CodeAnnotations.cs
index 65d74cbf..3e9ea062 100644
--- a/src/CodoMetis.TypeKit.Generators/CodeAnnotations.cs
+++ b/src/CodoMetis.TypeKit.Generators/CodeAnnotations.cs
@@ -8,31 +8,36 @@
 namespace CodoMetis.TypeKit.Generators;
 
 /// <summary>The attributes the aspects put on what they generate.</summary>
+/// <remarks>
+/// Each is built where it is used, never kept in a static field: an <see cref="AttributeConstruction"/>
+/// belongs to one compilation, and a static field would keep every compilation the IDE ever made alive
+/// (<c>CompileTimeStaticStateTests</c>).
+/// </remarks>
 [CompileTime]
 internal static class CodeAnnotations
 {
-    public static readonly AttributeConstruction AggressiveInlining =
+    public static AttributeConstruction AggressiveInlining =>
         AttributeConstruction.Create(typeof(MethodImplAttribute), [MethodImplOptions.AggressiveInlining]);
 
     /// <summary>
     /// On the <c>source</c> parameter of the generated <c>FromKnownGood</c>, whose first parameter is
     /// always named <c>value</c>.
     /// </summary>
-    public static readonly AttributeConstruction CallerArgumentExpressionOfValue =
+    public static AttributeConstruction CallerArgumentExpressionOfValue =>
         AttributeConstruction.Create(typeof(CallerArgumentExpressionAttribute), ["value"]);
 
-    public static readonly AttributeConstruction CompilerGenerated =
+    public static AttributeConstruction CompilerGenerated =>
         AttributeConstruction.Create(typeof(CompilerGeneratedAttribute));
 
-    public static readonly AttributeConstruction DebuggerHidden =
+    public static AttributeConstruction DebuggerHidden =>
         AttributeConstruction.Create(typeof(DebuggerHiddenAttribute));
 
-    public static readonly AttributeConstruction DebuggerStepThrough =
+    public static AttributeConstruction DebuggerStepThrough =>
         AttributeConstruction.Create(typeof(DebuggerStepThroughAttribute));
 
-    public static readonly AttributeConstruction EditorNonBrowsable =
+    public static AttributeConstruction EditorNonBrowsable =>
         AttributeConstruction.Create(typeof(EditorBrowsableAttribute), [EditorBrowsableState.Never]);
 
-    public static readonly AttributeConstruction TranslatedAsWrappedValue =
+    public static AttributeConstruction TranslatedAsWrappedValue =>
         AttributeConstruction.Create(typeof(TranslatedAsWrappedValueAttribute));
 }
diff --git a/src/CodoMetis.TypeKit.Generators/README.md b/src/CodoMetis.TypeKit.Generators/README.md
index 7037b355..8d3818be 100644
--- a/src/CodoMetis.TypeKit.Generators/README.md
+++ b/src/CodoMetis.TypeKit.Generators/README.md
@@ -2,8 +2,9 @@
 
 Declare a value object in one line, and get a complete type at compile time. This package generates
 value objects and closed sets (smart enums) for
-[CodoMetis.TypeKit](https://www.nuget.org/packages/CodoMetis.TypeKit), built on
-[Metalama](https://www.postsharp.net/metalama). Each one comes with its JSON converter, parsing,
+[CodoMetis.TypeKit](https://www.nuget.org/packages/CodoMetis.TypeKit). It is built on
+[Metalama](https://postsharp.net/metalama), a framework that generates C# code at compile time from
+templates written in C#. Each value object comes with its JSON converter, parsing,
 formatting, comparison, type converter and query helpers, and every one of them runs the one
 `Create` you wrote.
 
@@ -25,7 +26,7 @@ one of them is the better choice, read
 
 ## Built with Metalama
 
-This package exists in this form because of [Metalama](https://www.postsharp.net/metalama). A
+This package exists in this form because of [Metalama](https://postsharp.net/metalama). A
 transitive fabric finds every type that implements a TypeKit interface, in the project that
 references this package and in every project that references that one. So you declare a value object
 by its interface and nothing else.
@@ -68,6 +69,23 @@ to be a reference type. There are two interfaces:
 - **`IValidatedValue<TSelf, T, TFault>`** adds `Create`, the one method you write. Every way a value
   gets created runs it.
 
+You don't have to type `Create` out. Declare the interface first. The build then fails because
+`Create` is missing (CS0535), and your editor offers a fix for that error: **Add Create**. It writes
+a `Create` that accepts every value, ready for your rules:
+
+```csharp
+public enum NameFault { Blank, TooLong }
+
+public readonly partial record struct Name : IValidatedValue<Name, string, NameFault>
+{
+    public static Result<Name, NameFault> Create(string value)
+    {
+        // Add your rules: if (...) return Result.Error(NameFault.Blank);
+        return new Name(value);
+    }
+}
+```
+
 A validated value object has no `From`. You create one with `Create`, `TryFrom` or `FromKnownGood`,
 so nothing harmless-looking throws on input. The one factory that throws says in its name that you
 vouch for the value, and its exception names the call site, never the value.
@@ -75,6 +93,48 @@ vouch for the value, and its exception names the call site, never the value.
 The error `Create` returns (TypeKit calls it a fault) is what every rejection reports: in that
 exception, in the JSON converter's `JsonException`, and in `Parse`'s `FormatException`.
 
+<details>
+<summary>What the generators write for <code>Email</code>, trimmed</summary>
+
+Every factory below calls the `Create` you wrote:
+
+<!-- not compiled: generated code for Generators/DeclaringSamples.cs, trimmed (GeneratedCodeBlockTests) -->
+```csharp
+public readonly partial record struct Email : IValidatedValue<Email, string, EmailFault>, IValueObject<Email, string>
+{
+    private readonly string _value;
+
+    private Email(string value)
+    {
+        _value = value;
+    }
+
+    public string Value
+    {
+        get { return _value; }
+    }
+
+    public static Option<Email> TryFrom(string value)
+    {
+        return Result.ToOption(Email.Create(value));
+    }
+
+    public static Email FromKnownGood(string value, [CallerArgumentExpression("value")] string? source = null)
+    {
+        return GeneratedFactories.OrInvalidOperationException(Email.Create(value), source);
+    }
+
+    public Result<Email, EmailFault> Revalidate()
+    {
+        return Email.Create(Value);
+    }
+
+    // Also: Parse and TryParse, formatting, comparison, a JSON converter and a type converter.
+}
+```
+
+</details>
+
 You can declare a value object inside another type. `Order.Id` is generated like any other. Its
 companion class is `OrderIdExtensions`, named after the whole nesting chain, so `Order.Id` and
 `Customer.Id` don't collide.
@@ -297,6 +357,52 @@ The generators add:
 Members are singletons, so equality is reference equality. A member added later fails every `Match`
 until it's handled.
 
+<details>
+<summary>What the generators write for <code>OrderStatus</code>, trimmed</summary>
+
+<!-- not compiled: generated code for Generators/ClosedSetSamples.cs, trimmed (GeneratedCodeBlockTests) -->
+```csharp
+public sealed partial class OrderStatus : IClosedSet<OrderStatus>, IParsable<OrderStatus>
+{
+    private static readonly IReadOnlyList<OrderStatus> _all = null!;
+
+    private string _name = null!;
+
+    static OrderStatus()
+    {
+        OrderStatus.Open._name = "Open";
+        OrderStatus.Shipped._name = "Shipped";
+        OrderStatus.Cancelled._name = "Cancelled";
+        OrderStatus._all = Array.AsReadOnly(new OrderStatus[] { OrderStatus.Open, OrderStatus.Shipped, OrderStatus.Cancelled });
+    }
+
+    private OrderStatus() { }
+
+    public string Name
+    {
+        get { return _name ?? throw GeneratedClosedSets.NotAMember("OrderStatus"); }
+    }
+
+    public TResult Match<TResult>(Func<TResult> open, Func<TResult> shipped, Func<TResult> cancelled)
+    {
+        ArgumentNullException.ThrowIfNull(open, "open");
+        ArgumentNullException.ThrowIfNull(shipped, "shipped");
+        ArgumentNullException.ThrowIfNull(cancelled, "cancelled");
+        if (object.ReferenceEquals(this, OrderStatus.Open))
+            return open.Invoke();
+        if (object.ReferenceEquals(this, OrderStatus.Shipped))
+            return shipped.Invoke();
+        if (object.ReferenceEquals(this, OrderStatus.Cancelled))
+            return cancelled.Invoke();
+        throw GeneratedClosedSets.NotAMember("OrderStatus");
+    }
+
+    // Also: All, QualifiedName, Parse and TryParse, ToString and a JSON converter.
+}
+```
+
+</details>
+
 ### Matching, parsing and binding
 
 - **`Match` arguments must be named (CMTK0012).** Every parameter of `Match` has the same type, so an
diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.Templates.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.Templates.cs
index 93c0e436..84fb9265 100644
--- a/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.Templates.cs
+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.Templates.cs
@@ -34,25 +34,31 @@ public static bool TryParseTemplate(
 
         result = meta.Default(tag.ValueObjectType);
 
+        // The branches are an if-else chain, not ifs that return: a return in a compile-time branch ends
+        // the run-time body, but the compile-time calls after it still run, and the InsertStatements
+        // below wrote an unreachable tail into every other TryParse (WovenReachabilityTests).
         if (meta.CompileTime(tag.InnerTryParse() is not null))
+        {
             return (bool)ExpressionFactory.Parse(tag.InnerTryParse()!, TypeFactory.GetType(SpecialType.Boolean), false).Value!;
-
-        if (meta.CompileTime(tag.Strategy == ValueParseStrategy.String))
+        }
+        else if (meta.CompileTime(tag.Strategy == ValueParseStrategy.String))
         {
             return (bool)ExpressionFactory.Parse($"(s is not null && {tag.TryFromText}(s, out result))", TypeFactory.GetType(SpecialType.Boolean), false).Value!;
         }
+        else
+        {
+            // The remaining strategies have no TryParse of their own: their inner parse throws, and what it
+            // throws for text the wrapped type cannot read is GeneratedParsing.Unreadable, a FormatException.
+            // Only that is caught, around the inner parse alone: a bare catch around the wrapping as well
+            // made an exception from Create a false, where Parse, and TryParse over a type with a TryParse
+            // of its own, let it through.
+            if (s is null) return false;
 
-        // The remaining strategies have no TryParse of their own: their inner parse throws, and what it
-        // throws for text the wrapped type cannot read is GeneratedParsing.Unreadable, a FormatException.
-        // Only that is caught, around the inner parse alone: a bare catch around the wrapping as well
-        // made an exception from Create a false, where Parse, and TryParse over a type with a TryParse
-        // of its own, let it through.
-        if (s is null) return false;
-
-        meta.InsertStatement($"{ValueObjectTypes.SourceName(tag.ValueType)} __inner;");
-        meta.InsertStatement($"try {{ __inner = {tag.InnerParse()}; }} catch (global::System.FormatException) {{ return false; }}");
+            meta.InsertStatement($"{ValueObjectTypes.SourceName(tag.ValueType)} __inner;");
+            meta.InsertStatement($"try {{ __inner = {tag.InnerParse()}; }} catch (global::System.FormatException) {{ return false; }}");
 
-        return (bool)ExpressionFactory.Parse($"{tag.TryFromText}(__inner, out result)", TypeFactory.GetType(SpecialType.Boolean), false).Value!;
+            return (bool)ExpressionFactory.Parse($"{tag.TryFromText}(__inner, out result)", TypeFactory.GetType(SpecialType.Boolean), false).Value!;
+        }
     }
 
     [Template]
diff --git a/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs b/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs
index 6b825b3d..f7b676f5 100644
--- a/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs
+++ b/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs
@@ -49,6 +49,76 @@ public static Fault<T2> ShouldHold<[Distinct] T1, [Distinct] T2, [Distinct] T3>(
     public static Fault<T3> ShouldHold<[Distinct] T1, [Distinct] T2, [Distinct] T3>(this Fault<T1, T2, T3> fault, T3 reason) where T1 : notnull where T2 : notnull where T3 : notnull =>
         HeldFaults.Expect<Fault<T1, T2, T3>, T3>(reason, Uninitialized(fault), () => fault.Match<object>(held => held, held => held, held => held));
 
+    /// <inheritdoc cref="ShouldHold{T1, T2}(Fault{T1, T2}, T1)"/>
+    /// <remarks>Awaits <paramref name="fault"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<Fault<T1>> ShouldHold<[Distinct] T1, [Distinct] T2>(this Task<Fault<T1, T2>> fault, T1 reason) where T1 : notnull where T2 : notnull
+    {
+        return (await Outcomes.Pending(fault, nameof(fault)).ConfigureAwait(false)).ShouldHold(reason);
+    }
+
+    /// <inheritdoc cref="ShouldHold{T1, T2}(Fault{T1, T2}, T1)"/>
+    /// <remarks>Awaits <paramref name="fault"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<Fault<T1>> ShouldHold<[Distinct] T1, [Distinct] T2>(this ValueTask<Fault<T1, T2>> fault, T1 reason) where T1 : notnull where T2 : notnull
+    {
+        return (await fault.ConfigureAwait(false)).ShouldHold(reason);
+    }
+
+    /// <inheritdoc cref="ShouldHold{T1, T2}(Fault{T1, T2}, T2)"/>
+    /// <remarks>Awaits <paramref name="fault"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<Fault<T2>> ShouldHold<[Distinct] T1, [Distinct] T2>(this Task<Fault<T1, T2>> fault, T2 reason) where T1 : notnull where T2 : notnull
+    {
+        return (await Outcomes.Pending(fault, nameof(fault)).ConfigureAwait(false)).ShouldHold(reason);
+    }
+
+    /// <inheritdoc cref="ShouldHold{T1, T2}(Fault{T1, T2}, T2)"/>
+    /// <remarks>Awaits <paramref name="fault"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<Fault<T2>> ShouldHold<[Distinct] T1, [Distinct] T2>(this ValueTask<Fault<T1, T2>> fault, T2 reason) where T1 : notnull where T2 : notnull
+    {
+        return (await fault.ConfigureAwait(false)).ShouldHold(reason);
+    }
+
+    /// <inheritdoc cref="ShouldHold{T1, T2, T3}(Fault{T1, T2, T3}, T1)"/>
+    /// <remarks>Awaits <paramref name="fault"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<Fault<T1>> ShouldHold<[Distinct] T1, [Distinct] T2, [Distinct] T3>(this Task<Fault<T1, T2, T3>> fault, T1 reason) where T1 : notnull where T2 : notnull where T3 : notnull
+    {
+        return (await Outcomes.Pending(fault, nameof(fault)).ConfigureAwait(false)).ShouldHold(reason);
+    }
+
+    /// <inheritdoc cref="ShouldHold{T1, T2, T3}(Fault{T1, T2, T3}, T1)"/>
+    /// <remarks>Awaits <paramref name="fault"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<Fault<T1>> ShouldHold<[Distinct] T1, [Distinct] T2, [Distinct] T3>(this ValueTask<Fault<T1, T2, T3>> fault, T1 reason) where T1 : notnull where T2 : notnull where T3 : notnull
+    {
+        return (await fault.ConfigureAwait(false)).ShouldHold(reason);
+    }
+
+    /// <inheritdoc cref="ShouldHold{T1, T2, T3}(Fault{T1, T2, T3}, T2)"/>
+    /// <remarks>Awaits <paramref name="fault"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<Fault<T2>> ShouldHold<[Distinct] T1, [Distinct] T2, [Distinct] T3>(this Task<Fault<T1, T2, T3>> fault, T2 reason) where T1 : notnull where T2 : notnull where T3 : notnull
+    {
+        return (await Outcomes.Pending(fault, nameof(fault)).ConfigureAwait(false)).ShouldHold(reason);
+    }
+
+    /// <inheritdoc cref="ShouldHold{T1, T2, T3}(Fault{T1, T2, T3}, T2)"/>
+    /// <remarks>Awaits <paramref name="fault"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<Fault<T2>> ShouldHold<[Distinct] T1, [Distinct] T2, [Distinct] T3>(this ValueTask<Fault<T1, T2, T3>> fault, T2 reason) where T1 : notnull where T2 : notnull where T3 : notnull
+    {
+        return (await fault.ConfigureAwait(false)).ShouldHold(reason);
+    }
+
+    /// <inheritdoc cref="ShouldHold{T1, T2, T3}(Fault{T1, T2, T3}, T3)"/>
+    /// <remarks>Awaits <paramref name="fault"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<Fault<T3>> ShouldHold<[Distinct] T1, [Distinct] T2, [Distinct] T3>(this Task<Fault<T1, T2, T3>> fault, T3 reason) where T1 : notnull where T2 : notnull where T3 : notnull
+    {
+        return (await Outcomes.Pending(fault, nameof(fault)).ConfigureAwait(false)).ShouldHold(reason);
+    }
+
+    /// <inheritdoc cref="ShouldHold{T1, T2, T3}(Fault{T1, T2, T3}, T3)"/>
+    /// <remarks>Awaits <paramref name="fault"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<Fault<T3>> ShouldHold<[Distinct] T1, [Distinct] T2, [Distinct] T3>(this ValueTask<Fault<T1, T2, T3>> fault, T3 reason) where T1 : notnull where T2 : notnull where T3 : notnull
+    {
+        return (await fault.ConfigureAwait(false)).ShouldHold(reason);
+    }
+
     private static bool Uninitialized<TComposed>(TComposed fault) where TComposed : struct =>
         EqualityComparer<TComposed>.Default.Equals(fault, default);
 }
diff --git a/src/CodoMetis.TypeKit.Testing/OptionAssertions.cs b/src/CodoMetis.TypeKit.Testing/OptionAssertions.cs
index 5eaa2d40..e7db1a8f 100644
--- a/src/CodoMetis.TypeKit.Testing/OptionAssertions.cs
+++ b/src/CodoMetis.TypeKit.Testing/OptionAssertions.cs
@@ -24,4 +24,32 @@ public static void ShouldBeNone<T>(this Option<T> option) where T : notnull
         if (option.IsSome())
             throw new TypeKitAssertionException($"Expected None, but the {Outcomes.Name<Option<T>>()} holds a value (not printed).");
     }
+
+    /// <inheritdoc cref="ShouldBeSome{T}(Option{T})"/>
+    /// <remarks>Awaits <paramref name="option"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<T> ShouldBeSome<T>(this Task<Option<T>> option) where T : notnull
+    {
+        return (await Outcomes.Pending(option, nameof(option)).ConfigureAwait(false)).ShouldBeSome();
+    }
+
+    /// <inheritdoc cref="ShouldBeSome{T}(Option{T})"/>
+    /// <remarks>Awaits <paramref name="option"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<T> ShouldBeSome<T>(this ValueTask<Option<T>> option) where T : notnull
+    {
+        return (await option.ConfigureAwait(false)).ShouldBeSome();
+    }
+
+    /// <inheritdoc cref="ShouldBeNone{T}(Option{T})"/>
+    /// <remarks>Awaits <paramref name="option"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task ShouldBeNone<T>(this Task<Option<T>> option) where T : notnull
+    {
+        (await Outcomes.Pending(option, nameof(option)).ConfigureAwait(false)).ShouldBeNone();
+    }
+
+    /// <inheritdoc cref="ShouldBeNone{T}(Option{T})"/>
+    /// <remarks>Awaits <paramref name="option"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task ShouldBeNone<T>(this ValueTask<Option<T>> option) where T : notnull
+    {
+        (await option.ConfigureAwait(false)).ShouldBeNone();
+    }
 }
diff --git a/src/CodoMetis.TypeKit.Testing/Outcomes.cs b/src/CodoMetis.TypeKit.Testing/Outcomes.cs
index 9bda0d7e..60fb8b24 100644
--- a/src/CodoMetis.TypeKit.Testing/Outcomes.cs
+++ b/src/CodoMetis.TypeKit.Testing/Outcomes.cs
@@ -16,6 +16,9 @@ public static void ThrowIfOtherError<TOutcome, TError>(TError actual, TError exp
             throw new TypeKitAssertionException($"Expected the error {expected}, but the {Name<TOutcome>()} is the error {actual}.");
     }
 
+    /// <summary>The task an asynchronous assertion awaits, refused when null: awaited, it was a <see cref="NullReferenceException"/> naming nothing.</summary>
+    public static Task<T> Pending<T>(Task<T>? task, string paramName) => task ?? throw new ArgumentNullException(paramName, "The assertion was given no task to await.");
+
     /// <summary>
     /// <c>Result&lt;Order, OrderFault&gt;</c>, as the type is written in C# from outside its containing
     /// types: <c>Billing.Fault</c>, <c>Outer&lt;Int32&gt;.Inner</c>.
diff --git a/src/CodoMetis.TypeKit.Testing/PatchAssertions.cs b/src/CodoMetis.TypeKit.Testing/PatchAssertions.cs
index 5a131c6c..769b45ad 100644
--- a/src/CodoMetis.TypeKit.Testing/PatchAssertions.cs
+++ b/src/CodoMetis.TypeKit.Testing/PatchAssertions.cs
@@ -34,6 +34,48 @@ public static void ShouldBeAbsent<T>(this Patch<T> patch) where T : notnull
             throw new TypeKitAssertionException($"Expected Absent, but the {Outcomes.Name<Patch<T>>()} {Was(patch.State)}.");
     }
 
+    /// <inheritdoc cref="ShouldBeValue{T}(Patch{T})"/>
+    /// <remarks>Awaits <paramref name="patch"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<T> ShouldBeValue<T>(this Task<Patch<T>> patch) where T : notnull
+    {
+        return (await Outcomes.Pending(patch, nameof(patch)).ConfigureAwait(false)).ShouldBeValue();
+    }
+
+    /// <inheritdoc cref="ShouldBeValue{T}(Patch{T})"/>
+    /// <remarks>Awaits <paramref name="patch"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<T> ShouldBeValue<T>(this ValueTask<Patch<T>> patch) where T : notnull
+    {
+        return (await patch.ConfigureAwait(false)).ShouldBeValue();
+    }
+
+    /// <inheritdoc cref="ShouldBeNull{T}(Patch{T})"/>
+    /// <remarks>Awaits <paramref name="patch"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task ShouldBeNull<T>(this Task<Patch<T>> patch) where T : notnull
+    {
+        (await Outcomes.Pending(patch, nameof(patch)).ConfigureAwait(false)).ShouldBeNull();
+    }
+
+    /// <inheritdoc cref="ShouldBeNull{T}(Patch{T})"/>
+    /// <remarks>Awaits <paramref name="patch"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task ShouldBeNull<T>(this ValueTask<Patch<T>> patch) where T : notnull
+    {
+        (await patch.ConfigureAwait(false)).ShouldBeNull();
+    }
+
+    /// <inheritdoc cref="ShouldBeAbsent{T}(Patch{T})"/>
+    /// <remarks>Awaits <paramref name="patch"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task ShouldBeAbsent<T>(this Task<Patch<T>> patch) where T : notnull
+    {
+        (await Outcomes.Pending(patch, nameof(patch)).ConfigureAwait(false)).ShouldBeAbsent();
+    }
+
+    /// <inheritdoc cref="ShouldBeAbsent{T}(Patch{T})"/>
+    /// <remarks>Awaits <paramref name="patch"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task ShouldBeAbsent<T>(this ValueTask<Patch<T>> patch) where T : notnull
+    {
+        (await patch.ConfigureAwait(false)).ShouldBeAbsent();
+    }
+
     private static string Was(PatchState state) => state == PatchState.Value ? "holds a value (not printed)" : $"is {Describe(state)}";
 
     private static string Describe(PatchState state) => state switch
diff --git a/src/CodoMetis.TypeKit.Testing/README.md b/src/CodoMetis.TypeKit.Testing/README.md
index 46558db9..4b7fb84b 100644
--- a/src/CodoMetis.TypeKit.Testing/README.md
+++ b/src/CodoMetis.TypeKit.Testing/README.md
@@ -43,6 +43,15 @@ Fault<EditFault> stale = refusal.ShouldHold(EditFault.Stale);   // this fault, o
 string? detail = stale.Detail;                                  // for the test's own assertions
 ```
 
+Every assertion also works on a `Task` or a `ValueTask` of what it checks. Put `await` in front, and
+it waits for the task, then checks what the task returned:
+
+```csharp
+Email email = await signups.RegisterAsync("ops@example.com").ShouldBeSuccess();   // awaited, then asserted
+await signups.RegisterAsync("nobody").ShouldBeError(EmailFault.NoAt);
+await signups.FindAsync("ops@example.com").ShouldBeNone();                         // a ValueTask too
+```
+
 - **The content comes back.** `ShouldBeSome()`, `ShouldBeSuccess()`, `ShouldBeError()` and
   `ShouldBeValue()` return the value or the error. Compare it with whatever assertions your tests
   already use: xUnit's `Assert`, Shouldly, or another.
@@ -54,3 +63,8 @@ string? detail = stale.Detail;                                  // for the test'
   `Option`, `Result` and `Patch<T>` themselves never do.
 - **An uninitialized result fails every assertion.** The message says it is a default instance,
   neither a success nor an error.
+- **Await an assertion on a task.** It fails your test only through the task it returns, so without
+  `await` the test passes whatever the task holds. The analyzer reports that line (CMTK0003), in a
+  test method that isn't `async` too, where C# itself says nothing.
+- **A task that throws fails your test with its own exception**, as it was thrown, and not as an
+  assertion failure. The assertion never sees an outcome.
diff --git a/src/CodoMetis.TypeKit.Testing/ResultAssertions.cs b/src/CodoMetis.TypeKit.Testing/ResultAssertions.cs
index d8e29452..b46572b3 100644
--- a/src/CodoMetis.TypeKit.Testing/ResultAssertions.cs
+++ b/src/CodoMetis.TypeKit.Testing/ResultAssertions.cs
@@ -83,4 +83,100 @@ public static TError ShouldBeError<TError>(this Result<TError> result) where TEr
     /// <exception cref="TypeKitAssertionException">The result is a success, another error, or uninitialized.</exception>
     public static void ShouldBeError<TError>(this Result<TError> result, TError expected) where TError : notnull =>
         Outcomes.ThrowIfOtherError<Result<TError>, TError>(result.ShouldBeError(), expected);
+
+    /// <inheritdoc cref="ShouldBeSuccess{T, TError}(Result{T, TError})"/>
+    /// <remarks>Awaits <paramref name="result"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<T> ShouldBeSuccess<T, TError>(this Task<Result<T, TError>> result)
+        where T : notnull
+        where TError : notnull
+    {
+        return (await Outcomes.Pending(result, nameof(result)).ConfigureAwait(false)).ShouldBeSuccess();
+    }
+
+    /// <inheritdoc cref="ShouldBeSuccess{T, TError}(Result{T, TError})"/>
+    /// <remarks>Awaits <paramref name="result"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<T> ShouldBeSuccess<T, TError>(this ValueTask<Result<T, TError>> result)
+        where T : notnull
+        where TError : notnull
+    {
+        return (await result.ConfigureAwait(false)).ShouldBeSuccess();
+    }
+
+    /// <inheritdoc cref="ShouldBeError{T, TError}(Result{T, TError})"/>
+    /// <remarks>Awaits <paramref name="result"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<TError> ShouldBeError<T, TError>(this Task<Result<T, TError>> result)
+        where T : notnull
+        where TError : notnull
+    {
+        return (await Outcomes.Pending(result, nameof(result)).ConfigureAwait(false)).ShouldBeError();
+    }
+
+    /// <inheritdoc cref="ShouldBeError{T, TError}(Result{T, TError})"/>
+    /// <remarks>Awaits <paramref name="result"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<TError> ShouldBeError<T, TError>(this ValueTask<Result<T, TError>> result)
+        where T : notnull
+        where TError : notnull
+    {
+        return (await result.ConfigureAwait(false)).ShouldBeError();
+    }
+
+    /// <inheritdoc cref="ShouldBeError{T, TError}(Result{T, TError}, TError)"/>
+    /// <remarks>Awaits <paramref name="result"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task ShouldBeError<T, TError>(this Task<Result<T, TError>> result, TError expected)
+        where T : notnull
+        where TError : notnull
+    {
+        (await Outcomes.Pending(result, nameof(result)).ConfigureAwait(false)).ShouldBeError(expected);
+    }
+
+    /// <inheritdoc cref="ShouldBeError{T, TError}(Result{T, TError}, TError)"/>
+    /// <remarks>Awaits <paramref name="result"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task ShouldBeError<T, TError>(this ValueTask<Result<T, TError>> result, TError expected)
+        where T : notnull
+        where TError : notnull
+    {
+        (await result.ConfigureAwait(false)).ShouldBeError(expected);
+    }
+
+    /// <inheritdoc cref="ShouldBeSuccess{TError}(Result{TError})"/>
+    /// <remarks>Awaits <paramref name="result"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task ShouldBeSuccess<TError>(this Task<Result<TError>> result) where TError : notnull
+    {
+        (await Outcomes.Pending(result, nameof(result)).ConfigureAwait(false)).ShouldBeSuccess();
+    }
+
+    /// <inheritdoc cref="ShouldBeSuccess{TError}(Result{TError})"/>
+    /// <remarks>Awaits <paramref name="result"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task ShouldBeSuccess<TError>(this ValueTask<Result<TError>> result) where TError : notnull
+    {
+        (await result.ConfigureAwait(false)).ShouldBeSuccess();
+    }
+
+    /// <inheritdoc cref="ShouldBeError{TError}(Result{TError})"/>
+    /// <remarks>Awaits <paramref name="result"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<TError> ShouldBeError<TError>(this Task<Result<TError>> result) where TError : notnull
+    {
+        return (await Outcomes.Pending(result, nameof(result)).ConfigureAwait(false)).ShouldBeError();
+    }
+
+    /// <inheritdoc cref="ShouldBeError{TError}(Result{TError})"/>
+    /// <remarks>Awaits <paramref name="result"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task<TError> ShouldBeError<TError>(this ValueTask<Result<TError>> result) where TError : notnull
+    {
+        return (await result.ConfigureAwait(false)).ShouldBeError();
+    }
+
+    /// <inheritdoc cref="ShouldBeError{TError}(Result{TError}, TError)"/>
+    /// <remarks>Awaits <paramref name="result"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task ShouldBeError<TError>(this Task<Result<TError>> result, TError expected) where TError : notnull
+    {
+        (await Outcomes.Pending(result, nameof(result)).ConfigureAwait(false)).ShouldBeError(expected);
+    }
+
+    /// <inheritdoc cref="ShouldBeError{TError}(Result{TError}, TError)"/>
+    /// <remarks>Awaits <paramref name="result"/> first: an exception the task ends with propagates as it is.</remarks>
+    public static async Task ShouldBeError<TError>(this ValueTask<Result<TError>> result, TError expected) where TError : notnull
+    {
+        (await result.ConfigureAwait(false)).ShouldBeError(expected);
+    }
 }
diff --git a/src/CodoMetis.TypeKit/Fault.cs b/src/CodoMetis.TypeKit/Fault.cs
index e2f33a88..f44ca270 100644
--- a/src/CodoMetis.TypeKit/Fault.cs
+++ b/src/CodoMetis.TypeKit/Fault.cs
@@ -15,7 +15,7 @@ namespace CodoMetis.TypeKit;
 /// it can say anything, so whether it quotes the request is the application's to decide.
 /// </para>
 /// <para>
-/// <see cref="Fault.Of{TFault}"/> makes one and infers the type, with a detail or without:
+/// <see cref="Fault.Of{TFault}(TFault, string?)"/> makes one and infers the type, with a detail or without:
 /// <c>Result.Error(Fault.Of(OrderFault.NotAmendable, "The order shipped on 3 May."))</c>. Where the reason
 /// answers for several rules, <c>WithRule</c> names the one that refused, an enum's or a closed set's
 /// member, as a key a client branches on: <c>Fault.Of(AccountFault.InvalidEmail).WithRule(EmailFault.NoAt)</c>. A bare reason
@@ -42,6 +42,16 @@ public Fault(TFault reason, string? detail = null)
             : detail;
     }
 
+    /// <summary>Creates the fault, keeping the exception that caused it.</summary>
+    /// <param name="reason">Which fault. Never null.</param>
+    /// <param name="detail">A sentence about this occurrence, or <see langword="null"/> for none. Never blank.</param>
+    /// <param name="cause">The exception underneath, kept for the log as <see cref="Cause"/>. Never null.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="reason"/> or <paramref name="cause"/> is null.</exception>
+    /// <exception cref="ArgumentException"><paramref name="detail"/> is empty or white space: say <see langword="null"/> for no detail.</exception>
+    public Fault(TFault reason, string? detail, Exception cause)
+        : this(reason, detail) =>
+        Cause = cause ?? throw new ArgumentNullException(nameof(cause), "A fault's cause is the exception underneath; leave it out for none.");
+
     /// <summary>Which fault.</summary>
     public TFault Reason { get; }
 
@@ -64,6 +74,27 @@ public Fault(TFault reason, string? detail = null)
     /// <summary>The rule's type, which equality compares beside <see cref="Rule"/>: two types' rules can read alike.</summary>
     private Type? RuleType { get; init; }
 
+    /// <summary>The exception that caused this occurrence, or <see langword="null"/>: for the log, never for the client.</summary>
+    /// <remarks>
+    /// Set by <see cref="Fault.Of{TFault}(TFault, string?, Exception)"/>, kept by <c>WithRule</c> and by a fault of
+    /// several types. CodoMetis.TypeKit.AspNetCore hands it to the host beside the problem and never writes it into
+    /// one. Equality leaves it out, so a fault with a cause equals the same fault without one, and the fault prints
+    /// without it: log it as the exception it is.
+    /// </remarks>
+    public Exception? Cause { get; }
+
+    /// <summary>Equal where the reason, the detail and the rule are; the <see cref="Cause"/> takes no part.</summary>
+    /// <param name="other">The other fault.</param>
+    /// <returns>Whether the two are the same fault.</returns>
+    public bool Equals(Fault<TFault> other) =>
+        EqualityComparer<TFault>.Default.Equals(Reason, other.Reason)
+        && string.Equals(Detail, other.Detail, StringComparison.Ordinal)
+        && string.Equals(Rule, other.Rule, StringComparison.Ordinal)
+        && RuleType == other.RuleType;
+
+    /// <inheritdoc />
+    public override int GetHashCode() => HashCode.Combine(Reason, Detail, Rule, RuleType);
+
     /// <summary>The same fault with <paramref name="rule"/>, a member of <paramref name="type"/>, as its <see cref="Rule"/>.</summary>
     internal Fault<TFault> Naming(string rule, Type type) => this with { Rule = rule, RuleType = type };
 
@@ -197,4 +228,18 @@ public static class Fault
     /// <exception cref="ArgumentNullException"><paramref name="reason"/> is null.</exception>
     /// <exception cref="ArgumentException"><paramref name="detail"/> is empty or white space.</exception>
     public static Fault<TFault> Of<TFault>(TFault reason, string? detail = null) where TFault : notnull => new(reason, detail);
+
+    /// <summary>A fault and the exception that caused it, kept for the log and never written to a response.</summary>
+    /// <remarks>
+    /// The pattern is a <c>MapError</c> from a caught exception:
+    /// <c>Result.Catch(read).MapError(e =&gt; Fault.Of(ImportFault.Unreadable, "The file could not be read.", e))</c>.
+    /// </remarks>
+    /// <param name="reason">Which fault. Never null.</param>
+    /// <param name="detail">A sentence about this occurrence, or <see langword="null"/> for none. Never blank.</param>
+    /// <param name="cause">The exception underneath. Never null.</param>
+    /// <typeparam name="TFault">The reason's type, inferred.</typeparam>
+    /// <returns>The fault, with <paramref name="cause"/> as its <see cref="Fault{TFault}.Cause"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="reason"/> or <paramref name="cause"/> is null.</exception>
+    /// <exception cref="ArgumentException"><paramref name="detail"/> is empty or white space.</exception>
+    public static Fault<TFault> Of<TFault>(TFault reason, string? detail, Exception cause) where TFault : notnull => new(reason, detail, cause);
 }
diff --git a/src/CodoMetis.TypeKit/FaultOfSets.cs b/src/CodoMetis.TypeKit/FaultOfSets.cs
index c62ac641..f48fcf18 100644
--- a/src/CodoMetis.TypeKit/FaultOfSets.cs
+++ b/src/CodoMetis.TypeKit/FaultOfSets.cs
@@ -54,12 +54,26 @@ namespace CodoMetis.TypeKit;
     /// <returns>The fault.</returns>
     public static Fault<T1, T2> Of(T1 reason, string? detail = null) => Fault.Of(reason, detail);
 
+    /// <summary>A fault of the first type, with the exception that caused it.</summary>
+    /// <param name="reason">Which fault. Never null.</param>
+    /// <param name="detail">A sentence about this occurrence, or <see langword="null"/> for none. Never blank.</param>
+    /// <param name="cause">The exception underneath, kept as the fault's <c>Cause</c>. Never null.</param>
+    /// <returns>The fault.</returns>
+    public static Fault<T1, T2> Of(T1 reason, string? detail, Exception cause) => Fault.Of(reason, detail, cause);
+
     /// <summary>A fault of the second type, with a sentence about this occurrence or none.</summary>
     /// <param name="reason">Which fault. Never null.</param>
     /// <param name="detail">A sentence about this occurrence, or <see langword="null"/> for none. Never blank.</param>
     /// <returns>The fault.</returns>
     public static Fault<T1, T2> Of(T2 reason, string? detail = null) => Fault.Of(reason, detail);
 
+    /// <summary>A fault of the second type, with the exception that caused it.</summary>
+    /// <param name="reason">Which fault. Never null.</param>
+    /// <param name="detail">A sentence about this occurrence, or <see langword="null"/> for none. Never blank.</param>
+    /// <param name="cause">The exception underneath, kept as the fault's <c>Cause</c>. Never null.</param>
+    /// <returns>The fault.</returns>
+    public static Fault<T1, T2> Of(T2 reason, string? detail, Exception cause) => Fault.Of(reason, detail, cause);
+
     /// <summary>The fault <paramref name="fault"/> is, of the first type: what the conversion does, by name.</summary>
     /// <param name="fault">The fault.</param>
     /// <returns>The fault.</returns>
@@ -163,18 +177,39 @@ private static Fault<T> Checked<T>(Fault<T> fault) where T : notnull =>
     /// <returns>The fault.</returns>
     public static Fault<T1, T2, T3> Of(T1 reason, string? detail = null) => Fault.Of(reason, detail);
 
+    /// <summary>A fault of the first type, with the exception that caused it.</summary>
+    /// <param name="reason">Which fault. Never null.</param>
+    /// <param name="detail">A sentence about this occurrence, or <see langword="null"/> for none. Never blank.</param>
+    /// <param name="cause">The exception underneath, kept as the fault's <c>Cause</c>. Never null.</param>
+    /// <returns>The fault.</returns>
+    public static Fault<T1, T2, T3> Of(T1 reason, string? detail, Exception cause) => Fault.Of(reason, detail, cause);
+
     /// <summary>A fault of the second type, with a sentence about this occurrence or none.</summary>
     /// <param name="reason">Which fault. Never null.</param>
     /// <param name="detail">A sentence about this occurrence, or <see langword="null"/> for none. Never blank.</param>
     /// <returns>The fault.</returns>
     public static Fault<T1, T2, T3> Of(T2 reason, string? detail = null) => Fault.Of(reason, detail);
 
+    /// <summary>A fault of the second type, with the exception that caused it.</summary>
+    /// <param name="reason">Which fault. Never null.</param>
+    /// <param name="detail">A sentence about this occurrence, or <see langword="null"/> for none. Never blank.</param>
+    /// <param name="cause">The exception underneath, kept as the fault's <c>Cause</c>. Never null.</param>
+    /// <returns>The fault.</returns>
+    public static Fault<T1, T2, T3> Of(T2 reason, string? detail, Exception cause) => Fault.Of(reason, detail, cause);
+
     /// <summary>A fault of the third type, with a sentence about this occurrence or none.</summary>
     /// <param name="reason">Which fault. Never null.</param>
     /// <param name="detail">A sentence about this occurrence, or <see langword="null"/> for none. Never blank.</param>
     /// <returns>The fault.</returns>
     public static Fault<T1, T2, T3> Of(T3 reason, string? detail = null) => Fault.Of(reason, detail);
 
+    /// <summary>A fault of the third type, with the exception that caused it.</summary>
+    /// <param name="reason">Which fault. Never null.</param>
+    /// <param name="detail">A sentence about this occurrence, or <see langword="null"/> for none. Never blank.</param>
+    /// <param name="cause">The exception underneath, kept as the fault's <c>Cause</c>. Never null.</param>
+    /// <returns>The fault.</returns>
+    public static Fault<T1, T2, T3> Of(T3 reason, string? detail, Exception cause) => Fault.Of(reason, detail, cause);
+
     /// <summary>The fault <paramref name="fault"/> is, of the first type: what the conversion does, by name.</summary>
     /// <param name="fault">The fault.</param>
     /// <returns>The fault.</returns>
diff --git a/src/CodoMetis.TypeKit/OptionExtensions.cs b/src/CodoMetis.TypeKit/OptionExtensions.cs
index 369d57a6..6895c310 100644
--- a/src/CodoMetis.TypeKit/OptionExtensions.cs
+++ b/src/CodoMetis.TypeKit/OptionExtensions.cs
@@ -651,6 +651,24 @@ public IEnumerable<T> Choose()
         }
     }
 
+    /// <param name="options">The stream of options.</param>
+    /// <typeparam name="T">The type of the values.</typeparam>
+    extension<T>(IAsyncEnumerable<Option<T>> options) where T : notnull
+    {
+        /// <summary>
+        /// The values of the options that hold one, in order, as they arrive: a stream of lookups to what
+        /// was found. Lazy, as an async LINQ operator is, and the token given to <c>WithCancellation</c> or
+        /// <c>GetAsyncEnumerator</c> reaches the stream it reads.
+        /// </summary>
+        /// <returns>The values, in order.</returns>
+        public IAsyncEnumerable<T> Choose()
+        {
+            ArgumentNullException.ThrowIfNull(options);
+
+            return Chosen(options, static option => option);
+        }
+    }
+
     /// <param name="instance">The nullable value.</param>
     /// <typeparam name="T">The underlying value type.</typeparam>
     extension<T>(in T? instance) where T : struct
@@ -679,4 +697,13 @@ internal static IEnumerable<TResult> Chosen<T, TResult>(IEnumerable<T> source, F
             if (selector(element).TryGetValue(out var value)) yield return value;
         }
     }
+
+    /// <summary>The iterator behind both <c>Choose</c> over a stream; the caller's token is the stream's.</summary>
+    internal static async IAsyncEnumerable<TResult> Chosen<T, TResult>(IAsyncEnumerable<T> source, Func<T, Option<TResult>> selector, [EnumeratorCancellation] CancellationToken cancellationToken = default) where TResult : notnull
+    {
+        await foreach (var element in source.WithCancellation(cancellationToken).ConfigureAwait(false))
+        {
+            if (selector(element).TryGetValue(out var value)) yield return value;
+        }
+    }
 }
diff --git a/src/CodoMetis.TypeKit/README.md b/src/CodoMetis.TypeKit/README.md
index 53be9727..6f7adf7a 100644
--- a/src/CodoMetis.TypeKit/README.md
+++ b/src/CodoMetis.TypeKit/README.md
@@ -2,7 +2,10 @@
 
 The base package of TypeKit. It gives you `Option<T>` and `Result<T, TError>` that you can't misuse,
 and the interfaces that value objects and closed sets (smart enums) are generated from. It brings no
-code generator and no Metalama, only the types and the analyzers that check them.
+code generator, only the types and the analyzers that check them. TypeKit's generators are built on
+[Metalama](https://postsharp.net/metalama), which generates C# code at compile time from templates
+written in C#. They live in `CodoMetis.TypeKit.Generators`, so this package never brings Metalama into
+your project.
 
 What it does for you:
 
@@ -76,6 +79,7 @@ Option<decimal> discount =                                       // a later from
 - **`Choose(selector)`** keeps the values a selector returns `Some` for, in order and without the
   `None`s. It filters and maps in one step, over elements that may be null
   (`nicknames.Choose(n => n.ToOption())`). `Choose()` keeps the values a sequence of options holds.
+  Both read an async stream too, as its elements arrive.
 
 On a database query, `FirstOrNone`, `FirstOrError`, `SingleOrNone` and `ElementAtOrNone` ask the
 provider for only the element they need, and let it run the predicate (a `WHERE` and a `LIMIT` in
@@ -84,7 +88,8 @@ no last element until it is ordered.
 
 Write the predicate as a lambda at the call, which makes it an expression. A `Func<T, bool>` variable
 or a method group is no expression. It binds to the sequence's overload, which reads every row and
-runs the condition in memory. Hold an `Expression<Func<T, bool>>` instead.
+runs the condition in memory, and the analyzer warns at the call (CMTK0009). Hold an
+`Expression<Func<T, bool>>` instead.
 
 ### Get the value out
 
@@ -95,6 +100,7 @@ runs the condition in memory. Hold an `Expression<Func<T, bool>>` instead.
 - **`ToResult(error)`** turns absence into an error.
 - **`Traverse`** validates an optional input when it is present.
   `dto.Phone.ToOption().Traverse(Phone.Create)` is a `Result<Option<Phone>, PhoneFault>`.
+  `TraverseAsync` does the same with a check you await, such as a lookup.
 - **`Transpose()`** turns an `Option<Result<...>>` inside out, and a `Result<Option<...>>` back.
 
 `ToString()` never prints the content, so an option is safe to log. The debugger shows it.
@@ -221,6 +227,20 @@ sequence order. `Traverse` calls nothing after it. None of them collects errors.
 cancellation token you give it is cancelled. For operations that may all run at once, use
 `Task.WhenAll` and `Sequence()`.
 
+An async stream (`IAsyncEnumerable<T>`), such as a paged API or a query read with
+`AsAsyncEnumerable()`, needs no list first:
+
+```csharp
+IAsyncEnumerable<Sku> known = lines.Choose(line => Sku.TryFrom(line));                        // the lines that are SKUs, as they arrive
+Result<IReadOnlyList<Sku>, SkuFault> imported = await rows.SequenceAsync(cancellationToken);   // every SKU, or the first fault
+Result<IReadOnlyList<Order>, OrderFault> found = await ids.TraverseAsync(orders.FindAsync);    // one lookup at a time, in order
+```
+
+`SequenceAsync` and `TraverseAsync` stop at the first error and read nothing after it. All three read
+the stream in order, and dispose its enumerator however they stop: at an error, at a `break`, or when
+your selector throws. The token you give `SequenceAsync` or `TraverseAsync` reaches the stream. For
+`Choose`, pass yours to `WithCancellation` on what it returns.
+
 The asynchronous steps take callbacks that return a `Task`, and wait for them.
 `.TapErrorAsync(fault => audit.RecordAsync(fault))` has recorded the fault when the chain's `await`
 returns, and what it throws comes out of that `await`.
@@ -271,14 +291,16 @@ Result<byte[], Exception> fetched = await Result.CatchAsync(() => client.GetByte
 - **A task goes to `CatchAsync`.** A delegate that returns a `Task`, an `async` lambda among them,
   given to `Catch` or its command form doesn't compile, and the error names `CatchAsync`. The task's
   exception would be thrown after `Catch` had returned.
-- **A `ValueTask`, or a task spelled as the type argument** (`Catch<Task<int>, ...>`), is rejected
-  when called, before the delegate runs. `CatchAsync` takes a `ValueTask` through `.AsTask()` or an
-  `async` lambda, as above.
+- **`CatchAsync` takes a `ValueTask` too**, as in `Result.CatchAsync(() => stream.ReadAsync(buffer))`.
+  An `async` lambda still goes to the `Task` form.
+- **A `ValueTask` given to `Catch`, or a task spelled as the type argument** (`Catch<Task<int>, ...>`),
+  is rejected when called, before the delegate runs. Use `CatchAsync`.
 - **A delegate that returns null throws**, as `Result.Success(null)` does.
 - **The other members don't catch.** `Map`, `Bind` and the rest are unchanged: a selector that throws
   propagates.
 - **An exception is for the code that called, not for a client.** `ToHttpResult()` doesn't accept a
   `Result<T, Exception>`. Use `MapError` to turn the exception into a fault that it does accept.
+  `MapError(e => Fault.Of(reason, detail, e))` keeps the exception as the fault's cause, for your log.
 
 ### A fault with a sentence
 
@@ -288,6 +310,9 @@ beside it, in a `Fault<TFault>`: the fault as its `Reason`, and an optional `Det
 - **`Fault.Of(OrderFault.NotAmendable, "The order shipped on 3 May.")`** infers the type.
   `Fault.Of(OrderFault.NotFound)` makes one without a detail. A blank detail throws
   `ArgumentException`. Leave the detail out instead, and it is `null`.
+- **`Fault.Of(reason, detail, exception)` keeps what failed underneath** as the fault's `Cause`.
+  It's for your log. A fault with a cause equals the same fault without one, and prints the same.
+  CodoMetis.TypeKit.AspNetCore hands it to your host and never writes it into a response.
 - **A bare fault doesn't convert to one**, so comparing the two doesn't compile. Write
   `fault.Reason == OrderFault.NotFound`.
 - **`WithRule` names the rule that failed**, where the reason covers several rules. The rule is an
@@ -582,7 +607,8 @@ A value object inside a patch keeps its own rule. `Patch<Email>` given a value t
 is rejected as anywhere else, without quoting the input. Where the rejection should be the
 endpoint's own fault, the request carries a `Patch<string>`, and `Traverse` validates it:
 `request.Email.Traverse(Email.Create)` is a `Result<Patch<Email>, EmailFault>`, with a clear and an
-absence passed through. `Map` changes a value the same way.
+absence passed through. `TraverseAsync` does the same with a check you await, and `Map` changes a
+value the same way.
 
 **Good to know**
 
@@ -830,13 +856,13 @@ In a field initializer, refer to a member by its field, `Open`, not by its name.
 Nothing has run: the delegate is rejected before it is called.
 
 **Why:** the task's exception is thrown after `Catch` has returned, so the result would be a success
-whatever the call does. A delegate that returns a `Task` is rejected at compile time. A `ValueTask`
-can't be: it converts to no task type that an overload could name without making every `async`
-lambda ambiguous. And a spelled type argument chooses its overload itself.
+whatever the call does. A delegate that returns a `Task` is rejected at compile time. One that
+returns a `ValueTask` is rejected when called, since a compile error there would break a build that
+works today. And a spelled type argument chooses its overload itself.
 
-**Instead:** use `CatchAsync`, which awaits the task:
-`await Result.CatchAsync(() => stream.ReadAsync(buffer).AsTask())`, or an `async` lambda. In
-`CatchAsync`, await the inner task in the delegate.
+**Instead:** use `CatchAsync`, which awaits the task, a `ValueTask` too:
+`await Result.CatchAsync(() => stream.ReadAsync(buffer))`. In `CatchAsync`, await the inner task in
+the delegate.
 
 ### AsText in globalization-invariant mode
 
diff --git a/src/CodoMetis.TypeKit/ResultExtensions.cs b/src/CodoMetis.TypeKit/ResultExtensions.cs
index 5e7b56b6..eb0a0978 100644
--- a/src/CodoMetis.TypeKit/ResultExtensions.cs
+++ b/src/CodoMetis.TypeKit/ResultExtensions.cs
@@ -1,3 +1,5 @@
+using System.Runtime.CompilerServices;
+
 namespace CodoMetis.TypeKit;
 
 /// <summary>
@@ -283,8 +285,8 @@ private static bool IsTimeout(OperationCanceledException cancellation)
     /// Refuses a value that is itself a task, before the delegate runs: its exception would be thrown
     /// after <c>Catch</c> had returned a success. The overloads over a task-returning delegate refuse
     /// it at compile time; this is the type argument spelled as a task, <c>Catch&lt;Task&lt;int&gt;, …&gt;</c>,
-    /// and a <c>ValueTask</c>, which no overload can name beside <c>Task</c> without making every
-    /// <c>async</c> lambda ambiguous.
+    /// and a <c>ValueTask</c>, whose refusal at compile time would break a build that works today
+    /// (decision 110).
     /// </summary>
     private static void RefuseTask<T>(string method)
     {
@@ -306,8 +308,7 @@ private static void RefuseTask<T>(string method)
     /// cancellation, and so does an <see cref="AggregateException"/> of cancellations alone; a timeout,
     /// which <see cref="System.Net.Http.HttpClient"/> throws as a cancellation over a
     /// <see cref="TimeoutException"/>, is the error. A delegate returning a <c>ValueTask</c>
-    /// needs <c>.AsTask()</c> or an <c>async</c> lambda: a <c>ValueTask</c> overload beside this one is
-    /// ambiguous for every <c>async</c> lambda.
+    /// binds to <see cref="CatchAsync{T}(Func{ValueTask{T}})"/>, and an <c>async</c> lambda to this one.
     /// See <see cref="Catch{T}(Func{T})"/> for cancellations, timeouts and null.
     /// </para>
     /// <para>
@@ -468,6 +469,164 @@ public static async Task<Result<TException>> CatchAsync<TException>(Func<Task> a
         return Result<TException>.Success();
     }
 
+    /// <summary>
+    /// Awaits <paramref name="action"/>, a call that returns a <see cref="ValueTask{TResult}"/>, and
+    /// returns its value as a success, or the exception it threw as the error, whether before or after
+    /// its first <c>await</c>: <c>Result.CatchAsync(() => stream.ReadAsync(buffer))</c>.
+    /// See <see cref="CatchAsync{T}(Func{Task{T}})"/>.
+    /// </summary>
+    /// <remarks>
+    /// An <c>async</c> lambda converts to either delegate, so this overload has the lower priority and such
+    /// a lambda binds to the <see cref="Task{TResult}"/> form, as it did before this one existed. A lambda or
+    /// a method group that returns a <c>ValueTask</c> converts to this one alone.
+    /// </remarks>
+    /// <param name="action">The asynchronous call whose outcome is wanted.</param>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <returns>A success holding the value, or an error holding the exception thrown.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="action"/> is null, or its task produced null.</exception>
+    /// <exception cref="ArgumentException"><typeparamref name="T"/> is itself a task; await it in the delegate.</exception>
+    [OverloadResolutionPriority(-1)]
+    public static async Task<Result<T, Exception>> CatchAsync<T>(Func<ValueTask<T>> action) where T : notnull
+    {
+        ArgumentNullException.ThrowIfNull(action);
+        RefuseTask<T>(nameof(CatchAsync));
+
+        ValueTask<T> task;
+        try
+        {
+            task = action();
+        }
+        catch (Exception exception) when (!IsCancellation(exception))
+        {
+            return Result<T, Exception>.Error(exception);
+        }
+
+        T value;
+        try
+        {
+            value = await task.ConfigureAwait(false);
+        }
+        catch (Exception exception) when (!IsCancellation(exception))
+        {
+            return Result<T, Exception>.Error(exception);
+        }
+
+        return Result<T, Exception>.Success(value);
+    }
+
+    /// <summary>
+    /// Awaits <paramref name="action"/>, a call that returns a <see cref="ValueTask"/>, and returns a
+    /// success, or the exception it threw as the error. See <see cref="CatchAsync{T}(Func{ValueTask{T}})"/>.
+    /// </summary>
+    /// <param name="action">The asynchronous call whose outcome is wanted.</param>
+    /// <returns>A success, or an error holding the exception thrown.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="action"/> is null.</exception>
+    [OverloadResolutionPriority(-1)]
+    public static async Task<Result<Exception>> CatchAsync(Func<ValueTask> action)
+    {
+        ArgumentNullException.ThrowIfNull(action);
+
+        ValueTask task;
+        try
+        {
+            task = action();
+        }
+        catch (Exception exception) when (!IsCancellation(exception))
+        {
+            return Result<Exception>.Error(exception);
+        }
+
+        try
+        {
+            await task.ConfigureAwait(false);
+        }
+        catch (Exception exception) when (!IsCancellation(exception))
+        {
+            return Result<Exception>.Error(exception);
+        }
+
+        return Result<Exception>.Success();
+    }
+
+    /// <summary>
+    /// Awaits <paramref name="action"/>, a call that returns a <see cref="ValueTask{TResult}"/>, and
+    /// returns its value as a success, or the <typeparamref name="TException"/> it threw as the error. Any
+    /// other exception propagates. See <see cref="CatchAsync{T}(Func{ValueTask{T}})"/>.
+    /// </summary>
+    /// <param name="action">The asynchronous call whose outcome is wanted.</param>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <typeparam name="TException">The exception that is an outcome; any other propagates.</typeparam>
+    /// <returns>A success holding the value, or an error holding the exception thrown.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="action"/> is null, or its task produced null.</exception>
+    /// <exception cref="ArgumentException"><typeparamref name="T"/> is itself a task; await it in the delegate.</exception>
+    [OverloadResolutionPriority(-1)]
+    public static async Task<Result<T, TException>> CatchAsync<T, TException>(Func<ValueTask<T>> action)
+        where T : notnull
+        where TException : Exception
+    {
+        ArgumentNullException.ThrowIfNull(action);
+        RefuseTask<T>(nameof(CatchAsync));
+
+        ValueTask<T> task;
+        try
+        {
+            task = action();
+        }
+        catch (TException exception) when (!IsCancellation(exception))
+        {
+            return Result<T, TException>.Error(exception);
+        }
+
+        T value;
+        try
+        {
+            value = await task.ConfigureAwait(false);
+        }
+        catch (TException exception) when (!IsCancellation(exception))
+        {
+            return Result<T, TException>.Error(exception);
+        }
+
+        return Result<T, TException>.Success(value);
+    }
+
+    /// <summary>
+    /// Awaits <paramref name="action"/>, a call that returns a <see cref="ValueTask"/>, and returns a
+    /// success, or the <typeparamref name="TException"/> it threw as the error. Any other exception
+    /// propagates. See <see cref="CatchAsync{T}(Func{ValueTask{T}})"/>.
+    /// </summary>
+    /// <param name="action">The asynchronous call whose outcome is wanted.</param>
+    /// <typeparam name="TException">The exception that is an outcome; any other propagates.</typeparam>
+    /// <returns>A success, or an error holding the exception thrown.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="action"/> is null.</exception>
+    [OverloadResolutionPriority(-1)]
+    public static async Task<Result<TException>> CatchAsync<TException>(Func<ValueTask> action)
+        where TException : Exception
+    {
+        ArgumentNullException.ThrowIfNull(action);
+
+        ValueTask task;
+        try
+        {
+            task = action();
+        }
+        catch (TException exception) when (!IsCancellation(exception))
+        {
+            return Result<TException>.Error(exception);
+        }
+
+        try
+        {
+            await task.ConfigureAwait(false);
+        }
+        catch (TException exception) when (!IsCancellation(exception))
+        {
+            return Result<TException>.Error(exception);
+        }
+
+        return Result<TException>.Success();
+    }
+
     /// <param name="instance">The result.</param>
     /// <typeparam name="T">The type of the value.</typeparam>
     /// <typeparam name="TError">The type of the error.</typeparam>
@@ -1226,6 +1385,138 @@ public async Task<Result<TError>> TraverseAsync<TError>(Func<T, CancellationToke
         }
     }
 
+    /// <param name="source">The stream.</param>
+    /// <typeparam name="T">The type of the elements.</typeparam>
+    extension<T>(IAsyncEnumerable<T> source)
+    {
+        /// <summary>
+        /// Applies an asynchronous operation that may fail to every element of a stream, one at a time
+        /// and in order, stopping at the first error: the next element is not read, nor its operation
+        /// started, after one failed, and the stream's enumerator is disposed.
+        /// </summary>
+        /// <param name="selector">Called with each element and awaited, until one fails.</param>
+        /// <typeparam name="TResult">The type of each produced value.</typeparam>
+        /// <typeparam name="TError">The type of the error.</typeparam>
+        /// <returns>A success with every produced value, in order, or the first error.</returns>
+        /// <exception cref="InvalidOperationException"><paramref name="selector"/> returned an uninitialized result.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="selector"/> returned no task.</exception>
+        public async Task<Result<IReadOnlyList<TResult>, TError>> TraverseAsync<TResult, TError>(Func<T, Task<Result<TResult, TError>>> selector)
+            where TResult : notnull
+            where TError : notnull
+        {
+            ArgumentNullException.ThrowIfNull(source);
+            ArgumentNullException.ThrowIfNull(selector);
+
+            var values = new List<TResult>();
+
+            await foreach (var element in source.ConfigureAwait(false))
+            {
+                var result = await ThrowHelper.Awaitable(selector(element), nameof(TraverseAsync), nameof(selector)).ConfigureAwait(false);
+                if (!result.TryGetValue(out var value, out var error)) return Result<IReadOnlyList<TResult>, TError>.Error(error);
+
+                values.Add(value);
+            }
+
+            return Result<IReadOnlyList<TResult>, TError>.Success(values);
+        }
+
+        /// <summary>
+        /// Applies an asynchronous operation that may fail to every element of a stream, one at a time
+        /// and in order, stopping at the first error, with a cancellation token handed to the stream and
+        /// to each operation, and checked before each element is read and before each operation: once
+        /// cancelled, nothing more is read or started and the <see cref="OperationCanceledException"/>
+        /// propagates, since a cancellation is not an error.
+        /// </summary>
+        /// <param name="selector">Called with each element and the token, and awaited, until one fails.</param>
+        /// <param name="cancellationToken">Handed to the stream's enumerator and to each operation, and checked before each.</param>
+        /// <typeparam name="TResult">The type of each produced value.</typeparam>
+        /// <typeparam name="TError">The type of the error.</typeparam>
+        /// <returns>A success with every produced value, in order, or the first error.</returns>
+        /// <exception cref="InvalidOperationException"><paramref name="selector"/> returned an uninitialized result.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="selector"/> returned no task.</exception>
+        /// <exception cref="OperationCanceledException"><paramref name="cancellationToken"/> was cancelled before an element was read or an operation started.</exception>
+        public async Task<Result<IReadOnlyList<TResult>, TError>> TraverseAsync<TResult, TError>(Func<T, CancellationToken, Task<Result<TResult, TError>>> selector, CancellationToken cancellationToken)
+            where TResult : notnull
+            where TError : notnull
+        {
+            ArgumentNullException.ThrowIfNull(source);
+            ArgumentNullException.ThrowIfNull(selector);
+
+            var values = new List<TResult>();
+
+            cancellationToken.ThrowIfCancellationRequested();
+            await foreach (var element in source.WithCancellation(cancellationToken).ConfigureAwait(false))
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                var result = await ThrowHelper.Awaitable(selector(element, cancellationToken), nameof(TraverseAsync), nameof(selector)).ConfigureAwait(false);
+                if (!result.TryGetValue(out var value, out var error)) return Result<IReadOnlyList<TResult>, TError>.Error(error);
+
+                values.Add(value);
+                cancellationToken.ThrowIfCancellationRequested();
+            }
+
+            return Result<IReadOnlyList<TResult>, TError>.Success(values);
+        }
+
+        /// <summary>
+        /// Applies an asynchronous command that may fail to every element of a stream, one at a time and
+        /// in order, stopping at the first error: the next element is not read, nor its command started,
+        /// after one failed, and the stream's enumerator is disposed.
+        /// </summary>
+        /// <param name="selector">Called with each element and awaited, until one fails.</param>
+        /// <typeparam name="TError">The type of the error.</typeparam>
+        /// <returns>A success if every command succeeded, or the first error.</returns>
+        /// <exception cref="InvalidOperationException"><paramref name="selector"/> returned an uninitialized result.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="selector"/> returned no task.</exception>
+        public async Task<Result<TError>> TraverseAsync<TError>(Func<T, Task<Result<TError>>> selector) where TError : notnull
+        {
+            ArgumentNullException.ThrowIfNull(source);
+            ArgumentNullException.ThrowIfNull(selector);
+
+            await foreach (var element in source.ConfigureAwait(false))
+            {
+                var result = await ThrowHelper.Awaitable(selector(element), nameof(TraverseAsync), nameof(selector)).ConfigureAwait(false);
+                if (result.TryGetError(out var error)) return Result<TError>.Error(error);
+            }
+
+            return Result<TError>.Success();
+        }
+
+        /// <summary>
+        /// Applies an asynchronous command that may fail to every element of a stream, one at a time and
+        /// in order, stopping at the first error, with a cancellation token handed to the stream and to
+        /// each command, and checked before each element is read and before each command: once
+        /// cancelled, nothing more is read or started and the <see cref="OperationCanceledException"/>
+        /// propagates, since a cancellation is not an error.
+        /// </summary>
+        /// <param name="selector">Called with each element and the token, and awaited, until one fails.</param>
+        /// <param name="cancellationToken">Handed to the stream's enumerator and to each command, and checked before each.</param>
+        /// <typeparam name="TError">The type of the error.</typeparam>
+        /// <returns>A success if every command succeeded, or the first error.</returns>
+        /// <exception cref="InvalidOperationException"><paramref name="selector"/> returned an uninitialized result.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="selector"/> returned no task.</exception>
+        /// <exception cref="OperationCanceledException"><paramref name="cancellationToken"/> was cancelled before an element was read or a command started.</exception>
+        public async Task<Result<TError>> TraverseAsync<TError>(Func<T, CancellationToken, Task<Result<TError>>> selector, CancellationToken cancellationToken) where TError : notnull
+        {
+            ArgumentNullException.ThrowIfNull(source);
+            ArgumentNullException.ThrowIfNull(selector);
+
+            cancellationToken.ThrowIfCancellationRequested();
+            await foreach (var element in source.WithCancellation(cancellationToken).ConfigureAwait(false))
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                var result = await ThrowHelper.Awaitable(selector(element, cancellationToken), nameof(TraverseAsync), nameof(selector)).ConfigureAwait(false);
+                if (result.TryGetError(out var error)) return Result<TError>.Error(error);
+
+                cancellationToken.ThrowIfCancellationRequested();
+            }
+
+            return Result<TError>.Success();
+        }
+    }
+
     /// <param name="results">The results.</param>
     /// <typeparam name="T">The type of the values.</typeparam>
     /// <typeparam name="TError">The type of the error.</typeparam>
@@ -1276,6 +1567,66 @@ public Result<TError> Sequence()
         }
     }
 
+    /// <param name="results">The stream of results.</param>
+    /// <typeparam name="T">The type of the values.</typeparam>
+    /// <typeparam name="TError">The type of the error.</typeparam>
+    extension<T, TError>(IAsyncEnumerable<Result<T, TError>> results) where T : notnull where TError : notnull
+    {
+        /// <summary>Every value of a stream, if every result in it is a success.</summary>
+        /// <param name="cancellationToken">Handed to the stream's enumerator, and checked before each result is read.</param>
+        /// <returns>
+        /// A success with every value, in order, or the first error. After an error nothing more is read
+        /// and the stream's enumerator is disposed.
+        /// </returns>
+        /// <exception cref="InvalidOperationException">A result up to the first error is uninitialized.</exception>
+        /// <exception cref="OperationCanceledException"><paramref name="cancellationToken"/> was cancelled before a result was read.</exception>
+        public async Task<Result<IReadOnlyList<T>, TError>> SequenceAsync(CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(results);
+
+            var values = new List<T>();
+
+            cancellationToken.ThrowIfCancellationRequested();
+            await foreach (var result in results.WithCancellation(cancellationToken).ConfigureAwait(false))
+            {
+                if (!result.TryGetValue(out var value, out var error)) return Result<IReadOnlyList<T>, TError>.Error(error);
+
+                values.Add(value);
+                cancellationToken.ThrowIfCancellationRequested();
+            }
+
+            return Result<IReadOnlyList<T>, TError>.Success(values);
+        }
+    }
+
+    /// <param name="results">The stream of results.</param>
+    /// <typeparam name="TError">The type of the error.</typeparam>
+    extension<TError>(IAsyncEnumerable<Result<TError>> results) where TError : notnull
+    {
+        /// <summary>A success if every result of a stream is one.</summary>
+        /// <param name="cancellationToken">Handed to the stream's enumerator, and checked before each result is read.</param>
+        /// <returns>
+        /// A success, or the first error. After an error nothing more is read and the stream's enumerator
+        /// is disposed.
+        /// </returns>
+        /// <exception cref="InvalidOperationException">A result up to the first error is uninitialized.</exception>
+        /// <exception cref="OperationCanceledException"><paramref name="cancellationToken"/> was cancelled before a result was read.</exception>
+        public async Task<Result<TError>> SequenceAsync(CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(results);
+
+            cancellationToken.ThrowIfCancellationRequested();
+            await foreach (var result in results.WithCancellation(cancellationToken).ConfigureAwait(false))
+            {
+                if (result.TryGetError(out var error)) return Result<TError>.Error(error);
+
+                cancellationToken.ThrowIfCancellationRequested();
+            }
+
+            return Result<TError>.Success();
+        }
+    }
+
     /// <param name="option">An optional input that is validated when present.</param>
     /// <typeparam name="T">The type of the value.</typeparam>
     /// <typeparam name="TError">The type of the error.</typeparam>
@@ -1337,6 +1688,57 @@ public Result<Option<TResult>, TError> Traverse<TResult, TError>(Func<T, Result<
 
             return option.Map(selector).Transpose();
         }
+
+        /// <summary>
+        /// Applies an asynchronous operation that may fail to the value, if there is one: an optional
+        /// input checked against a store when present, <c>await request.Coupon.TraverseAsync(coupons.FindAsync)</c>.
+        /// For <c>None</c> the selector is not called.
+        /// </summary>
+        /// <param name="selector">Called with the value if there is one, and awaited.</param>
+        /// <typeparam name="TResult">The type of the produced value.</typeparam>
+        /// <typeparam name="TError">The type of the error.</typeparam>
+        /// <returns>A success with no value for <c>None</c>, a success with the produced value, or its error.</returns>
+        /// <exception cref="InvalidOperationException"><paramref name="selector"/> returned an uninitialized result.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="selector"/> returned no task.</exception>
+        public async Task<Result<Option<TResult>, TError>> TraverseAsync<TResult, TError>(Func<T, Task<Result<TResult, TError>>> selector)
+            where TResult : notnull
+            where TError : notnull
+        {
+            ArgumentNullException.ThrowIfNull(selector);
+
+            if (!option.TryGetValue(out var value)) return Result<Option<TResult>, TError>.Success(Option.None<TResult>());
+
+            var result = await ThrowHelper.Awaitable(selector(value), nameof(TraverseAsync), nameof(selector)).ConfigureAwait(false);
+            return result.Map(static produced => Option.Some(produced));
+        }
+
+        /// <summary>
+        /// Applies an asynchronous operation that may fail to the value, if there is one, with a
+        /// cancellation token handed to the operation and checked before it: once cancelled, the
+        /// operation is not started and the <see cref="OperationCanceledException"/> propagates, since a
+        /// cancellation is not an error. For <c>None</c> the selector is not called and the token not checked.
+        /// </summary>
+        /// <param name="selector">Called with the value and the token if there is a value, and awaited.</param>
+        /// <param name="cancellationToken">Checked before the operation, and handed to it.</param>
+        /// <typeparam name="TResult">The type of the produced value.</typeparam>
+        /// <typeparam name="TError">The type of the error.</typeparam>
+        /// <returns>A success with no value for <c>None</c>, a success with the produced value, or its error.</returns>
+        /// <exception cref="InvalidOperationException"><paramref name="selector"/> returned an uninitialized result.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="selector"/> returned no task.</exception>
+        /// <exception cref="OperationCanceledException"><paramref name="cancellationToken"/> was cancelled before the operation started.</exception>
+        public async Task<Result<Option<TResult>, TError>> TraverseAsync<TResult, TError>(Func<T, CancellationToken, Task<Result<TResult, TError>>> selector, CancellationToken cancellationToken)
+            where TResult : notnull
+            where TError : notnull
+        {
+            ArgumentNullException.ThrowIfNull(selector);
+
+            if (!option.TryGetValue(out var value)) return Result<Option<TResult>, TError>.Success(Option.None<TResult>());
+
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var result = await ThrowHelper.Awaitable(selector(value, cancellationToken), nameof(TraverseAsync), nameof(selector)).ConfigureAwait(false);
+            return result.Map(static produced => Option.Some(produced));
+        }
     }
 
     /// <param name="patch">A field of a merge patch, validated when it carries a value.</param>
@@ -1365,6 +1767,61 @@ public Result<Patch<TResult>, TError> Traverse<TResult, TError>(Func<T, Result<T
 
             return selector(value).Map(static produced => Patch.Value(produced));
         }
+
+        /// <summary>
+        /// Applies an asynchronous operation that may fail to the value, if the field carried one: a
+        /// patch over what the request sent is checked against a store into a patch over the domain's
+        /// type, <c>await request.Manager.TraverseAsync(people.FindAsync)</c>. A clear or an absent field
+        /// passes through as it is, and the selector is not called.
+        /// </summary>
+        /// <param name="selector">Called with the value when the field carried one, and awaited.</param>
+        /// <typeparam name="TResult">The type of the produced value.</typeparam>
+        /// <typeparam name="TError">The type of the error.</typeparam>
+        /// <returns>A success holding a patch in the same state, with the produced value when the field carried one, or the error.</returns>
+        /// <exception cref="InvalidOperationException"><paramref name="selector"/> returned an uninitialized result.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="selector"/> returned no task.</exception>
+        public async Task<Result<Patch<TResult>, TError>> TraverseAsync<TResult, TError>(Func<T, Task<Result<TResult, TError>>> selector)
+            where TResult : notnull
+            where TError : notnull
+        {
+            ArgumentNullException.ThrowIfNull(selector);
+
+            if (!patch.TryGetValue(out var value))
+                return Result<Patch<TResult>, TError>.Success(patch.State == PatchState.Null ? Patch.Null<TResult>() : Patch.Absent<TResult>());
+
+            var result = await ThrowHelper.Awaitable(selector(value), nameof(TraverseAsync), nameof(selector)).ConfigureAwait(false);
+            return result.Map(static produced => Patch.Value(produced));
+        }
+
+        /// <summary>
+        /// Applies an asynchronous operation that may fail to the value, if the field carried one, with a
+        /// cancellation token handed to the operation and checked before it: once cancelled, the
+        /// operation is not started and the <see cref="OperationCanceledException"/> propagates, since a
+        /// cancellation is not an error. A clear or an absent field passes through as it is, and neither the
+        /// selector is called nor the token checked.
+        /// </summary>
+        /// <param name="selector">Called with the value and the token when the field carried one, and awaited.</param>
+        /// <param name="cancellationToken">Checked before the operation, and handed to it.</param>
+        /// <typeparam name="TResult">The type of the produced value.</typeparam>
+        /// <typeparam name="TError">The type of the error.</typeparam>
+        /// <returns>A success holding a patch in the same state, with the produced value when the field carried one, or the error.</returns>
+        /// <exception cref="InvalidOperationException"><paramref name="selector"/> returned an uninitialized result.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="selector"/> returned no task.</exception>
+        /// <exception cref="OperationCanceledException"><paramref name="cancellationToken"/> was cancelled before the operation started.</exception>
+        public async Task<Result<Patch<TResult>, TError>> TraverseAsync<TResult, TError>(Func<T, CancellationToken, Task<Result<TResult, TError>>> selector, CancellationToken cancellationToken)
+            where TResult : notnull
+            where TError : notnull
+        {
+            ArgumentNullException.ThrowIfNull(selector);
+
+            if (!patch.TryGetValue(out var value))
+                return Result<Patch<TResult>, TError>.Success(patch.State == PatchState.Null ? Patch.Null<TResult>() : Patch.Absent<TResult>());
+
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var result = await ThrowHelper.Awaitable(selector(value, cancellationToken), nameof(TraverseAsync), nameof(selector)).ConfigureAwait(false);
+            return result.Map(static produced => Patch.Value(produced));
+        }
     }
 
     /// <summary>
diff --git a/src/CodoMetis.TypeKit/SequenceOptionExtensions.cs b/src/CodoMetis.TypeKit/SequenceOptionExtensions.cs
index d74e9935..7f10c7dd 100644
--- a/src/CodoMetis.TypeKit/SequenceOptionExtensions.cs
+++ b/src/CodoMetis.TypeKit/SequenceOptionExtensions.cs
@@ -1,7 +1,7 @@
 namespace CodoMetis.TypeKit;
 
 /// <summary>
-/// <c>Choose(selector)</c> over a sequence whose elements may be null: only what the selector finds
+/// <c>Choose(selector)</c> over a sequence or a stream whose elements may be null: only what the selector finds
 /// must be non-null, so a sequence of <c>string?</c> or <c>int?</c> is chosen from without a warning,
 /// its nulls the selector's to answer. The other sequence members, <c>Choose()</c> over options among
 /// them, are on <see cref="Option"/>.
@@ -35,4 +35,26 @@ public IEnumerable<TResult> Choose<TResult>(Func<T, Option<TResult>> selector) w
             return Option.Chosen(source, selector);
         }
     }
+
+    /// <param name="source">The stream, whose elements may be null.</param>
+    /// <typeparam name="T">The type of the elements, nullable or not.</typeparam>
+    extension<T>(IAsyncEnumerable<T> source)
+    {
+        /// <summary>
+        /// The values <paramref name="selector"/> finds in a stream, as they arrive: for each element it
+        /// answers with <c>Some</c>, that value, in order, and nothing for a <c>None</c>. Lazy, as an async
+        /// LINQ operator is, and the token given to <c>WithCancellation</c> or <c>GetAsyncEnumerator</c>
+        /// reaches the stream it reads.
+        /// </summary>
+        /// <param name="selector">Called with each element as the stream is read.</param>
+        /// <typeparam name="TResult">The type of the values.</typeparam>
+        /// <returns>The values found, in order.</returns>
+        public IAsyncEnumerable<TResult> Choose<TResult>(Func<T, Option<TResult>> selector) where TResult : notnull
+        {
+            ArgumentNullException.ThrowIfNull(source);
+            ArgumentNullException.ThrowIfNull(selector);
+
+            return Option.Chosen(source, selector);
+        }
+    }
 }
diff --git a/src/Directory.Build.targets b/src/Directory.Build.targets
index 0ba5aac4..ed2ddcbe 100644
--- a/src/Directory.Build.targets
+++ b/src/Directory.Build.targets
@@ -17,4 +17,63 @@
         <ProjectReference Include="$(MSBuildThisFileDirectory)CodoMetis.TypeKit.Analyzers/CodoMetis.TypeKit.Analyzers.csproj"
                           OutputItemType="Analyzer" ReferenceOutputAssembly="false" PrivateAssets="all" />
     </ItemGroup>
+
+    <!--
+      Release notes: the version's section of CHANGELOG.md, which nuget.org shows on its Release Notes
+      tab and Visual Studio on its Updates tab, followed by one line linking the whole changelog (#75).
+
+      Every package carries the whole section. The packages share one version and one changelog, every
+      satellite depends on the base package and through it on the analyzers, and a line's area names a
+      topic ("OpenAPI", "JSON"), not a package, so filtering by area would hide from a satellite's
+      reader a change that reaches them through the base package.
+
+      Plain text, because nuget.org shows release notes as plain text: measured 2026-10-20, it escapes
+      them, turns each line break into <br />, and links a bare URL, leaving the brackets of [text](url)
+      and every # * and backtick on the page (Bogus 35.6.5, Asp.Versioning.Http 10.2.3), and a URL in
+      parentheses linked without its closing one (RazorEngine 3.10.0). So [text](url) is written
+      text (url), and backticks, ** and the ### of a subheading are dropped.
+
+      Fails closed: a missing or empty section, a relative link (nothing on nuget.org resolves it), or
+      notes over nuget.org's 35,000 characters fail the pack, naming the file. The section of an
+      Unreleased version is read too, so a CI pack carries the notes of the commit it was built from.
+      PackageReleaseNotesTests holds every packed nuspec to this, and runs the target on a sample
+      changelog of every shape (ReleaseNotesChangelog) whatever the current section holds.
+    -->
+    <Target Name="ReleaseNotesFromChangelog" BeforeTargets="GenerateNuspec">
+        <PropertyGroup>
+            <ReleaseNotesChangelog Condition="'$(ReleaseNotesChangelog)' == ''">$([MSBuild]::GetDirectoryNameOfFileAbove('$(MSBuildThisFileDirectory)', 'CodoMetis.TypeKit.slnx'))/CHANGELOG.md</ReleaseNotesChangelog>
+        </PropertyGroup>
+
+        <Error Condition="!Exists('$(ReleaseNotesChangelog)')" Text="There is no $(ReleaseNotesChangelog) to take $(PackageId)'s release notes from." />
+
+        <PropertyGroup>
+            <_TypeKitChangelogText>$([System.Text.RegularExpressions.Regex]::Replace($([System.IO.File]::ReadAllText('$(ReleaseNotesChangelog)')), '\r', ''))</_TypeKitChangelogText>
+            <_TypeKitHeading>^## $([System.Text.RegularExpressions.Regex]::Escape('$(Version)'))(?: [^\n]*)?\n</_TypeKitHeading>
+            <_TypeKitHasSection>$([System.Text.RegularExpressions.Regex]::IsMatch('$(_TypeKitChangelogText)', '(?m)$(_TypeKitHeading)'))</_TypeKitHasSection>
+        </PropertyGroup>
+
+        <Error Condition="'$(_TypeKitHasSection)' != 'True'" File="$(ReleaseNotesChangelog)"
+               Text="CHANGELOG.md has no '## $(Version)' section, so $(PackageId) $(Version) would have no release notes. Add the section (CONTRIBUTING.md, Releasing)." />
+
+        <PropertyGroup>
+            <_TypeKitSection>$([System.Text.RegularExpressions.Regex]::Replace('$(_TypeKitChangelogText)', '(?sm)\A.*?$(_TypeKitHeading)(.*?)(?=^## |\z).*\z', '$1').Trim())</_TypeKitSection>
+            <_TypeKitRelativeLink>$([System.Text.RegularExpressions.Regex]::IsMatch('$(_TypeKitSection)', '\]\((?!https?://)'))</_TypeKitRelativeLink>
+        </PropertyGroup>
+
+        <Error Condition="'$(_TypeKitSection)' == ''" File="$(ReleaseNotesChangelog)"
+               Text="CHANGELOG.md's '## $(Version)' section is empty, so $(PackageId) $(Version) would have no release notes. Write the version's changes under it." />
+        <Error Condition="'$(_TypeKitRelativeLink)' == 'True'" File="$(ReleaseNotesChangelog)"
+               Text="CHANGELOG.md's '## $(Version)' section has a relative link, which nuget.org cannot resolve in the release notes. Link the absolute URL on GitHub." />
+
+        <PropertyGroup>
+            <_TypeKitNotes>$([System.Text.RegularExpressions.Regex]::Replace('$(_TypeKitSection)', '\[([^\]\n]+)\]\(([^)\s]+)\)', '$1 ($2)'))</_TypeKitNotes>
+            <_TypeKitNotes>$([System.Text.RegularExpressions.Regex]::Replace('$(_TypeKitNotes)', '(?m)^#{3,6} +', ''))</_TypeKitNotes>
+            <_TypeKitNotes>$(_TypeKitNotes.Replace('`', '').Replace('**', ''))</_TypeKitNotes>
+            <PackageReleaseNotes>$(_TypeKitNotes)%0A%0AFull changelog: $(PackageProjectUrl)/blob/main/CHANGELOG.md</PackageReleaseNotes>
+            <_TypeKitNotesLength>$([MSBuild]::Unescape('$(PackageReleaseNotes)').Length)</_TypeKitNotesLength>
+        </PropertyGroup>
+
+        <Error Condition="$(_TypeKitNotesLength) &gt; 35000" File="$(ReleaseNotesChangelog)"
+               Text="$(PackageId) $(Version)'s release notes, from CHANGELOG.md's '## $(Version)' section, are $(_TypeKitNotesLength) characters, over nuget.org's 35,000. Shorten the section's lines: their details belong in the docs they link." />
+    </Target>
 </Project>
diff --git a/test/CodoMetis.TypeKit.Analyzers.Tests/AnalyzerTest.cs b/test/CodoMetis.TypeKit.Analyzers.Tests/AnalyzerTest.cs
index 712ba855..061fe502 100644
--- a/test/CodoMetis.TypeKit.Analyzers.Tests/AnalyzerTest.cs
+++ b/test/CodoMetis.TypeKit.Analyzers.Tests/AnalyzerTest.cs
@@ -57,6 +57,13 @@ internal static class RealEntityFrameworkCore
     ];
 }
 
+/// <summary>The real test assertions, whose assertions on a pending value CMTK0003 knows by the assembly's identity.</summary>
+internal static class RealTesting
+{
+    public static MetadataReference Reference { get; } =
+        MetadataReference.CreateFromFile(typeof(global::CodoMetis.TypeKit.Testing.TypeKitAssertionException).Assembly.Location);
+}
+
 internal static class RealTypeKit
 {
     public static Assembly Assembly { get; } = typeof(Option<>).Assembly;
diff --git a/test/CodoMetis.TypeKit.Analyzers.Tests/CodoMetis.TypeKit.Analyzers.Tests.csproj b/test/CodoMetis.TypeKit.Analyzers.Tests/CodoMetis.TypeKit.Analyzers.Tests.csproj
index c6103ac4..a6513c17 100644
--- a/test/CodoMetis.TypeKit.Analyzers.Tests/CodoMetis.TypeKit.Analyzers.Tests.csproj
+++ b/test/CodoMetis.TypeKit.Analyzers.Tests/CodoMetis.TypeKit.Analyzers.Tests.csproj
@@ -12,6 +12,7 @@
         <ProjectReference Include="..\..\src\CodoMetis.TypeKit.Analyzers\CodeFixes\CodoMetis.TypeKit.Analyzers.CodeFixes.csproj" />
         <ProjectReference Include="..\..\src\CodoMetis.TypeKit\CodoMetis.TypeKit.csproj" />
         <ProjectReference Include="..\..\src\CodoMetis.TypeKit.EntityFrameworkCore\CodoMetis.TypeKit.EntityFrameworkCore.csproj" />
+        <ProjectReference Include="..\..\src\CodoMetis.TypeKit.Testing\CodoMetis.TypeKit.Testing.csproj" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/test/CodoMetis.TypeKit.Analyzers.Tests/DefaultProducingCallAnalyzerTests.cs b/test/CodoMetis.TypeKit.Analyzers.Tests/DefaultProducingCallAnalyzerTests.cs
index 8189a2ba..8158a56b 100644
--- a/test/CodoMetis.TypeKit.Analyzers.Tests/DefaultProducingCallAnalyzerTests.cs
+++ b/test/CodoMetis.TypeKit.Analyzers.Tests/DefaultProducingCallAnalyzerTests.cs
@@ -80,15 +80,17 @@ private static AnalyzerTest<DefaultProducingCallAnalyzer> TestWithEntityFramewor
     private static DiagnosticResult Cmtk0009(int location, string method, string type, string circumstance, string advice) =>
         new DiagnosticResult("CMTK0009", DiagnosticSeverity.Warning).WithLocation(location).WithArguments(method, type, circumstance, advice);
 
+    /// <summary>Both descriptors, the default instance's and the query condition's, are the one shipped rule.</summary>
     [Fact]
     public void The_descriptor_is_the_published_contract()
     {
-        var rule = new DefaultProducingCallAnalyzer().SupportedDiagnostics.ShouldHaveSingleItem();
+        var rules = new DefaultProducingCallAnalyzer().SupportedDiagnostics;
 
-        rule.Id.ShouldBe("CMTK0009");
-        rule.DefaultSeverity.ShouldBe(DiagnosticSeverity.Warning);
-        rule.Category.ShouldBe("Usage");
-        rule.IsEnabledByDefault.ShouldBeTrue();
+        rules.Length.ShouldBe(2);
+        rules.ShouldAllBe(rule => rule.Id == "CMTK0009"
+                               && rule.DefaultSeverity == DiagnosticSeverity.Warning
+                               && rule.Category == "Usage"
+                               && rule.IsEnabledByDefault);
     }
 
     [Fact]
diff --git a/test/CodoMetis.TypeKit.Analyzers.Tests/DroppedTaskVariantTests.cs b/test/CodoMetis.TypeKit.Analyzers.Tests/DroppedTaskVariantTests.cs
new file mode 100644
index 00000000..4f3544e4
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Analyzers.Tests/DroppedTaskVariantTests.cs
@@ -0,0 +1,70 @@
+using CodoMetis.TypeKit.Analyzers.Tests.Variants;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Testing;
+
+namespace CodoMetis.TypeKit.Analyzers.Tests;
+
+/// <summary>
+/// CMTK0003 over <see cref="DroppedTaskShapes"/>: a call's task dropped in every form and through every
+/// pass-through is reported, once per call that made it, and kept in any other use is silent.
+/// </summary>
+/// <remarks>
+/// The oracle is the rule's own statement, which each shape holds to: the statement's own call is reported
+/// whole, a branch's call at the branch, a combination of assertions at the combinator, and an awaited task
+/// only where what it completes with is a result, or a <c>WhenAny</c> that leaves every failure unobserved.
+/// An assertion of CodoMetis.TypeKit.Testing and a call that returns a task of a <c>Result</c> run through
+/// the same shapes, so the two forms of the rule agree on each (#152).
+/// </remarks>
+public sealed class DroppedTaskVariantTests
+{
+    public static TheoryData<string, string> Cases()
+    {
+        var cases = new TheoryData<string, string>();
+        foreach (var call in DroppedTaskShapes.Calls)
+        foreach (var form in DroppedTaskShapes.Forms.Where(form => DroppedTaskShapes.Applies(form, call)))
+            cases.Add(call.Name, form.Name);
+
+        return cases;
+    }
+
+    [Theory]
+    [MemberData(nameof(Cases))]
+    public Task A_dropped_task_is_reported_in_every_form_and_a_kept_one_never(string name, string shape)
+    {
+        var call = DroppedTaskShapes.Calls.Single(candidate => candidate.Name == name);
+        var form = DroppedTaskShapes.Forms.Single(candidate => candidate.Name == shape);
+        var (source, expected) = DroppedTaskShapes.Use(call, form);
+
+        var test = new AnalyzerTest<IgnoredOutcomeAnalyzer>(source);
+        test.TestState.Sources.Add(("Declarations.cs", DroppedTaskShapes.Declarations));
+        test.TestState.AdditionalReferences.Add(RealTesting.Reference);
+        test.ExpectedDiagnostics.AddRange(
+            expected.Select((message, location) =>
+                new DiagnosticResult("CMTK0003", DiagnosticSeverity.Error).WithLocation(location).WithArguments(message.Outcome, message.Method)));
+
+        return test.RunAsync(TestContext.Current.CancellationToken);
+    }
+
+    /// <summary>
+    /// Every axis of the catalogue reaches the sweep, and each call has a form that reports and one that keeps:
+    /// a shape that compiles to no case would pass as silent.
+    /// </summary>
+    [Fact]
+    public void Every_shape_makes_a_case()
+    {
+        foreach (var call in DroppedTaskShapes.Calls)
+        {
+            var uses = DroppedTaskShapes.Forms.Where(form => DroppedTaskShapes.Applies(form, call)).Select(form => DroppedTaskShapes.Use(call, form)).ToList();
+            var source = string.Concat(uses.Select(use => use.Source));
+
+            foreach (var passThrough in DroppedTaskShapes.PassThroughs.Where(passThrough => passThrough.Suffix.Length > 0))
+                source.ShouldContain(passThrough.Suffix, customMessage: $"{call}: no case passes through {passThrough}.");
+
+            foreach (var use in DroppedTaskShapes.Uses)
+                source.ShouldContain($", {use.Name}\n", customMessage: $"{call}: no case is {use}.");
+
+            uses.ShouldContain(use => use.Expected.Count > 0, $"{call}: nothing is expected to be reported.");
+            uses.Where(use => use.Source.Contains("{|#", StringComparison.Ordinal)).Count().ShouldBeLessThan(uses.Count, $"{call}: every form reports, so no form keeps the task.");
+        }
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Analyzers.Tests/IgnoredOutcomeAnalyzerTests.cs b/test/CodoMetis.TypeKit.Analyzers.Tests/IgnoredOutcomeAnalyzerTests.cs
index a6961367..ca71528d 100644
--- a/test/CodoMetis.TypeKit.Analyzers.Tests/IgnoredOutcomeAnalyzerTests.cs
+++ b/test/CodoMetis.TypeKit.Analyzers.Tests/IgnoredOutcomeAnalyzerTests.cs
@@ -94,6 +94,166 @@ private static AnalyzerTest<IgnoredOutcomeAnalyzer> TestWithFile(string file, pa
         return test;
     }
 
+    /// <summary>The subjects, with the real test assertions referenced and imported.</summary>
+    private static AnalyzerTest<IgnoredOutcomeAnalyzer> TestWithAssertions(string code, params DiagnosticResult[] expected)
+    {
+        var test = Test("", expected);
+        test.TestState.AdditionalReferences.Add(RealTesting.Reference);
+        test.TestState.Sources.Add(("Caller.cs", "using System;\nusing System.Threading.Tasks;\nusing CodoMetis.TypeKit;\nusing CodoMetis.TypeKit.Testing;\n\n" + code));
+        return test;
+    }
+
+    /// <summary>
+    /// An assertion on a pending value fails the test only through the task it returns: dropped
+    /// unawaited, in a test method that is not <c>async</c> (where C# warns of nothing) or in one that is,
+    /// it passes whatever the value is.
+    /// </summary>
+    [Fact]
+    public Task A_dropped_assertion_on_a_pending_value_reports() =>
+        TestWithAssertions(
+            """
+            public static class Caller
+            {
+                public static void Run(Service service)
+                {
+                    {|#0:service.LoadAsync().ShouldBeSuccess()|};
+                    {|#1:service.FindAsync().ShouldBeNone()|};
+                    {|#2:service.SaveAsync().ShouldBeError(Fault.Refused)|};
+                    {|#3:service.LoadAsync().ShouldBeSuccess().ConfigureAwait(false)|};
+                    Action check = () => {|#4:service.FindAsync().ShouldBeSome()|};
+                }
+
+                public static async Task RunAsync(Service service)
+                {
+                    #pragma warning disable CS4014
+                    {|#5:service.LoadAsync().ShouldBeError()|};
+                    #pragma warning restore CS4014
+                    await Task.Yield();
+                }
+            }
+            """,
+            new DiagnosticResult("CMTK0003", DiagnosticSeverity.Error)
+                .WithLocation(0)
+                .WithMessage("The Task that 'ShouldBeSuccess' returns is ignored, so its outcome is never seen. Handle it, or discard it with '_ =' if nothing depends on it."),
+            Cmtk0003(1, "Task", "ShouldBeNone"),
+            Cmtk0003(2, "Task", "ShouldBeError"),
+            Cmtk0003(3, "Task", "ShouldBeSuccess"),
+            Cmtk0003(4, "Task", "ShouldBeSome"),
+            Cmtk0003(5, "Task", "ShouldBeError"))
+            .RunAsync(TestContext.Current.CancellationToken);
+
+    [Fact]
+    public Task An_awaited_held_or_discarded_assertion_is_silent() =>
+        TestWithAssertions(
+            """
+            public static class Caller
+            {
+                public static async Task RunAsync(Service service)
+                {
+                    await service.LoadAsync().ShouldBeSuccess();
+                    await service.FindAsync().ShouldBeNone().ConfigureAwait(false);
+                    var pending = service.LoadAsync().ShouldBeSuccess();
+                    await pending;
+                    _ = service.SaveAsync().ShouldBeSuccess();
+                    service.Load().ShouldBeSuccess();
+                }
+
+                public static Task Returned(Service service) => service.FindAsync().ShouldBeNone();
+
+                public static Func<Task> Deferred(Service service) => () => service.FindAsync().ShouldBeNone();
+            }
+            """)
+            .RunAsync(TestContext.Current.CancellationToken);
+
+    /// <summary>
+    /// Only the package's own assertions are reported: the same shape from any other assembly, a
+    /// consumer's own extension on a pending result among them, built before 2.3 and builds still.
+    /// </summary>
+    [Fact]
+    public Task A_task_of_another_assembly_s_extension_on_a_pending_value_is_silent() =>
+        TestWithAssertions(
+            """
+            public static class Logging
+            {
+                public static Task LogAsync<T>(this Task<Result<T, Fault>> pending) where T : notnull => pending;
+
+                public static Task ShouldBeSuccess<T>(this Task<Option<T>> pending) where T : notnull => pending;
+            }
+
+            public static class Caller
+            {
+                public static void Run(Service service)
+                {
+                    service.LoadAsync().LogAsync();
+                    Logging.ShouldBeSuccess(service.FindAsync());
+                }
+            }
+            """)
+            .RunAsync(TestContext.Current.CancellationToken);
+
+    /// <summary>
+    /// A <c>Task.WhenAny</c> inside a <c>Task.WhenAll</c> or a <c>Task.Run</c> completes with the faulted assertion
+    /// as its value, so awaiting the outer task sees no failure (#165). Awaiting what the <c>WhenAny</c> completes
+    /// with sees it.
+    /// </summary>
+    [Fact]
+    public Task An_assertion_a_nested_WhenAny_completes_with_reports_and_awaited_twice_is_silent() =>
+        TestWithAssertions(
+            """
+            public static class Caller
+            {
+                public static async Task Check(Task<Option<int>> first, Task<Option<int>> second)
+                {
+                    {|#0:await Task.WhenAll(Task.WhenAny(first.ShouldBeNone(), second.ShouldBeNone()))|};
+                    {|#1:await Task.Run(() => Task.WhenAny(first.ShouldBeNone(), second.ShouldBeNone()))|};
+                    {|#2:Task.WhenAll(Task.WhenAny(first.ShouldBeNone(), second.ShouldBeNone())).Wait()|};
+                    Func<Task> check = () => {|#3:Task.WhenAll(Task.WhenAny(first.ShouldBeNone(), second.ShouldBeNone()))|};
+                    await await Task.WhenAny(first.ShouldBeNone(), second.ShouldBeNone());
+                    await Task.WhenAll(Task.WhenAll(first.ShouldBeNone(), second.ShouldBeNone()));
+                }
+            }
+            """,
+            Cmtk0003(0, "Task", "WhenAll"),
+            Cmtk0003(1, "Task", "Run"),
+            Cmtk0003(2, "Task", "WhenAll"),
+            Cmtk0003(3, "Task", "WhenAll"))
+            .RunAsync(TestContext.Current.CancellationToken);
+
+    /// <summary>
+    /// A <c>catch</c> around an awaited assertion in an <c>async</c> lambda keeps its failure only when it can: a
+    /// <c>catch</c> that throws again, one of a type that cannot hold a <c>TypeKitAssertionException</c>, a look-alike
+    /// of that name among them, or one whose filter is a constant <c>false</c> hands it on to the dropped task (#166).
+    /// </summary>
+    [Fact]
+    public Task An_assertion_a_catch_cannot_keep_reports_and_one_it_keeps_is_silent() =>
+        TestWithAssertions(
+            """
+            using System.Linq;
+
+            public static class Lookalike
+            {
+                public sealed class TypeKitAssertionException : Exception { }
+            }
+
+            public static class Caller
+            {
+                public static void Check(Task<Option<int>> pending)
+                {
+                    {|#0:Task.WhenAll(new[] { pending }.Select(async item => { try { await item.ShouldBeNone(); } catch { throw; } }))|};
+                    {|#1:Task.WhenAll(new[] { pending }.Select(async item => { try { await item.ShouldBeNone(); } catch (OperationCanceledException) { } }))|};
+                    {|#2:Task.WhenAll(new[] { pending }.Select(async item => { try { await item.ShouldBeNone(); } catch (Exception) when (false) { } }))|};
+                    {|#3:Task.WhenAll(new[] { pending }.Select(async item => { try { await item.ShouldBeNone(); } catch (Lookalike.TypeKitAssertionException) { } }))|};
+                    Task.WhenAll(new[] { pending }.Select(async item => { try { await item.ShouldBeNone(); } catch (TypeKitAssertionException) { } }));
+                    Task.WhenAll(new[] { pending }.Select(async item => { try { await item.ShouldBeNone(); } catch (Exception exception) when (exception.Data.Count == 0) { } }));
+                }
+            }
+            """,
+            Cmtk0003(0, "Task", "WhenAll"),
+            Cmtk0003(1, "Task", "WhenAll"),
+            Cmtk0003(2, "Task", "WhenAll"),
+            Cmtk0003(3, "Task", "WhenAll"))
+            .RunAsync(TestContext.Current.CancellationToken);
+
     [Fact]
     public void The_descriptor_is_the_published_contract()
     {
@@ -170,6 +330,39 @@ public static void Run(Patch<int> quantity, Patch<string> nickname, List<int> se
             """)
             .RunAsync(TestContext.Current.CancellationToken);
 
+    /// <summary>
+    /// <c>Task.WhenAny</c> completes with a task of a result: dropped, awaited or not, converted to a plain
+    /// <c>Task</c> or waited for, the result of every task the statement made is gone (#159). Of tasks the
+    /// caller holds it completes with one of them, and drops nothing.
+    /// </summary>
+    [Fact]
+    public Task A_WhenAny_of_results_the_statement_made_reports_and_of_held_ones_is_silent() =>
+        Test(
+            """
+            public static class Caller
+            {
+                public static async Task Run(Service service, Task<Result<int, Fault>> held, Task<Result<int, Fault>> other, Task<Result<int, Fault>>[] all)
+                {
+                    {|#0:Task.WhenAny(service.LoadAsync(), service.LoadAsync())|};
+                    {|#1:await Task.WhenAny(held, service.LoadAsync())|};
+                    {|#2:Task.WhenAny(service.LoadAsync(), held).Wait()|};
+                    await Task.WhenAny(held, other);
+                    Task.WhenAny(held, other);
+                    await Task.WhenAny(all).ConfigureAwait(false);
+                    _ = Task.WhenAny(service.LoadAsync(), service.LoadAsync());
+                }
+
+                public static Task Converted(Service service) => {|#3:Task.WhenAny(service.LoadAsync(), service.LoadAsync())|};
+
+                public static Task Held(Task<Result<int, Fault>> held, Task<Result<int, Fault>> other) => Task.WhenAny(held, other);
+            }
+            """,
+            Cmtk0003(0, "Result", "WhenAny"),
+            Cmtk0003(1, "Result", "WhenAny"),
+            Cmtk0003(2, "Result", "WhenAny"),
+            Cmtk0003(3, "Result", "WhenAny"))
+            .RunAsync(TestContext.Current.CancellationToken);
+
     /// <summary>
     /// <c>ConfigureAwait</c> and <c>WaitAsync</c> hand on the task they are called on: a task the caller
     /// still holds keeps its result through them, as it does through <c>await held;</c>. They were
@@ -554,6 +747,50 @@ public static Task Save(Service service)
             Cmtk0003(3, "Result", "LoadAsync"))
             .RunAsync(TestContext.Current.CancellationToken);
 
+    /// <summary>
+    /// <c>SequenceAsync</c> and <c>TraverseAsync</c> over an async stream answer a <c>Task</c> of a result,
+    /// so dropping one reports as dropping <c>TraverseAsync</c> over a sequence does: awaited or not, and
+    /// converted to a plain <c>Task</c>. Kept or discarded with <c>_ =</c>, it is silent.
+    /// </summary>
+    [Fact]
+    public Task A_dropped_SequenceAsync_or_TraverseAsync_over_a_stream_reports_as_over_a_sequence() =>
+        Test(
+            """
+            public static class Caller
+            {
+                public static async Task Run(Service service, int[] ids, IAsyncEnumerable<int> stream, IAsyncEnumerable<Result<int, Fault>> values)
+                {
+                    {|#0:await ids.TraverseAsync(service.CancelAsync)|};
+                    {|#1:await stream.TraverseAsync(service.CancelAsync)|};
+                    {|#2:await stream.TraverseAsync((id, token) => service.LoadAsync(), default)|};
+                    {|#3:await service.SaveEachAsync(ids).SequenceAsync()|};
+                    {|#4:await values.SequenceAsync(default)|};
+                    #pragma warning disable CS4014
+                    {|#5:service.SaveEachAsync(ids).SequenceAsync()|};
+                    {|#6:stream.TraverseAsync(service.CancelAsync)|};
+                    #pragma warning restore CS4014
+
+                    _ = await values.SequenceAsync();
+                    var all = await stream.TraverseAsync(id => service.LoadAsync());
+                    if (await service.SaveEachAsync(ids).SequenceAsync()) { }
+                }
+
+                public static Task Drop(Service service, int[] ids) => {|#7:service.SaveEachAsync(ids).SequenceAsync()|};
+
+                public static Task DropEach(Service service, IAsyncEnumerable<int> stream) => {|#8:stream.TraverseAsync(service.CancelAsync)|};
+            }
+            """,
+            Cmtk0003(0, "Result", "TraverseAsync"),
+            Cmtk0003(1, "Result", "TraverseAsync"),
+            Cmtk0003(2, "Result", "TraverseAsync"),
+            Cmtk0003(3, "Result", "SequenceAsync"),
+            Cmtk0003(4, "Result", "SequenceAsync"),
+            Cmtk0003(5, "Result", "SequenceAsync"),
+            Cmtk0003(6, "Result", "TraverseAsync"),
+            Cmtk0003(7, "Result", "SequenceAsync"),
+            Cmtk0003(8, "Result", "TraverseAsync"))
+            .RunAsync(TestContext.Current.CancellationToken);
+
     /// <summary>A task that keeps its result type, an explicit cast, and a task the caller holds are not dropped by the conversion.</summary>
     [Fact]
     public Task A_task_of_a_result_that_keeps_its_type_is_cast_or_is_held_stays_silent() =>
diff --git a/test/CodoMetis.TypeKit.Analyzers.Tests/MissingCreateCodeFixTests.cs b/test/CodoMetis.TypeKit.Analyzers.Tests/MissingCreateCodeFixTests.cs
new file mode 100644
index 00000000..87962ddc
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Analyzers.Tests/MissingCreateCodeFixTests.cs
@@ -0,0 +1,529 @@
+using CodoMetis.TypeKit.ValueObjects;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+
+namespace CodoMetis.TypeKit.Analyzers.Tests;
+
+/// <summary>
+/// The fix for a validated value object without <c>Create</c>: the compiler's CS0535 at the interface,
+/// answered with a <c>Create</c> that accepts every value, laid out as the type is.
+/// </summary>
+/// <remarks>
+/// A second file declares the private constructor the generators add, so a fixed file that does not
+/// compile fails the test as the build would; the generation itself is the Samples' to show, from the
+/// block <c>The_README_s_block_is_what_the_fix_writes</c> holds to the fix.
+/// </remarks>
+public sealed class MissingCreateCodeFixTests
+{
+    private const string Usings =
+        """
+        using CodoMetis.TypeKit;
+        using CodoMetis.TypeKit.ValueObjects;
+
+
+        """;
+
+    [Fact]
+    public void The_names_the_fix_spells_are_the_contract_s()
+    {
+        MissingCreateCodeFixProvider.ValidatedValueMetadataName.ShouldBe(typeof(IValidatedValue<,,>).FullName);
+        typeof(IValidatedValue<,,>).Assembly.ShouldBe(RealTypeKit.Assembly);
+
+        var create = typeof(IValidatedValue<,,>).GetMethods().ShouldHaveSingleItem();
+        create.Name.ShouldBe(MissingCreateCodeFixProvider.CreateName);
+        create.GetParameters().ShouldHaveSingleItem().Name.ShouldBe("value");
+    }
+
+    [Fact]
+    public Task A_struct_declared_with_a_semicolon_gets_a_body_and_Create() =>
+        Fix(Usings + """
+            public enum NameFault { Blank, TooLong }
+
+            public readonly partial record struct Name : {|CS0535:IValidatedValue<Name, string, NameFault>|};
+            """,
+            Usings + """
+            public enum NameFault { Blank, TooLong }
+
+            public readonly partial record struct Name : IValidatedValue<Name, string, NameFault>
+            {
+                public static Result<Name, NameFault> Create(string value)
+                {
+                    // Add your rules: if (...) return Result.Error(NameFault.Blank);
+                    return new Name(value);
+                }
+            }
+            """,
+            Constructor("public readonly partial record struct Name", "string"));
+
+    [Fact]
+    public Task A_class_gets_Create_as_a_struct_does() =>
+        Fix(Usings + """
+            public enum CountFault { Negative }
+
+            public sealed partial record Count : {|CS0535:IValidatedValue<Count, int, CountFault>|};
+            """,
+            Usings + """
+            public enum CountFault { Negative }
+
+            public sealed partial record Count : IValidatedValue<Count, int, CountFault>
+            {
+                public static Result<Count, CountFault> Create(int value)
+                {
+                    // Add your rules: if (...) return Result.Error(CountFault.Negative);
+                    return new Count(value);
+                }
+            }
+            """,
+            Constructor("public sealed partial record Count", "int"));
+
+    [Fact]
+    public Task Create_comes_first_in_a_body_of_several_lines_a_blank_line_before_the_next_member() =>
+        Fix(Usings + """
+            public enum NameFault { Blank }
+
+            public readonly partial record struct Name : {|CS0535:IValidatedValue<Name, string, NameFault>|}
+            {
+                /// <summary>The name as it is shown.</summary>
+                public override string ToString() => "";
+            }
+            """,
+            Usings + """
+            public enum NameFault { Blank }
+
+            public readonly partial record struct Name : IValidatedValue<Name, string, NameFault>
+            {
+                public static Result<Name, NameFault> Create(string value)
+                {
+                    // Add your rules: if (...) return Result.Error(NameFault.Blank);
+                    return new Name(value);
+                }
+
+                /// <summary>The name as it is shown.</summary>
+                public override string ToString() => "";
+            }
+            """,
+            Constructor("public readonly partial record struct Name", "string"));
+
+    [Fact]
+    public Task An_empty_body_on_lines_of_its_own_keeps_its_braces_where_they_are() =>
+        Fix(Usings + """
+            public enum NameFault { Blank }
+
+            public readonly partial record struct Name : {|CS0535:IValidatedValue<Name, string, NameFault>|} {
+            }
+            """,
+            Usings + """
+            public enum NameFault { Blank }
+
+            public readonly partial record struct Name : IValidatedValue<Name, string, NameFault> {
+                public static Result<Name, NameFault> Create(string value)
+                {
+                    // Add your rules: if (...) return Result.Error(NameFault.Blank);
+                    return new Name(value);
+                }
+            }
+            """,
+            Constructor("public readonly partial record struct Name", "string"));
+
+    [Fact]
+    public Task An_empty_body_on_one_line_gets_a_body_on_lines_of_its_own() =>
+        Fix(Usings + """
+            public enum NameFault { Blank }
+
+            public readonly partial record struct Name : {|CS0535:IValidatedValue<Name, string, NameFault>|} { }
+            """,
+            Usings + """
+            public enum NameFault { Blank }
+
+            public readonly partial record struct Name : IValidatedValue<Name, string, NameFault>
+            {
+                public static Result<Name, NameFault> Create(string value)
+                {
+                    // Add your rules: if (...) return Result.Error(NameFault.Blank);
+                    return new Name(value);
+                }
+            }
+            """,
+            Constructor("public readonly partial record struct Name", "string"));
+
+    [Fact]
+    public Task A_body_on_one_line_that_holds_members_gets_no_fix() =>
+        NoFix(Usings + """
+            public enum NameFault { Blank }
+
+            public readonly partial record struct Name : {|CS0535:IValidatedValue<Name, string, NameFault>|} { public override string ToString() => ""; }
+            """,
+            Constructor("public readonly partial record struct Name", "string"));
+
+    [Fact]
+    public Task The_semicolon_s_comment_stays_after_the_body() =>
+        Fix(Usings + """
+            public enum NameFault { Blank }
+
+            public readonly partial record struct Name : {|CS0535:IValidatedValue<Name, string, NameFault>|}; // a person's name
+            """,
+            Usings + """
+            public enum NameFault { Blank }
+
+            public readonly partial record struct Name : IValidatedValue<Name, string, NameFault>
+            {
+                public static Result<Name, NameFault> Create(string value)
+                {
+                    // Add your rules: if (...) return Result.Error(NameFault.Blank);
+                    return new Name(value);
+                }
+            } // a person's name
+            """,
+            Constructor("public readonly partial record struct Name", "string"));
+
+    [Fact]
+    public Task A_nested_value_object_in_a_generic_type_is_indented_and_named_as_it_stands() =>
+        Fix(Usings + """
+            namespace Shop
+            {
+                public partial class Catalog<TItem>
+                {
+                    public enum SkuFault { Blank }
+
+                    public readonly partial record struct Sku : {|CS0535:IValidatedValue<Sku, string, SkuFault>|};
+                }
+            }
+            """,
+            Usings + """
+            namespace Shop
+            {
+                public partial class Catalog<TItem>
+                {
+                    public enum SkuFault { Blank }
+
+                    public readonly partial record struct Sku : IValidatedValue<Sku, string, SkuFault>
+                    {
+                        public static Result<Sku, SkuFault> Create(string value)
+                        {
+                            // Add your rules: if (...) return Result.Error(SkuFault.Blank);
+                            return new Sku(value);
+                        }
+                    }
+                }
+            }
+            """,
+            """
+            namespace Shop
+            {
+                public partial class Catalog<TItem>
+                {
+                    public readonly partial record struct Sku { private Sku(string value) { } }
+                }
+            }
+            """);
+
+    [Fact]
+    public Task Types_of_a_namespace_the_file_does_not_import_are_qualified() =>
+        Fix("""
+            namespace Faults { public enum WeightFault { Negative } }
+
+            public readonly partial record struct Weight : {|CS0535:CodoMetis.TypeKit.ValueObjects.IValidatedValue<Weight, System.Text.StringBuilder, Faults.WeightFault>|};
+            """,
+            """
+            namespace Faults { public enum WeightFault { Negative } }
+
+            public readonly partial record struct Weight : CodoMetis.TypeKit.ValueObjects.IValidatedValue<Weight, System.Text.StringBuilder, Faults.WeightFault>
+            {
+                public static CodoMetis.TypeKit.Result<Weight, Faults.WeightFault> Create(System.Text.StringBuilder value)
+                {
+                    // Add your rules: if (...) return Result.Error(Faults.WeightFault.Negative);
+                    return new Weight(value);
+                }
+            }
+            """,
+            Constructor("public readonly partial record struct Weight", "System.Text.StringBuilder"));
+
+    [Fact]
+    public Task A_fault_that_is_no_enum_leaves_the_example_open() =>
+        Fix(Usings + """
+            public sealed record CodeFault(string Reason);
+
+            public readonly partial record struct Code : {|CS0535:IValidatedValue<Code, string, CodeFault>|};
+            """,
+            Usings + """
+            public sealed record CodeFault(string Reason);
+
+            public readonly partial record struct Code : IValidatedValue<Code, string, CodeFault>
+            {
+                public static Result<Code, CodeFault> Create(string value)
+                {
+                    // Add your rules: if (...) return Result.Error(...);
+                    return new Code(value);
+                }
+            }
+            """,
+            Constructor("public readonly partial record struct Code", "string"));
+
+    [Fact]
+    public Task A_file_indented_with_tabs_and_ending_lines_in_CRLF_stays_so() =>
+        Fix(Crlf(Usings + "namespace Shop\n{\n\tpublic enum NameFault { Blank }\n\n\tpublic readonly partial record struct Name : {|CS0535:IValidatedValue<Name, string, NameFault>|};\n}\n"),
+            Crlf(Usings + "namespace Shop\n{\n\tpublic enum NameFault { Blank }\n\n\tpublic readonly partial record struct Name : IValidatedValue<Name, string, NameFault>\n\t{\n"
+               + "\t\tpublic static Result<Name, NameFault> Create(string value)\n\t\t{\n\t\t\t// Add your rules: if (...) return Result.Error(NameFault.Blank);\n"
+               + "\t\t\treturn new Name(value);\n\t\t}\n\t}\n}\n"),
+            "namespace Shop { public readonly partial record struct Name { private Name(string value) { } } }");
+
+    /// <summary>
+    /// A file whose line endings are mixed, as one with CRLF usings and LF code is on a Windows checkout:
+    /// the lines added end as the declaration's do, not as the file's first line.
+    /// </summary>
+    [Fact]
+    public Task In_a_file_of_mixed_line_endings_the_body_ends_as_the_declaration_s_lines_do() =>
+        Fix("using CodoMetis.TypeKit;\r\nusing CodoMetis.TypeKit.ValueObjects;\r\n\r\npublic enum NameFault { Blank }\n\n"
+          + "public readonly partial record struct Name : {|CS0535:IValidatedValue<Name, string, NameFault>|};",
+            "using CodoMetis.TypeKit;\r\nusing CodoMetis.TypeKit.ValueObjects;\r\n\r\npublic enum NameFault { Blank }\n\n"
+          + "public readonly partial record struct Name : IValidatedValue<Name, string, NameFault>\n{\n"
+          + "    public static Result<Name, NameFault> Create(string value)\n    {\n"
+          + "        // Add your rules: if (...) return Result.Error(NameFault.Blank);\n        return new Name(value);\n    }\n}",
+            Constructor("public readonly partial record struct Name", "string"));
+
+    [Fact]
+    public Task The_interface_brought_by_an_interface_of_the_application_is_fixed_too() =>
+        Fix(Usings + """
+            public enum NameFault { Blank }
+
+            public interface IName<TSelf> : IValidatedValue<TSelf, string, NameFault> where TSelf : IName<TSelf>;
+
+            public readonly partial record struct Name : {|CS0535:IName<Name>|};
+            """,
+            Usings + """
+            public enum NameFault { Blank }
+
+            public interface IName<TSelf> : IValidatedValue<TSelf, string, NameFault> where TSelf : IName<TSelf>;
+
+            public readonly partial record struct Name : IName<Name>
+            {
+                public static Result<Name, NameFault> Create(string value)
+                {
+                    // Add your rules: if (...) return Result.Error(NameFault.Blank);
+                    return new Name(value);
+                }
+            }
+            """,
+            Constructor("public readonly partial record struct Name", "string"));
+
+    [Fact]
+    public Task The_part_that_names_the_interface_gets_Create_when_the_type_has_two() =>
+        new CodeFixTest<EmptyDiagnosticAnalyzer, MissingCreateCodeFixProvider>(
+            Usings + "public readonly partial record struct Name : {|CS0535:IValidatedValue<Name, string, NameFault>|};",
+            Usings + """
+            public readonly partial record struct Name : IValidatedValue<Name, string, NameFault>
+            {
+                public static Result<Name, NameFault> Create(string value)
+                {
+                    // Add your rules: if (...) return Result.Error(NameFault.Blank);
+                    return new Name(value);
+                }
+            }
+            """)
+            {
+                TestState  = { Sources = { ("Other.cs", OtherPart) } },
+                FixedState = { Sources = { ("Other.cs", OtherPart) } },
+            }
+            .RunAsync(TestContext.Current.CancellationToken);
+
+    private const string OtherPart =
+        """
+        public enum NameFault { Blank }
+
+        public readonly partial record struct Name
+        {
+            private Name(string value) { }
+
+            public override string ToString() => "";
+        }
+        """;
+
+    /// <summary>The instance to return is the other type's to build, not this one's.</summary>
+    [Fact]
+    public Task A_type_whose_TSelf_is_another_type_gets_no_fix() =>
+        NoFix(Usings + """
+            public enum NameFault { Blank }
+
+            public readonly partial record struct Name : IValidatedValue<Name, string, NameFault>
+            {
+                public static Result<Name, NameFault> Create(string value) => new Name(value);
+            }
+
+            public readonly partial record struct Alias : {|CS0535:IValidatedValue<Name, string, NameFault>|};
+            """,
+            Constructor("public readonly partial record struct Name", "string"));
+
+    /// <summary>
+    /// An instance <c>Create(string)</c> is CS8928, not CS0535, and a second <c>Create(string)</c> would not
+    /// compile (CS0111): the one there is the author's to correct.
+    /// </summary>
+    [Fact]
+    public Task An_instance_Create_of_the_wrapped_type_gets_no_fix() =>
+        NoFix(Usings + """
+            public enum NameFault { Blank }
+
+            public readonly partial record struct Name : {|CS8928:IValidatedValue<Name, string, NameFault>|}
+            {
+                public Result<Name, NameFault> Create(string value) => new Name(value);
+            }
+            """,
+            Constructor("public readonly partial record struct Name", "string"));
+
+    [Fact]
+    public Task A_Create_of_another_type_is_an_overload_and_the_fix_is_offered() =>
+        Fix(Usings + """
+            public enum NameFault { Blank }
+
+            public readonly partial record struct Name : {|CS0535:IValidatedValue<Name, string, NameFault>|}
+            {
+                public static Result<Name, NameFault> Create(char initial) => Result.Error(NameFault.Blank);
+            }
+            """,
+            Usings + """
+            public enum NameFault { Blank }
+
+            public readonly partial record struct Name : IValidatedValue<Name, string, NameFault>
+            {
+                public static Result<Name, NameFault> Create(string value)
+                {
+                    // Add your rules: if (...) return Result.Error(NameFault.Blank);
+                    return new Name(value);
+                }
+
+                public static Result<Name, NameFault> Create(char initial) => Result.Error(NameFault.Blank);
+            }
+            """,
+            Constructor("public readonly partial record struct Name", "string"));
+
+    /// <summary>Another interface's missing member is its own CS0535, at its own base type: not this fix's.</summary>
+    [Fact]
+    public Task Another_interface_s_missing_member_gets_no_fix() =>
+        NoFix(Usings + """
+            public enum NameFault { Blank }
+
+            public interface IShown { string Shown { get; } }
+
+            public readonly partial record struct Name : IValidatedValue<Name, string, NameFault>, {|CS0535:IShown|}
+            {
+                public static Result<Name, NameFault> Create(string value) => new Name(value);
+            }
+            """,
+            Constructor("public readonly partial record struct Name", "string"));
+
+    /// <summary>An <c>in</c> parameter is another signature (CS0535), and a second <c>Create(string)</c> beside it would not compile (CS0663).</summary>
+    [Fact]
+    public Task A_Create_taking_an_in_T_gets_no_fix() =>
+        NoFix(Usings + """
+            public enum NameFault { Blank }
+
+            public readonly partial record struct Name : {|CS0535:IValidatedValue<Name, string, NameFault>|}
+            {
+                public static Result<Name, NameFault> Create(in string value) => new Name(value);
+            }
+            """,
+            Constructor("public readonly partial record struct Name", "string"));
+
+    /// <summary>One interface that brings two missing members has a CS0535 for each: the fix is offered on Create's alone.</summary>
+    [Fact]
+    public async Task Of_two_members_one_interface_brings_the_fix_is_offered_on_Create_s()
+    {
+        var offered = await MissingCreateVariantTests.OfferedAsync(
+            Usings + """
+            public enum NameFault { Blank }
+
+            public interface IName<TSelf> : IValidatedValue<TSelf, string, NameFault> where TSelf : IName<TSelf> { string Shown { get; } }
+
+            public readonly partial record struct Name : IName<Name>;
+            """,
+            Constructor("public readonly partial record struct Name", "string"));
+
+        offered.Count.ShouldBe(2);
+        offered.Count(o => o.Offered).ShouldBe(1);
+    }
+
+    /// <summary>Another interface's own <c>Create</c> is missing too: the fix is offered at the contract, not there.</summary>
+    [Fact]
+    public async Task Another_interface_s_Create_gets_no_fix_beside_the_contract_s()
+    {
+        var offered = await MissingCreateVariantTests.OfferedAsync(
+            Usings + """
+            public enum NameFault { Blank }
+
+            public interface IFactory<TSelf> { static abstract TSelf Create(int seed); }
+
+            public readonly partial record struct Name : IValidatedValue<Name, string, NameFault>, IFactory<Name>;
+            """,
+            Constructor("public readonly partial record struct Name", "string"));
+
+        offered.ShouldBe([("IValidatedValue<Name, string, NameFault>", true), ("IFactory<Name>", false)], ignoreOrder: true);
+    }
+
+    /// <summary>Discovery is by the contract's identity: an interface of the application's own that shares its name gets no fix.</summary>
+    [Fact]
+    public async Task A_lookalike_IValidatedValue_of_the_application_gets_no_fix()
+    {
+        var offered = await MissingCreateVariantTests.OfferedAsync(
+            """
+            namespace Mine
+            {
+                public interface IValidatedValue<TSelf, T, TFault> { static abstract CodoMetis.TypeKit.Result<TSelf, TFault> Create(T value); }
+
+                public enum NameFault { Blank }
+
+                public readonly partial record struct Name : IValidatedValue<Name, string, NameFault>;
+            }
+            """,
+            "");
+
+        offered.ShouldBe([("IValidatedValue<Name, string, NameFault>", false)]);
+    }
+
+    [Fact]
+    public Task The_action_is_titled_Add_Create() =>
+        new CodeFixTest<EmptyDiagnosticAnalyzer, MissingCreateCodeFixProvider>(
+            Usings + "public enum F { A }\n\npublic readonly partial record struct N : {|CS0535:IValidatedValue<N, int, F>|};",
+            Usings + "public enum F { A }\n\npublic readonly partial record struct N : IValidatedValue<N, int, F>\n{\n    public static Result<N, F> Create(int value)\n    {\n"
+                   + "        // Add your rules: if (...) return Result.Error(F.A);\n        return new N(value);\n    }\n}")
+            {
+                TestState          = { Sources = { ("Generated.cs", Constructor("public readonly partial record struct N", "int")) } },
+                FixedState         = { Sources = { ("Generated.cs", Constructor("public readonly partial record struct N", "int")) } },
+                CodeActionVerifier = (action, verifier) => verifier.Equal("Add Create", action.Title),
+            }
+            .RunAsync(TestContext.Current.CancellationToken);
+
+    /// <summary>
+    /// The Generators README's block is what the fix writes for its declaration ended with <c>;</c>, as
+    /// you would type it: the Samples compile the same block, generated, so what the fix writes is shown,
+    /// compiled and generated in one place.
+    /// </summary>
+    [Fact]
+    public Task The_README_s_block_is_what_the_fix_writes()
+    {
+        var readme = File.ReadAllText(Path.Combine(AnalyzerHelpLinkTests.RepositoryRoot(), "src", "CodoMetis.TypeKit.Generators", "README.md")).Replace("\r\n", "\n");
+        var blocks = readme.Split("```csharp\n").Skip(1).Select(block => block[..block.IndexOf("```", StringComparison.Ordinal)].TrimEnd('\n'));
+        var block  = blocks.Single(candidate => candidate.Contains("// Add your rules:", StringComparison.Ordinal));
+
+        var lines       = block.Split('\n');
+        var declaration = Array.FindIndex(lines, line => line.Contains(" : IValidatedValue<", StringComparison.Ordinal));
+        var written     = string.Join('\n', lines.Take(declaration)) + '\n' + lines[declaration].Replace(" : IValidatedValue<", " : {|CS0535:IValidatedValue<") + "|};";
+        var self        = lines[declaration].Split(" : ")[0];
+
+        return Fix(Usings + written, Usings + block, Constructor(self, "string"));
+    }
+
+    /// <summary>The private constructor the generators add, in a file of its own as theirs is.</summary>
+    internal static string Constructor(string declaration, string wrapped) =>
+        $"{declaration} {{ private {declaration.Split(' ')[^1]}({wrapped} value) {{ }} }}";
+
+    private static string Crlf(string text) => text.Replace("\r\n", "\n").Replace("\n", "\r\n");
+
+    private static Task Fix(string source, string fixedSource, string generated) =>
+        new CodeFixTest<EmptyDiagnosticAnalyzer, MissingCreateCodeFixProvider>(source, fixedSource)
+            {
+                TestState  = { Sources = { ("Generated.cs", generated) } },
+                FixedState = { Sources = { ("Generated.cs", generated) } },
+            }
+            .RunAsync(TestContext.Current.CancellationToken);
+
+    private static Task NoFix(string source, string generated) => Fix(source, source, generated);
+}
diff --git a/test/CodoMetis.TypeKit.Analyzers.Tests/MissingCreateVariantTests.cs b/test/CodoMetis.TypeKit.Analyzers.Tests/MissingCreateVariantTests.cs
new file mode 100644
index 00000000..eb9c656d
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Analyzers.Tests/MissingCreateVariantTests.cs
@@ -0,0 +1,170 @@
+using System.Collections.Immutable;
+using System.Text.RegularExpressions;
+using CodoMetis.TypeKit.Analyzers.Tests.Variants;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Testing;
+
+namespace CodoMetis.TypeKit.Analyzers.Tests;
+
+/// <summary>
+/// The fix for a missing <c>Create</c> across its input class (design/adr/0095): what the wrapped type
+/// and the fault are (<see cref="TypeArgumentKinds"/>), and the declaration's shape and where it is
+/// nested. The oracle is the compiler's: before the fix the file fails only for the missing member,
+/// after it the file compiles and the type's <c>Create</c> implements the contract.
+/// </summary>
+/// <remarks>
+/// <see cref="TypeArgumentSites"/> does not apply: the fix reads a declaration's base list, not a type
+/// argument at a use. A kind that is no valid argument there is named below with the compiler's reason,
+/// so a kind that stops compiling is a failure, not a skip.
+/// </remarks>
+public sealed class MissingCreateVariantTests
+{
+    /// <summary>Kinds the declaration refuses before any fix, and the error it refuses them with.</summary>
+    private static readonly ImmutableDictionary<string, string> NotAnArgument = new Dictionary<string, string>
+    {
+        ["dynamic"] = "CS1966", // an interface's type argument cannot be dynamic
+    }.ToImmutableDictionary();
+
+    public static TheoryData<string> Kinds() => new(TypeArgumentKinds.All.Select(kind => kind.Name));
+
+    [Theory]
+    [MemberData(nameof(Kinds))]
+    public Task The_fix_compiles_whatever_the_wrapped_type_is(string kind) =>
+        Sweep(kind, (argument, _) => ("Subject", argument, "Shade"));
+
+    [Theory]
+    [MemberData(nameof(Kinds))]
+    public Task The_fix_compiles_whatever_the_fault_is(string kind) =>
+        Sweep(kind, (argument, _) => ("Subject", "string", argument));
+
+    public static TheoryData<string, string> Shapes() => new()
+    {
+        { "public readonly partial record struct", "" },
+        { "public partial record struct", "" },
+        { "public sealed partial record", "" },
+        { "public partial record", "" },
+        { "public readonly partial struct", "" },
+        { "public sealed partial class", "" },
+        { "public partial class", "" },
+        { "public readonly partial record struct", "class" },
+        { "public sealed partial record", "struct" },
+        { "public readonly partial record struct", "generic" },
+    };
+
+    [Theory]
+    [MemberData(nameof(Shapes))]
+    public async Task The_fix_compiles_whatever_the_declaration_s_shape(string declaration, string nesting)
+    {
+        var (open, close, outer) = nesting switch
+        {
+            "class"   => ("public partial class Outer\n{\n", "}\n", "public partial class Outer"),
+            "struct"  => ("public partial struct Outer\n{\n", "}\n", "public partial struct Outer"),
+            "generic" => ("public partial class Outer<TItem> where TItem : class\n{\n", "}\n", "public partial class Outer<TItem> where TItem : class"),
+            _         => ("", "", null),
+        };
+
+        var source    = $"{open}{declaration} Subject : CodoMetis.TypeKit.ValueObjects.IValidatedValue<Subject, string, Shade>;\n{close}";
+        var generated = Wrap(outer, MissingCreateCodeFixTests.Constructor($"{declaration} Subject", "string"));
+
+        await Verify(source, generated, nesting == "" ? "Subject" : nesting == "generic" ? "Outer`1+Subject" : "Outer+Subject");
+    }
+
+    private static async Task Sweep(string name, Func<string, TypeArgumentKind, (string Self, string Wrapped, string Fault)> shape)
+    {
+        var kind = TypeArgumentKinds.All.Single(candidate => candidate.Name == name);
+        var (self, wrapped, fault) = shape(kind.Argument, kind);
+
+        var holder    = $"public partial class Holder{kind.Parameters} {kind.Where}";
+        var source    = $"{holder}\n{{\n    public readonly partial record struct {self} : CodoMetis.TypeKit.ValueObjects.IValidatedValue<{self}, {wrapped}, {fault}>;\n}}\n";
+        // An attribute on a type parameter is written once: the parts' attributes merge (CS0579).
+        var bare      = $"public partial class Holder{Regex.Replace(kind.Parameters, @"\[[^\]]*\]\s*", "")} {kind.Where}";
+        var generated = $"{bare} {{ public readonly partial record struct {self} {{ private {self}({wrapped} value) {{ }} }} }}";
+        var metadata  = kind.Parameters.Length == 0 ? "Holder+Subject" : $"Holder`{kind.Parameters.Count(c => c == ',') + 1}+Subject";
+
+        if (NotAnArgument.TryGetValue(kind.Argument, out var refused))
+        {
+            var before = await CompileAsync(Project(source, generated));
+            before.GetDiagnostics(TestContext.Current.CancellationToken).Where(d => d.Severity == DiagnosticSeverity.Error).Select(d => d.Id).ShouldContain(refused);
+            return;
+        }
+
+        await Verify(source, generated, metadata);
+    }
+
+    private static async Task Verify(string source, string generated, string metadataName)
+    {
+        var cancellationToken = TestContext.Current.CancellationToken;
+        var project           = Project(source, generated);
+        var before            = await CompileAsync(project);
+
+        var errors = before.GetDiagnostics(cancellationToken).Where(d => d.Severity == DiagnosticSeverity.Error).ToList();
+        errors.Select(d => d.Id).ShouldBe(["CS0535"], string.Join(Environment.NewLine, errors));
+
+        var document = project.Documents.Single(d => d.Name == "Subject.cs");
+        var actions  = new List<CodeAction>();
+        var context  = new CodeFixContext(document, errors[0], (action, _) => actions.Add(action), cancellationToken);
+
+        await new MissingCreateCodeFixProvider().RegisterCodeFixesAsync(context);
+        var action = actions.ShouldHaveSingleItem();
+
+        var operations = await action.GetOperationsAsync(cancellationToken);
+        var solution   = operations.OfType<ApplyChangesOperation>().Single().ChangedSolution;
+        var after      = await CompileAsync(solution.GetProject(project.Id)!);
+        var text       = (await solution.GetDocument(document.Id)!.GetTextAsync(cancellationToken)).ToString();
+
+        after.GetDiagnostics(cancellationToken).Where(d => d.Severity == DiagnosticSeverity.Error).ShouldBeEmpty(text);
+
+        var subject  = after.GetTypeByMetadataName(metadataName).ShouldNotBeNull(text);
+        var contract = subject.AllInterfaces.Single(i => i.OriginalDefinition.MetadataName == "IValidatedValue`3");
+        var create   = (IMethodSymbol)subject.FindImplementationForInterfaceMember(contract.GetMembers("Create").Single()).ShouldNotBeNull(text);
+
+        create.IsStatic.ShouldBeTrue(text);
+        create.DeclaredAccessibility.ShouldBe(Accessibility.Public, text);
+    }
+
+    /// <summary>
+    /// For each CS0535 of the file, the base type it is reported at and whether the fix is offered there:
+    /// one interface can bring two missing members, and another interface a <c>Create</c> of its own.
+    /// </summary>
+    internal static async Task<List<(string BaseType, bool Offered)>> OfferedAsync(string source, string generated)
+    {
+        var cancellationToken = TestContext.Current.CancellationToken;
+        var project           = Project(source, generated);
+        var document          = project.Documents.Single(d => d.Name == "Subject.cs");
+        var root              = await document.GetSyntaxRootAsync(cancellationToken);
+        var offered           = new List<(string, bool)>();
+
+        foreach (var diagnostic in (await CompileAsync(project)).GetDiagnostics(cancellationToken).Where(d => d.Id == "CS0535"))
+        {
+            var actions = new List<CodeAction>();
+            await new MissingCreateCodeFixProvider().RegisterCodeFixesAsync(new CodeFixContext(document, diagnostic, (action, _) => actions.Add(action), cancellationToken));
+            offered.Add((root!.FindNode(diagnostic.Location.SourceSpan).ToString(), actions.Count > 0));
+        }
+
+        return offered;
+    }
+
+    private static string Wrap(string? outer, string member) => outer is null ? member : $"{outer} {{ {member} }}";
+
+    private static Project Project(string source, string generated)
+    {
+        var workspace = new AdhocWorkspace();
+        var project   = workspace.AddProject("Variants", LanguageNames.CSharp)
+                                 .WithCompilationOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, nullableContextOptions: NullableContextOptions.Enable))
+                                 .WithParseOptions(new CSharpParseOptions(LanguageVersion.Preview))
+                                 .WithMetadataReferences(References.Value);
+
+        project = project.AddDocument("Candidates.cs", TypeArgumentKinds.Candidates).Project;
+        project = project.AddDocument("Generated.cs", generated).Project;
+        return project.AddDocument("Subject.cs", source).Project;
+    }
+
+    private static readonly Lazy<ImmutableArray<MetadataReference>> References = new(() =>
+        ReferenceAssemblies.Net.Net100.ResolveAsync(LanguageNames.CSharp, CancellationToken.None).GetAwaiter().GetResult().Add(RealTypeKit.Reference));
+
+    private static async Task<Compilation> CompileAsync(Project project) =>
+        (await project.GetCompilationAsync(TestContext.Current.CancellationToken)).ShouldNotBeNull();
+}
diff --git a/test/CodoMetis.TypeKit.Analyzers.Tests/QueryDelegateConditionTests.cs b/test/CodoMetis.TypeKit.Analyzers.Tests/QueryDelegateConditionTests.cs
new file mode 100644
index 00000000..c0f84da4
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Analyzers.Tests/QueryDelegateConditionTests.cs
@@ -0,0 +1,150 @@
+using CodoMetis.TypeKit.Analyzers.Tests.Variants;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Testing;
+
+namespace CodoMetis.TypeKit.Analyzers.Tests;
+
+/// <summary>
+/// CMTK0009's query condition: <c>FirstOrNone</c>, <c>SingleOrNone</c>, <c>FirstOrError</c> and the Last
+/// forms called on a query with a delegate for a condition bind to their sequence overloads, which read
+/// every row and run the condition in memory.
+/// </summary>
+/// <remarks>
+/// The oracle is the compiler's overload resolution, stated per shape in <see cref="QueryDelegateShapes"/>:
+/// a condition that converts to a delegate alone, on a receiver that is a query, is reported once, at
+/// the call; every other call that compiles is silent.
+/// </remarks>
+public sealed class QueryDelegateConditionTests
+{
+    private const string AsExpression = "Write the condition as a lambda at the call, or hold it as an Expression<Func<Shipment, bool>>, so that the query runs it, or call AsEnumerable() first to read every row on purpose";
+
+    private static DiagnosticResult Cmtk0009(int location, string method, string advice = AsExpression) =>
+        new DiagnosticResult("CMTK0009", DiagnosticSeverity.Warning)
+            .WithLocation(location)
+            .WithMessage($"'{method}' on the query binds to its IEnumerable<T> overload, since the condition is a 'Func<Shipment, bool>' and not an expression: it reads every row and runs the condition in memory. {advice}.");
+
+    private const string Shipment =
+        """
+        using System;
+        using System.Collections.Generic;
+        using System.Linq;
+        using System.Linq.Expressions;
+        using CodoMetis.TypeKit;
+
+        public sealed class Shipment { public string Carrier { get; set; } = ""; }
+
+        """;
+
+    [Fact]
+    public Task Each_lookup_says_which_overload_it_fell_to_and_what_to_write_instead() =>
+        Run(
+            Shipment +
+            """
+            public static class C
+            {
+                private static bool IsGamma(Shipment s) => s.Carrier == "gamma";
+
+                public static void Run(IQueryable<Shipment> shipments)
+                {
+                    Func<Shipment, bool> isBeta = s => s.Carrier == "beta";
+
+                    _ = {|#0:shipments.FirstOrNone(isBeta)|};
+                    _ = {|#1:shipments.SingleOrNone(IsGamma)|};
+                    _ = {|#2:shipments.FirstOrError(isBeta, "none")|};
+                    _ = {|#3:shipments.LastOrNone(isBeta)|};
+                    _ = {|#4:shipments.LastOrError(isBeta, "none")|};
+                }
+            }
+            """,
+            Cmtk0009(0, "FirstOrNone"),
+            Cmtk0009(1, "SingleOrNone"),
+            Cmtk0009(2, "FirstOrError"),
+            Cmtk0009(3, "LastOrNone", "A query has no last element until it is ordered: order it the other way and use FirstOrNone with the condition as a lambda, or call AsEnumerable() first to read every row on purpose"),
+            Cmtk0009(4, "LastOrError", "A query has no last element until it is ordered: order it the other way and use FirstOrError with the condition as a lambda, or call AsEnumerable() first to read every row on purpose"));
+
+    [Fact]
+    public Task A_lambda_an_expression_and_a_sequence_are_silent() =>
+        Run(
+            Shipment +
+            """
+            public static class C
+            {
+                public static void Run(IQueryable<Shipment> shipments, List<Shipment> list)
+                {
+                    Expression<Func<Shipment, bool>> isAlpha = s => s.Carrier == "alpha";
+                    Func<Shipment, bool> isBeta = s => s.Carrier == "beta";
+
+                    _ = shipments.FirstOrNone(s => s.Carrier == "beta");
+                    _ = shipments.SingleOrNone(isAlpha);
+                    _ = shipments.FirstOrError(isAlpha, "none");
+                    _ = list.FirstOrNone(isBeta);
+                    _ = shipments.AsEnumerable().FirstOrNone(isBeta);
+                }
+            }
+            """);
+
+    /// <summary>EF Core's <c>DbSet</c>, the receiver the EF README's warning is about, and <c>Set&lt;T&gt;()</c>.</summary>
+    [Fact]
+    public Task A_DbSet_is_a_query()
+    {
+        var test = new AnalyzerTest<DefaultProducingCallAnalyzer>(
+            "using Microsoft.EntityFrameworkCore;\n" + Shipment +
+            """
+            public static class C
+            {
+                public static void Run(DbSet<Shipment> shipments, DbContext db)
+                {
+                    Func<Shipment, bool> isBeta = s => s.Carrier == "beta";
+
+                    _ = {|#0:shipments.FirstOrNone(isBeta)|};
+                    _ = {|#1:db.Set<Shipment>().SingleOrNone(isBeta)|};
+                    _ = shipments.FirstOrNone(s => s.Carrier == "beta");
+                }
+            }
+            """);
+        test.TestState.AdditionalReferences.AddRange(RealEntityFrameworkCore.References);
+        test.ExpectedDiagnostics.AddRange([Cmtk0009(0, "FirstOrNone"), Cmtk0009(1, "SingleOrNone")]);
+
+        return test.RunAsync(TestContext.Current.CancellationToken);
+    }
+
+    public static TheoryData<string> Receivers() => [.. QueryDelegateShapes.Receivers.Select(receiver => receiver.Name)];
+
+    /// <summary>Every receiver against every condition and lookup, over one element type.</summary>
+    [Theory]
+    [MemberData(nameof(Receivers))]
+    public Task Every_receiver_against_every_condition(string receiver) =>
+        Sweep(QueryDelegateShapes.Receivers.Single(candidate => candidate.Name == receiver), "Widget");
+
+    public static TheoryData<string> Kinds() => [.. TypeArgumentKinds.All.Select(kind => kind.Name)];
+
+    /// <summary>Every kind of element, on a plain query, against every condition and lookup.</summary>
+    [Theory]
+    [MemberData(nameof(Kinds))]
+    public Task Every_kind_of_element(string kind)
+    {
+        var element = TypeArgumentKinds.All.Single(candidate => candidate.Name == kind);
+
+        return Sweep(QueryDelegateShapes.Receivers[0], element.Argument, element.Parameters, element.Where);
+    }
+
+    private static Task Sweep(QueryReceiver receiver, string element, string parameters = "", string where = "")
+    {
+        var (source, expected) = QueryDelegateShapes.Use(receiver, element, parameters, where);
+
+        var test = new AnalyzerTest<DefaultProducingCallAnalyzer>(TypeArgumentKinds.Candidates);
+        test.TestState.Sources.Add(("Declarations.cs", QueryDelegateShapes.Declarations));
+        test.TestState.Sources.Add(("Use.cs", source));
+        test.ExpectedDiagnostics.AddRange(expected.Select(call => new DiagnosticResult("CMTK0009", DiagnosticSeverity.Warning).WithLocation(call.Location)));
+
+        return test.RunAsync(TestContext.Current.CancellationToken);
+    }
+
+    private static Task Run(string code, params DiagnosticResult[] expected)
+    {
+        var test = new AnalyzerTest<DefaultProducingCallAnalyzer>(code);
+        test.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync(TestContext.Current.CancellationToken);
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Analyzers.Tests/UnassignedNoDefaultMemberAnalyzerTests.cs b/test/CodoMetis.TypeKit.Analyzers.Tests/UnassignedNoDefaultMemberAnalyzerTests.cs
index 303face2..c87b6a47 100644
--- a/test/CodoMetis.TypeKit.Analyzers.Tests/UnassignedNoDefaultMemberAnalyzerTests.cs
+++ b/test/CodoMetis.TypeKit.Analyzers.Tests/UnassignedNoDefaultMemberAnalyzerTests.cs
@@ -94,6 +94,28 @@ public abstract class Base { public Plain {|#6:Id|} { get; set; } }
     /// on a member or setter less visible than the class (CS9032), so the message names it only where
     /// it does.
     /// </summary>
+    /// <summary>
+    /// A struct made of value objects is no value object itself, so its unset member is silent until the struct is
+    /// marked; marked, it reports as a value object does (the Analyzers README's "Mark your own struct").
+    /// </summary>
+    [Fact]
+    public Task A_struct_marked_RequireCustomInitialization_reports_and_an_unmarked_one_does_not() =>
+        Test(
+            """
+            [RequireCustomInitialization("Use OrderLine.Of(order, quantity)")]
+            public readonly record struct OrderLine(Plain Order, Plain Quantity);
+
+            public readonly record struct Unmarked(Plain Order, Plain Quantity);
+
+            public sealed class Cart
+            {
+                public OrderLine {|#0:Line|} { get; set; }
+                public Unmarked Loose { get; set; }
+            }
+            """,
+            Cmtk0006(0, "Line", "OrderLine", "the implicit constructor"))
+            .RunAsync(TestContext.Current.CancellationToken);
+
     [Fact]
     public Task The_advice_names_required_only_where_it_compiles() =>
         Test(
diff --git a/test/CodoMetis.TypeKit.Analyzers.Tests/Variants/DroppedTaskShapes.cs b/test/CodoMetis.TypeKit.Analyzers.Tests/Variants/DroppedTaskShapes.cs
new file mode 100644
index 00000000..82ae846e
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Analyzers.Tests/Variants/DroppedTaskShapes.cs
@@ -0,0 +1,424 @@
+namespace CodoMetis.TypeKit.Analyzers.Tests.Variants;
+
+/// <summary>A call that returns a task whose drop CMTK0003 judges.</summary>
+/// <param name="Name">What the call is, as a test case names it.</param>
+/// <param name="Call">The call as written on the run method's parameters.</param>
+/// <param name="Static">The same call in the lowered static form, or <see langword="null"/> where it has none.</param>
+/// <param name="NullConditional">The same call through <c>?.</c>, or <see langword="null"/> where its receiver is a struct.</param>
+/// <param name="Returns">The type the call returns, which a <c>??</c>'s held operand is declared as.</param>
+/// <param name="Method">The method the message names.</param>
+/// <param name="Outcome">What the message says is dropped.</param>
+/// <param name="AwaitDrops">
+/// Whether awaiting it drops something too: a task of a <c>Result</c> completes with the result, which the
+/// statement then drops; an assertion completes once it has passed, with nothing left to see.
+/// </param>
+/// <param name="IsAssertion">Whether it is an assertion of CodoMetis.TypeKit.Testing, whose combination the message names as a <c>Task</c>.</param>
+/// <param name="Group">A sequence of the calls made through a method group, or <see langword="null"/> where the call takes more than its receiver.</param>
+public sealed record PendingCall(string Name, string Call, string? Static, string? NullConditional, string Returns, string Method, string Outcome, bool AwaitDrops, bool IsAssertion = true, string? Group = null)
+{
+    public override string ToString() => Name;
+}
+
+/// <summary>A call on a task that hands on the task it is called on, or none.</summary>
+/// <param name="Name">What the call is, as a test case names it.</param>
+/// <param name="Suffix">The call as written after the task.</param>
+/// <param name="KeepsTask">Whether what it returns is still a task, as <c>WaitAsync</c>'s is and <c>ConfigureAwait</c>'s awaitable is not.</param>
+public sealed record TaskPassThrough(string Name, string Suffix, bool KeepsTask = true)
+{
+    public override string ToString() => Name;
+}
+
+/// <summary>Where the dropped call stands in the statement's expression.</summary>
+/// <param name="Name">What the form is, as a test case names it.</param>
+/// <param name="Expression">
+/// The expression: <c>{call}</c> is the call, <c>{w}</c> the pass-through, and <c>[[</c> <c>]]</c> enclose a
+/// branch's call, which a diagnostic reports on its own. A form without them is the statement's own call,
+/// reported whole.
+/// </param>
+/// <param name="NeedsPassThrough">Whether the form is a statement only with a pass-through: a bare <c>?:</c>, <c>??</c> or <c>switch</c> is CS0201.</param>
+/// <param name="Combinator">
+/// The <c>Task</c> method that combines the calls, which the message names in place of the call's, or
+/// <see langword="null"/>. A <c>WhenAll</c> of results drops a collection of them, and a <c>WhenAny</c> one
+/// result (#159).
+/// </param>
+/// <param name="AwaitDrops">Whether awaiting the combination of assertions still drops a failure, which <c>WhenAny</c>'s does; <see langword="null"/> where the call decides.</param>
+/// <param name="Silent">Whether nothing is dropped in any use: the statement combines no task it made.</param>
+/// <param name="Value">What the expression is: a task, or what <c>Task.WaitAny</c> and <c>Task.WaitAll</c> return, which loses the tasks in every use.</param>
+/// <param name="AssertionsObserved">Whether an assertion's failure is seen all the same: <c>Task.WaitAll</c> throws it.</param>
+/// <param name="AssertionsOnly">
+/// Whether only an assertion is written in the form: where a <c>Result</c>'s would be a statement of its own, or a
+/// combinator inside another, which only an assertion's failure passes through (#165).
+/// </param>
+/// <param name="Lazy">Whether the sequence runs nothing until a loop reads it, so that dropping it drops nothing.</param>
+public sealed record DropForm(
+    string Name,
+    string Expression,
+    bool NeedsPassThrough = false,
+    string? Combinator = null,
+    bool? AwaitDrops = null,
+    bool Silent = false,
+    FormValue Value = FormValue.Task,
+    bool AssertionsObserved = false,
+    bool AssertionsOnly = false,
+    bool Lazy = false)
+{
+    public bool IsBranch => Expression.Contains("[[", StringComparison.Ordinal);
+
+    public override string ToString() => Name;
+}
+
+/// <summary>What a form's expression is.</summary>
+public enum FormValue
+{
+    /// <summary>A task, or what a pass-through makes of one.</summary>
+    Task,
+
+    /// <summary>The index <c>Task.WaitAny</c> returns.</summary>
+    Index,
+
+    /// <summary>Nothing: <c>Task.WaitAll</c> returns <c>void</c>.</summary>
+    Nothing,
+
+    /// <summary>A sequence of the tasks, read with <c>foreach</c>: a <c>Select</c>, which runs nothing until it is read.</summary>
+    Sequence,
+
+    /// <summary>A sequence of the tasks, read with <c>await foreach</c>: <c>Task.WhenEach</c>'s.</summary>
+    AsyncSequence,
+}
+
+/// <summary>What the statement does with the expression.</summary>
+/// <param name="Name">What the use is, as a test case names it.</param>
+/// <param name="Statement"><c>{e}</c> is the expression, and <c>&lt;&lt;</c> <c>&gt;&gt;</c> enclose what a diagnostic reports for the statement's own call.</param>
+/// <param name="Drops">Whether the use drops the task: <see langword="null"/> where it drops what the task completes with, which only <see cref="PendingCall.AwaitDrops"/> holds anything of.</param>
+/// <param name="Async">Whether the use needs an <c>async</c> method.</param>
+/// <param name="NeedsTask">Whether the use needs a task: it converts it to a plain <c>Task</c> or calls <c>Wait</c> on it.</param>
+/// <param name="Chains">Whether the use writes a call after the expression, which binds inside a <c>?.</c>.</param>
+/// <param name="IsStatement">Whether the expression is a statement, so that one of no value can be written there.</param>
+/// <param name="Loops">The sequence a loop reads the expression as, or <see langword="null"/> for a use that is no loop.</param>
+public sealed record TaskUse(string Name, string Statement, bool? Drops, bool Async = false, bool NeedsTask = false, bool Chains = false, bool IsStatement = false, FormValue? Loops = null)
+{
+    public override string ToString() => Name;
+}
+
+/// <summary>
+/// The variant catalogue for CMTK0003's dropped task (design/adr/0095): every way a statement can leave a
+/// call's task unobserved, and the uses that keep it.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Four axes. The call: every assertion of CodoMetis.TypeKit.Testing on a <c>Task</c> and a <c>ValueTask</c>,
+/// those that return a plain <c>Task</c> and those that return a <c>Task&lt;T&gt;</c>, beside a call that returns a
+/// task of a <c>Result</c>, whose drop the rule judged first. The pass-through: none, and every overload of
+/// <c>ConfigureAwait</c> and <c>WaitAsync</c>, one chained onto another. The form: the call alone, in the lowered
+/// static form, through <c>?.</c>, as a branch of a <c>?:</c>, a <c>??</c> and a <c>switch</c> expression, and
+/// handed on by <c>Task.WhenAll</c>, <c>Task.WhenAny</c> or <c>Task.Run</c> as arguments, an array, a collection
+/// expression, a <c>Select</c> of a lambda, an <c>async</c> lambda or a method group, beside a held task and as a
+/// branch, and given to <c>Task.WaitAny</c> or <c>Task.WaitAll</c>, against held tasks, an assertion discarded
+/// where it was made and one whose failure a <c>catch</c> swallows. The use: dropped as a statement or as a
+/// lambda's body, awaited, converted to a plain <c>Task</c> and waited for with <c>Wait</c>, against discarded,
+/// held and returned.
+/// </para>
+/// <para>
+/// Both calls go through the one path, so they agree on every form: #152 found the assertions alone silent
+/// through the pass-throughs of a plain <c>Task</c> and through the branches, #157 through the combinators,
+/// #159 a <c>WhenAny</c> of results dropped unawaited, #165 a <c>WhenAny</c> inside a <c>WhenAll</c> or a <c>Run</c>,
+/// awaited, and #166 a <c>catch</c> that throws again, of another exception or filtered by <c>false</c>.
+/// </para>
+/// </remarks>
+public static class DroppedTaskShapes
+{
+    /// <summary>The run method's parameters, which the calls and the forms name.</summary>
+    public const string Parameters =
+        "Service service, Service? maybe, bool choose, CancellationToken token, "
+      + "Task<Option<int>> option, ValueTask<Option<int>> optionValue, "
+      + "Task<Result<int, Fault>> result, ValueTask<Result<int, Fault>> resultValue, "
+      + "Task<Result<Fault>> command, ValueTask<Result<Fault>> commandValue, "
+      + "Task<Patch<int>> patch, ValueTask<Patch<int>> patchValue, "
+      + "Task<Fault<Fault, Other>> composed, ValueTask<Fault<Fault, Other>> composedValue";
+
+    /// <summary>The declarations the parameters name, a file of their own.</summary>
+    public const string Declarations =
+        """
+        using System.Threading.Tasks;
+        using CodoMetis.TypeKit;
+
+        public enum Fault { Refused }
+
+        public enum Other { Late }
+
+        public sealed class Service
+        {
+            public Task<Result<int, Fault>> LoadAsync() => Task.FromResult<Result<int, Fault>>(1);
+        }
+
+        """;
+
+    public static IReadOnlyList<PendingCall> Calls { get; } =
+    [
+        .. Assertion("ShouldBeNone", "OptionAssertions", "option", "", "Task"),
+        .. Assertion("ShouldBeSuccess", "ResultAssertions", "command", "", "Task", "command"),
+        .. Assertion("ShouldBeError", "ResultAssertions", "result", "Fault.Refused", "Task", "expected-value"),
+        .. Assertion("ShouldBeError", "ResultAssertions", "command", "Fault.Refused", "Task", "command expected-value"),
+        .. Assertion("ShouldBeAbsent", "PatchAssertions", "patch", "", "Task"),
+        .. Assertion("ShouldBeNull", "PatchAssertions", "patch", "", "Task"),
+        .. Assertion("ShouldBeSome", "OptionAssertions", "option", "", "Task<int>"),
+        .. Assertion("ShouldBeSuccess", "ResultAssertions", "result", "", "Task<int>"),
+        .. Assertion("ShouldBeError", "ResultAssertions", "result", "", "Task<Fault>"),
+        .. Assertion("ShouldBeError", "ResultAssertions", "command", "", "Task<Fault>", "command"),
+        .. Assertion("ShouldBeValue", "PatchAssertions", "patch", "", "Task<int>"),
+        .. Assertion("ShouldHold", "FaultAssertions", "composed", "Fault.Refused", "Task<Fault<Fault>>"),
+
+        new("a call that returns a Task of a Result", "service.LoadAsync()", null, "maybe?.LoadAsync()", "Task<Result<int, Fault>>", "LoadAsync", "Result", AwaitDrops: true, IsAssertion: false),
+    ];
+
+    public static IReadOnlyList<TaskPassThrough> PassThroughs { get; } =
+    [
+        new("no pass-through", ""),
+        new("ConfigureAwait(bool)", ".ConfigureAwait(false)", KeepsTask: false),
+        new("ConfigureAwait(ConfigureAwaitOptions)", ".ConfigureAwait(ConfigureAwaitOptions.None)", KeepsTask: false),
+        new("WaitAsync(TimeSpan)", ".WaitAsync(TimeSpan.FromSeconds(1))"),
+        new("WaitAsync(CancellationToken)", ".WaitAsync(token)"),
+        new("WaitAsync(TimeSpan, CancellationToken)", ".WaitAsync(TimeSpan.FromSeconds(1), token)"),
+        new("WaitAsync(TimeSpan, TimeProvider)", ".WaitAsync(TimeSpan.FromSeconds(1), TimeProvider.System)"),
+        new("WaitAsync(TimeSpan, TimeProvider, CancellationToken)", ".WaitAsync(TimeSpan.FromSeconds(1), TimeProvider.System, token)"),
+        new("WaitAsync then ConfigureAwait", ".WaitAsync(token).ConfigureAwait(false)", KeepsTask: false),
+    ];
+
+    public static IReadOnlyList<DropForm> Forms { get; } =
+    [
+        new("the call", "{call}{w}"),
+        new("the lowered static form", "{static}{w}"),
+        new("a null-conditional call", "{nc}{w}"),
+        new("both branches of a conditional", "(choose ? [[{call}]] : [[{call}]]){w}", NeedsPassThrough: true),
+        new("the right operand of ??", "(held ?? [[{call}]]){w}", NeedsPassThrough: true),
+        new("both arms of a switch expression", "(choose switch { true => [[{call}]], false => [[{call}]] }){w}", NeedsPassThrough: true),
+
+        new("Task.WhenAll of two calls", "Task.WhenAll({call}, {call}){w}", Combinator: "WhenAll", AwaitDrops: false),
+        new("Task.WhenAll of an array", "Task.WhenAll(new[] { {call}, {call} }){w}", Combinator: "WhenAll", AwaitDrops: false),
+        new("Task.WhenAll of a collection expression", "Task.WhenAll([{call}, {call}]){w}", Combinator: "WhenAll", AwaitDrops: false),
+        new("Task.WhenAll of a Select", "Task.WhenAll(Enumerable.Range(0, 2).Select(_ => {call})){w}", Combinator: "WhenAll", AwaitDrops: false),
+        new("Task.WhenAll beside a held task", "Task.WhenAll(held!, {call}){w}", Combinator: "WhenAll", AwaitDrops: false),
+        new("Task.WhenAll of a conditional", "Task.WhenAll(choose ? {call} : {call}){w}", Combinator: "WhenAll", AwaitDrops: false),
+        new("Task.WhenAny of two calls", "Task.WhenAny({call}, {call}){w}", Combinator: "WhenAny", AwaitDrops: true),
+        new("Task.WhenAny of an array", "Task.WhenAny(new[] { {call}, {call} }){w}", Combinator: "WhenAny", AwaitDrops: true),
+        new("Task.WhenAny beside a held task", "Task.WhenAny(held!, {call}){w}", Combinator: "WhenAny", AwaitDrops: true),
+        new("Task.WhenAll of held tasks", "Task.WhenAll(held!, held!){w}", Combinator: "WhenAll", Silent: true),
+        new("Task.WhenAny of held tasks", "Task.WhenAny(held!, held!){w}", Combinator: "WhenAny", Silent: true),
+        new("Task.WhenAll of tasks discarded where they are made", "Task.WhenAll(Enumerable.Range(0, 2).Select(i => { _ = {call}; return Task.CompletedTask; })){w}", Combinator: "WhenAll", Silent: true),
+        new("Task.WhenAll of tasks made from the calls, not of them", "Task.WhenAll(Enumerable.Range(0, 2).Select(i => Task.FromResult(ReferenceEquals({call}, null)))){w}", Combinator: "WhenAll", Silent: true),
+        new("Task.WhenAll of a method group", "Task.WhenAll({group}){w}", Combinator: "WhenAll", AwaitDrops: false),
+        new("Task.WhenAll of async lambdas", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => await {call})){w}", Combinator: "WhenAll", AwaitDrops: false),
+        new("Task.WhenAll of async lambdas that catch", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { await {call}; } catch (Exception) { } })){w}", Combinator: "WhenAll", Silent: true, AssertionsOnly: true),
+        new("Task.Run of a lambda", "Task.Run(() => {call}){w}", Combinator: "Run", AwaitDrops: false),
+        new("Task.Run of an async lambda", "Task.Run(async () => await {call}){w}", Combinator: "Run", AwaitDrops: false),
+
+        // A combinator inside another (#165): WhenAll and Run fault with a task that faults, WhenAny completes with
+        // it as its value, at any depth, and each await unwraps one such task.
+        new("Task.WhenAll of a Task.WhenAll", "Task.WhenAll(Task.WhenAll({call}, {call})){w}", Combinator: "WhenAll", AwaitDrops: false, AssertionsOnly: true),
+        new("Task.WhenAll of a Task.WhenAny", "Task.WhenAll(Task.WhenAny({call}, {call})){w}", Combinator: "WhenAll", AwaitDrops: true, AssertionsOnly: true),
+        new("Task.WhenAll of a Task.Run", "Task.WhenAll(Task.Run(() => {call})){w}", Combinator: "WhenAll", AwaitDrops: false, AssertionsOnly: true),
+        new("Task.WhenAny of a Task.WhenAll", "Task.WhenAny(Task.WhenAll({call}, {call})){w}", Combinator: "WhenAny", AwaitDrops: true, AssertionsOnly: true),
+        new("Task.WhenAny of a Task.WhenAny", "Task.WhenAny(Task.WhenAny({call}, {call})){w}", Combinator: "WhenAny", AwaitDrops: true, AssertionsOnly: true),
+        new("Task.WhenAny of a Task.Run", "Task.WhenAny(Task.Run(() => {call})){w}", Combinator: "WhenAny", AwaitDrops: true, AssertionsOnly: true),
+        new("Task.Run of a Task.WhenAll", "Task.Run(() => Task.WhenAll({call}, {call})){w}", Combinator: "Run", AwaitDrops: false, AssertionsOnly: true),
+        new("Task.Run of a Task.WhenAny", "Task.Run(() => Task.WhenAny({call}, {call})){w}", Combinator: "Run", AwaitDrops: true, AssertionsOnly: true),
+        new("Task.Run of a Task.Run", "Task.Run(() => Task.Run(() => {call})){w}", Combinator: "Run", AwaitDrops: false, AssertionsOnly: true),
+        new("Task.WhenAll of a Task.Run of a Task.WhenAll of a Task.WhenAll", "Task.WhenAll(Task.Run(() => Task.WhenAll(Task.WhenAll({call}, {call})))){w}", Combinator: "WhenAll", AwaitDrops: false, AssertionsOnly: true),
+        new("Task.WhenAll of a Task.Run of a Task.WhenAll of a Task.WhenAny", "Task.WhenAll(Task.Run(() => Task.WhenAll(Task.WhenAny({call}, {call})))){w}", Combinator: "WhenAll", AwaitDrops: true, AssertionsOnly: true),
+        new("Task.WhenAll of an array of Task.WhenAny", "Task.WhenAll(new[] { Task.WhenAny({call}, {call}), Task.WhenAny({call}, {call}) }){w}", Combinator: "WhenAll", AwaitDrops: true, AssertionsOnly: true),
+        new("Task.WhenAll of a Select of Task.WhenAny", "Task.WhenAll(Enumerable.Range(0, 2).Select(i => Task.WhenAny({call}, {call}))){w}", Combinator: "WhenAll", AwaitDrops: true, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that return a Task.WhenAny", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => Task.WhenAny({call}, {call}))){w}", Combinator: "WhenAll", AwaitDrops: true, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that await a Task.WhenAny once", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => await Task.WhenAny({call}, {call}))){w}", Combinator: "WhenAll", AwaitDrops: true, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that await a Task.WhenAny twice", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => await await Task.WhenAny({call}, {call}))){w}", Combinator: "WhenAll", AwaitDrops: false, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that await a Task.WhenAny of a Task.WhenAny twice", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => await await Task.WhenAny(Task.WhenAny({call}, {call})))){w}", Combinator: "WhenAll", AwaitDrops: true, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that await a Task.WhenAny of a Task.WhenAny three times", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => await await await Task.WhenAny(Task.WhenAny({call}, {call})))){w}", Combinator: "WhenAll", AwaitDrops: false, AssertionsOnly: true),
+
+        // A catch around the awaited assertion in an async lambda (#166) keeps the failure only when its type can
+        // hold a TypeKitAssertionException, no constant false filter refuses it and its handler can complete. A
+        // filter that is no constant may take it, and counts as taking it.
+        new("Task.WhenAll of async lambdas that try with only a finally", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { await {call}; } finally { GC.KeepAlive(i); } })){w}", Combinator: "WhenAll", AwaitDrops: false, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that catch and rethrow", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { await {call}; } catch { throw; } })){w}", Combinator: "WhenAll", AwaitDrops: false, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that log and rethrow", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { await {call}; } catch (Exception exception) { GC.KeepAlive(exception); throw; } })){w}", Combinator: "WhenAll", AwaitDrops: false, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that throw another exception", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { await {call}; } catch (Exception exception) { throw new InvalidOperationException(\"wrapped\", exception); } })){w}", Combinator: "WhenAll", AwaitDrops: false, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that catch an unrelated exception", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { await {call}; } catch (OperationCanceledException) { } })){w}", Combinator: "WhenAll", AwaitDrops: false, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that catch with a false filter", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { await {call}; } catch (Exception) when (false) { } })){w}", Combinator: "WhenAll", AwaitDrops: false, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that rethrow inside a try that rethrows", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { try { await {call}; } catch { throw; } } catch (OperationCanceledException) { } })){w}", Combinator: "WhenAll", AwaitDrops: false, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that await in a catch's handler", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { GC.KeepAlive(i); } catch (Exception) { await {call}; } })){w}", Combinator: "WhenAll", AwaitDrops: false, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that await in a finally", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { GC.KeepAlive(i); } catch (Exception) { } finally { await {call}; } })){w}", Combinator: "WhenAll", AwaitDrops: false, AssertionsOnly: true),
+        new("Task.Run of an async lambda that catches and rethrows", "Task.Run(async () => { try { await {call}; } catch { throw; } }){w}", Combinator: "Run", AwaitDrops: false, AssertionsOnly: true),
+        new("Task.WhenAny of async lambdas that catch and rethrow", "Task.WhenAny(Enumerable.Range(0, 2).Select(async i => { try { await {call}; } catch { throw; } })){w}", Combinator: "WhenAny", AwaitDrops: true, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that catch everything", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { await {call}; } catch { } })){w}", Combinator: "WhenAll", Silent: true, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that catch the assertion's exception", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { await {call}; } catch (TypeKitAssertionException) { } })){w}", Combinator: "WhenAll", Silent: true, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that catch with a true filter", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { await {call}; } catch (Exception) when (true) { } })){w}", Combinator: "WhenAll", Silent: true, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that catch with a filter that is no constant", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { await {call}; } catch (Exception exception) when (exception.Data.Count == 0) { } })){w}", Combinator: "WhenAll", Silent: true, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that rethrow only sometimes", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { await {call}; } catch (Exception) { if (choose) throw; } })){w}", Combinator: "WhenAll", Silent: true, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that return from the catch", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { await {call}; } catch (Exception) { if (choose) return; throw; } })){w}", Combinator: "WhenAll", Silent: true, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that catch in a later clause", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { await {call}; } catch (OperationCanceledException) { throw; } catch (Exception) { } })){w}", Combinator: "WhenAll", Silent: true, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that rethrow inside a try that catches", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { try { await {call}; } catch { throw; } } catch (Exception) { } })){w}", Combinator: "WhenAll", Silent: true, AssertionsOnly: true),
+        new("Task.WhenAll of async lambdas that catch inside a try that rethrows", "Task.WhenAll(Enumerable.Range(0, 2).Select(async i => { try { try { await {call}; } catch (Exception) { } } catch { throw; } })){w}", Combinator: "WhenAll", Silent: true, AssertionsOnly: true),
+        new("Task.Run of an async lambda that catches", "Task.Run(async () => { try { await {call}; } catch (Exception) { } }){w}", Combinator: "Run", Silent: true, AssertionsOnly: true),
+
+        new("Task.WaitAny of two calls", "Task.WaitAny([[{call}]], [[{call}]])", Value: FormValue.Index),
+        new("Task.WaitAny of held tasks", "Task.WaitAny(held!, held!)", Value: FormValue.Index, Silent: true),
+        new("Task.WaitAll of two calls", "Task.WaitAll([[{call}]], [[{call}]])", Value: FormValue.Nothing, AssertionsObserved: true),
+        new("Task.WaitAny of an array", "Task.WaitAny(new[] { [[{call}]], [[{call}]] })", Value: FormValue.Index),
+        new("Task.WaitAll of an array", "Task.WaitAll(new[] { [[{call}]], [[{call}]] })", Value: FormValue.Nothing, AssertionsObserved: true),
+        new("Task.WaitAll of a Task.WhenAll", "Task.WaitAll(Task.WhenAll([[{call}]], [[{call}]]))", Value: FormValue.Nothing, AssertionsObserved: true, AssertionsOnly: true),
+        // Task.WaitAll waits for the WhenAny as a plain Task, a task that never faults, reported where it converts.
+        new("Task.WaitAll of a Task.WhenAny", "Task.WaitAll([[Task.WhenAny({call}, {call})]])", Combinator: "WhenAny", Value: FormValue.Nothing, AssertionsOnly: true),
+        new("Task.WaitAny of a Task.WhenAll", "Task.WaitAny(Task.WhenAll([[{call}]], [[{call}]]))", Value: FormValue.Index, AssertionsOnly: true),
+
+        new("Task.WhenAll of a query", "Task.WhenAll(from i in Enumerable.Range(0, 2) select {call}){w}", Combinator: "WhenAll", AwaitDrops: false),
+        new("Task.WhenAll of a list", "Task.WhenAll(Enumerable.Range(0, 2).Select(i => {call}).ToList()){w}", Combinator: "WhenAll", AwaitDrops: false),
+        new("Task.WhenEach of two calls", "Task.WhenEach({call}, {call})", Combinator: "WhenEach", Value: FormValue.AsyncSequence),
+        new("Task.WhenEach of held tasks", "Task.WhenEach(held!, held!)", Combinator: "WhenEach", Value: FormValue.AsyncSequence, Silent: true),
+        new("a Select of the calls", "Enumerable.Range(0, 2).Select(i => {call})", Combinator: "Select", Value: FormValue.Sequence, Lazy: true),
+    ];
+
+    public static IReadOnlyList<TaskUse> Uses { get; } =
+    [
+        new("dropped as a statement", "<<{e}>>;", Drops: true, IsStatement: true),
+        new("dropped as a lambda's body", "Action dropped = () => <<{e}>>;", Drops: true, IsStatement: true),
+        new("awaited", "<<await {e}>>;", Drops: null, Async: true),
+        new("converted to a plain Task", "Func<Task> converted = () => <<{e}>>;", Drops: null, NeedsTask: true),
+        new("waited for with Wait()", "<<{e}.Wait()>>;", Drops: null, NeedsTask: true, Chains: true),
+        new("the body of a method that returns nothing", "void Check() => <<{e}>>;", Drops: true, IsStatement: true),
+        new("drained by a foreach that never reads it", "foreach (var each in <<{e}>>) { }", Drops: true, Loops: FormValue.Sequence),
+        new("read by a foreach", "foreach (var each in {e}) { GC.KeepAlive(each); }", Drops: false, Loops: FormValue.Sequence),
+        new("drained by an await foreach that never reads it", "await foreach (var each in <<{e}>>) { }", Drops: true, Async: true, Loops: FormValue.AsyncSequence),
+        new("read by an await foreach", "await foreach (var each in {e}) { GC.KeepAlive(each); }", Drops: false, Async: true, Loops: FormValue.AsyncSequence),
+        new("discarded with _ =", "_ = {e};", Drops: false),
+        new("held in a local", "var kept = {e};", Drops: false),
+        new("returned from a lambda", "Func<object?> returned = () => {e};", Drops: false),
+    ];
+
+    /// <summary>
+    /// A file whose two run methods use <paramref name="call"/> in <paramref name="form"/>, through every
+    /// pass-through, in every use, and the spans a diagnostic is expected at, by markup location. One file per
+    /// form keeps a failure to the form, and the verifier's matching, which recurses once per diagnostic,
+    /// within its stack.
+    /// </summary>
+    public static (string Source, IReadOnlyList<(string Outcome, string Method)> Expected) Use(PendingCall call, DropForm form)
+    {
+        var expected = new List<(string Outcome, string Method)>();
+        var body     = new System.Text.StringBuilder();
+        var awaited  = new System.Text.StringBuilder();
+
+        foreach (var passThrough in PassThroughs)
+        foreach (var use in Uses)
+        {
+            // A statement that does not compile is no case.
+            if (form.NeedsPassThrough && passThrough.Suffix.Length == 0) continue;
+
+            // await x?.M().ConfigureAwait(false) awaits a nullable awaiter, which has no GetAwaiter, and await x?.M()
+            // a task that may be null (CS8602); x?.M().Wait() waits inside the ?..
+            if ((use.Async || use.Chains) && form.Expression.Contains("{nc}", StringComparison.Ordinal)) continue;
+            if (use.NeedsTask && !passThrough.KeepsTask) continue;
+
+            // An index, nothing or a sequence takes no await, no pass-through and no conversion, nothing is no
+            // value, and a loop reads only the sequence it was written for.
+            if (use.Loops is { } loops ? loops != form.Value : form.Value != FormValue.Task && (use.Async || use.NeedsTask)) continue;
+            if (form.Value != FormValue.Task && passThrough.Suffix.Length > 0) continue;
+            if (form.Value == FormValue.Nothing && !use.IsStatement) continue;
+
+            // Task.WaitAny and Task.WaitAll lose or keep the tasks at the call, whatever the statement does next.
+            var reported   = !form.Silent
+                          && !(form.AssertionsObserved && call.IsAssertion)
+                          && !(form.Lazy && use.Loops is null)
+                          && (form.Value is FormValue.Index or FormValue.Nothing || (use.Drops ?? (call.AwaitDrops || (form.AwaitDrops ?? false))));
+            var expression = form.Expression
+                                 .Replace("{call}", call.Call)
+                                 .Replace("{static}", call.Static)
+                                 .Replace("{nc}", call.NullConditional)
+                                 .Replace("{group}", call.Group)
+                                 .Replace("{w}", passThrough.Suffix);
+            var statement  = use.Statement.Replace("{e}", expression);
+
+            var message    = form.Combinator switch
+            {
+                null                         => (call.Outcome, call.Method),
+                "WhenEach" or "Select"        => ($"sequence of {(call.IsAssertion ? "Task" : call.Outcome)}s", form.Combinator),
+                var all when call.IsAssertion => ("Task", all),
+                "WhenAll"                    => ($"collection of {call.Outcome}s", "WhenAll"),
+                var any                      => (call.Outcome, any),
+            };
+
+            statement = Mark(statement, "<<", ">>", reported && !form.IsBranch, message, expected);
+            statement = Mark(statement, "[[", "]]", reported, message, expected);
+
+            // A task the caller holds, declared where the form names it.
+            var held = expression.Contains("held", StringComparison.Ordinal) ? $"{call.Returns}? held = choose ? null : {call.Call};\n            " : "";
+
+            (use.Async ? awaited : body).Append($"        {{ // {form.Name}, {passThrough.Name}, {use.Name}\n            ")
+                                        .Append(held)
+                                        .Append(statement)
+                                        .Append("\n        }\n");
+        }
+
+        var source =
+            $$"""
+              #nullable enable
+              using System;
+              using System.Linq;
+              using System.Threading;
+              using System.Threading.Tasks;
+              using CodoMetis.TypeKit;
+              using CodoMetis.TypeKit.Testing;
+
+              public static class Use
+              {
+                  public static void Run({{Parameters}})
+                  {
+              {{body}}
+                  }
+
+                  public static async Task RunAsync({{Parameters}})
+                  {
+              {{awaited}}
+                  }
+              }
+              """;
+
+        return (source, expected);
+    }
+
+    /// <summary>
+    /// Whether <paramref name="call"/> can be written in <paramref name="form"/>: a call has no static form, a
+    /// <c>ValueTask</c> no <c>?.</c>, an assertion with arguments no method group, and a <c>Result</c> stays out of
+    /// a form written for assertions.
+    /// </summary>
+    public static bool Applies(DropForm form, PendingCall call) =>
+        !(form.AssertionsOnly && !call.IsAssertion)
+     && !(form.Expression.Contains("{group}", StringComparison.Ordinal) && call.Group is null)
+     && !(form.Expression.Contains("{static}", StringComparison.Ordinal) && call.Static is null)
+     && !(form.Expression.Contains("{nc}", StringComparison.Ordinal) && call.NullConditional is null);
+
+    /// <summary>Each span between <paramref name="open"/> and <paramref name="close"/> becomes the next markup location, or plain text where nothing is reported.</summary>
+    private static string Mark(string text, string open, string close, bool reported, (string Outcome, string Method) message, List<(string Outcome, string Method)> expected)
+    {
+        var marked = new System.Text.StringBuilder();
+        var at     = 0;
+
+        for (var start = text.IndexOf(open, StringComparison.Ordinal); start >= 0; start = text.IndexOf(open, at, StringComparison.Ordinal))
+        {
+            var end = text.IndexOf(close, start, StringComparison.Ordinal);
+            marked.Append(text, at, start - at).Append(reported ? $"{{|#{expected.Count}:" : "").Append(text, start + open.Length, end - start - open.Length).Append(reported ? "|}" : "");
+            if (reported) expected.Add(message);
+            at = end + close.Length;
+        }
+
+        return marked.Append(text, at, text.Length - at).ToString();
+    }
+
+    /// <summary>An assertion, on a <c>Task</c> of what it checks and on a <c>ValueTask</c>.</summary>
+    private static IEnumerable<PendingCall> Assertion(string method, string @class, string receiver, string arguments, string returns, string? kind = null)
+    {
+        var name = kind is null ? method : $"{kind} {method}";
+        var tail = arguments.Length == 0 ? "" : ", " + arguments;
+
+        string? Group(string held) => arguments.Length == 0 ? $"new[] {{ {held}, {held} }}.Select({@class}.{method})" : null;
+
+        yield return new($"{name} on a Task", $"{receiver}.{method}({arguments})", $"{@class}.{method}({receiver}{tail})", $"{receiver}?.{method}({arguments})", returns, method, "Task", AwaitDrops: false, Group: Group(receiver));
+        yield return new($"{name} on a ValueTask", $"{receiver}Value.{method}({arguments})", $"{@class}.{method}({receiver}Value{tail})", null, returns, method, "Task", AwaitDrops: false, Group: Group(receiver + "Value"));
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Analyzers.Tests/Variants/QueryDelegateShapes.cs b/test/CodoMetis.TypeKit.Analyzers.Tests/Variants/QueryDelegateShapes.cs
new file mode 100644
index 00000000..1c27bacd
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Analyzers.Tests/Variants/QueryDelegateShapes.cs
@@ -0,0 +1,229 @@
+namespace CodoMetis.TypeKit.Analyzers.Tests.Variants;
+
+/// <summary>
+/// What a call to a TypeKit lookup is made on: how the receiver is typed, and how the call is written.
+/// </summary>
+/// <param name="Name">What the receiver is, as a test case names it.</param>
+/// <param name="Parameter">The run method's parameter that holds it, <c>{A}</c> the element type.</param>
+/// <param name="Call">
+/// The call as written: <c>{Class}</c> is <c>Option</c> or <c>Result</c>, <c>{M}</c> the method,
+/// <c>{Args}</c> its arguments, and <c>[[</c> <c>]]</c> enclose the invocation a diagnostic reports.
+/// </param>
+/// <param name="IsQuery">Whether the receiver is an <c>IQueryable&lt;T&gt;</c> before the compiler converts it.</param>
+/// <param name="TypeParameters">The run method's type parameters, empty for none.</param>
+/// <param name="Where">Their constraint clauses.</param>
+public sealed record QueryReceiver(string Name, string Parameter, string Call, bool IsQuery, string TypeParameters = "", string Where = "")
+{
+    public override string ToString() => Name;
+}
+
+/// <summary>What a condition converts to.</summary>
+public enum Converts
+{
+    /// <summary>A <c>Func</c> alone, so a query's overload cannot take it.</summary>
+    ToDelegate,
+
+    /// <summary>A <c>Func</c> or an expression: a lambda, which binds to the query's overload where there is one.</summary>
+    ToEither,
+
+    /// <summary>An expression alone, which a sequence's overload cannot take.</summary>
+    ToExpression,
+}
+
+/// <summary>A condition passed to a lookup, written in the run method's body.</summary>
+/// <param name="Name">What the condition is, as a test case names it.</param>
+/// <param name="Argument">The argument as written; the members it names are <see cref="QueryDelegateShapes.Members"/>.</param>
+/// <param name="Converts">What it converts to.</param>
+public sealed record QueryCondition(string Name, string Argument, Converts Converts)
+{
+    public bool IsDelegate => Converts == Converts.ToDelegate;
+
+    public override string ToString() => Name;
+}
+
+/// <summary>One of the lookups that has an overload on a sequence, taking a <c>Func</c>, and one on a query.</summary>
+/// <param name="Name">The method.</param>
+/// <param name="Class">The static class that declares it.</param>
+/// <param name="After">The arguments after the condition.</param>
+/// <param name="HasQueryOverload">
+/// Whether its query overload compiles: <c>LastOrNone</c>'s and <c>LastOrError</c>'s refuse to, so a
+/// lambda at the call on a query is no case.
+/// </param>
+public sealed record QueryLookup(string Name, string Class, string After, bool HasQueryOverload)
+{
+    public override string ToString() => Name;
+}
+
+/// <summary>
+/// The variant catalogue for CMTK0009's query condition (design/adr/0095): a lookup called on a query
+/// with a condition that is a delegate binds to its sequence overload, and reads every row.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Three axes. The receiver: how a query can be typed (an interface, one deriving from it, a class
+/// implementing it, a type parameter constrained to it, EF Core's <c>DbSet</c> in its own test) and the
+/// call shapes of <see cref="TypeArgumentSites"/> that move the receiver (a null-conditional call, the
+/// lowered static form, a call in a lambda), against sequences that are no query. The condition: every
+/// way C# writes a delegate, against the forms that convert to an expression. The element type is
+/// <see cref="TypeArgumentKinds"/>.
+/// </para>
+/// <para>
+/// A receiver typed as a sequence is no query to the rule, even where it holds one: the call cannot
+/// bind otherwise, and <c>AsEnumerable()</c> or a cast says the full read is meant.
+/// </para>
+/// </remarks>
+public static class QueryDelegateShapes
+{
+    /// <summary>The members the conditions name, declared in the class that holds the run method.</summary>
+    public const string Members =
+        """
+            private static Func<{A}, bool> field = x => true;
+            private static Func<{A}, bool> Property => x => true;
+            private static readonly Expression<Func<{A}, bool>> expressionField = x => true;
+            private static bool Test({A} x) => true;
+            private bool InstanceTest({A} x) => true;
+            private static Func<{A}, bool> Make() => x => true;
+        """;
+
+    /// <summary>The locals the conditions name, declared at the top of the run method.</summary>
+    public const string Locals =
+        """
+                Func<{A}, bool> local = x => true;
+                Expression<Func<{A}, bool>> expressionLocal = x => true;
+                static bool LocalTest({A} x) => true;
+        """;
+
+    /// <summary>The declarations the receivers name, a file of their own.</summary>
+    public const string Declarations =
+        """
+        using System.Collections;
+        using System.Linq;
+        using System.Linq.Expressions;
+
+        public abstract class Table<T> : IQueryable<T>
+        {
+            public abstract Type ElementType { get; }
+            public abstract Expression Expression { get; }
+            public abstract IQueryProvider Provider { get; }
+            public abstract IEnumerator<T> GetEnumerator();
+            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        }
+
+        public interface IRepository<T> : IQueryable<T> { }
+
+        """;
+
+    public static IReadOnlyList<QueryLookup> Lookups { get; } =
+    [
+        new("FirstOrNone", "Option", "", HasQueryOverload: true),
+        new("SingleOrNone", "Option", "", HasQueryOverload: true),
+        new("FirstOrError", "Result", ", \"none\"", HasQueryOverload: true),
+        new("LastOrNone", "Option", "", HasQueryOverload: false),
+        new("LastOrError", "Result", ", \"none\"", HasQueryOverload: false),
+    ];
+
+    private const string Instance = "_ = [[source.{M}({Args})]];";
+
+    public static IReadOnlyList<QueryReceiver> Receivers { get; } =
+    [
+        // A query, as it can be typed.
+        new("an IQueryable<T>", "IQueryable<{A}> source", Instance, IsQuery: true),
+        new("an IOrderedQueryable<T>", "IOrderedQueryable<{A}> source", Instance, IsQuery: true),
+        new("an EnumerableQuery<T>, a class from metadata", "EnumerableQuery<{A}> source", Instance, IsQuery: true),
+        new("a class that implements IQueryable<T>", "Table<{A}> source", Instance, IsQuery: true),
+        new("an interface that derives from IQueryable<T>", "IRepository<{A}> source", Instance, IsQuery: true),
+        new("a type parameter constrained to IQueryable<T>", "TQuery source", Instance, IsQuery: true, "<TQuery>", "where TQuery : IQueryable<{A}>"),
+        new("a type parameter bound by one constrained to IQueryable<T>", "TQuery source", Instance, IsQuery: true, "<TBase, TQuery>", "where TBase : IQueryable<{A}> where TQuery : TBase"),
+
+        // A query, as the call is written.
+        new("a composed query", "IQueryable<{A}> source", "_ = [[source.Where(x => true).{M}({Args})]];", IsQuery: true),
+        new("a list made a query", "List<{A}> source", "_ = [[source.AsQueryable().{M}({Args})]];", IsQuery: true),
+        new("a parenthesized receiver", "IQueryable<{A}> source", "_ = [[(source).{M}({Args})]];", IsQuery: true),
+        new("a null-conditional call", "IQueryable<{A}> source", "_ = source?[[.{M}({Args})]];", IsQuery: true),
+        new("the lowered static form", "IQueryable<{A}> source", "_ = [[{Class}.{M}(source, {Args})]];", IsQuery: true),
+        new("a call in a lambda", "IQueryable<{A}> source", "Action act = () => _ = [[source.{M}({Args})]];", IsQuery: true),
+        new("a query held in a local", "IQueryable<{A}> source", "var held = source.Where(x => true);\n_ = [[held.{M}({Args})]];", IsQuery: true),
+
+        // No query.
+        new("an IEnumerable<T>", "IEnumerable<{A}> source", Instance, IsQuery: false),
+        new("a List<T>", "List<{A}> source", Instance, IsQuery: false),
+        new("an array", "{A}[] source", Instance, IsQuery: false),
+        new("a type parameter constrained to IEnumerable<T>", "TSequence source", Instance, IsQuery: false, "<TSequence>", "where TSequence : IEnumerable<{A}>"),
+        new("a query read through AsEnumerable()", "IQueryable<{A}> source", "_ = [[source.AsEnumerable().{M}({Args})]];", IsQuery: false),
+        new("a query cast to IEnumerable<T>", "IQueryable<{A}> source", "_ = [[((IEnumerable<{A}>)source).{M}({Args})]];", IsQuery: false),
+        new("a query held as IEnumerable<T>", "IQueryable<{A}> source", "IEnumerable<{A}> held = source;\n_ = [[held.{M}({Args})]];", IsQuery: false),
+        new("a sequence in the lowered static form", "IEnumerable<{A}> source", "_ = [[{Class}.{M}(source, {Args})]];", IsQuery: false),
+    ];
+
+    public static IReadOnlyList<QueryCondition> Conditions { get; } =
+    [
+        new("a Func local", "local", Converts.ToDelegate),
+        new("a Func parameter", "parameter", Converts.ToDelegate),
+        new("a Func field", "field", Converts.ToDelegate),
+        new("a Func property", "Property", Converts.ToDelegate),
+        new("a static method group", "Test", Converts.ToDelegate),
+        new("an instance method group", "InstanceTest", Converts.ToDelegate),
+        new("a local function's method group", "LocalTest", Converts.ToDelegate),
+        new("an anonymous method", "delegate ({A} x) { return true; }", Converts.ToDelegate),
+        new("a call that returns a Func", "Make()", Converts.ToDelegate),
+        new("a conditional of two Funcs", "flag ? local : field", Converts.ToDelegate),
+        new("a lambda cast to a Func", "(Func<{A}, bool>)(x => true)", Converts.ToDelegate),
+        new("an expression compiled", "expressionField.Compile()", Converts.ToDelegate),
+
+        new("a lambda at the call", "x => true", Converts.ToEither),
+        new("a static lambda", "static x => true", Converts.ToEither),
+        new("a lambda with a typed parameter", "({A} x) => true", Converts.ToEither),
+        new("an expression local", "expressionLocal", Converts.ToExpression),
+        new("an expression field", "expressionField", Converts.ToExpression),
+    ];
+
+    /// <summary>
+    /// A file whose run method calls every lookup on <paramref name="receiver"/> with every condition, over
+    /// elements written <paramref name="element"/>, and the calls a diagnostic is expected at, by markup location.
+    /// </summary>
+    public static (string Source, IReadOnlyList<(int Location, QueryLookup Lookup, QueryCondition Condition)> Expected) Use(
+        QueryReceiver receiver, string element, string parameters = "", string where = "")
+    {
+        var expected = new List<(int, QueryLookup, QueryCondition)>();
+        var body     = new System.Text.StringBuilder();
+
+        foreach (var lookup in Lookups)
+        foreach (var condition in Conditions)
+        {
+            // A call that does not compile is no case: an expression on a sequence, and on a query a lambda
+            // or an expression given to a lookup whose query overload refuses to compile.
+            if (condition.Converts == Converts.ToExpression && !receiver.IsQuery) continue;
+            if (!condition.IsDelegate && receiver.IsQuery && !lookup.HasQueryOverload) continue;
+
+            var reported = receiver.IsQuery && condition.IsDelegate;
+            var call     = receiver.Call.Replace("{Class}", lookup.Class).Replace("{M}", lookup.Name).Replace("{Args}", condition.Argument + lookup.After);
+
+            call = reported
+                ? call.Replace("[[", $"{{|#{expected.Count}:").Replace("]]", "|}")
+                : call.Replace("[[", "").Replace("]]", "");
+
+            if (reported) expected.Add((expected.Count, lookup, condition));
+
+            body.Append("        {\n            ").Append(call.Replace("\n", "\n            ")).Append("\n        }\n");
+        }
+
+        var source =
+            $$"""
+              using System.Linq;
+              using System.Linq.Expressions;
+
+              public sealed class Use{{parameters}} {{where}}
+              {
+              {{Members}}
+
+                  public void Run{{receiver.TypeParameters}}({{receiver.Parameter}}, Func<{A}, bool> parameter, bool flag) {{receiver.Where}}
+                  {
+              {{Locals}}
+              {{body}}
+                  }
+              }
+              """;
+
+        return (source.Replace("{A}", element), expected);
+    }
+}
diff --git a/test/CodoMetis.TypeKit.AspNetCore.Tests/ComposedFaultResponseTests.cs b/test/CodoMetis.TypeKit.AspNetCore.Tests/ComposedFaultResponseTests.cs
index ac859afb..d6c493da 100644
--- a/test/CodoMetis.TypeKit.AspNetCore.Tests/ComposedFaultResponseTests.cs
+++ b/test/CodoMetis.TypeKit.AspNetCore.Tests/ComposedFaultResponseTests.cs
@@ -224,6 +224,21 @@ public async Task Two_types_sharing_a_member_s_bare_name_are_a_warning_and_the_h
         logs.Warnings.ShouldHaveSingleItem().ShouldContain("HTTP: PUT /orders/{id:int} answers ComposedFaultResponseTests.OrderFault.NameTaken and ComposedFaultResponseTests.ClashingFault.NameTaken alike, as the fault \"NameTaken\"");
     }
 
+    /// <summary>A member whose name the mapping withholds writes no name, so it shares none with another type's (decision 111).</summary>
+    [Fact]
+    public async Task A_shared_name_one_type_withholds_is_no_warning()
+    {
+        var logs = new ListedLogs();
+        await using var app = await StartAsync(
+            logs: logs,
+            clashWithheld: true,
+            endpoints: app => app.MapPut("/orders/{id:int}", Results<NoContent, FaultProblem<OrderFault>, FaultProblem<ClashingFault>> (int id) =>
+                id == 1 ? TypedResults.NoContent() : NameTakenAsIn20()));
+
+        (await ProblemAsync(app, "PUT", "/orders/2", HttpStatusCode.Conflict))["fault"]!.GetValue<string>().ShouldBe("NameTaken");
+        logs.Warnings.ShouldBeEmpty();
+    }
+
     [Fact]
     public async Task Qualified_names_keep_a_shared_member_name_apart()
     {
@@ -313,7 +328,8 @@ private static async Task<WebApplication> StartAsync(
         Action<IServiceCollection>? services = null,
         ILoggerProvider? logs = null,
         bool typeKit = true,
-        Action<Microsoft.AspNetCore.OpenApi.OpenApiOptions>? openApi = null)
+        Action<Microsoft.AspNetCore.OpenApi.OpenApiOptions>? openApi = null,
+        bool clashWithheld = false)
     {
         var builder = WebApplication.CreateBuilder(new WebApplicationOptions { EnvironmentName = Environments.Production });
         builder.WebHost.UseTestServer();
@@ -350,7 +366,7 @@ private static async Task<WebApplication> StartAsync(
         }
         builder.Services.AddFaultResponses<ClashingFault>(fault => fault switch
         {
-            ClashingFault.NameTaken => StatusCodes.Status409Conflict,
+            ClashingFault.NameTaken => clashWithheld ? FaultResponse.Status(StatusCodes.Status409Conflict).WithoutFaultName() : StatusCodes.Status409Conflict,
             ClashingFault.Other => StatusCodes.Status422UnprocessableEntity,
             _ => throw new ArgumentOutOfRangeException(nameof(fault)),
         });
diff --git a/test/CodoMetis.TypeKit.AspNetCore.Tests/DescribedParameterTests.cs b/test/CodoMetis.TypeKit.AspNetCore.Tests/DescribedParameterTests.cs
index 05252090..9560df30 100644
--- a/test/CodoMetis.TypeKit.AspNetCore.Tests/DescribedParameterTests.cs
+++ b/test/CodoMetis.TypeKit.AspNetCore.Tests/DescribedParameterTests.cs
@@ -148,7 +148,7 @@ private static Task<OpenApiJson> DocumentAsync(OpenApiSpecVersion version, strin
                 if (key.Item2 == "inline-all") openApi.CreateSchemaReferenceId = _ => null;
                 if (key.Described) openApi.AddTypeKit();
 
-                // The README's way to inline value objects alone.
+                // A host's own way to inline value objects alone, which needs no AddTypeKit().
                 if (key.Item2 == "inline-value-objects")
                     openApi.CreateSchemaReferenceId = type =>
                         (Nullable.GetUnderlyingType(type.Type) ?? type.Type).GetCustomAttribute<GeneratedValueObjectAttribute>() is not null
diff --git a/test/CodoMetis.TypeKit.AspNetCore.Tests/FaultResponsePartsTests.cs b/test/CodoMetis.TypeKit.AspNetCore.Tests/FaultResponsePartsTests.cs
index 0ac7324a..edc6ec85 100644
--- a/test/CodoMetis.TypeKit.AspNetCore.Tests/FaultResponsePartsTests.cs
+++ b/test/CodoMetis.TypeKit.AspNetCore.Tests/FaultResponsePartsTests.cs
@@ -50,6 +50,18 @@ private static Result<Fault<OrderFault>> ArchiveWithRule(int id) =>
     private static Result<Fault<OrderFault>> ArchiveWithDetail(int id) =>
         id == 1 ? Result.Success() : Result.Error(Fault.Of(OrderFault.NameTaken, "Order 7 is called that."));
 
+    /// <summary>What failed underneath a refusal, which names a host the client must not learn of.</summary>
+    private static readonly TimeoutException Underneath = new("db-host-7 timed out after 30 s");
+
+    private static Result<Order, Fault<OrderFault>> RenameWithCause(int id) =>
+        id == 1 ? new Order(1, "renamed") : Result.Error(Fault.Of(OrderFault.NameTaken, "Order 7 is called that.", Underneath));
+
+    private static Result<Fault<OrderFault>> ArchiveWithCause(int id) =>
+        id == 1 ? Result.Success() : Result.Error(Fault.Of(OrderFault.NameTaken, "Order 7 is called that.", Underneath));
+
+    private static Result<Order, Fault<OrderFault, ProbeOrderFault>> RenameComposedWithCause(int id) =>
+        id == 1 ? new Order(1, "renamed") : Result.Error(Fault<OrderFault, ProbeOrderFault>.Of(OrderFault.NameTaken, "Order 7 is called that.", Underneath));
+
     private static Result<Order, ProbeOrderFault> Find(int id) => id switch
     {
         1 => new Order(1, "book"),
@@ -183,6 +195,45 @@ public void ToHttpResult_resolves_for_an_enum_a_fault_and_a_closed_set_without_t
         Rename(1).ToHttpResult(order => TypedResults.Created($"/orders/{order.Id}", order)).Result.ShouldBeOfType<Created<Order>>();
     }
 
+    /// <summary>
+    /// The Result page: <c>ToHttpResult()</c> accepts an enum, a closed set and a fault of one or several types,
+    /// never a <c>Result&lt;T, Exception&gt;</c>, whose exception is for the code that called. Every overload's
+    /// error is a <c>Fault</c>, or a type parameter whose constraints an exception does not meet.
+    /// </summary>
+    [Fact]
+    public void ToHttpResult_accepts_no_result_whose_error_is_an_exception()
+    {
+        var overloads = new[] { typeof(TypeKitHttpResultExtensions), typeof(TypeKitClosedSetHttpResultExtensions) }
+            .SelectMany(type => type.GetMethods(BindingFlags.Public | BindingFlags.Static))
+            .Where(method => method.Name == nameof(TypeKitHttpResultExtensions.ToHttpResult))
+            .ToList();
+
+        overloads.Count.ShouldBeGreaterThanOrEqualTo(20);
+        overloads.Where(method => Admits(method.GetParameters()[0].ParameterType.GetGenericArguments()[^1], typeof(Exception)))
+                 .Select(method => method.ToString())
+                 .ShouldBeEmpty();
+
+        static bool Admits(Type error, Type candidate)
+        {
+            if (!error.IsGenericParameter) return error.IsAssignableFrom(candidate);
+            if (error.GenericParameterAttributes.HasFlag(GenericParameterAttributes.NotNullableValueTypeConstraint) && !candidate.IsValueType) return false;
+
+            try
+            {
+                return error.GetGenericParameterConstraints().All(constraint => Substituted(constraint, error, candidate).IsAssignableFrom(candidate));
+            }
+            catch (ArgumentException)
+            {
+                return false; // the constraint cannot even be formed over the candidate
+            }
+        }
+
+        static Type Substituted(Type constraint, Type parameter, Type candidate) =>
+            constraint.IsGenericType && constraint.ContainsGenericParameters
+                ? constraint.GetGenericTypeDefinition().MakeGenericType([.. constraint.GetGenericArguments().Select(argument => argument == parameter ? candidate : argument)])
+                : constraint;
+    }
+
     // 4: a detail reaches the body only when set, and the default response is unchanged.
     [Fact]
     public async Task A_detail_reaches_the_problem_only_when_there_is_one()
@@ -412,11 +463,67 @@ public async Task CustomizeProblemDetails_sees_the_rule()
         (await ProblemAsync(app, "/detailed/orders/2", HttpStatusCode.Conflict))["code"]!.GetValue<string>().ShouldBe("-");
     }
 
+    /// <summary>
+    /// A fault's cause reaches the host through the feature, for its log, through every overload over a
+    /// <see cref="Fault{TFault}"/> and over a fault of several types, and never the client: the problem
+    /// has the members the same fault without a cause writes, and names neither the exception's type nor
+    /// its message (decision 52).
+    /// </summary>
+    [Theory]
+    [InlineData("PUT", "/caused/orders/2")]              // Result<T, Fault<TFault>>
+    [InlineData("DELETE", "/caused/orders/2")]           // Result<Fault<TFault>>
+    [InlineData("POST", "/caused/orders/2/copies")]      // Result<T, Fault<TFault>>, with the endpoint's success
+    [InlineData("POST", "/caused/orders/2/archive")]     // Result<Fault<TFault>>, with the endpoint's success
+    [InlineData("PATCH", "/caused/orders/2")]            // Result<T, Fault<T1, T2>>
+    public async Task A_cause_reaches_the_host_through_the_feature_and_never_the_problem(string method, string path)
+    {
+        var causes = new List<Exception?>();
+        await using var app = await StartAsync(
+            services: services =>
+            {
+                Responses(services);
+                services.AddProblemDetails(options => options.CustomizeProblemDetails = context =>
+                    causes.Add(context.HttpContext.Features.Get<IFaultFeature>()?.Cause));
+            },
+            endpoints: app =>
+            {
+                app.MapPut("/caused/orders/{id:int}", (int id) => RenameWithCause(id).ToHttpResult());
+                app.MapDelete("/caused/orders/{id:int}", (int id) => ArchiveWithCause(id).ToHttpResult());
+                app.MapPost("/caused/orders/{id:int}/copies", (int id) => RenameWithCause(id).ToHttpResult(order => TypedResults.Created($"/orders/{order.Id}", order)));
+                app.MapPost("/caused/orders/{id:int}/archive", (int id) => ArchiveWithCause(id).ToHttpResult(() => TypedResults.Accepted("/jobs/7")));
+                app.MapPatch("/caused/orders/{id:int}", (int id) => RenameComposedWithCause(id).ToHttpResult());
+            });
+
+        using var request = new HttpRequestMessage(new HttpMethod(method), path);
+        using var response = await app.GetTestClient().SendAsync(request, TestContext.Current.CancellationToken);
+        var body = await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken);
+
+        response.StatusCode.ShouldBe(HttpStatusCode.Conflict, $"{method} {path}");
+        causes.ShouldHaveSingleItem().ShouldBeSameAs(Underneath, $"{method} {path}");
+        JsonNode.Parse(body)!.AsObject().Select(member => member.Key).Order().ToArray().ShouldBe(["detail", "fault", "status", "title", "traceId", "type"], customMessage: body);
+        body.ShouldNotContain(nameof(TimeoutException), Case.Insensitive);
+        body.ShouldNotContain("db-host-7", Case.Insensitive);
+    }
+
+    /// <summary>The response an endpoint returns carries the cause as well, for a test or a filter that reads it before it is written.</summary>
+    [Fact]
+    public void The_problem_carries_the_cause_and_a_fault_without_one_none()
+    {
+        RenameWithCause(2).ToHttpResult().Result.ShouldBeOfType<FaultProblem<OrderFault>>().Cause.ShouldBeSameAs(Underneath);
+        RenameWithDetail(2).ToHttpResult().Result.ShouldBeOfType<FaultProblem<OrderFault>>().Cause.ShouldBeNull();
+        RenameWithCause(2).Map(order => order).ToHttpResult().Result.ShouldBeOfType<FaultProblem<OrderFault>>().Rule.ShouldBeNull();
+    }
+
     /// <summary>The rule joined the feature with a default, so a host's or a test's own implementation still builds, and names none.</summary>
     [Fact]
     public void A_fault_feature_of_the_host_s_own_names_no_rule() =>
         ((IFaultFeature)new HostFeature()).Rule.ShouldBeNull();
 
+    /// <summary>The cause joined the feature with a default too.</summary>
+    [Fact]
+    public void A_fault_feature_of_the_host_s_own_has_no_cause() =>
+        ((IFaultFeature)new HostFeature()).Cause.ShouldBeNull();
+
     private sealed class HostFeature : IFaultFeature
     {
         public Type FaultType => typeof(OrderFault);
diff --git a/test/CodoMetis.TypeKit.AspNetCore.Tests/FaultSetDefaultTests.cs b/test/CodoMetis.TypeKit.AspNetCore.Tests/FaultSetDefaultTests.cs
index 872f0ab9..0b4b551f 100644
--- a/test/CodoMetis.TypeKit.AspNetCore.Tests/FaultSetDefaultTests.cs
+++ b/test/CodoMetis.TypeKit.AspNetCore.Tests/FaultSetDefaultTests.cs
@@ -99,6 +99,24 @@ public async Task A_closed_set_that_is_no_fault_set_still_needs_a_mapping_of_its
         refusal.Message.ShouldStartWith("No HTTP status is mapped for the fault type ProbeStatus, which these endpoints answer with: HTTP: DELETE /status.");
     }
 
+    /// <summary>
+    /// The README's "Any closed set can be an error type": a set that is no fault set, mapped on its own, is answered
+    /// through <c>ToHttpResult()</c> with the status its mapping gives and its member's qualified name as the fault.
+    /// </summary>
+    [Fact]
+    public async Task A_closed_set_that_is_no_fault_set_is_answered_with_a_mapping_of_its_own()
+    {
+        await using var app = await StartAsync(
+            services =>
+            {
+                services.AddFaultResponses();   // the fault sets the other endpoints answer with
+                services.AddFaultResponses<ProbeStatus>(status => status == ProbeStatus.Open ? StatusCodes.Status409Conflict : StatusCodes.Status422UnprocessableEntity);
+            },
+            app => app.MapPut("/status", () => Opened().ToHttpResult()));
+
+        (await ProblemAsync(app, "/status", HttpStatusCode.Conflict))["fault"]!.GetValue<string>().ShouldBe("ProbeStatus.Open");
+    }
+
     [Fact]
     public async Task A_member_of_no_kind_stops_the_host()
     {
diff --git a/test/CodoMetis.TypeKit.AspNetCore.Tests/HostConfigurationTests.cs b/test/CodoMetis.TypeKit.AspNetCore.Tests/HostConfigurationTests.cs
index 3d5360f3..41cc369c 100644
--- a/test/CodoMetis.TypeKit.AspNetCore.Tests/HostConfigurationTests.cs
+++ b/test/CodoMetis.TypeKit.AspNetCore.Tests/HostConfigurationTests.cs
@@ -120,7 +120,7 @@ public async Task A_container_another_transformer_already_described_is_left_alon
         }
     }
 
-    /// <summary>The predicate the package README shows, a nullable value object included.</summary>
+    /// <summary>A host's own predicate, a nullable value object included.</summary>
     [Fact]
     public async Task A_host_that_inlines_value_objects_gets_the_wrapped_types_schema_in_place()
     {
@@ -239,12 +239,15 @@ private static async Task<JsonNode> SourceGeneratedDocumentAsync(JsonSerializerC
     /// <summary>
     /// What the README's "Binding" says of a minimal API refusing a body: an empty 400 with
     /// <c>AddProblemDetails()</c> too, a generic problem only with <c>UseStatusCodePages()</c>, and the
-    /// input in neither (spikes/ValidationFaults).
+    /// input in neither (spikes/ValidationFaults). A value object inside a <see cref="Patch{T}"/> refuses alike, as
+    /// the merge-patches page says.
     /// </summary>
     [Theory]
-    [InlineData(false)]
-    [InlineData(true)]
-    public async Task A_minimal_API_answers_a_refused_body_with_a_bare_400(bool statusCodePages)
+    [InlineData(false, "/codes")]
+    [InlineData(true, "/codes")]
+    [InlineData(false, "/patches")]
+    [InlineData(true, "/patches")]
+    public async Task A_minimal_API_answers_a_refused_body_with_a_bare_400(bool statusCodePages, string path)
     {
         var builder = WebApplication.CreateBuilder(new WebApplicationOptions { EnvironmentName = Environments.Production });
         builder.WebHost.UseTestServer();
@@ -254,10 +257,11 @@ public async Task A_minimal_API_answers_a_refused_body_with_a_bare_400(bool stat
         await using var app = builder.Build();
         if (statusCodePages) app.UseStatusCodePages();
         app.MapPost("/codes", (CodeHolder holder) => holder.Code.Value);
+        app.MapPost("/patches", (CodePatch patch) => patch.Code.State.ToString());   // the merge-patches page: a patch refuses as the value object does
         await app.StartAsync(TestContext.Current.CancellationToken);
 
         using var response = await app.GetTestClient().PostAsync(
-            "/codes", new StringContent("""{"code":"lower"}""", System.Text.Encoding.UTF8, "application/json"), TestContext.Current.CancellationToken);
+            path, new StringContent("""{"code":"lower"}""", System.Text.Encoding.UTF8, "application/json"), TestContext.Current.CancellationToken);
         var body = await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken);
 
         response.StatusCode.ShouldBe(HttpStatusCode.BadRequest);
@@ -276,6 +280,8 @@ public async Task A_minimal_API_answers_a_refused_body_with_a_bare_400(bool stat
 
     private sealed record CodeHolder(ProbeCode Code);
 
+    private sealed record CodePatch(Patch<ProbeCode> Code);
+
     private sealed class InstantSchemaTransformer : IOpenApiSchemaTransformer
     {
         public Task TransformAsync(OpenApiSchema schema, OpenApiSchemaTransformerContext context, CancellationToken cancellationToken)
diff --git a/test/CodoMetis.TypeKit.AspNetCore.Tests/InlineValueObjectsSettingTests.cs b/test/CodoMetis.TypeKit.AspNetCore.Tests/InlineValueObjectsSettingTests.cs
new file mode 100644
index 00000000..d4fd05a7
--- /dev/null
+++ b/test/CodoMetis.TypeKit.AspNetCore.Tests/InlineValueObjectsSettingTests.cs
@@ -0,0 +1,110 @@
+using System.Reflection;
+using CodoMetis.TypeKit.AspNetCore.Tests.Collisions;
+using CodoMetis.TypeKit.CompilerServices;
+using CodoMetis.TypeKit.Generators.Probes;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.OpenApi;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.OpenApi;
+
+namespace CodoMetis.TypeKit.AspNetCore.Tests;
+
+/// <summary>
+/// <see cref="TypeKitOpenApiOptions.InlineValueObjects"/> writes every value object in place and names no component
+/// after one, and the document without it is the one <c>AddTypeKit()</c> writes (decision 115). The schemas it writes
+/// are held to the wrapped type's by <c>SchemaTests</c> and <c>NullablePositionTests</c>, under both settings.
+/// </summary>
+public sealed class InlineValueObjectsSettingTests
+{
+    private static readonly OpenApiSpecVersion[] Versions = [OpenApiSpecVersion.OpenApi3_1, OpenApiSpecVersion.OpenApi3_0, OpenApiSpecVersion.OpenApi2_0];
+
+    public static TheoryData<OpenApiSpecVersion> EveryVersion() => [.. Versions];
+
+    /// <summary>The names a value object of these assemblies would have as a component, after its nesting chain.</summary>
+    private static readonly HashSet<string> ValueObjectNames =
+    [
+        .. new[] { typeof(ProbeId).Assembly, typeof(InlineValueObjectsSettingTests).Assembly }
+            .SelectMany(assembly => assembly.GetTypes())
+            .Where(type => type.GetCustomAttribute<GeneratedValueObjectAttribute>(inherit: false) is { } valueObject && valueObject.ValueObjectType == type)
+            .Select(Chain),
+    ];
+
+    [Theory]
+    [MemberData(nameof(EveryVersion))]
+    public async Task No_component_is_a_value_object(OpenApiSpecVersion version)
+    {
+        var inlined = await ProbeHost.DocumentAsync(openApi => openApi.AddTypeKit(typeKit => typeKit.InlineValueObjects = true), version: version);
+        var components = await ProbeHost.DefaultDocumentAsync(version);
+
+        // The control: without the setting, the same endpoints name components after value objects.
+        components.Components.Select(component => component.Key).Where(ValueObjectNames.Contains).ShouldNotBeEmpty();
+
+        inlined.Components.Select(component => component.Key).Where(ValueObjectNames.Contains).ShouldBeEmpty();
+        var json = inlined.Root.ToJsonString();
+        foreach (var name in ValueObjectNames) json.ShouldNotContain($"/{name}\"", customMessage: $"a reference to '{name}' is left");
+    }
+
+    [Theory]
+    [MemberData(nameof(EveryVersion))]
+    public async Task Without_the_setting_the_document_is_the_one_AddTypeKit_writes(OpenApiSpecVersion version)
+    {
+        var plain = await ProbeHost.DocumentAsync(openApi => openApi.AddTypeKit(), version: version);
+        var unset = await ProbeHost.DocumentAsync(openApi => openApi.AddTypeKit(_ => { }), version: version);
+        var off = await ProbeHost.DocumentAsync(openApi => openApi.AddTypeKit(typeKit => typeKit.InlineValueObjects = false), version: version);
+
+        unset.Root.ShouldDescribeTheSameAs(plain.Root, "no setting chosen");
+        off.Root.ShouldDescribeTheSameAs(plain.Root, "InlineValueObjects = false");
+    }
+
+    /// <summary>A second, plain <c>AddTypeKit()</c> asks the first for the name, which is none.</summary>
+    [Fact]
+    public async Task A_later_AddTypeKit_keeps_them_inlined()
+    {
+        var once = await ProbeHost.DocumentAsync(openApi => openApi.AddTypeKit(typeKit => typeKit.InlineValueObjects = true));
+        var twice = await ProbeHost.DocumentAsync(openApi => openApi.AddTypeKit(typeKit => typeKit.InlineValueObjects = true).AddTypeKit());
+
+        twice.Root.ShouldDescribeTheSameAs(once.Root);
+    }
+
+    /// <summary>A name the host's own delegate gives a value object does not make it a component; every other type keeps its name.</summary>
+    [Fact]
+    public async Task The_host_s_own_names_are_kept_for_every_other_type()
+    {
+        var document = await ProbeHost.DocumentAsync(openApi =>
+        {
+            openApi.CreateSchemaReferenceId = type =>
+                type.Type == typeof(ProbeDocument) ? "Probes" : type.Type == typeof(ProbeId) ? "Identifier" : OpenApiOptions.CreateDefaultSchemaReferenceId(type);
+            openApi.AddTypeKit(typeKit => typeKit.InlineValueObjects = true);
+        });
+
+        document.Components.ContainsKey("Identifier").ShouldBeFalse("the host's name made the value object a component");
+        document.Property("Probes", "id").ShouldDescribeTheSameAs(new JsonObject { ["type"] = "string", ["format"] = "uuid" });
+    }
+
+    /// <summary>
+    /// Decision 55 refuses a name two types claim. Inlined, a value object claims none, so a nested one and a top-level one
+    /// of its chain's name are two schemas in place; a closed set still claims its name, and is still refused.
+    /// </summary>
+    [Fact]
+    public async Task Value_objects_claim_no_name_and_closed_sets_still_do()
+    {
+        var carts = await ProbeHost.DocumentAsync(
+            openApi => openApi.AddTypeKit(typeKit => typeKit.InlineValueObjects = true),
+            endpoints: app => app.MapPost("/carts", int (Carts carts) => 0));
+
+        carts.Property(nameof(Carts), "nested").ShouldDescribeTheSameAs(new JsonObject { ["type"] = "string", ["format"] = "uuid" });
+        carts.Property(nameof(Carts), "topLevel")["format"]!.GetValue<string>().ShouldBe("int32");
+
+        var refusal = await Should.ThrowAsync<InvalidOperationException>(() => ProbeHost.DocumentAsync(
+            openApi => openApi.AddTypeKit(typeKit => typeKit.InlineValueObjects = true),
+            endpoints: app => app.MapPost("/orders", int (OrderStatuses statuses) => 0)));
+        refusal.Message.ShouldContain("'OrderStatus'");
+    }
+
+    [Fact]
+    public void A_null_configuration_is_refused() =>
+        Should.Throw<ArgumentNullException>(() => new OpenApiOptions().AddTypeKit(configure: null!)).ParamName.ShouldBe("configure");
+
+    private static string Chain(Type type) => type.DeclaringType is { } declaring ? Chain(declaring) + type.Name : type.Name;
+}
diff --git a/test/CodoMetis.TypeKit.AspNetCore.Tests/InlinedValueObjectTests.cs b/test/CodoMetis.TypeKit.AspNetCore.Tests/InlinedValueObjectTests.cs
index 584be04f..4a59196a 100644
--- a/test/CodoMetis.TypeKit.AspNetCore.Tests/InlinedValueObjectTests.cs
+++ b/test/CodoMetis.TypeKit.AspNetCore.Tests/InlinedValueObjectTests.cs
@@ -9,7 +9,7 @@
 namespace CodoMetis.TypeKit.AspNetCore.Tests;
 
 /// <summary>
-/// A host that inlines value objects (the README's <c>CreateSchemaReferenceId</c> returning <see langword="null"/>)
+/// A host that inlines value objects (its own <c>CreateSchemaReferenceId</c> returning <see langword="null"/>)
 /// gets, in every position, exactly what ASP.NET publishes for the wrapped type there: a nullable value object
 /// admits null as a nullable <c>int</c>, <c>string</c>, <c>Guid</c> or enum does, and a non-nullable one does not.
 /// </summary>
@@ -119,7 +119,7 @@ public async Task Adding_it_twice_to_an_inlining_host_publishes_the_same_documen
         _ => schema?.DeepClone(),
     };
 
-    /// <summary>The README's predicate.</summary>
+    /// <summary>A host's own predicate, as TypeKitOpenApiOptions.InlineValueObjects does (NullablePositionTests holds the setting).</summary>
     private static void InlineValueObjects(OpenApiOptions openApi)
     {
         openApi.AddTypeKit();
diff --git a/test/CodoMetis.TypeKit.AspNetCore.Tests/NullablePositionTests.cs b/test/CodoMetis.TypeKit.AspNetCore.Tests/NullablePositionTests.cs
index 6e550fae..67ed9975 100644
--- a/test/CodoMetis.TypeKit.AspNetCore.Tests/NullablePositionTests.cs
+++ b/test/CodoMetis.TypeKit.AspNetCore.Tests/NullablePositionTests.cs
@@ -1,8 +1,6 @@
 using System.Collections.Concurrent;
-using System.Reflection;
 using System.Text.Json.Serialization;
 using System.Text.Json.Serialization.Metadata;
-using CodoMetis.TypeKit.CompilerServices;
 using CodoMetis.TypeKit.Generators.Probes;
 using CodoMetis.TypeKit.ValueObjects;
 using Microsoft.AspNetCore.Builder;
@@ -21,7 +19,7 @@ namespace CodoMetis.TypeKit.AspNetCore.Tests;
 /// operation (body, query, header, form, route, response, a list's elements, a dictionary's values, a query or header
 /// array's items, a property of a non-abstract polymorphic base's derived branch and of its own), in MVC
 /// and in minimal APIs, with enums written by number or by name, and with everything inlined, value objects alone
-/// inlined or components, exactly the schema ASP.NET publishes for the wrapped type in the same position at the same
+/// inlined (<see cref="TypeKitOpenApiOptions.InlineValueObjects"/>) or components, in OpenAPI 3.1, 3.0 and 2.0, exactly the schema ASP.NET publishes for the wrapped type in the same position at the same
 /// nullability.
 /// </summary>
 /// <remarks>
@@ -113,14 +111,9 @@ public async Task A_value_object_is_described_as_its_wrapped_type_in_the_same_po
             openApi =>
             {
                 if (key.Item2 == "inline-all") openApi.CreateSchemaReferenceId = _ => null;
-                openApi.AddTypeKit();
-
-                // The README's way to inline value objects alone: the wrapped enum stays ASP.NET's component.
-                if (key.Item2 == "inline-value-objects")
-                    openApi.CreateSchemaReferenceId = type =>
-                        (Nullable.GetUnderlyingType(type.Type) ?? type.Type).GetCustomAttribute<GeneratedValueObjectAttribute>() is not null
-                            ? null
-                            : OpenApiOptions.CreateDefaultSchemaReferenceId(type);
+
+                // The setting that inlines value objects alone (decision 115): the wrapped enum stays ASP.NET's component.
+                openApi.AddTypeKit(typeKit => typeKit.InlineValueObjects = key.Item2 == "inline-value-objects");
             },
             json: json =>
             {
diff --git a/test/CodoMetis.TypeKit.AspNetCore.Tests/PatchSchemaTests.cs b/test/CodoMetis.TypeKit.AspNetCore.Tests/PatchSchemaTests.cs
index f69470fc..7fe4c2f2 100644
--- a/test/CodoMetis.TypeKit.AspNetCore.Tests/PatchSchemaTests.cs
+++ b/test/CodoMetis.TypeKit.AspNetCore.Tests/PatchSchemaTests.cs
@@ -28,6 +28,9 @@ public sealed record StrictPatch(Patch<string> Name)
 
     public sealed record Control(string? Name, int Quantity, ProbeCode Code, ProbeId Id, Lines? Lines);
 
+    /// <summary>A patch parameter with <c>= default</c>, which the merge-patches page says breaks the document.</summary>
+    public sealed record DefaultedPatch(Patch<int> Quantity = default);
+
     [JsonConverter(typeof(JsonStringEnumConverter<Colour>))]
     public enum Colour { Red, Green }
 
@@ -234,6 +237,20 @@ static IEnumerable<string> Required(OpenApiJson document) =>
             document.Component(nameof(StrictPatch))["required"]?.AsArray().Select(node => node!.GetValue<string>()) ?? [];
     }
 
+    /// <summary>
+    /// The merge-patches page's warning: <c>= default</c> on a patch parameter satisfies the serializer, but
+    /// System.Text.Json's schema exporter throws on a struct parameter whose default is <c>default</c>, so the
+    /// endpoint's document fails. Pinned, so the page is corrected when the exporter learns to describe it.
+    /// </summary>
+    [Fact]
+    public async Task A_patch_parameter_defaulted_with_default_breaks_the_document()
+    {
+        var refusal = await Should.ThrowAsync<JsonException>(() => ProbeHost.DocumentAsync(
+            openApi => openApi.AddTypeKit(), endpoints: app => app.MapPatch("/defaulted", int (DefaultedPatch patch) => 0)));
+
+        refusal.StackTrace.ShouldNotBeNull().ShouldContain(nameof(System.Text.Json.Schema.JsonSchemaExporter), customMessage: "the exporter throws, not the converter");
+    }
+
     private static bool AdmitsNull(JsonNode schema, OpenApiSpecVersion version) =>
         version == OpenApiSpecVersion.OpenApi3_1
             ? schema["type"] is JsonArray types && types.Any(type => type!.GetValue<string>() == "null")
diff --git a/test/CodoMetis.TypeKit.AspNetCore.Tests/ProbeApi.cs b/test/CodoMetis.TypeKit.AspNetCore.Tests/ProbeApi.cs
index 061030ca..fe723b1a 100644
--- a/test/CodoMetis.TypeKit.AspNetCore.Tests/ProbeApi.cs
+++ b/test/CodoMetis.TypeKit.AspNetCore.Tests/ProbeApi.cs
@@ -39,7 +39,8 @@ public sealed record ProbeDocument(
     ProbeName Name,
     ProbeName? MaybeName,
     ProbeId? MaybeId,
-    ProbeWeekday? MaybeWeekday);
+    ProbeWeekday? MaybeWeekday,
+    Dictionary<ProbeId, int> CountsById);
 
 /// <summary>The same names as <see cref="ProbeDocument"/>, with the wrapped types.</summary>
 public sealed record ControlDocument(
@@ -68,7 +69,13 @@ public sealed record ControlDocument(
     string Name,
     string? MaybeName,
     Guid? MaybeId,
-    DayOfWeek? MaybeWeekday);
+    DayOfWeek? MaybeWeekday,
+    Dictionary<Guid, int> CountsById,
+    Guid[] IdArray,
+    IReadOnlyList<Guid> ReadOnlyIds,
+    HashSet<Guid> IdSet,
+    Dictionary<string, List<Guid>> NestedIds,
+    List<List<Guid>> ListOfLists);
 
 public sealed record ProbeSearch(ProbeId Customer, ProbeCount? Limit);
 
diff --git a/test/CodoMetis.TypeKit.AspNetCore.Tests/ProbeHost.cs b/test/CodoMetis.TypeKit.AspNetCore.Tests/ProbeHost.cs
index 35fb13f5..4f3d96af 100644
--- a/test/CodoMetis.TypeKit.AspNetCore.Tests/ProbeHost.cs
+++ b/test/CodoMetis.TypeKit.AspNetCore.Tests/ProbeHost.cs
@@ -145,7 +145,8 @@ internal sealed class OpenApiJson(JsonNode root)
 {
     public JsonNode Root => root;
 
-    public JsonObject Components => root["components"]?["schemas"]?.AsObject() ?? [];
+    /// <summary>The components, or under OpenAPI 2.0 the definitions.</summary>
+    public JsonObject Components => (root["components"]?["schemas"] ?? root["definitions"])?.AsObject() ?? [];
 
     public JsonNode Component(string name) =>
         Components[name] ?? throw new InvalidOperationException($"No component '{name}'. Components: {string.Join(", ", Components.Select(c => c.Key))}");
@@ -157,6 +158,15 @@ public JsonNode Property(string component, string property) =>
     public JsonNode Resolve(JsonNode schema) =>
         schema["$ref"] is { } reference ? Component(reference.GetValue<string>().Split('/')[^1]) : schema;
 
+    /// <summary>The schema with every reference replaced by what it refers to.</summary>
+    public JsonNode? Expand(JsonNode? schema) => schema switch
+    {
+        JsonObject reference when reference["$ref"] is { } id => Expand(Component(id.GetValue<string>().Split('/')[^1])),
+        JsonObject keywords => new JsonObject(keywords.Select(keyword => KeyValuePair.Create(keyword.Key, Expand(keyword.Value)))),
+        JsonArray items => new JsonArray([.. items.Select(Expand)]),
+        _ => schema?.DeepClone(),
+    };
+
     public JsonNode Parameter(string path, string method, string name) =>
         Operation(path, method)["parameters"]?.AsArray().SingleOrDefault(p => p!["name"]!.GetValue<string>() == name)?["schema"]
      ?? throw new InvalidOperationException($"{method} {path} has no parameter '{name}'.");
diff --git a/test/CodoMetis.TypeKit.AspNetCore.Tests/SchemaTests.cs b/test/CodoMetis.TypeKit.AspNetCore.Tests/SchemaTests.cs
index 35b7bb24..6b365a65 100644
--- a/test/CodoMetis.TypeKit.AspNetCore.Tests/SchemaTests.cs
+++ b/test/CodoMetis.TypeKit.AspNetCore.Tests/SchemaTests.cs
@@ -1,3 +1,4 @@
+using System.Collections.Concurrent;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.OpenApi;
 
@@ -5,35 +6,69 @@ namespace CodoMetis.TypeKit.AspNetCore.Tests;
 
 /// <summary>
 /// A value object in a JSON position (property, body, element) publishes the schema of the type it
-/// wraps, under a component of its own.
+/// wraps, under a component of its own, or in place with <see cref="TypeKitOpenApiOptions.InlineValueObjects"/>.
 /// </summary>
 public sealed class SchemaTests
 {
-    public static TheoryData<string, OpenApiSpecVersion> WrappedTypeFamilies()
+    private static readonly ConcurrentDictionary<OpenApiSpecVersion, Task<OpenApiJson>> InlineDocuments = new();
+
+    /// <summary>The properties held to their control in both settings: each a value object beside the wrapped type.</summary>
+    private static readonly string[] Properties =
+    [
+        "id", "count", "amount", "flag", "timestamp", "date", "moment", "time", "uri", "weekday",
+        "label", "code", "percentage", "customerId", "nested", "name", "countsById",
+    ];
+
+    /// <summary>
+    /// Held in place only, where the schema is the position's own: a component cannot admit null (decision 36), so
+    /// the components document holds these to the component or null (the tests below, and KB-026 for 2.0).
+    /// </summary>
+    private static readonly string[] InlineOnlyProperties =
+    [
+        "maybeCount", "maybeLabel", "maybeName", "maybeId", "maybeWeekday",
+        "ids", "idArray", "readOnlyIds", "idSet", "counts", "nestedIds", "listOfLists",
+        "maybeCounts", "maybeCountArray", "maybeCountsByKey",
+    ];
+
+    public static TheoryData<string, OpenApiSpecVersion, bool> WrappedTypeFamilies()
     {
-        var data = new TheoryData<string, OpenApiSpecVersion>();
-        foreach (var version in new[] { OpenApiSpecVersion.OpenApi3_1, OpenApiSpecVersion.OpenApi3_0 })
-        foreach (var property in new[]
-                 {
-                     "id", "count", "amount", "flag", "timestamp", "date", "moment", "time", "uri", "weekday",
-                     "label", "code", "percentage", "customerId", "nested",
-                 })
-            data.Add(property, version);
+        var data = new TheoryData<string, OpenApiSpecVersion, bool>();
+        foreach (var version in new[] { OpenApiSpecVersion.OpenApi3_1, OpenApiSpecVersion.OpenApi3_0, OpenApiSpecVersion.OpenApi2_0 })
+        foreach (var inline in new[] { false, true })
+        foreach (var property in inline ? [.. Properties, .. InlineOnlyProperties] : Properties)
+            data.Add(property, version, inline);
 
         return data;
     }
 
     [Theory]
     [MemberData(nameof(WrappedTypeFamilies))]
-    public async Task A_value_object_publishes_the_schema_of_the_type_it_wraps(string property, OpenApiSpecVersion version)
+    public async Task A_value_object_publishes_the_schema_of_the_type_it_wraps(string property, OpenApiSpecVersion version, bool inline)
     {
-        var document = await ProbeHost.DefaultDocumentAsync(version);
+        var document = inline
+            ? await InlineDocuments.GetOrAdd(version, static v => ProbeHost.DocumentAsync(openApi => openApi.AddTypeKit(typeKit => typeKit.InlineValueObjects = true), version: v))
+            : await ProbeHost.DefaultDocumentAsync(version);
 
         var valueObject = document.Property("ProbeDocument", property);
         var control = document.Property("ControlDocument", property);
 
-        valueObject["$ref"].ShouldNotBeNull($"'{property}' should refer to the value object's own component, but was {valueObject.ToJsonString()}");
-        document.Resolve(valueObject).ShouldDescribeTheSameAs(document.Resolve(control), property);
+        if (inline)
+        {
+            // In place, the value object holds what the wrapped type refers to (an enum's component), byte for byte.
+            valueObject.ToJsonString().ShouldNotContain("Probe", customMessage: $"'{property}' refers to a value object's component: {valueObject.ToJsonString()}");
+            document.Expand(valueObject)!.ShouldDescribeTheSameAs(document.Expand(control)!, property);
+        }
+        else if (property == "countsById")
+        {
+            // ASP.NET describes no key, of a Guid or of a value object over one: the two dictionaries are one object.
+            valueObject["propertyNames"].ShouldBeNull();
+            valueObject.ShouldDescribeTheSameAs(control, property);
+        }
+        else
+        {
+            valueObject["$ref"].ShouldNotBeNull($"'{property}' should refer to the value object's own component, but was {valueObject.ToJsonString()}");
+            document.Resolve(valueObject).ShouldDescribeTheSameAs(document.Resolve(control), property);
+        }
     }
 
     [Fact]
diff --git a/test/CodoMetis.TypeKit.AspNetCore.Tests/WithheldFaultNameTests.cs b/test/CodoMetis.TypeKit.AspNetCore.Tests/WithheldFaultNameTests.cs
new file mode 100644
index 00000000..a6adfb0e
--- /dev/null
+++ b/test/CodoMetis.TypeKit.AspNetCore.Tests/WithheldFaultNameTests.cs
@@ -0,0 +1,168 @@
+using CodoMetis.TypeKit.AspNetCore;
+using CodoMetis.TypeKit.Generators.Probes;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.TestHost;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace CodoMetis.TypeKit.AspNetCore.Tests;
+
+/// <summary>
+/// A mapping that withholds a member's name, <c>FaultResponse.Status(401).WithoutFaultName()</c>: the problem
+/// has no <c>fault</c>, no <c>rule</c> and no member description, so two causes on one status answer alike
+/// but for the detail the application wrote, and the document says that status names no fault (decision 111).
+/// </summary>
+public sealed class WithheldFaultNameTests
+{
+    public enum SignInFault { UnknownUser, WrongPassword, Locked }
+
+    public enum PasswordRule { Expired }
+
+    private static Result<string, Fault<SignInFault>> SignIn(string user) => user switch
+    {
+        "nobody" => Result.Error(Fault.Of(SignInFault.UnknownUser)),
+        "ann"    => Result.Error(Fault.Of(SignInFault.WrongPassword).WithRule(PasswordRule.Expired)),
+        "bob"    => Result.Error(Fault.Of(SignInFault.WrongPassword, "Try again in a minute.")),
+        _        => Result.Error(Fault.Of(SignInFault.Locked)),
+    };
+
+    private static Result<Fault<ProbeOrderFault>> Archive(int id) =>
+        id == 1 ? Fault.Of(ProbeOrderFault.NotFound) : Fault.Of(ProbeOrderFault.NotFound, "Order 2 was archived.");
+
+    private static FaultResponse Mapping(SignInFault fault) => fault switch
+    {
+        SignInFault.Locked => StatusCodes.Status403Forbidden,
+        _ => FaultResponse.Status(StatusCodes.Status401Unauthorized).WithType(new Uri("https://problems.example/sign-in")).WithoutFaultName(),
+    };
+
+    [Fact]
+    public async Task Two_withheld_members_on_one_status_answer_alike_with_no_fault_and_no_rule()
+    {
+        await using var app = await StartAsync();
+
+        var unknownUser = await ProblemAsync(app, "/login/nobody");
+        var wrongPassword = await ProblemAsync(app, "/login/ann");
+
+        unknownUser.ContainsKey("fault").ShouldBeFalse(unknownUser.ToJsonString());
+        wrongPassword.ContainsKey("rule").ShouldBeFalse("the rule names the cause as surely as the member does");
+        JsonNode.DeepEquals(unknownUser, wrongPassword).ShouldBeTrue($"{wrongPassword.ToJsonString()} tells itself apart from {unknownUser.ToJsonString()}");
+        unknownUser["status"]!.GetValue<int>().ShouldBe(401);
+        unknownUser["type"]!.GetValue<string>().ShouldBe("https://problems.example/sign-in");
+    }
+
+    [Fact]
+    public async Task The_occurrence_s_own_detail_is_kept_and_a_named_member_still_names_itself()
+    {
+        await using var app = await StartAsync();
+
+        var withDetail = await ProblemAsync(app, "/login/bob");
+        withDetail["detail"]!.GetValue<string>().ShouldBe("Try again in a minute.");
+        withDetail.ContainsKey("fault").ShouldBeFalse();
+
+        (await ProblemAsync(app, "/login/carol"))["fault"]!.GetValue<string>().ShouldBe("Locked");
+    }
+
+    [Fact]
+    public async Task The_host_still_sees_the_fault_and_that_its_name_is_withheld()
+    {
+        var seen = new List<(string Name, bool Withheld, string? Rule)>();
+        await using var app = await StartAsync(services => services.AddProblemDetails(options => options.CustomizeProblemDetails = context =>
+        {
+            if (context.HttpContext.Features.Get<IFaultFeature>() is { } feature) seen.Add((feature.Name, feature.NameWithheld, feature.Rule));
+        }));
+
+        await ProblemAsync(app, "/login/ann");
+        await ProblemAsync(app, "/login/carol");
+
+        seen.ShouldBe([("WrongPassword", true, "WithheldFaultNameTests.PasswordRule.Expired"), ("Locked", false, null)]);
+    }
+
+    [Fact]
+    public async Task The_document_says_a_status_whose_every_fault_is_withheld_names_none()
+    {
+        await using var app = await StartAsync(endpoints: app =>
+            app.MapPost("/admin/login/{user}", (string user) => SignIn(user).ToHttpResult()).WithFaultStatus(SignInFault.Locked, StatusCodes.Status401Unauthorized));
+
+        var paths = (await DocumentAsync(app))["paths"]!;
+
+        Description(paths, "/login/{user}", "401").ShouldBe("Unauthorized. Problem types: https://problems.example/sign-in. The problem names no fault.");
+        Description(paths, "/login/{user}", "403").ShouldBe("Forbidden");
+        Description(paths, "/admin/login/{user}", "401").ShouldBe("Unauthorized. Problem types: https://problems.example/sign-in", "Locked shares the status and names itself");
+    }
+
+    /// <summary>A fault set member's description stands in for a missing detail, and names the member: withheld, it goes too.</summary>
+    [Fact]
+    public async Task A_whole_fault_set_withheld_writes_no_member_description()
+    {
+        await using var app = await StartAsync(
+            services => services.AddFaultResponses<ProbeOrderFault>(fault => FaultResponse.For(fault.Kind).WithoutFaultName()),
+            app => app.MapGet("/orders/{id:int}", (int id) => Archive(id).ToHttpResult()));
+
+        var described = await ProblemAsync(app, "/orders/1");
+        described.ContainsKey("detail").ShouldBeFalse(described.ToJsonString());
+        described.ContainsKey("fault").ShouldBeFalse();
+
+        (await ProblemAsync(app, "/orders/2"))["detail"]!.GetValue<string>().ShouldBe("Order 2 was archived.");
+    }
+
+    [Fact]
+    public void Withholding_the_name_survives_a_type_and_a_title_in_either_order()
+    {
+        FaultResponse.Status(401).NamesFault.ShouldBeTrue();
+        FaultResponse.Status(401).WithoutFaultName().WithType(new Uri("https://problems.example/a")).WithTitle("Refused").NamesFault.ShouldBeFalse();
+
+        var response = FaultResponse.Status(401).WithType(new Uri("https://problems.example/a")).WithTitle("Refused").WithoutFaultName();
+        response.NamesFault.ShouldBeFalse();
+        response.Type.ShouldBe(new Uri("https://problems.example/a"));
+        response.Title.ShouldBe("Refused");
+        response.StatusCode.ShouldBe(401);
+    }
+
+    private static async Task<WebApplication> StartAsync(Action<IServiceCollection>? services = null, Action<WebApplication>? endpoints = null)
+    {
+        var builder = WebApplication.CreateBuilder(new WebApplicationOptions { EnvironmentName = Environments.Production });
+        builder.WebHost.UseTestServer();
+        builder.Logging.ClearProviders();
+        builder.Services.AddOpenApi(options => options.AddTypeKit());
+        builder.Services.AddFaultResponses<SignInFault>(Mapping);
+        services?.Invoke(builder.Services);
+
+        var app = builder.Build();
+        app.MapOpenApi();
+        app.MapPost("/login/{user}", (string user) => SignIn(user).ToHttpResult());
+        endpoints?.Invoke(app);
+
+        try
+        {
+            await app.StartAsync(TestContext.Current.CancellationToken);
+        }
+        catch
+        {
+            await app.DisposeAsync();
+            throw;
+        }
+
+        return app;
+    }
+
+    private static async Task<JsonObject> ProblemAsync(WebApplication app, string path)
+    {
+        var method = path.StartsWith("/login", StringComparison.Ordinal) ? HttpMethod.Post : HttpMethod.Get;
+        using var response = await app.GetTestClient().SendAsync(new HttpRequestMessage(method, path), TestContext.Current.CancellationToken);
+
+        response.Content.Headers.ContentType!.MediaType.ShouldBe("application/problem+json");
+        var body = JsonNode.Parse(await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken))!.AsObject();
+        body.Remove("traceId");
+        return body;
+    }
+
+    private static async Task<JsonNode> DocumentAsync(WebApplication app) =>
+        JsonNode.Parse(await app.GetTestClient().GetStringAsync("/openapi/v1.json", TestContext.Current.CancellationToken))!;
+
+    private static string Description(JsonNode paths, string path, string status) =>
+        paths[path]!["post"]?["responses"]?[status]?["description"]?.GetValue<string>()
+     ?? paths[path]!["get"]!["responses"]![status]!["description"]!.GetValue<string>();
+}
diff --git a/test/CodoMetis.TypeKit.CiLanes.Tests/CodoMetis.TypeKit.CiLanes.Tests.csproj b/test/CodoMetis.TypeKit.CiLanes.Tests/CodoMetis.TypeKit.CiLanes.Tests.csproj
new file mode 100644
index 00000000..c978265a
--- /dev/null
+++ b/test/CodoMetis.TypeKit.CiLanes.Tests/CodoMetis.TypeKit.CiLanes.Tests.csproj
@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <!--
+      Runs the built ci-lanes.dll as a process, from a throwaway repository that holds its sources and its
+      output (ToolSandbox.cs). The reference only orders the build; ToolOutput says where the output is.
+    -->
+    <ItemGroup>
+        <ProjectReference Include="../../tools/CiLanes/CiLanes.csproj" ReferenceOutputAssembly="false" />
+        <AssemblyAttribute Include="System.Reflection.AssemblyMetadataAttribute">
+            <_Parameter1>ToolOutput</_Parameter1>
+            <_Parameter2>$([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)../../tools/CiLanes/bin/$(Configuration)/$(TargetFramework)/'))</_Parameter2>
+        </AssemblyAttribute>
+    </ItemGroup>
+
+    <ItemGroup>
+        <Compile Include="../CodoMetis.TypeKit.BuildVerdict.Tests/ToolSandbox.cs" Link="ToolSandbox.cs" />
+    </ItemGroup>
+</Project>
diff --git a/test/CodoMetis.TypeKit.CiLanes.Tests/GateTests.cs b/test/CodoMetis.TypeKit.CiLanes.Tests/GateTests.cs
new file mode 100644
index 00000000..d7886970
--- /dev/null
+++ b/test/CodoMetis.TypeKit.CiLanes.Tests/GateTests.cs
@@ -0,0 +1,171 @@
+using System.Text.Json;
+
+namespace CodoMetis.TypeKit.CiLanes.Tests;
+
+/// <summary>
+/// The gate's verdict on a run, from the <c>toJSON(needs)</c> the CI job writes. Each failing case starts from a
+/// run that passes and breaks one thing: a failed selection, a cancelled leg, an answer the selection does not
+/// write, a selected job that was skipped, and a skipped job that ran (#71, design/adr/0113).
+/// </summary>
+public sealed class GateTests : IDisposable
+{
+    private const string LinuxOnly = """["ubuntu-latest"]""";
+    private const string LinuxAndWindows = """["ubuntu-latest","windows-latest"]""";
+    private const string EveryLeg = """["ubuntu-latest","windows-latest","macos-latest"]""";
+
+    private readonly ToolSandbox _tool = new("CiLanes", "ci-lanes");
+
+    public void Dispose() => _tool.Dispose();
+
+    private sealed record Run(
+        string Changes = "success",
+        string? Legs = LinuxOnly,
+        string? Pack = "false",
+        string? Suite = "prose",
+        string Test = "success",
+        string PackJob = "skipped",
+        string Consumer = "skipped");
+
+    private static readonly Run Prose = new();
+
+    private static readonly Run Package = new(Pack: "true", Suite: "full", PackJob: "success", Consumer: "success");
+
+    private static readonly Run Full = Package with { Legs = EveryLeg };
+
+    private (int Code, string Output) Judge(Run run, Action<Dictionary<string, object>>? edit = null)
+    {
+        var outputs = new Dictionary<string, string>();
+        if (run.Legs is not null) outputs["legs"] = run.Legs;
+        if (run.Pack is not null) outputs["pack"] = run.Pack;
+        if (run.Suite is not null) outputs["suite"] = run.Suite;
+
+        var needs = new Dictionary<string, object>
+        {
+            ["changes"] = new { result = run.Changes, outputs },
+            ["test"] = new { result = run.Test, outputs = new { } },
+            ["pack"] = new { result = run.PackJob, outputs = new { } },
+            ["consumer"] = new { result = run.Consumer, outputs = new { } },
+        };
+        edit?.Invoke(needs);
+
+        var file = Path.Combine(_tool.Work, $"{Guid.NewGuid():N}.json");
+        File.WriteAllText(file, JsonSerializer.Serialize(needs));
+        var (code, output, _) = _tool.Run(arguments: ["gate", file]);
+        return (code, output);
+    }
+
+    private void Passes(Run run)
+    {
+        var (code, output) = Judge(run);
+        code.ShouldBe(0, output);
+        output.ShouldNotContain("::error::");
+    }
+
+    private void Fails(Run run, string problem, Action<Dictionary<string, object>>? edit = null)
+    {
+        var (code, output) = Judge(run, edit);
+        code.ShouldBe(1, output);
+        output.ShouldContain($"::error::{problem}");
+    }
+
+    [Fact]
+    public void A_prose_run_passes_with_the_pack_skipped() => Passes(Prose);
+
+    [Fact]
+    public void A_package_run_passes_with_the_pack_run() => Passes(Package);
+
+    [Fact]
+    public void An_analyzer_run_passes_with_Windows_and_the_pack() => Passes(Package with { Legs = LinuxAndWindows });
+
+    [Fact]
+    public void A_test_run_passes_with_Windows_and_no_pack() => Passes(Prose with { Legs = LinuxAndWindows, Suite = "full" });
+
+    [Theory]
+    [InlineData("Prose")]
+    [InlineData("all")]
+    [InlineData("")]
+    public void A_suite_answer_the_selection_does_not_write_fails(string suite) =>
+        Fails(Prose with { Suite = suite }, $"The changes job's suite output is '{suite}'");
+
+    [Fact]
+    public void The_prose_suite_beside_another_leg_fails() =>
+        Fails(Prose with { Legs = LinuxAndWindows }, "The changes job chose the prose suite for a run with more than the Linux leg");
+
+    [Fact]
+    public void The_prose_suite_beside_the_pack_fails() =>
+        Fails(Package with { Suite = "prose" }, "The changes job chose the prose suite for a run with more than the Linux leg");
+
+    [Fact]
+    public void A_run_that_is_not_selected_passes_with_every_leg() => Passes(Full);
+
+    [Theory]
+    [InlineData("failure")]
+    [InlineData("cancelled")]
+    [InlineData("skipped")]
+    public void A_selection_that_did_not_succeed_fails(string result) =>
+        Fails(Prose with { Changes = result, Legs = null, Pack = null, Suite = null }, $"The changes job ended '{result}'");
+
+    [Theory]
+    [InlineData("cancelled")]
+    [InlineData("failure")]
+    [InlineData("skipped")]
+    public void A_test_matrix_that_did_not_succeed_fails(string result) =>
+        Fails(Package with { Test = result }, $"The job 'test' was selected and ended '{result}'.");
+
+    [Fact]
+    public void A_selected_pack_that_was_skipped_fails() =>
+        Fails(Package with { PackJob = "skipped" }, "The job 'pack' was selected and ended 'skipped'.");
+
+    [Fact]
+    public void A_cancelled_consumer_fails() =>
+        Fails(Package with { Consumer = "cancelled" }, "The job 'consumer' was selected and ended 'cancelled'.");
+
+    [Fact]
+    public void An_unselected_job_that_ran_fails() =>
+        Fails(Prose with { Consumer = "success" }, "The job 'consumer' was not selected and ended 'success', not skipped");
+
+    [Theory]
+    [InlineData("True")]
+    [InlineData("yes")]
+    [InlineData("")]
+    public void A_pack_answer_the_selection_does_not_write_fails(string pack) =>
+        Fails(Prose with { Pack = pack }, $"The changes job's pack output is '{pack}'");
+
+    [Fact]
+    public void A_missing_answer_fails() => Fails(Prose with { Pack = null }, "The changes job's pack output is missing");
+
+    [Theory]
+    [InlineData("""["ubuntu-latest","macos-latest"]""")]
+    [InlineData("""["windows-latest","ubuntu-latest"]""")]
+    [InlineData("""["ubuntu"]""")]
+    [InlineData("ubuntu-latest")]
+    [InlineData("[]")]
+    public void A_matrix_the_selection_does_not_write_fails(string legs) =>
+        Fails(Prose with { Legs = legs }, "The changes job's legs output is");
+
+    [Fact]
+    public void A_job_the_gate_does_not_know_fails() =>
+        Fails(Prose, "The gate does not know the job 'docs'", needs => needs["docs"] = new { result = "success", outputs = new { } });
+
+    [Fact]
+    public void A_job_the_gate_does_not_need_fails() =>
+        Fails(Prose, "The gate does not need the job 'consumer'", needs => needs.Remove("consumer"));
+
+    [Fact]
+    public void The_summary_tables_each_job()
+    {
+        var file = Path.Combine(_tool.Work, "needs.json");
+        File.WriteAllText(file, JsonSerializer.Serialize(new Dictionary<string, object>
+        {
+            ["changes"] = new { result = "success", outputs = new { legs = LinuxOnly, pack = "false", suite = "prose" } },
+            ["test"] = new { result = "success" },
+            ["pack"] = new { result = "skipped" },
+            ["consumer"] = new { result = "skipped" },
+        }));
+        var summary = Path.Combine(_tool.Work, "summary.md");
+
+        _tool.Run(arguments: ["gate", file, "--summary", summary]).Code.ShouldBe(0);
+
+        File.ReadAllText(summary).ShouldContain("| pack | no | skipped |");
+    }
+}
diff --git a/test/CodoMetis.TypeKit.CiLanes.Tests/SelectionTests.cs b/test/CodoMetis.TypeKit.CiLanes.Tests/SelectionTests.cs
new file mode 100644
index 00000000..8ecf0cad
--- /dev/null
+++ b/test/CodoMetis.TypeKit.CiLanes.Tests/SelectionTests.cs
@@ -0,0 +1,263 @@
+namespace CodoMetis.TypeKit.CiLanes.Tests;
+
+/// <summary>
+/// The lanes a run gets, from the event and the paths it changes. Each case runs the built tool as its own process
+/// against a throwaway git repository, the way the changes job runs it against the checkout, and reads the answers
+/// it writes to the step's output file (design/adr/0113).
+/// </summary>
+public sealed class SelectionTests : IDisposable
+{
+    private const string LinuxOnly = """legs=["ubuntu-latest"]""";
+    private const string LinuxAndWindows = """legs=["ubuntu-latest","windows-latest"]""";
+    private const string EveryLeg = """legs=["ubuntu-latest","windows-latest","macos-latest"]""";
+
+    private readonly ToolSandbox _tool = new("CiLanes", "ci-lanes");
+
+    public SelectionTests()
+    {
+        Write("src/CodoMetis.TypeKit/Option.cs", "// a package's source\n");
+        Write("src/CodoMetis.TypeKit.Analyzers/CodeFixes/AddCreate.cs", "// a code fix's source\n");
+        Write("docs/guide.md", "# A guide\n");
+        Git("init", "-q", "-b", "release/9.9.0");
+        Git("add", "-A");
+        Git("commit", "-q", "-m", "base");
+        Git("update-ref", "refs/remotes/origin/release/9.9.0", "HEAD");
+        Git("update-ref", "refs/remotes/origin/main", "HEAD");
+    }
+
+    public void Dispose() => _tool.Dispose();
+
+    public static TheoryData<string, string, string> Paths => new()
+    {
+        { "docs/guide.md", "prose", "linux" },
+        { "design/adr/0113-ci-runs-the-lanes-a-change-can-affect.md", "prose", "linux" },
+        { "README.md", "prose", "linux" },
+        { "test/oracles/README.md", "prose", "linux" },
+        { ".github/ISSUE_TEMPLATE/bug.yml", "prose", "linux" },
+        { "site/docfx.json", "prose", "linux" },
+        { "site/toc.yml", "prose", "linux" },
+        { "site/template/conceptual.extension.js", "prose", "linux" },
+        { "CHANGELOG.md", "changelog", "linux, pack" },
+        { "src/CodoMetis.TypeKit.Analyzers/CodeFixes/AddCreateCodeFix.cs", "source text", "linux, windows, pack" },
+        { "src/CodoMetis.TypeKit.Analyzers/AnalyzerReleases.Unshipped.md", "source text", "linux, windows, pack" },
+        { "src/CodoMetis.TypeKit.Generators/README.md", "source text", "linux, windows, pack" },
+        { "src/CodoMetis.TypeKit/README.md", "package", "linux, pack" },
+        { "src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectConverter.cs", "package", "linux, pack" },
+        { "src/CodoMetis.TypeKit.AnalyzersAndMore/X.cs", "package", "linux, pack" },
+        { "src/Directory.Build.targets", "package", "linux, pack" },
+        { "tools/ConsumerSmokeTest/Consumers/Aot/Program.cs", "smoke test", "linux, windows, pack" },
+        { "tools/ConsumerSmokeTest/README.md", "smoke test", "linux, windows, pack" },
+        { "tools/Shared/SharedFile.cs", "smoke test", "linux, windows, pack" },
+        { "tools/Directory.Build.props", "smoke test", "linux, windows, pack" },
+        { "tools/CiLanes/Program.cs", "smoke test", "linux, windows, pack" },
+        { "tools/PrHygiene/Program.cs", "code no package reads", "linux, windows" },
+        { "test/CodoMetis.TypeKit.Tests/OptionTests.cs", "code no package reads", "linux, windows" },
+        { "test/Directory.Build.props", "code no package reads", "linux, windows" },
+        { "spikes/FabricSpike/Program.cs", "code no package reads", "linux, windows" },
+        { "global.json", "unlisted", "linux, windows, pack" },
+        { "Directory.Build.props", "unlisted", "linux, windows, pack" },
+        { "Directory.Packages.props", "unlisted", "linux, windows, pack" },
+        { ".config/dotnet-tools.json", "unlisted", "linux, windows, pack" },
+        { ".github/workflows/dotnet.yml", "unlisted", "linux, windows, pack" },
+        { ".github/workflows/docs.yml", "unlisted", "linux, windows, pack" },
+        { "benchmarks/CodoMetis.TypeKit.Benchmarks/Program.cs", "unlisted", "linux, windows, pack" },
+        { "a-file-nobody-listed", "unlisted", "linux, windows, pack" },
+    };
+
+    [Theory, MemberData(nameof(Paths))]
+    public void A_path_selects_the_lanes_of_its_class(string path, string @class, string lanes)
+    {
+        var (code, output, _) = _tool.Run(arguments: ["classify", path]);
+
+        code.ShouldBe(0, output);
+        output.ShouldBe($"{path}\t{@class}\t{lanes}\n");
+    }
+
+    [Fact]
+    public void A_prose_change_runs_the_Linux_leg_alone()
+    {
+        Commit("docs/guide.md", "# A guide, reworded\n");
+
+        Answers(PullRequestInto("release/9.9.0")).ShouldBe([LinuxOnly, "pack=false", "suite=prose"]);
+    }
+
+    /// <summary>The prose suite runs only for a change that is prose throughout.</summary>
+    [Fact]
+    public void Prose_beside_any_other_change_runs_the_whole_suite()
+    {
+        Commit("docs/guide.md", "# A guide, reworded\n");
+        Commit("test/CodoMetis.TypeKit.Tests/OptionTests.cs", "// a test\n");
+
+        Answers(PullRequestInto("release/9.9.0")).ShouldBe([LinuxAndWindows, "pack=false", "suite=full"]);
+    }
+
+    [Fact]
+    public void A_changelog_change_runs_the_whole_suite()
+    {
+        Commit("CHANGELOG.md", "## 9.9.0\n");
+
+        Answers(PullRequestInto("release/9.9.0")).ShouldBe([LinuxOnly, "pack=true", "suite=full"]);
+    }
+
+    [Fact]
+    public void A_package_change_runs_Linux_and_the_pack()
+    {
+        Commit("docs/guide.md", "# A guide, reworded\n");
+        Commit("src/CodoMetis.TypeKit/Option.cs", "// changed\n");
+
+        Answers(PullRequestInto("release/9.9.0")).ShouldBe([LinuxOnly, "pack=true", "suite=full"]);
+    }
+
+    /// <summary>The one src/ defect a Windows leg alone caught in 150 runs was a code fix's line endings (f9f64e5).</summary>
+    [Fact]
+    public void An_analyzer_change_adds_the_Windows_leg()
+    {
+        Commit("src/CodoMetis.TypeKit/Option.cs", "// changed\n");
+        Commit("src/CodoMetis.TypeKit.Analyzers/CodeFixes/AddCreate.cs", "// changed\n");
+
+        Answers(PullRequestInto("release/9.9.0")).ShouldBe([LinuxAndWindows, "pack=true", "suite=full"]);
+    }
+
+    [Fact]
+    public void A_test_change_runs_Linux_and_Windows_without_the_pack()
+    {
+        Commit("test/CodoMetis.TypeKit.Tests/OptionTests.cs", "// a test\n");
+
+        Answers(PullRequestInto("release/9.9.0")).ShouldBe([LinuxAndWindows, "pack=false", "suite=full"]);
+    }
+
+    /// <summary>A selection never runs macOS: a path no class names gets every lane but that one.</summary>
+    [Fact]
+    public void An_unlisted_change_runs_every_lane_but_macOS()
+    {
+        Commit("global.json", "{}\n");
+
+        Answers(PullRequestInto("release/9.9.0")).ShouldBe([LinuxAndWindows, "pack=true", "suite=full"]);
+    }
+
+    /// <summary>Without <c>--no-renames</c>, git lists a rename's new path alone, and a move out of src/ reads as prose (#70).</summary>
+    [Fact]
+    public void A_move_out_of_a_package_counts_its_old_path()
+    {
+        Git("mv", "src/CodoMetis.TypeKit/Option.cs", "docs/Option.cs.md");
+        Git("commit", "-q", "-m", "move");
+
+        Answers(PullRequestInto("release/9.9.0")).ShouldBe([LinuxOnly, "pack=true", "suite=full"]);
+    }
+
+    [Fact]
+    public void The_release_pull_request_into_main_runs_every_lane()
+    {
+        Commit("docs/guide.md", "# A guide, reworded\n");
+
+        Answers(PullRequestInto("main")).ShouldBe([EveryLeg, "pack=true", "suite=full"]);
+    }
+
+    [Fact]
+    public void A_push_to_a_release_branch_is_selected_by_what_it_replaced()
+    {
+        var before = Git("rev-parse", "HEAD").Trim();
+        Commit("docs/guide.md", "# A guide, reworded\n");
+
+        Answers("--event", "push", "--ref", "refs/heads/release/9.9.0", "--before", before).ShouldBe([LinuxOnly, "pack=false", "suite=prose"]);
+    }
+
+    [Theory]
+    [InlineData("0000000000000000000000000000000000000000")]
+    [InlineData("1234567890abcdef1234567890abcdef12345678")]
+    [InlineData("")]
+    public void A_push_without_a_commit_to_diff_against_runs_every_lane(string before)
+    {
+        Commit("docs/guide.md", "# A guide, reworded\n");
+
+        Answers("--event", "push", "--ref", "refs/heads/release/9.9.0", "--before", before).ShouldBe([EveryLeg, "pack=true", "suite=full"]);
+    }
+
+    [Theory]
+    [InlineData("push", "refs/heads/main")]
+    [InlineData("push", "refs/tags/v9.9.0")]
+    [InlineData("workflow_dispatch", "refs/heads/release/9.9.0")]
+    [InlineData("schedule", "refs/heads/main")]
+    public void Every_other_run_gets_every_lane(string @event, string @ref)
+    {
+        Commit("docs/guide.md", "# A guide, reworded\n");
+
+        Answers("--event", @event, "--ref", @ref, "--before", Git("rev-parse", "HEAD~1").Trim()).ShouldBe([EveryLeg, "pack=true", "suite=full"]);
+    }
+
+    [Fact]
+    public void A_diff_that_names_no_path_runs_every_lane() =>
+        Answers(PullRequestInto("release/9.9.0")).ShouldBe([EveryLeg, "pack=true", "suite=full"]);
+
+    /// <summary>A diff that cannot be taken fails the job, never answers "nothing changed" (#70).</summary>
+    [Fact]
+    public void A_diff_that_fails_fails_the_selection()
+    {
+        var output = Path.Combine(_tool.Work, "output");
+
+        var (code, text, _) = _tool.Run(arguments: ["select", .. PullRequestInto("release/9.9.1"), "--output", output]);
+
+        code.ShouldBe(1, text);
+        text.ShouldContain("::error::git diff origin/release/9.9.1...HEAD failed");
+        File.Exists(output).ShouldBeFalse("a failed selection writes no answer");
+    }
+
+    [Fact]
+    public void The_summary_names_each_path_and_its_class()
+    {
+        Commit("CHANGELOG.md", "## 9.9.0\n");
+        var summary = Path.Combine(_tool.Work, "summary.md");
+
+        _tool.Run(arguments: ["select", .. PullRequestInto("release/9.9.0"), "--summary", summary]).Code.ShouldBe(0);
+
+        File.ReadAllText(summary).ShouldContain("| `CHANGELOG.md` | changelog | linux, pack |");
+    }
+
+    [Theory]
+    [InlineData]
+    [InlineData("select")]
+    [InlineData("select", "--event", "push")]
+    [InlineData("select", "--event", "push", "--ref", "refs/heads/main", "--colour", "red")]
+    [InlineData("classify")]
+    [InlineData("gate")]
+    [InlineData("lanes")]
+    public void A_usage_error_is_exit_2(params string[] arguments) =>
+        _tool.Run(arguments: arguments).Code.ShouldBe(2);
+
+    private static string[] PullRequestInto(string target) => ["--event", "pull_request", "--ref", "refs/pull/1/merge", "--base", target];
+
+    private string[] Answers(params string[] options)
+    {
+        var output = Path.Combine(_tool.Work, $"{Guid.NewGuid():N}.output");
+        var (code, text, _) = _tool.Run(arguments: ["select", .. options, "--output", output]);
+
+        code.ShouldBe(0, text);
+        return File.ReadAllLines(output);
+    }
+
+    private void Commit(string path, string content)
+    {
+        Write(path, content);
+        Git("add", "-A");
+        Git("commit", "-q", "-m", $"change {path}");
+    }
+
+    private void Write(string path, string content)
+    {
+        var file = Path.Combine(_tool.Repo, path);
+        Directory.CreateDirectory(Path.GetDirectoryName(file)!);
+        File.WriteAllText(file, content);
+    }
+
+    // git in the sandbox's repository, with no configuration of the machine's: its user, signing and hooks stay out.
+    private string Git(params string[] arguments)
+    {
+        var empty = Path.Combine(_tool.Work, "gitconfig");
+        File.WriteAllText(empty, "");
+        var (code, output, error) = ToolSandbox.RunProcess("git", ["-c", "user.name=CI Lanes", "-c", "user.email=ci@example.invalid", "-c", "commit.gpgsign=false", .. arguments],
+            _tool.Repo, new Dictionary<string, string?> { ["GIT_CONFIG_GLOBAL"] = empty, ["GIT_CONFIG_NOSYSTEM"] = "1" });
+
+        code.ShouldBe(0, $"git {string.Join(' ', arguments)}: {error}");
+        return output;
+    }
+}
diff --git a/test/CodoMetis.TypeKit.CiLanes.Tests/StaleToolTests.cs b/test/CodoMetis.TypeKit.CiLanes.Tests/StaleToolTests.cs
new file mode 100644
index 00000000..2c563896
--- /dev/null
+++ b/test/CodoMetis.TypeKit.CiLanes.Tests/StaleToolTests.cs
@@ -0,0 +1,30 @@
+namespace CodoMetis.TypeKit.CiLanes.Tests;
+
+/// <summary>
+/// A selection built from other sources than the checkout holds says so and selects nothing: exit 3, the
+/// difference, and the command that rebuilds it. A stale selection would skip or run lanes by rules
+/// nobody can read in the checkout.
+/// </summary>
+public sealed class StaleToolTests
+{
+    [Fact]
+    public void A_tool_built_from_its_sources_runs()
+    {
+        using var sandbox = new ToolSandbox("CiLanes", "ci-lanes");
+
+        sandbox.Run().Code.ShouldBe(2, "a usage error, so the tool ran");
+    }
+
+    [Fact]
+    public void A_changed_source_stops_it()
+    {
+        using var sandbox = new ToolSandbox("CiLanes", "ci-lanes");
+        File.AppendAllText(Path.Combine(sandbox.Repo, "tools", "CiLanes", "Program.cs"), "\n// edited\n");
+
+        var (code, output, _) = sandbox.Run();
+
+        code.ShouldBe(3);
+        output.ShouldStartWith("TOOL STALE: tools/CiLanes was built from other sources than the checkout holds (tools/CiLanes/Program.cs differs)");
+        output.ShouldContain("rebuild it: dotnet build tools/CiLanes -c ");
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/ChangelogTests.cs b/test/CodoMetis.TypeKit.Conventions.Tests/ChangelogTests.cs
index e293252c..de586664 100644
--- a/test/CodoMetis.TypeKit.Conventions.Tests/ChangelogTests.cs
+++ b/test/CodoMetis.TypeKit.Conventions.Tests/ChangelogTests.cs
@@ -51,6 +51,26 @@ public void A_released_version_has_shipped_its_analyzer_rules()
             $"CHANGELOG.md dates {Version} as released, but AnalyzerReleases.Shipped.md has no '## Release {Version}'.");
     }
 
+    /// <summary>
+    /// A dated section is its packages' release notes on nuget.org and its GitHub release's notes, both
+    /// frozen with the version, so it links the repository at its own tag. A link at <c>main</c> opens
+    /// that day's page, where the section may say something else or the anchor may be gone (#76). A
+    /// page written after the tag, such as the 2.1 migration guide, is linked at a full commit id,
+    /// which is as frozen. The <c>Unreleased</c> section has no tag yet and links <c>main</c>.
+    /// </summary>
+    [Fact]
+    public void A_released_version_links_the_repository_at_its_tag()
+    {
+        var links = DatedSections().SelectMany(section => RepositoryLink().Matches(section.Text)
+                                       .Select(link => (section.Version, Ref: link.Groups["ref"].Value, Link: link.Value)))
+                                   .ToList();
+
+        links.Count.ShouldBeGreaterThanOrEqualTo(30, "Too few links read from the dated sections: the reader no longer finds them.");
+        links.Where(link => link.Ref != $"v{link.Version}" && !CommitId().IsMatch(link.Ref))
+             .Select(link => $"{link.Version}: {link.Link}")
+             .ShouldBeEmpty("These links in a released version's section don't name its tag. Write blob/v<version>/ in place of blob/main/ when you date the section (CONTRIBUTING.md, Releasing).");
+    }
+
     /// <summary>
     /// Package validation compares every pack with the baseline, so ApiCompat refuses a break of the
     /// public surface. A baseline left behind at an older release, or dropped, lets a break of the last
@@ -82,9 +102,27 @@ public void The_package_validation_baseline_is_the_last_release()
     private static Dictionary<string, string> Sections() =>
         VersionHeading().Matches(Changelog).ToDictionary(match => match.Groups["version"].Value, match => match.Groups["date"].Value);
 
+    /// <summary>Each dated version's section: its heading and everything up to the next one.</summary>
+    private static IEnumerable<(string Version, string Text)> DatedSections()
+    {
+        var headings = VersionHeading().Matches(Changelog);
+
+        return headings.Select((heading, index) =>
+                           (heading, end: index + 1 < headings.Count ? headings[index + 1].Index : Changelog.Length))
+                       .Where(section => section.heading.Groups["date"].Value != "Unreleased")
+                       .Select(section => (section.heading.Groups["version"].Value,
+                                           Changelog[section.heading.Index..section.end]));
+    }
+
     [GeneratedRegex(@"(?m)^## (?<version>\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?) — (?<date>Unreleased|\d{4}-\d{2}-\d{2})\s*$")]
     private static partial Regex VersionHeading();
 
+    [GeneratedRegex(@"https://github\.com/CaffeinatedCoder/CodoMetis\.TypeKit/(?:blob|tree)/(?<ref>[^/\s)]+)/[^\s)]*")]
+    private static partial Regex RepositoryLink();
+
+    [GeneratedRegex(@"^[0-9a-f]{40}$")]
+    private static partial Regex CommitId();
+
     [GeneratedRegex(@"^CMTK\d{4}\s*\|")]
     private static partial Regex RuleRow();
 }
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/CiLaneTests.cs b/test/CodoMetis.TypeKit.Conventions.Tests/CiLaneTests.cs
new file mode 100644
index 00000000..0fe055d0
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Conventions.Tests/CiLaneTests.cs
@@ -0,0 +1,140 @@
+using System.Diagnostics;
+using System.Reflection;
+using System.Text.Json;
+
+namespace CodoMetis.TypeKit.Conventions.Tests;
+
+/// <summary>
+/// The selection of <c>tools/CiLanes</c> never lets a change to a package skip the pack: every file MSBuild evaluates
+/// for a shipping project or the consumer smoke test, items and imports both, is classified into a class that
+/// selects the <c>pack</c> lane (design/adr/0113, #70).
+/// </summary>
+/// <remarks>
+/// Read from MSBuild's evaluation, not from a list: before decision 113 the changes job listed its paths by hand,
+/// and missed <c>tools/Shared/*.cs</c>, which <c>tools/Directory.Build.props</c> compiles into the smoke test. The
+/// imports are read from the preprocessed project (<c>-pp</c>), since <c>MSBuildAllProjects</c> lists only the
+/// files that append themselves to it. A file a target reads by a property function is in no evaluation: the one
+/// such file, the changelog the release notes come from, is held by name.
+/// </remarks>
+public sealed class CiLaneTests
+{
+    /// <summary>The shipping projects, with the ones they reference, and the smoke test, which packs them.</summary>
+    public static TheoryData<string> Projects =>
+    [
+        .. Repository.ShippingProjects().Select(project => $"src/{project}/{project}.csproj"),
+        "tools/ConsumerSmokeTest/ConsumerSmokeTest.csproj",
+    ];
+
+    [Theory, MemberData(nameof(Projects))]
+    public async Task Every_file_a_package_or_the_smoke_test_reads_selects_the_pack(string project)
+    {
+        var inputs = new SortedSet<string>(StringComparer.Ordinal);
+        var pending = new Queue<string>([Path.GetFullPath(Path.Combine(Repository.Root, project))]);
+        var seen = new HashSet<string>(StringComparer.Ordinal);
+
+        while (pending.TryDequeue(out var path))
+        {
+            if (!seen.Add(path)) continue;
+            inputs.Add(path);
+
+            foreach (var import in await Imports(path)) inputs.Add(import);
+            foreach (var (item, full) in await Items(path))
+            {
+                inputs.Add(full);
+                if (item == "ProjectReference") pending.Enqueue(full);
+            }
+        }
+
+        var relative = inputs.Where(InRepository).Select(path => Path.GetRelativePath(Repository.Root, path).Replace('\\', '/')).ToList();
+        relative.ShouldContain(path => path.StartsWith("tools/Directory.Build.props", StringComparison.Ordinal) || path.StartsWith("src/", StringComparison.Ordinal),
+            "the evaluation found none of the project's own inputs, so the discovery is broken");
+
+        var unpacked = Classify(relative).Where(row => !row.Lanes.Contains("pack", StringComparer.Ordinal)).ToList();
+
+        unpacked.ShouldBeEmpty(
+            $"{project} reads these files, and a pull request changing one alone would skip the pack: " +
+            string.Join(", ", unpacked.Select(row => $"{row.Path} ({row.Class})")) +
+            ". Give them a class that selects pack in tools/CiLanes (decision 113).");
+    }
+
+    /// <summary>
+    /// src/Directory.Build.targets reads the changelog into the release notes with a property function inside a
+    /// target, which no evaluation lists (#75). Held by name, beside the evidence that the target still reads it.
+    /// </summary>
+    [Fact]
+    public void The_changelog_the_release_notes_come_from_selects_the_pack()
+    {
+        File.ReadAllText(Path.Combine(Repository.Root, "src", "Directory.Build.targets"))
+            .ShouldContain("'CodoMetis.TypeKit.slnx'))/CHANGELOG.md", Case.Sensitive,
+                "src/Directory.Build.targets no longer reads CHANGELOG.md at the root; find what it reads and hold that here");
+
+        Classify(["CHANGELOG.md"]).Single().Lanes.ShouldContain("pack");
+    }
+
+    private static bool InRepository(string path) =>
+        path.StartsWith(Repository.Root + Path.DirectorySeparatorChar, StringComparison.Ordinal)
+        && !Path.GetRelativePath(Repository.Root, path).Split(Path.DirectorySeparatorChar).Any(part => part is "bin" or "obj");
+
+    private static List<(string Path, string Class, string[] Lanes)> Classify(IReadOnlyList<string> paths)
+    {
+        var output = typeof(CiLaneTests).Assembly.GetCustomAttributes<AssemblyMetadataAttribute>().Single(a => a.Key == "CiLanesOutput").Value!;
+        var (code, text) = Run(Path.Combine(output, "ci-lanes.dll"), ["classify", .. paths]);
+
+        code.ShouldBe(0, text);
+        return
+        [
+            .. text.Split('\n', StringSplitOptions.RemoveEmptyEntries)
+                   .Select(line => line.Split('\t'))
+                   .Select(parts => (parts[0], parts[1], parts[2].Split(", ")))
+        ];
+    }
+
+    // The project and every file it imports, from the preprocessed project: each import is named there by its full path, on a line of its own.
+    private static async Task<IEnumerable<string>> Imports(string project)
+    {
+        var file = Path.Combine(Path.GetTempPath(), $"cilanes-{Guid.NewGuid():N}.xml");
+        try
+        {
+            var (code, text) = await RunAsync(["msbuild", project, $"-pp:{file}", "-nodeReuse:false"]);
+            code.ShouldBe(0, $"dotnet msbuild -pp {project} failed: {text}");
+            return [.. File.ReadAllLines(file).Select(line => line.Trim()).Where(line => Path.IsPathFullyQualified(line) && File.Exists(line))];
+        }
+        finally
+        {
+            File.Delete(file);
+        }
+    }
+
+    // Every item that names a file: what is compiled, embedded, packed or analysed, and the projects referenced.
+    private static async Task<IEnumerable<(string Item, string FullPath)>> Items(string project)
+    {
+        string[] kinds = ["Compile", "None", "Content", "EmbeddedResource", "AdditionalFiles", "ProjectReference"];
+        var (code, text) = await RunAsync(["msbuild", project, .. kinds.Select(kind => $"-getItem:{kind}"), "-nodeReuse:false"]);
+        code.ShouldBe(0, $"dotnet msbuild {project} failed: {text}");
+
+        using var evaluation = JsonDocument.Parse(text);
+        return
+        [
+            .. evaluation.RootElement.GetProperty("Items").EnumerateObject()
+                         .SelectMany(kind => kind.Value.EnumerateArray().Select(item => (kind.Name, item.GetProperty("FullPath").GetString()!)))
+                         .Where(item => File.Exists(item.Item2))
+        ];
+    }
+
+    private static Task<(int Code, string Output)> RunAsync(string[] arguments) => Task.Run(() => Run(null, arguments));
+
+    // dotnet with the arguments, or the dll with them when one is given; stdout, and stderr after it on a failure.
+    private static (int Code, string Output) Run(string? dll, string[] arguments)
+    {
+        using var process = Process.Start(new ProcessStartInfo("dotnet", dll is null ? arguments : [dll, .. arguments])
+        {
+            RedirectStandardOutput = true,
+            RedirectStandardError  = true,
+        })!;
+
+        var errors = process.StandardError.ReadToEndAsync();
+        var output = process.StandardOutput.ReadToEnd();
+        process.WaitForExit();
+        return (process.ExitCode, process.ExitCode == 0 ? output : output + errors.Result);
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/CodoMetis.TypeKit.Conventions.Tests.csproj b/test/CodoMetis.TypeKit.Conventions.Tests/CodoMetis.TypeKit.Conventions.Tests.csproj
index d79888dc..e05e52e3 100644
--- a/test/CodoMetis.TypeKit.Conventions.Tests/CodoMetis.TypeKit.Conventions.Tests.csproj
+++ b/test/CodoMetis.TypeKit.Conventions.Tests/CodoMetis.TypeKit.Conventions.Tests.csproj
@@ -10,6 +10,18 @@
         <PackageReference Include="Microsoft.CodeAnalysis.CSharp" />
     </ItemGroup>
 
+    <!--
+      CiLaneTests runs the built ci-lanes.dll's `classify` over the files MSBuild evaluates for the packages. The
+      reference only orders the build; CiLanesOutput says where the output is.
+    -->
+    <ItemGroup>
+        <ProjectReference Include="../../tools/CiLanes/CiLanes.csproj" ReferenceOutputAssembly="false" />
+        <AssemblyAttribute Include="System.Reflection.AssemblyMetadataAttribute">
+            <_Parameter1>CiLanesOutput</_Parameter1>
+            <_Parameter2>$([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)../../tools/CiLanes/bin/$(Configuration)/$(TargetFramework)/'))</_Parameter2>
+        </AssemblyAttribute>
+    </ItemGroup>
+
     <!--
       So the build restores the shipping projects itself. Referencing none of them, this project
       restores nothing they need, and a `dotnet test` of this project alone on a fresh checkout ran against no
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/CompileTimeStaticStateTests.cs b/test/CodoMetis.TypeKit.Conventions.Tests/CompileTimeStaticStateTests.cs
new file mode 100644
index 00000000..16ffb566
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Conventions.Tests/CompileTimeStaticStateTests.cs
@@ -0,0 +1,150 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace CodoMetis.TypeKit.Conventions.Tests;
+
+/// <summary>
+/// A static field of the generators, or a static auto-property with storage, holds durable data only:
+/// strings, <see cref="Type"/>s, Metalama's <c>DiagnosticDefinition</c>s and arrays, lists and tuples of
+/// those. Never a code-model object such as an <c>AttributeConstruction</c>, an <c>INamedType</c> or an
+/// <c>IExpression</c>.
+/// </summary>
+/// <remarks>
+/// <para>
+/// A code-model object belongs to one compilation, and a static field outlives it. At design time the IDE
+/// keeps Metalama's process across edits, so every compilation that ever filled such a field stays
+/// reachable. Gaël Fraiteur of Metalama found seven <c>AttributeConstruction</c> fields in
+/// <c>CodeAnnotations</c> (discussion 2305, issue #90); they are properties that build the construction on
+/// use now.
+/// </para>
+/// <para>
+/// The rule is an allowlist on the declared type, read from syntax, so a field of a type nobody has
+/// judged fails until someone adds the type here. A <c>[Template]</c> member is no storage: Metalama
+/// introduces it into the target, and the generators never assign it.
+/// </para>
+/// </remarks>
+public sealed class CompileTimeStaticStateTests
+{
+    /// <summary>Types whose instances hold no compilation: what a static field may be.</summary>
+    private static readonly string[] DurableTypes = ["string", "bool", "int", "Type", "DiagnosticDefinition"];
+
+    /// <summary>Collections that are durable when their elements are.</summary>
+    private static readonly string[] DurableCollections = ["IReadOnlyList", "IReadOnlyCollection", "ImmutableArray", "FrozenSet", "FrozenDictionary"];
+
+    [Fact]
+    public void Static_storage_of_a_code_model_type_is_found()
+    {
+        const string source =
+            """
+            static class C
+            {
+                public static readonly AttributeConstruction A = AttributeConstruction.Create(typeof(X));
+                private static INamedType? b;
+                public static IReadOnlyList<IExpression> C { get; } = [];
+                private static readonly (string Name, IType Type)[] D = [];
+                public static readonly DiagnosticDefinition<(INamedType, string)> E = new("X", Severity.Error, "{0}");
+                private static readonly (string Name, Type Type)[] F = [];
+                public static IReadOnlyList<string> G { get; } = [];
+                public static AttributeConstruction H => AttributeConstruction.Create(typeof(X));
+                [Template] public static IReadOnlyList<object> _i;
+                private const string J = "j";
+                private readonly IType k;
+            }
+            """;
+
+        StaticStorage(source, Path.Combine(Repository.Root, "C.cs"))
+            .Where(storage => !storage.Durable)
+            .Select(storage => storage.Location)
+            .ShouldBe(
+            [
+                "C.cs:3: A: AttributeConstruction",
+                "C.cs:4: b: INamedType?",
+                "C.cs:5: C: IReadOnlyList<IExpression>",
+                "C.cs:6: D: (string Name, IType Type)[]",
+            ]);
+    }
+
+    [Fact]
+    public void The_generators_hold_static_storage()
+    {
+        // The positive control: the diagnostics and the member tables are found, so an empty result below
+        // cannot mean the walker stopped finding anything.
+        var storage = GeneratorsSources().SelectMany(path => StaticStorage(File.ReadAllText(path), path)).ToArray();
+
+        storage.Length.ShouldBeGreaterThanOrEqualTo(20, string.Join(Environment.NewLine, storage.Select(s => s.Location)));
+    }
+
+    [Fact]
+    public void The_generators_keep_no_code_model_object_in_static_storage()
+    {
+        var offending = GeneratorsSources().SelectMany(path => StaticStorage(File.ReadAllText(path), path))
+                                           .Where(storage => !storage.Durable)
+                                           .Select(storage => storage.Location)
+                                           .ToArray();
+
+        offending.ShouldBeEmpty(
+            "A static field outlives the compilation its code-model objects belong to, and the IDE keeps every one alive. " +
+            "Build the object where it is used (a property with an expression body), or add a type that holds no compilation " +
+            $"to {nameof(DurableTypes)}:{Environment.NewLine}{string.Join(Environment.NewLine, offending)}");
+    }
+
+    private static IReadOnlyList<string> GeneratorsSources()
+    {
+        var project = Path.Combine(Repository.Root, "src", "CodoMetis.TypeKit.Generators");
+
+        return
+        [
+            .. Directory.EnumerateFiles(project, "*.cs", SearchOption.AllDirectories)
+                        .Where(path => !Path.GetRelativePath(project, path).Split(Path.DirectorySeparatorChar).Any(part => part is "bin" or "obj"))
+                        .Order(StringComparer.Ordinal)
+        ];
+    }
+
+    private static IEnumerable<(string Location, bool Durable)> StaticStorage(string source, string path)
+    {
+        var cancellationToken = TestContext.Current.CancellationToken;
+        var tree              = CSharpSyntaxTree.ParseText(source, path: path, cancellationToken: cancellationToken);
+        var root              = tree.GetRoot(cancellationToken);
+        var lines             = tree.GetText(cancellationToken).Lines;
+
+        var fields = root.DescendantNodes()
+                         .OfType<FieldDeclarationSyntax>()
+                         .Where(field => field.Modifiers.Any(SyntaxKind.StaticKeyword) && !IsTemplate(field.AttributeLists))
+                         .SelectMany(field => field.Declaration.Variables.Select(variable => (Node: (SyntaxNode)variable, variable.Identifier, field.Declaration.Type)));
+
+        // An auto-property has a backing field; one with an expression body or accessor bodies has none.
+        var properties = root.DescendantNodes()
+                             .OfType<PropertyDeclarationSyntax>()
+                             .Where(property => property.Modifiers.Any(SyntaxKind.StaticKeyword)
+                                             && !IsTemplate(property.AttributeLists)
+                                             && property.AccessorList is { } accessors
+                                             && accessors.Accessors.All(accessor => accessor.Body is null && accessor.ExpressionBody is null))
+                             .Select(property => (Node: (SyntaxNode)property, property.Identifier, property.Type));
+
+        return fields.Concat(properties)
+                     .OrderBy(storage => storage.Node.SpanStart)
+                     .Select(storage => (
+                         $"{Path.GetRelativePath(Repository.Root, path)}:{lines.GetLineFromPosition(storage.Node.SpanStart).LineNumber + 1}: {storage.Identifier.ValueText}: {storage.Type}",
+                         IsDurable(storage.Type)));
+    }
+
+    private static bool IsTemplate(SyntaxList<AttributeListSyntax> attributeLists) =>
+        attributeLists.SelectMany(list => list.Attributes).Any(attribute => attribute.Name.ToString() is "Template" or "TemplateAttribute");
+
+    private static bool IsDurable(TypeSyntax type) =>
+        type switch
+        {
+            PredefinedTypeSyntax predefined => DurableTypes.Contains(predefined.Keyword.ValueText),
+            NullableTypeSyntax nullable     => IsDurable(nullable.ElementType),
+            ArrayTypeSyntax array           => IsDurable(array.ElementType),
+            TupleTypeSyntax tuple           => tuple.Elements.All(element => IsDurable(element.Type)),
+            QualifiedNameSyntax qualified   => IsDurable(qualified.Right),
+
+            // A diagnostic's type argument only says what its message is formatted from.
+            GenericNameSyntax { Identifier.ValueText: "DiagnosticDefinition" } => true,
+            GenericNameSyntax generic => DurableCollections.Contains(generic.Identifier.ValueText) && generic.TypeArgumentList.Arguments.All(IsDurable),
+            IdentifierNameSyntax name => DurableTypes.Contains(name.Identifier.ValueText),
+            _                         => false,
+        };
+}
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/DocsSiteTests.cs b/test/CodoMetis.TypeKit.Conventions.Tests/DocsSiteTests.cs
new file mode 100644
index 00000000..3dd65cec
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Conventions.Tests/DocsSiteTests.cs
@@ -0,0 +1,116 @@
+using System.Text.Json;
+using System.Text.RegularExpressions;
+
+namespace CodoMetis.TypeKit.Conventions.Tests;
+
+/// <summary>
+/// The docs site's menu and API pages follow the repository, so a new guide, package README or run-time package
+/// reaches the site without anyone remembering it (design/adr/0116). DocFX builds every page whether the menu lists
+/// it or not, so a page the menu forgets is reached only by search, and its build passes.
+/// </summary>
+/// <remarks>
+/// The menu is <c>site/toc.yml</c>, read line by line in the one shape it has: top-level entries, the sections among
+/// them holding <c>items</c>, each entry a <c>name</c> and an <c>href</c>.
+/// </remarks>
+public sealed partial class DocsSiteTests
+{
+    private const string Site = "site";
+
+    /// <summary>The packages with no API pages, and why: their READMEs are their reference.</summary>
+    private static readonly Dictionary<string, string> WithoutApiPages = new(StringComparer.Ordinal)
+    {
+        ["CodoMetis.TypeKit.Analyzers"] = "its public surface is its rules, which its README lists",
+        ["CodoMetis.TypeKit.Generators"] = "its aspects are internal, and its surface is what they generate into a consumer",
+    };
+
+    private static readonly Lazy<IReadOnlyList<MenuEntry>> Menu = new(() => ReadMenu(File.ReadAllLines(Path.Combine(Repository.Root, Site, "toc.yml"))));
+
+    [Fact]
+    public void The_menu_lists_the_guides_in_the_order_of_the_README()
+    {
+        var guides = Section("Guides").Select(entry => entry.Href);
+        var listed = ReadmeSamples.DocumentationLinks(File.ReadAllText(Path.Combine(Repository.Root, ReadmeSamples.RootReadme)));
+
+        guides.ShouldBe(listed.Select(page => $"../{page}"),
+            "site/toc.yml's Guides are the pages of the README's Documentation table, in its order.");
+    }
+
+    [Fact]
+    public void The_menu_lists_every_package_README_as_reference()
+    {
+        var reference = Section("Reference").Select(entry => entry.Href);
+
+        reference.ShouldBe(Repository.ShippingProjects().Select(package => $"../src/{package}/README.md"), ignoreOrder: true,
+            "site/toc.yml's Reference lists every shipping package's README, and nothing else.");
+    }
+
+    [Fact]
+    public void The_menu_starts_at_the_README_and_ends_with_the_API_and_the_changelog()
+    {
+        Menu.Value.Select(entry => entry.Name).ShouldBe(["Home", "Guides", "Reference", "API", "Changelog"]);
+        Menu.Value[0].Href.ShouldBe("../README.md");
+        Menu.Value[^1].Href.ShouldBe("../CHANGELOG.md");
+    }
+
+    [Fact]
+    public void The_API_pages_are_the_run_time_packages()
+    {
+        using var config = JsonDocument.Parse(File.ReadAllText(Path.Combine(Repository.Root, Site, "docfx.json")));
+        var assemblies = config.RootElement.GetProperty("metadata").EnumerateArray()
+                               .SelectMany(metadata => metadata.GetProperty("src").EnumerateArray())
+                               .SelectMany(source => source.GetProperty("files").EnumerateArray())
+                               .Select(file => file.GetString()!);
+
+        WithoutApiPages.Keys.ShouldBeSubsetOf(Repository.ShippingProjects(), "An exemption names a package that no longer exists.");
+        assemblies.ShouldBe(Repository.ShippingProjects().Where(package => !WithoutApiPages.ContainsKey(package)).Select(package => $"{package}.dll"), ignoreOrder: true,
+            "site/docfx.json's metadata reads every run-time package's assembly. A package without API pages goes into WithoutApiPages with the reason.");
+    }
+
+    [Fact]
+    public void The_menu_is_read()
+    {
+        Menu.Value.Count.ShouldBeGreaterThanOrEqualTo(5);
+        Section("Guides").Count.ShouldBeGreaterThanOrEqualTo(10);
+    }
+
+    private static IReadOnlyList<MenuEntry> Section(string name) =>
+        Menu.Value.SingleOrDefault(entry => entry.Name == name)?.Items ?? throw new InvalidOperationException($"site/toc.yml has no section '{name}'.");
+
+    private static IReadOnlyList<MenuEntry> ReadMenu(string[] lines)
+    {
+        var menu = new List<MenuEntry>();
+        foreach (var line in lines)
+        {
+            if (line.Trim().Length == 0 || line.Trim() == "items:") continue;
+
+            var match = Entry().Match(line);
+            if (!match.Success) throw new InvalidOperationException($"site/toc.yml has a line this test cannot read: '{line}'.");
+
+            var nested = match.Groups["indent"].Length > 2;
+            var value = match.Groups["value"].Value;
+            if (match.Groups["key"].Value == "name")
+            {
+                var entry = new MenuEntry(value);
+                if (nested) menu[^1].Items.Add(entry);
+                else menu.Add(entry);
+            }
+            else
+            {
+                var owner = nested ? menu[^1].Items[^1] : menu[^1];
+                owner.Href = value;
+            }
+        }
+        return menu;
+    }
+
+    private sealed record MenuEntry(string Name)
+    {
+        /// <summary>Empty for a section, which has <see cref="Items"/> instead.</summary>
+        public string Href { get; set; } = "";
+
+        public List<MenuEntry> Items { get; } = [];
+    }
+
+    [GeneratedRegex(@"^(?<indent>[ -]*)(?<key>name|href): (?<value>.+)$")]
+    private static partial Regex Entry();
+}
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/GeneratedCodeBlockTests.cs b/test/CodoMetis.TypeKit.Conventions.Tests/GeneratedCodeBlockTests.cs
new file mode 100644
index 00000000..9e797ae9
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Conventions.Tests/GeneratedCodeBlockTests.cs
@@ -0,0 +1,297 @@
+using System.Reflection.Metadata;
+using System.Reflection.PortableExecutable;
+using System.Text.RegularExpressions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace CodoMetis.TypeKit.Conventions.Tests;
+
+/// <summary>
+/// A README block that shows generated code shows what the build writes: every member in it, and every
+/// interface in its base list, is in the woven code of the sample it names.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Such a block repeats a partial declaration, so it cannot compile and is marked
+/// <c>&lt;!-- not compiled: generated code for {file}, trimmed (GeneratedCodeBlockTests) --&gt;</c>, where
+/// <c>{file}</c> is a source of the samples project, relative to it. The samples project sets
+/// <c>MetalamaEmitCompilerTransformedFiles</c>, so the build writes that file's woven form under
+/// <c>obj/{configuration}/net10.0/metalama/</c>, and this reads the one of its own configuration.
+/// </para>
+/// <para>
+/// The woven code is fully qualified, carries an attribute on every member and a cast on every
+/// returned expression, so both sides are compared in a reading form: no attributes, no comments, no
+/// namespace before a type, <c>string</c> for <c>System.String</c>, no casts and no <c>this.</c>. A block
+/// may leave members out; the members it shows have to be the generated ones, bodies included.
+/// </para>
+/// </remarks>
+public sealed partial class GeneratedCodeBlockTests
+{
+    private const string SamplesObj = "test/CodoMetis.TypeKit.Samples/obj";
+
+    public static TheoryData<string, string, string> Blocks =>
+    [
+        .. ReadmeSamples.CodeBlocks()
+                        .Where(block => block.IsCSharp && block.OptOut is { } reason && reason.StartsWith(MarkerStart, StringComparison.Ordinal))
+                        .Select(block => (block.Location, SampleFile(block), block.Code))
+    ];
+
+    private const string MarkerStart = "generated code for ";
+
+    [Fact]
+    public void The_blocks_are_found() =>
+        Blocks.Count.ShouldBeGreaterThanOrEqualTo(3);
+
+    [Theory]
+    [MemberData(nameof(Blocks))]
+    public void A_block_of_generated_code_is_what_the_build_writes(string location, string sample, string code) =>
+        Differences(code, File.ReadAllText(WovenFile(sample)), KnownNamespaces.Value)
+            .Select(difference => $"{difference.Key}: {difference.Detail}")
+            .ShouldBeEmpty($"{location} shows code the build does not write for {sample}. Correct the block from {WovenFile(sample)}.");
+
+    [Fact]
+    public void A_member_that_differs_is_found()
+    {
+        const string woven =
+            """
+            namespace Shop;
+            [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]
+            public readonly partial record struct OrderId : IValue<Guid>, global::System.IComparable<global::Shop.OrderId>
+            {
+                [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]private readonly global::System.Guid _value;
+                [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute]public global::System.Guid Value
+                { get{    return (global::System.Guid)this._value; } }
+                public static global::Shop.OrderId From(global::System.Guid value){    return new global::Shop.OrderId(value); }
+                public override global::System.String ToString(){ return (global::System.String)this.Value.ToString(); }
+            }
+            """;
+
+        const string shown =
+            """
+            public readonly partial record struct OrderId : IValue<Guid>, IComparable<OrderId>, IParsable<OrderId>
+            {
+                private readonly Guid _value;
+
+                public Guid Value
+                {
+                    get { return _value; }
+                }
+
+                public static OrderId From(Guid value)
+                {
+                    return default;
+                }
+
+                public override string ToString()
+                {
+                    return Value.ToString();
+                }
+
+                public static OrderId Parse(string s, IFormatProvider? provider)
+                {
+                    return From(Guid.Parse(s));
+                }
+            }
+            """;
+
+        Differences(shown, woven, new HashSet<string> { "Shop", "System" })
+            .Select(difference => difference.Key)
+            .ShouldBe(["OrderId : IParsable<OrderId>", "OrderId.From", "OrderId.Parse"]);
+    }
+
+    /// <summary>
+    /// What <paramref name="shown"/> declares that <paramref name="woven"/> does not: a type, an interface
+    /// of a type's base list, or a member, each with what the woven code has under that name instead.
+    /// </summary>
+    private static IEnumerable<(string Key, string Detail)> Differences(string shown, string woven, IReadOnlySet<string> namespaces)
+    {
+        var wovenTypes = TypesByName(Parse(woven));
+
+        foreach (var type in Parse(shown).DescendantNodes().OfType<TypeDeclarationSyntax>())
+        {
+            if (!wovenTypes.TryGetValue(type.Identifier.ValueText, out var wovenType))
+            {
+                yield return (type.Identifier.ValueText, "no such type in the woven code");
+                continue;
+            }
+
+            var wovenBases = wovenType.BaseList?.Types.Select(baseType => Reading(baseType.Type, namespaces)).ToHashSet() ?? [];
+            foreach (var baseType in type.BaseList?.Types ?? [])
+            {
+                var reading = Reading(baseType.Type, namespaces);
+                if (!wovenBases.Contains(reading)) yield return ($"{type.Identifier.ValueText} : {reading}", $"not in the woven base list ({string.Join(", ", wovenBases)})");
+            }
+
+            var wovenMembers = wovenType.Members.Where(member => member is not BaseTypeDeclarationSyntax).Select(member => Reading(member, namespaces)).ToArray();
+            foreach (var member in type.Members.Where(member => member is not BaseTypeDeclarationSyntax))
+            {
+                var reading = Reading(member, namespaces);
+                if (wovenMembers.Contains(reading)) continue;
+
+                var name      = Name(member);
+                var namesakes = wovenType.Members.Where(candidate => Name(candidate) == name).Select(candidate => Reading(candidate, namespaces));
+
+                yield return ($"{type.Identifier.ValueText}.{name}",
+                              $"shown as{Environment.NewLine}{reading}{Environment.NewLine}generated as{Environment.NewLine}{string.Join(Environment.NewLine, namesakes.DefaultIfEmpty("(nothing of that name)"))}");
+            }
+        }
+    }
+
+    private static Dictionary<string, TypeDeclarationSyntax> TypesByName(SyntaxNode root) =>
+        root.DescendantNodes().OfType<TypeDeclarationSyntax>()
+            .GroupBy(type => type.Identifier.ValueText)
+            .ToDictionary(group => group.Key, group => group.First());
+
+    private static SyntaxNode Parse(string code) =>
+        CSharpSyntaxTree.ParseText(code, cancellationToken: TestContext.Current.CancellationToken).GetRoot(TestContext.Current.CancellationToken);
+
+    private static string Name(MemberDeclarationSyntax member) =>
+        member switch
+        {
+            MethodDeclarationSyntax method           => method.Identifier.ValueText,
+            PropertyDeclarationSyntax property       => property.Identifier.ValueText,
+            ConstructorDeclarationSyntax constructor => constructor.Identifier.ValueText,
+            FieldDeclarationSyntax field             => string.Join(", ", field.Declaration.Variables.Select(variable => variable.Identifier.ValueText)),
+            OperatorDeclarationSyntax op             => "operator " + op.OperatorToken.ValueText,
+            _                                        => member.Kind().ToString(),
+        };
+
+    /// <summary>The code as a reader would write it, on one normalised layout.</summary>
+    private static string Reading(SyntaxNode node, IReadOnlySet<string> namespaces) =>
+        new ReadingForm(namespaces).Visit(node)!.NormalizeWhitespace().ToFullString();
+
+    /// <summary>The woven form of <paramref name="sample"/>, written by the build of this configuration.</summary>
+    private static string WovenFile(string sample)
+    {
+        // bin/{configuration}/{framework}/ of this test project.
+        var output        = new DirectoryInfo(AppContext.BaseDirectory.TrimEnd(Path.DirectorySeparatorChar));
+        var framework     = output.Name;
+        var configuration = output.Parent!.Name;
+        var path          = Path.Combine(Repository.Root, SamplesObj, configuration, framework, "metalama", sample);
+
+        return File.Exists(path)
+            ? path
+            : throw new FileNotFoundException($"No woven {sample} at {path}. Build {ReadmeSamples.SamplesProject} in {configuration} first; dotnet test --solution does.");
+    }
+
+    private static string SampleFile(CodeBlock block)
+    {
+        var match = Marker().Match(block.OptOut!);
+        return match.Success
+            ? match.Groups["file"].Value
+            : throw new InvalidOperationException($"{block.Location}: the marker names no sample: <!-- not compiled: {MarkerStart}{{file}}, trimmed (GeneratedCodeBlockTests) -->");
+    }
+
+    [GeneratedRegex(@"^generated code for (?<file>\S+), trimmed \(GeneratedCodeBlockTests\)$")]
+    private static partial Regex Marker();
+
+    /// <summary>The namespaces of every type the samples can name, so a qualified name loses only those.</summary>
+    private static readonly Lazy<IReadOnlySet<string>> KnownNamespaces = new(() =>
+    {
+        var names = new HashSet<string>(StringComparer.Ordinal);
+
+        // TypeKit's and the samples' own, read from their sources: this project loads neither assembly.
+        foreach (var folder in new[] { "src", ReadmeSamples.SamplesProject })
+        foreach (var path in Directory.EnumerateFiles(Path.Combine(Repository.Root, folder), "*.cs", SearchOption.AllDirectories)
+                                      .Where(path => !path.Split(Path.DirectorySeparatorChar).Any(part => part is "bin" or "obj")))
+        foreach (var declaration in Parse(File.ReadAllText(path)).DescendantNodes().OfType<BaseNamespaceDeclarationSyntax>())
+            AddWithParents(names, declaration.Name.ToString());
+
+        // The framework's, read from the metadata of every assembly of the runtime and of this test's output.
+        var folders = new[] { Path.GetDirectoryName(typeof(object).Assembly.Location)!, AppContext.BaseDirectory };
+        foreach (var path in folders.SelectMany(folder => Directory.EnumerateFiles(folder, "*.dll")))
+        {
+            try
+            {
+                using var stream = File.OpenRead(path);
+                using var reader = new PEReader(stream);
+                if (!reader.HasMetadata) continue;
+
+                var metadata = reader.GetMetadataReader();
+                foreach (var handle in metadata.TypeDefinitions)
+                    if (metadata.GetString(metadata.GetTypeDefinition(handle).Namespace) is { Length: > 0 } ns) AddWithParents(names, ns);
+            }
+            catch (BadImageFormatException)
+            {
+                // A native library beside the managed ones.
+            }
+        }
+
+        return names;
+    });
+
+    private static void AddWithParents(HashSet<string> names, string ns)
+    {
+        for (var name = ns; name.Length > 0; name = name.Contains('.') ? name[..name.LastIndexOf('.')] : "") names.Add(name);
+    }
+
+    /// <summary>Takes out what the woven code adds for the compiler and not for a reader.</summary>
+    private sealed class ReadingForm(IReadOnlySet<string> namespaces) : CSharpSyntaxRewriter
+    {
+        private static readonly Dictionary<string, SyntaxKind> Keywords = new(StringComparer.Ordinal)
+        {
+            ["Boolean"] = SyntaxKind.BoolKeyword, ["String"] = SyntaxKind.StringKeyword, ["Int32"] = SyntaxKind.IntKeyword,
+            ["Int64"]   = SyntaxKind.LongKeyword, ["Object"] = SyntaxKind.ObjectKeyword, ["Char"]  = SyntaxKind.CharKeyword,
+            ["Byte"]    = SyntaxKind.ByteKeyword, ["Double"] = SyntaxKind.DoubleKeyword, ["Decimal"] = SyntaxKind.DecimalKeyword,
+        };
+
+        public override SyntaxNode? VisitAttributeList(AttributeListSyntax node) => null;
+
+        public override SyntaxTrivia VisitTrivia(SyntaxTrivia trivia) =>
+            trivia.IsKind(SyntaxKind.SingleLineCommentTrivia) || trivia.IsKind(SyntaxKind.MultiLineCommentTrivia) ? default : trivia;
+
+        /// <summary>
+        /// A cast goes, and so do the parentheses around its operand where the cast stood alone: a returned
+        /// value, an initializer, an argument or another cast.
+        /// </summary>
+        public override SyntaxNode? VisitCastExpression(CastExpressionSyntax node) =>
+            node.Expression is ParenthesizedExpressionSyntax parenthesized
+         && node.Parent is ReturnStatementSyntax or ArrowExpressionClauseSyntax or EqualsValueClauseSyntax or ArgumentSyntax or CastExpressionSyntax
+                ? Visit(parenthesized.Expression)
+                : Visit(node.Expression);
+
+        public override SyntaxNode? VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
+        {
+            if (node.Expression is ThisExpressionSyntax) return Visit(node.Name);
+
+            var qualifier = Qualifier(node.Expression);
+            if (qualifier is not null && namespaces.Contains(qualifier)) return Unqualified(node.Name);
+
+            return base.VisitMemberAccessExpression(node);
+        }
+
+        public override SyntaxNode? VisitQualifiedName(QualifiedNameSyntax node)
+        {
+            var qualifier = Qualifier(node.Left);
+            return qualifier is not null && namespaces.Contains(qualifier) ? Unqualified(node.Right) : base.VisitQualifiedName(node);
+        }
+
+        public override SyntaxNode? VisitAliasQualifiedName(AliasQualifiedNameSyntax node) => Unqualified(node.Name);
+
+        /// <summary>A name whose namespace was taken off: <c>System.Object</c> is read as <c>object</c>.</summary>
+        private SyntaxNode? Unqualified(SimpleNameSyntax name) =>
+            name is IdentifierNameSyntax identifier && Keywords.TryGetValue(identifier.Identifier.ValueText, out var keyword)
+                ? Keyword(identifier, keyword)
+                : Visit(name);
+
+        public override SyntaxNode? VisitIdentifierName(IdentifierNameSyntax node) =>
+            Keywords.TryGetValue(node.Identifier.ValueText, out var keyword) && !(node.Parent is MemberAccessExpressionSyntax access && access.Name == node)
+                ? Keyword(node, keyword)
+                : base.VisitIdentifierName(node);
+
+        private static SyntaxNode Keyword(IdentifierNameSyntax node, SyntaxKind keyword) =>
+            SyntaxFactory.PredefinedType(SyntaxFactory.Token(keyword)).WithTriviaFrom(node);
+
+        /// <summary>The dotted text of a name or member-access chain, without <c>global::</c>; null for anything else.</summary>
+        private static string? Qualifier(ExpressionSyntax expression) =>
+            expression switch
+            {
+                AliasQualifiedNameSyntax alias      => alias.Name.Identifier.ValueText,
+                IdentifierNameSyntax identifier     => identifier.Identifier.ValueText,
+                QualifiedNameSyntax qualified       => Qualifier(qualified.Left) is { } left ? $"{left}.{qualified.Right.Identifier.ValueText}" : null,
+                MemberAccessExpressionSyntax access => Qualifier(access.Expression) is { } left ? $"{left}.{access.Name.Identifier.ValueText}" : null,
+                _                                   => null,
+            };
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/GeneratedHarnessTests.cs b/test/CodoMetis.TypeKit.Conventions.Tests/GeneratedHarnessTests.cs
deleted file mode 100644
index 4737a5bb..00000000
--- a/test/CodoMetis.TypeKit.Conventions.Tests/GeneratedHarnessTests.cs
+++ /dev/null
@@ -1,113 +0,0 @@
-using System.Diagnostics;
-
-namespace CodoMetis.TypeKit.Conventions.Tests;
-
-/// <summary>
-/// Every generated file of the probe harness (<c>tools/probe/corpus/harness/*.g.cs</c>) is what its generator writes
-/// from the tracked inputs today: the generator is run into a temporary directory and its output compared with the
-/// committed file.
-/// </summary>
-/// <remarks>
-/// The generators are file-based apps under <c>tools/probe/generators/</c> (design/adr/0092, form 1), which have no
-/// tests of their own; this is their guard. Without it a hand edit of a <c>.g.cs</c>, or a rows file changed by
-/// <c>prober rows</c> without regenerating the declarations, would leave the harness built from something nothing can
-/// reproduce, as the Python originals did when they left the repository. The comparison ignores line endings only,
-/// since a Windows checkout may write the committed file with CRLF and the generators write LF, as git stores it.
-/// </remarks>
-public sealed class GeneratedHarnessTests
-{
-    private const string Harness = "tools/probe/corpus/harness";
-
-    private const string Rows = "tools/probe/corpus/rows";
-
-    private const string Axes = ".claude/probe-axes.md";
-
-    /// <summary>
-    /// The one place the mapping lives: each generated file, the app that writes it and its arguments, the paths from
-    /// the repository root. The test adds <c>--out</c>. The EF catalogue is E01's and E02's first round of rows (the
-    /// rows appended since run on EfShapes3's and EfShapes4's complete grids), so it reads only those.
-    /// </summary>
-    private static readonly (string File, string App, string[] Arguments)[] Generators =
-    [
-        ("Shapes.g.cs", "shapes.cs", ["--axes", Axes, "--l06", $"{Rows}/L06OffTheWireProbe.json.gz"]),
-        ("Containers.g.cs", "containers.cs", ["--axes", Axes]),
-        ("EfShapes.g.cs", "ef.cs", ["catalogue", .. EfCatalogue]),
-        ("EfShapes3.g.cs", "ef.cs", ["top-level", .. EfCatalogue]),
-        ("EfShapes4.g.cs", "ef.cs", ["nested", .. EfCatalogue]),
-        ("KeyShapes.g.cs", "ef.cs", ["keys", "--rows", $"{Rows}/E04IntegerKeyProbe.json.gz"]),
-        ("JsonFamilyShapes.g.cs", "json-family.cs", ["stand-ins"]),
-        ("L05Shapes.g.cs", "json-family.cs", ["l05", "--rows", $"{Rows}/L05EqualityProbe.json.gz"]),
-        ("C09Shapes.g.cs", "decls.cs", ["C09", "--rows", $"{Rows}/C09BaseRecordEqualityProbe.json.gz"]),
-        ("C11Shapes.g.cs", "decls.cs", ["C11", "--rows", $"{Rows}/C11ParseShapesBuildProbe.json.gz"]),
-        ("FaultClaimControllers.g.cs", "faults.cs", []),
-        ("RuleControllers.g.cs", "rules.cs", []),
-    ];
-
-    private static string[] EfCatalogue =>
-    [
-        "--rows", $"{Rows}/E01ColumnParityProbe.json.gz", "--first", "90",
-        "--rows", $"{Rows}/E02ValueTranslatesProbe.json.gz", "--first", "108",
-    ];
-
-    public static TheoryData<string> Files => [.. Generators.Select(generator => generator.File)];
-
-    [Fact]
-    public void Every_generated_file_of_the_harness_has_its_generator()
-    {
-        var committed = Directory.GetFiles(Path.Combine(Repository.Root, Harness), "*.g.cs")
-                                 .Select(Path.GetFileName).OfType<string>().Order(StringComparer.Ordinal).ToList();
-
-        committed.Count.ShouldBeGreaterThanOrEqualTo(12, $"{Harness} holds {committed.Count} generated files; it held twelve when this test was written.");
-        committed.ShouldBe(
-            Generators.Select(generator => generator.File).Order(StringComparer.Ordinal).ToList(), ignoreOrder: false,
-            $"Every {Harness}/*.g.cs is written by an app of tools/probe/generators, listed in {nameof(Generators)} with its arguments, and every listed file exists.");
-    }
-
-    [Theory]
-    [MemberData(nameof(Files))]
-    public async Task The_committed_file_is_its_generators_output(string file)
-    {
-        var (_, app, arguments) = Generators.Single(generator => generator.File == file);
-        var directory = Directory.CreateTempSubdirectory("generated-harness-");
-        try
-        {
-            var output = Path.Combine(directory.FullName, file);
-            string[] command = ["run", $"tools/probe/generators/{app}", "--", .. arguments, "--out", output];
-            using var process = Process.Start(new ProcessStartInfo("dotnet", command)
-            {
-                WorkingDirectory       = Repository.Root,
-                RedirectStandardOutput = true,
-                RedirectStandardError  = true,
-            })!;
-
-            var standardOutput = process.StandardOutput.ReadToEndAsync(TestContext.Current.CancellationToken);
-            var errors = process.StandardError.ReadToEndAsync(TestContext.Current.CancellationToken);
-            await process.WaitForExitAsync(TestContext.Current.CancellationToken);
-
-            var invocation = $"dotnet {string.Join(' ', command[..^1])} {Harness}/{file}";
-            process.ExitCode.ShouldBe(0, $"`{invocation}` failed:{Environment.NewLine}{await standardOutput}{await errors}");
-
-            var expected = (await File.ReadAllTextAsync(output, TestContext.Current.CancellationToken)).ReplaceLineEndings("\n");
-            var actual = (await File.ReadAllTextAsync(Path.Combine(Repository.Root, Harness, file), TestContext.Current.CancellationToken)).ReplaceLineEndings("\n");
-            (actual == expected).ShouldBeTrue(
-                $"{Harness}/{file} is not what {app} writes from the tracked inputs ({FirstDifference(actual, expected)}). " +
-                $"Regenerate it with `{invocation}` and commit the result; a hand edit belongs in the generator.");
-        }
-        finally
-        {
-            directory.Delete(recursive: true);
-        }
-    }
-
-    private static string FirstDifference(string committed, string generated)
-    {
-        var (a, b) = (committed.Split('\n'), generated.Split('\n'));
-        for (var line = 0; line < Math.Min(a.Length, b.Length); line++)
-        {
-            if (a[line] != b[line]) return $"first difference at line {line + 1}: committed `{Cut(a[line])}`, generated `{Cut(b[line])}`";
-        }
-        return $"the committed file has {a.Length} lines, the generated one {b.Length}";
-    }
-
-    private static string Cut(string line) => line.Length > 160 ? line[..160] + "..." : line;
-}
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/PackageReleaseNotesTests.cs b/test/CodoMetis.TypeKit.Conventions.Tests/PackageReleaseNotesTests.cs
new file mode 100644
index 00000000..74d9386b
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Conventions.Tests/PackageReleaseNotesTests.cs
@@ -0,0 +1,176 @@
+using System.Diagnostics;
+using System.Text.RegularExpressions;
+using System.Xml.Linq;
+
+namespace CodoMetis.TypeKit.Conventions.Tests;
+
+/// <summary>
+/// Every package's release notes are its version's section of CHANGELOG.md, in the plain text
+/// nuget.org shows, followed by one line linking the whole changelog (#75).
+/// </summary>
+/// <remarks>
+/// nuget.org's Release Notes tab and Visual Studio's Updates tab show the nuspec's
+/// <c>releaseNotes</c>, frozen with the version once pushed. The <c>ReleaseNotesFromChangelog</c>
+/// target in <c>src/Directory.Build.targets</c> writes it at pack. These read the packed nuspecs and
+/// derive the expected text again from the changelog, line by line rather than by the target's
+/// expressions, so a target that reads another version's section or stops running fails here. A
+/// missing or empty section fails the pack itself, and with it the fixture. The version's section
+/// may hold no Markdown at all, which would let a target that leaves Markdown in pass, so the target
+/// also runs on a sample changelog of every shape, and on samples it must refuse.
+/// <para>
+/// Plain text, measured on nuget.org on 2026-10-20: release notes are escaped, each line break becomes
+/// <c>&lt;br /&gt;</c>, and a bare URL is linked; the brackets of <c>[text](url)</c>, backticks, <c>**</c>
+/// and <c>#</c> reach the page literally (Bogus 35.6.5, Asp.Versioning.Http 10.2.3), and a URL in
+/// parentheses is linked without its closing one (RazorEngine 3.10.0).
+/// </para>
+/// </remarks>
+[Collection(PacksCollection.Name)]
+public sealed partial class PackageReleaseNotesTests(AnalyzerPackagingTests.Packs packs)
+{
+    public static TheoryData<string> ShippingPackages => [.. Repository.ShippingProjects()];
+
+    private static XElement Props => XDocument.Load(Path.Combine(Repository.Root, "Directory.Build.props")).Root!;
+
+    private static string Version => Props.Descendants("Version").Single().Value.Trim();
+
+    private static string Footer => $"Full changelog: {Props.Descendants("PackageProjectUrl").Single().Value.Trim()}/blob/main/CHANGELOG.md";
+
+    [Theory]
+    [MemberData(nameof(ShippingPackages))]
+    public void The_release_notes_are_the_versions_changelog_section(string package) =>
+        ReleaseNotes(package).ShouldBe(Expected(File.ReadAllText(Path.Combine(Repository.Root, "CHANGELOG.md")), Version),
+            $"{package}'s release notes are not CHANGELOG.md's '## {Version}' section in plain text. The ReleaseNotesFromChangelog target (src/Directory.Build.targets) writes them at pack.");
+
+    [Theory]
+    [MemberData(nameof(ShippingPackages))]
+    public void The_release_notes_carry_no_markdown(string package) =>
+        Markdown().Matches(ReleaseNotes(package)).Select(match => match.Value).ShouldBeEmpty(
+            $"{package}'s release notes contain Markdown, which nuget.org shows literally.");
+
+    /// <summary>A section between two others, with every shape the changelog writes, and text MSBuild would expand or unescape.</summary>
+    private const string Sample = """
+        # Changelog
+
+        ## 9.9.10 — Unreleased
+
+        - Later: not this version.
+
+        ## 9.9.9 — 2026-01-02
+
+        ### Fixed
+
+        - Generators: `Parse` on a **span** ([What is generated](https://example.org/g#what)).
+        - [`Code` in a link](https://example.org/c?a=1&b=2) and 50%3B; $(Foo) @(Bar) %(Baz) 'q' "d" <a> & b — ü.
+
+        ## 9.9.8 — 2026-01-01
+
+        - Earlier: not this version.
+        """;
+
+    private const string SamplePlain = """
+        Fixed
+
+        - Generators: Parse on a span (What is generated (https://example.org/g#what)).
+        - Code in a link (https://example.org/c?a=1&b=2) and 50%3B; $(Foo) @(Bar) %(Baz) 'q' "d" <a> & b — ü.
+        """;
+
+    [Theory]
+    [InlineData("\n")]
+    [InlineData("\r\n")]
+    public async Task The_target_writes_every_shape_as_plain_text(string lineEnding)
+    {
+        var changelog = Sample.ReplaceLineEndings(lineEnding);
+        var expected  = $"{SamplePlain.ReplaceLineEndings("\n")}\n\n{Footer}";
+
+        Expected(changelog, "9.9.9").ShouldBe(expected, "This test's own reading of a section disagrees with the sample's plain text.");
+
+        var (exitCode, output) = await RunTarget(changelog, "9.9.9");
+
+        exitCode.ShouldBe(0, output);
+        output.ReplaceLineEndings("\n").Trim().ShouldBe(expected);
+    }
+
+    public static TheoryData<string, string, string> Refused => new()
+    {
+        { "no section",    "## 9.9.8 — 2026-01-01\n\n- Earlier.\n",                                  "has no '## 9.9.9' section" },
+        { "empty section", "## 9.9.9 — Unreleased\n\n## 9.9.8 — 2026-01-01\n\n- Earlier.\n",       "'## 9.9.9' section is empty" },
+        { "relative link", "## 9.9.9 — Unreleased\n\n- See [the docs](docs/json.md).\n",            "relative link" },
+        { "too long",      $"## 9.9.9 — Unreleased\n\n- {new string('x', 35_000)}\n",              "over nuget.org's 35,000" },
+    };
+
+    [Theory]
+    [MemberData(nameof(Refused))]
+    public async Task The_target_refuses_a_section_nuget_org_cannot_show(string what, string changelog, string message)
+    {
+        var (exitCode, output) = await RunTarget(changelog, "9.9.9");
+
+        exitCode.ShouldNotBe(0, $"The target accepted a changelog with {what}:{Environment.NewLine}{output}");
+        output.ShouldContain(message, Case.Sensitive, $"The target refused a changelog with {what}, but not for that reason:{Environment.NewLine}{output}");
+        output.ShouldContain("CHANGELOG.md", Case.Sensitive, "The refusal does not name the changelog.");
+    }
+
+    /// <summary>The section, read line by line from the line after its heading up to the next <c>## </c>, in plain text, with the footer.</summary>
+    private static string Expected(string changelog, string version)
+    {
+        var lines   = changelog.ReplaceLineEndings("\n").Split('\n');
+        var heading = Array.FindIndex(lines, line => line == $"## {version}" || line.StartsWith($"## {version} ", StringComparison.Ordinal));
+
+        heading.ShouldBeGreaterThanOrEqualTo(0, $"CHANGELOG.md has no '## {version}' section.");
+
+        var section = string.Join('\n', lines.Skip(heading + 1).TakeWhile(line => !line.StartsWith("## ", StringComparison.Ordinal))).Trim();
+        section.ShouldNotBeEmpty($"CHANGELOG.md's '## {version}' section is empty.");
+
+        var plain = section.Split('\n').Select(line =>
+            Link().Replace(line.StartsWith("### ", StringComparison.Ordinal) ? line[4..] : line, "$1 ($2)").Replace("`", "").Replace("**", ""));
+
+        return $"{string.Join('\n', plain)}\n\n{Footer}";
+    }
+
+    private string ReleaseNotes(string package)
+    {
+        var notes = packs.Nuspec(package).Descendants()
+                         .SingleOrDefault(element => element.Name.LocalName == "releaseNotes" && element.Parent?.Name.LocalName == "metadata");
+
+        notes.ShouldNotBeNull($"{package} has no <releaseNotes> in its nuspec.");
+        return notes.Value;
+    }
+
+    /// <summary>
+    /// The target alone, on one shipping project, against a changelog of the test's own: what it sets
+    /// <c>PackageReleaseNotes</c> to, or its refusal. Nothing is built or written beside the project.
+    /// </summary>
+    private static async Task<(int ExitCode, string Output)> RunTarget(string changelog, string version)
+    {
+        var directory = Directory.CreateTempSubdirectory("codometis-typekit-release-notes-");
+        try
+        {
+            var path = Path.Combine(directory.FullName, "CHANGELOG.md");
+            await File.WriteAllTextAsync(path, changelog);
+
+            var project = Path.Combine(Repository.Root, "src", "CodoMetis.TypeKit.Serilog", "CodoMetis.TypeKit.Serilog.csproj");
+            using var process = Process.Start(new ProcessStartInfo("dotnet",
+                ["msbuild", project, "-t:ReleaseNotesFromChangelog", "-getProperty:PackageReleaseNotes", $"-p:ReleaseNotesChangelog={path}", $"-p:Version={version}", "-nodeReuse:false"])
+            {
+                RedirectStandardOutput = true,
+                RedirectStandardError  = true,
+            })!;
+
+            var output = process.StandardOutput.ReadToEndAsync();
+            var errors = process.StandardError.ReadToEndAsync();
+            await process.WaitForExitAsync();
+
+            return (process.ExitCode, await output + await errors);
+        }
+        finally
+        {
+            directory.Delete(recursive: true);
+        }
+    }
+
+    [GeneratedRegex(@"\[([^\]\n]+)\]\((https?://[^)\s]+)\)")]
+    private static partial Regex Link();
+
+    /// <summary>Inline code, emphasis, a link, or a heading marker at the start of a line.</summary>
+    [GeneratedRegex(@"(?m)`|\*\*|\]\(|^#")]
+    private static partial Regex Markdown();
+}
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/PortableFileNameTests.cs b/test/CodoMetis.TypeKit.Conventions.Tests/PortableFileNameTests.cs
new file mode 100644
index 00000000..a2378df4
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Conventions.Tests/PortableFileNameTests.cs
@@ -0,0 +1,126 @@
+using System.Diagnostics;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace CodoMetis.TypeKit.Conventions.Tests;
+
+/// <summary>
+/// Every tracked path checks out on Windows and macOS as it does on Linux. A prose-only change runs the Linux leg
+/// alone (design/adr/0113), so a file name that Windows refuses, or two names a case-insensitive file system takes
+/// for one, would otherwise first fail on the release's pull request (#73).
+/// </summary>
+/// <remarks>
+/// Read from git's index (<c>git ls-files</c>), which can hold names this file system cannot: a test that walked the
+/// directory would never see the second of two names that differ only in case.
+/// </remarks>
+public sealed partial class PortableFileNameTests
+{
+    /// <summary>
+    /// The longest repository-relative path allowed. Windows' MAX_PATH is 260; a checkout's own directory takes
+    /// about 40 characters on a hosted runner and up to about 90 in a worktree under <c>.claude/worktrees/</c>, and
+    /// the longest tracked path was 102 on 2026-10-29.
+    /// </summary>
+    private const int LongestPath = 160;
+
+    [Fact]
+    public void Every_tracked_path_is_a_name_Windows_and_macOS_accept() =>
+        Problems(TrackedPaths()).ShouldBeEmpty("These tracked paths do not check out on every platform the tests run on.");
+
+    [Fact]
+    public void The_index_is_read() => TrackedPaths().ShouldContain("CodoMetis.TypeKit.slnx");
+
+    [Theory]
+    [InlineData("docs/a:b.md", "a character Windows refuses")]
+    [InlineData("docs/what?.md", "a character Windows refuses")]
+    [InlineData("docs/tab\there.md", "a character Windows refuses")]
+    [InlineData("docs/back\\slash.md", "a character Windows refuses")]
+    [InlineData("docs/trailing.", "ends in a dot or a space")]
+    [InlineData("docs/trailing /x.md", "ends in a dot or a space")]
+    [InlineData("docs/con.md", "a device name Windows reserves")]
+    [InlineData("src/LPT1/x.cs", "a device name Windows reserves")]
+    [InlineData("docs/Aux", "a device name Windows reserves")]
+    public void A_name_Windows_refuses_is_found(string path, string problem) =>
+        Problems([path]).ShouldContain(found => found.Contains(problem, StringComparison.Ordinal));
+
+    [Fact]
+    public void Two_names_that_differ_only_in_case_are_found() =>
+        Problems(["docs/Guide.md", "docs/guide.md"]).ShouldContain(found => found.Contains("the same name to a case-insensitive", StringComparison.Ordinal));
+
+    [Fact]
+    public void Two_directories_that_differ_only_in_case_are_found() =>
+        Problems(["Docs/a.md", "docs/b.md"]).ShouldContain(found => found.Contains("Docs", StringComparison.Ordinal) && found.Contains("docs", StringComparison.Ordinal));
+
+    [Fact]
+    public void Two_names_that_differ_only_in_normalization_are_found() =>
+        Problems(["docs/caf\u00e9.md", "docs/cafe\u0301.md"]).ShouldNotBeEmpty();
+
+    [Fact]
+    public void A_path_too_long_is_found() =>
+        Problems([$"docs/{new string('a', LongestPath)}.md"]).ShouldContain(found => found.Contains("characters long", StringComparison.Ordinal));
+
+    [Theory]
+    [InlineData("docs/console.md")]
+    [InlineData("docs/a.b.c.md")]
+    [InlineData(".github/workflows/dotnet.yml")]
+    [InlineData("design/adr/0113-ci-runs-the-lanes-a-change-can-affect.md")]
+    public void An_ordinary_name_passes(string path) => Problems([path]).ShouldBeEmpty();
+
+    private static List<string> Problems(IReadOnlyList<string> paths)
+    {
+        var problems = new List<string>();
+        foreach (var path in paths)
+        {
+            if (path.Length > LongestPath)
+                problems.Add($"{path} is {path.Length} characters long, over {LongestPath}: with a checkout's own directory it passes Windows' MAX_PATH");
+
+            foreach (var segment in path.Split('/'))
+            {
+                if (segment.Any(c => c < ' ' || "<>:\"|?*\\".Contains(c)))
+                    problems.Add($"{path} holds a character Windows refuses in a file name (<>:\"|?*\\ or a control character)");
+                if (segment.EndsWith('.') || segment.EndsWith(' '))
+                    problems.Add($"{path}: '{segment}' ends in a dot or a space, which Windows drops");
+                if (DeviceName().IsMatch(segment))
+                    problems.Add($"{path}: '{segment}' is a device name Windows reserves, with any extension");
+            }
+        }
+
+        var names = new Dictionary<string, string>(StringComparer.Ordinal);
+        foreach (var name in paths.SelectMany(Prefixes).Distinct(StringComparer.Ordinal))
+        {
+            var folded = name.Normalize(NormalizationForm.FormC).ToUpperInvariant();
+            if (names.TryGetValue(folded, out var other))
+                problems.Add($"{other} and {name} are the same name to a case-insensitive or normalizing file system (Windows, macOS)");
+            else
+                names[folded] = name;
+        }
+
+        return problems;
+    }
+
+    // The path and each directory above it: two directories that differ in case collide as two files do.
+    private static IEnumerable<string> Prefixes(string path)
+    {
+        for (var slash = path.IndexOf('/'); slash > 0; slash = path.IndexOf('/', slash + 1)) yield return path[..slash];
+        yield return path;
+    }
+
+    private static List<string> TrackedPaths()
+    {
+        using var process = Process.Start(new ProcessStartInfo("git", ["-C", Repository.Root, "-c", "core.quotePath=false", "ls-files", "-z"])
+        {
+            RedirectStandardOutput = true,
+            RedirectStandardError  = true,
+            StandardOutputEncoding = Encoding.UTF8,
+        })!;
+
+        var errors = process.StandardError.ReadToEndAsync();
+        var output = process.StandardOutput.ReadToEnd();
+        process.WaitForExit();
+
+        process.ExitCode.ShouldBe(0, $"git ls-files failed: {errors.Result}");
+        return [.. output.Split('\0', StringSplitOptions.RemoveEmptyEntries)];
+    }
+
+    [GeneratedRegex(@"^(CON|PRN|AUX|NUL|COM[0-9]|LPT[0-9])(\..*)?$", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
+    private static partial Regex DeviceName();
+}
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/ProbeCiteTests.cs b/test/CodoMetis.TypeKit.Conventions.Tests/ProbeCiteTests.cs
deleted file mode 100644
index de7969a7..00000000
--- a/test/CodoMetis.TypeKit.Conventions.Tests/ProbeCiteTests.cs
+++ /dev/null
@@ -1,135 +0,0 @@
-using System.Text.Json.Nodes;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-
-namespace CodoMetis.TypeKit.Conventions.Tests;
-
-/// <summary>
-/// Every reason a check gives for not applying or for meeting a refusal is cited, and what it cites exists: in the
-/// probe corpus, the first argument of a check's <c>Inapplicable</c> or <c>Refused</c> is a <c>Cite</c> factory
-/// (<c>NotPromised</c>, <c>Docs</c>, <c>Fact</c>, <c>Record</c>) called with a string literal, and a
-/// <c>NotPromised</c> id is a not-promised entry of the probe's claim (of any claim, for a harness source no one
-/// probe owns), a <c>Docs</c> source names a file of the repository, a <c>Fact</c> an entry under design/knowledge/
-/// and a <c>Record</c> a file under design/adr/.
-/// </summary>
-/// <remarks>
-/// The factories check the form when a check runs; this holds, before any build, that an excuse names a reason a
-/// reader can find. `prober register` and `publish` hold the same for the staged sources (SourceLint). It reads
-/// syntax, so a call in a comment or a string does not count, and the positive control finds each rule's defect. No
-/// floor yet: no probe calls a check's <c>Inapplicable</c> or <c>Refused</c> until the conversion that starts
-/// with the per-check evidence.
-/// </remarks>
-public sealed class ProbeCiteTests
-{
-    private static string Corpus => Path.Combine(Repository.Root, "tools", "probe", "corpus");
-
-    [Fact]
-    public void Every_citation_in_the_corpus_is_a_factory_with_a_literal_naming_what_exists()
-    {
-        var context = Context.Of(Repository.Root);
-        Directory.EnumerateFiles(Corpus, "*.cs", SearchOption.AllDirectories).Order(StringComparer.Ordinal)
-                 .SelectMany(path => Problems(Path.GetRelativePath(Repository.Root, path).Replace('\\', '/'), File.ReadAllText(path), context))
-                 .ShouldBeEmpty();
-    }
-
-    [Fact]
-    public void A_citation_built_from_text_or_naming_nothing_is_found()
-    {
-        const string source =
-            """
-            class P1Probe
-            {
-                string? Check(Check c, string x, Entry e)
-                {
-                    var refused = e.Refused();
-                    c.Inapplicable(Cite.NotPromised("c1-limit"), x);
-                    c.Refused(Cite.Docs("README.md#what-typekit-guarantees"));
-                    c.Refused(Cite.Fact("KB-001"));
-                    c.Inapplicable(Cite.Record("0094"), "detail");
-                    var cite = Cite.NotPromised("c1-limit");
-                    c.Inapplicable(cite);
-                    c.Refused(Cite.NotPromised("c1-" + x));
-                    c.Inapplicable(Cite.NotPromised("c2-limit"));
-                    c.Refused(Cite.Docs("docs/gone.md#a"));
-                    c.Refused(Cite.Fact("KB-999"));
-                    c.Inapplicable(Cite.Record("9999"));
-                    // c.Inapplicable(cite);
-                    var text = "c.Inapplicable(cite)";
-                    return null;
-                }
-            }
-            """;
-        var context = new Context(Repository.Root,
-            new Dictionary<string, string>(StringComparer.Ordinal) { ["P1Probe"] = "C1" },
-            new Dictionary<string, HashSet<string>>(StringComparer.Ordinal) { ["C1"] = ["c1-limit"], ["C2"] = ["c2-limit"] });
-        Problems("probes/P1Probe.cs", source, context).ShouldBe(
-        [
-            "probes/P1Probe.cs:11: Inapplicable(cite, ...) does not cite by a Cite factory with a string literal",
-            "probes/P1Probe.cs:12: Refused(Cite.NotPromised(\"c1-\" + x), ...) does not cite by a Cite factory with a string literal",
-            "probes/P1Probe.cs:13: Inapplicable(Cite.NotPromised(\"c2-limit\"), ...) names no not-promised entry of its claim C1",
-            "probes/P1Probe.cs:14: Refused(Cite.Docs(\"docs/gone.md#a\"), ...) names no file docs/gone.md in the repository",
-            "probes/P1Probe.cs:15: Refused(Cite.Fact(\"KB-999\"), ...) names no entry under design/knowledge/",
-            "probes/P1Probe.cs:16: Inapplicable(Cite.Record(\"9999\"), ...) names no record under design/adr/",
-        ]);
-        Problems("harness/Shared.cs", source.Replace("P1Probe", "Shared"), context)
-            .ShouldNotContain(p => p.Contains("c2-limit"), "a harness source no one probe owns may cite any claim's entry");
-    }
-
-    /// <summary>The repository's files, each claim's not-promised ids, and the claim of each probe by its name and by the class its filter selects.</summary>
-    private sealed record Context(string Root, Dictionary<string, string> ClaimOf, Dictionary<string, HashSet<string>> NotPromised)
-    {
-        public static Context Of(string root)
-        {
-            var corpus = Path.Combine(root, "tools", "probe", "corpus");
-            var notPromised = new Dictionary<string, HashSet<string>>(StringComparer.Ordinal);
-            foreach (var claim in JsonNode.Parse(File.ReadAllText(Path.Combine(corpus, "claims.json")))!.AsArray().OfType<JsonObject>())
-                notPromised[claim["id"]!.GetValue<string>()] = [.. (claim["not-promised"] as JsonArray ?? []).Select(n => n!["id"]!.GetValue<string>())];
-            var claimOf = new Dictionary<string, string>(StringComparer.Ordinal);
-            foreach (var (name, entry) in JsonNode.Parse(File.ReadAllText(Path.Combine(corpus, "registry.json")))!["probes"]!.AsObject())
-            {
-                var claim = entry!["claim"]!.GetValue<string>();
-                claimOf[name] = claim;
-                if (entry["filter"]?.GetValue<string>().TrimStart('*') is { Length: > 0 } cls) claimOf.TryAdd(cls, claim);
-            }
-            return new Context(root, claimOf, notPromised);
-        }
-    }
-
-    private static IEnumerable<string> Problems(string path, string text, Context context)
-    {
-        var claim = context.ClaimOf.GetValueOrDefault(Path.GetFileNameWithoutExtension(path));
-        foreach (var call in CSharpSyntaxTree.ParseText(text).GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>())
-        {
-            if (call.Expression is not MemberAccessExpressionSyntax { Name.Identifier.ValueText: var method and ("Inapplicable" or "Refused") }) continue;
-            var arguments = call.ArgumentList.Arguments;
-            if (arguments.Count == 0) continue;   // an entry's own Refused() of the harness, not a check's
-            var line = call.GetLocation().GetLineSpan().StartLinePosition.Line + 1;
-            var shown = $"{path}:{line}: {method}({arguments[0]}, ...)";
-            if (arguments[0].Expression is not InvocationExpressionSyntax
-                {
-                    Expression: MemberAccessExpressionSyntax { Expression: IdentifierNameSyntax { Identifier.ValueText: "Cite" }, Name.Identifier.ValueText: var factory and ("NotPromised" or "Docs" or "Fact" or "Record") },
-                    ArgumentList.Arguments: [{ Expression: LiteralExpressionSyntax literal }],
-                } || !literal.IsKind(SyntaxKind.StringLiteralExpression))
-            {
-                yield return $"{shown} does not cite by a Cite factory with a string literal";
-                continue;
-            }
-            var value = literal.Token.ValueText;
-            var missing = factory switch
-            {
-                "NotPromised" when claim is not null => context.NotPromised.GetValueOrDefault(claim)?.Contains(value) ?? false ? null : $"names no not-promised entry of its claim {claim}",
-                "NotPromised" => context.NotPromised.Values.Any(ids => ids.Contains(value)) ? null : "names no not-promised entry of any claim",
-                "Docs" => value.Split('#')[0] is var file && file.Length > 0 && !file.Contains("..", StringComparison.Ordinal) && File.Exists(Path.Combine(context.Root, file))
-                    ? null : $"names no file {value.Split('#')[0]} in the repository",
-                "Fact" => Named(Path.Combine(context.Root, "design", "knowledge"), value) ? null : "names no entry under design/knowledge/",
-                _ => Named(Path.Combine(context.Root, "design", "adr"), value) ? null : "names no record under design/adr/",
-            };
-            if (missing is not null) yield return $"{shown} {missing}";
-        }
-    }
-
-    private static bool Named(string directory, string id) =>
-        id.Length > 0 && Directory.Exists(directory)
-        && Directory.EnumerateFiles(directory, "*.md").Any(f => Path.GetFileName(f).StartsWith(id + "-", StringComparison.Ordinal) || Path.GetFileName(f) == id + ".md");
-}
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/ProbeMessageTextTests.cs b/test/CodoMetis.TypeKit.Conventions.Tests/ProbeMessageTextTests.cs
deleted file mode 100644
index c0e67120..00000000
--- a/test/CodoMetis.TypeKit.Conventions.Tests/ProbeMessageTextTests.cs
+++ /dev/null
@@ -1,148 +0,0 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-
-namespace CodoMetis.TypeKit.Conventions.Tests;
-
-/// <summary>
-/// No probe decides how a row ends by the words of a message, except to fail it: in the probe corpus (harness and probes), a
-/// <c>.Message.Contains(</c>, <c>StartsWith(</c>, <c>EndsWith(</c> or <c>IndexOf(</c> stands only in the condition of a failure text,
-/// an <c>if</c> whose branch returns one or raises a harness error, or a <c>?:</c> between <c>null</c> and one. A refusal the framework
-/// makes on its own is shown by side (1) of the three-sided differential (the harness's <c>Sides</c>), compared by its type and stage;
-/// an intended difference by a citation. A message read to excuse a row, the substring excuse decision 99 retired, is refused here.
-/// </summary>
-/// <remarks>
-/// It reads syntax, as <see cref="ProbeNoteKeyTests"/> does: a lambda inside the condition counts as the condition (<c>errors.Any(e =>
-/// e.Message.StartsWith(...))</c>), an assignment, a <c>catch ... when</c> or a branch that passes does not. The EF family stays
-/// two-sided in WS2's last step and is not changed by it: its one excuse by a message is listed in <see cref="Kept"/> with its reason,
-/// and a listed site that no longer reads a message fails, so the list cannot outlive it.
-/// </remarks>
-public sealed class ProbeMessageTextTests
-{
-    private static string Corpus => Path.Combine(Repository.Root, "tools", "probe", "corpus");
-
-    private static readonly string[] Reads = ["Contains", "StartsWith", "EndsWith", "IndexOf"];
-
-    /// <summary>The sites kept, by file, each with why: the EF family is two-sided by decision of WS2's last step.</summary>
-    private static readonly Dictionary<string, string> Kept = new()
-    {
-        ["tools/probe/corpus/probes/E06OwnConverterNoValueProbe.cs"] =
-            "EF stays two-sided in WS2's last step: EF's 'could not be translated' refusal is matched by its words until the EF family gets its side (1)",
-    };
-
-    [Fact]
-    public void The_corpus_reads_of_a_message_are_found() =>
-        Sources().Sum(source => Sites(source.Text).Count()).ShouldBeGreaterThanOrEqualTo(30,
-            "the corpus read a message's words at 33 places when this rule was written (WS2's three-sided differential), all but the one EF site a failure's condition");
-
-    [Fact]
-    public void No_message_text_decides_a_row_but_a_failure() =>
-        Sources().Where(source => !Kept.ContainsKey(source.Path)).SelectMany(source => Problems(source.Path, source.Text)).ShouldBeEmpty();
-
-    [Fact]
-    public void Each_kept_site_still_reads_a_message_outside_a_failure() =>
-        Kept.Keys.Where(path => !Problems(path, File.ReadAllText(Path.Combine(Repository.Root, path))).Any()).ShouldBeEmpty();
-
-    [Fact]
-    public void A_message_read_to_excuse_a_row_is_found()
-    {
-        const string source =
-            """
-            class P
-            {
-                string? Check(Check c, Exception x, Exception? y, string[] names)
-                {
-                    if (x.Message.Contains("maximum allowed depth")) { c.Note(NoteKeys.StjMaxdepth); return null; }
-                    if (!x.Message.Contains("Refused")) return $"does not name the fault: {x.Message}";
-                    if (x.InnerException is { } i && i.Message.Contains("secret")) return "inner quotes the input";
-                    if (!x.Message.StartsWith("V") || x.Message.EndsWith(".")) return "not named: " + x.Message;
-                    if (names.Any(n => !x.Message.Contains(n))) { r.Outcome("harness-error", "not named"); return null; }
-                    var named = x.Message.Contains("V");
-                    try { throw x; } catch (Exception e) when (e.Message.Contains("could not be translated")) { return null; }
-                    var missing = names.Where(n => !x.Message.Contains(n)).ToList();
-                    return x.Message.Contains("V") ? null : $"not named: {x.Message}";
-                    // x.Message.Contains("in a comment") is no call
-                }
-            }
-            """;
-        Problems("P.cs", source).ShouldBe(
-        [
-            "P.cs:5: x.Message.Contains(\"maximum allowed depth\") decides a row by a message's words outside a failure",
-            "P.cs:10: x.Message.Contains(\"V\") decides a row by a message's words outside a failure",
-            "P.cs:11: e.Message.Contains(\"could not be translated\") decides a row by a message's words outside a failure",
-            "P.cs:12: x.Message.Contains(n) decides a row by a message's words outside a failure",
-        ]);
-    }
-
-    private static List<(string Path, string Text)> Sources() =>
-    [
-        .. Directory.EnumerateFiles(Corpus, "*.cs", SearchOption.AllDirectories)
-                    .Order(StringComparer.Ordinal)
-                    .Select(path => (Path.GetRelativePath(Repository.Root, path).Replace('\\', '/'), File.ReadAllText(path)))
-    ];
-
-    /// <summary>Every <c>X.Message.Contains(...)</c> and its kin in a source.</summary>
-    private static IEnumerable<InvocationExpressionSyntax> Sites(string text) =>
-        CSharpSyntaxTree.ParseText(text).GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>()
-                        .Where(call => call.Expression is MemberAccessExpressionSyntax
-                        {
-                            Name.Identifier.ValueText: var read,
-                            Expression: MemberAccessExpressionSyntax { Name.Identifier.ValueText: "Message" },
-                        } && Reads.Contains(read));
-
-    private static IEnumerable<string> Problems(string path, string text)
-    {
-        foreach (var call in Sites(text))
-            if (!InAFailuresCondition(call))
-                yield return $"{path}:{call.GetLocation().GetLineSpan().StartLinePosition.Line + 1}: {call} decides a row by a message's words outside a failure";
-    }
-
-    /// <summary>
-    /// The read stands in the condition of an <c>if</c> whose branch fails the row (returns a failure text, or raises a harness error), or
-    /// of a <c>?:</c> between <c>null</c> and a failure text. A lambda on the way up is part of that condition.
-    /// </summary>
-    private static bool InAFailuresCondition(SyntaxNode read)
-    {
-        for (var node = read; node.Parent is { } parent; node = parent)
-        {
-            switch (parent)
-            {
-                case IfStatementSyntax branch when branch.Condition == node:
-                    return Fails(branch.Statement);
-                case ConditionalExpressionSyntax choice when choice.Condition == node:
-                    return (IsNull(choice.WhenTrue) && IsFailure(choice.WhenFalse)) || (IsNull(choice.WhenFalse) && IsFailure(choice.WhenTrue));
-                case StatementSyntax:
-                case CatchFilterClauseSyntax:
-                    return false;
-            }
-        }
-
-        return false;
-    }
-
-    /// <summary>A branch that fails the row: it returns a failure text, or raises a harness error, first.</summary>
-    private static bool Fails(StatementSyntax statement) => statement switch
-    {
-        ReturnStatementSyntax { Expression: { } returned } => IsFailure(returned),
-        BlockSyntax { Statements: [var first, ..] } => Fails(first),
-        ExpressionStatementSyntax { Expression: InvocationExpressionSyntax raise } => RaisesAHarnessError(raise),
-        _ => false,
-    };
-
-    private static bool RaisesAHarnessError(InvocationExpressionSyntax call) =>
-        call.Expression is MemberAccessExpressionSyntax { Name.Identifier.ValueText: "Outcome" }
-        && call.ArgumentList.Arguments is [{ Expression: LiteralExpressionSyntax { Token.ValueText: "harness-error" } }, ..];
-
-    /// <summary>A failure text: a string, an interpolated one, a concatenation with one, or a <c>?:</c> one of whose branches is one.</summary>
-    private static bool IsFailure(ExpressionSyntax expression) => expression switch
-    {
-        LiteralExpressionSyntax literal => literal.IsKind(SyntaxKind.StringLiteralExpression),
-        InterpolatedStringExpressionSyntax => true,
-        BinaryExpressionSyntax add when add.IsKind(SyntaxKind.AddExpression) => IsFailure(add.Left) || IsFailure(add.Right),
-        ConditionalExpressionSyntax choice => IsFailure(choice.WhenTrue) || IsFailure(choice.WhenFalse),
-        ParenthesizedExpressionSyntax inner => IsFailure(inner.Expression),
-        _ => false,
-    };
-
-    private static bool IsNull(ExpressionSyntax expression) => expression.IsKind(SyntaxKind.NullLiteralExpression);
-}
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/ProbeNoteKeyTests.cs b/test/CodoMetis.TypeKit.Conventions.Tests/ProbeNoteKeyTests.cs
deleted file mode 100644
index 8876ae13..00000000
--- a/test/CodoMetis.TypeKit.Conventions.Tests/ProbeNoteKeyTests.cs
+++ /dev/null
@@ -1,94 +0,0 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-
-namespace CodoMetis.TypeKit.Conventions.Tests;
-
-/// <summary>
-/// Every note a probe makes names a key of the catalogue, and every skip names its finding as written
-/// (decision 103): in the probe corpus, the first argument of a <c>Note</c> call is a member of
-/// <c>NoteKeys</c>, and the first argument of a two-argument <c>Skip</c> (the harness's, not LINQ's) is a
-/// string literal.
-/// </summary>
-/// <remarks>
-/// The compiler already refuses a note key outside the catalogue, since <c>NoteKeys</c> has a private
-/// constructor; this holds the shape for the sources the replay overlays, before any build, and for
-/// <c>Skip</c>, whose finding id stays a string. It reads syntax, so a call in a comment or a string does
-/// not count, and the positive control and the floor keep it from passing because the walker stopped
-/// finding anything.
-/// </remarks>
-public sealed class ProbeNoteKeyTests
-{
-    private static string Corpus => Path.Combine(Repository.Root, "tools", "probe", "corpus");
-
-    [Fact]
-    public void The_corpus_notes_are_found() =>
-        Calls(Sources()).Count(c => c.Method == "Note").ShouldBeGreaterThanOrEqualTo(100,
-            "the corpus made 136 notes when this rule was written, 127 once the http family's outcome notes became checks' citations (WS2 step 4), " +
-            "and 119 at WS2's close, where every note is a pass key or framework-refuses");
-
-    [Fact]
-    public void Every_note_and_skip_in_the_corpus_names_its_key_as_written() =>
-        Sources().SelectMany(source => Problems(source.Path, source.Text)).ShouldBeEmpty();
-
-    [Fact]
-    public void A_key_or_a_finding_built_from_text_is_found()
-    {
-        const string source =
-            """
-            class P
-            {
-                void Check(Row r, string x)
-                {
-                    r.Note("msg:" + x, "detail");
-                    r.Note(NoteKeys.Compared, "fine");
-                    r.Skip("F" + x, "why");
-                    r.Skip("F7", "fine");
-                    var rest = new[] { 1, 2 }.Skip(x.Length);
-                    // r.Note("in a comment", x);
-                }
-            }
-            """;
-        Problems("P.cs", source).ShouldBe(
-        [
-            "P.cs:5: Note(\"msg:\" + x, ...) does not name a key of NoteKeys",
-            "P.cs:7: Skip(\"F\" + x, ...) does not name its finding as a string literal",
-        ]);
-    }
-
-    private static List<(string Path, string Text)> Sources() =>
-    [
-        .. Directory.EnumerateFiles(Corpus, "*.cs", SearchOption.AllDirectories)
-                    .Order(StringComparer.Ordinal)
-                    .Select(path => (Path.GetRelativePath(Repository.Root, path).Replace('\\', '/'), File.ReadAllText(path)))
-    ];
-
-    private static IEnumerable<(string Method, InvocationExpressionSyntax Call)> Calls(IEnumerable<(string Path, string Text)> sources) =>
-        sources.SelectMany(source => Calls(source.Text));
-
-    private static IEnumerable<(string Method, InvocationExpressionSyntax Call)> Calls(string text) =>
-        CSharpSyntaxTree.ParseText(text).GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>()
-                        .Select(call => (Method: call.Expression switch
-                        {
-                            MemberAccessExpressionSyntax member => member.Name.Identifier.ValueText,
-                            IdentifierNameSyntax name => name.Identifier.ValueText,
-                            _ => "",
-                        }, Call: call))
-                        .Where(c => c.Method is "Note" or "Skip");
-
-    private static IEnumerable<string> Problems(string path, string text)
-    {
-        foreach (var (method, call) in Calls(text))
-        {
-            var arguments = call.ArgumentList.Arguments;
-            var line = call.GetLocation().GetLineSpan().StartLinePosition.Line + 1;
-            if (method == "Note" && arguments.Count > 0 && !IsCatalogueKey(arguments[0].Expression))
-                yield return $"{path}:{line}: Note({arguments[0]}, ...) does not name a key of NoteKeys";
-            if (method == "Skip" && arguments.Count == 2 && !arguments[0].Expression.IsKind(SyntaxKind.StringLiteralExpression))
-                yield return $"{path}:{line}: Skip({arguments[0]}, ...) does not name its finding as a string literal";
-        }
-    }
-
-    private static bool IsCatalogueKey(ExpressionSyntax expression) =>
-        expression is MemberAccessExpressionSyntax { Expression: IdentifierNameSyntax { Identifier.ValueText: "NoteKeys" } };
-}
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/ProbeRowsTests.cs b/test/CodoMetis.TypeKit.Conventions.Tests/ProbeRowsTests.cs
deleted file mode 100644
index 4d424afd..00000000
--- a/test/CodoMetis.TypeKit.Conventions.Tests/ProbeRowsTests.cs
+++ /dev/null
@@ -1,103 +0,0 @@
-using System.IO.Compression;
-using System.Text.Json.Nodes;
-
-namespace CodoMetis.TypeKit.Conventions.Tests;
-
-/// <summary>
-/// The probe corpus keeps its rows per probe (<c>tools/probe/corpus/rows/&lt;probe&gt;.json.gz</c>): every registered
-/// probe has a rows file named for it, each file names its probe's claim, a claim of <c>claims.json</c>, and no two rows of
-/// one file have the same axis map.
-/// </summary>
-/// <remarks>
-/// A shared rows file tied two probes of a claim together, so rows appended for one changed the other's identity, and
-/// appending instead of regenerating left duplicates (C02 42 of 88, C20 90 of 351), each a row run again for nothing. A
-/// rows file named for no registered probe is a leftover no replay runs. The positive control holds each rule to finding
-/// its defect, and the floor keeps the walker from passing by finding no file.
-/// </remarks>
-public sealed class ProbeRowsTests
-{
-    private static string Corpus => Path.Combine(Repository.Root, "tools", "probe", "corpus");
-
-    [Fact]
-    public void The_rows_files_are_found() =>
-        RowsFiles().Count.ShouldBeGreaterThanOrEqualTo(43, "the corpus had a rows file for each of its 43 probes when this rule was written");
-
-    [Fact]
-    public void Every_probe_has_rows_of_its_own_each_axis_map_once() =>
-        Problems(RowsFiles(), Claims(), Registry()).ShouldBeEmpty();
-
-    [Fact]
-    public void A_duplicate_row_a_wrong_claim_a_leftover_file_and_a_probe_without_rows_are_found()
-    {
-        static Dictionary<string, string> Row(string x, string y) => new(StringComparer.Ordinal) { ["x"] = x, ["y"] = y };
-        var files = new Dictionary<string, (string? Claim, List<Dictionary<string, string>> Rows)>(StringComparer.Ordinal)
-        {
-            ["P"] = ("C1", [Row("1", "1"), Row("1", "2"), new(StringComparer.Ordinal) { ["y"] = "1", ["x"] = "1" }]),
-            ["Q"] = ("C9", [Row("1", "1")]),
-            ["R"] = ("C1", [Row("1", "1")]),
-            ["Old"] = ("C1", [Row("2", "2")]),
-            ["N"] = (null, [Row("2", "2")]),
-        };
-        var registry = new Dictionary<string, string>(StringComparer.Ordinal) { ["P"] = "C1", ["Q"] = "C9", ["R"] = "C2", ["N"] = "C1", ["S"] = "C1" };
-        Problems(files, new HashSet<string>(StringComparer.Ordinal) { "C1", "C2" }, registry).ShouldBe(
-        [
-            "rows/N.json.gz names no claim",
-            "rows/Old.json.gz names no registered probe",
-            "rows/P.json.gz: row 2 has the axis map of row 0",
-            "rows/Q.json.gz names claim C9, which claims.json does not have",
-            "rows/R.json.gz names claim C1, but its probe R is a probe of C2",
-            "S is a registered probe without a rows file (rows/S.json.gz)",
-        ]);
-    }
-
-    /// <summary>Every rule's problems, in ordinal order: files by name, then the probes without a file.</summary>
-    private static List<string> Problems(IReadOnlyDictionary<string, (string? Claim, List<Dictionary<string, string>> Rows)> files,
-                                         IReadOnlySet<string> claims, IReadOnlyDictionary<string, string> registry)
-    {
-        var problems = new List<string>();
-        foreach (var (probe, (claim, rows)) in files.OrderBy(f => f.Key, StringComparer.Ordinal))
-        {
-            var name = $"rows/{probe}.json.gz";
-            if (claim is null) problems.Add($"{name} names no claim");
-            else if (!claims.Contains(claim)) problems.Add($"{name} names claim {claim}, which claims.json does not have");
-            if (!registry.TryGetValue(probe, out var registered)) problems.Add($"{name} names no registered probe");
-            else if (claim is not null && claims.Contains(claim) && registered != claim) problems.Add($"{name} names claim {claim}, but its probe {probe} is a probe of {registered}");
-            var first = new Dictionary<string, int>(StringComparer.Ordinal);
-            for (var i = 0; i < rows.Count; i++)
-            {
-                var key = string.Join("\n", rows[i].OrderBy(kv => kv.Key, StringComparer.Ordinal).Select(kv => kv.Key + "=" + kv.Value));
-                if (first.TryGetValue(key, out var earlier)) problems.Add($"{name}: row {i} has the axis map of row {earlier}");
-                else first[key] = i;
-            }
-        }
-        foreach (var probe in registry.Keys.Where(p => !files.ContainsKey(p)).Order(StringComparer.Ordinal))
-            problems.Add($"{probe} is a registered probe without a rows file (rows/{probe}.json.gz)");
-        return problems;
-    }
-
-    /// <summary>Every rows file of the corpus by its probe's name, with the claim it names and its rows' axis maps.</summary>
-    private static Dictionary<string, (string? Claim, List<Dictionary<string, string>> Rows)> RowsFiles()
-    {
-        var files = new Dictionary<string, (string?, List<Dictionary<string, string>>)>(StringComparer.Ordinal);
-        foreach (var path in Directory.EnumerateFiles(Path.Combine(Corpus, "rows")).Order(StringComparer.Ordinal))
-        {
-            var name = Path.GetFileName(path);
-            name.ShouldEndWith(".json.gz", Case.Sensitive, $"rows/{name}: the corpus keeps its rows gzipped, one file per probe");
-            using var gz = new GZipStream(File.OpenRead(path), CompressionMode.Decompress);
-            var document = JsonNode.Parse(gz)!;
-            var claim = document["claim"] is JsonValue c && c.TryGetValue<string>(out var s) ? s : null;
-            var rows = document["rows"]!.AsArray()
-                                        .Select(r => r!["row"]!.AsObject().ToDictionary(kv => kv.Key, kv => kv.Value!.GetValue<string>(), StringComparer.Ordinal))
-                                        .ToList();
-            files[name[..^".json.gz".Length]] = (claim, rows);
-        }
-        return files;
-    }
-
-    private static HashSet<string> Claims() =>
-        [.. JsonNode.Parse(File.ReadAllText(Path.Combine(Corpus, "claims.json")))!.AsArray().Select(c => c!["id"]!.GetValue<string>())];
-
-    private static Dictionary<string, string> Registry() =>
-        JsonNode.Parse(File.ReadAllText(Path.Combine(Corpus, "registry.json")))!["probes"]!.AsObject()
-                .ToDictionary(kv => kv.Key, kv => kv.Value!["claim"]!.GetValue<string>(), StringComparer.Ordinal);
-}
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/ProseReaderTests.cs b/test/CodoMetis.TypeKit.Conventions.Tests/ProseReaderTests.cs
new file mode 100644
index 00000000..97f85eef
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Conventions.Tests/ProseReaderTests.cs
@@ -0,0 +1,119 @@
+using System.Text.Json;
+using System.Text.RegularExpressions;
+
+namespace CodoMetis.TypeKit.Conventions.Tests;
+
+/// <summary>
+/// A prose-only change builds and runs only the test projects of <c>test/Prose.slnf</c> (design/adr/0113). So no test
+/// project outside it may read prose: a file under <c>docs/</c>, <c>design/</c>, <c>site/</c> or <c>.github/</c>, or a
+/// Markdown file outside <c>src/</c>. One that did would go untested by the very change that breaks it, silently.
+/// </summary>
+/// <remarks>
+/// Read from the sources, by the string literals that name such a path: <c>"docs"</c>, <c>"design"</c>,
+/// <c>"site"</c>, <c>".github"</c>, a literal starting with one of them and a slash, and one ending in <c>.md</c>. A
+/// package's README is not prose (the selection classes it with its package), so <c>"README.md"</c> passes in a file
+/// that also names <c>"src"</c>, as <c>Path.Combine(root, "src", package, "README.md")</c> does, and a literal holding <c>src/</c> passes.
+/// A literal that names such a path without reading it is waived below, with the reason.
+/// </remarks>
+public sealed partial class ProseReaderTests
+{
+    private const string Filter = "test/Prose.slnf";
+
+    /// <summary>Files whose prose-shaped literals are not reads, each with the reason.</summary>
+    private static readonly Dictionary<string, string> Waived = new(StringComparer.Ordinal)
+    {
+        ["test/CodoMetis.TypeKit.CiLanes.Tests/SelectionTests.cs"] = "paths handed to the classifier and written into a throwaway repository",
+        ["test/CodoMetis.TypeKit.BashGuard.Tests/GuardTests.cs"] = "command lines the guard judges, never run",
+        ["test/CodoMetis.TypeKit.CiLanes.Tests/GateTests.cs"] = "a job named docs the gate must refuse, and a summary file in the sandbox",
+        ["test/CodoMetis.TypeKit.PrHygiene.Tests/HygieneTests.cs"] = "branch names such as docs/plain-voice, which name no file",
+    };
+
+    private static IReadOnlyList<string> ProseProjects()
+    {
+        using var filter = JsonDocument.Parse(File.ReadAllText(Path.Combine(Repository.Root, Filter)));
+        return
+        [
+            .. filter.RootElement.GetProperty("solution").GetProperty("projects").EnumerateArray()
+                     .Select(project => Path.GetDirectoryName(project.GetString()!)!.Replace('\\', '/'))
+        ];
+    }
+
+    [Fact]
+    public void The_prose_suite_holds_the_projects_that_read_the_documents()
+    {
+        var projects = ProseProjects();
+
+        foreach (var project in projects)
+            Directory.Exists(Path.Combine(Repository.Root, project)).ShouldBeTrue($"{Filter} names {project}, which does not exist.");
+        projects.ShouldContain("test/CodoMetis.TypeKit.Conventions.Tests", $"{Filter} lost the conventions tests, which read every document's links.");
+        projects.ShouldContain("test/CodoMetis.TypeKit.Samples", $"{Filter} lost the samples, which compile the documents' code blocks.");
+    }
+
+    [Fact]
+    public void No_test_project_outside_the_prose_suite_reads_prose()
+    {
+        var prose = ProseProjects().ToHashSet(StringComparer.Ordinal);
+        var readers = new List<string>();
+
+        foreach (var project in Directory.GetDirectories(Path.Combine(Repository.Root, "test")))
+        {
+            var relative = Path.GetRelativePath(Repository.Root, project).Replace('\\', '/');
+            if (prose.Contains(relative) || Directory.GetFiles(project, "*.csproj").Length == 0) continue;
+
+            foreach (var file in SourceFiles(project))
+            {
+                var path = Path.GetRelativePath(Repository.Root, file).Replace('\\', '/');
+                if (Waived.ContainsKey(path)) continue;
+
+                var found = Prose(File.ReadAllText(file)).ToList();
+                if (found.Count > 0) readers.Add($"{path} ({string.Join(", ", found)})");
+            }
+        }
+
+        readers.ShouldBeEmpty(
+            $"These test sources name prose, which a prose-only change does not run them for. Add their project to {Filter}, " +
+            "or waive the file in ProseReaderTests.Waived with the reason it reads nothing.");
+    }
+
+    [Theory]
+    [InlineData("""File.ReadAllText(Path.Combine(root, "docs", "json.md"));""", true)]
+    [InlineData("""var page = "design/adr/README.md";""", true)]
+    [InlineData("""Path.Combine(root, ".github", "workflows", "dotnet.yml")""", true)]
+    [InlineData("""Path.Combine(root, "site", "toc.yml")""", true)]
+    [InlineData("""Path.Combine(root, "CHANGELOG.md")""", true)]
+    [InlineData("""Path.Combine(root, "README.md")""", true)]
+    [InlineData("""Path.Combine(root, "src", "CodoMetis.TypeKit", "README.md")""", false)]
+    [InlineData("""const string Link = "https://github.com/o/r/blob/main/src/CodoMetis.TypeKit.Analyzers/README.md";""", false)]
+    [InlineData("""rule.HelpLinkUri.ShouldEndWith("README.md#cmtk0014");""", false)]
+    [InlineData("""var name = "documented";""", false)]
+    public void A_literal_that_names_prose_is_found(string source, bool reads) =>
+        Prose(source).Any().ShouldBe(reads);
+
+    private static IEnumerable<string> Prose(string source)
+    {
+        var literals = Literal().Matches(source).Select(match => match.Groups["text"].Value).ToList();
+        var namesSrc = literals.Contains("src");
+
+        foreach (var literal in literals)
+        {
+            var directory = literal is "docs" or "design" or "site" or ".github"
+                         || literal.StartsWith("docs/", StringComparison.Ordinal)
+                         || literal.StartsWith("design/", StringComparison.Ordinal)
+                         || literal.StartsWith("site/", StringComparison.Ordinal)
+                         || literal.StartsWith(".github/", StringComparison.Ordinal);
+            var markdown = literal.EndsWith(".md", StringComparison.OrdinalIgnoreCase)
+                        && !literal.Contains("src/", StringComparison.Ordinal)
+                        && !(literal == "README.md" && namesSrc);
+
+            if (directory || markdown) yield return $"\"{literal}\"";
+        }
+    }
+
+    private static IEnumerable<string> SourceFiles(string project) =>
+        Directory.EnumerateFiles(project, "*.cs", SearchOption.AllDirectories)
+                 .Where(file => !Path.GetRelativePath(project, file).Split(Path.DirectorySeparatorChar).Any(part => part is "bin" or "obj"));
+
+    // A regular string literal's text; a verbatim or raw one is matched as far as its first quote, which is enough for a path.
+    [GeneratedRegex(@"""(?<text>(?:[^""\\\r\n]|\\.)*)""")]
+    private static partial Regex Literal();
+}
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/ReadmeSampleTests.cs b/test/CodoMetis.TypeKit.Conventions.Tests/ReadmeSampleTests.cs
index 82b5727d..676e5d26 100644
--- a/test/CodoMetis.TypeKit.Conventions.Tests/ReadmeSampleTests.cs
+++ b/test/CodoMetis.TypeKit.Conventions.Tests/ReadmeSampleTests.cs
@@ -2,8 +2,9 @@ namespace CodoMetis.TypeKit.Conventions.Tests;
 
 /// <summary>
 /// Every C# block in the READMEs and the topic pages under <c>docs/</c> is compiled code: it equals,
-/// after indentation, exactly one sample region in <c>test/CodoMetis.TypeKit.Samples</c>, and every
-/// region there is shown in the page its name starts with. A README edit that is not mirrored in the samples fails here, and a sample that
+/// after indentation, exactly one sample region in <c>test/CodoMetis.TypeKit.Samples</c>, or in the sources a
+/// page names for itself (<see cref="ReadmeSamples.RegionSources"/>: the walkthrough's sample application),
+/// and every region is shown in the page its name starts with. A README edit that is not mirrored in the samples fails here, and a sample that
 /// stops compiling fails the build.
 /// </summary>
 /// <remarks>
@@ -44,6 +45,7 @@ public void The_docs_pages_are_discovered() =>
     [InlineData("README.md", "README")]
     [InlineData("src/CodoMetis.TypeKit.EntityFrameworkCore/README.md", "CodoMetis.TypeKit.EntityFrameworkCore")]
     [InlineData("docs/ef-core.md", "ef-core")]
+    [InlineData("docs/walkthrough.md", "walkthrough")]
     public void A_page_s_samples_are_named_after_it(string page, string prefix) => ReadmeSamples.Prefix(page).ShouldBe(prefix);
 
     /// <summary>
@@ -92,6 +94,36 @@ public void The_csharp_blocks_and_the_samples_are_discovered()
         Samples.Value.Count.ShouldBeGreaterThanOrEqualTo(30);
     }
 
+    /// <summary>
+    /// The walkthrough's sample application is found: a directory renamed would leave its page's blocks matching
+    /// nothing, which the theories report, but a page that lost its blocks with it would pass.
+    /// </summary>
+    [Fact]
+    public void Each_page_s_own_sources_hold_its_samples()
+    {
+        foreach (var (prefix, directory) in ReadmeSamples.RegionSources)
+        {
+            Directory.Exists(Path.Combine(Repository.Root, directory)).ShouldBeTrue($"{directory}, where the '{prefix}' samples live, does not exist.");
+            Samples.Value.Count(sample => sample.ReadmePrefix == prefix).ShouldBeGreaterThanOrEqualTo(10, $"{directory} holds too few '{prefix}/' samples.");
+        }
+    }
+
+    /// <summary>
+    /// A page's region lives in the sources its prefix names, and nowhere else: a walkthrough region in the samples
+    /// project would be compiled where the packed packages never build it, and a samples region among the
+    /// walkthrough's sources would be shipped to its consumer.
+    /// </summary>
+    [Theory]
+    [MemberData(nameof(SampleNames))]
+    public void A_sample_lives_in_the_sources_of_its_page(string name)
+    {
+        var sample = Samples.Value.Single(candidate => candidate.Name == name);
+        var expected = ReadmeSamples.SourcesOf(sample.ReadmePrefix);
+
+        sample.File.ShouldStartWith(expected + "/", Case.Sensitive,
+            $"'{name}' ({sample.Location}) belongs to the page '{sample.ReadmePrefix}', whose samples live in {expected}.");
+    }
+
     [Theory]
     [MemberData(nameof(CompiledBlocks))]
     public void A_csharp_block_in_a_README_is_a_compiled_sample(string location)
@@ -102,7 +134,7 @@ public void A_csharp_block_in_a_README_is_a_compiled_sample(string location)
         if (sample is null)
         {
             throw new ShouldAssertException(
-                $"{location} is not compiled: no sample in {ReadmeSamples.SamplesProject} holds this code. Mirror the change in the sample region, " +
+                $"{location} is not compiled: no sample in {ReadmeSamples.SourcesOf(ReadmeSamples.Prefix(block.Readme))} holds this code. Mirror the change in the sample region, " +
                 $"or mark a block that cannot compile on purpose with <!-- not compiled: {{reason}} --> above its fence.{Environment.NewLine}" +
                 Closest(block.Code, Samples.Value.Select(candidate => (candidate.Name + " at " + candidate.Location, candidate.Code)), "sample", "README"));
         }
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/ReadmeSamples.cs b/test/CodoMetis.TypeKit.Conventions.Tests/ReadmeSamples.cs
index ab771ab8..f43d92b9 100644
--- a/test/CodoMetis.TypeKit.Conventions.Tests/ReadmeSamples.cs
+++ b/test/CodoMetis.TypeKit.Conventions.Tests/ReadmeSamples.cs
@@ -42,6 +42,19 @@ internal static partial class ReadmeSamples
 
     public const string DocsDirectory = "docs";
 
+    /// <summary>
+    /// The pages whose regions live outside the samples project, each with the directory that holds them. The
+    /// walkthrough's are the sources of the smoke test's <c>walkthrough</c> consumer: a sample application that
+    /// the packed packages build and run, and whose answers the page states.
+    /// </summary>
+    public static readonly IReadOnlyDictionary<string, string> RegionSources = new Dictionary<string, string>(StringComparer.Ordinal)
+    {
+        ["walkthrough"] = "tools/ConsumerSmokeTest/Consumers/walkthrough",
+    };
+
+    /// <summary>Where the regions of the page with this prefix live: its own sources, or the samples project.</summary>
+    public static string SourcesOf(string prefix) => RegionSources.GetValueOrDefault(prefix, SamplesProject);
+
     /// <summary>
     /// Every page whose C# is compiled: the root README, every shipping package's, discovered from
     /// <c>src/</c>, and every topic page in <c>docs/</c> (<see cref="DocsPages"/>).
@@ -93,12 +106,13 @@ public static IReadOnlyList<string> DocumentationLinks(string markdown)
     public static IReadOnlyList<CodeBlock> CodeBlocks() =>
         [.. Readmes().SelectMany(readme => CodeBlocks(readme, File.ReadAllText(Path.Combine(Repository.Root, readme))))];
 
+    /// <summary>Every region of the samples project and of each page's own sources (<see cref="RegionSources"/>).</summary>
     public static IReadOnlyList<SampleRegion> Regions()
     {
-        var project = Path.Combine(Repository.Root, SamplesProject);
-
-        var regions = Directory.EnumerateFiles(project, "*.cs", SearchOption.AllDirectories)
-                               .Where(path => !Path.GetRelativePath(project, path).Split(Path.DirectorySeparatorChar).Any(part => part is "bin" or "obj"))
+        var regions = new[] { SamplesProject }.Concat(RegionSources.Values)
+                               .Select(directory => Path.Combine(Repository.Root, directory))
+                               .SelectMany(directory => Directory.EnumerateFiles(directory, "*.cs", SearchOption.AllDirectories)
+                                                                 .Where(path => !Path.GetRelativePath(directory, path).Split(Path.DirectorySeparatorChar).Any(part => part is "bin" or "obj")))
                                .Order(StringComparer.Ordinal)
                                .SelectMany(path => Regions(Path.GetRelativePath(Repository.Root, path).Replace('\\', '/'), File.ReadAllText(path)))
                                .ToArray();
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/ReleaseWiringTests.cs b/test/CodoMetis.TypeKit.Conventions.Tests/ReleaseWiringTests.cs
index 28441a1f..ad7277de 100644
--- a/test/CodoMetis.TypeKit.Conventions.Tests/ReleaseWiringTests.cs
+++ b/test/CodoMetis.TypeKit.Conventions.Tests/ReleaseWiringTests.cs
@@ -25,9 +25,6 @@ public sealed partial class ReleaseWiringTests
     private const string SmokeTestProject = "tools/ConsumerSmokeTest/ConsumerSmokeTest.csproj";
     private const string SmokeTest = "dotnet tools/ConsumerSmokeTest/bin/Release/net10.0/consumer-smoke-test.dll";
 
-    /// <summary>The prober, a tool project run as its built dll (design/adr/0092), which the workflows run with no model (design/adr/0096).</summary>
-    private const string Prober = "dotnet tools/Prober/bin/Release/net10.0/prober.dll";
-
     private static string ReleaseWorkflow => Workflow(ReleaseWorkflowFileName);
 
     private static string BuildWorkflow => Workflow("dotnet.yml");
@@ -49,7 +46,7 @@ public void Only_the_publish_job_may_mint_a_token()
     {
         var jobs = Jobs(ReleaseWorkflow);
 
-        jobs.Keys.ShouldBe(["verify", "publish", "release"], ignoreOrder: true, "The release workflow no longer has the verify/publish/release split these tests assume.");
+        jobs.Keys.ShouldBe(["ci", "verify", "publish", "release"], ignoreOrder: true, "The release workflow no longer has the ci/verify/publish/release split these tests assume.");
 
         foreach (var (name, job) in jobs)
         {
@@ -160,214 +157,147 @@ public void Every_job_that_runs_the_smoke_test_builds_it_first()
     }
 
     /// <summary>
-    /// Measured on PR #22's run, 2026-10-16: on a pull request that changed no package, the pack job took four
-    /// minutes and the consumer smoke test four more after a test job of five to eight, a thirteen-minute run. So on
-    /// a pull request the build workflow packs and smoke-tests only when the diff against the base branch touches a
-    /// path that can change a package or a trimmed consumer, as its <c>changes</c> job decides, and on a push always.
-    /// A job that loses the condition runs on every pull request again, which fails nothing but the maintainer's
-    /// time; a path the step no longer lists lets a change to a package merge unpacked and untested, silently. Both
-    /// are held here, by structure: the job-level keys and the case labels of the deciding step.
+    /// The changes job asks tools/CiLanes which lanes the run needs (design/adr/0113), and hands its two answers to the
+    /// jobs that read them: the test matrix and the pack lane. Before decision 113 the job decided in a shell `case`
+    /// whose list missed inputs and failed open (#70). The checkout is the whole history, since the diff is against
+    /// the base branch or the commit a push replaced.
     /// </summary>
     [Fact]
-    public void The_build_workflow_packs_a_pull_request_only_when_the_diff_can_change_a_package()
+    public void The_changes_job_selects_the_lanes_with_ci_lanes()
     {
         var changes = Job(BuildWorkflow, "changes");
-        var output = Regex.Match(changes, @"(?m)^      product:\s*\$\{\{ steps\.(?<id>[A-Za-z0-9_-]+)\.outputs\.product \}\}\s*$");
 
-        output.Success.ShouldBeTrue("dotnet.yml:changes has no `product` output taken from a step's output, so the pack and consumer jobs have nothing to read.");
+        foreach (var output in new[] { "legs", "pack", "suite" })
+            changes.ShouldMatch($@"(?m)^      {output}:\s*\$\{{\{{ steps\.select\.outputs\.{output} \}}\}}\s*$",
+                $"dotnet.yml:changes has no `{output}` output taken from the select step's, so the jobs it selects have nothing to read.");
+
+        var select = Steps(changes).SingleOrDefault(step => Regex.IsMatch(step, @"(?m)^\s+id:\s*select\s*$"));
+        select.ShouldNotBeNull("dotnet.yml:changes has no step with id select.");
+        select.ShouldContain("dotnet tools/CiLanes/bin/Release/net10.0/ci-lanes.dll select", Case.Sensitive, "dotnet.yml:changes does not run the selection's built dll.");
+        foreach (var argument in new[] { @"--event ""$GITHUB_EVENT_NAME""", @"--ref ""$GITHUB_REF""", @"--base ""$BASE_REF""", @"--before ""$BEFORE""", @"--output ""$GITHUB_OUTPUT""" })
+            select.ShouldContain(argument, Case.Sensitive, $"dotnet.yml:changes does not pass {argument} to the selection.");
+        select.ShouldContain("BASE_REF: ${{ github.base_ref }}", Case.Sensitive);
+        select.ShouldContain("BEFORE: ${{ github.event.before }}", Case.Sensitive);
+
+        changes.ShouldMatch(@"(?m)^\s+run:\s*dotnet build tools/CiLanes -c Release\s*$", "dotnet.yml:changes runs the selection without building it in Release first.");
+        changes.ShouldMatch(@"(?m)^\s+fetch-depth:\s*0\s*$", "dotnet.yml:changes checks out a shallow clone, which has neither the base branch nor the commit a push replaced.");
+    }
 
-        var decide = Steps(changes).SingleOrDefault(step => Regex.IsMatch(step, $@"(?m)^\s+id:\s*{Regex.Escape(output.Groups["id"].Value)}\s*$"));
+    [Fact]
+    public void The_test_matrix_is_the_selection()
+    {
+        var test = Job(BuildWorkflow, "test");
 
-        decide.ShouldNotBeNull($"dotnet.yml:changes has no step with id {output.Groups["id"].Value}, which its `product` output names.");
-        decide.ShouldMatch(@"(?m)^\s+if \[ ""\$GITHUB_EVENT_NAME"" != pull_request \]; then\s*$",
-            "dotnet.yml:changes does not answer true for every event but a pull request, so a push or the dispatch would skip the pack.");
-        decide.ShouldMatch(@"(?m)^\s+echo ""product=true"" >> ""\$GITHUB_OUTPUT""\s*$", "dotnet.yml:changes never writes product=true to the step's output.");
-        decide.ShouldMatch(@"(?m)^\s+git diff --name-only ""origin/\$GITHUB_BASE_REF\.\.\.HEAD"" > \S+\s*$",
-            "dotnet.yml:changes does not diff the pull request against its base branch (origin/$GITHUB_BASE_REF...HEAD) as a command of its own, whose failure fails the job.");
-        decide.ShouldMatch(@"(?m)^\s+echo ""product=\$product"" >> ""\$GITHUB_OUTPUT""\s*$", "dotnet.yml:changes never writes the diff's answer to the step's output.");
+        test.ShouldMatch(JobKey("needs", @"(?:changes|\[\s*changes\s*\])"), "dotnet.yml:test does not need changes, so it cannot read the selected legs.");
+        test.ShouldMatch(@"(?m)^\s+os:\s*\$\{\{ fromJSON\(needs\.changes\.outputs\.legs\) \}\}\s*$",
+            "dotnet.yml:test's matrix is not the changes job's legs, so the selection no longer decides which legs run.");
 
-        foreach (var pattern in ProductPaths)
-            decide.ShouldMatch(CaseLabel(pattern),
-                $"dotnet.yml:changes no longer lists {pattern} as a case label of the deciding step, so a pull request changing it alone would merge unpacked and untested.");
+        // A prose-only change runs test/Prose.slnf; any other answer, a missing one included, the whole solution.
+        test.ShouldMatch(@"(?m)^      SOLUTION:\s*\$\{\{ needs\.changes\.outputs\.suite == 'prose' && 'test/Prose\.slnf' \|\| 'CodoMetis\.TypeKit\.slnx' \}\}\s*$",
+            "dotnet.yml:test does not choose its solution from the changes job's suite, falling back to the whole solution.");
+        foreach (var command in new[] { @"dotnet restore ""$SOLUTION""", @"dotnet build ""$SOLUTION"" -c Release", @"dotnet test --solution ""$SOLUTION"" -c Release" })
+            test.ShouldContain(command, Case.Sensitive, $"dotnet.yml:test does not run `{command}`, so the suite the changes job chose is not what it builds or tests.");
+    }
 
+    /// <summary>Pack and Consumer start beside the test legs (#117) and run when the pack lane is selected.</summary>
+    [Fact]
+    public void Pack_and_Consumer_run_when_the_pack_lane_is_selected()
+    {
         foreach (var name in new[] { "pack", "consumer" })
         {
             var job = Job(BuildWorkflow, name);
 
-            job.ShouldMatch(JobKey("needs", @"\[\s*test,\s*changes\s*\]"), $"dotnet.yml:{name} does not need [ test, changes ], so it cannot read the changes job's output.");
-            job.ShouldMatch(JobKey("if", Regex.Escape("needs.changes.outputs.product == 'true'")),
-                $"dotnet.yml:{name} is not conditioned on `needs.changes.outputs.product == 'true'`, so it runs on every pull request again.");
+            job.ShouldMatch(JobKey("needs", @"\[\s*changes\s*\]"),
+                $"dotnet.yml:{name} does not need [ changes ] alone: it reads the selection, and waits for nothing else.");
+            job.ShouldMatch(JobKey("if", Regex.Escape("needs.changes.outputs.pack == 'true'")),
+                $"dotnet.yml:{name} is not conditioned on `needs.changes.outputs.pack == 'true'`, so it runs on every pull request again or never.");
         }
     }
 
     /// <summary>
-    /// The release packs and smoke-tests always: the artifacts it publishes are the artifacts it tested, whatever
-    /// the tag's diff. Neither its verify job nor the pack or smoke test step carries a condition.
+    /// The CI job is the required build check: it judges every other job, so it needs each of them, and it runs under
+    /// <c>always()</c>, since a skipped job reads as a passing required check (KB-043). A job added without joining its
+    /// needs would go unjudged; the gate itself fails a job it does not know.
     /// </summary>
     [Fact]
-    public void The_release_packs_and_smoke_tests_unconditionally()
+    public void The_CI_job_judges_every_other_job()
     {
-        var job = Job(ReleaseWorkflow, "verify");
-        var steps = Steps(job).ToList();
-
-        job.ShouldNotMatch(JobKey("if", ".*"), "release.yml:verify carries a job-level condition; the release packs and smoke-tests every tag.");
-
-        foreach (var (what, step) in new[] { ("pack", steps.Single(candidate => candidate.Contains("dotnet pack", StringComparison.Ordinal))), ("smoke test", steps.Single(candidate => SmokeTestStep().IsMatch(candidate))) })
-            step.ShouldNotMatch(@"(?m)^\s+if:", $"release.yml:verify's {what} step carries a condition; the release packs and smoke-tests every tag.");
+        var jobs = Jobs(BuildWorkflow);
+        var ci = Job(BuildWorkflow, "ci");
+
+        var needs = Regex.Match(ci, @"(?m)^    needs:\s*\[(?<jobs>[^\]]*)\]\s*$");
+        needs.Success.ShouldBeTrue("dotnet.yml:ci has no `needs: [ ... ]` list.");
+        needs.Groups["jobs"].Value.Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries)
+             .ShouldBe(jobs.Keys.Where(name => name != "ci"), ignoreOrder: true, "dotnet.yml:ci does not need exactly every other job, so it cannot judge them all.");
+
+        ci.ShouldMatch(JobKey("if", Regex.Escape("always()")), "dotnet.yml:ci does not run under always(), so a failed or cancelled job skips it, and a skipped CI reads as passing.");
+        ci.ShouldMatch(@"(?m)^\s+NEEDS:\s*\$\{\{ toJSON\(needs\) \}\}\s*$", "dotnet.yml:ci does not hand the gate toJSON(needs).");
+        ci.ShouldContain("dotnet tools/CiLanes/bin/Release/net10.0/ci-lanes.dll gate", Case.Sensitive, "dotnet.yml:ci does not run the gate.");
+        ci.ShouldMatch(@"(?m)^\s+name:\s*CI\s*$", "dotnet.yml:ci is not named CI, the required check's name.");
     }
 
     /// <summary>
-    /// The paths a pull request must touch for its diff to change a package or a trimmed consumer, each a case label
-    /// of the changes job's deciding step: the shipping projects, the build property files at any depth, any project
-    /// file, the SDK pin, the package versions, the workflows and the smoke test itself.
-    /// </summary>
-    private static readonly string[] ProductPaths =
-        ["src/", "Directory.*.props", "Directory.*.targets", "*.csproj", "global.json", "Directory.Packages.props", ".github/workflows/", "tools/ConsumerSmokeTest/"];
-
-    /// <summary>A bash case label naming the path pattern, alone or among alternatives, a trailing <c>*</c> allowed for a directory.</summary>
-    private static string CaseLabel(string pattern) => $@"(?m)^\s+(?:[^\s)|]+\|)*{Regex.Escape(pattern)}\*?(?:\|[^\s)|]+)*\)";
-
-    /// <summary>
-    /// CI replays the probe corpus with no model (design/adr/0096), split by family into legs that run at once
-    /// and a job that merges their states (design/adr/0101): on a push every probe, with coverage, and the merged
-    /// state saved for the branch's pull requests; on a pull request the base branch's state restored and only
-    /// the probes it stales replayed, without a footprint. The replay had once been documented as running in CI
-    /// while no workflow called it, and a dropped step fails nothing: a regression the corpus would catch merges
-    /// instead. So a dropped leg, a family in no leg, a replay that cannot fail its job, a merge that cannot fail
-    /// its job, a state saved from a pull request, or a job with no time limit each fail here.
+    /// The release runs every lane of the build workflow before it verifies (#74): the Windows and macOS legs and the
+    /// smoke test's own-feed mode, which a pull request may have skipped.
     /// </summary>
     [Fact]
-    public void The_build_workflow_replays_every_probe_by_family_and_merges_the_legs()
+    public void The_release_runs_the_build_workflow_before_it_verifies()
     {
-        var (name, job, steps) = ProberJob("dotnet.yml", BuildWorkflow);
-        var jobName = name[(name.IndexOf(':') + 1)..];
-
-        var listed = Regex.Match(job, @"(?m)^\s+family:\s*\[(?<families>[^\]]*)\]").Groups["families"].Value
-                          .Split(',').Select(f => f.Trim()).Where(f => f.Length > 0).ToList();
-        listed.ShouldBe(ReplayFamilies(), ignoreOrder: true,
-            $"{name}'s matrix does not list exactly the families of the axes file's replay configuration: a family in no leg is never replayed (`prober merge` then refuses), a leg of no family runs nothing.");
-        job.ShouldMatch(JobKey("timeout-minutes", @"\d+"), $"{name} has no timeout-minutes, so a hung replay runs to the six-hour default.");
-        job.ShouldMatch(@"PROBE_BRANCH=\$\{\{ github\.event_name == 'pull_request' && github\.base_ref \|\| github\.ref_name \}\}",
-            $"{name} does not take the base branch's state on a pull request (PROBE_BRANCH), so the base's footprints would not decide what the branch stales.");
-
-        var replay = steps.FindIndex(step => ProberStep("replay").IsMatch(step));
-        var build = steps.FindIndex(step => ProberBuild().IsMatch(step));
-        replay.ShouldBeGreaterThanOrEqualTo(0, $"{name} does not run `prober replay`.");
-        build.ShouldBeInRange(0, replay - 1, $"{name} runs the prober without building it in Release first: build the solution or tools/Prober with -c Release.");
-        var lines = steps[replay].Split('\n').Where(line => ProberStep("replay").IsMatch(line)).Select(line => line.Trim()).ToList();
-        lines.Count.ShouldBe(2, $"{name} does not run the replay one way on a push and another on a pull request.");
-        lines.Single(line => line.Contains(" --all", StringComparison.Ordinal))
-             .ShouldMatch($@"^{Regex.Escape(Prober)} replay --all --branch ""\$PROBE_BRANCH"" --family ""\$\{{\{{ matrix\.family \}}\}}""$",
-                 $"{name}'s push replay is not `replay --all` of the branch's family leg: every probe, with a footprint, for the state the branch saves.");
-        lines.Single(line => !line.Contains(" --all", StringComparison.Ordinal))
-             .ShouldMatch($@"^{Regex.Escape(Prober)} replay --branch ""\$PROBE_BRANCH"" --family ""\$\{{\{{ matrix\.family \}}\}}"" --no-footprint$",
-                 $"{name}'s pull request replay is not the family leg's stale probes without a footprint: coverage would be spent on a state nobody keeps.");
-        steps[replay].ShouldNotMatch(@"\|\|\s*true", $"{name} lets the replay fail without failing the job.");
-        steps[replay].ShouldNotMatch(@"(?m)^\s+continue-on-error:", $"{name} lets the replay fail without failing the job.");
-
-        var restore = steps.FindIndex(step => step.Contains("uses: actions/cache/restore@", StringComparison.Ordinal));
-        restore.ShouldBeInRange(0, replay - 1, $"{name} does not restore the base branch's probe state before the replay, so a pull request replays every probe.");
-        steps[restore].ShouldMatch(@"(?m)^\s+if:\s*github\.event_name == 'pull_request'\s*$", $"{name} restores a saved state on a push too, where decision 0101 keeps the replay from an empty state.");
-        steps[restore].ShouldMatch(@"restore-keys:\s*probe-state-\$\{\{ github\.base_ref \}\}-", $"{name} does not restore the base branch's newest saved state (restore-keys by base_ref).");
-
-        var merge = Jobs(BuildWorkflow).Single(candidate => Steps(candidate.Value).Any(step => ProberStep("merge").IsMatch(step)));
-        var mergeName = $"dotnet.yml:{merge.Key}";
-        merge.Value.ShouldMatch(JobKey("needs", Regex.Escape(jobName)), $"{mergeName} does not follow the {jobName} legs.");
-        merge.Value.ShouldMatch(JobKey("if", @"always\(\)"), $"{mergeName} is skipped when a leg fails, so a failing run reports no status.");
-        merge.Value.ShouldMatch(JobKey("timeout-minutes", @"\d+"), $"{mergeName} has no timeout-minutes.");
-        merge.Value.ShouldMatch(StateDirectory, $"{mergeName} does not set PROBE_STATE_DIR, so the prober writes into a developer's state directory.");
-        var mergeSteps = Steps(merge.Value).ToList();
-        var merging = mergeSteps.FindIndex(step => ProberStep("merge").IsMatch(step));
-        var download = mergeSteps.FindIndex(step => step.Contains("uses: actions/download-artifact@", StringComparison.Ordinal));
-        var status = mergeSteps.FindIndex(step => ProberStep("status").IsMatch(step));
-        var save = mergeSteps.FindIndex(step => step.Contains("uses: actions/cache/save@", StringComparison.Ordinal));
-        download.ShouldBeInRange(0, merging - 1, $"{mergeName} does not download the legs' states before merging them.");
-        mergeSteps[merging].ShouldMatch($@"(?m)^\s+run:\s*{Regex.Escape(Prober)} merge --branch ""\$PROBE_BRANCH"" --from \S", $"{mergeName} does not merge the legs' states with `prober merge --branch --from` alone on its run line.");
-        mergeSteps[merging].ShouldNotMatch(@"\|\|\s*true", $"{mergeName} lets the merge fail without failing the job, so a probe in no leg or a failed leg would pass.");
-        mergeSteps[merging].ShouldNotMatch(@"(?m)^\s+continue-on-error:", $"{mergeName} lets the merge fail without failing the job, so a probe in no leg or a failed leg would pass.");
-        status.ShouldBeGreaterThan(merging, $"{mergeName} does not run `prober status` after the merge, so the run reports no coverage.");
-        save.ShouldBeGreaterThan(merging, $"{mergeName} does not save the merged state for the branch's pull requests.");
-        mergeSteps[save].ShouldMatch(@"(?m)^\s+if:\s*github\.event_name == 'push'\s*$", $"{mergeName} saves the state from a pull request too, whose replay was partial and without a footprint.");
-        mergeSteps[save].ShouldMatch(@"key:\s*probe-state-\$\{\{ github\.ref_name \}\}-", $"{mergeName} does not save the state under the branch's key, which its pull requests restore by prefix.");
-    }
-
-    /// <summary>A key of the job itself, at the job's indentation (four spaces), never a step's key of the same name.</summary>
-    private static string JobKey(string key, string value) => $@"(?m)^    {key}:\s*{value}\s*$";
-
-    /// <summary>The families of the axes file's replay configuration, which the matrix lists in full.</summary>
-    private static List<string> ReplayFamilies()
-    {
-        var text = File.ReadAllText(Path.Combine(Repository.Root, ".claude", "probe-axes.md"));
-        var start = text.IndexOf("```json probe-axes", StringComparison.Ordinal);
-        start.ShouldBeGreaterThanOrEqualTo(0, "No `json probe-axes` block in .claude/probe-axes.md.");
-        start = text.IndexOf('\n', start) + 1;
-        var end = text.IndexOf("\n```", start, StringComparison.Ordinal);
-        using var block = System.Text.Json.JsonDocument.Parse(text[start..end]);
-        var families = block.RootElement.GetProperty("replay").GetProperty("families").EnumerateObject().Select(property => property.Name).ToList();
-        families.ShouldNotBeEmpty("The replay configuration of .claude/probe-axes.md names no families.");
-        return families;
+        BuildWorkflow.ShouldMatch(@"(?m)^  workflow_call:\s*$", "dotnet.yml cannot be called: it has no workflow_call trigger.");
+        Job(ReleaseWorkflow, "ci").ShouldMatch(JobKey("uses", Regex.Escape("./.github/workflows/dotnet.yml")), "release.yml:ci does not call dotnet.yml.");
+        Job(ReleaseWorkflow, "verify").ShouldMatch(JobKey("needs", @"(?:ci|\[\s*ci\s*\])"), "release.yml:verify does not need ci, so it packs without the full matrix.");
     }
 
     /// <summary>
-    /// The release replays the corpus and runs the gate before it packs (design/adr/0096), against the previous
-    /// release: on a tag push, <c>git describe</c> alone names the tag being released, and the gate would compare
-    /// the commit with itself and find nothing touched. The gate binds from 2.2.0 (design/adr/0097), so a refusal
-    /// fails the job: the step's exit code is the gate's own, either because nothing follows the gate's
-    /// <c>||</c> or because the step ends with <c>exit "$code"</c>, and it has no <c>continue-on-error</c>.
+    /// A called workflow's <c>github.workflow</c> is its caller's name, and a concurrency group ignores case (KB-043).
+    /// The build workflow's group under the release's call must differ from the release's own, or the call waits for its
+    /// caller and the release never finishes.
     /// </summary>
     [Fact]
-    public void The_release_replays_every_probe_and_runs_the_gate_before_packing()
+    public void A_call_from_the_release_never_shares_its_callers_concurrency_group()
     {
-        var job = Job(ReleaseWorkflow, "verify");
-        var steps = Steps(job).ToList();
+        var caller = Regex.Match(ReleaseWorkflow, @"(?m)^name:\s*(?<name>.+?)\s*$").Groups["name"].Value;
+        string Group(string workflow) =>
+            Regex.Match(workflow, @"(?m)^concurrency:\s*\n\s+group:\s*(?<group>.+?)\s*$").Groups["group"].Value.Replace("${{ github.workflow }}", caller, StringComparison.Ordinal);
+
+        var release = Group(ReleaseWorkflow);
+        var called = Group(BuildWorkflow);
 
-        var replay = StrictReplay("release.yml:verify", steps);
-        var gate = steps.FindIndex(step => ProberStep("gate").IsMatch(step));
-        var pack = steps.FindIndex(step => step.Contains("dotnet pack", StringComparison.Ordinal));
-
-        gate.ShouldBeGreaterThan(replay, "release.yml:verify does not run `prober gate` after `prober replay --all`; the gate reads the replay's evidence.");
-        pack.ShouldBeGreaterThan(gate, "release.yml:verify packs before the probe gate has run.");
-        steps[gate].ShouldMatch(@"\bgate --since ""?\$", "The gate runs without --since, so on a tag push it compares the release with itself.");
-        steps[gate].ShouldNotMatch(@"(?m)^\s+continue-on-error:", "release.yml:verify lets the probe gate fail without failing the job; it binds from 2.2.0.");
-        (!Regex.IsMatch(steps[gate], $@"{Regex.Escape(Prober)} gate\b[^\n]*\|\|") || Regex.IsMatch(steps[gate], @"\n\s*exit ""?\$code""?\s*$"))
-            .ShouldBeTrue("release.yml:verify catches the probe gate's exit code and does not end the step with it, so a refusal does not fail the release; it binds from 2.2.0.");
-        job.ShouldMatch(StateDirectory, "release.yml:verify does not set PROBE_STATE_DIR, so the prober writes into a developer's state directory.");
+        release.ShouldNotBeEmpty("release.yml has no workflow-level concurrency group.");
+        called.ShouldNotBeEmpty("dotnet.yml has no workflow-level concurrency group.");
+        string.Equals(release, called, StringComparison.OrdinalIgnoreCase).ShouldBeFalse(
+            $"Under release.yml's call, dotnet.yml's concurrency group is {called}, the release's own ({release}) as GitHub compares groups: the call would wait for its caller.");
     }
 
-    /// <summary>The one job of a workflow whose steps run `prober replay`: its name, its text and its steps.</summary>
-    private static (string Name, string Job, List<string> Steps) ProberJob(string workflow, string text)
+    [Fact]
+    public void The_nightly_run_dispatches_the_build_workflow()
     {
-        var jobs = Jobs(text).Where(job => Steps(job.Value).Any(step => ProberStep("replay").IsMatch(step))).ToList();
-
-        jobs.Count.ShouldBe(1, $"{workflow} has no job that runs `prober replay`, or more than one.");
-        jobs[0].Value.ShouldMatch(StateDirectory, $"{workflow}:{jobs[0].Key} does not set PROBE_STATE_DIR, so the prober writes into a developer's state directory.");
+        var nightly = Workflow("nightly.yml");
 
-        return ($"{workflow}:{jobs[0].Key}", jobs[0].Value, Steps(jobs[0].Value).ToList());
+        nightly.ShouldMatch(@"(?m)^\s+- cron:", "nightly.yml has no schedule.");
+        nightly.ShouldContain("gh workflow run dotnet.yml --ref", Case.Sensitive, "nightly.yml does not dispatch dotnet.yml.");
+        nightly.ShouldMatch(@"(?m)^\s+actions:\s*write\b", "nightly.yml cannot dispatch without actions: write.");
     }
 
     /// <summary>
-    /// The replay of every probe, built first, and able to fail the job: its exit code is the step's own, with no
-    /// <c>|| true</c> and no <c>continue-on-error</c>.
+    /// The release packs and smoke-tests always: the artifacts it publishes are the artifacts it tested, whatever
+    /// the tag's diff. Neither its verify job nor the pack or smoke test step carries a condition.
     /// </summary>
-    private static int StrictReplay(string name, List<string> steps)
+    [Fact]
+    public void The_release_packs_and_smoke_tests_unconditionally()
     {
-        var replay = steps.FindIndex(step => ProberStep("replay").IsMatch(step));
-        var build = steps.FindIndex(step => ProberBuild().IsMatch(step));
+        var job = Job(ReleaseWorkflow, "verify");
+        var steps = Steps(job).ToList();
 
-        replay.ShouldBeGreaterThanOrEqualTo(0, $"{name} does not run `prober replay`.");
-        steps[replay].ShouldMatch($@"(?m)^\s+run:\s*{Regex.Escape(Prober)} replay --all\s*$",
-            $"{name} replays the probes some other way than `{Prober} replay --all` alone on its run line, so a failing probe may not fail the job.");
-        steps[replay].ShouldNotMatch(@"(?m)^\s+continue-on-error:", $"{name} lets the replay fail without failing the job.");
-        build.ShouldBeInRange(0, replay - 1, $"{name} runs the prober without building it in Release first: build the solution or tools/Prober with -c Release.");
+        job.ShouldNotMatch(JobKey("if", ".*"), "release.yml:verify carries a job-level condition; the release packs and smoke-tests every tag.");
 
-        return replay;
+        foreach (var (what, step) in new[] { ("pack", steps.Single(candidate => candidate.Contains("dotnet pack", StringComparison.Ordinal))), ("smoke test", steps.Single(candidate => SmokeTestStep().IsMatch(candidate))) })
+            step.ShouldNotMatch(@"(?m)^\s+if:", $"release.yml:verify's {what} step carries a condition; the release packs and smoke-tests every tag.");
     }
 
-    /// <summary>PROBE_STATE_DIR set for the job: as an env key, or written to <c>$GITHUB_ENV</c> (the runner context is not available to a job's env).</summary>
-    private const string StateDirectory = @"(?m)^\s+(PROBE_STATE_DIR:\s*\S|echo ""PROBE_STATE_DIR=\S+"" >> ""\$GITHUB_ENV"")";
+    /// <summary>A key of the job itself, at the job's indentation (four spaces), never a step's key of the same name.</summary>
+    private static string JobKey(string key, string value) => $@"(?m)^    {key}:\s*{value}\s*$";
 
-    /// <summary>A step that runs a prober command; <see cref="Steps"/> has already dropped the comment lines.</summary>
-    private static Regex ProberStep(string command) => new($@"{Regex.Escape(Prober)} {command}\b");
 
     /// <summary>
     /// Measured 2026-09-27: without the filter, the analyzer package's SBOM lists 13 Roslyn
@@ -478,9 +408,6 @@ private static IEnumerable<string> Steps(string job) =>
     [GeneratedRegex(@"(?m)^\s+run:\s*dotnet build (CodoMetis\.TypeKit\.slnx|tools/ConsumerSmokeTest)\s+-c Release\s*$")]
     private static partial Regex SmokeTestBuild();
 
-    [GeneratedRegex(@"(?m)^\s+run:\s*dotnet build (CodoMetis\.TypeKit\.slnx|tools/Prober)\s+-c Release\s*$")]
-    private static partial Regex ProberBuild();
-
     [GeneratedRegex(@"(?m)^\s+run:.*\bapt-get install\b.*\bclang\b.*\bzlib1g-dev\b")]
     private static partial Regex AotPrerequisites();
 
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/SessionStartHookTests.cs b/test/CodoMetis.TypeKit.Conventions.Tests/SessionStartHookTests.cs
index 73ea4959..9660cedd 100644
--- a/test/CodoMetis.TypeKit.Conventions.Tests/SessionStartHookTests.cs
+++ b/test/CodoMetis.TypeKit.Conventions.Tests/SessionStartHookTests.cs
@@ -36,7 +36,7 @@ .. Directory.GetDirectories(Path.Combine(Repository.Root, "tools"))
     ];
 
     [Fact]
-    public void The_tools_are_found() => Tools.Select(row => row.Data).ShouldContain("Prober");
+    public void The_tools_are_found() => Tools.Select(row => row.Data).ShouldContain("Oracles");
 
     [Theory, MemberData(nameof(Tools))]
     public void Every_tool_is_in_the_session_start_filter(string tool)
diff --git a/test/CodoMetis.TypeKit.Conventions.Tests/WovenReachabilityTests.cs b/test/CodoMetis.TypeKit.Conventions.Tests/WovenReachabilityTests.cs
new file mode 100644
index 00000000..a2fe7db9
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Conventions.Tests/WovenReachabilityTests.cs
@@ -0,0 +1,126 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace CodoMetis.TypeKit.Conventions.Tests;
+
+/// <summary>
+/// The woven code has no statement after a <c>return</c> or a <c>throw</c> of the same block: what the
+/// generators write is all reachable.
+/// </summary>
+/// <remarks>
+/// <para>
+/// A template that returns from a compile-time branch ends the run-time body there, but compile-time
+/// calls after it still run. <c>TryParseTemplate</c> called <c>meta.InsertStatement</c> after such a
+/// branch, so every generated <c>TryParse(string?, IFormatProvider?, out …)</c> ended in a declaration and
+/// a <c>try</c>/<c>catch</c> nothing reached (issue #100). The compiler keeps quiet about unreachable code
+/// in generated code, and no test of behaviour can see it.
+/// </para>
+/// <para>
+/// This reads the woven files the probes emit (<c>MetalamaEmitCompilerTransformedFiles</c>) for the build
+/// of its own configuration. The probes hold a value object of every parse strategy.
+/// </para>
+/// </remarks>
+public sealed class WovenReachabilityTests
+{
+    private const string Probes = "test/CodoMetis.TypeKit.Generators.Probes";
+
+    [Fact]
+    public void A_statement_after_a_return_is_found()
+    {
+        const string source =
+            """
+            class C
+            {
+                bool M(string? s)
+                {
+                    if (s is null) return false;
+                    return true;
+                    int dead;
+                }
+
+                int N()
+                {
+                    throw new System.Exception();
+                    return 1;
+                }
+
+                int O()
+                {
+                    return Local();
+                    int Local() => 1;
+                }
+            }
+            """;
+
+        Unreachable(source, Path.Combine(Repository.Root, "C.cs")).ShouldBe(["C.cs:7: C.M: int dead;", "C.cs:13: C.N: return 1;"]);
+    }
+
+    [Fact]
+    public void The_woven_probes_are_read()
+    {
+        var methods = WovenFiles().SelectMany(path => Methods(File.ReadAllText(path), path)).ToArray();
+
+        // Every value object of the probes that parses gets a TryParse over a string.
+        methods.Count(method => method.Identifier.ValueText == "TryParse" && method.ParameterList.Parameters.FirstOrDefault()?.Type?.ToString() is "global::System.String?")
+               .ShouldBeGreaterThanOrEqualTo(20);
+    }
+
+    [Fact]
+    public void The_woven_code_has_no_unreachable_statement()
+    {
+        var unreachable = WovenFiles().SelectMany(path => Unreachable(File.ReadAllText(path), path)).ToArray();
+
+        unreachable.ShouldBeEmpty(
+            "A template wrote a statement after a return or a throw. A compile-time call after a return in a compile-time branch " +
+            $"still runs: put it in an else branch.{Environment.NewLine}{string.Join(Environment.NewLine, unreachable.Take(20))}");
+    }
+
+    /// <summary>The woven sources of the probes, written by the build of this configuration.</summary>
+    private static IReadOnlyList<string> WovenFiles()
+    {
+        // bin/{configuration}/{framework}/ of this test project.
+        var output        = new DirectoryInfo(AppContext.BaseDirectory.TrimEnd(Path.DirectorySeparatorChar));
+        var framework     = output.Name;
+        var configuration = output.Parent!.Name;
+        var folder        = Path.Combine(Repository.Root, Probes, "obj", configuration, framework, "metalama");
+
+        return Directory.Exists(folder)
+            ? [.. Directory.EnumerateFiles(folder, "*.cs", SearchOption.AllDirectories).Order(StringComparer.Ordinal)]
+            : throw new DirectoryNotFoundException($"No woven probes at {folder}. Build {Probes} in {configuration} first; dotnet test --solution does.");
+    }
+
+    private static IEnumerable<MethodDeclarationSyntax> Methods(string source, string path) =>
+        CSharpSyntaxTree.ParseText(source, path: path, cancellationToken: TestContext.Current.CancellationToken)
+                        .GetRoot(TestContext.Current.CancellationToken)
+                        .DescendantNodes()
+                        .OfType<MethodDeclarationSyntax>();
+
+    /// <summary>Each statement that follows a <c>return</c> or a <c>throw</c> in the same block, a local function excepted.</summary>
+    private static IEnumerable<string> Unreachable(string source, string path)
+    {
+        var cancellationToken = TestContext.Current.CancellationToken;
+        var tree              = CSharpSyntaxTree.ParseText(source, path: path, cancellationToken: cancellationToken);
+        var lines             = tree.GetText(cancellationToken).Lines;
+
+        foreach (var block in tree.GetRoot(cancellationToken).DescendantNodes().OfType<BlockSyntax>())
+        {
+            var exit = block.Statements.IndexOf(statement => statement is ReturnStatementSyntax or ThrowStatementSyntax);
+            if (exit < 0) continue;
+
+            var after = block.Statements.Skip(exit + 1).FirstOrDefault(statement => statement is not LocalFunctionStatementSyntax);
+            if (after is null) continue;
+
+            var member = after.Ancestors().OfType<MemberDeclarationSyntax>().First();
+            var type   = after.Ancestors().OfType<BaseTypeDeclarationSyntax>().First().Identifier.ValueText;
+            var name   = member switch
+            {
+                MethodDeclarationSyntax method     => method.Identifier.ValueText,
+                PropertyDeclarationSyntax property => property.Identifier.ValueText,
+                _                                  => member.Kind().ToString(),
+            };
+
+            yield return $"{Path.GetRelativePath(Repository.Root, path)}:{lines.GetLineFromPosition(after.SpanStart).LineNumber + 1}: {type}.{name}: {after.ToString().Split('\n')[0].Trim()}";
+        }
+    }
+}
diff --git a/test/CodoMetis.TypeKit.DocsQuery.Tests/FactCitationTests.cs b/test/CodoMetis.TypeKit.DocsQuery.Tests/FactCitationTests.cs
deleted file mode 100644
index 6ca113d4..00000000
--- a/test/CodoMetis.TypeKit.DocsQuery.Tests/FactCitationTests.cs
+++ /dev/null
@@ -1,216 +0,0 @@
-using DocsQuery;
-
-namespace CodoMetis.TypeKit.DocsQuery.Tests;
-
-/// <summary>
-/// A fact is executable or it explains only (design/adr/0107): <c>check</c> fails a fact the probe corpus cites to
-/// prune or excuse a row (a refused entry of the axes file, a not-promised entry or an obligation's declaration in
-/// claims.json, a <c>Cite.Fact</c> or <c>Baseline.Fact</c> of the harness) when it has no test, and a <c>fixture:</c>
-/// whose file is missing or not beside the test.
-/// </summary>
-public sealed class FactCitationTests : IDisposable
-{
-    private readonly TempRepo _repo = Store(new TempRepo());
-
-    public void Dispose() => _repo.Dispose();
-
-    private static string Fact(int number, string test, string fixture = "") =>
-        $"""
-        ---
-        verified: 2026-10-15
-        pins:
-          - sdk 10.0.4xx
-        source: the framework's own output, measured
-        turned-on: decision 1
-        test: {test}
-        {fixture}
-        ---
-
-        # KB-{number:D3}. A fact
-        """;
-
-    /// <summary>KB-001 tested, with a fixture; KB-002 prose only.</summary>
-    private static TempRepo Store(TempRepo repo) => repo
-        .With("global.json", """{ "sdk": { "version": "10.0.402", "rollForward": "latestPatch" } }""")
-        .With("design/adr/0001-first.md", "# 0001. First\n\nDate: 2026-10-01\nStatus: accepted\n")
-        .With("design/knowledge/KB-001-tested.md", Fact(1, "test/CodoMetis.TypeKit.Facts/KB001.cs", "fixture: test/CodoMetis.TypeKit.Facts/KB001.fixture.json"))
-        .With("test/CodoMetis.TypeKit.Facts/KB001.cs", "public sealed class KB001 { }\n")
-        .With("test/CodoMetis.TypeKit.Facts/KB001.fixture.json", """{ "fact": "KB-001", "answers": [] }""")
-        .With("design/knowledge/KB-002-prose.md", Fact(2, "none, a sentence of the framework's documentation"));
-
-    /// <summary>The axes file, its refused entries citing <paramref name="fact"/> in their reason.</summary>
-    private TempRepo Axes(string fact) => _repo.With(".claude/probe-axes.md",
-        $$"""
-        # Axes
-
-        ```json probe-axes
-        {
-          "axes": {},
-          "refused": {
-            "json.ReadCommentHandling": {
-              "Allow": "System.Text.Json refuses it on the options object"
-            },
-            "mvc.MaxValidationDepth": {
-              "0": "MVC refuses it, fact:{{fact}}"
-            }
-          }
-        }
-        ```
-        """);
-
-    /// <summary>claims.json with a not-promised entry whose source is <paramref name="source"/> and an obligation declaration citing <paramref name="cite"/>.</summary>
-    private TempRepo Claims(string source, string cite) => _repo.With("tools/probe/corpus/claims.json",
-        $$"""
-        [
-          {
-            "id": "C01",
-            "source": "README.md#a",
-            "obligations": [
-              {
-                "id": "binds",
-                "sentence": "It binds.",
-                "inapplicable": [
-                  { "axes": { "x": ["1"] }, "cite": "not-promised:np" },
-                  { "axes": { "x": ["2"] }, "cite": "{{cite}}" }
-                ]
-              }
-            ],
-            "not-promised": [
-              { "id": "np", "source": "{{source}}", "sentence": "So.", "axes": { "x": ["1"] } }
-            ]
-          }
-        ]
-        """);
-
-    private List<string> Problems() =>
-        [.. _repo.Queries().Check().Rows.Select(row => $"{row.Fields[0].Value} {row.Fields[1].Value} {row.Fields[2].Value}")];
-
-    [Fact]
-    public void Citations_of_a_tested_fact_check_clean_and_are_counted_by_kind()
-    {
-        Axes("KB-001");
-        Claims("design/knowledge/KB-001-tested.md#kb-001-a-fact", "fact:KB-001");
-        _repo.With("tools/probe/corpus/harness/Http.cs", "class Http { void M() { c.Inapplicable(Cite.Fact(\"KB-001\"), \"why\"); } }\n")
-             .With("tools/probe/corpus/probes/P.cs", "class P { Baseline b = Baseline.Fact( \"KB-001\" ); }\n");
-
-        var answer = _repo.Queries().Check();
-
-        answer.Rows.ShouldBeEmpty(answer.Text());
-        answer.Summary.ShouldContain("5 fact citations (1 refused, 1 not-promised, 1 obligation, 2 harness)");
-        var scan = FactCitations.Find(_repo.Root);
-        scan.Read.ShouldBe(new Dictionary<string, int> { ["refused"] = 2, ["not-promised"] = 1, ["obligation"] = 2, ["harness"] = 2 });
-        scan.Citations.Select(c => $"{c.Kind} {c.At} {c.Fact} {c.Baseline}").ShouldBe(
-        [
-            "refused .claude/probe-axes.md:11 KB-001 False",
-            "obligation tools/probe/corpus/claims.json:11 KB-001 False",
-            "not-promised tools/probe/corpus/claims.json:16 KB-001 False",
-            "harness tools/probe/corpus/harness/Http.cs:1 KB-001 False",
-            "harness tools/probe/corpus/probes/P.cs:1 KB-001 True",
-        ]);
-    }
-
-    [Fact]
-    public void A_refused_entry_citing_a_fact_without_a_test_fails_where_it_is_written()
-    {
-        Axes("KB-002");
-
-        Problems().ShouldBe([".claude/probe-axes.md:11 fact-not-executable-cited KB-002"]);
-        _repo.Queries().Check().Rows.Single().Fields.Single(f => f.Name == "detail").Value
-             .ShouldBe("the refused entry mvc.MaxValidationDepth=0 cites KB-002, and its test: is 'none, a sentence of the framework's documentation': " +
-                       "a fact without its test explains only, never prunes or excuses a row; write its test in test/CodoMetis.TypeKit.Facts/, or cite a docs sentence");
-    }
-
-    [Fact]
-    public void A_not_promised_entry_whose_source_is_a_fact_without_a_test_fails()
-    {
-        Claims("design/knowledge/KB-002-prose.md#kb-002-a-fact", "fact:KB-001");
-
-        Problems().ShouldBe(["tools/probe/corpus/claims.json:16 fact-not-executable-cited KB-002"]);
-    }
-
-    [Fact]
-    public void An_obligation_s_declaration_citing_a_fact_without_a_test_fails()
-    {
-        Claims("README.md#a", "fact:KB-002");
-
-        Problems().ShouldBe(["tools/probe/corpus/claims.json:11 fact-not-executable-cited KB-002"]);
-    }
-
-    [Fact]
-    public void A_harness_citation_of_a_fact_without_a_test_fails_and_one_in_a_comment_does_not_count()
-    {
-        _repo.With("tools/probe/corpus/harness/Http.cs",
-            """
-            class Http
-            {
-                // Cite.Fact("KB-002") is only mentioned here
-                /* and Cite.Fact("KB-002") here */
-                string url = "http://example"; object o = Cite.Fact("KB-002");
-                void M() => c.Inapplicable(Cite.Fact("KB-002"), "why");
-            }
-            """);
-
-        Problems().ShouldBe(["tools/probe/corpus/harness/Http.cs:5 fact-not-executable-cited KB-002", "tools/probe/corpus/harness/Http.cs:6 fact-not-executable-cited KB-002"]);
-    }
-
-    [Fact]
-    public void A_cited_fact_whose_test_file_is_missing_fails_twice()
-    {
-        _repo.With("design/knowledge/KB-003-test-gone.md", Fact(3, "test/CodoMetis.TypeKit.Facts/KB003.cs"))
-             .With("tools/probe/corpus/probes/P.cs", "class P { object o = Cite.Fact(\"KB-003\"); }\n");
-
-        Problems().ShouldBe(
-        [
-            "design/knowledge/KB-003-test-gone.md:7 fact-untested test/CodoMetis.TypeKit.Facts/KB003.cs",
-            "tools/probe/corpus/probes/P.cs:1 fact-not-executable-cited KB-003",
-        ]);
-    }
-
-    [Fact]
-    public void A_cited_fact_that_does_not_exist_fails()
-    {
-        _repo.With("tools/probe/corpus/probes/P.cs", "class P { object o = Cite.Fact(\"KB-099\"); }\n");
-
-        Problems().ShouldBe(["tools/probe/corpus/probes/P.cs:1 fact-not-executable-cited KB-099"]);
-    }
-
-    /// <summary>A baseline is the fact's measured answer, so it takes the fixture as well as the test.</summary>
-    [Fact]
-    public void A_baseline_of_a_tested_fact_without_a_fixture_fails()
-    {
-        _repo.With("design/knowledge/KB-004-no-fixture.md", Fact(4, "test/CodoMetis.TypeKit.Facts/KB004.cs"))
-             .With("test/CodoMetis.TypeKit.Facts/KB004.cs", "public sealed class KB004 { }\n")
-             .With("tools/probe/corpus/harness/Http.cs", "class Http { Baseline a = Baseline.Fact(\"KB-001\"), b = Baseline.Fact(\"KB-004\"); object c = Cite.Fact(\"KB-004\"); }\n");
-
-        Problems().ShouldBe(["tools/probe/corpus/harness/Http.cs:1 fact-not-executable-cited KB-004"]);
-    }
-
-    [Fact]
-    public void A_fixture_must_exist_beside_the_test_of_a_tested_fact()
-    {
-        _repo.With("design/knowledge/KB-005-fixture-gone.md", Fact(5, "test/CodoMetis.TypeKit.Facts/KB005.cs", "fixture: test/CodoMetis.TypeKit.Facts/KB005.fixture.json"))
-             .With("test/CodoMetis.TypeKit.Facts/KB005.cs", "public sealed class KB005 { }\n")
-             .With("design/knowledge/KB-006-fixture-elsewhere.md", Fact(6, "test/CodoMetis.TypeKit.Facts/KB006.cs", "fixture: test/fixtures/KB006.json"))
-             .With("test/CodoMetis.TypeKit.Facts/KB006.cs", "public sealed class KB006 { }\n")
-             .With("test/fixtures/KB006.json", "{}")
-             .With("design/knowledge/KB-007-fixture-untested.md", Fact(7, "none, prose", "fixture: test/CodoMetis.TypeKit.Facts/KB007.fixture.json"))
-             .With("test/CodoMetis.TypeKit.Facts/KB007.fixture.json", "{}")
-             .With("test/CodoMetis.TypeKit.Facts/KB008.fixture.json", "{}");
-
-        Problems().ShouldBe(
-        [
-            "design/knowledge/KB-005-fixture-gone.md:8 fact-fixture-missing test/CodoMetis.TypeKit.Facts/KB005.fixture.json",
-            "design/knowledge/KB-006-fixture-elsewhere.md:8 fact-fixture test/fixtures/KB006.json",
-            "design/knowledge/KB-007-fixture-untested.md:8 fact-fixture test/CodoMetis.TypeKit.Facts/KB007.fixture.json",
-            "test/CodoMetis.TypeKit.Facts/KB008.fixture.json:1 fact-orphan-fixture test/CodoMetis.TypeKit.Facts/KB008.fixture.json",
-        ]);
-    }
-
-    [Fact]
-    public void Comments_are_blanked_and_strings_kept()
-    {
-        var source = "a // b\nc /* d\ne */ f \"// g\" @\"h \"\" // i\" \"\"\"raw // j\"\"\" '\"' k";
-
-        FactCitations.WithoutComments(source).ShouldBe("a     \nc     \n     f \"// g\" @\"h \"\" // i\" \"\"\"raw // j\"\"\" '\"' k");
-    }
-}
diff --git a/test/CodoMetis.TypeKit.DocsQuery.Tests/FactTests.cs b/test/CodoMetis.TypeKit.DocsQuery.Tests/FactTests.cs
index 360c25ed..2b5b1536 100644
--- a/test/CodoMetis.TypeKit.DocsQuery.Tests/FactTests.cs
+++ b/test/CodoMetis.TypeKit.DocsQuery.Tests/FactTests.cs
@@ -168,4 +168,82 @@ public void What_is_installed_is_read_from_the_two_files()
         installed.Packages.ShouldContainKeyAndValue("Microsoft.AspNetCore.OpenApi", "10.0.12");
         installed.Packages.Count.ShouldBe(2);
     }
+
+    /// <summary>
+    /// A fact with an external pin is due once its verified: date is more than the given days old, and not a day
+    /// before; one pinning only what is installed never is, however old, since <c>check</c> compares its pins.
+    /// </summary>
+    [Fact]
+    public void Due_lists_an_external_fact_verified_more_than_the_given_days_ago()
+    {
+        _repo.With("design/knowledge/KB-002-installed-only.md", Fact(2, "  - sdk 10.0.4xx", "none, prose").Replace("2026-10-15", "2025-01-01", StringComparison.Ordinal));
+
+        var today = new DateOnly(2026, 10, 29);
+        var due   = _repo.Queries().Due(13, today, feed: null);
+
+        due.ExitCode.ShouldBe(0);
+        due.Rows.Select(row => row.ToString()).ShouldBe(["at=design/knowledge/KB-001-a-fact.md:2  kind=fact-old  id=KB-001  target=2026-10-15  detail=verified 14 days ago, more than 13: re-read it at its latest release"]);
+        due.Summary.ShouldStartWith("1 fact due of 1 fact pinned external");
+
+        var notYet = _repo.Queries().Due(14, today, feed: null);
+        notYet.Rows.ShouldBeEmpty(notYet.Text());
+        notYet.ExitCode.ShouldBe(1);
+    }
+
+    /// <summary>
+    /// Given a feed, a pin is due when NuGet lists a later release on its track: stable for a stable pin, any for a
+    /// pre-release, labels ordered as SemVer orders them (beta.10 after beta.2). A pin of a release still the latest, of
+    /// a name NuGet has no package of, or with no version (even where NuGet has a package of the name), is not.
+    /// </summary>
+    [Fact]
+    public void Due_with_a_feed_lists_a_pin_nuget_has_a_later_release_of()
+    {
+        _repo.With("design/knowledge/KB-002-competitors.md", Fact(2,
+            "  - external Vogen 8.0.7\n  - external Vogen 9.0.0-beta.2\n  - external OneOf 3.0.271\n  - external PostgreSQL 17.11\n  - external NuGet registration data, 2026-10-29",
+            "none, prose"));
+
+        var asked = new List<string>();
+        IReadOnlyList<string>? Feed(string id)
+        {
+            asked.Add(id);
+            return id switch
+            {
+                "Vogen" => ["8.0.7", "9.0.0-beta.2", "9.0.0-beta.10"],
+                "OneOf" => ["3.0.255", "3.0.271"],
+                "NuGet" => ["0.0.1"],
+                _       => null,
+            };
+        }
+
+        var due = _repo.Queries().Due(1000, new DateOnly(2026, 10, 29), Feed);
+
+        due.Rows.Select(row => $"{row.Fields[0].Value} {row.Fields[1].Value} {row.Fields[3].Value}: {row.Fields[4].Value}").ShouldBe(
+        [
+            "design/knowledge/KB-002-competitors.md:5 fact-released external Vogen 9.0.0-beta.2: NuGet's latest Vogen is 9.0.0-beta.10: re-read it there",
+        ], due.Text());
+        asked.ShouldBe(["Vogen", "Vogen", "Vogen", "OneOf", "PostgreSQL"], "KB-001's Vogen pin, then KB-002's; the pin with no version is never looked up");
+        due.Summary.ShouldEndWith("or a later release on NuGet, against which 4 pins compared");
+
+        var released = _repo.Queries().Due(1000, new DateOnly(2026, 10, 29), id => id == "Vogen" ? ["8.0.7", "8.0.8", "9.0.0-beta.2"] : null);
+        released.Rows.Select(row => $"{row.Fields[0].Value} {row.Fields[4].Value}").ShouldBe(
+        [
+            "design/knowledge/KB-001-a-fact.md:6 NuGet's latest stable Vogen is 8.0.8: re-read it there",
+            "design/knowledge/KB-002-competitors.md:4 NuGet's latest stable Vogen is 8.0.8: re-read it there",
+        ], released.Text());
+    }
+
+    [Theory]
+    [InlineData("1.0.0-beta.2", "1.0.0-beta.10", -1)]
+    [InlineData("1.0.0-beta-77", "1.0.0-beta-78", -1)]
+    [InlineData("1.0.0-beta", "1.0.0-beta.1", -1)]
+    [InlineData("1.0.0-alpha.9", "1.0.0-beta", -1)]
+    [InlineData("1.0.0-1", "1.0.0-alpha", -1)]
+    [InlineData("1.0.0-Beta08", "1.0.0-beta08", 0)]
+    [InlineData("1.0.0-rc.1", "1.0.0", -1)]
+    [InlineData("10.6.0", "10.5.1", 1)]
+    public void Versions_are_ordered_as_nuget_orders_them(string left, string right, int expected)
+    {
+        Pins.CompareVersions(left, right).ShouldBe(expected);
+        Pins.CompareVersions(right, left).ShouldBe(-expected);
+    }
 }
diff --git a/test/CodoMetis.TypeKit.DocsQuery.Tests/RepositoryTests.cs b/test/CodoMetis.TypeKit.DocsQuery.Tests/RepositoryTests.cs
index fd61d078..87616598 100644
--- a/test/CodoMetis.TypeKit.DocsQuery.Tests/RepositoryTests.cs
+++ b/test/CodoMetis.TypeKit.DocsQuery.Tests/RepositoryTests.cs
@@ -58,25 +58,6 @@ public void The_repository_checks_clean()
         answer.Rows.ShouldBeEmpty(answer.Text());
     }
 
-    /// <summary>
-    /// Floors on the places the citation rule reads and on the citations it finds there (design/adr/0107), so that a
-    /// scan that found nothing cannot let the check above pass. On 2026-10-17: 3 refused entries, 41 not-promised
-    /// entries, 11 obligation declarations and 87 harness and probe sources were read, and KB-001 and KB-027 were
-    /// cited by not-promised entries, KB-037 twice by the harness.
-    /// </summary>
-    [Theory]
-    [InlineData(FactCitations.Refused, 3, 0)]
-    [InlineData(FactCitations.NotPromised, 30, 2)]
-    [InlineData(FactCitations.Obligation, 10, 0)]
-    [InlineData(FactCitations.Harness, 40, 2)]
-    public void The_corpus_s_citations_of_facts_are_found(string kind, int read, int cited)
-    {
-        var scan = FactCitations.Find(RepositoryRoot.Path);
-
-        scan.Read[kind].ShouldBeGreaterThanOrEqualTo(read);
-        scan.Of(kind).ShouldBeGreaterThanOrEqualTo(cited);
-    }
-
     [Fact]
     public void Every_record_is_listed_with_its_status_and_date() =>
         Queries.List(["kind=adr"]).Rows.ShouldAllBe(row => row.Fields.Single(f => f.Name == "status").Value.Length > 0 && row.Fields.Single(f => f.Name == "date").Value.Length == 10);
diff --git a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/CodoMetis.TypeKit.EntityFrameworkCore.Tests.csproj b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/CodoMetis.TypeKit.EntityFrameworkCore.Tests.csproj
index 7782386b..ce8a11d3 100644
--- a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/CodoMetis.TypeKit.EntityFrameworkCore.Tests.csproj
+++ b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/CodoMetis.TypeKit.EntityFrameworkCore.Tests.csproj
@@ -2,8 +2,8 @@
 
     <!--
       The EF satellite against value objects the real generators wove: the probes, and the model's own
-      identifiers, which this project gets through the probes' transitive fabric. The PostgreSQL round
-      trips start a container, so these tests need Docker.
+      identifiers, which this project gets through the probes' transitive fabric. The PostgreSQL and SQL
+      Server tests start a container, so they need Docker.
     -->
     <ItemGroup>
         <ProjectReference Include="..\..\src\CodoMetis.TypeKit.EntityFrameworkCore\CodoMetis.TypeKit.EntityFrameworkCore.csproj" />
@@ -20,6 +20,8 @@
         <!-- Past the advisories of the 9.0.11 Microsoft.Data.SqlClient brings; see Directory.Packages.props. -->
         <PackageReference Include="System.Security.Cryptography.Pkcs" />
         <PackageReference Include="Testcontainers.PostgreSql" />
+        <!-- SQL Server as a plain container (SqlServer.cs): the module waits through sqlcmd, which Azure SQL Edge has not. -->
+        <PackageReference Include="Testcontainers" />
     </ItemGroup>
 
 </Project>
diff --git a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/DesignTime.cs b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/DesignTime.cs
index 704da534..73eb1faf 100644
--- a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/DesignTime.cs
+++ b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/DesignTime.cs
@@ -30,8 +30,11 @@ public static ServiceProvider Services(DbContext db)
         return services.BuildServiceProvider();
     }
 
-    /// <summary>The context's compiled model, as <c>dotnet ef dbcontext optimize</c> writes it, compiled and loaded.</summary>
-    public static IModel CompiledModel(DbContext db)
+    /// <summary>
+    /// The context's compiled model, as <c>dotnet ef dbcontext optimize</c> writes it, compiled and loaded; with
+    /// <paramref name="nativeAot"/>, as <c>--nativeaot</c> writes it, type mappings included.
+    /// </summary>
+    public static IModel CompiledModel(DbContext db, bool nativeAot = false)
     {
         using var designTime = Services(db);
         var options = new CompiledModelCodeGenerationOptions
@@ -40,6 +43,7 @@ public static IModel CompiledModel(DbContext db)
             ModelNamespace            = $"CompiledModel{Guid.NewGuid():N}",
             Language                  = "C#",
             UseNullableReferenceTypes = true,
+            ForNativeAot              = nativeAot,
         };
         var files = designTime.GetRequiredService<ICompiledModelCodeGeneratorSelector>().Select(options)
                               .GenerateModel(db.GetService<IDesignTimeModel>().Model, options);
diff --git a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/KeyGenerationTests.cs b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/KeyGenerationTests.cs
index 1bc61232..df2783e3 100644
--- a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/KeyGenerationTests.cs
+++ b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/KeyGenerationTests.cs
@@ -1,6 +1,7 @@
 using CodoMetis.TypeKit.ValueObjects;
 using Microsoft.Data.Sqlite;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Metadata;
 
 namespace CodoMetis.TypeKit.EntityFrameworkCore.Tests;
@@ -180,19 +181,26 @@ public void A_char_key_the_application_configures_keeps_its_configuration(string
     }
 
     /// <summary>
-    /// Pinned as documented, not as wanted: where the provider stores a <c>ulong</c> as a <c>decimal</c>
-    /// (SQL Server, PostgreSQL), EF gives a value object's default key a temporary <c>decimal</c>, which is
-    /// negative, and converting it back throws at <c>Add</c>; a plain <c>ulong</c> key gets a temporary
-    /// <c>ulong</c>. Configured <c>ValueGeneratedNever()</c>, the key the application assigns is added.
+    /// A default key over <c>ulong</c> gets a temporary <c>ulong</c> at <c>Add</c>, as a plain key does, also where the
+    /// provider stores it as a <c>decimal</c> (SQL Server, PostgreSQL). EF chooses a temporary number by the property's
+    /// type mapping, which for a value object is its own, so it fell back to the column's type, and the negative
+    /// temporary <c>decimal</c> threw <see cref="OverflowException"/> converted back (decision 63, now 114).
+    /// Configured <c>ValueGeneratedNever()</c>, the key the application assigns is added.
     /// </summary>
     [Theory]
-    [InlineData("sqlserver")]
-    [InlineData("npgsql")]
-    public void A_default_key_over_ulong_throws_at_Add_where_the_column_is_a_decimal(string provider)
+    [MemberData(nameof(AllProviders))]
+    public void A_default_key_over_ulong_gets_a_temporary_value_at_Add_as_a_plain_one_does(string provider)
     {
         using var db = new CharAndULongKeysDb(Options<CharAndULongKeysDb>(provider));
 
-        Should.Throw<OverflowException>(() => db.Add(new KeyedByUInt64()));
+        KeyedByUInt64[] keyed = [new(), new()];
+        KeyedByUlong[] plain  = [new(), new()];
+        db.AddRange([.. keyed, .. plain]);
+
+        keyed.Select(e => db.Entry(e).Property(p => p.Id).IsTemporary)
+             .ShouldBe(plain.Select(e => db.Entry(e).Property(p => p.Id).IsTemporary), $"on {provider}");
+        keyed.Select(e => db.Entry(e).Property(p => p.Id).CurrentValue.Value)
+             .ShouldBe(plain.Select(e => db.Entry(e).Property(p => p.Id).CurrentValue), $"on {provider}");
 
         var assigned = new AssignedUInt64Key { Id = UInt64Key.From(42) };
         db.Add(assigned);
@@ -202,6 +210,106 @@ public void A_default_key_over_ulong_throws_at_Add_where_the_column_is_a_decimal
         Key(db, typeof(AssignedUInt64Key)).ValueGenerated.ShouldBe(ValueGenerated.Never);
     }
 
+    public static TheoryData<string> DecimalColumnProviders => ["sqlserver", "npgsql"];
+
+    /// <summary>
+    /// SQL Server's HiLo still comes before a temporary value, for a <c>ulong</c> key as for a plain one, and hands out
+    /// values that are not temporary. A generator configured on the property would have come before HiLo, so the
+    /// temporary value is the type mapping's (decision 114). No database is opened: this is the generator EF chooses,
+    /// not its values. PostgreSQL's provider refuses HiLo on a <c>ulong</c> key, plain or value object, when it validates the model.
+    /// </summary>
+    [Fact]
+    public void SQL_Server_s_HiLo_still_comes_first_for_a_key_over_ulong()
+    {
+        using var db = new ULongHiLoKeysDb(Options<ULongHiLoKeysDb>("sqlserver"));
+        var selector = db.GetService<Microsoft.EntityFrameworkCore.ValueGeneration.IValueGeneratorSelector>();
+
+        bool Temporary(Type entity)
+        {
+            var entityType = db.Model.FindEntityType(entity)!;
+            selector.TrySelect(entityType.FindPrimaryKey()!.Properties.Single(), entityType, out var generator).ShouldBeTrue(entity.Name);
+            return generator!.GeneratesTemporaryValues;
+        }
+
+        Temporary(typeof(HiLoUlongKey)).ShouldBeFalse();
+        Temporary(typeof(HiLoUInt64Key)).ShouldBeFalse("HiLo was not chosen");
+    }
+
+    /// <summary>A generator the application configures on a <c>ulong</c> key still comes before a temporary value.</summary>
+    [Theory]
+    [MemberData(nameof(DecimalColumnProviders))]
+    public void The_application_s_own_generator_still_comes_first_for_a_key_over_ulong(string provider)
+    {
+        using var db = new ULongHiLoKeysDb(Options<ULongHiLoKeysDb>(provider));
+
+        var own = new OwnGeneratorUInt64Key();
+        db.Add(own);
+
+        own.Id.Value.ShouldBe(7ul, $"on {provider}");
+    }
+
+    /// <summary>
+    /// A compiled model gives a default <c>ulong</c> key the same temporary value: <c>dbcontext optimize</c> leaves the
+    /// type mappings to be found when the model is first used, where <c>UseTypeKit()</c> composes them.
+    /// </summary>
+    [Theory]
+    [MemberData(nameof(DecimalColumnProviders))]
+    public void In_a_compiled_model_a_default_key_over_ulong_gets_a_temporary_value(string provider)
+    {
+        using var db = Compiled(provider, nativeAot: false);
+
+        KeyedByUInt64[] keyed = [new(), new()];
+        KeyedByUlong[] plain  = [new(), new()];
+        db.AddRange([.. keyed, .. plain]);
+
+        keyed.Select(e => db.Entry(e).Property(p => p.Id).IsTemporary).ShouldBe([true, true], $"on {provider}");
+        keyed.Select(e => db.Entry(e).Property(p => p.Id).CurrentValue.Value)
+             .ShouldBe(plain.Select(e => db.Entry(e).Property(p => p.Id).CurrentValue), $"on {provider}");
+    }
+
+    /// <summary>
+    /// Pinned as documented, not as wanted: <c>--nativeaot</c> writes each type mapping out as code, and the factory a
+    /// value object's mapping carries is a delegate it cannot write, so a default <c>ulong</c> key still throws at
+    /// <c>Add</c> where the column is a <c>decimal</c> (decision 114). <c>ValueGeneratedNever()</c> is the workaround.
+    /// </summary>
+    [Theory]
+    [MemberData(nameof(DecimalColumnProviders))]
+    public void In_a_Native_AOT_compiled_model_a_default_key_over_ulong_still_throws_at_Add(string provider)
+    {
+        using var db = Compiled(provider, nativeAot: true);
+
+        Should.Throw<OverflowException>(() => db.Add(new KeyedByUInt64()));
+    }
+
+    /// <summary>
+    /// Pinned as documented, not as wanted: a key configured with <see cref="ValueObjectConverter{TValueObject,T}"/> by hand
+    /// is mapped on that converter, which carries no hints, so a default <c>ulong</c> key still throws at <c>Add</c> where
+    /// the column is a <c>decimal</c> (decision 114).
+    /// </summary>
+    [Theory]
+    [MemberData(nameof(DecimalColumnProviders))]
+    public void A_default_key_over_ulong_with_the_converter_named_by_hand_still_throws_at_Add(string provider)
+    {
+        using var db = new NamedConverterULongKeyDb(Options<NamedConverterULongKeyDb>(provider));
+
+        Should.Throw<OverflowException>(() => db.Add(new KeyedByUInt64()));
+    }
+
+    /// <summary>
+    /// A context on the compiled model, with an internal service provider of its own: EF caches a property's generator
+    /// by the model's id, which a compiled model keeps from the model it was written from.
+    /// </summary>
+    private CompiledULongKeysDb Compiled(string provider, bool nativeAot)
+    {
+        using var design = new CompiledULongKeysDb(Options<CompiledULongKeysDb>(provider));
+        var compiled = DesignTime.CompiledModel(design, nativeAot);
+        var db = new CompiledULongKeysDb(
+            new DbContextOptionsBuilder<CompiledULongKeysDb>(Options<CompiledULongKeysDb>(provider)).UseModel(compiled).EnableServiceProviderCaching(false).Options);
+
+        db.Model.ShouldBeSameAs(compiled);
+        return db;
+    }
+
     /// <summary>
     /// Each integer type SQLite fills a key of, added twice. Not <c>char</c>: EF's own <c>char</c> key asks
     /// SQLite for a <c>TEXT</c> column with <c>AUTOINCREMENT</c>, which it refuses.
@@ -549,10 +657,57 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
         modelBuilder.Entity<GeneratedOnAddCharKey>().Property(e => e.Id).ValueGeneratedOnAdd();
         modelBuilder.Entity<OwnGeneratorCharKey>().Property(e => e.Id).HasValueGenerator<LetterKeyGenerator>();
         modelBuilder.Entity<KeyedByUInt64>();
+        modelBuilder.Entity<KeyedByUlong>();
         modelBuilder.Entity<AssignedUInt64Key>().Property(e => e.Id).ValueGeneratedNever();
     }
 }
 
+public class HiLoUInt64Key { public UInt64Key Id { get; set; } }
+
+public class HiLoUlongKey { public ulong Id { get; set; } }
+
+public class OwnGeneratorUInt64Key { public UInt64Key Id { get; set; } }
+
+public sealed class SevenGenerator : Microsoft.EntityFrameworkCore.ValueGeneration.ValueGenerator<UInt64Key>
+{
+    public override bool GeneratesTemporaryValues => false;
+
+    public override UInt64Key Next(Microsoft.EntityFrameworkCore.ChangeTracking.EntityEntry entry) => UInt64Key.From(7);
+}
+
+/// <summary>A key over <c>ulong</c> configured with the public converter by hand.</summary>
+public sealed class NamedConverterULongKeyDb(DbContextOptions<NamedConverterULongKeyDb> options) : DbContext(options)
+{
+    protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+        modelBuilder.Entity<KeyedByUInt64>().Property(e => e.Id).HasConversion<ValueObjectConverter<UInt64Key, ulong>>();
+}
+
+/// <summary>A default key over <c>ulong</c> and a plain one, for a compiled model, which refuses a generator type.</summary>
+public sealed class CompiledULongKeysDb(DbContextOptions<CompiledULongKeysDb> options) : DbContext(options)
+{
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        modelBuilder.Entity<KeyedByUInt64>();
+        modelBuilder.Entity<KeyedByUlong>();
+    }
+}
+
+/// <summary>Keys over <c>ulong</c> numbered by SQL Server's HiLo, and one numbered by the application's own generator.</summary>
+public sealed class ULongHiLoKeysDb(DbContextOptions<ULongHiLoKeysDb> options) : DbContext(options)
+{
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        // Npgsql refuses HiLo on a ulong key, plain or value object: "Sequences can only be used with integer properties".
+        if (Database.IsSqlServer())
+        {
+            SqlServerPropertyBuilderExtensions.UseHiLo(modelBuilder.Entity<HiLoUInt64Key>().Property(e => e.Id));
+            SqlServerPropertyBuilderExtensions.UseHiLo(modelBuilder.Entity<HiLoUlongKey>().Property(e => e.Id));
+        }
+
+        modelBuilder.Entity<OwnGeneratorUInt64Key>().Property(e => e.Id).HasValueGenerator<SevenGenerator>();
+    }
+}
+
 /// <summary>The keys over the integer types SQLite fills in.</summary>
 public sealed class SqliteIntegerKeysDb(DbContextOptions<SqliteIntegerKeysDb> options) : DbContext(options)
 {
diff --git a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/KeyGenerationVariantTests.cs b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/KeyGenerationVariantTests.cs
index df1fda2c..dd58a4c2 100644
--- a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/KeyGenerationVariantTests.cs
+++ b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/KeyGenerationVariantTests.cs
@@ -88,22 +88,9 @@ public void A_value_object_key_generated_on_add_gets_values_as_a_key_of_the_wrap
         var plain = Added(provider, wrapped.Wrapped, typeKit: false);
         if (plain is null) Assert.Skip("the wrapped type's key is not generated at Add");
 
-        Added(provider, wrapped.ValueObject, typeKit: true).ShouldBe(AddedExpected(provider, wrapped, plain), $"{kind} configured OnAdd on {provider}");
+        Added(provider, wrapped.ValueObject, typeKit: true).ShouldBe(plain, $"{kind} configured OnAdd on {provider}");
     }
 
-    /// <summary>
-    /// The README's departures at <c>Add</c>: "A default key over <c>ulong</c> throws at <c>Add</c> where the column
-    /// is a <c>decimal</c> (SQL Server, PostgreSQL)", and on SQL Server a key over <c>char</c> configured
-    /// <c>ValueGeneratedOnAdd()</c> gets "one character of a GUID string", since EF reaches the generator through the
-    /// column's <c>nvarchar(1)</c>, so sixteen of them collide.
-    /// </summary>
-    private static string? AddedExpected(string provider, WrappedKind kind, string plain) => (provider, kind.Name) switch
-    {
-        ("npgsql" or "sqlserver", "ulong") => null,
-        ("sqlserver", "char")              => null,
-        _                                  => plain,
-    };
-
     /// <summary>What the values generated at <c>Add</c> are, or null where <c>Add</c> generates none or refuses.</summary>
     private string? Added(string provider, Type key, bool typeKit)
     {
diff --git a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/PostgreSqlRoundTripTests.cs b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/PostgreSqlRoundTripTests.cs
index d65a26b5..562d7368 100644
--- a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/PostgreSqlRoundTripTests.cs
+++ b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/PostgreSqlRoundTripTests.cs
@@ -9,6 +9,7 @@ namespace CodoMetis.TypeKit.EntityFrameworkCore.Tests;
 /// A real PostgreSQL: every wrapped-type family survives a round trip, stored values are read back
 /// without the rules, and the translated queries return the rows they should.
 /// </summary>
+[Trait("Needs", "Docker")]
 public sealed class PostgreSqlRoundTripTests(PostgreSqlRoundTripTests.Database database) : IClassFixture<PostgreSqlRoundTripTests.Database>
 {
     [Fact]
diff --git a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/QueryOptionTests.cs b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/QueryOptionTests.cs
index 58099512..cf46fb21 100644
--- a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/QueryOptionTests.cs
+++ b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/QueryOptionTests.cs
@@ -76,8 +76,8 @@ public async Task A_condition_only_the_database_can_run_is_translated()
     /// <summary>
     /// What the documentation says of a condition EF cannot read. A lambda written at the call is an
     /// expression and binds to the query's overload; a <c>Func</c> held in a variable, or a method group,
-    /// binds to the sequence's, which reads every row and runs the condition in memory. No analyzer
-    /// tells it yet, so this pins the behaviour the pages describe.
+    /// binds to the sequence's, which reads every row and runs the condition in memory. CMTK0009 reports
+    /// such a call (<c>QueryDelegateConditionTests</c>); this pins the behaviour it warns of.
     /// </summary>
     [Fact]
     public void A_Func_or_a_method_group_reads_every_row_and_runs_the_condition_in_memory()
diff --git a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/QueryTranslationVariantTests.cs b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/QueryTranslationVariantTests.cs
index fdfa4e7a..a1600950 100644
--- a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/QueryTranslationVariantTests.cs
+++ b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/QueryTranslationVariantTests.cs
@@ -68,32 +68,59 @@ public void A_query_over_a_value_object_answers_as_the_same_query_over_the_wrapp
         if (expectation is Unclaimed unclaimed) Assert.Skip(unclaimed.Reason);
         if (expectation is OpenFinding finding) Assert.Skip($"open finding: {finding.Reason}");
 
-        var valueObject = Run(@case, valueObject: true);
+        if (!AnswersAsTheWrappedType(@case, expectation, Run, out _, out var plain)) return;
+
+        // PostgreSQL translates where it would refuse what SQLite runs: an element column re-typed to the
+        // wrapped type, for one, threw there alone.
+        if (plain is null || PostgreSql(@case, valueObject: false) is not { Refusal: null } wrapped) return;
+        var translated = PostgreSql(@case, valueObject: true)!;
+        if (translated.Refusal is not null)
+            throw new ShouldAssertException($"PostgreSQL refuses what it translates over the wrapped type: {translated.Refusal}");
+        if (ClaimsTheColumn(@case))
+            translated.Sql.ShouldBe(wrapped.Sql, "PostgreSQL's SQL of the same query over the wrapped type");
+    }
+
+    /// <summary>
+    /// The case's query over the value object, run by <paramref name="run"/>, against its expectation: refused as the
+    /// docs say, or answering the rows (and, on a table's column, the SQL) of the same query over the wrapped type, or
+    /// memory's rows where that query is refused or not written. False where a refusal settles the case.
+    /// </summary>
+    /// <remarks>
+    /// <paramref name="differs"/> names the cases a database is known to answer differently from memory, a fact of
+    /// design/knowledge: where memory is the oracle, such a case is left to the caller.
+    /// </remarks>
+    internal static bool AnswersAsTheWrappedType(QueryCase @case, Expectation expectation, Func<QueryCase, bool, Answer> run, out Answer valueObject, out Answer? plain,
+                                                 Func<QueryCase, Answer, Answer, bool>? differs = null)
+    {
+        valueObject = run(@case, true);
+        plain = null;
 
         switch (expectation)
         {
             case RefusedOrdering:
                 Refusal(valueObject, "its ordering is its own CompareTo").ShouldContain(@case.Kind.ValueObject.Name);
-                return;
+                return false;
             // The same last step through EF.Functions, which EF takes in memory too, where a database's function cannot run.
             case RefusedForeign when @case is { Op: Op.Greatest or Op.Least, Site: Site.Column or Site.Nullable }:
                 Refusal(valueObject, "is not supported because the query has switched to client-evaluation");
-                return;
+                return false;
             case RefusedForeign when @case.Op is Op.Select or Op.Distinct:
                 var memory = Memory(@case);
                 if (memory.Refusal is { } thrown)
                 {
                     // r.N!.Value over the null row, read through the converter and then unwrapped in memory, as memory does.
                     valueObject.Refusal.ShouldBeOfType(thrown.GetType(), "the query's last step, which throws in memory too");
-                    return;
+                    return false;
                 }
 
                 valueObject.Refusal.ShouldBeNull("the query's last step, which EF evaluates in memory after reading the value object through its converter");
                 valueObject.Rows.ShouldBe(memory.Rows, "the query's last step, evaluated in memory");
-                return;
+                return false;
             case RefusedForeign:
                 Refusal(valueObject, "could not be translated");
-                return;
+                return false;
+            case NullsLeftOut when differs?.Invoke(@case, valueObject, Memory(@case)) == true:
+                return false;
             case NullsLeftOut:
                 valueObject.Refusal.ShouldBeNull();
                 var nulls = NullRows(@case);
@@ -102,16 +129,17 @@ public void A_query_over_a_value_object_answers_as_the_same_query_over_the_wrapp
                     "the rows memory keeps are the query's and the null rows, which the generated operators sort first");
 
                 // A string has no < to write the wrapped type's query with; memory is no oracle here.
-                if (!new QueryBuilder(@case, valueObject: false).CanBuild) return;
+                if (!new QueryBuilder(@case, valueObject: false).CanBuild) return false;
                 break;
         }
 
-        var plain = new QueryBuilder(@case, valueObject: false).CanBuild ? Run(@case, valueObject: false) : null;
+        plain = new QueryBuilder(@case, valueObject: false).CanBuild ? run(@case, false) : null;
+        if (plain is not { Refusal: null } && differs?.Invoke(@case, valueObject, Memory(@case)) == true) return false;
         if (valueObject.Refusal is not null)
         {
             if (plain is { Refusal: null }) throw new ShouldAssertException($"refused where the same query over the wrapped type answers [{string.Join(", ", plain.Rows!)}]: {valueObject.Refusal}");
             if (plain is null) throw new ShouldAssertException($"refused, where memory answers {Shown(Memory(@case))}: {valueObject.Refusal}");
-            return;
+            return false;
         }
 
         if (plain is { Refusal: null })
@@ -125,14 +153,7 @@ public void A_query_over_a_value_object_answers_as_the_same_query_over_the_wrapp
             valueObject.Rows.ShouldBe(Memory(@case).Rows, $"the rows memory answers, where the wrapped type's query is {(plain is null ? "not written" : "refused")}");
         }
 
-        // PostgreSQL translates where it would refuse what SQLite runs: an element column re-typed to the
-        // wrapped type, for one, threw there alone.
-        if (plain is null || PostgreSql(@case, valueObject: false) is not { Refusal: null } wrapped) return;
-        var translated = PostgreSql(@case, valueObject: true)!;
-        if (translated.Refusal is not null)
-            throw new ShouldAssertException($"PostgreSQL refuses what it translates over the wrapped type: {translated.Refusal}");
-        if (ClaimsTheColumn(@case))
-            translated.Sql.ShouldBe(wrapped.Sql, "PostgreSQL's SQL of the same query over the wrapped type");
+        return true;
     }
 
     /// <summary>A guard against a vacuous run: the catalogue's floor, every kind, site and accessor in it, and the refusals it expects.</summary>
@@ -151,34 +172,53 @@ public void The_catalogue_reaches_every_kind_site_accessor_and_converter()
         all.Count(@case => Expect(@case) is NullsLeftOut).ShouldBeGreaterThan(5);
     }
 
-    private abstract record Expectation;
+    /// <summary>
+    /// A guard on the harness: one seeded database read by many cases at once, as this class and
+    /// <see cref="SqlServerQueryVariantTests"/> read it from two collections, answers each the same rows, never
+    /// "database is locked" (#148).
+    /// </summary>
+    [Fact]
+    public void A_seeded_database_read_by_many_cases_at_once_answers_each_alike()
+    {
+        var @case = QueryShapes.All().First(@case => @case is { Op: Op.OrderBy, Site: Site.Nullable } && Run(@case, valueObject: true).Rows is not null);
+        var first = Run(@case, valueObject: true);
+
+        var answers = new ConcurrentBag<Answer>();
+        Parallel.For(0, 400, new ParallelOptions { MaxDegreeOfParallelism = Math.Max(8, Environment.ProcessorCount * 2) },
+                     _ => answers.Add(Run(@case, valueObject: true)));
+
+        answers.ShouldAllBe(answer => answer.Refusal == null && answer.Rows!.SequenceEqual(first.Rows!),
+                            answers.FirstOrDefault(answer => answer.Refusal != null) is { } refused ? Shown(refused) : null);
+    }
+
+    internal abstract record Expectation;
 
     /// <summary>Answers as the same query over the wrapped type.</summary>
-    private sealed record Same : Expectation;
+    internal sealed record Same : Expectation;
 
     /// <summary>Refused, naming the value object whose own <c>CompareTo</c> the database cannot run.</summary>
-    private sealed record RefusedOrdering : Expectation;
+    internal sealed record RefusedOrdering : Expectation;
 
     /// <summary>
     /// Refused by EF, "could not be translated": the column holds what a converter of the application's own
     /// stores. A final <c>Select</c> or <c>Distinct</c>, which EF evaluates in memory after reading the value
     /// object through that converter, answers as memory does.
     /// </summary>
-    private sealed record RefusedForeign : Expectation;
+    internal sealed record RefusedForeign : Expectation;
 
     /// <summary>
     /// Answers as the same query over the wrapped type, where a null passes no comparison, which is fewer rows
     /// than memory's: a record class's generated operators sort null first (decision 98).
     /// </summary>
-    private sealed record NullsLeftOut : Expectation;
+    internal sealed record NullsLeftOut : Expectation;
 
     /// <summary>A divergence the catalogue found and no decision settles yet: named here, never dropped from the catalogue.</summary>
-    private sealed record OpenFinding(string Reason) : Expectation;
+    internal sealed record OpenFinding(string Reason) : Expectation;
 
-    /// <summary>No sentence of the docs says what the case answers.</summary>
-    private sealed record Unclaimed(string Reason) : Expectation;
+    /// <summary>No sentence of the docs says what the case answers; <paramref name="SqliteOnly"/> where that is SQLite's doing alone.</summary>
+    internal sealed record Unclaimed(string Reason, bool SqliteOnly = false) : Expectation;
 
-    private static Expectation Expect(QueryCase @case)
+    internal static Expectation Expect(QueryCase @case)
     {
         if (@case.IsForeign)
         {
@@ -194,7 +234,7 @@ private static Expectation Expect(QueryCase @case)
         // JSON text EF stores: "1:2:00:00" before "2:00:00", "09:30:00.0000000" against a parameter '09:30:00'. The
         // wrapped type's own max over a TimeSpan column answers the same text order (measured on 2026-10-16).
         if (@case is { Site: Site.CollectionElement, Op: Op.Greatest or Op.Least, ReadsWrapped: true } && (@case.Kind.Wrapped == typeof(TimeSpan) || @case.Kind.Wrapped == typeof(TimeOnly)))
-            return new Unclaimed("SQLite orders a primitive collection's TimeSpan and TimeOnly elements as the text EF stores, and the wrapped type's query is refused there");
+            return new Unclaimed("SQLite orders a primitive collection's TimeSpan and TimeOnly elements as the text EF stores, and the wrapped type's query is refused there", SqliteOnly: true);
 
         // The generated operators of a record class sort null first, so in memory null < x is true; SQL's
         // "N" < @x is unknown for a null N, as it is for the wrapped type's lifted operator.
@@ -226,12 +266,16 @@ private static string Refusal(Answer answer, string expected)
         return answer.Refusal.Message;
     }
 
-    private sealed record Answer(string[]? Rows, string? Sql, Exception? Refusal);
+    internal sealed record Answer(string[]? Rows, string? Sql, Exception? Refusal);
 
-    /// <summary>One in-memory SQLite database per model, seeded once and only read.</summary>
+    /// <summary>
+    /// One in-memory SQLite database per model, seeded once and only read, one query at a time: a connection is not
+    /// thread-safe, and <see cref="SqlServerQueryVariantTests"/> reads the same databases from its own collection, in
+    /// parallel with this one, where two commands at once are "database is locked" (#148).
+    /// </summary>
     private static readonly ConcurrentDictionary<string, Lazy<(SqliteConnection Connection, Exception? Refusal)>> Databases = new();
 
-    private static Answer Run(QueryCase @case, bool valueObject)
+    internal static Answer Run(QueryCase @case, bool valueObject)
     {
         var builder = new QueryBuilder(@case, valueObject);
         var key = @case.IsFilter
@@ -241,16 +285,19 @@ private static Answer Run(QueryCase @case, bool valueObject)
         var (connection, refusal) = Databases.GetOrAdd(key, _ => new Lazy<(SqliteConnection, Exception?)>(() => Seeded(model, builder))).Value;
         if (refusal is not null) return new Answer(null, null, refusal);
 
-        using var db = QueryDb.Create(model, connection);
-        try
-        {
-            var set = (IQueryable)typeof(DbContext).GetMethod(nameof(DbContext.Set), Type.EmptyTypes)!.MakeGenericMethod(builder.Source).Invoke(db, null)!;
-            var (query, ordered) = builder.Build(set.Expression);
-            return Execute(set.Provider, query, ordered, sql: true);
-        }
-        catch (Exception exception) when (exception is not ShouldAssertException)
+        lock (connection)
         {
-            return new Answer(null, null, Unwrapped(exception));
+            using var db = QueryDb.Create(model, connection);
+            try
+            {
+                var set = (IQueryable)typeof(DbContext).GetMethod(nameof(DbContext.Set), Type.EmptyTypes)!.MakeGenericMethod(builder.Source).Invoke(db, null)!;
+                var (query, ordered) = builder.Build(set.Expression);
+                return Execute(set.Provider, query, ordered, sql: true);
+            }
+            catch (Exception exception) when (exception is not ShouldAssertException)
+            {
+                return new Answer(null, null, Unwrapped(exception));
+            }
         }
     }
 
@@ -281,7 +328,7 @@ private static Answer Run(QueryCase @case, bool valueObject)
     /// The same query over the value objects in memory, with the query filter applied as EF would, and
     /// <c>EF.Functions</c> answered as <see cref="InMemoryFunctions"/> does.
     /// </summary>
-    private static Answer Memory(QueryCase @case)
+    internal static Answer Memory(QueryCase @case)
     {
         var builder = new QueryBuilder(@case, valueObject: true);
         var source = Queryable.AsQueryable(Seed.Entities(builder, @case.Kind, valueObject: true));
@@ -302,7 +349,9 @@ private static Answer Memory(QueryCase @case)
     /// <summary>
     /// <c>EF.Functions.Greatest</c>, <c>Least</c> and Npgsql's row-value comparisons, which throw outside a query, as
     /// SQLite answers them: by each type's default comparer, which is the wrapped type's order for a value object
-    /// that declares none of its own, and a null wherever <c>Greatest</c> or <c>Least</c> meets one.
+    /// that declares none of its own, and a null wherever <c>Greatest</c> or <c>Least</c> meets one. Text compares
+    /// ordinally, as SQLite's <c>max</c> and a value object's generated comparison do, where a string's default
+    /// comparer follows the culture.
     /// </summary>
     private sealed class InMemoryFunctions : ExpressionVisitor
     {
@@ -322,7 +371,9 @@ protected override Expression VisitMethodCall(MethodCallExpression node)
         public static T Least<T>(T[] values) => Pick(values, order => order < 0);
 
         private static T Pick<T>(T[] values, Func<int, bool> keeps) =>
-            values.Any(value => value is null) ? default! : values.Aggregate((kept, value) => keeps(Comparer<T>.Default.Compare(value, kept)) ? value : kept);
+            values.Any(value => value is null) ? default! : values.Aggregate((kept, value) => keeps(Order<T>().Compare(value, kept)) ? value : kept);
+
+        private static IComparer<T> Order<T>() => typeof(T) == typeof(string) ? (IComparer<T>)StringComparer.Ordinal : Comparer<T>.Default;
 
         /// <summary>A tuple's own order is its elements', one after the other, each by its default comparer.</summary>
         public static bool RowValue(string comparison, ITuple left, ITuple right)
@@ -339,7 +390,7 @@ public static bool RowValue(string comparison, ITuple left, ITuple right)
     }
 
     /// <summary>An answer as a message shows it: its rows, or its refusal.</summary>
-    private static string Shown(Answer answer) =>
+    internal static string Shown(Answer answer) =>
         answer.Refusal is { } refusal ? $"refused ({refusal.Message})" : $"[{string.Join(", ", answer.Rows!)}]";
 
     private static (SqliteConnection, Exception?) Seeded(QueryModel model, QueryBuilder builder)
@@ -360,7 +411,7 @@ private static (SqliteConnection, Exception?) Seeded(QueryModel model, QueryBuil
         }
     }
 
-    private static Answer Execute(IQueryProvider provider, Expression query, bool ordered, bool sql)
+    internal static Answer Execute(IQueryProvider provider, Expression query, bool ordered, bool sql)
     {
         if (!typeof(IQueryable).IsAssignableFrom(query.Type))
             return new Answer([Text(provider.Execute(query))], null, null);
@@ -379,5 +430,5 @@ private static string Text(object? value) =>
             ? $"#{id.GetValue(value)}"
             : WrappedKind.Text(value);
 
-    private static Exception Unwrapped(Exception exception) => exception is TargetInvocationException { InnerException: { } inner } ? Unwrapped(inner) : exception;
+    internal static Exception Unwrapped(Exception exception) => exception is TargetInvocationException { InnerException: { } inner } ? Unwrapped(inner) : exception;
 }
diff --git a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/SqlServer.cs b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/SqlServer.cs
new file mode 100644
index 00000000..f53ac770
--- /dev/null
+++ b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/SqlServer.cs
@@ -0,0 +1,91 @@
+using System.Collections.Concurrent;
+using Microsoft.Data.SqlClient;
+using DotNet.Testcontainers.Builders;
+using DotNet.Testcontainers.Containers;
+
+namespace CodoMetis.TypeKit.EntityFrameworkCore.Tests;
+
+/// <summary>
+/// One SQL Server container for every class of the <see cref="SqlServerCollection"/>, started when the first of
+/// them runs: the server takes seconds to start, and a class that needs it never starts one of its own.
+/// </summary>
+/// <remarks>
+/// SQL Server 2022's Linux image, which CI runs and the design/knowledge entries pin. It is amd64 only: on an
+/// arm64 machine Docker must emulate it with Rosetta, since under QEMU it stops at start ("Unable to create a new
+/// asynchronous I/O context"). <c>TYPEKIT_MSSQL_IMAGE</c> names another image, such as the native arm64
+/// <c>mcr.microsoft.com/azure-sql-edge</c>, whose older engine lacks some of 2022's functions. A database is made
+/// for each class (<see cref="DatabaseAsync"/>), under the server's default collation,
+/// <c>SQL_Latin1_General_CP1_CI_AS</c>, which is case-insensitive.
+/// </remarks>
+public sealed class SqlServer : IAsyncLifetime
+{
+    public const string ImageVariable = "TYPEKIT_MSSQL_IMAGE";
+
+    private const string Password = "TypeKit-2026!";
+
+    /// <summary>Started by its log line: Testcontainers' module waits through <c>sqlcmd</c>, which Azure SQL Edge's image has not.</summary>
+    private readonly IContainer _container =
+        new ContainerBuilder(Environment.GetEnvironmentVariable(ImageVariable) is { Length: > 0 } image ? image : "mcr.microsoft.com/mssql/server:2022-latest")
+            .WithEnvironment("ACCEPT_EULA", "Y")
+            .WithEnvironment("MSSQL_SA_PASSWORD", Password)
+            .WithPortBinding(1433, assignRandomHostPort: true)
+            .WithWaitStrategy(Wait.ForUnixContainer().UntilMessageIsLogged("SQL Server is now ready for client connections"))
+            .Build();
+
+    private readonly ConcurrentDictionary<string, Task<string>> _databases = new();
+
+    private string ConnectionString(string database) => new SqlConnectionStringBuilder
+    {
+        DataSource = $"{_container.Hostname},{_container.GetMappedPublicPort(1433)}",
+        UserID = "sa",
+        Password = Password,
+        InitialCatalog = database,
+        TrustServerCertificate = true,
+    }.ConnectionString;
+
+    /// <summary>A database of its own on the server, created empty the first time it is asked for, and its connection string.</summary>
+    public Task<string> DatabaseAsync(string name) => _databases.GetOrAdd(name, CreateAsync);
+
+    private async Task<string> CreateAsync(string name)
+    {
+        await using var connection = await OpenAsync(ConnectionString("master"));
+        await using var create = connection.CreateCommand();
+        create.CommandText = $"IF DB_ID(N'{name}') IS NOT NULL DROP DATABASE [{name}]; CREATE DATABASE [{name}];";
+        await create.ExecuteNonQueryAsync();
+
+        return ConnectionString(name);
+    }
+
+    /// <summary>
+    /// The server logs that it is ready before the login works, the first time it starts (a "Login failed for user 'sa'"
+    /// for some seconds after), so the first connection is tried again for a minute.
+    /// </summary>
+    private static async Task<SqlConnection> OpenAsync(string connectionString)
+    {
+        for (var attempt = 1; ; attempt++)
+        {
+            var connection = new SqlConnection(connectionString);
+            try
+            {
+                await connection.OpenAsync();
+                return connection;
+            }
+            catch (SqlException) when (attempt < 60)
+            {
+                await connection.DisposeAsync();
+                await Task.Delay(TimeSpan.FromSeconds(1));
+            }
+        }
+    }
+
+    public async ValueTask InitializeAsync() => await _container.StartAsync();
+
+    public async ValueTask DisposeAsync() => await _container.DisposeAsync();
+}
+
+/// <summary>The classes that share the SQL Server container; CI's Windows and macOS legs, which cannot start it, leave them out.</summary>
+[CollectionDefinition(Name)]
+public sealed class SqlServerCollection : ICollectionFixture<SqlServer>
+{
+    public const string Name = "SQL Server";
+}
diff --git a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/SqlServerKeyVariantTests.cs b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/SqlServerKeyVariantTests.cs
new file mode 100644
index 00000000..ef42e4b1
--- /dev/null
+++ b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/SqlServerKeyVariantTests.cs
@@ -0,0 +1,188 @@
+using System.Globalization;
+using CodoMetis.TypeKit.EntityFrameworkCore.Tests.Variants;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Storage;
+
+namespace CodoMetis.TypeKit.EntityFrameworkCore.Tests;
+
+/// <summary>
+/// The key-generation catalogue (<see cref="KeyShapes"/>) inserted into a real SQL Server and read back: every shape
+/// keyed by every kind of <see cref="WrappedKinds.Keys"/>, under <c>UseTypeKit()</c> and keyed by the wrapped type
+/// under plain EF, each in a schema of its own.
+/// </summary>
+/// <remarks>
+/// <see cref="KeyGenerationVariantTests"/> holds the model: a value-object key is generated as a key of the wrapped
+/// type is. Here the database answers. A key the model generates is left unset, one it does not is assigned, and
+/// every key reads back as it was after <c>SaveChanges</c>. Where the database numbers the keys (an identity column,
+/// TPC's sequence), the value object gets the numbers the wrapped type gets.
+/// </remarks>
+[Collection(SqlServerCollection.Name)]
+[Trait("Needs", "Docker")]
+public sealed class SqlServerKeyVariantTests(SqlServer server)
+{
+    public static TheoryData<KeyShape, string> Cases
+    {
+        get
+        {
+            var cases = new TheoryData<KeyShape, string>();
+            foreach (var (_, shape, kind) in KeyShapes.All().Where(@case => @case.Provider == "sqlserver")) cases.Add(shape, kind.Name);
+            return cases;
+        }
+    }
+
+    [Theory]
+    [MemberData(nameof(Cases))]
+    public async Task A_value_object_key_is_stored_and_read_back_as_a_key_of_the_wrapped_type_is(KeyShape shape, string kind)
+    {
+        var wrapped = WrappedKinds.Named(kind);
+        var database = await server.DatabaseAsync("typekit_keys");
+
+        var plain = Inserted(shape, wrapped, typeKit: false, database);
+        var valueObject = Inserted(shape, wrapped, typeKit: true, database);
+        var keys = $"{shape} keyed by {kind}: value object [{string.Join(", ", valueObject.Saved)}], wrapped type [{string.Join(", ", plain.Saved)}]";
+
+        if (plain.Refusal is not null)
+        {
+            if (valueObject.Refusal is not null) Assert.Skip($"refused for the wrapped type and the value object alike: {plain.Refusal}");
+
+            // A key over char, which the application assigns (the README's exception), where EF generates the plain one as NULL.
+            wrapped.Wrapped.ShouldBe(typeof(char), $"stored where the wrapped type's keys are refused ({plain.Refusal}); {keys}");
+            ReadBack(valueObject, wrapped).ShouldBe(Saved(valueObject, wrapped), ignoreOrder: true, $"the keys read back; {keys}");
+            return;
+        }
+
+        valueObject.Refusal.ShouldBeNull(keys);
+        ReadBack(valueObject, wrapped).ShouldBe(Saved(valueObject, wrapped), ignoreOrder: true, $"the keys read back; {keys}");
+        ReadBack(plain, wrapped).ShouldBe(Saved(plain, wrapped), ignoreOrder: true, $"the wrapped type's keys read back; {keys}");
+
+        // The README's two exceptions: a key over char or Guid is the application's to assign unless configured.
+        var assigned = (wrapped.Wrapped == typeof(char) || wrapped.Wrapped == typeof(Guid)) && shape is not (KeyShape.ConfiguredOnAdd or KeyShape.ConfiguredNever);
+        valueObject.Generated.ShouldBe(plain.Generated && !assigned, keys);
+        valueObject.Numbered.ShouldBe(plain.Numbered && !assigned, keys);
+        if (plain.Numbered && IsInteger(wrapped.Wrapped))
+            valueObject.Saved.ShouldBe(plain.Saved, $"the keys SQL Server numbered; {keys}");
+    }
+
+    /// <summary>A guard against a vacuous run: every shape crossed with every key kind, and the database numbering some.</summary>
+    [Fact]
+    public void The_catalogue_crosses_every_shape_with_every_key_kind() =>
+        Cases.Count.ShouldBe(Enum.GetValues<KeyShape>().Length * WrappedKinds.Keys.Length);
+
+    /// <summary>
+    /// A decimal reads back at its column's scale, <c>1.50</c> for <c>1.5</c> in SQL Server's default <c>decimal(18,2)</c>
+    /// (KB-050), and is the same number: decimal keys are compared as numbers.
+    /// </summary>
+    private static string[] ReadBack(Keys keys, WrappedKind kind) => kind.Wrapped == typeof(decimal) ? [.. keys.Read.Select(Number)] : keys.Read;
+
+    private static string[] Saved(Keys keys, WrappedKind kind) => kind.Wrapped == typeof(decimal) ? [.. keys.Saved.Select(Number)] : keys.Saved;
+
+    private static string Number(string key) =>
+        string.Join("/", key.Split('/').Select(part => decimal.Parse(part, CultureInfo.InvariantCulture).ToString("0.############", CultureInfo.InvariantCulture)));
+
+    private static int _schemas;
+
+    /// <summary>The keys saved and read back, whether the subject's key is generated, and whether the database left any key it saved to the database.</summary>
+    private sealed record Keys(string[] Saved, string[] Read, bool Generated, bool Numbered, string? Refusal);
+
+    /// <summary>Two entities of the shape saved, the keys they have after <c>SaveChanges</c>, and the keys a fresh context reads.</summary>
+    private static Keys Inserted(KeyShape shape, WrappedKind kind, bool typeKit, string database)
+    {
+        var key = typeKit ? kind.ValueObject : kind.Wrapped;
+        var schema = $"k{Interlocked.Increment(ref _schemas)}";
+        try
+        {
+            using (var create = KeyShapeDb.OnSqlServer(shape, key, typeKit, database, schema))
+                create.GetService<IRelationalDatabaseCreator>().CreateTables();
+
+            string[] saved;
+            bool generated, numbered;
+            using (var db = KeyShapeDb.OnSqlServer(shape, key, typeKit, database, schema))
+            {
+                generated = KeyShapes.KeyOf(db, shape, key) is [{ ValueGenerated: ValueGenerated.OnAdd }];
+                object Value(int index) => typeKit ? kind.Wrap(kind.Values[index]) : kind.Values[index];
+                (saved, numbered) = Save(db, shape, key, Value);
+            }
+
+            using var read = KeyShapeDb.OnSqlServer(shape, key, typeKit, database, schema);
+            return new Keys(saved, Read(read, shape, key), generated, numbered, null);
+        }
+        catch (Exception exception) when (exception is not ShouldAssertException)
+        {
+            return new Keys([], [], false, false, $"{exception.GetType().Name}: {exception.GetBaseException().Message}");
+        }
+    }
+
+    /// <summary>The shape's entities saved, each key left to the model's generation or assigned, and whether any was left.</summary>
+    private static (string[] Saved, bool Numbered) Save(KeyShapeDb db, KeyShape shape, Type key, Func<int, object> value)
+    {
+        var numbered = false;
+        Type Closed(Type definition) => definition.MakeGenericType(key);
+        object New(Type type, int index)
+        {
+            var entity = Activator.CreateInstance(type)!;
+            if (db.Model.FindEntityType(type)!.FindPrimaryKey()!.Properties is [{ ValueGenerated: ValueGenerated.OnAdd }]) numbered = true;
+            else type.GetProperty("Id")!.SetValue(entity, value(index));
+            return entity;
+        }
+
+        object[] entities = shape switch
+        {
+            KeyShape.TphRoot or KeyShape.TptRoot or KeyShape.TpcRoot                         => [New(Closed(typeof(Root<>)), 0), New(Closed(typeof(Leaf<>)), 1)],
+            KeyShape.AbstractTphRoot or KeyShape.AbstractTptRoot or KeyShape.AbstractTpcRoot => [New(Closed(typeof(LeafA<>)), 0), New(Closed(typeof(LeafB<>)), 1)],
+            KeyShape.OwnedDependent                                                          => [New(Closed(typeof(Owner<>)), 0), New(Closed(typeof(Owner<>)), 1)],
+            KeyShape.SharedKeyDependent or KeyShape.TableSplitDependent                      => [New(Closed(typeof(Principal<>)), 0), New(Closed(typeof(Principal<>)), 1)],
+            KeyShape.Composite                                                               => [Composite(key, value(0), value(1)), Composite(key, value(1), value(0))],
+            _                                                                                => [New(Closed(typeof(Alone<>)), 0), New(Closed(typeof(Alone<>)), 1)],
+        };
+        db.AddRange(entities);
+        db.SaveChanges();
+
+        // A dependent's key is its principal's, so the dependents follow the principals they share it with.
+        if (shape is KeyShape.SharedKeyDependent or KeyShape.TableSplitDependent)
+        {
+            object[] dependents = [.. entities.Select(principal =>
+            {
+                var dependent = Activator.CreateInstance(Closed(typeof(Dependent<>)))!;
+                dependent.GetType().GetProperty("Id")!.SetValue(dependent, principal.GetType().GetProperty("Id")!.GetValue(principal));
+                return dependent;
+            })];
+            db.AddRange(dependents);
+            db.SaveChanges();
+            entities = dependents;
+        }
+
+        return ([.. entities.Select(Text)], numbered);
+    }
+
+    private static object Composite(Type key, object id, object line)
+    {
+        var entity = Activator.CreateInstance(typeof(Composite<>).MakeGenericType(key))!;
+        entity.GetType().GetProperty("Id")!.SetValue(entity, id);
+        entity.GetType().GetProperty("Line")!.SetValue(entity, line);
+        return entity;
+    }
+
+    /// <summary>The keys of the entities the shape is about, as a fresh context reads them.</summary>
+    private static string[] Read(KeyShapeDb db, KeyShape shape, Type key)
+    {
+        var type = shape switch
+        {
+            KeyShape.OwnedDependent => typeof(Owner<>).MakeGenericType(key),
+            _                       => KeyShapes.Subject(shape, key),
+        };
+        var set = (IQueryable)typeof(DbContext).GetMethod(nameof(DbContext.Set), Type.EmptyTypes)!.MakeGenericMethod(type).Invoke(db, null)!;
+        return [.. set.Cast<object>().AsEnumerable().Select(Text)];
+    }
+
+    /// <summary>An entity's key as text, both properties of a composite one.</summary>
+    private static string Text(object entity) =>
+        entity.GetType().GetProperty("Line") is { } line
+            ? $"{WrappedKind.Text(entity.GetType().GetProperty("Id")!.GetValue(entity))}/{WrappedKind.Text(line.GetValue(entity))}"
+            : WrappedKind.Text(entity.GetType().GetProperty("Id")!.GetValue(entity));
+
+    private static bool IsInteger(Type type) =>
+        type == typeof(int) || type == typeof(long) || type == typeof(short) || type == typeof(sbyte) || type == typeof(byte)
+     || type == typeof(uint) || type == typeof(ulong) || type == typeof(ushort);
+}
diff --git a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/SqlServerQueryVariantTests.cs b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/SqlServerQueryVariantTests.cs
new file mode 100644
index 00000000..aafe945f
--- /dev/null
+++ b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/SqlServerQueryVariantTests.cs
@@ -0,0 +1,197 @@
+using System.Collections.Concurrent;
+using System.Globalization;
+using CodoMetis.TypeKit.EntityFrameworkCore.Tests.Variants;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage;
+using static CodoMetis.TypeKit.EntityFrameworkCore.Tests.QueryTranslationVariantTests;
+
+namespace CodoMetis.TypeKit.EntityFrameworkCore.Tests;
+
+/// <summary>
+/// The query-translation catalogue (<see cref="QueryShapes"/>) run on a real SQL Server: each query over a value
+/// object against the same query over the wrapped type there, as <see cref="QueryTranslationVariantTests"/> runs
+/// it on SQLite, and then against the same query over the objects in memory.
+/// </summary>
+/// <remarks>
+/// An answer that differs from memory's is SQL Server's own only where SQLite answers as memory does: a null
+/// <c>.Value</c> that throws in memory and is a NULL in SQL, or a query EF translates for neither, is the relational
+/// providers' alike. Each difference that is SQL Server's alone is a fact of design/knowledge, named in
+/// <see cref="Known"/>; any other fails.
+/// </remarks>
+[Collection(SqlServerCollection.Name)]
+[Trait("Needs", "Docker")]
+public sealed class SqlServerQueryVariantTests(SqlServer server)
+{
+    public static TheoryData<string, Conversion, Site, Accessor, Op> Cases => QueryTranslationVariantTests.Cases;
+
+    [Theory]
+    [MemberData(nameof(Cases))]
+    public async Task On_SQL_Server_a_query_over_a_value_object_answers_as_the_same_query_over_the_wrapped_type_and_as_memory(
+        string kind, Conversion conversion, Site site, Accessor accessor, Op op)
+    {
+        var @case = QueryShapes.Find(new QueryCase(WrappedKinds.Named(kind), conversion, site, accessor, op).Id);
+        var expectation = Expect(@case);
+        if (expectation is Unclaimed { SqliteOnly: false } unclaimed) Assert.Skip(unclaimed.Reason);
+        if (expectation is OpenFinding finding) Assert.Skip($"open finding: {finding.Reason}");
+        if (expectation is Unclaimed) expectation = new Same();
+
+        var database = await server.DatabaseAsync("typekit_queries");
+        AnswersAsTheWrappedType(@case, expectation, (c, valueObject) => Run(c, valueObject, database), out var answer, out _,
+                                differs: (c, onSqlServer, memory) => Known(c, onSqlServer, memory) is not null);
+        if (expectation is not (Same or NullsLeftOut)) return;
+
+        // EF.Functions.Greatest and Least, which EF translates on SQL Server from compatibility level 160 alone (KB-053):
+        // there the SQL is the wrapped type's, translated without a server.
+        if (@case.Op is Op.Greatest or Op.Least && answer.Refusal is not null)
+        {
+            // Over a primitive collection's element EF refuses them on SQLite too, and a TimeSpan table is refused its rows (KB-051).
+            if (Refusal(answer) is not DbUpdateException)
+                answer.Refusal!.Message.ShouldMatch("is not supported because the query has switched to client-evaluation|could not be translated");
+            AtLevel160(@case, database);
+            return;
+        }
+
+        var memory = Memory(@case);
+        if (Agree(answer, memory)) return;
+
+        var sqlite = QueryTranslationVariantTests.Run(@case, valueObject: true);
+        if (Agree(answer, sqlite)) return;
+
+        // r.N!.Value.Value throws in memory on the row without one, where SQL reads a NULL, as ValueOrNull() does.
+        if (memory.Refusal is not null && @case is { Site: Site.Nullable, Accessor: Accessor.ValueThroughTypeParameter }
+         && QueryShapes.All().FirstOrDefault(other => other == @case with { Accessor = Accessor.ValueOrNull }) is { } orNull)
+        {
+            answer.Rows.ShouldBe(Run(orNull, valueObject: true, database).Rows, $"the same query through ValueOrNull(), where memory throws: {memory.Refusal.Message}");
+            return;
+        }
+
+        if (Known(@case, answer, memory) is null)
+            throw new ShouldAssertException($"SQL Server answers {Shown(answer)}, where memory answers {Shown(memory)} and SQLite {Shown(sqlite)}");
+    }
+
+    /// <summary>
+    /// A guard against a vacuous run: the catalogue holds the cases each fact is about, and the facts that a case's
+    /// answer decides (a decimal's scale, a refused aggregate) excuse no other answer.
+    /// </summary>
+    [Fact]
+    public void Every_known_difference_is_one_the_catalogue_reaches()
+    {
+        Answer Rows(params string[] rows) => new(rows, null, null);
+
+        QueryShapes.All().Select(@case => Known(@case, Rows("0"), Rows("1"))).OfType<string>().Distinct().ShouldBe([TextCollation, GuidOrder, TimeUnderADay], ignoreOrder: true);
+        var decimals = QueryShapes.All().Where(@case => @case.Kind == WrappedKinds.Decimal).ToList();
+        decimals.Any(@case => Known(@case, Rows("10.00"), Rows("10")) == DecimalScale).ShouldBeTrue("a decimal read back at another scale");
+        decimals.All(@case => Known(@case, Rows("10.01"), Rows("10")) is null).ShouldBeTrue("a decimal read back as another number is no difference of scale");
+        var refused = new Answer(null, null, new InvalidOperationException("Operand data type bit is invalid for max operator."));
+        QueryShapes.All().Where(@case => @case.Kind == WrappedKinds.Boolean).Any(@case => Known(@case, refused, Rows("1")) == BitAggregate).ShouldBeTrue("a refused MAX of a bit");
+    }
+
+    private const string TextCollation = "KB-048: SQL Server compares and orders text by the database's collation, case-insensitive by default";
+
+    private const string GuidOrder = "KB-049: SQL Server orders a uniqueidentifier by its last group first";
+
+    private const string DecimalScale = "KB-050: a decimal reads back at its column's scale, decimal(18,2) unless configured";
+
+    private const string TimeUnderADay = "KB-051: SQL Server's time holds less than a day, so a TimeSpan of a day or more is refused in a column and misread in JSON";
+
+    private const string BitAggregate = "KB-052: SQL Server takes neither MAX nor MIN of a bit";
+
+    /// <summary>
+    /// The differences from memory that are SQL Server's own, each pinned in design/knowledge with a test of plain
+    /// EF Core there (<c>test/CodoMetis.TypeKit.Facts</c>); null for any other.
+    /// </summary>
+    private static string? Known(QueryCase @case, Answer answer, Answer memory)
+    {
+        var wrapped = @case.Kind.Wrapped;
+        if ((wrapped == typeof(string) || wrapped == typeof(char)) && @case.Orders && answer.Refusal is null) return TextCollation;
+        if (wrapped == typeof(Guid) && @case.Orders && answer.Refusal is null) return GuidOrder;
+        if (wrapped == typeof(decimal) && answer.Rows is { } rows && memory.Rows is { } expected && rows.Length == expected.Length
+         && rows.Zip(expected).All(pair => pair.First == pair.Second || decimal.TryParse(pair.First, CultureInfo.InvariantCulture, out var read) && read == decimal.Parse(pair.Second, CultureInfo.InvariantCulture)))
+            return DecimalScale;
+        if (wrapped == typeof(TimeSpan) && (answer.Refusal is DbUpdateException || @case.Site is Site.JsonProperty or Site.CollectionElement)) return TimeUnderADay;
+        if (wrapped == typeof(bool) && answer.Refusal?.Message.Contains("Operand data type bit is invalid", StringComparison.Ordinal) == true) return BitAggregate;
+        return null;
+    }
+
+    /// <summary>The SQL of the case at compatibility level 160, over the value object and over the wrapped type, written without a server.</summary>
+    private static void AtLevel160(QueryCase @case, string database)
+    {
+        Answer Translated(bool valueObject)
+        {
+            var builder = new QueryBuilder(@case, valueObject);
+            using var db = QueryDb.OnSqlServer(new QueryModel($"{@case.Id} | {valueObject} | 160", @case, valueObject), database, compatibilityLevel: 160);
+            try
+            {
+                var set = (IQueryable)typeof(DbContext).GetMethod(nameof(DbContext.Set), Type.EmptyTypes)!.MakeGenericMethod(builder.Source).Invoke(db, null)!;
+                return new Answer(null, set.Provider.CreateQuery(builder.Build(set.Expression).Query).ToQueryString(), null);
+            }
+            catch (Exception exception) when (exception is not ShouldAssertException)
+            {
+                return new Answer(null, null, Unwrapped(exception));
+            }
+        }
+
+        if (!new QueryBuilder(@case, valueObject: false).CanBuild || Translated(valueObject: false) is not { Refusal: null } plain) return;
+
+        var translated = Translated(valueObject: true);
+        translated.Refusal.ShouldBeNull("refused at compatibility level 160, where the same query over the wrapped type translates");
+        translated.Sql.ShouldBe(plain.Sql, "the SQL of the same query over the wrapped type at compatibility level 160");
+    }
+
+    private static Exception Refusal(Answer answer) => answer.Refusal ?? throw new ShouldAssertException($"answered {Shown(answer)}");
+
+    /// <summary>The same rows, or both refused.</summary>
+    private static bool Agree(Answer left, Answer right) =>
+        left.Refusal is not null && right.Refusal is not null || left.Rows is { } rows && right.Rows is { } other && rows.SequenceEqual(other);
+
+    /// <summary>The schema each model was seeded into, all in one database, seeded once and only read.</summary>
+    private static readonly ConcurrentDictionary<string, Lazy<(QueryModel Model, Exception? Refusal)>> Schemas = new();
+
+    private static int _schemas;
+
+    private static Answer Run(QueryCase @case, bool valueObject, string database)
+    {
+        var builder = new QueryBuilder(@case, valueObject);
+        var key = @case.IsFilter
+                      ? $"{@case.Id} | {valueObject}"
+                      : $"{@case.Kind.Name} | {(valueObject ? @case.Conversion : Conversion.TypeKit)} | {builder.Source.Name} | {valueObject}";
+        var (model, refusal) = Schemas.GetOrAdd(key, _ => new Lazy<(QueryModel, Exception?)>(() =>
+        {
+            var seeded = new QueryModel(key, @case, valueObject, $"m{Interlocked.Increment(ref _schemas)}");
+            return (seeded, Seeded(seeded, builder, database));
+        })).Value;
+        if (refusal is not null) return new Answer(null, null, refusal);
+
+        using var db = QueryDb.OnSqlServer(model, database);
+        try
+        {
+            var set = (IQueryable)typeof(DbContext).GetMethod(nameof(DbContext.Set), Type.EmptyTypes)!.MakeGenericMethod(builder.Source).Invoke(db, null)!;
+            var (query, ordered) = builder.Build(set.Expression);
+            var answer = Execute(set.Provider, query, ordered, sql: true);
+
+            // Each model has a schema of its own; the SQL compared is the rest.
+            return answer with { Sql = answer.Sql?.Replace($"[{model.Schema}].", "", StringComparison.Ordinal) };
+        }
+        catch (Exception exception) when (exception is not ShouldAssertException)
+        {
+            return new Answer(null, null, Unwrapped(exception));
+        }
+    }
+
+    private static Exception? Seeded(QueryModel model, QueryBuilder builder, string database)
+    {
+        try
+        {
+            using var db = QueryDb.OnSqlServer(model, database);
+            db.GetService<IRelationalDatabaseCreator>().CreateTables();
+            db.AddRange(Seed.Stored(builder, model.Case.Kind, model.ValueObject));
+            db.SaveChanges();
+            return null;
+        }
+        catch (Exception exception) when (exception is not ShouldAssertException)
+        {
+            return Unwrapped(exception);
+        }
+    }
+}
diff --git a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/SqlServerRoundTripTests.cs b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/SqlServerRoundTripTests.cs
new file mode 100644
index 00000000..52cd744f
--- /dev/null
+++ b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/SqlServerRoundTripTests.cs
@@ -0,0 +1,176 @@
+using System.Globalization;
+using CodoMetis.TypeKit.Generators.Probes;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.EntityFrameworkCore.Metadata;
+
+namespace CodoMetis.TypeKit.EntityFrameworkCore.Tests;
+
+/// <summary>
+/// A real SQL Server, as <see cref="PostgreSqlRoundTripTests"/> is a real PostgreSQL: every wrapped-type family survives
+/// a round trip, stored values are read back without the rules, the translated queries return the rows they should,
+/// and what SQL Server does differently from memory (design/knowledge KB-048 to KB-054) a value object does as the
+/// type it wraps does.
+/// </summary>
+[Collection(SqlServerCollection.Name)]
+[Trait("Needs", "Docker")]
+public sealed class SqlServerRoundTripTests(SqlServer server)
+{
+    private async Task<TestDb> CreateAsync()
+    {
+        var options = new DbContextOptionsBuilder<TestDb>().UseSqlServer(await server.DatabaseAsync("typekit_round_trips")).UseTypeKit()
+                                                           .ConfigureWarnings(warnings => warnings.Ignore(CoreEventId.ManyServiceProvidersCreatedWarning))
+                                                           .Options;
+        var db = new TestDb(options);
+        await db.Database.EnsureCreatedAsync(TestContext.Current.CancellationToken);
+        return db;
+    }
+
+    private async Task<(Customer Customer, Order Order)> SeedAsync(Action<Order>? adjust = null)
+    {
+        var customer = new Customer { Id = CustomerId.New(), Name = $"customer {Guid.NewGuid():N}" };
+        var order    = Order.Sample(customer.Id);
+        adjust?.Invoke(order);
+
+        await using var db = await CreateAsync();
+        db.AddRange(customer, order);
+        await db.SaveChangesAsync(TestContext.Current.CancellationToken);
+
+        return (customer, order);
+    }
+
+    [Fact]
+    public async Task Every_value_object_round_trips_and_the_navigation_loads()
+    {
+        var (customer, saved) = await SeedAsync();
+
+        await using var db = await CreateAsync();
+        var loaded = await db.Orders.Include(o => o.Customer).SingleAsync(o => o.Id == saved.Id, TestContext.Current.CancellationToken);
+
+        loaded.CustomerId.ShouldBe(customer.Id);
+        loaded.Customer!.Name.ShouldBe(customer.Name);
+        loaded.Code.ShouldBe(saved.Code);
+        loaded.Discount.ShouldBe(saved.Discount);
+        loaded.Quantity.ShouldBe(saved.Quantity);
+        loaded.Amount.ShouldBe(saved.Amount);
+        loaded.Urgent.ShouldBe(saved.Urgent);
+        loaded.PlacedAt.ShouldBe(saved.PlacedAt);
+        loaded.DueOn.ShouldBe(saved.DueOn);
+        loaded.ConfirmedAt.ShouldBe(saved.ConfirmedAt);
+        loaded.Slot.ShouldBe(saved.Slot);
+        loaded.Note.ShouldBe(saved.Note);
+        loaded.Tags.ShouldBe(saved.Tags);
+
+        // KB-054: datetime2 keeps the ticks, and reads a DateTime back without its kind, as a plain DateTime column does.
+        loaded.PlacedAt.Value.Ticks.ShouldBe(saved.PlacedAt.Value.Ticks);
+        loaded.PlacedAt.Value.Kind.ShouldBe(DateTimeKind.Unspecified);
+    }
+
+    [Fact]
+    public async Task An_absent_optional_value_object_round_trips_as_null()
+    {
+        var (_, saved) = await SeedAsync(order => { order.Discount = null; order.Note = null; });
+
+        await using var db = await CreateAsync();
+        var loaded = await db.Orders.SingleAsync(o => o.Id == saved.Id, TestContext.Current.CancellationToken);
+
+        loaded.Discount.ShouldBeNull();
+        loaded.Note.ShouldBeNull();
+    }
+
+    /// <summary>A rule added after a row was written must not make it unreadable: the column is read through the materializer.</summary>
+    [Fact]
+    public async Task A_stored_value_the_rules_now_refuse_is_read_back_as_stored()
+    {
+        var (_, saved) = await SeedAsync();
+
+        await using (var db = await CreateAsync())
+            await db.Database.ExecuteSqlAsync($"UPDATE [Orders] SET [Code] = 'lower', [Discount] = 101 WHERE [Id] = {saved.Id.Value}", TestContext.Current.CancellationToken);
+
+        await using var read = await CreateAsync();
+        var loaded = await read.Orders.AsNoTracking().SingleAsync(o => o.Id == saved.Id, TestContext.Current.CancellationToken);
+
+        loaded.Code.Value.ShouldBe("lower");
+        loaded.Discount!.Value.Value.ShouldBe(101);
+        loaded.Code.Revalidate().TryGetValue(out _, out var fault).ShouldBeFalse();
+        fault.ShouldBe(ProbeCodeFault.NotUpperCase);
+    }
+
+    [Fact]
+    public async Task The_translated_queries_find_the_row()
+    {
+        var (_, saved) = await SeedAsync(order => order.Code = ProbeCode.FromKnownGood("QUERY"));
+        List<OrderId> ids = [saved.Id];
+        var tag = saved.Tags[0];
+        var cancellation = TestContext.Current.CancellationToken;
+
+        await using var db = await CreateAsync();
+
+        (await db.Orders.CountAsync(o => ids.Contains(o.Id), cancellation)).ShouldBe(1);
+        (await db.Orders.CountAsync(o => o.Id == saved.Id && o.Code.Value.StartsWith("QUE"), cancellation)).ShouldBe(1);
+        (await db.Orders.CountAsync(o => o.Id == saved.Id && o.Discount.ValueOrNull() > 10, cancellation)).ShouldBe(1);
+        (await db.Orders.CountAsync(o => o.Id == saved.Id && o.Tags.Contains(tag), cancellation)).ShouldBe(1);
+        (await db.Orders.CountAsync(o => o.Id == saved.Id && o.Tags.Any(t => t.Value == "x"), cancellation)).ShouldBe(1);
+        (await db.Orders.CountAsync(o => ids.Any(id => id.Value == o.Id.Value), cancellation)).ShouldBe(1);
+    }
+
+    /// <summary>A key over an integer is an identity column, as an <c>int</c> key is, and SQL Server numbers it.</summary>
+    [Fact]
+    public async Task An_integer_key_is_an_identity_column()
+    {
+        await using var db = await CreateAsync();
+
+        SqlServerPropertyExtensions.GetValueGenerationStrategy(db.Model.FindEntityType(typeof(Shipment))!.FindProperty(nameof(Shipment.Id))!)
+                                   .ShouldBe(SqlServerValueGenerationStrategy.IdentityColumn);
+
+        var first  = new Shipment { Carrier = "a" };
+        var second = new Shipment { Carrier = "b" };
+        db.AddRange(first, second);
+        await db.SaveChangesAsync(TestContext.Current.CancellationToken);
+
+        first.Id.Value.ShouldBeGreaterThan(0);
+        second.Id.ShouldNotBe(first.Id);
+    }
+
+    /// <summary>
+    /// KB-048: under the default collation a value object over text is compared and matched ignoring case and trailing
+    /// spaces, as the plain string column beside it is, where in memory its equality is ordinal.
+    /// </summary>
+    [Fact]
+    public async Task Text_is_compared_by_the_collation_as_a_plain_string_column_is()
+    {
+        var marker = Guid.NewGuid().ToString("N")[..8];
+        var (customer, saved) = await SeedAsync(order => { order.Note = ProbeLabel.From($"Fragile {marker}"); order.Tags = [Tag.From($"Needle {marker}")]; });
+        var cancellation = TestContext.Current.CancellationToken;
+        var shouted = ProbeLabel.From($"FRAGILE {marker}");
+        List<ProbeLabel> notes = [shouted];
+
+        shouted.ShouldNotBe(saved.Note, "in memory, a value object over text is equal ordinally");
+
+        await using var db = await CreateAsync();
+        var mine = db.Orders.Where(o => o.Id == saved.Id);
+
+        (await mine.CountAsync(o => o.Note == shouted, cancellation)).ShouldBe(1);
+        (await mine.CountAsync(o => o.Note == ProbeLabel.From($"Fragile {marker}  "), cancellation)).ShouldBe(1, "trailing spaces");
+        (await mine.CountAsync(o => notes.Contains(o.Note!), cancellation)).ShouldBe(1);
+        (await mine.CountAsync(o => o.Code.Value.StartsWith("ab"), cancellation)).ShouldBe(1);
+        (await mine.CountAsync(o => o.Tags.Any(t => t.Value == $"needle {marker}"), cancellation)).ShouldBe(1);
+        (await db.Customers.CountAsync(c => c.Id == customer.Id && c.Name == customer.Name.ToUpperInvariant(), cancellation)).ShouldBe(1, "the plain string column");
+    }
+
+    /// <summary>
+    /// KB-050: a decimal value object without a configured precision is a <c>decimal(18,2)</c> column, as a plain
+    /// <c>decimal</c> is: more fractional digits are rounded on write, and the value reads back at scale 2.
+    /// </summary>
+    [Fact]
+    public async Task A_decimal_value_object_is_rounded_to_the_column_s_scale_as_a_plain_decimal_is()
+    {
+        var (_, saved) = await SeedAsync(order => order.Amount = ProbeAmount.From(12.505m));
+
+        await using var db = await CreateAsync();
+        db.Model.FindEntityType(typeof(Order))!.FindProperty(nameof(Order.Amount))!.GetColumnType().ShouldBe("decimal(18,2)");
+        var loaded = await db.Orders.AsNoTracking().SingleAsync(o => o.Id == saved.Id, TestContext.Current.CancellationToken);
+
+        loaded.Amount.Value.ToString(CultureInfo.InvariantCulture).ShouldBe("12.51");
+    }
+}
diff --git a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/Variants/KeyShapes.cs b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/Variants/KeyShapes.cs
index 61135a9a..aa781900 100644
--- a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/Variants/KeyShapes.cs
+++ b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/Variants/KeyShapes.cs
@@ -1,4 +1,5 @@
 using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Metadata;
 
@@ -118,14 +119,30 @@ public static IReadOnlyList<IProperty> KeyOf(DbContext db, KeyShape shape, Type
         db.GetService<IDesignTimeModel>().Model.FindEntityType(Subject(shape, key))!.FindPrimaryKey()!.Properties;
 }
 
-/// <summary>A model of one key shape, cached per shape, key type and side.</summary>
-public sealed class KeyShapeDb(DbContextOptions<KeyShapeDb> options, KeyShape shape, Type key) : DbContext(options)
+/// <summary>A model of one key shape, cached per shape, key type and side, in a schema of its own where many share one database.</summary>
+public sealed class KeyShapeDb(DbContextOptions<KeyShapeDb> options, KeyShape shape, Type key, string? schema = null) : DbContext(options)
 {
     public KeyShape Shape => shape;
 
     public Type Key => key;
 
-    protected override void OnModelCreating(ModelBuilder modelBuilder) => KeyShapes.Configure(modelBuilder, shape, key);
+    public string? Schema => schema;
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        if (schema is not null) modelBuilder.HasDefaultSchema(schema);
+        KeyShapes.Configure(modelBuilder, shape, key);
+    }
+
+    /// <summary>On a real SQL Server, the shape's tables in <paramref name="schema"/>.</summary>
+    public static KeyShapeDb OnSqlServer(KeyShape shape, Type key, bool typeKit, string connectionString, string schema)
+    {
+        var builder = new DbContextOptionsBuilder<KeyShapeDb>().ReplaceService<IModelCacheKeyFactory, KeyShapeModelCacheKey>().UseSqlServer(connectionString)
+                                                               .ConfigureWarnings(warnings => warnings.Ignore(CoreEventId.ManyServiceProvidersCreatedWarning));
+        if (typeKit) builder = builder.UseTypeKit();
+
+        return new KeyShapeDb(builder.Options, shape, key, schema);
+    }
 
     public static KeyShapeDb Create(string provider, KeyShape shape, Type key, bool typeKit, Microsoft.Data.Sqlite.SqliteConnection connection)
     {
@@ -146,7 +163,7 @@ public static KeyShapeDb Create(string provider, KeyShape shape, Type key, bool
 public sealed class KeyShapeModelCacheKey : IModelCacheKeyFactory
 {
     public object Create(DbContext context, bool designTime) =>
-        context is KeyShapeDb db ? (db.GetType(), db.Shape, db.Key, designTime) : (context.GetType(), designTime);
+        context is KeyShapeDb db ? (db.GetType(), db.Shape, db.Key, db.Schema, designTime) : (context.GetType(), designTime);
 }
 
 public class Alone<TKey>
diff --git a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/Variants/QueryShapes.cs b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/Variants/QueryShapes.cs
index a99b6e6f..55c4fdd1 100644
--- a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/Variants/QueryShapes.cs
+++ b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/Variants/QueryShapes.cs
@@ -3,6 +3,7 @@
 using System.Runtime.CompilerServices;
 using CodoMetis.TypeKit.ValueObjects;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 
@@ -657,8 +658,11 @@ private static List<object> Rows(QueryBuilder builder, WrappedKind kind, bool va
     private static void Set(object target, string property, object? value) => target.GetType().GetProperty(property)!.SetValue(target, value);
 }
 
-/// <summary>A model of one kind's entities for the catalogue, cached by <see cref="Key"/>.</summary>
-public sealed record QueryModel(string Key, QueryCase Case, bool ValueObject);
+/// <summary>
+/// A model of one kind's entities for the catalogue, cached by <see cref="Key"/>, in a schema of its own where
+/// many models share one database.
+/// </summary>
+public sealed record QueryModel(string Key, QueryCase Case, bool ValueObject, string? Schema = null);
 
 public sealed class QueryDb(DbContextOptions<QueryDb> options, QueryModel model) : DbContext(options)
 {
@@ -673,6 +677,7 @@ protected override void ConfigureConventions(ModelConfigurationBuilder configura
     protected override void OnModelCreating(ModelBuilder modelBuilder)
     {
         var builder = new QueryBuilder(model.Case, model.ValueObject);
+        if (model.Schema is { } schema) modelBuilder.HasDefaultSchema(schema);
 
         if (builder.Source == builder.ElementRow)
         {
@@ -725,6 +730,16 @@ public static QueryDb Create(QueryModel model, Microsoft.Data.Sqlite.SqliteConne
     public static QueryDb OnPostgreSql(QueryModel model) =>
         Create(model, new DbContextOptionsBuilder<QueryDb>().UseNpgsql("Host=localhost;Database=none"));
 
+    /// <summary>
+    /// On SQL Server, at EF's default compatibility level or at <paramref name="compatibilityLevel"/>. The suite's
+    /// models need more than the twenty internal service providers EF warns about, all in one process.
+    /// </summary>
+    public static QueryDb OnSqlServer(QueryModel model, string connectionString, int? compatibilityLevel = null) =>
+        Create(model, new DbContextOptionsBuilder<QueryDb>().UseSqlServer(connectionString, sql =>
+        {
+            if (compatibilityLevel is { } level) sql.UseCompatibilityLevel(level);
+        }).ConfigureWarnings(warnings => warnings.Ignore(CoreEventId.ManyServiceProvidersCreatedWarning)));
+
     private static QueryDb Create(QueryModel model, DbContextOptionsBuilder<QueryDb> provider)
     {
         var builder = provider.ReplaceService<IModelCacheKeyFactory, QueryModelCacheKey>();
diff --git a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/Variants/WrappedKinds.cs b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/Variants/WrappedKinds.cs
index 63583190..50795eaa 100644
--- a/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/Variants/WrappedKinds.cs
+++ b/test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/Variants/WrappedKinds.cs
@@ -20,7 +20,10 @@ public enum Ordering
 /// <remarks>
 /// The values are chosen so that a column read as text orders differently from the type (<c>10</c>
 /// before <c>2.25</c>, <c>1.02:00:00</c> before <c>10:00:00</c>): a converter that stores another
-/// representation, or a provider that orders the stored text, cannot answer like memory by accident.
+/// representation, or a provider that orders the stored text, cannot answer like memory by accident. Text and
+/// <c>char</c> mix case (<c>"Bravo"</c> before <c>"alpha"</c> ordinally), and the Guids ascend by their first group
+/// and not by their last, so a database that orders text ignoring case, or a <c>uniqueidentifier</c> by its last
+/// group (SQL Server), cannot either.
 /// </remarks>
 public sealed record WrappedKind(string Name, Type ValueObject, Type Wrapped, Ordering Ordering, object[] Values)
 {
@@ -83,11 +86,11 @@ public static class WrappedKinds
     public static readonly WrappedKind UInt16  = new("ushort", typeof(WrapsUInt16), typeof(ushort), Ordering.Wrapped, [(ushort)2, (ushort)7, (ushort)10]);
     public static readonly WrappedKind UInt32  = new("uint", typeof(WrapsUInt32), typeof(uint), Ordering.Wrapped, [2u, 7u, 10u]);
     public static readonly WrappedKind UInt64  = new("ulong", typeof(WrapsUInt64), typeof(ulong), Ordering.Wrapped, [2ul, 7ul, 10ul]);
-    public static readonly WrappedKind Char    = new("char", typeof(WrapsChar), typeof(char), Ordering.Wrapped, ['a', 'b', 'c']);
+    public static readonly WrappedKind Char    = new("char", typeof(WrapsChar), typeof(char), Ordering.Wrapped, ['B', 'a', 'c']);
     public static readonly WrappedKind Guid    = new("Guid", typeof(WrapsGuid), typeof(Guid), Ordering.Wrapped,
-                                                     [System.Guid.Parse("00000000-0000-0000-0000-000000000002"), System.Guid.Parse("00000000-0000-0000-0000-000000000007"), System.Guid.Parse("00000000-0000-0000-0000-000000000010")]);
-    public static readonly WrappedKind String  = new("string", typeof(WrapsString), typeof(string), Ordering.Wrapped, ["alpha", "bravo", "charlie"]);
-    public static readonly WrappedKind StringRecordClass = new("string, record class", typeof(WrapsStringRecord), typeof(string), Ordering.Wrapped, ["alpha", "bravo", "charlie"]);
+                                                     [System.Guid.Parse("00000001-0000-0000-0000-000000000010"), System.Guid.Parse("00000002-0000-0000-0000-000000000002"), System.Guid.Parse("00000003-0000-0000-0000-000000000007")]);
+    public static readonly WrappedKind String  = new("string", typeof(WrapsString), typeof(string), Ordering.Wrapped, ["Bravo", "alpha", "charlie"]);
+    public static readonly WrappedKind StringRecordClass = new("string, record class", typeof(WrapsStringRecord), typeof(string), Ordering.Wrapped, ["Bravo", "alpha", "charlie"]);
     public static readonly WrappedKind Int32RecordClass = new("int, record class", typeof(WrapsInt32Record), typeof(int), Ordering.Wrapped, [2, 7, 10]);
     public static readonly WrappedKind Decimal = new("decimal", typeof(WrapsDecimal), typeof(decimal), Ordering.Wrapped, [1.5m, 2.25m, 10m]);
     public static readonly WrappedKind Double  = new("double", typeof(WrapsDouble), typeof(double), Ordering.Wrapped, [1.5, 2.25, 10.0]);
diff --git a/test/CodoMetis.TypeKit.Facts/CodoMetis.TypeKit.Facts.csproj b/test/CodoMetis.TypeKit.Facts/CodoMetis.TypeKit.Facts.csproj
index 20de5a52..e725ba98 100644
--- a/test/CodoMetis.TypeKit.Facts/CodoMetis.TypeKit.Facts.csproj
+++ b/test/CodoMetis.TypeKit.Facts/CodoMetis.TypeKit.Facts.csproj
@@ -25,6 +25,13 @@
         <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" />
         <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" />
         <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" />
+        <!--
+          The SQL Server facts, in a container (SqlServerFactHost), with the trait Needs=Docker; SqlClient's advisories
+          are answered as in the EF tests (Directory.Packages.props).
+        -->
+        <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" />
+        <PackageReference Include="System.Security.Cryptography.Pkcs" />
+        <PackageReference Include="Testcontainers" />
     </ItemGroup>
 
     <!-- A fact's measured answers as data, beside its test (FactFixture, design/adr/0107), read from the test output. -->
diff --git a/test/CodoMetis.TypeKit.Facts/KB047.cs b/test/CodoMetis.TypeKit.Facts/KB047.cs
new file mode 100644
index 00000000..245d66d1
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Facts/KB047.cs
@@ -0,0 +1,109 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.ChangeTracking;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Microsoft.EntityFrameworkCore.ValueGeneration;
+
+namespace CodoMetis.TypeKit.Facts;
+
+/// <summary>
+/// design/knowledge/KB-047: EF Core gives a key generated on add whose type is no number, converted to a <see cref="decimal"/>
+/// column, a negative temporary <see cref="decimal"/>, which a conversion to <see cref="ulong"/> refuses. A value generator
+/// factory in the converter's mapping hints is consulted instead, after a generator configured on the property and after
+/// Npgsql's HiLo. No database is opened.
+/// </summary>
+public sealed class KB047
+{
+    public readonly record struct Code(ulong Value);
+
+    public readonly record struct Number(long Value);
+
+    public sealed class ByCode
+    {
+        public Code Id { get; set; }
+    }
+
+    public sealed class ByNumber
+    {
+        public Number Id { get; set; }
+    }
+
+    private static readonly Code Hinted = new(7);
+
+    /// <summary>A <see cref="Code"/> stored as a <see cref="decimal"/>, as SQL Server and PostgreSQL store a <see cref="ulong"/>.</summary>
+    private static ValueConverter<Code, decimal> CodeConverter(bool hinted) =>
+        new(code => (decimal)code.Value, value => new Code((ulong)value), hinted ? new ConverterMappingHints(valueGeneratorFactory: (_, _) => new Fixed<Code>(Hinted)) : null);
+
+    private sealed class Fixed<T>(T value) : ValueGenerator<T>
+    {
+        public override bool GeneratesTemporaryValues => true;
+
+        public override T Next(EntityEntry entry) => value;
+    }
+
+    private sealed class Own : ValueGenerator<Code>
+    {
+        public override bool GeneratesTemporaryValues => false;
+
+        public override Code Next(EntityEntry entry) => new(42);
+    }
+
+    private sealed class Db(DbContextOptions options, Action<ModelBuilder> configure) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) => configure(modelBuilder);
+    }
+
+    private sealed class Uncached : IModelCacheKeyFactory
+    {
+        private static int _next;
+
+        public object Create(DbContext context, bool designTime) => Interlocked.Increment(ref _next);
+    }
+
+    private static Db Create(Action<ModelBuilder> configure) =>
+        new(new DbContextOptionsBuilder().UseNpgsql("Host=localhost;Database=none").ReplaceService<IModelCacheKeyFactory, Uncached>().Options, configure);
+
+    [Fact]
+    public void Without_hints_the_temporary_decimal_is_refused_converted_back()
+    {
+        using var db = Create(model => model.Entity<ByCode>().Property(e => e.Id).HasConversion(CodeConverter(hinted: false)).ValueGeneratedOnAdd());
+
+        Should.Throw<OverflowException>(() => db.Add(new ByCode()));
+    }
+
+    [Fact]
+    public void The_hints_factory_fills_the_key()
+    {
+        using var db = Create(model => model.Entity<ByCode>().Property(e => e.Id).HasConversion(CodeConverter(hinted: true)).ValueGeneratedOnAdd());
+
+        var entity = new ByCode();
+        db.Add(entity);
+
+        db.Entry(entity).Property(e => e.Id).CurrentValue.ShouldBe(Hinted);
+    }
+
+    [Fact]
+    public void A_generator_on_the_property_comes_before_the_hints_factory()
+    {
+        using var db = Create(model => model.Entity<ByCode>().Property(e => e.Id).HasConversion(CodeConverter(hinted: true)).HasValueGenerator<Own>());
+
+        var entity = new ByCode();
+        db.Add(entity);
+
+        entity.Id.ShouldBe(new Code(42));
+    }
+
+    [Fact]
+    public void Npgsql_s_HiLo_comes_before_the_hints_factory()
+    {
+        var converter = new ValueConverter<Number, long>(
+            number => number.Value, value => new Number(value), new ConverterMappingHints(valueGeneratorFactory: (_, _) => new Fixed<Number>(new Number(7))));
+        using var db = Create(model => NpgsqlPropertyBuilderExtensions.UseHiLo(model.Entity<ByNumber>().Property(e => e.Id).HasConversion(converter)));
+
+        var entityType = db.Model.FindEntityType(typeof(ByNumber))!;
+        db.GetService<IValueGeneratorSelector>().TrySelect(entityType.FindPrimaryKey()!.Properties[0], entityType, out var generator).ShouldBeTrue();
+
+        generator.ShouldNotBeOfType<Fixed<Number>>();
+        generator!.GeneratesTemporaryValues.ShouldBeFalse();
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Facts/KB048.cs b/test/CodoMetis.TypeKit.Facts/KB048.cs
new file mode 100644
index 00000000..69efd812
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Facts/KB048.cs
@@ -0,0 +1,38 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace CodoMetis.TypeKit.Facts;
+
+/// <summary>
+/// design/knowledge/KB-048: under SQL Server's default collation, <c>SQL_Latin1_General_CP1_CI_AS</c>, text compares
+/// ignoring case and trailing spaces: <c>==</c>, <c>Contains</c> over a list (<c>IN</c>) and <c>StartsWith</c>
+/// (<c>LIKE</c>) match rows that differ in case, and <c>ORDER BY</c> sorts ignoring case. A binary collation
+/// (<c>Latin1_General_BIN2</c>) gives the ordinal order.
+/// </summary>
+[Trait("Needs", "Docker")]
+public sealed class KB048
+{
+    public sealed class Named
+    {
+        public int Id { get; set; }
+
+        public string Name { get; set; } = "";
+    }
+
+    [Fact]
+    public async Task Text_compares_and_orders_ignoring_case()
+    {
+        var cancellation = TestContext.Current.CancellationToken;
+        await using var db = await SqlServer.ContextAsync(model => model.Entity<Named>());
+        db.AddRange(new Named { Name = "alpha" }, new Named { Name = "Bravo" }, new Named { Name = "charlie" });
+        await db.SaveChangesAsync(cancellation);
+        List<string> upper = ["ALPHA"];
+
+        (await db.Set<Named>().Where(n => n.Name == "BRAVO").Select(n => n.Name).ToListAsync(cancellation)).ShouldBe(["Bravo"]);
+        (await db.Set<Named>().Where(n => n.Name == "alpha  ").Select(n => n.Name).ToListAsync(cancellation)).ShouldBe(["alpha"]);
+        (await db.Set<Named>().Where(n => upper.Contains(n.Name)).Select(n => n.Name).ToListAsync(cancellation)).ShouldBe(["alpha"]);
+        (await db.Set<Named>().Where(n => n.Name.StartsWith("b")).Select(n => n.Name).ToListAsync(cancellation)).ShouldBe(["Bravo"]);
+        (await db.Set<Named>().OrderBy(n => n.Name).Select(n => n.Name).ToListAsync(cancellation)).ShouldBe(["alpha", "Bravo", "charlie"]);
+        (await db.Set<Named>().OrderBy(n => EF.Functions.Collate(n.Name, "Latin1_General_BIN2")).Select(n => n.Name).ToListAsync(cancellation))
+            .ShouldBe(["Bravo", "alpha", "charlie"]);
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Facts/KB049.cs b/test/CodoMetis.TypeKit.Facts/KB049.cs
new file mode 100644
index 00000000..9148e0db
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Facts/KB049.cs
@@ -0,0 +1,34 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace CodoMetis.TypeKit.Facts;
+
+/// <summary>
+/// design/knowledge/KB-049: SQL Server orders a <c>uniqueidentifier</c> by its last group first (bytes 10 to 15), then
+/// the fourth, third, second and first, where <see cref="Guid.CompareTo(Guid)"/> starts at the first group. So
+/// <c>ORDER BY</c>, <c>&lt;</c> and <c>MIN</c> over Guids answer in another order than memory does.
+/// </summary>
+[Trait("Needs", "Docker")]
+public sealed class KB049
+{
+    public sealed class Keyed
+    {
+        public int Id { get; set; }
+
+        public Guid Key { get; set; }
+    }
+
+    [Fact]
+    public async Task A_uniqueidentifier_orders_by_its_last_group_first()
+    {
+        var cancellation = TestContext.Current.CancellationToken;
+        Guid first = Guid.Parse("00000001-0000-0000-0000-000000000003"), second = Guid.Parse("00000002-0000-0000-0000-000000000001"), third = Guid.Parse("00000003-0000-0000-0000-000000000002");
+        await using var db = await SqlServer.ContextAsync(model => model.Entity<Keyed>());
+        db.AddRange(new Keyed { Key = first }, new Keyed { Key = second }, new Keyed { Key = third });
+        await db.SaveChangesAsync(cancellation);
+
+        new[] { third, first, second }.Order().ShouldBe([first, second, third]);
+        (await db.Set<Keyed>().OrderBy(k => k.Key).Select(k => k.Key).ToListAsync(cancellation)).ShouldBe([second, third, first]);
+        (await db.Set<Keyed>().MinAsync(k => k.Key, cancellation)).ShouldBe(second);
+        (await db.Set<Keyed>().Where(k => k.Key < first).Select(k => k.Key).OrderBy(k => k).ToListAsync(cancellation)).ShouldBe([second, third]);
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Facts/KB050.cs b/test/CodoMetis.TypeKit.Facts/KB050.cs
new file mode 100644
index 00000000..8f90703f
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Facts/KB050.cs
@@ -0,0 +1,34 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace CodoMetis.TypeKit.Facts;
+
+/// <summary>
+/// design/knowledge/KB-050: a <see cref="decimal"/> property without a configured precision is a <c>decimal(18,2)</c>
+/// column on SQL Server. Every value reads back at scale 2 (<c>10m</c> as <c>10.00m</c>, equal but printed
+/// <c>"10.00"</c>), and a value with more fractional digits is rounded when it is written.
+/// </summary>
+[Trait("Needs", "Docker")]
+public sealed class KB050
+{
+    public sealed class Money
+    {
+        public int Id { get; set; }
+
+        public decimal Amount { get; set; }
+    }
+
+    [Fact]
+    public async Task A_decimal_reads_back_at_scale_2_rounded()
+    {
+        var cancellation = TestContext.Current.CancellationToken;
+        await using var db = await SqlServer.ContextAsync(model => model.Entity<Money>());
+        db.Model.FindEntityType(typeof(Money))!.FindProperty(nameof(Money.Amount))!.GetColumnType().ShouldBe("decimal(18,2)");
+        db.AddRange(new Money { Amount = 10m }, new Money { Amount = 1.005m }, new Money { Amount = -0.004m });
+        await db.SaveChangesAsync(cancellation);
+        db.ChangeTracker.Clear();
+
+        var read = await db.Set<Money>().OrderBy(m => m.Id).Select(m => m.Amount).ToListAsync(cancellation);
+        read.Select(amount => amount.ToString(System.Globalization.CultureInfo.InvariantCulture)).ShouldBe(["10.00", "1.01", "0.00"]);
+        read[0].ShouldBe(10m);
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Facts/KB051.cs b/test/CodoMetis.TypeKit.Facts/KB051.cs
new file mode 100644
index 00000000..defad0a0
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Facts/KB051.cs
@@ -0,0 +1,56 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace CodoMetis.TypeKit.Facts;
+
+/// <summary>
+/// design/knowledge/KB-051: EF maps a <see cref="TimeSpan"/> to SQL Server's <c>time</c>, which holds less than a day.
+/// In a column, <c>SaveChanges</c> refuses a value of a day or more. In a JSON column the value is written as its text,
+/// <c>"1.02:00:00"</c>, and a query that reads the property converts that text to <c>time</c>: it answers
+/// <c>01:02:00</c>, without an error, where the entity materialized whole reads <c>1.02:00:00</c>.
+/// </summary>
+[Trait("Needs", "Docker")]
+public sealed class KB051
+{
+    public sealed class Span
+    {
+        public int Id { get; set; }
+
+        public TimeSpan Length { get; set; }
+    }
+
+    public sealed class Holder
+    {
+        public int Id { get; set; }
+
+        public Spans Doc { get; set; } = new();
+    }
+
+    public sealed class Spans
+    {
+        public TimeSpan Length { get; set; }
+    }
+
+    [Fact]
+    public async Task A_time_column_refuses_a_day_or_more()
+    {
+        var cancellation = TestContext.Current.CancellationToken;
+        await using var db = await SqlServer.ContextAsync(model => model.Entity<Span>());
+        db.Model.FindEntityType(typeof(Span))!.FindProperty(nameof(Span.Length))!.GetColumnType().ShouldBe("time");
+
+        db.Add(new Span { Length = TimeSpan.FromHours(26) });
+        await Should.ThrowAsync<DbUpdateException>(() => db.SaveChangesAsync(cancellation));
+    }
+
+    [Fact]
+    public async Task A_day_or_more_in_a_JSON_column_is_misread_by_a_query()
+    {
+        var cancellation = TestContext.Current.CancellationToken;
+        await using var db = await SqlServer.ContextAsync(model => model.Entity<Holder>().OwnsOne(h => h.Doc, doc => doc.ToJson()));
+        db.Add(new Holder { Doc = new Spans { Length = TimeSpan.FromHours(26) } });
+        await db.SaveChangesAsync(cancellation);
+        db.ChangeTracker.Clear();
+
+        (await db.Set<Holder>().Select(h => h.Doc.Length).SingleAsync(cancellation)).ShouldBe(new TimeSpan(1, 2, 0));
+        (await db.Set<Holder>().SingleAsync(cancellation)).Doc.Length.ShouldBe(TimeSpan.FromHours(26));
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Facts/KB052.cs b/test/CodoMetis.TypeKit.Facts/KB052.cs
new file mode 100644
index 00000000..932f4991
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Facts/KB052.cs
@@ -0,0 +1,31 @@
+using Microsoft.Data.SqlClient;
+using Microsoft.EntityFrameworkCore;
+
+namespace CodoMetis.TypeKit.Facts;
+
+/// <summary>
+/// design/knowledge/KB-052: EF translates <c>Max</c> and <c>Min</c> of a <see cref="bool"/> column to <c>MAX</c> and
+/// <c>MIN</c> of a <c>bit</c>, which SQL Server refuses: "Operand data type bit is invalid for max operator".
+/// </summary>
+[Trait("Needs", "Docker")]
+public sealed class KB052
+{
+    public sealed class Flagged
+    {
+        public int Id { get; set; }
+
+        public bool Flag { get; set; }
+    }
+
+    [Fact]
+    public async Task Max_and_min_of_a_bit_are_refused()
+    {
+        var cancellation = TestContext.Current.CancellationToken;
+        await using var db = await SqlServer.ContextAsync(model => model.Entity<Flagged>());
+        db.AddRange(new Flagged { Flag = false }, new Flagged { Flag = true });
+        await db.SaveChangesAsync(cancellation);
+
+        (await Should.ThrowAsync<SqlException>(() => db.Set<Flagged>().MaxAsync(f => f.Flag, cancellation))).Message.ShouldContain("Operand data type bit is invalid for max operator");
+        (await Should.ThrowAsync<SqlException>(() => db.Set<Flagged>().MinAsync(f => f.Flag, cancellation))).Message.ShouldContain("Operand data type bit is invalid for min operator");
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Facts/KB053.cs b/test/CodoMetis.TypeKit.Facts/KB053.cs
new file mode 100644
index 00000000..844f4db1
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Facts/KB053.cs
@@ -0,0 +1,55 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace CodoMetis.TypeKit.Facts;
+
+/// <summary>
+/// design/knowledge/KB-053: EF's SQL Server provider translates <c>EF.Functions.Greatest</c> and <c>Least</c> to
+/// <c>GREATEST</c> and <c>LEAST</c> only at compatibility level 160 or later (<c>UseCompatibilityLevel(160)</c>), which
+/// <c>UseSqlServer</c> does not assume. Below it a filter that calls one is refused ("could not be translated"), and a
+/// final projection reads the arguments' columns and calls the function in memory, where it throws when the query runs.
+/// No server is opened; <c>ToQueryString</c> translates without one.
+/// </summary>
+public sealed class KB053
+{
+    public sealed class Pair
+    {
+        public int Id { get; set; }
+
+        public int Left { get; set; }
+
+        public int Right { get; set; }
+    }
+
+    private sealed class Db(DbContextOptions<Db> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) => modelBuilder.Entity<Pair>();
+    }
+
+    private static Db Create(int? level) =>
+        new(new DbContextOptionsBuilder<Db>().UseSqlServer("Server=localhost;Database=none", sql =>
+        {
+            if (level is { } compatibility) sql.UseCompatibilityLevel(compatibility);
+        }).Options);
+
+    /// <summary>EF's default, and 150, the level below.</summary>
+    public static TheoryData<int> Below160 => [0, 150];
+
+    [Theory, MemberData(nameof(Below160))]
+    public void Below_compatibility_level_160_Greatest_is_not_translated(int level)
+    {
+        using var db = Create(level == 0 ? null : level);
+
+        Should.Throw<InvalidOperationException>(() => db.Set<Pair>().Where(p => EF.Functions.Greatest(p.Left, p.Right) > 2).ToQueryString()).Message.ShouldContain("could not be translated");
+        db.Set<Pair>().Select(p => EF.Functions.Least(p.Left, p.Right)).ToQueryString().ShouldBe("SELECT [p].[Left], [p].[Right]" + Environment.NewLine + "FROM [Pair] AS [p]");
+        Should.Throw<InvalidOperationException>(() => EF.Functions.Least(1, 2)).Message.ShouldContain("switched to client-evaluation");
+    }
+
+    [Fact]
+    public void At_compatibility_level_160_Greatest_and_Least_are_translated()
+    {
+        using var db = Create(160);
+
+        db.Set<Pair>().Where(p => EF.Functions.Greatest(p.Left, p.Right) > 2).ToQueryString().ShouldContain("WHERE GREATEST([p].[Left], [p].[Right]) > 2");
+        db.Set<Pair>().Select(p => EF.Functions.Least(p.Left, p.Right)).ToQueryString().ShouldContain("SELECT LEAST([p].[Left], [p].[Right])");
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Facts/KB054.cs b/test/CodoMetis.TypeKit.Facts/KB054.cs
new file mode 100644
index 00000000..1e526286
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Facts/KB054.cs
@@ -0,0 +1,41 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace CodoMetis.TypeKit.Facts;
+
+/// <summary>
+/// design/knowledge/KB-054: EF maps a <see cref="DateTime"/> to SQL Server's <c>datetime2</c>, of precision 7 unless
+/// configured, which keeps every tick: nothing is rounded. A <see cref="DateTime"/> written as UTC reads back with
+/// <see cref="DateTime.Kind"/> <see cref="DateTimeKind.Unspecified"/>, and equal, since equality ignores the kind. A
+/// <see cref="DateTimeOffset"/> keeps its offset.
+/// </summary>
+[Trait("Needs", "Docker")]
+public sealed class KB054
+{
+    public sealed class Stamped
+    {
+        public int Id { get; set; }
+
+        public DateTime At { get; set; }
+
+        public DateTimeOffset Offset { get; set; }
+    }
+
+    [Fact]
+    public async Task Datetime2_keeps_every_tick_and_reads_back_unspecified()
+    {
+        var cancellation = TestContext.Current.CancellationToken;
+        var at = new DateTime(2026, 10, 29, 12, 0, 0, DateTimeKind.Utc).AddTicks(1234567);
+        var offset = new DateTimeOffset(2026, 10, 29, 12, 0, 0, TimeSpan.FromHours(2)).AddTicks(7654321);
+        await using var db = await SqlServer.ContextAsync(model => model.Entity<Stamped>());
+        db.Model.FindEntityType(typeof(Stamped))!.FindProperty(nameof(Stamped.At))!.GetColumnType().ShouldBe("datetime2");
+        db.Add(new Stamped { At = at, Offset = offset });
+        await db.SaveChangesAsync(cancellation);
+        db.ChangeTracker.Clear();
+
+        var read = await db.Set<Stamped>().SingleAsync(cancellation);
+        read.At.Ticks.ShouldBe(at.Ticks);
+        read.At.Kind.ShouldBe(DateTimeKind.Unspecified);
+        read.Offset.ShouldBe(offset);
+        read.Offset.Offset.ShouldBe(TimeSpan.FromHours(2));
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Facts/SqlServerFactHost.cs b/test/CodoMetis.TypeKit.Facts/SqlServerFactHost.cs
new file mode 100644
index 00000000..cebb39ef
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Facts/SqlServerFactHost.cs
@@ -0,0 +1,84 @@
+using System.Runtime.CompilerServices;
+using DotNet.Testcontainers.Builders;
+using DotNet.Testcontainers.Containers;
+using Microsoft.Data.SqlClient;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+
+namespace CodoMetis.TypeKit.Facts;
+
+/// <summary>
+/// A SQL Server database of its own for a fact, with plain EF Core and nothing of TypeKit's, in one container started
+/// by the first fact that needs it: SQL Server 2022's Linux image, which CI's Linux leg runs and the entries pin, or the
+/// image <c>TYPEKIT_MSSQL_IMAGE</c> names (the native arm64 <c>mcr.microsoft.com/azure-sql-edge</c>, on a machine that
+/// would emulate 2022 under QEMU, where it does not start).
+/// </summary>
+/// <remarks>The facts that need it carry the trait <c>Needs=Docker</c>, which CI's Windows and macOS legs leave out.</remarks>
+internal static class SqlServer
+{
+    private const string Password = "TypeKit-2026!";
+
+    private static readonly Lazy<Task<IContainer>> Container = new(async () =>
+    {
+        var container = new ContainerBuilder(Environment.GetEnvironmentVariable("TYPEKIT_MSSQL_IMAGE") is { Length: > 0 } image ? image : "mcr.microsoft.com/mssql/server:2022-latest")
+                        .WithEnvironment("ACCEPT_EULA", "Y")
+                        .WithEnvironment("MSSQL_SA_PASSWORD", Password)
+                        .WithPortBinding(1433, assignRandomHostPort: true)
+                        .WithWaitStrategy(Wait.ForUnixContainer().UntilMessageIsLogged("SQL Server is now ready for client connections"))
+                        .Build();
+        await container.StartAsync();
+        return container;
+    });
+
+    /// <summary>A fresh database for <paramref name="model"/>, created, and dropped when disposed; the model is cached per fact and test.</summary>
+    public static async Task<SqlServerDb> ContextAsync(Action<ModelBuilder> model, Action<SqlServerDbContextOptionsBuilder>? sql = null,
+                                                       [CallerFilePath] string fact = "", [CallerMemberName] string test = "")
+    {
+        var container = await Container.Value;
+        var connection = new SqlConnectionStringBuilder
+        {
+            DataSource = $"{container.Hostname},{container.GetMappedPublicPort(1433)}",
+            UserID = "sa",
+            Password = Password,
+            InitialCatalog = $"kb_{Guid.NewGuid():N}",
+            TrustServerCertificate = true,
+        }.ConnectionString;
+        var options = new DbContextOptionsBuilder<SqlServerDb>().UseSqlServer(connection, sql)
+                                                                 .ReplaceService<IModelCacheKeyFactory, SqlServerDb.CacheKey>()
+                                                                 .Options;
+        var db = new SqlServerDb(options, model, $"{Path.GetFileNameWithoutExtension(fact)}.{test}");
+
+        // The server logs that it is ready before its login works, the first time it starts.
+        for (var attempt = 1; ; attempt++)
+        {
+            try
+            {
+                await db.Database.EnsureCreatedAsync(TestContext.Current.CancellationToken);
+                return db;
+            }
+            catch (SqlException) when (attempt < 60)
+            {
+                await Task.Delay(TimeSpan.FromSeconds(1), TestContext.Current.CancellationToken);
+            }
+        }
+    }
+}
+
+/// <summary>A context whose model is the fact's, cached per fact.</summary>
+internal sealed class SqlServerDb(DbContextOptions<SqlServerDb> options, Action<ModelBuilder> model, string fact) : DbContext(options)
+{
+    protected override void OnModelCreating(ModelBuilder modelBuilder) => model(modelBuilder);
+
+    public override async ValueTask DisposeAsync()
+    {
+        await Database.EnsureDeletedAsync();
+        await base.DisposeAsync();
+    }
+
+    public sealed class CacheKey : IModelCacheKeyFactory
+    {
+        public object Create(DbContext context, bool designTime) => context is SqlServerDb db ? (typeof(SqlServerDb), db.FactName, designTime) : (context.GetType(), designTime);
+    }
+
+    private string FactName => fact;
+}
diff --git a/test/CodoMetis.TypeKit.Generators.Tests/FabricTests.cs b/test/CodoMetis.TypeKit.Generators.Tests/FabricTests.cs
index e67465ca..a2881620 100644
--- a/test/CodoMetis.TypeKit.Generators.Tests/FabricTests.cs
+++ b/test/CodoMetis.TypeKit.Generators.Tests/FabricTests.cs
@@ -10,6 +10,13 @@ namespace CodoMetis.TypeKit.Generators.Tests;
 /// </summary>
 public readonly partial record struct TestLocalId : IValue<int>;
 
+/// <summary>
+/// Reaches its marker through <see cref="IProbeIdentifier"/>, an interface of another assembly: the
+/// fabric finds it in this compilation's index of derived types, whose chain runs through a type it
+/// did not compile.
+/// </summary>
+public readonly partial record struct TestForeignIdentifier : IProbeIdentifier;
+
 /// <summary>
 /// The fabric reaches every value object it should. A type it skips compiles cleanly, and the
 /// analyzer stays quiet because the generators are referenced, so only a test like this notices.
@@ -47,6 +54,7 @@ public void Every_declared_value_object_is_generated(Type type)
     /// </summary>
     [Theory]
     [InlineData(typeof(ProbeCustomerId), "a marker reached through another interface")]
+    [InlineData(typeof(TestForeignIdentifier), "a marker reached through an interface of another assembly")]
     [InlineData(typeof(ProbeContainer.NestedId), "a nested type")]
     [InlineData(typeof(ProbeLabel), "a record class")]
     [InlineData(typeof(ProbeInternalId), "an internal type")]
diff --git a/test/CodoMetis.TypeKit.Generators.Tests/GeneratedSurface.verified.txt b/test/CodoMetis.TypeKit.Generators.Tests/GeneratedSurface.verified.txt
index c2e1484e..14f02dab 100644
--- a/test/CodoMetis.TypeKit.Generators.Tests/GeneratedSurface.verified.txt
+++ b/test/CodoMetis.TypeKit.Generators.Tests/GeneratedSurface.verified.txt
@@ -1,3 +1,4 @@
+# CodoMetis.TypeKit.Generators.Probes
 ProbeAmount
   CompareTo(Object) : Int32
   CompareTo(ProbeAmount) : Int32
@@ -1581,3 +1582,2617 @@ ProbeWeekday
   static op_LessThanOrEqual(ProbeWeekday, ProbeWeekday) : Boolean
   extension static ProbeWeekdayExtensions.GetValue(ProbeWeekday) : DayOfWeek
   extension static ProbeWeekdayExtensions.ValueOrNull(ProbeWeekday?) : DayOfWeek?
+# CodoMetis.TypeKit.Generators.Tests
+DefaultedAddress
+  Equals(DefaultedAddress) : Boolean
+  Equals(Object) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : IPAddress
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<DefaultedAddress, IPAddress>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IEqualityOperators<DefaultedAddress, DefaultedAddress, Boolean>
+  implements IEquatable<DefaultedAddress>
+  implements IFormattable
+  implements IParsable<DefaultedAddress>
+  implements IPlainValueObject<DefaultedAddress, IPAddress>
+  implements ISpanFormattable
+  implements ISpanParsable<DefaultedAddress>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<DefaultedAddress>
+  implements IValue<IPAddress>
+  implements IValueObject<DefaultedAddress, IPAddress>
+  implements IValueObjectMaterializer<DefaultedAddress, IPAddress>
+  nested DefaultedAddressJsonConverter : JsonConverter<DefaultedAddress>, IStoredJsonConverterSource
+  nested DefaultedAddressTypeConverter : TypeConverter
+  new()
+  static From(IPAddress) : DefaultedAddress
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : DefaultedAddress
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : DefaultedAddress
+  static Parse(String, IFormatProvider) : DefaultedAddress
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out DefaultedAddress) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out DefaultedAddress) : Boolean
+  static TryParse(String, IFormatProvider, out DefaultedAddress) : Boolean
+  static op_Equality(DefaultedAddress, DefaultedAddress) : Boolean
+  static op_Inequality(DefaultedAddress, DefaultedAddress) : Boolean
+  extension static DefaultedAddressExtensions.GetValue(DefaultedAddress) : IPAddress
+  extension static DefaultedAddressExtensions.ValueOrNull(DefaultedAddress?) : IPAddress
+DefaultedVersion
+  CompareTo(DefaultedVersion) : Int32
+  CompareTo(Object) : Int32
+  Equals(DefaultedVersion) : Boolean
+  Equals(Object) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Version
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<DefaultedVersion, Version>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<DefaultedVersion>
+  implements IComparisonOperators<DefaultedVersion, DefaultedVersion, Boolean>
+  implements IEqualityOperators<DefaultedVersion, DefaultedVersion, Boolean>
+  implements IEquatable<DefaultedVersion>
+  implements IFormattable
+  implements IParsable<DefaultedVersion>
+  implements IPlainValueObject<DefaultedVersion, Version>
+  implements ISpanFormattable
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<DefaultedVersion>
+  implements IValue<Version>
+  implements IValueObject<DefaultedVersion, Version>
+  implements IValueObjectMaterializer<DefaultedVersion, Version>
+  nested DefaultedVersionJsonConverter : JsonConverter<DefaultedVersion>, IStoredJsonConverterSource
+  nested DefaultedVersionTypeConverter : TypeConverter
+  new()
+  static From(Version) : DefaultedVersion
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : DefaultedVersion
+  static Parse(String, IFormatProvider) : DefaultedVersion
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out DefaultedVersion) : Boolean
+  static TryParse(String, IFormatProvider, out DefaultedVersion) : Boolean
+  static op_Equality(DefaultedVersion, DefaultedVersion) : Boolean
+  static op_GreaterThan(DefaultedVersion, DefaultedVersion) : Boolean
+  static op_GreaterThanOrEqual(DefaultedVersion, DefaultedVersion) : Boolean
+  static op_Inequality(DefaultedVersion, DefaultedVersion) : Boolean
+  static op_LessThan(DefaultedVersion, DefaultedVersion) : Boolean
+  static op_LessThanOrEqual(DefaultedVersion, DefaultedVersion) : Boolean
+  extension static DefaultedVersionExtensions.GetValue(DefaultedVersion) : Version
+  extension static DefaultedVersionExtensions.ValueOrNull(DefaultedVersion?) : Version
+DocumentKind
+  Match(Func<TResult>, Func<TResult>) : TResult
+  Name : String
+  QualifiedName : String
+  ToString() : String
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedClosedSetAttribute<DocumentKind>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IClosedSet<DocumentKind>
+  implements IParsable<DocumentKind>
+  nested DocumentKindJsonConverter : JsonConverter<DocumentKind>
+  nested DocumentKindTypeConverter : TypeConverter
+  static All : IReadOnlyList<DocumentKind>
+  static Parse(String) : DocumentKind
+  static Parse(String, Boolean) : DocumentKind
+  static TryParse(String, Boolean, out DocumentKind) : Boolean
+  static TryParse(String, out DocumentKind) : Boolean
+EarlyAllStatus
+  Match(Func<TResult>) : TResult
+  Name : String
+  QualifiedName : String
+  ToString() : String
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedClosedSetAttribute<EarlyAllStatus>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IClosedSet<EarlyAllStatus>
+  implements IParsable<EarlyAllStatus>
+  nested EarlyAllStatusJsonConverter : JsonConverter<EarlyAllStatus>
+  nested EarlyAllStatusTypeConverter : TypeConverter
+  static All : IReadOnlyList<EarlyAllStatus>
+  static Parse(String) : EarlyAllStatus
+  static Parse(String, Boolean) : EarlyAllStatus
+  static TryParse(String, Boolean, out EarlyAllStatus) : Boolean
+  static TryParse(String, out EarlyAllStatus) : Boolean
+EarlyIgnoreCaseParseStatus
+  Match(Func<TResult>) : TResult
+  Name : String
+  QualifiedName : String
+  ToString() : String
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedClosedSetAttribute<EarlyIgnoreCaseParseStatus>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IClosedSet<EarlyIgnoreCaseParseStatus>
+  implements IParsable<EarlyIgnoreCaseParseStatus>
+  nested EarlyIgnoreCaseParseStatusJsonConverter : JsonConverter<EarlyIgnoreCaseParseStatus>
+  nested EarlyIgnoreCaseParseStatusTypeConverter : TypeConverter
+  static All : IReadOnlyList<EarlyIgnoreCaseParseStatus>
+  static Parse(String) : EarlyIgnoreCaseParseStatus
+  static Parse(String, Boolean) : EarlyIgnoreCaseParseStatus
+  static TryParse(String, Boolean, out EarlyIgnoreCaseParseStatus) : Boolean
+  static TryParse(String, out EarlyIgnoreCaseParseStatus) : Boolean
+EarlyIgnoreCaseTryParseStatus
+  Match(Func<TResult>) : TResult
+  Name : String
+  QualifiedName : String
+  ToString() : String
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedClosedSetAttribute<EarlyIgnoreCaseTryParseStatus>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IClosedSet<EarlyIgnoreCaseTryParseStatus>
+  implements IParsable<EarlyIgnoreCaseTryParseStatus>
+  nested EarlyIgnoreCaseTryParseStatusJsonConverter : JsonConverter<EarlyIgnoreCaseTryParseStatus>
+  nested EarlyIgnoreCaseTryParseStatusTypeConverter : TypeConverter
+  static All : IReadOnlyList<EarlyIgnoreCaseTryParseStatus>
+  static Parse(String) : EarlyIgnoreCaseTryParseStatus
+  static Parse(String, Boolean) : EarlyIgnoreCaseTryParseStatus
+  static TryParse(String, Boolean, out EarlyIgnoreCaseTryParseStatus) : Boolean
+  static TryParse(String, out EarlyIgnoreCaseTryParseStatus) : Boolean
+EarlyJsonKeyStatus
+  Match(Func<TResult>) : TResult
+  Name : String
+  QualifiedName : String
+  ToString() : String
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedClosedSetAttribute<EarlyJsonKeyStatus>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IClosedSet<EarlyJsonKeyStatus>
+  implements IParsable<EarlyJsonKeyStatus>
+  nested EarlyJsonKeyStatusJsonConverter : JsonConverter<EarlyJsonKeyStatus>
+  nested EarlyJsonKeyStatusTypeConverter : TypeConverter
+  static All : IReadOnlyList<EarlyJsonKeyStatus>
+  static Parse(String) : EarlyJsonKeyStatus
+  static Parse(String, Boolean) : EarlyJsonKeyStatus
+  static TryParse(String, Boolean, out EarlyJsonKeyStatus) : Boolean
+  static TryParse(String, out EarlyJsonKeyStatus) : Boolean
+EarlyJsonStatus
+  Match(Func<TResult>) : TResult
+  Name : String
+  QualifiedName : String
+  ToString() : String
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedClosedSetAttribute<EarlyJsonStatus>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IClosedSet<EarlyJsonStatus>
+  implements IParsable<EarlyJsonStatus>
+  nested EarlyJsonStatusJsonConverter : JsonConverter<EarlyJsonStatus>
+  nested EarlyJsonStatusTypeConverter : TypeConverter
+  static All : IReadOnlyList<EarlyJsonStatus>
+  static Parse(String) : EarlyJsonStatus
+  static Parse(String, Boolean) : EarlyJsonStatus
+  static TryParse(String, Boolean, out EarlyJsonStatus) : Boolean
+  static TryParse(String, out EarlyJsonStatus) : Boolean
+EarlyParsableStatus
+  Match(Func<TResult>) : TResult
+  Name : String
+  QualifiedName : String
+  ToString() : String
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedClosedSetAttribute<EarlyParsableStatus>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IClosedSet<EarlyParsableStatus>
+  implements IParsable<EarlyParsableStatus>
+  nested EarlyParsableStatusJsonConverter : JsonConverter<EarlyParsableStatus>
+  nested EarlyParsableStatusTypeConverter : TypeConverter
+  static All : IReadOnlyList<EarlyParsableStatus>
+  static Parse(String) : EarlyParsableStatus
+  static Parse(String, Boolean) : EarlyParsableStatus
+  static TryParse(String, Boolean, out EarlyParsableStatus) : Boolean
+  static TryParse(String, out EarlyParsableStatus) : Boolean
+EarlyParseStatus
+  Match(Func<TResult>) : TResult
+  Name : String
+  QualifiedName : String
+  ToString() : String
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedClosedSetAttribute<EarlyParseStatus>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IClosedSet<EarlyParseStatus>
+  implements IParsable<EarlyParseStatus>
+  nested EarlyParseStatusJsonConverter : JsonConverter<EarlyParseStatus>
+  nested EarlyParseStatusTypeConverter : TypeConverter
+  static All : IReadOnlyList<EarlyParseStatus>
+  static Parse(String) : EarlyParseStatus
+  static Parse(String, Boolean) : EarlyParseStatus
+  static TryParse(String, Boolean, out EarlyParseStatus) : Boolean
+  static TryParse(String, out EarlyParseStatus) : Boolean
+EarlyTryParseStatus
+  Match(Func<TResult>) : TResult
+  Name : String
+  QualifiedName : String
+  ToString() : String
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedClosedSetAttribute<EarlyTryParseStatus>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IClosedSet<EarlyTryParseStatus>
+  implements IParsable<EarlyTryParseStatus>
+  nested EarlyTryParseStatusJsonConverter : JsonConverter<EarlyTryParseStatus>
+  nested EarlyTryParseStatusTypeConverter : TypeConverter
+  static All : IReadOnlyList<EarlyTryParseStatus>
+  static Parse(String) : EarlyTryParseStatus
+  static Parse(String, Boolean) : EarlyTryParseStatus
+  static TryParse(String, Boolean, out EarlyTryParseStatus) : Boolean
+  static TryParse(String, out EarlyTryParseStatus) : Boolean
+LocalOrder.Stage
+  Match(Func<TResult>, Func<TResult>) : TResult
+  Name : String
+  QualifiedName : String
+  ToString() : String
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedClosedSetAttribute<LocalOrder.Stage>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IClosedSet<LocalOrder.Stage>
+  implements IParsable<LocalOrder.Stage>
+  nested StageJsonConverter : JsonConverter<LocalOrder.Stage>
+  nested StageTypeConverter : TypeConverter
+  static All : IReadOnlyList<LocalOrder.Stage>
+  static Parse(String) : LocalOrder.Stage
+  static Parse(String, Boolean) : LocalOrder.Stage
+  static TryParse(String, Boolean, out LocalOrder.Stage) : Boolean
+  static TryParse(String, out LocalOrder.Stage) : Boolean
+LocalStatus
+  Match(Func<TResult>, Func<TResult>, Func<TResult>) : TResult
+  Name : String
+  QualifiedName : String
+  ToString() : String
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedClosedSetAttribute<LocalStatus>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IClosedSet<LocalStatus>
+  implements IParsable<LocalStatus>
+  nested LocalStatusJsonConverter : JsonConverter<LocalStatus>
+  nested LocalStatusTypeConverter : TypeConverter
+  static All : IReadOnlyList<LocalStatus>
+  static Parse(String) : LocalStatus
+  static Parse(String, Boolean) : LocalStatus
+  static TryParse(String, Boolean, out LocalStatus) : Boolean
+  static TryParse(String, out LocalStatus) : Boolean
+MaskedOverALibraryRecord
+  <Clone>$() : MaskedOverALibraryRecord
+  CompareTo(MaskedOverALibraryRecord) : Int32
+  CompareTo(Object) : Int32
+  Equals(MaskedOverALibraryRecord) : Boolean
+  Equals(Object) : Boolean
+  Equals(ProbeMaskingRecord) : Boolean
+  GetHashCode() : Int32
+  Value : String
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<MaskedOverALibraryRecord, String>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<MaskedOverALibraryRecord>
+  implements IComparisonOperators<MaskedOverALibraryRecord, MaskedOverALibraryRecord, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<MaskedOverALibraryRecord, MaskedOverALibraryRecord, Boolean>
+  implements IEquatable<MaskedOverALibraryRecord>
+  implements IEquatable<ProbeMaskingRecord>
+  implements IParsable<MaskedOverALibraryRecord>
+  implements IPlainValueObject<MaskedOverALibraryRecord, String>
+  implements IReimplementedEquatable<ProbeMaskingRecord>
+  implements ISpanParsable<MaskedOverALibraryRecord>
+  implements IValue<String>
+  implements IValueObject<MaskedOverALibraryRecord, String>
+  implements IValueObjectMaterializer<MaskedOverALibraryRecord, String>
+  nested MaskedOverALibraryRecordJsonConverter : JsonConverter<MaskedOverALibraryRecord>, IStoredJsonConverterSource
+  nested MaskedOverALibraryRecordTypeConverter : TypeConverter
+  static From(String) : MaskedOverALibraryRecord
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : MaskedOverALibraryRecord
+  static Parse(String, IFormatProvider) : MaskedOverALibraryRecord
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out MaskedOverALibraryRecord) : Boolean
+  static TryParse(String, IFormatProvider, out MaskedOverALibraryRecord) : Boolean
+  static op_Equality(MaskedOverALibraryRecord, MaskedOverALibraryRecord) : Boolean
+  static op_GreaterThan(MaskedOverALibraryRecord, MaskedOverALibraryRecord) : Boolean
+  static op_GreaterThanOrEqual(MaskedOverALibraryRecord, MaskedOverALibraryRecord) : Boolean
+  static op_Inequality(MaskedOverALibraryRecord, MaskedOverALibraryRecord) : Boolean
+  static op_LessThan(MaskedOverALibraryRecord, MaskedOverALibraryRecord) : Boolean
+  static op_LessThanOrEqual(MaskedOverALibraryRecord, MaskedOverALibraryRecord) : Boolean
+  extension static MaskedOverALibraryRecordExtensions.GetValue(MaskedOverALibraryRecord) : String
+  extension static MaskedOverALibraryRecordExtensions.ValueOrNull(MaskedOverALibraryRecord) : String
+MaskedOverALocalRecord
+  <Clone>$() : MaskedOverALocalRecord
+  CompareTo(MaskedOverALocalRecord) : Int32
+  CompareTo(Object) : Int32
+  Equals(LocalMaskingRecord) : Boolean
+  Equals(MaskedOverALocalRecord) : Boolean
+  Equals(Object) : Boolean
+  GetHashCode() : Int32
+  Value : String
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<MaskedOverALocalRecord, String>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<MaskedOverALocalRecord>
+  implements IComparisonOperators<MaskedOverALocalRecord, MaskedOverALocalRecord, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<MaskedOverALocalRecord, MaskedOverALocalRecord, Boolean>
+  implements IEquatable<LocalMaskingRecord>
+  implements IEquatable<MaskedOverALocalRecord>
+  implements IParsable<MaskedOverALocalRecord>
+  implements IPlainValueObject<MaskedOverALocalRecord, String>
+  implements IReimplementedEquatable<LocalMaskingRecord>
+  implements ISpanParsable<MaskedOverALocalRecord>
+  implements IValue<String>
+  implements IValueObject<MaskedOverALocalRecord, String>
+  implements IValueObjectMaterializer<MaskedOverALocalRecord, String>
+  nested MaskedOverALocalRecordJsonConverter : JsonConverter<MaskedOverALocalRecord>, IStoredJsonConverterSource
+  nested MaskedOverALocalRecordTypeConverter : TypeConverter
+  static From(String) : MaskedOverALocalRecord
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : MaskedOverALocalRecord
+  static Parse(String, IFormatProvider) : MaskedOverALocalRecord
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out MaskedOverALocalRecord) : Boolean
+  static TryParse(String, IFormatProvider, out MaskedOverALocalRecord) : Boolean
+  static op_Equality(MaskedOverALocalRecord, MaskedOverALocalRecord) : Boolean
+  static op_GreaterThan(MaskedOverALocalRecord, MaskedOverALocalRecord) : Boolean
+  static op_GreaterThanOrEqual(MaskedOverALocalRecord, MaskedOverALocalRecord) : Boolean
+  static op_Inequality(MaskedOverALocalRecord, MaskedOverALocalRecord) : Boolean
+  static op_LessThan(MaskedOverALocalRecord, MaskedOverALocalRecord) : Boolean
+  static op_LessThanOrEqual(MaskedOverALocalRecord, MaskedOverALocalRecord) : Boolean
+  extension static MaskedOverALocalRecordExtensions.GetValue(MaskedOverALocalRecord) : String
+  extension static MaskedOverALocalRecordExtensions.ValueOrNull(MaskedOverALocalRecord) : String
+OverABetweenExplicitEqualityRecord
+  <Clone>$() : OverABetweenExplicitEqualityRecord
+  CompareTo(Object) : Int32
+  CompareTo(OverABetweenExplicitEqualityRecord) : Int32
+  Equals(LocalEqualityFreeRecord) : Boolean
+  Equals(LocalReimplementingBetweenRecord) : Boolean
+  Equals(Object) : Boolean
+  Equals(OverABetweenExplicitEqualityRecord) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Int32
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverABetweenExplicitEqualityRecord, Int32>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<OverABetweenExplicitEqualityRecord>
+  implements IComparisonOperators<OverABetweenExplicitEqualityRecord, OverABetweenExplicitEqualityRecord, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<OverABetweenExplicitEqualityRecord, OverABetweenExplicitEqualityRecord, Boolean>
+  implements IEquatable<LocalEqualityFreeRecord>
+  implements IEquatable<LocalReimplementingBetweenRecord>
+  implements IEquatable<OverABetweenExplicitEqualityRecord>
+  implements IFormattable
+  implements IMinMaxValue<OverABetweenExplicitEqualityRecord>
+  implements IParsable<OverABetweenExplicitEqualityRecord>
+  implements IPlainValueObject<OverABetweenExplicitEqualityRecord, Int32>
+  implements IReimplementedEquatable<LocalEqualityFreeRecord>
+  implements IReimplementedEquatable<LocalReimplementingBetweenRecord>
+  implements ISpanFormattable
+  implements ISpanParsable<OverABetweenExplicitEqualityRecord>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<OverABetweenExplicitEqualityRecord>
+  implements IValue<Int32>
+  implements IValueObject<OverABetweenExplicitEqualityRecord, Int32>
+  implements IValueObjectMaterializer<OverABetweenExplicitEqualityRecord, Int32>
+  nested OverABetweenExplicitEqualityRecordJsonConverter : JsonConverter<OverABetweenExplicitEqualityRecord>, IStoredJsonConverterSource
+  nested OverABetweenExplicitEqualityRecordTypeConverter : TypeConverter
+  static From(Int32) : OverABetweenExplicitEqualityRecord
+  static MaxValue : OverABetweenExplicitEqualityRecord
+  static MinValue : OverABetweenExplicitEqualityRecord
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : OverABetweenExplicitEqualityRecord
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : OverABetweenExplicitEqualityRecord
+  static Parse(String, IFormatProvider) : OverABetweenExplicitEqualityRecord
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out OverABetweenExplicitEqualityRecord) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out OverABetweenExplicitEqualityRecord) : Boolean
+  static TryParse(String, IFormatProvider, out OverABetweenExplicitEqualityRecord) : Boolean
+  static op_Equality(OverABetweenExplicitEqualityRecord, OverABetweenExplicitEqualityRecord) : Boolean
+  static op_GreaterThan(OverABetweenExplicitEqualityRecord, OverABetweenExplicitEqualityRecord) : Boolean
+  static op_GreaterThanOrEqual(OverABetweenExplicitEqualityRecord, OverABetweenExplicitEqualityRecord) : Boolean
+  static op_Inequality(OverABetweenExplicitEqualityRecord, OverABetweenExplicitEqualityRecord) : Boolean
+  static op_LessThan(OverABetweenExplicitEqualityRecord, OverABetweenExplicitEqualityRecord) : Boolean
+  static op_LessThanOrEqual(OverABetweenExplicitEqualityRecord, OverABetweenExplicitEqualityRecord) : Boolean
+  extension static OverABetweenExplicitEqualityRecordExtensions.GetValue(OverABetweenExplicitEqualityRecord) : Int32
+  extension static OverABetweenExplicitEqualityRecordExtensions.ValueOrNull(OverABetweenExplicitEqualityRecord) : Int32?
+OverADeeperExplicitEqualityRecord
+  <Clone>$() : OverADeeperExplicitEqualityRecord
+  CompareTo(Object) : Int32
+  CompareTo(OverADeeperExplicitEqualityRecord) : Int32
+  Equals(LocalBetweenRecord) : Boolean
+  Equals(LocalExplicitEqualityRecord) : Boolean
+  Equals(Object) : Boolean
+  Equals(OverADeeperExplicitEqualityRecord) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Int32
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverADeeperExplicitEqualityRecord, Int32>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<OverADeeperExplicitEqualityRecord>
+  implements IComparisonOperators<OverADeeperExplicitEqualityRecord, OverADeeperExplicitEqualityRecord, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<OverADeeperExplicitEqualityRecord, OverADeeperExplicitEqualityRecord, Boolean>
+  implements IEquatable<LocalBetweenRecord>
+  implements IEquatable<LocalExplicitEqualityRecord>
+  implements IEquatable<OverADeeperExplicitEqualityRecord>
+  implements IFormattable
+  implements IMinMaxValue<OverADeeperExplicitEqualityRecord>
+  implements IParsable<OverADeeperExplicitEqualityRecord>
+  implements IPlainValueObject<OverADeeperExplicitEqualityRecord, Int32>
+  implements IReimplementedEquatable<LocalBetweenRecord>
+  implements IReimplementedEquatable<LocalExplicitEqualityRecord>
+  implements ISpanFormattable
+  implements ISpanParsable<OverADeeperExplicitEqualityRecord>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<OverADeeperExplicitEqualityRecord>
+  implements IValue<Int32>
+  implements IValueObject<OverADeeperExplicitEqualityRecord, Int32>
+  implements IValueObjectMaterializer<OverADeeperExplicitEqualityRecord, Int32>
+  nested OverADeeperExplicitEqualityRecordJsonConverter : JsonConverter<OverADeeperExplicitEqualityRecord>, IStoredJsonConverterSource
+  nested OverADeeperExplicitEqualityRecordTypeConverter : TypeConverter
+  static From(Int32) : OverADeeperExplicitEqualityRecord
+  static MaxValue : OverADeeperExplicitEqualityRecord
+  static MinValue : OverADeeperExplicitEqualityRecord
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : OverADeeperExplicitEqualityRecord
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : OverADeeperExplicitEqualityRecord
+  static Parse(String, IFormatProvider) : OverADeeperExplicitEqualityRecord
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out OverADeeperExplicitEqualityRecord) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out OverADeeperExplicitEqualityRecord) : Boolean
+  static TryParse(String, IFormatProvider, out OverADeeperExplicitEqualityRecord) : Boolean
+  static op_Equality(OverADeeperExplicitEqualityRecord, OverADeeperExplicitEqualityRecord) : Boolean
+  static op_GreaterThan(OverADeeperExplicitEqualityRecord, OverADeeperExplicitEqualityRecord) : Boolean
+  static op_GreaterThanOrEqual(OverADeeperExplicitEqualityRecord, OverADeeperExplicitEqualityRecord) : Boolean
+  static op_Inequality(OverADeeperExplicitEqualityRecord, OverADeeperExplicitEqualityRecord) : Boolean
+  static op_LessThan(OverADeeperExplicitEqualityRecord, OverADeeperExplicitEqualityRecord) : Boolean
+  static op_LessThanOrEqual(OverADeeperExplicitEqualityRecord, OverADeeperExplicitEqualityRecord) : Boolean
+  extension static OverADeeperExplicitEqualityRecordExtensions.GetValue(OverADeeperExplicitEqualityRecord) : Int32
+  extension static OverADeeperExplicitEqualityRecordExtensions.ValueOrNull(OverADeeperExplicitEqualityRecord) : Int32?
+OverALibraryRecord
+  <Clone>$() : OverALibraryRecord
+  CompareTo(Object) : Int32
+  CompareTo(OverALibraryRecord) : Int32
+  Equals(Object) : Boolean
+  Equals(OverALibraryRecord) : Boolean
+  Equals(ProbeRecordBase) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Int32
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverALibraryRecord, Int32>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<OverALibraryRecord>
+  implements IComparisonOperators<OverALibraryRecord, OverALibraryRecord, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<OverALibraryRecord, OverALibraryRecord, Boolean>
+  implements IEquatable<OverALibraryRecord>
+  implements IEquatable<ProbeRecordBase>
+  implements IFormattable
+  implements IMinMaxValue<OverALibraryRecord>
+  implements IParsable<OverALibraryRecord>
+  implements IPlainValueObject<OverALibraryRecord, Int32>
+  implements IReimplementedEquatable<ProbeRecordBase>
+  implements ISpanFormattable
+  implements ISpanParsable<OverALibraryRecord>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<OverALibraryRecord>
+  implements IValue<Int32>
+  implements IValueObject<OverALibraryRecord, Int32>
+  implements IValueObjectMaterializer<OverALibraryRecord, Int32>
+  nested OverALibraryRecordJsonConverter : JsonConverter<OverALibraryRecord>, IStoredJsonConverterSource
+  nested OverALibraryRecordTypeConverter : TypeConverter
+  static From(Int32) : OverALibraryRecord
+  static MaxValue : OverALibraryRecord
+  static MinValue : OverALibraryRecord
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : OverALibraryRecord
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : OverALibraryRecord
+  static Parse(String, IFormatProvider) : OverALibraryRecord
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out OverALibraryRecord) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out OverALibraryRecord) : Boolean
+  static TryParse(String, IFormatProvider, out OverALibraryRecord) : Boolean
+  static op_Equality(OverALibraryRecord, OverALibraryRecord) : Boolean
+  static op_GreaterThan(OverALibraryRecord, OverALibraryRecord) : Boolean
+  static op_GreaterThanOrEqual(OverALibraryRecord, OverALibraryRecord) : Boolean
+  static op_Inequality(OverALibraryRecord, OverALibraryRecord) : Boolean
+  static op_LessThan(OverALibraryRecord, OverALibraryRecord) : Boolean
+  static op_LessThanOrEqual(OverALibraryRecord, OverALibraryRecord) : Boolean
+  extension static OverALibraryRecordExtensions.GetValue(OverALibraryRecord) : Int32
+  extension static OverALibraryRecordExtensions.ValueOrNull(OverALibraryRecord) : Int32?
+OverAReferenceEqualityRecord
+  <Clone>$() : OverAReferenceEqualityRecord
+  CompareTo(Object) : Int32
+  CompareTo(OverAReferenceEqualityRecord) : Int32
+  Equals(LocalReferenceEqualityRecord) : Boolean
+  Equals(Object) : Boolean
+  Equals(OverAReferenceEqualityRecord) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Int32
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverAReferenceEqualityRecord, Int32>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<OverAReferenceEqualityRecord>
+  implements IComparisonOperators<OverAReferenceEqualityRecord, OverAReferenceEqualityRecord, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<OverAReferenceEqualityRecord, OverAReferenceEqualityRecord, Boolean>
+  implements IEquatable<LocalReferenceEqualityRecord>
+  implements IEquatable<OverAReferenceEqualityRecord>
+  implements IFormattable
+  implements IMinMaxValue<OverAReferenceEqualityRecord>
+  implements IParsable<OverAReferenceEqualityRecord>
+  implements IPlainValueObject<OverAReferenceEqualityRecord, Int32>
+  implements IReimplementedEquatable<LocalReferenceEqualityRecord>
+  implements ISpanFormattable
+  implements ISpanParsable<OverAReferenceEqualityRecord>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<OverAReferenceEqualityRecord>
+  implements IValue<Int32>
+  implements IValueObject<OverAReferenceEqualityRecord, Int32>
+  implements IValueObjectMaterializer<OverAReferenceEqualityRecord, Int32>
+  nested OverAReferenceEqualityRecordJsonConverter : JsonConverter<OverAReferenceEqualityRecord>, IStoredJsonConverterSource
+  nested OverAReferenceEqualityRecordTypeConverter : TypeConverter
+  static From(Int32) : OverAReferenceEqualityRecord
+  static MaxValue : OverAReferenceEqualityRecord
+  static MinValue : OverAReferenceEqualityRecord
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : OverAReferenceEqualityRecord
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : OverAReferenceEqualityRecord
+  static Parse(String, IFormatProvider) : OverAReferenceEqualityRecord
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out OverAReferenceEqualityRecord) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out OverAReferenceEqualityRecord) : Boolean
+  static TryParse(String, IFormatProvider, out OverAReferenceEqualityRecord) : Boolean
+  static op_Equality(OverAReferenceEqualityRecord, OverAReferenceEqualityRecord) : Boolean
+  static op_GreaterThan(OverAReferenceEqualityRecord, OverAReferenceEqualityRecord) : Boolean
+  static op_GreaterThanOrEqual(OverAReferenceEqualityRecord, OverAReferenceEqualityRecord) : Boolean
+  static op_Inequality(OverAReferenceEqualityRecord, OverAReferenceEqualityRecord) : Boolean
+  static op_LessThan(OverAReferenceEqualityRecord, OverAReferenceEqualityRecord) : Boolean
+  static op_LessThanOrEqual(OverAReferenceEqualityRecord, OverAReferenceEqualityRecord) : Boolean
+  extension static OverAReferenceEqualityRecordExtensions.GetValue(OverAReferenceEqualityRecord) : Int32
+  extension static OverAReferenceEqualityRecordExtensions.ValueOrNull(OverAReferenceEqualityRecord) : Int32?
+OverAccess
+  CompareTo(Object) : Int32
+  CompareTo(OverAccess) : Int32
+  Equals(Object) : Boolean
+  Equals(OverAccess) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : ProbeAccess
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverAccess, ProbeAccess>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<OverAccess>
+  implements IComparisonOperators<OverAccess, OverAccess, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<OverAccess, OverAccess, Boolean>
+  implements IEquatable<OverAccess>
+  implements IFormattable
+  implements IParsable<OverAccess>
+  implements IPlainValueObject<OverAccess, ProbeAccess>
+  implements ISpanFormattable
+  implements IValue<ProbeAccess>
+  implements IValueObject<OverAccess, ProbeAccess>
+  implements IValueObjectMaterializer<OverAccess, ProbeAccess>
+  nested OverAccessJsonConverter : JsonConverter<OverAccess>, IStoredJsonConverterSource
+  nested OverAccessTypeConverter : TypeConverter
+  new()
+  static From(ProbeAccess) : OverAccess
+  static Parse(String, IFormatProvider) : OverAccess
+  static TryParse(String, IFormatProvider, out OverAccess) : Boolean
+  static op_Equality(OverAccess, OverAccess) : Boolean
+  static op_GreaterThan(OverAccess, OverAccess) : Boolean
+  static op_GreaterThanOrEqual(OverAccess, OverAccess) : Boolean
+  static op_Inequality(OverAccess, OverAccess) : Boolean
+  static op_LessThan(OverAccess, OverAccess) : Boolean
+  static op_LessThanOrEqual(OverAccess, OverAccess) : Boolean
+  extension static OverAccessExtensions.GetValue(OverAccess) : ProbeAccess
+  extension static OverAccessExtensions.ValueOrNull(OverAccess?) : ProbeAccess?
+OverAnExplicitEqualityRecord
+  <Clone>$() : OverAnExplicitEqualityRecord
+  CompareTo(Object) : Int32
+  CompareTo(OverAnExplicitEqualityRecord) : Int32
+  Equals(LocalExplicitEqualityRecord) : Boolean
+  Equals(Object) : Boolean
+  Equals(OverAnExplicitEqualityRecord) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Int32
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverAnExplicitEqualityRecord, Int32>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<OverAnExplicitEqualityRecord>
+  implements IComparisonOperators<OverAnExplicitEqualityRecord, OverAnExplicitEqualityRecord, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<OverAnExplicitEqualityRecord, OverAnExplicitEqualityRecord, Boolean>
+  implements IEquatable<LocalExplicitEqualityRecord>
+  implements IEquatable<OverAnExplicitEqualityRecord>
+  implements IFormattable
+  implements IMinMaxValue<OverAnExplicitEqualityRecord>
+  implements IParsable<OverAnExplicitEqualityRecord>
+  implements IPlainValueObject<OverAnExplicitEqualityRecord, Int32>
+  implements IReimplementedEquatable<LocalExplicitEqualityRecord>
+  implements ISpanFormattable
+  implements ISpanParsable<OverAnExplicitEqualityRecord>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<OverAnExplicitEqualityRecord>
+  implements IValue<Int32>
+  implements IValueObject<OverAnExplicitEqualityRecord, Int32>
+  implements IValueObjectMaterializer<OverAnExplicitEqualityRecord, Int32>
+  nested OverAnExplicitEqualityRecordJsonConverter : JsonConverter<OverAnExplicitEqualityRecord>, IStoredJsonConverterSource
+  nested OverAnExplicitEqualityRecordTypeConverter : TypeConverter
+  static From(Int32) : OverAnExplicitEqualityRecord
+  static MaxValue : OverAnExplicitEqualityRecord
+  static MinValue : OverAnExplicitEqualityRecord
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : OverAnExplicitEqualityRecord
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : OverAnExplicitEqualityRecord
+  static Parse(String, IFormatProvider) : OverAnExplicitEqualityRecord
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out OverAnExplicitEqualityRecord) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out OverAnExplicitEqualityRecord) : Boolean
+  static TryParse(String, IFormatProvider, out OverAnExplicitEqualityRecord) : Boolean
+  static op_Equality(OverAnExplicitEqualityRecord, OverAnExplicitEqualityRecord) : Boolean
+  static op_GreaterThan(OverAnExplicitEqualityRecord, OverAnExplicitEqualityRecord) : Boolean
+  static op_GreaterThanOrEqual(OverAnExplicitEqualityRecord, OverAnExplicitEqualityRecord) : Boolean
+  static op_Inequality(OverAnExplicitEqualityRecord, OverAnExplicitEqualityRecord) : Boolean
+  static op_LessThan(OverAnExplicitEqualityRecord, OverAnExplicitEqualityRecord) : Boolean
+  static op_LessThanOrEqual(OverAnExplicitEqualityRecord, OverAnExplicitEqualityRecord) : Boolean
+  extension static OverAnExplicitEqualityRecordExtensions.GetValue(OverAnExplicitEqualityRecord) : Int32
+  extension static OverAnExplicitEqualityRecordExtensions.ValueOrNull(OverAnExplicitEqualityRecord) : Int32?
+OverAnIdentityRecord
+  <Clone>$() : OverAnIdentityRecord
+  CompareTo(Object) : Int32
+  CompareTo(OverAnIdentityRecord) : Int32
+  Equals(Object) : Boolean
+  Equals(OverAnIdentityRecord) : Boolean
+  Equals(ProbeIdentityRecord) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Int32
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverAnIdentityRecord, Int32>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<OverAnIdentityRecord>
+  implements IComparisonOperators<OverAnIdentityRecord, OverAnIdentityRecord, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<OverAnIdentityRecord, OverAnIdentityRecord, Boolean>
+  implements IEquatable<OverAnIdentityRecord>
+  implements IEquatable<ProbeIdentityRecord>
+  implements IFormattable
+  implements IMinMaxValue<OverAnIdentityRecord>
+  implements IParsable<OverAnIdentityRecord>
+  implements IPlainValueObject<OverAnIdentityRecord, Int32>
+  implements IReimplementedEquatable<ProbeIdentityRecord>
+  implements ISpanFormattable
+  implements ISpanParsable<OverAnIdentityRecord>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<OverAnIdentityRecord>
+  implements IValue<Int32>
+  implements IValueObject<OverAnIdentityRecord, Int32>
+  implements IValueObjectMaterializer<OverAnIdentityRecord, Int32>
+  nested OverAnIdentityRecordJsonConverter : JsonConverter<OverAnIdentityRecord>, IStoredJsonConverterSource
+  nested OverAnIdentityRecordTypeConverter : TypeConverter
+  static From(Int32) : OverAnIdentityRecord
+  static MaxValue : OverAnIdentityRecord
+  static MinValue : OverAnIdentityRecord
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : OverAnIdentityRecord
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : OverAnIdentityRecord
+  static Parse(String, IFormatProvider) : OverAnIdentityRecord
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out OverAnIdentityRecord) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out OverAnIdentityRecord) : Boolean
+  static TryParse(String, IFormatProvider, out OverAnIdentityRecord) : Boolean
+  static op_Equality(OverAnIdentityRecord, OverAnIdentityRecord) : Boolean
+  static op_GreaterThan(OverAnIdentityRecord, OverAnIdentityRecord) : Boolean
+  static op_GreaterThanOrEqual(OverAnIdentityRecord, OverAnIdentityRecord) : Boolean
+  static op_Inequality(OverAnIdentityRecord, OverAnIdentityRecord) : Boolean
+  static op_LessThan(OverAnIdentityRecord, OverAnIdentityRecord) : Boolean
+  static op_LessThanOrEqual(OverAnIdentityRecord, OverAnIdentityRecord) : Boolean
+  extension static OverAnIdentityRecordExtensions.GetValue(OverAnIdentityRecord) : Int32
+  extension static OverAnIdentityRecordExtensions.ValueOrNull(OverAnIdentityRecord) : Int32?
+OverByte
+  CompareTo(Object) : Int32
+  CompareTo(OverByte) : Int32
+  Equals(Object) : Boolean
+  Equals(OverByte) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Byte
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverByte, Byte>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<OverByte>
+  implements IComparisonOperators<OverByte, OverByte, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<OverByte, OverByte, Boolean>
+  implements IEquatable<OverByte>
+  implements IFormattable
+  implements IMinMaxValue<OverByte>
+  implements IParsable<OverByte>
+  implements IPlainValueObject<OverByte, Byte>
+  implements ISpanFormattable
+  implements ISpanParsable<OverByte>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<OverByte>
+  implements IValue<Byte>
+  implements IValueObject<OverByte, Byte>
+  implements IValueObjectMaterializer<OverByte, Byte>
+  nested OverByteJsonConverter : JsonConverter<OverByte>, IStoredJsonConverterSource
+  nested OverByteTypeConverter : TypeConverter
+  new()
+  static From(Byte) : OverByte
+  static MaxValue : OverByte
+  static MinValue : OverByte
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : OverByte
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : OverByte
+  static Parse(String, IFormatProvider) : OverByte
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out OverByte) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out OverByte) : Boolean
+  static TryParse(String, IFormatProvider, out OverByte) : Boolean
+  static op_Equality(OverByte, OverByte) : Boolean
+  static op_GreaterThan(OverByte, OverByte) : Boolean
+  static op_GreaterThanOrEqual(OverByte, OverByte) : Boolean
+  static op_Inequality(OverByte, OverByte) : Boolean
+  static op_LessThan(OverByte, OverByte) : Boolean
+  static op_LessThanOrEqual(OverByte, OverByte) : Boolean
+  extension static OverByteExtensions.GetValue(OverByte) : Byte
+  extension static OverByteExtensions.ValueOrNull(OverByte?) : Byte?
+OverChar
+  CompareTo(Object) : Int32
+  CompareTo(OverChar) : Int32
+  Equals(Object) : Boolean
+  Equals(OverChar) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Char
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverChar, Char>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<OverChar>
+  implements IComparisonOperators<OverChar, OverChar, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<OverChar, OverChar, Boolean>
+  implements IEquatable<OverChar>
+  implements IFormattable
+  implements IMinMaxValue<OverChar>
+  implements IParsable<OverChar>
+  implements IPlainValueObject<OverChar, Char>
+  implements ISpanFormattable
+  implements ISpanParsable<OverChar>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<OverChar>
+  implements IValue<Char>
+  implements IValueObject<OverChar, Char>
+  implements IValueObjectMaterializer<OverChar, Char>
+  nested OverCharJsonConverter : JsonConverter<OverChar>, IStoredJsonConverterSource
+  nested OverCharTypeConverter : TypeConverter
+  new()
+  static From(Char) : OverChar
+  static MaxValue : OverChar
+  static MinValue : OverChar
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : OverChar
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : OverChar
+  static Parse(String, IFormatProvider) : OverChar
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out OverChar) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out OverChar) : Boolean
+  static TryParse(String, IFormatProvider, out OverChar) : Boolean
+  static op_Equality(OverChar, OverChar) : Boolean
+  static op_GreaterThan(OverChar, OverChar) : Boolean
+  static op_GreaterThanOrEqual(OverChar, OverChar) : Boolean
+  static op_Inequality(OverChar, OverChar) : Boolean
+  static op_LessThan(OverChar, OverChar) : Boolean
+  static op_LessThanOrEqual(OverChar, OverChar) : Boolean
+  extension static OverCharExtensions.GetValue(OverChar) : Char
+  extension static OverCharExtensions.ValueOrNull(OverChar?) : Char?
+OverCode
+  Equals(Object) : Boolean
+  Equals(OverCode) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : Code
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverCode, Code>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IEqualityOperators<OverCode, OverCode, Boolean>
+  implements IEquatable<OverCode>
+  implements IFormattable
+  implements IParsable<OverCode>
+  implements IPlainValueObject<OverCode, Code>
+  implements IValue<Code>
+  implements IValueObject<OverCode, Code>
+  implements IValueObjectMaterializer<OverCode, Code>
+  nested OverCodeJsonConverter : JsonConverter<OverCode>, IStoredJsonConverterSource
+  nested OverCodeTypeConverter : TypeConverter
+  new()
+  static From(Code) : OverCode
+  static Parse(String, IFormatProvider) : OverCode
+  static TryParse(String, IFormatProvider, out OverCode) : Boolean
+  static op_Equality(OverCode, OverCode) : Boolean
+  static op_Inequality(OverCode, OverCode) : Boolean
+  extension static OverCodeExtensions.GetValue(OverCode) : Code
+  extension static OverCodeExtensions.ValueOrNull(OverCode?) : Code?
+OverConstructedAbstract
+  Equals(Object) : Boolean
+  Equals(OverConstructedAbstract) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : ConstructedAbstract
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverConstructedAbstract, ConstructedAbstract>
+  attribute JsonConverterAttribute
+  implements IEqualityOperators<OverConstructedAbstract, OverConstructedAbstract, Boolean>
+  implements IEquatable<OverConstructedAbstract>
+  implements IFormattable
+  implements IPlainValueObject<OverConstructedAbstract, ConstructedAbstract>
+  implements IValue<ConstructedAbstract>
+  implements IValueObject<OverConstructedAbstract, ConstructedAbstract>
+  implements IValueObjectMaterializer<OverConstructedAbstract, ConstructedAbstract>
+  nested OverConstructedAbstractJsonConverter : JsonConverter<OverConstructedAbstract>, IStoredJsonConverterSource
+  new()
+  static From(ConstructedAbstract) : OverConstructedAbstract
+  static op_Equality(OverConstructedAbstract, OverConstructedAbstract) : Boolean
+  static op_Inequality(OverConstructedAbstract, OverConstructedAbstract) : Boolean
+  extension static OverConstructedAbstractExtensions.GetValue(OverConstructedAbstract) : ConstructedAbstract
+  extension static OverConstructedAbstractExtensions.ValueOrNull(OverConstructedAbstract?) : ConstructedAbstract
+OverConstructedByRef
+  Equals(Object) : Boolean
+  Equals(OverConstructedByRef) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : ConstructedByRef
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverConstructedByRef, ConstructedByRef>
+  attribute JsonConverterAttribute
+  implements IEqualityOperators<OverConstructedByRef, OverConstructedByRef, Boolean>
+  implements IEquatable<OverConstructedByRef>
+  implements IFormattable
+  implements IPlainValueObject<OverConstructedByRef, ConstructedByRef>
+  implements IValue<ConstructedByRef>
+  implements IValueObject<OverConstructedByRef, ConstructedByRef>
+  implements IValueObjectMaterializer<OverConstructedByRef, ConstructedByRef>
+  nested OverConstructedByRefJsonConverter : JsonConverter<OverConstructedByRef>, IStoredJsonConverterSource
+  new()
+  static From(ConstructedByRef) : OverConstructedByRef
+  static op_Equality(OverConstructedByRef, OverConstructedByRef) : Boolean
+  static op_Inequality(OverConstructedByRef, OverConstructedByRef) : Boolean
+  extension static OverConstructedByRefExtensions.GetValue(OverConstructedByRef) : ConstructedByRef
+  extension static OverConstructedByRefExtensions.ValueOrNull(OverConstructedByRef?) : ConstructedByRef
+OverConstructedFromIn
+  Equals(Object) : Boolean
+  Equals(OverConstructedFromIn) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : ConstructedFromIn
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverConstructedFromIn, ConstructedFromIn>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IEqualityOperators<OverConstructedFromIn, OverConstructedFromIn, Boolean>
+  implements IEquatable<OverConstructedFromIn>
+  implements IFormattable
+  implements IParsable<OverConstructedFromIn>
+  implements IPlainValueObject<OverConstructedFromIn, ConstructedFromIn>
+  implements IValue<ConstructedFromIn>
+  implements IValueObject<OverConstructedFromIn, ConstructedFromIn>
+  implements IValueObjectMaterializer<OverConstructedFromIn, ConstructedFromIn>
+  nested OverConstructedFromInJsonConverter : JsonConverter<OverConstructedFromIn>, IStoredJsonConverterSource
+  nested OverConstructedFromInTypeConverter : TypeConverter
+  new()
+  static From(ConstructedFromIn) : OverConstructedFromIn
+  static Parse(String, IFormatProvider) : OverConstructedFromIn
+  static TryParse(String, IFormatProvider, out OverConstructedFromIn) : Boolean
+  static op_Equality(OverConstructedFromIn, OverConstructedFromIn) : Boolean
+  static op_Inequality(OverConstructedFromIn, OverConstructedFromIn) : Boolean
+  extension static OverConstructedFromInExtensions.GetValue(OverConstructedFromIn) : ConstructedFromIn
+  extension static OverConstructedFromInExtensions.ValueOrNull(OverConstructedFromIn?) : ConstructedFromIn
+OverDisposable
+  Equals(Object) : Boolean
+  Equals(OverDisposable) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : IDisposable
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverDisposable, IDisposable>
+  attribute JsonConverterAttribute
+  implements IEqualityOperators<OverDisposable, OverDisposable, Boolean>
+  implements IEquatable<OverDisposable>
+  implements IFormattable
+  implements IPlainValueObject<OverDisposable, IDisposable>
+  implements IValue<IDisposable>
+  implements IValueObject<OverDisposable, IDisposable>
+  implements IValueObjectMaterializer<OverDisposable, IDisposable>
+  nested OverDisposableJsonConverter : JsonConverter<OverDisposable>, IStoredJsonConverterSource
+  new()
+  static From(IDisposable) : OverDisposable
+  static op_Equality(OverDisposable, OverDisposable) : Boolean
+  static op_Inequality(OverDisposable, OverDisposable) : Boolean
+  extension static OverDisposableExtensions.GetValue(OverDisposable) : IDisposable
+  extension static OverDisposableExtensions.ValueOrNull(OverDisposable?) : IDisposable
+OverGenericParser
+  Equals(Object) : Boolean
+  Equals(OverGenericParser) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : GenericParser
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverGenericParser, GenericParser>
+  attribute JsonConverterAttribute
+  implements IEqualityOperators<OverGenericParser, OverGenericParser, Boolean>
+  implements IEquatable<OverGenericParser>
+  implements IFormattable
+  implements IPlainValueObject<OverGenericParser, GenericParser>
+  implements IValue<GenericParser>
+  implements IValueObject<OverGenericParser, GenericParser>
+  implements IValueObjectMaterializer<OverGenericParser, GenericParser>
+  nested OverGenericParserJsonConverter : JsonConverter<OverGenericParser>, IStoredJsonConverterSource
+  new()
+  static From(GenericParser) : OverGenericParser
+  static op_Equality(OverGenericParser, OverGenericParser) : Boolean
+  static op_Inequality(OverGenericParser, OverGenericParser) : Boolean
+  extension static OverGenericParserExtensions.GetValue(OverGenericParser) : GenericParser
+  extension static OverGenericParserExtensions.ValueOrNull(OverGenericParser?) : GenericParser
+OverHoldingAnything
+  Equals(Object) : Boolean
+  Equals(OverHoldingAnything) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : HoldingAnything
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverHoldingAnything, HoldingAnything>
+  attribute JsonConverterAttribute
+  implements IEqualityOperators<OverHoldingAnything, OverHoldingAnything, Boolean>
+  implements IEquatable<OverHoldingAnything>
+  implements IFormattable
+  implements IPlainValueObject<OverHoldingAnything, HoldingAnything>
+  implements IValue<HoldingAnything>
+  implements IValueObject<OverHoldingAnything, HoldingAnything>
+  implements IValueObjectMaterializer<OverHoldingAnything, HoldingAnything>
+  nested OverHoldingAnythingJsonConverter : JsonConverter<OverHoldingAnything>, IStoredJsonConverterSource
+  new()
+  static From(HoldingAnything) : OverHoldingAnything
+  static op_Equality(OverHoldingAnything, OverHoldingAnything) : Boolean
+  static op_Inequality(OverHoldingAnything, OverHoldingAnything) : Boolean
+  extension static OverHoldingAnythingExtensions.GetValue(OverHoldingAnything) : HoldingAnything
+  extension static OverHoldingAnythingExtensions.ValueOrNull(OverHoldingAnything?) : HoldingAnything?
+OverHoldingIgnored
+  Equals(Object) : Boolean
+  Equals(OverHoldingIgnored) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : HoldingIgnored
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverHoldingIgnored, HoldingIgnored>
+  attribute JsonConverterAttribute
+  implements IEqualityOperators<OverHoldingIgnored, OverHoldingIgnored, Boolean>
+  implements IEquatable<OverHoldingIgnored>
+  implements IFormattable
+  implements IPlainValueObject<OverHoldingIgnored, HoldingIgnored>
+  implements IValue<HoldingIgnored>
+  implements IValueObject<OverHoldingIgnored, HoldingIgnored>
+  implements IValueObjectMaterializer<OverHoldingIgnored, HoldingIgnored>
+  nested OverHoldingIgnoredJsonConverter : JsonConverter<OverHoldingIgnored>, IStoredJsonConverterSource
+  new()
+  static From(HoldingIgnored) : OverHoldingIgnored
+  static op_Equality(OverHoldingIgnored, OverHoldingIgnored) : Boolean
+  static op_Inequality(OverHoldingIgnored, OverHoldingIgnored) : Boolean
+  extension static OverHoldingIgnoredExtensions.GetValue(OverHoldingIgnored) : HoldingIgnored
+  extension static OverHoldingIgnoredExtensions.ValueOrNull(OverHoldingIgnored?) : HoldingIgnored?
+OverHoldingNamedHolder
+  Equals(Object) : Boolean
+  Equals(OverHoldingNamedHolder) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : HoldingNamedHolder
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverHoldingNamedHolder, HoldingNamedHolder>
+  attribute JsonConverterAttribute
+  implements IEqualityOperators<OverHoldingNamedHolder, OverHoldingNamedHolder, Boolean>
+  implements IEquatable<OverHoldingNamedHolder>
+  implements IFormattable
+  implements IPlainValueObject<OverHoldingNamedHolder, HoldingNamedHolder>
+  implements IValue<HoldingNamedHolder>
+  implements IValueObject<OverHoldingNamedHolder, HoldingNamedHolder>
+  implements IValueObjectMaterializer<OverHoldingNamedHolder, HoldingNamedHolder>
+  nested OverHoldingNamedHolderJsonConverter : JsonConverter<OverHoldingNamedHolder>, IStoredJsonConverterSource
+  new()
+  static From(HoldingNamedHolder) : OverHoldingNamedHolder
+  static op_Equality(OverHoldingNamedHolder, OverHoldingNamedHolder) : Boolean
+  static op_Inequality(OverHoldingNamedHolder, OverHoldingNamedHolder) : Boolean
+  extension static OverHoldingNamedHolderExtensions.GetValue(OverHoldingNamedHolder) : HoldingNamedHolder
+  extension static OverHoldingNamedHolderExtensions.ValueOrNull(OverHoldingNamedHolder?) : HoldingNamedHolder?
+OverHoldingNamedShade
+  Equals(Object) : Boolean
+  Equals(OverHoldingNamedShade) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : HoldingNamedShade
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverHoldingNamedShade, HoldingNamedShade>
+  attribute JsonConverterAttribute
+  implements IEqualityOperators<OverHoldingNamedShade, OverHoldingNamedShade, Boolean>
+  implements IEquatable<OverHoldingNamedShade>
+  implements IFormattable
+  implements IPlainValueObject<OverHoldingNamedShade, HoldingNamedShade>
+  implements IValue<HoldingNamedShade>
+  implements IValueObject<OverHoldingNamedShade, HoldingNamedShade>
+  implements IValueObjectMaterializer<OverHoldingNamedShade, HoldingNamedShade>
+  nested OverHoldingNamedShadeJsonConverter : JsonConverter<OverHoldingNamedShade>, IStoredJsonConverterSource
+  new()
+  static From(HoldingNamedShade) : OverHoldingNamedShade
+  static op_Equality(OverHoldingNamedShade, OverHoldingNamedShade) : Boolean
+  static op_Inequality(OverHoldingNamedShade, OverHoldingNamedShade) : Boolean
+  extension static OverHoldingNamedShadeExtensions.GetValue(OverHoldingNamedShade) : HoldingNamedShade
+  extension static OverHoldingNamedShadeExtensions.ValueOrNull(OverHoldingNamedShade?) : HoldingNamedShade?
+OverHoldingNullableHolder
+  Equals(Object) : Boolean
+  Equals(OverHoldingNullableHolder) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : HoldingNullableHolder
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverHoldingNullableHolder, HoldingNullableHolder>
+  attribute JsonConverterAttribute
+  implements IEqualityOperators<OverHoldingNullableHolder, OverHoldingNullableHolder, Boolean>
+  implements IEquatable<OverHoldingNullableHolder>
+  implements IFormattable
+  implements IPlainValueObject<OverHoldingNullableHolder, HoldingNullableHolder>
+  implements IValue<HoldingNullableHolder>
+  implements IValueObject<OverHoldingNullableHolder, HoldingNullableHolder>
+  implements IValueObjectMaterializer<OverHoldingNullableHolder, HoldingNullableHolder>
+  nested OverHoldingNullableHolderJsonConverter : JsonConverter<OverHoldingNullableHolder>, IStoredJsonConverterSource
+  new()
+  static From(HoldingNullableHolder) : OverHoldingNullableHolder
+  static op_Equality(OverHoldingNullableHolder, OverHoldingNullableHolder) : Boolean
+  static op_Inequality(OverHoldingNullableHolder, OverHoldingNullableHolder) : Boolean
+  extension static OverHoldingNullableHolderExtensions.GetValue(OverHoldingNullableHolder) : HoldingNullableHolder
+  extension static OverHoldingNullableHolderExtensions.ValueOrNull(OverHoldingNullableHolder?) : HoldingNullableHolder?
+OverHoldingTracked
+  Equals(Object) : Boolean
+  Equals(OverHoldingTracked) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : HoldingTracked
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverHoldingTracked, HoldingTracked>
+  attribute JsonConverterAttribute
+  implements IEqualityOperators<OverHoldingTracked, OverHoldingTracked, Boolean>
+  implements IEquatable<OverHoldingTracked>
+  implements IFormattable
+  implements IPlainValueObject<OverHoldingTracked, HoldingTracked>
+  implements IValue<HoldingTracked>
+  implements IValueObject<OverHoldingTracked, HoldingTracked>
+  implements IValueObjectMaterializer<OverHoldingTracked, HoldingTracked>
+  nested OverHoldingTrackedJsonConverter : JsonConverter<OverHoldingTracked>, IStoredJsonConverterSource
+  new()
+  static From(HoldingTracked) : OverHoldingTracked
+  static op_Equality(OverHoldingTracked, OverHoldingTracked) : Boolean
+  static op_Inequality(OverHoldingTracked, OverHoldingTracked) : Boolean
+  extension static OverHoldingTrackedExtensions.GetValue(OverHoldingTracked) : HoldingTracked
+  extension static OverHoldingTrackedExtensions.ValueOrNull(OverHoldingTracked?) : HoldingTracked?
+OverLabels
+  Equals(Object) : Boolean
+  Equals(OverLabels) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : Labels
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverLabels, Labels>
+  attribute JsonConverterAttribute
+  implements IEqualityOperators<OverLabels, OverLabels, Boolean>
+  implements IEquatable<OverLabels>
+  implements IFormattable
+  implements IPlainValueObject<OverLabels, Labels>
+  implements IValue<Labels>
+  implements IValueObject<OverLabels, Labels>
+  implements IValueObjectMaterializer<OverLabels, Labels>
+  nested OverLabelsJsonConverter : JsonConverter<OverLabels>, IStoredJsonConverterSource
+  new()
+  static From(Labels) : OverLabels
+  static op_Equality(OverLabels, OverLabels) : Boolean
+  static op_Inequality(OverLabels, OverLabels) : Boolean
+  extension static OverLabelsExtensions.GetValue(OverLabels) : Labels
+  extension static OverLabelsExtensions.ValueOrNull(OverLabels?) : Labels?
+OverLocalTime
+  CompareTo(Object) : Int32
+  CompareTo(OverLocalTime) : Int32
+  Equals(Object) : Boolean
+  Equals(OverLocalTime) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : LocalTime
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverLocalTime, LocalTime>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<OverLocalTime>
+  implements IComparisonOperators<OverLocalTime, OverLocalTime, Boolean>
+  implements IEqualityOperators<OverLocalTime, OverLocalTime, Boolean>
+  implements IEquatable<OverLocalTime>
+  implements IFormattable
+  implements IMinMaxValue<OverLocalTime>
+  implements IParsable<OverLocalTime>
+  implements IPlainValueObject<OverLocalTime, LocalTime>
+  implements IValue<LocalTime>
+  implements IValueObject<OverLocalTime, LocalTime>
+  implements IValueObjectMaterializer<OverLocalTime, LocalTime>
+  nested OverLocalTimeJsonConverter : JsonConverter<OverLocalTime>, IStoredJsonConverterSource
+  nested OverLocalTimeTypeConverter : TypeConverter
+  new()
+  static From(LocalTime) : OverLocalTime
+  static MaxValue : OverLocalTime
+  static MinValue : OverLocalTime
+  static Parse(String, IFormatProvider) : OverLocalTime
+  static TryParse(String, IFormatProvider, out OverLocalTime) : Boolean
+  static op_Equality(OverLocalTime, OverLocalTime) : Boolean
+  static op_GreaterThan(OverLocalTime, OverLocalTime) : Boolean
+  static op_GreaterThanOrEqual(OverLocalTime, OverLocalTime) : Boolean
+  static op_Inequality(OverLocalTime, OverLocalTime) : Boolean
+  static op_LessThan(OverLocalTime, OverLocalTime) : Boolean
+  static op_LessThanOrEqual(OverLocalTime, OverLocalTime) : Boolean
+  extension static OverLocalTimeExtensions.GetValue(OverLocalTime) : LocalTime
+  extension static OverLocalTimeExtensions.ValueOrNull(OverLocalTime?) : LocalTime?
+OverLong
+  CompareTo(Object) : Int32
+  CompareTo(OverLong) : Int32
+  Equals(Object) : Boolean
+  Equals(OverLong) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Int64
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverLong, Int64>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<OverLong>
+  implements IComparisonOperators<OverLong, OverLong, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<OverLong, OverLong, Boolean>
+  implements IEquatable<OverLong>
+  implements IFormattable
+  implements IMinMaxValue<OverLong>
+  implements IParsable<OverLong>
+  implements IPlainValueObject<OverLong, Int64>
+  implements ISpanFormattable
+  implements ISpanParsable<OverLong>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<OverLong>
+  implements IValue<Int64>
+  implements IValueObject<OverLong, Int64>
+  implements IValueObjectMaterializer<OverLong, Int64>
+  nested OverLongJsonConverter : JsonConverter<OverLong>, IStoredJsonConverterSource
+  nested OverLongTypeConverter : TypeConverter
+  new()
+  static From(Int64) : OverLong
+  static MaxValue : OverLong
+  static MinValue : OverLong
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : OverLong
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : OverLong
+  static Parse(String, IFormatProvider) : OverLong
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out OverLong) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out OverLong) : Boolean
+  static TryParse(String, IFormatProvider, out OverLong) : Boolean
+  static op_Equality(OverLong, OverLong) : Boolean
+  static op_GreaterThan(OverLong, OverLong) : Boolean
+  static op_GreaterThanOrEqual(OverLong, OverLong) : Boolean
+  static op_Inequality(OverLong, OverLong) : Boolean
+  static op_LessThan(OverLong, OverLong) : Boolean
+  static op_LessThanOrEqual(OverLong, OverLong) : Boolean
+  extension static OverLongExtensions.GetValue(OverLong) : Int64
+  extension static OverLongExtensions.ValueOrNull(OverLong?) : Int64?
+OverParsedFromText
+  Equals(Object) : Boolean
+  Equals(OverParsedFromText) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : ParsedFromText
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverParsedFromText, ParsedFromText>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IEqualityOperators<OverParsedFromText, OverParsedFromText, Boolean>
+  implements IEquatable<OverParsedFromText>
+  implements IFormattable
+  implements IParsable<OverParsedFromText>
+  implements IPlainValueObject<OverParsedFromText, ParsedFromText>
+  implements IValue<ParsedFromText>
+  implements IValueObject<OverParsedFromText, ParsedFromText>
+  implements IValueObjectMaterializer<OverParsedFromText, ParsedFromText>
+  nested OverParsedFromTextJsonConverter : JsonConverter<OverParsedFromText>, IStoredJsonConverterSource
+  nested OverParsedFromTextTypeConverter : TypeConverter
+  new()
+  static From(ParsedFromText) : OverParsedFromText
+  static Parse(String, IFormatProvider) : OverParsedFromText
+  static TryParse(String, IFormatProvider, out OverParsedFromText) : Boolean
+  static op_Equality(OverParsedFromText, OverParsedFromText) : Boolean
+  static op_Inequality(OverParsedFromText, OverParsedFromText) : Boolean
+  extension static OverParsedFromTextExtensions.GetValue(OverParsedFromText) : ParsedFromText
+  extension static OverParsedFromTextExtensions.ValueOrNull(OverParsedFromText?) : ParsedFromText
+OverParsedShape
+  Equals(Object) : Boolean
+  Equals(OverParsedShape) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : ParsedShape
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverParsedShape, ParsedShape>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IEqualityOperators<OverParsedShape, OverParsedShape, Boolean>
+  implements IEquatable<OverParsedShape>
+  implements IFormattable
+  implements IParsable<OverParsedShape>
+  implements IPlainValueObject<OverParsedShape, ParsedShape>
+  implements IValue<ParsedShape>
+  implements IValueObject<OverParsedShape, ParsedShape>
+  implements IValueObjectMaterializer<OverParsedShape, ParsedShape>
+  nested OverParsedShapeJsonConverter : JsonConverter<OverParsedShape>, IStoredJsonConverterSource
+  nested OverParsedShapeTypeConverter : TypeConverter
+  new()
+  static From(ParsedShape) : OverParsedShape
+  static Parse(String, IFormatProvider) : OverParsedShape
+  static TryParse(String, IFormatProvider, out OverParsedShape) : Boolean
+  static op_Equality(OverParsedShape, OverParsedShape) : Boolean
+  static op_Inequality(OverParsedShape, OverParsedShape) : Boolean
+  extension static OverParsedShapeExtensions.GetValue(OverParsedShape) : ParsedShape
+  extension static OverParsedShapeExtensions.ValueOrNull(OverParsedShape?) : ParsedShape
+OverParsesFromIn
+  Equals(Object) : Boolean
+  Equals(OverParsesFromIn) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : ParsesFromIn
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverParsesFromIn, ParsesFromIn>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IEqualityOperators<OverParsesFromIn, OverParsesFromIn, Boolean>
+  implements IEquatable<OverParsesFromIn>
+  implements IFormattable
+  implements IParsable<OverParsesFromIn>
+  implements IPlainValueObject<OverParsesFromIn, ParsesFromIn>
+  implements IValue<ParsesFromIn>
+  implements IValueObject<OverParsesFromIn, ParsesFromIn>
+  implements IValueObjectMaterializer<OverParsesFromIn, ParsesFromIn>
+  nested OverParsesFromInJsonConverter : JsonConverter<OverParsesFromIn>, IStoredJsonConverterSource
+  nested OverParsesFromInTypeConverter : TypeConverter
+  new()
+  static From(ParsesFromIn) : OverParsesFromIn
+  static Parse(String, IFormatProvider) : OverParsesFromIn
+  static TryParse(String, IFormatProvider, out OverParsesFromIn) : Boolean
+  static op_Equality(OverParsesFromIn, OverParsesFromIn) : Boolean
+  static op_Inequality(OverParsesFromIn, OverParsesFromIn) : Boolean
+  extension static OverParsesFromInExtensions.GetValue(OverParsesFromIn) : ParsesFromIn
+  extension static OverParsesFromInExtensions.ValueOrNull(OverParsesFromIn?) : ParsesFromIn
+OverParsesToADerivedType
+  Equals(Object) : Boolean
+  Equals(OverParsesToADerivedType) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : ParsesToADerivedType
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverParsesToADerivedType, ParsesToADerivedType>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IEqualityOperators<OverParsesToADerivedType, OverParsesToADerivedType, Boolean>
+  implements IEquatable<OverParsesToADerivedType>
+  implements IFormattable
+  implements IParsable<OverParsesToADerivedType>
+  implements IPlainValueObject<OverParsesToADerivedType, ParsesToADerivedType>
+  implements IValue<ParsesToADerivedType>
+  implements IValueObject<OverParsesToADerivedType, ParsesToADerivedType>
+  implements IValueObjectMaterializer<OverParsesToADerivedType, ParsesToADerivedType>
+  nested OverParsesToADerivedTypeJsonConverter : JsonConverter<OverParsesToADerivedType>, IStoredJsonConverterSource
+  nested OverParsesToADerivedTypeTypeConverter : TypeConverter
+  new()
+  static From(ParsesToADerivedType) : OverParsesToADerivedType
+  static Parse(String, IFormatProvider) : OverParsesToADerivedType
+  static TryParse(String, IFormatProvider, out OverParsesToADerivedType) : Boolean
+  static op_Equality(OverParsesToADerivedType, OverParsesToADerivedType) : Boolean
+  static op_Inequality(OverParsesToADerivedType, OverParsesToADerivedType) : Boolean
+  extension static OverParsesToADerivedTypeExtensions.GetValue(OverParsesToADerivedType) : ParsesToADerivedType
+  extension static OverParsesToADerivedTypeExtensions.ValueOrNull(OverParsesToADerivedType?) : ParsesToADerivedType
+OverParsesToAnotherType
+  Equals(Object) : Boolean
+  Equals(OverParsesToAnotherType) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : ParsesToAnotherType
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverParsesToAnotherType, ParsesToAnotherType>
+  attribute JsonConverterAttribute
+  implements IEqualityOperators<OverParsesToAnotherType, OverParsesToAnotherType, Boolean>
+  implements IEquatable<OverParsesToAnotherType>
+  implements IFormattable
+  implements IPlainValueObject<OverParsesToAnotherType, ParsesToAnotherType>
+  implements IValue<ParsesToAnotherType>
+  implements IValueObject<OverParsesToAnotherType, ParsesToAnotherType>
+  implements IValueObjectMaterializer<OverParsesToAnotherType, ParsesToAnotherType>
+  nested OverParsesToAnotherTypeJsonConverter : JsonConverter<OverParsesToAnotherType>, IStoredJsonConverterSource
+  new()
+  static From(ParsesToAnotherType) : OverParsesToAnotherType
+  static op_Equality(OverParsesToAnotherType, OverParsesToAnotherType) : Boolean
+  static op_Inequality(OverParsesToAnotherType, OverParsesToAnotherType) : Boolean
+  extension static OverParsesToAnotherTypeExtensions.GetValue(OverParsesToAnotherType) : ParsesToAnotherType
+  extension static OverParsesToAnotherTypeExtensions.ValueOrNull(OverParsesToAnotherType?) : ParsesToAnotherType
+OverParsesVirtually
+  Equals(Object) : Boolean
+  Equals(OverParsesVirtually) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : IParsesVirtually
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverParsesVirtually, IParsesVirtually>
+  attribute JsonConverterAttribute
+  implements IEqualityOperators<OverParsesVirtually, OverParsesVirtually, Boolean>
+  implements IEquatable<OverParsesVirtually>
+  implements IFormattable
+  implements IPlainValueObject<OverParsesVirtually, IParsesVirtually>
+  implements IValue<IParsesVirtually>
+  implements IValueObject<OverParsesVirtually, IParsesVirtually>
+  implements IValueObjectMaterializer<OverParsesVirtually, IParsesVirtually>
+  nested OverParsesVirtuallyJsonConverter : JsonConverter<OverParsesVirtually>, IStoredJsonConverterSource
+  new()
+  static From(IParsesVirtually) : OverParsesVirtually
+  static op_Equality(OverParsesVirtually, OverParsesVirtually) : Boolean
+  static op_Inequality(OverParsesVirtually, OverParsesVirtually) : Boolean
+  extension static OverParsesVirtuallyExtensions.GetValue(OverParsesVirtually) : IParsesVirtually
+  extension static OverParsesVirtuallyExtensions.ValueOrNull(OverParsesVirtually?) : IParsesVirtually
+OverProbeStatus
+  Equals(Object) : Boolean
+  Equals(OverProbeStatus) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : ProbeStatus
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverProbeStatus, ProbeStatus>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IEqualityOperators<OverProbeStatus, OverProbeStatus, Boolean>
+  implements IEquatable<OverProbeStatus>
+  implements IFormattable
+  implements IParsable<OverProbeStatus>
+  implements IPlainValueObject<OverProbeStatus, ProbeStatus>
+  implements IValue<ProbeStatus>
+  implements IValueObject<OverProbeStatus, ProbeStatus>
+  implements IValueObjectMaterializer<OverProbeStatus, ProbeStatus>
+  nested OverProbeStatusJsonConverter : JsonConverter<OverProbeStatus>, IStoredJsonConverterSource
+  nested OverProbeStatusTypeConverter : TypeConverter
+  new()
+  static From(ProbeStatus) : OverProbeStatus
+  static Parse(String, IFormatProvider) : OverProbeStatus
+  static TryParse(String, IFormatProvider, out OverProbeStatus) : Boolean
+  static op_Equality(OverProbeStatus, OverProbeStatus) : Boolean
+  static op_Inequality(OverProbeStatus, OverProbeStatus) : Boolean
+  extension static OverProbeStatusExtensions.GetValue(OverProbeStatus) : ProbeStatus
+  extension static OverProbeStatusExtensions.ValueOrNull(OverProbeStatus?) : ProbeStatus
+OverStream
+  Equals(Object) : Boolean
+  Equals(OverStream) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : Stream
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverStream, Stream>
+  attribute JsonConverterAttribute
+  implements IEqualityOperators<OverStream, OverStream, Boolean>
+  implements IEquatable<OverStream>
+  implements IFormattable
+  implements IPlainValueObject<OverStream, Stream>
+  implements IValue<Stream>
+  implements IValueObject<OverStream, Stream>
+  implements IValueObjectMaterializer<OverStream, Stream>
+  nested OverStreamJsonConverter : JsonConverter<OverStream>, IStoredJsonConverterSource
+  new()
+  static From(Stream) : OverStream
+  static op_Equality(OverStream, OverStream) : Boolean
+  static op_Inequality(OverStream, OverStream) : Boolean
+  extension static OverStreamExtensions.GetValue(OverStream) : Stream
+  extension static OverStreamExtensions.ValueOrNull(OverStream?) : Stream
+OverTracked
+  Equals(Object) : Boolean
+  Equals(OverTracked) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : Tracked
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverTracked, Tracked>
+  attribute JsonConverterAttribute
+  implements IEqualityOperators<OverTracked, OverTracked, Boolean>
+  implements IEquatable<OverTracked>
+  implements IFormattable
+  implements IPlainValueObject<OverTracked, Tracked>
+  implements IValue<Tracked>
+  implements IValueObject<OverTracked, Tracked>
+  implements IValueObjectMaterializer<OverTracked, Tracked>
+  nested OverTrackedJsonConverter : JsonConverter<OverTracked>, IStoredJsonConverterSource
+  new()
+  static From(Tracked) : OverTracked
+  static op_Equality(OverTracked, OverTracked) : Boolean
+  static op_Inequality(OverTracked, OverTracked) : Boolean
+  extension static OverTrackedExtensions.GetValue(OverTracked) : Tracked
+  extension static OverTrackedExtensions.ValueOrNull(OverTracked?) : Tracked
+OverTrackedList
+  Equals(Object) : Boolean
+  Equals(OverTrackedList) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : TrackedList
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverTrackedList, TrackedList>
+  attribute JsonConverterAttribute
+  implements IEqualityOperators<OverTrackedList, OverTrackedList, Boolean>
+  implements IEquatable<OverTrackedList>
+  implements IFormattable
+  implements IPlainValueObject<OverTrackedList, TrackedList>
+  implements IValue<TrackedList>
+  implements IValueObject<OverTrackedList, TrackedList>
+  implements IValueObjectMaterializer<OverTrackedList, TrackedList>
+  nested OverTrackedListJsonConverter : JsonConverter<OverTrackedList>, IStoredJsonConverterSource
+  new()
+  static From(TrackedList) : OverTrackedList
+  static op_Equality(OverTrackedList, OverTrackedList) : Boolean
+  static op_Inequality(OverTrackedList, OverTrackedList) : Boolean
+  extension static OverTrackedListExtensions.GetValue(OverTrackedList) : TrackedList
+  extension static OverTrackedListExtensions.ValueOrNull(OverTrackedList?) : TrackedList?
+OverUInt64
+  CompareTo(Object) : Int32
+  CompareTo(OverUInt64) : Int32
+  Equals(Object) : Boolean
+  Equals(OverUInt64) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : UInt64
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverUInt64, UInt64>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<OverUInt64>
+  implements IComparisonOperators<OverUInt64, OverUInt64, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<OverUInt64, OverUInt64, Boolean>
+  implements IEquatable<OverUInt64>
+  implements IFormattable
+  implements IMinMaxValue<OverUInt64>
+  implements IParsable<OverUInt64>
+  implements IPlainValueObject<OverUInt64, UInt64>
+  implements ISpanFormattable
+  implements ISpanParsable<OverUInt64>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<OverUInt64>
+  implements IValue<UInt64>
+  implements IValueObject<OverUInt64, UInt64>
+  implements IValueObjectMaterializer<OverUInt64, UInt64>
+  nested OverUInt64JsonConverter : JsonConverter<OverUInt64>, IStoredJsonConverterSource
+  nested OverUInt64TypeConverter : TypeConverter
+  new()
+  static From(UInt64) : OverUInt64
+  static MaxValue : OverUInt64
+  static MinValue : OverUInt64
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : OverUInt64
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : OverUInt64
+  static Parse(String, IFormatProvider) : OverUInt64
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out OverUInt64) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out OverUInt64) : Boolean
+  static TryParse(String, IFormatProvider, out OverUInt64) : Boolean
+  static op_Equality(OverUInt64, OverUInt64) : Boolean
+  static op_GreaterThan(OverUInt64, OverUInt64) : Boolean
+  static op_GreaterThanOrEqual(OverUInt64, OverUInt64) : Boolean
+  static op_Inequality(OverUInt64, OverUInt64) : Boolean
+  static op_LessThan(OverUInt64, OverUInt64) : Boolean
+  static op_LessThanOrEqual(OverUInt64, OverUInt64) : Boolean
+  extension static OverUInt64Extensions.GetValue(OverUInt64) : UInt64
+  extension static OverUInt64Extensions.ValueOrNull(OverUInt64?) : UInt64?
+OverUntracked
+  Equals(Object) : Boolean
+  Equals(OverUntracked) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : Untracked
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverUntracked, Untracked>
+  attribute JsonConverterAttribute
+  implements IEqualityOperators<OverUntracked, OverUntracked, Boolean>
+  implements IEquatable<OverUntracked>
+  implements IFormattable
+  implements IPlainValueObject<OverUntracked, Untracked>
+  implements IValue<Untracked>
+  implements IValueObject<OverUntracked, Untracked>
+  implements IValueObjectMaterializer<OverUntracked, Untracked>
+  nested OverUntrackedJsonConverter : JsonConverter<OverUntracked>, IStoredJsonConverterSource
+  new()
+  static From(Untracked) : OverUntracked
+  static op_Equality(OverUntracked, OverUntracked) : Boolean
+  static op_Inequality(OverUntracked, OverUntracked) : Boolean
+  extension static OverUntrackedExtensions.GetValue(OverUntracked) : Untracked
+  extension static OverUntrackedExtensions.ValueOrNull(OverUntracked?) : Untracked?
+OverUntrackedTwice
+  Equals(Object) : Boolean
+  Equals(OverUntrackedTwice) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : UntrackedTwice
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverUntrackedTwice, UntrackedTwice>
+  attribute JsonConverterAttribute
+  implements IEqualityOperators<OverUntrackedTwice, OverUntrackedTwice, Boolean>
+  implements IEquatable<OverUntrackedTwice>
+  implements IFormattable
+  implements IPlainValueObject<OverUntrackedTwice, UntrackedTwice>
+  implements IValue<UntrackedTwice>
+  implements IValueObject<OverUntrackedTwice, UntrackedTwice>
+  implements IValueObjectMaterializer<OverUntrackedTwice, UntrackedTwice>
+  nested OverUntrackedTwiceJsonConverter : JsonConverter<OverUntrackedTwice>, IStoredJsonConverterSource
+  new()
+  static From(UntrackedTwice) : OverUntrackedTwice
+  static op_Equality(OverUntrackedTwice, OverUntrackedTwice) : Boolean
+  static op_Inequality(OverUntrackedTwice, OverUntrackedTwice) : Boolean
+  extension static OverUntrackedTwiceExtensions.GetValue(OverUntrackedTwice) : UntrackedTwice
+  extension static OverUntrackedTwiceExtensions.ValueOrNull(OverUntrackedTwice?) : UntrackedTwice?
+OverVersion
+  CompareTo(Object) : Int32
+  CompareTo(OverVersion) : Int32
+  Equals(Object) : Boolean
+  Equals(OverVersion) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Version
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<OverVersion, Version>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<OverVersion>
+  implements IComparisonOperators<OverVersion, OverVersion, Boolean>
+  implements IEqualityOperators<OverVersion, OverVersion, Boolean>
+  implements IEquatable<OverVersion>
+  implements IFormattable
+  implements IParsable<OverVersion>
+  implements IPlainValueObject<OverVersion, Version>
+  implements ISpanFormattable
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<OverVersion>
+  implements IValue<Version>
+  implements IValueObject<OverVersion, Version>
+  implements IValueObjectMaterializer<OverVersion, Version>
+  nested OverVersionJsonConverter : JsonConverter<OverVersion>, IStoredJsonConverterSource
+  nested OverVersionTypeConverter : TypeConverter
+  new()
+  static From(Version) : OverVersion
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : OverVersion
+  static Parse(String, IFormatProvider) : OverVersion
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out OverVersion) : Boolean
+  static TryParse(String, IFormatProvider, out OverVersion) : Boolean
+  static op_Equality(OverVersion, OverVersion) : Boolean
+  static op_GreaterThan(OverVersion, OverVersion) : Boolean
+  static op_GreaterThanOrEqual(OverVersion, OverVersion) : Boolean
+  static op_Inequality(OverVersion, OverVersion) : Boolean
+  static op_LessThan(OverVersion, OverVersion) : Boolean
+  static op_LessThanOrEqual(OverVersion, OverVersion) : Boolean
+  extension static OverVersionExtensions.GetValue(OverVersion) : Version
+  extension static OverVersionExtensions.ValueOrNull(OverVersion?) : Version
+ParityByte
+  CompareTo(Object) : Int32
+  CompareTo(ParityByte) : Int32
+  Equals(Object) : Boolean
+  Equals(ParityByte) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Byte
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<ParityByte, Byte>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<ParityByte>
+  implements IComparisonOperators<ParityByte, ParityByte, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<ParityByte, ParityByte, Boolean>
+  implements IEquatable<ParityByte>
+  implements IFormattable
+  implements IMinMaxValue<ParityByte>
+  implements IParsable<ParityByte>
+  implements IPlainValueObject<ParityByte, Byte>
+  implements ISpanFormattable
+  implements ISpanParsable<ParityByte>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<ParityByte>
+  implements IValue<Byte>
+  implements IValueObject<ParityByte, Byte>
+  implements IValueObjectMaterializer<ParityByte, Byte>
+  nested ParityByteJsonConverter : JsonConverter<ParityByte>, IStoredJsonConverterSource
+  nested ParityByteTypeConverter : TypeConverter
+  new()
+  static From(Byte) : ParityByte
+  static MaxValue : ParityByte
+  static MinValue : ParityByte
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : ParityByte
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : ParityByte
+  static Parse(String, IFormatProvider) : ParityByte
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out ParityByte) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out ParityByte) : Boolean
+  static TryParse(String, IFormatProvider, out ParityByte) : Boolean
+  static op_Equality(ParityByte, ParityByte) : Boolean
+  static op_GreaterThan(ParityByte, ParityByte) : Boolean
+  static op_GreaterThanOrEqual(ParityByte, ParityByte) : Boolean
+  static op_Inequality(ParityByte, ParityByte) : Boolean
+  static op_LessThan(ParityByte, ParityByte) : Boolean
+  static op_LessThanOrEqual(ParityByte, ParityByte) : Boolean
+  extension static ParityByteExtensions.GetValue(ParityByte) : Byte
+  extension static ParityByteExtensions.ValueOrNull(ParityByte?) : Byte?
+ParityFloat
+  CompareTo(Object) : Int32
+  CompareTo(ParityFloat) : Int32
+  Equals(Object) : Boolean
+  Equals(ParityFloat) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Single
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<ParityFloat, Single>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<ParityFloat>
+  implements IComparisonOperators<ParityFloat, ParityFloat, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<ParityFloat, ParityFloat, Boolean>
+  implements IEquatable<ParityFloat>
+  implements IFormattable
+  implements IMinMaxValue<ParityFloat>
+  implements IParsable<ParityFloat>
+  implements IPlainValueObject<ParityFloat, Single>
+  implements ISpanFormattable
+  implements ISpanParsable<ParityFloat>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<ParityFloat>
+  implements IValue<Single>
+  implements IValueObject<ParityFloat, Single>
+  implements IValueObjectMaterializer<ParityFloat, Single>
+  nested ParityFloatJsonConverter : JsonConverter<ParityFloat>, IStoredJsonConverterSource
+  nested ParityFloatTypeConverter : TypeConverter
+  new()
+  static From(Single) : ParityFloat
+  static MaxValue : ParityFloat
+  static MinValue : ParityFloat
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : ParityFloat
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : ParityFloat
+  static Parse(String, IFormatProvider) : ParityFloat
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out ParityFloat) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out ParityFloat) : Boolean
+  static TryParse(String, IFormatProvider, out ParityFloat) : Boolean
+  static op_Equality(ParityFloat, ParityFloat) : Boolean
+  static op_GreaterThan(ParityFloat, ParityFloat) : Boolean
+  static op_GreaterThanOrEqual(ParityFloat, ParityFloat) : Boolean
+  static op_Inequality(ParityFloat, ParityFloat) : Boolean
+  static op_LessThan(ParityFloat, ParityFloat) : Boolean
+  static op_LessThanOrEqual(ParityFloat, ParityFloat) : Boolean
+  extension static ParityFloatExtensions.GetValue(ParityFloat) : Single
+  extension static ParityFloatExtensions.ValueOrNull(ParityFloat?) : Single?
+ParityHalf
+  CompareTo(Object) : Int32
+  CompareTo(ParityHalf) : Int32
+  Equals(Object) : Boolean
+  Equals(ParityHalf) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Half
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<ParityHalf, Half>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<ParityHalf>
+  implements IComparisonOperators<ParityHalf, ParityHalf, Boolean>
+  implements IEqualityOperators<ParityHalf, ParityHalf, Boolean>
+  implements IEquatable<ParityHalf>
+  implements IFormattable
+  implements IMinMaxValue<ParityHalf>
+  implements IParsable<ParityHalf>
+  implements IPlainValueObject<ParityHalf, Half>
+  implements ISpanFormattable
+  implements ISpanParsable<ParityHalf>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<ParityHalf>
+  implements IValue<Half>
+  implements IValueObject<ParityHalf, Half>
+  implements IValueObjectMaterializer<ParityHalf, Half>
+  nested ParityHalfJsonConverter : JsonConverter<ParityHalf>, IStoredJsonConverterSource
+  nested ParityHalfTypeConverter : TypeConverter
+  new()
+  static From(Half) : ParityHalf
+  static MaxValue : ParityHalf
+  static MinValue : ParityHalf
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : ParityHalf
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : ParityHalf
+  static Parse(String, IFormatProvider) : ParityHalf
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out ParityHalf) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out ParityHalf) : Boolean
+  static TryParse(String, IFormatProvider, out ParityHalf) : Boolean
+  static op_Equality(ParityHalf, ParityHalf) : Boolean
+  static op_GreaterThan(ParityHalf, ParityHalf) : Boolean
+  static op_GreaterThanOrEqual(ParityHalf, ParityHalf) : Boolean
+  static op_Inequality(ParityHalf, ParityHalf) : Boolean
+  static op_LessThan(ParityHalf, ParityHalf) : Boolean
+  static op_LessThanOrEqual(ParityHalf, ParityHalf) : Boolean
+  extension static ParityHalfExtensions.GetValue(ParityHalf) : Half
+  extension static ParityHalfExtensions.ValueOrNull(ParityHalf?) : Half?
+ParityInt128
+  CompareTo(Object) : Int32
+  CompareTo(ParityInt128) : Int32
+  Equals(Object) : Boolean
+  Equals(ParityInt128) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Int128
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<ParityInt128, Int128>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<ParityInt128>
+  implements IComparisonOperators<ParityInt128, ParityInt128, Boolean>
+  implements IEqualityOperators<ParityInt128, ParityInt128, Boolean>
+  implements IEquatable<ParityInt128>
+  implements IFormattable
+  implements IMinMaxValue<ParityInt128>
+  implements IParsable<ParityInt128>
+  implements IPlainValueObject<ParityInt128, Int128>
+  implements ISpanFormattable
+  implements ISpanParsable<ParityInt128>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<ParityInt128>
+  implements IValue<Int128>
+  implements IValueObject<ParityInt128, Int128>
+  implements IValueObjectMaterializer<ParityInt128, Int128>
+  nested ParityInt128JsonConverter : JsonConverter<ParityInt128>, IStoredJsonConverterSource
+  nested ParityInt128TypeConverter : TypeConverter
+  new()
+  static From(Int128) : ParityInt128
+  static MaxValue : ParityInt128
+  static MinValue : ParityInt128
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : ParityInt128
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : ParityInt128
+  static Parse(String, IFormatProvider) : ParityInt128
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out ParityInt128) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out ParityInt128) : Boolean
+  static TryParse(String, IFormatProvider, out ParityInt128) : Boolean
+  static op_Equality(ParityInt128, ParityInt128) : Boolean
+  static op_GreaterThan(ParityInt128, ParityInt128) : Boolean
+  static op_GreaterThanOrEqual(ParityInt128, ParityInt128) : Boolean
+  static op_Inequality(ParityInt128, ParityInt128) : Boolean
+  static op_LessThan(ParityInt128, ParityInt128) : Boolean
+  static op_LessThanOrEqual(ParityInt128, ParityInt128) : Boolean
+  extension static ParityInt128Extensions.GetValue(ParityInt128) : Int128
+  extension static ParityInt128Extensions.ValueOrNull(ParityInt128?) : Int128?
+ParityLong
+  CompareTo(Object) : Int32
+  CompareTo(ParityLong) : Int32
+  Equals(Object) : Boolean
+  Equals(ParityLong) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Int64
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<ParityLong, Int64>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<ParityLong>
+  implements IComparisonOperators<ParityLong, ParityLong, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<ParityLong, ParityLong, Boolean>
+  implements IEquatable<ParityLong>
+  implements IFormattable
+  implements IMinMaxValue<ParityLong>
+  implements IParsable<ParityLong>
+  implements IPlainValueObject<ParityLong, Int64>
+  implements ISpanFormattable
+  implements ISpanParsable<ParityLong>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<ParityLong>
+  implements IValue<Int64>
+  implements IValueObject<ParityLong, Int64>
+  implements IValueObjectMaterializer<ParityLong, Int64>
+  nested ParityLongJsonConverter : JsonConverter<ParityLong>, IStoredJsonConverterSource
+  nested ParityLongTypeConverter : TypeConverter
+  new()
+  static From(Int64) : ParityLong
+  static MaxValue : ParityLong
+  static MinValue : ParityLong
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : ParityLong
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : ParityLong
+  static Parse(String, IFormatProvider) : ParityLong
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out ParityLong) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out ParityLong) : Boolean
+  static TryParse(String, IFormatProvider, out ParityLong) : Boolean
+  static op_Equality(ParityLong, ParityLong) : Boolean
+  static op_GreaterThan(ParityLong, ParityLong) : Boolean
+  static op_GreaterThanOrEqual(ParityLong, ParityLong) : Boolean
+  static op_Inequality(ParityLong, ParityLong) : Boolean
+  static op_LessThan(ParityLong, ParityLong) : Boolean
+  static op_LessThanOrEqual(ParityLong, ParityLong) : Boolean
+  extension static ParityLongExtensions.GetValue(ParityLong) : Int64
+  extension static ParityLongExtensions.ValueOrNull(ParityLong?) : Int64?
+ParitySByte
+  CompareTo(Object) : Int32
+  CompareTo(ParitySByte) : Int32
+  Equals(Object) : Boolean
+  Equals(ParitySByte) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : SByte
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<ParitySByte, SByte>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<ParitySByte>
+  implements IComparisonOperators<ParitySByte, ParitySByte, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<ParitySByte, ParitySByte, Boolean>
+  implements IEquatable<ParitySByte>
+  implements IFormattable
+  implements IMinMaxValue<ParitySByte>
+  implements IParsable<ParitySByte>
+  implements IPlainValueObject<ParitySByte, SByte>
+  implements ISpanFormattable
+  implements ISpanParsable<ParitySByte>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<ParitySByte>
+  implements IValue<SByte>
+  implements IValueObject<ParitySByte, SByte>
+  implements IValueObjectMaterializer<ParitySByte, SByte>
+  nested ParitySByteJsonConverter : JsonConverter<ParitySByte>, IStoredJsonConverterSource
+  nested ParitySByteTypeConverter : TypeConverter
+  new()
+  static From(SByte) : ParitySByte
+  static MaxValue : ParitySByte
+  static MinValue : ParitySByte
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : ParitySByte
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : ParitySByte
+  static Parse(String, IFormatProvider) : ParitySByte
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out ParitySByte) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out ParitySByte) : Boolean
+  static TryParse(String, IFormatProvider, out ParitySByte) : Boolean
+  static op_Equality(ParitySByte, ParitySByte) : Boolean
+  static op_GreaterThan(ParitySByte, ParitySByte) : Boolean
+  static op_GreaterThanOrEqual(ParitySByte, ParitySByte) : Boolean
+  static op_Inequality(ParitySByte, ParitySByte) : Boolean
+  static op_LessThan(ParitySByte, ParitySByte) : Boolean
+  static op_LessThanOrEqual(ParitySByte, ParitySByte) : Boolean
+  extension static ParitySByteExtensions.GetValue(ParitySByte) : SByte
+  extension static ParitySByteExtensions.ValueOrNull(ParitySByte?) : SByte?
+ParityShort
+  CompareTo(Object) : Int32
+  CompareTo(ParityShort) : Int32
+  Equals(Object) : Boolean
+  Equals(ParityShort) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Int16
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<ParityShort, Int16>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<ParityShort>
+  implements IComparisonOperators<ParityShort, ParityShort, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<ParityShort, ParityShort, Boolean>
+  implements IEquatable<ParityShort>
+  implements IFormattable
+  implements IMinMaxValue<ParityShort>
+  implements IParsable<ParityShort>
+  implements IPlainValueObject<ParityShort, Int16>
+  implements ISpanFormattable
+  implements ISpanParsable<ParityShort>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<ParityShort>
+  implements IValue<Int16>
+  implements IValueObject<ParityShort, Int16>
+  implements IValueObjectMaterializer<ParityShort, Int16>
+  nested ParityShortJsonConverter : JsonConverter<ParityShort>, IStoredJsonConverterSource
+  nested ParityShortTypeConverter : TypeConverter
+  new()
+  static From(Int16) : ParityShort
+  static MaxValue : ParityShort
+  static MinValue : ParityShort
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : ParityShort
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : ParityShort
+  static Parse(String, IFormatProvider) : ParityShort
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out ParityShort) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out ParityShort) : Boolean
+  static TryParse(String, IFormatProvider, out ParityShort) : Boolean
+  static op_Equality(ParityShort, ParityShort) : Boolean
+  static op_GreaterThan(ParityShort, ParityShort) : Boolean
+  static op_GreaterThanOrEqual(ParityShort, ParityShort) : Boolean
+  static op_Inequality(ParityShort, ParityShort) : Boolean
+  static op_LessThan(ParityShort, ParityShort) : Boolean
+  static op_LessThanOrEqual(ParityShort, ParityShort) : Boolean
+  extension static ParityShortExtensions.GetValue(ParityShort) : Int16
+  extension static ParityShortExtensions.ValueOrNull(ParityShort?) : Int16?
+ParityUInt
+  CompareTo(Object) : Int32
+  CompareTo(ParityUInt) : Int32
+  Equals(Object) : Boolean
+  Equals(ParityUInt) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : UInt32
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<ParityUInt, UInt32>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<ParityUInt>
+  implements IComparisonOperators<ParityUInt, ParityUInt, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<ParityUInt, ParityUInt, Boolean>
+  implements IEquatable<ParityUInt>
+  implements IFormattable
+  implements IMinMaxValue<ParityUInt>
+  implements IParsable<ParityUInt>
+  implements IPlainValueObject<ParityUInt, UInt32>
+  implements ISpanFormattable
+  implements ISpanParsable<ParityUInt>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<ParityUInt>
+  implements IValue<UInt32>
+  implements IValueObject<ParityUInt, UInt32>
+  implements IValueObjectMaterializer<ParityUInt, UInt32>
+  nested ParityUIntJsonConverter : JsonConverter<ParityUInt>, IStoredJsonConverterSource
+  nested ParityUIntTypeConverter : TypeConverter
+  new()
+  static From(UInt32) : ParityUInt
+  static MaxValue : ParityUInt
+  static MinValue : ParityUInt
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : ParityUInt
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : ParityUInt
+  static Parse(String, IFormatProvider) : ParityUInt
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out ParityUInt) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out ParityUInt) : Boolean
+  static TryParse(String, IFormatProvider, out ParityUInt) : Boolean
+  static op_Equality(ParityUInt, ParityUInt) : Boolean
+  static op_GreaterThan(ParityUInt, ParityUInt) : Boolean
+  static op_GreaterThanOrEqual(ParityUInt, ParityUInt) : Boolean
+  static op_Inequality(ParityUInt, ParityUInt) : Boolean
+  static op_LessThan(ParityUInt, ParityUInt) : Boolean
+  static op_LessThanOrEqual(ParityUInt, ParityUInt) : Boolean
+  extension static ParityUIntExtensions.GetValue(ParityUInt) : UInt32
+  extension static ParityUIntExtensions.ValueOrNull(ParityUInt?) : UInt32?
+ParityUInt128
+  CompareTo(Object) : Int32
+  CompareTo(ParityUInt128) : Int32
+  Equals(Object) : Boolean
+  Equals(ParityUInt128) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : UInt128
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<ParityUInt128, UInt128>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<ParityUInt128>
+  implements IComparisonOperators<ParityUInt128, ParityUInt128, Boolean>
+  implements IEqualityOperators<ParityUInt128, ParityUInt128, Boolean>
+  implements IEquatable<ParityUInt128>
+  implements IFormattable
+  implements IMinMaxValue<ParityUInt128>
+  implements IParsable<ParityUInt128>
+  implements IPlainValueObject<ParityUInt128, UInt128>
+  implements ISpanFormattable
+  implements ISpanParsable<ParityUInt128>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<ParityUInt128>
+  implements IValue<UInt128>
+  implements IValueObject<ParityUInt128, UInt128>
+  implements IValueObjectMaterializer<ParityUInt128, UInt128>
+  nested ParityUInt128JsonConverter : JsonConverter<ParityUInt128>, IStoredJsonConverterSource
+  nested ParityUInt128TypeConverter : TypeConverter
+  new()
+  static From(UInt128) : ParityUInt128
+  static MaxValue : ParityUInt128
+  static MinValue : ParityUInt128
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : ParityUInt128
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : ParityUInt128
+  static Parse(String, IFormatProvider) : ParityUInt128
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out ParityUInt128) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out ParityUInt128) : Boolean
+  static TryParse(String, IFormatProvider, out ParityUInt128) : Boolean
+  static op_Equality(ParityUInt128, ParityUInt128) : Boolean
+  static op_GreaterThan(ParityUInt128, ParityUInt128) : Boolean
+  static op_GreaterThanOrEqual(ParityUInt128, ParityUInt128) : Boolean
+  static op_Inequality(ParityUInt128, ParityUInt128) : Boolean
+  static op_LessThan(ParityUInt128, ParityUInt128) : Boolean
+  static op_LessThanOrEqual(ParityUInt128, ParityUInt128) : Boolean
+  extension static ParityUInt128Extensions.GetValue(ParityUInt128) : UInt128
+  extension static ParityUInt128Extensions.ValueOrNull(ParityUInt128?) : UInt128?
+ParityULong
+  CompareTo(Object) : Int32
+  CompareTo(ParityULong) : Int32
+  Equals(Object) : Boolean
+  Equals(ParityULong) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : UInt64
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<ParityULong, UInt64>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<ParityULong>
+  implements IComparisonOperators<ParityULong, ParityULong, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<ParityULong, ParityULong, Boolean>
+  implements IEquatable<ParityULong>
+  implements IFormattable
+  implements IMinMaxValue<ParityULong>
+  implements IParsable<ParityULong>
+  implements IPlainValueObject<ParityULong, UInt64>
+  implements ISpanFormattable
+  implements ISpanParsable<ParityULong>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<ParityULong>
+  implements IValue<UInt64>
+  implements IValueObject<ParityULong, UInt64>
+  implements IValueObjectMaterializer<ParityULong, UInt64>
+  nested ParityULongJsonConverter : JsonConverter<ParityULong>, IStoredJsonConverterSource
+  nested ParityULongTypeConverter : TypeConverter
+  new()
+  static From(UInt64) : ParityULong
+  static MaxValue : ParityULong
+  static MinValue : ParityULong
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : ParityULong
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : ParityULong
+  static Parse(String, IFormatProvider) : ParityULong
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out ParityULong) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out ParityULong) : Boolean
+  static TryParse(String, IFormatProvider, out ParityULong) : Boolean
+  static op_Equality(ParityULong, ParityULong) : Boolean
+  static op_GreaterThan(ParityULong, ParityULong) : Boolean
+  static op_GreaterThanOrEqual(ParityULong, ParityULong) : Boolean
+  static op_Inequality(ParityULong, ParityULong) : Boolean
+  static op_LessThan(ParityULong, ParityULong) : Boolean
+  static op_LessThanOrEqual(ParityULong, ParityULong) : Boolean
+  extension static ParityULongExtensions.GetValue(ParityULong) : UInt64
+  extension static ParityULongExtensions.ValueOrNull(ParityULong?) : UInt64?
+ParityUShort
+  CompareTo(Object) : Int32
+  CompareTo(ParityUShort) : Int32
+  Equals(Object) : Boolean
+  Equals(ParityUShort) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : UInt16
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<ParityUShort, UInt16>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<ParityUShort>
+  implements IComparisonOperators<ParityUShort, ParityUShort, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<ParityUShort, ParityUShort, Boolean>
+  implements IEquatable<ParityUShort>
+  implements IFormattable
+  implements IMinMaxValue<ParityUShort>
+  implements IParsable<ParityUShort>
+  implements IPlainValueObject<ParityUShort, UInt16>
+  implements ISpanFormattable
+  implements ISpanParsable<ParityUShort>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<ParityUShort>
+  implements IValue<UInt16>
+  implements IValueObject<ParityUShort, UInt16>
+  implements IValueObjectMaterializer<ParityUShort, UInt16>
+  nested ParityUShortJsonConverter : JsonConverter<ParityUShort>, IStoredJsonConverterSource
+  nested ParityUShortTypeConverter : TypeConverter
+  new()
+  static From(UInt16) : ParityUShort
+  static MaxValue : ParityUShort
+  static MinValue : ParityUShort
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : ParityUShort
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : ParityUShort
+  static Parse(String, IFormatProvider) : ParityUShort
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out ParityUShort) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out ParityUShort) : Boolean
+  static TryParse(String, IFormatProvider, out ParityUShort) : Boolean
+  static op_Equality(ParityUShort, ParityUShort) : Boolean
+  static op_GreaterThan(ParityUShort, ParityUShort) : Boolean
+  static op_GreaterThanOrEqual(ParityUShort, ParityUShort) : Boolean
+  static op_Inequality(ParityUShort, ParityUShort) : Boolean
+  static op_LessThan(ParityUShort, ParityUShort) : Boolean
+  static op_LessThanOrEqual(ParityUShort, ParityUShort) : Boolean
+  extension static ParityUShortExtensions.GetValue(ParityUShort) : UInt16
+  extension static ParityUShortExtensions.ValueOrNull(ParityUShort?) : UInt16?
+ShippableStatus
+  Equals(Object) : Boolean
+  Equals(ShippableStatus) : Boolean
+  GetHashCode() : Int32
+  Revalidate() : Result<ShippableStatus, ShippableFault>
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : LocalStatus
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<ShippableStatus, LocalStatus>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IEqualityOperators<ShippableStatus, ShippableStatus, Boolean>
+  implements IEquatable<ShippableStatus>
+  implements IFormattable
+  implements IParsable<ShippableStatus>
+  implements IValidatedValue<ShippableStatus, LocalStatus, ShippableFault>
+  implements IValueObject<ShippableStatus, LocalStatus>
+  implements IValueObjectMaterializer<ShippableStatus, LocalStatus>
+  nested ShippableStatusJsonConverter : JsonConverter<ShippableStatus>, IStoredJsonConverterSource
+  nested ShippableStatusTypeConverter : TypeConverter
+  new()
+  static Create(LocalStatus) : Result<ShippableStatus, ShippableFault>
+  static FromKnownGood(LocalStatus, String) : ShippableStatus
+  static Parse(String, IFormatProvider) : ShippableStatus
+  static TryFrom(LocalStatus) : Option<ShippableStatus>
+  static TryParse(String, IFormatProvider, out ShippableStatus) : Boolean
+  static op_Equality(ShippableStatus, ShippableStatus) : Boolean
+  static op_Inequality(ShippableStatus, ShippableStatus) : Boolean
+  extension static ShippableStatusExtensions.GetValue(ShippableStatus) : LocalStatus
+  extension static ShippableStatusExtensions.ValueOrNull(ShippableStatus?) : LocalStatus
+StageOfOrder
+  Equals(Object) : Boolean
+  Equals(StageOfOrder) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : LocalOrder.Stage
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<StageOfOrder, LocalOrder.Stage>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IEqualityOperators<StageOfOrder, StageOfOrder, Boolean>
+  implements IEquatable<StageOfOrder>
+  implements IFormattable
+  implements IParsable<StageOfOrder>
+  implements IPlainValueObject<StageOfOrder, LocalOrder.Stage>
+  implements IValue<LocalOrder.Stage>
+  implements IValueObject<StageOfOrder, LocalOrder.Stage>
+  implements IValueObjectMaterializer<StageOfOrder, LocalOrder.Stage>
+  nested StageOfOrderJsonConverter : JsonConverter<StageOfOrder>, IStoredJsonConverterSource
+  nested StageOfOrderTypeConverter : TypeConverter
+  new()
+  static From(LocalOrder.Stage) : StageOfOrder
+  static Parse(String, IFormatProvider) : StageOfOrder
+  static TryParse(String, IFormatProvider, out StageOfOrder) : Boolean
+  static op_Equality(StageOfOrder, StageOfOrder) : Boolean
+  static op_Inequality(StageOfOrder, StageOfOrder) : Boolean
+  extension static StageOfOrderExtensions.GetValue(StageOfOrder) : LocalOrder.Stage
+  extension static StageOfOrderExtensions.ValueOrNull(StageOfOrder?) : LocalOrder.Stage
+StatusLabel
+  <Clone>$() : StatusLabel
+  Equals(Object) : Boolean
+  Equals(StatusLabel) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : LocalStatus
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<StatusLabel, LocalStatus>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IEqualityOperators<StatusLabel, StatusLabel, Boolean>
+  implements IEquatable<StatusLabel>
+  implements IFormattable
+  implements IParsable<StatusLabel>
+  implements IPlainValueObject<StatusLabel, LocalStatus>
+  implements IValue<LocalStatus>
+  implements IValueObject<StatusLabel, LocalStatus>
+  implements IValueObjectMaterializer<StatusLabel, LocalStatus>
+  nested StatusLabelJsonConverter : JsonConverter<StatusLabel>, IStoredJsonConverterSource
+  nested StatusLabelTypeConverter : TypeConverter
+  static From(LocalStatus) : StatusLabel
+  static Parse(String, IFormatProvider) : StatusLabel
+  static TryParse(String, IFormatProvider, out StatusLabel) : Boolean
+  static op_Equality(StatusLabel, StatusLabel) : Boolean
+  static op_Inequality(StatusLabel, StatusLabel) : Boolean
+  extension static StatusLabelExtensions.GetValue(StatusLabel) : LocalStatus
+  extension static StatusLabelExtensions.ValueOrNull(StatusLabel) : LocalStatus
+StatusOfOrder
+  Equals(Object) : Boolean
+  Equals(StatusOfOrder) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : LocalStatus
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<StatusOfOrder, LocalStatus>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IEqualityOperators<StatusOfOrder, StatusOfOrder, Boolean>
+  implements IEquatable<StatusOfOrder>
+  implements IFormattable
+  implements IParsable<StatusOfOrder>
+  implements IPlainValueObject<StatusOfOrder, LocalStatus>
+  implements IValue<LocalStatus>
+  implements IValueObject<StatusOfOrder, LocalStatus>
+  implements IValueObjectMaterializer<StatusOfOrder, LocalStatus>
+  nested StatusOfOrderJsonConverter : JsonConverter<StatusOfOrder>, IStoredJsonConverterSource
+  nested StatusOfOrderTypeConverter : TypeConverter
+  new()
+  static From(LocalStatus) : StatusOfOrder
+  static Parse(String, IFormatProvider) : StatusOfOrder
+  static TryParse(String, IFormatProvider, out StatusOfOrder) : Boolean
+  static op_Equality(StatusOfOrder, StatusOfOrder) : Boolean
+  static op_Inequality(StatusOfOrder, StatusOfOrder) : Boolean
+  extension static StatusOfOrderExtensions.GetValue(StatusOfOrder) : LocalStatus
+  extension static StatusOfOrderExtensions.ValueOrNull(StatusOfOrder?) : LocalStatus
+TestForeignIdentifier
+  CompareTo(Object) : Int32
+  CompareTo(TestForeignIdentifier) : Int32
+  Equals(Object) : Boolean
+  Equals(TestForeignIdentifier) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Guid
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<TestForeignIdentifier, Guid>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<TestForeignIdentifier>
+  implements IComparisonOperators<TestForeignIdentifier, TestForeignIdentifier, Boolean>
+  implements IEqualityOperators<TestForeignIdentifier, TestForeignIdentifier, Boolean>
+  implements IEquatable<TestForeignIdentifier>
+  implements IFormattable
+  implements IParsable<TestForeignIdentifier>
+  implements IPlainValueObject<TestForeignIdentifier, Guid>
+  implements IProbeIdentifier
+  implements ISpanFormattable
+  implements ISpanParsable<TestForeignIdentifier>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<TestForeignIdentifier>
+  implements IValue<Guid>
+  implements IValueObject<TestForeignIdentifier, Guid>
+  implements IValueObjectMaterializer<TestForeignIdentifier, Guid>
+  nested TestForeignIdentifierJsonConverter : JsonConverter<TestForeignIdentifier>, IStoredJsonConverterSource
+  nested TestForeignIdentifierTypeConverter : TypeConverter
+  new()
+  static From(Guid) : TestForeignIdentifier
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : TestForeignIdentifier
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : TestForeignIdentifier
+  static Parse(String, IFormatProvider) : TestForeignIdentifier
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out TestForeignIdentifier) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out TestForeignIdentifier) : Boolean
+  static TryParse(String, IFormatProvider, out TestForeignIdentifier) : Boolean
+  static op_Equality(TestForeignIdentifier, TestForeignIdentifier) : Boolean
+  static op_GreaterThan(TestForeignIdentifier, TestForeignIdentifier) : Boolean
+  static op_GreaterThanOrEqual(TestForeignIdentifier, TestForeignIdentifier) : Boolean
+  static op_Inequality(TestForeignIdentifier, TestForeignIdentifier) : Boolean
+  static op_LessThan(TestForeignIdentifier, TestForeignIdentifier) : Boolean
+  static op_LessThanOrEqual(TestForeignIdentifier, TestForeignIdentifier) : Boolean
+  extension static TestForeignIdentifierExtensions.GetValue(TestForeignIdentifier) : Guid
+  extension static TestForeignIdentifierExtensions.ValueOrNull(TestForeignIdentifier?) : Guid?
+TestLocalId
+  CompareTo(Object) : Int32
+  CompareTo(TestLocalId) : Int32
+  Equals(Object) : Boolean
+  Equals(TestLocalId) : Boolean
+  GetHashCode() : Int32
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Int32
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<TestLocalId, Int32>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<TestLocalId>
+  implements IComparisonOperators<TestLocalId, TestLocalId, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<TestLocalId, TestLocalId, Boolean>
+  implements IEquatable<TestLocalId>
+  implements IFormattable
+  implements IMinMaxValue<TestLocalId>
+  implements IParsable<TestLocalId>
+  implements IPlainValueObject<TestLocalId, Int32>
+  implements ISpanFormattable
+  implements ISpanParsable<TestLocalId>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<TestLocalId>
+  implements IValue<Int32>
+  implements IValueObject<TestLocalId, Int32>
+  implements IValueObjectMaterializer<TestLocalId, Int32>
+  nested TestLocalIdJsonConverter : JsonConverter<TestLocalId>, IStoredJsonConverterSource
+  nested TestLocalIdTypeConverter : TypeConverter
+  new()
+  static From(Int32) : TestLocalId
+  static MaxValue : TestLocalId
+  static MinValue : TestLocalId
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : TestLocalId
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : TestLocalId
+  static Parse(String, IFormatProvider) : TestLocalId
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out TestLocalId) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out TestLocalId) : Boolean
+  static TryParse(String, IFormatProvider, out TestLocalId) : Boolean
+  static op_Equality(TestLocalId, TestLocalId) : Boolean
+  static op_GreaterThan(TestLocalId, TestLocalId) : Boolean
+  static op_GreaterThanOrEqual(TestLocalId, TestLocalId) : Boolean
+  static op_Inequality(TestLocalId, TestLocalId) : Boolean
+  static op_LessThan(TestLocalId, TestLocalId) : Boolean
+  static op_LessThanOrEqual(TestLocalId, TestLocalId) : Boolean
+  extension static TestLocalIdExtensions.GetValue(TestLocalId) : Int32
+  extension static TestLocalIdExtensions.ValueOrNull(TestLocalId?) : Int32?
+ThrowingCount
+  CompareTo(Object) : Int32
+  CompareTo(ThrowingCount) : Int32
+  Equals(Object) : Boolean
+  Equals(ThrowingCount) : Boolean
+  GetHashCode() : Int32
+  Revalidate() : Result<ThrowingCount, ThrowingFault>
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  TryFormat(Span<Byte>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  TryFormat(Span<Char>, out Int32, ReadOnlySpan<Char>, IFormatProvider) : Boolean
+  Value : Int32
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<ThrowingCount, Int32>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<ThrowingCount>
+  implements IComparisonOperators<ThrowingCount, ThrowingCount, Boolean>
+  implements IConvertible
+  implements IEqualityOperators<ThrowingCount, ThrowingCount, Boolean>
+  implements IEquatable<ThrowingCount>
+  implements IFormattable
+  implements IParsable<ThrowingCount>
+  implements ISpanFormattable
+  implements ISpanParsable<ThrowingCount>
+  implements IUtf8SpanFormattable
+  implements IUtf8SpanParsable<ThrowingCount>
+  implements IValidatedValue<ThrowingCount, Int32, ThrowingFault>
+  implements IValueObject<ThrowingCount, Int32>
+  implements IValueObjectMaterializer<ThrowingCount, Int32>
+  nested ThrowingCountJsonConverter : JsonConverter<ThrowingCount>, IStoredJsonConverterSource
+  nested ThrowingCountTypeConverter : TypeConverter
+  new()
+  static Create(Int32) : Result<ThrowingCount, ThrowingFault>
+  static FromKnownGood(Int32, String) : ThrowingCount
+  static Parse(ReadOnlySpan<Byte>, IFormatProvider) : ThrowingCount
+  static Parse(ReadOnlySpan<Char>, IFormatProvider) : ThrowingCount
+  static Parse(String, IFormatProvider) : ThrowingCount
+  static TryFrom(Int32) : Option<ThrowingCount>
+  static TryParse(ReadOnlySpan<Byte>, IFormatProvider, out ThrowingCount) : Boolean
+  static TryParse(ReadOnlySpan<Char>, IFormatProvider, out ThrowingCount) : Boolean
+  static TryParse(String, IFormatProvider, out ThrowingCount) : Boolean
+  static op_Equality(ThrowingCount, ThrowingCount) : Boolean
+  static op_GreaterThan(ThrowingCount, ThrowingCount) : Boolean
+  static op_GreaterThanOrEqual(ThrowingCount, ThrowingCount) : Boolean
+  static op_Inequality(ThrowingCount, ThrowingCount) : Boolean
+  static op_LessThan(ThrowingCount, ThrowingCount) : Boolean
+  static op_LessThanOrEqual(ThrowingCount, ThrowingCount) : Boolean
+  extension static ThrowingCountExtensions.GetValue(ThrowingCount) : Int32
+  extension static ThrowingCountExtensions.ValueOrNull(ThrowingCount?) : Int32?
+ThrowingDate
+  CompareTo(Object) : Int32
+  CompareTo(ThrowingDate) : Int32
+  Equals(Object) : Boolean
+  Equals(ThrowingDate) : Boolean
+  GetHashCode() : Int32
+  Revalidate() : Result<ThrowingDate, ThrowingFault>
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : LocalDate
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<ThrowingDate, LocalDate>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IComparable
+  implements IComparable<ThrowingDate>
+  implements IComparisonOperators<ThrowingDate, ThrowingDate, Boolean>
+  implements IEqualityOperators<ThrowingDate, ThrowingDate, Boolean>
+  implements IEquatable<ThrowingDate>
+  implements IFormattable
+  implements IParsable<ThrowingDate>
+  implements IValidatedValue<ThrowingDate, LocalDate, ThrowingFault>
+  implements IValueObject<ThrowingDate, LocalDate>
+  implements IValueObjectMaterializer<ThrowingDate, LocalDate>
+  nested ThrowingDateJsonConverter : JsonConverter<ThrowingDate>, IStoredJsonConverterSource
+  nested ThrowingDateTypeConverter : TypeConverter
+  new()
+  static Create(LocalDate) : Result<ThrowingDate, ThrowingFault>
+  static FromKnownGood(LocalDate, String) : ThrowingDate
+  static Parse(String, IFormatProvider) : ThrowingDate
+  static TryFrom(LocalDate) : Option<ThrowingDate>
+  static TryParse(String, IFormatProvider, out ThrowingDate) : Boolean
+  static op_Equality(ThrowingDate, ThrowingDate) : Boolean
+  static op_GreaterThan(ThrowingDate, ThrowingDate) : Boolean
+  static op_GreaterThanOrEqual(ThrowingDate, ThrowingDate) : Boolean
+  static op_Inequality(ThrowingDate, ThrowingDate) : Boolean
+  static op_LessThan(ThrowingDate, ThrowingDate) : Boolean
+  static op_LessThanOrEqual(ThrowingDate, ThrowingDate) : Boolean
+  extension static ThrowingDateExtensions.GetValue(ThrowingDate) : LocalDate
+  extension static ThrowingDateExtensions.ValueOrNull(ThrowingDate?) : LocalDate?
+ThrowingIsbn
+  Equals(Object) : Boolean
+  Equals(ThrowingIsbn) : Boolean
+  GetHashCode() : Int32
+  Revalidate() : Result<ThrowingIsbn, ThrowingFault>
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : ProbeIsbnText
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<ThrowingIsbn, ProbeIsbnText>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IEqualityOperators<ThrowingIsbn, ThrowingIsbn, Boolean>
+  implements IEquatable<ThrowingIsbn>
+  implements IFormattable
+  implements IParsable<ThrowingIsbn>
+  implements IValidatedValue<ThrowingIsbn, ProbeIsbnText, ThrowingFault>
+  implements IValueObject<ThrowingIsbn, ProbeIsbnText>
+  implements IValueObjectMaterializer<ThrowingIsbn, ProbeIsbnText>
+  nested ThrowingIsbnJsonConverter : JsonConverter<ThrowingIsbn>, IStoredJsonConverterSource
+  nested ThrowingIsbnTypeConverter : TypeConverter
+  new()
+  static Create(ProbeIsbnText) : Result<ThrowingIsbn, ThrowingFault>
+  static FromKnownGood(ProbeIsbnText, String) : ThrowingIsbn
+  static Parse(String, IFormatProvider) : ThrowingIsbn
+  static TryFrom(ProbeIsbnText) : Option<ThrowingIsbn>
+  static TryParse(String, IFormatProvider, out ThrowingIsbn) : Boolean
+  static op_Equality(ThrowingIsbn, ThrowingIsbn) : Boolean
+  static op_Inequality(ThrowingIsbn, ThrowingIsbn) : Boolean
+  extension static ThrowingIsbnExtensions.GetValue(ThrowingIsbn) : ProbeIsbnText
+  extension static ThrowingIsbnExtensions.ValueOrNull(ThrowingIsbn?) : ProbeIsbnText
+ThrowingSku
+  Equals(Object) : Boolean
+  Equals(ThrowingSku) : Boolean
+  GetHashCode() : Int32
+  Revalidate() : Result<ThrowingSku, ThrowingFault>
+  ToString() : String
+  ToString(String, IFormatProvider) : String
+  Value : ProbeSkuText
+  attribute CompilerGeneratedAttribute
+  attribute GeneratedValueObjectAttribute<ThrowingSku, ProbeSkuText>
+  attribute JsonConverterAttribute
+  attribute TypeConverterAttribute
+  implements IEqualityOperators<ThrowingSku, ThrowingSku, Boolean>
+  implements IEquatable<ThrowingSku>
+  implements IFormattable
+  implements IParsable<ThrowingSku>
+  implements IValidatedValue<ThrowingSku, ProbeSkuText, ThrowingFault>
+  implements IValueObject<ThrowingSku, ProbeSkuText>
+  implements IValueObjectMaterializer<ThrowingSku, ProbeSkuText>
+  nested ThrowingSkuJsonConverter : JsonConverter<ThrowingSku>, IStoredJsonConverterSource
+  nested ThrowingSkuTypeConverter : TypeConverter
+  new()
+  static Create(ProbeSkuText) : Result<ThrowingSku, ThrowingFault>
+  static FromKnownGood(ProbeSkuText, String) : ThrowingSku
+  static Parse(String, IFormatProvider) : ThrowingSku
+  static TryFrom(ProbeSkuText) : Option<ThrowingSku>
+  static TryParse(String, IFormatProvider, out ThrowingSku) : Boolean
+  static op_Equality(ThrowingSku, ThrowingSku) : Boolean
+  static op_Inequality(ThrowingSku, ThrowingSku) : Boolean
+  extension static ThrowingSkuExtensions.GetValue(ThrowingSku) : ProbeSkuText
+  extension static ThrowingSkuExtensions.ValueOrNull(ThrowingSku?) : ProbeSkuText
diff --git a/test/CodoMetis.TypeKit.Generators.Tests/GeneratedSurfaceTests.cs b/test/CodoMetis.TypeKit.Generators.Tests/GeneratedSurfaceTests.cs
index cc39a700..391ccc88 100644
--- a/test/CodoMetis.TypeKit.Generators.Tests/GeneratedSurfaceTests.cs
+++ b/test/CodoMetis.TypeKit.Generators.Tests/GeneratedSurfaceTests.cs
@@ -7,13 +7,17 @@
 namespace CodoMetis.TypeKit.Generators.Tests;
 
 /// <summary>
-/// The public surface the generators give each probe, compared with <c>GeneratedSurface.verified.txt</c>.
+/// The public surface the generators give each probe, and each value object these tests declare for
+/// themselves, compared with <c>GeneratedSurface.verified.txt</c>.
 /// </summary>
 /// <remarks>
 /// <para>
 /// The behaviour tests check what they know to look for. This catches the rest: an aspect change
 /// that adds, drops or renames a member, an interface or an attribute shows up as a diff in review
-/// instead of shipping unnoticed.
+/// instead of shipping unnoticed. The tests' own value objects are in it because the shapes a fix was
+/// found for live there: 2.1.0's prerelease stopped generating <c>Parse</c> for a wrapped <c>Parse</c>
+/// whose result converts implicitly (<c>OverParsedShape</c>), which ApiCompat, seeing only the packages'
+/// own surface, let through.
 /// </para>
 /// <para>
 /// On a mismatch the actual surface is written next to the snapshot as
@@ -29,7 +33,7 @@ public sealed class GeneratedSurfaceTests
     public void The_generated_surface_matches_the_snapshot()
     {
         var directory = Path.Combine(RepositoryRoot(), "test", "CodoMetis.TypeKit.Generators.Tests");
-        var actual    = Render(typeof(ProbeId).Assembly);
+        var actual    = Render(typeof(ProbeId).Assembly, 19) + Render(typeof(GeneratedSurfaceTests).Assembly, 70);
         var expected  = File.Exists(Path.Combine(directory, Verified)) ? File.ReadAllText(Path.Combine(directory, Verified)) : "";
 
         if (actual == expected.ReplaceLineEndings("\n"))
@@ -42,16 +46,16 @@ public void The_generated_surface_matches_the_snapshot()
         actual.ShouldBe(expected, $"The generated surface changed. Review {Received} and, if the change is intended, replace {Verified} with it.");
     }
 
-    private static string Render(Assembly assembly)
+    private static string Render(Assembly assembly, int floor)
     {
         var valueObjects = assembly.GetTypes()
                                    .Where(type => type.GetInterfaces().Any(i => i.IsGenericType && (i.GetGenericTypeDefinition() == typeof(IValueObject<,>) || i.GetGenericTypeDefinition() == typeof(CodoMetis.TypeKit.ClosedSets.IClosedSet<>))))
                                    .OrderBy(type => type.FullName, StringComparer.Ordinal)
                                    .ToList();
 
-        valueObjects.Count.ShouldBeGreaterThanOrEqualTo(19);
+        valueObjects.Count.ShouldBeGreaterThanOrEqualTo(floor, assembly.GetName().Name);
 
-        var text = new StringBuilder();
+        var text = new StringBuilder().Append("# ").Append(assembly.GetName().Name).Append('\n');
 
         foreach (var type in valueObjects)
         {
diff --git a/test/CodoMetis.TypeKit.Generators.Tests/SourceGeneratedJsonTests.cs b/test/CodoMetis.TypeKit.Generators.Tests/SourceGeneratedJsonTests.cs
index 59edb06e..728d2ce8 100644
--- a/test/CodoMetis.TypeKit.Generators.Tests/SourceGeneratedJsonTests.cs
+++ b/test/CodoMetis.TypeKit.Generators.Tests/SourceGeneratedJsonTests.cs
@@ -131,8 +131,33 @@ public void A_converter_on_the_options_comes_before_the_wrapped_type_s_own()
     public void Stored_JSON_is_read_without_the_rules() =>
         JsonSerializer.Deserialize<ProbePercentage>("101", new JsonSerializerOptions(ContextOnly) { Converters = { new StoredJsonConverterFactory() } })
                       .Value.ShouldBe(101);
+
+    /// <summary>
+    /// The merge-patches page: a source-generated context never sees through a patch, and a value object inside one
+    /// is read with its own converter, so it keeps its rule where neither it nor its wrapped type is listed.
+    /// </summary>
+    [Fact]
+    public void A_value_object_inside_a_patch_is_read_with_its_own_converter()
+    {
+        var options = new JsonSerializerOptions { TypeInfoResolver = PatchesOnly.Default };
+        PatchesOnly.Default.GetTypeInfo(typeof(ProbeCode)).ShouldBeNull("the control: the context never saw the value object");
+
+        var read = JsonSerializer.Deserialize<CodePatch>("""{"Code":"ABC","Amount":1.5}""", options).ShouldNotBeNull();
+        read.Code.Match(code => code.Value, () => "cleared", () => "absent").ShouldBe("ABC");
+        read.Amount.Match(amount => amount.Value, () => -1m, () => -2m).ShouldBe(1.5m);
+
+        var refusal = Should.Throw<JsonException>(() => JsonSerializer.Deserialize<CodePatch>("""{"Code":"lower"}""", options));
+        refusal.Path.ShouldBe("$.Code");
+        refusal.Message.ShouldContain(nameof(ProbeCodeFault.NotUpperCase));
+        refusal.Message.ShouldNotContain("lower");
+    }
 }
 
+public sealed record CodePatch(Patch<ProbeCode> Code, Patch<ProbeAmount> Amount);
+
+[JsonSerializable(typeof(CodePatch))]
+internal sealed partial class PatchesOnly : JsonSerializerContext;
+
 /// <summary>A wrapped type with a converter of its own, which writes it in lower case.</summary>
 [JsonConverter(typeof(CodeAsLowerConverter))]
 public readonly struct Code(string text)
diff --git a/test/CodoMetis.TypeKit.Generators.Tests/SpanParsingTests.cs b/test/CodoMetis.TypeKit.Generators.Tests/SpanParsingTests.cs
index f966ae2d..cc8146b9 100644
--- a/test/CodoMetis.TypeKit.Generators.Tests/SpanParsingTests.cs
+++ b/test/CodoMetis.TypeKit.Generators.Tests/SpanParsingTests.cs
@@ -30,7 +30,7 @@ public enum ProbeAccess
 /// <summary>
 /// Span and UTF-8 parsing are generated exactly where the wrapped type has them, and read and refuse
 /// what <c>Parse(string)</c> reads and refuses, one row per wrapped type of the shape catalogue
-/// (<c>shape.wrapped</c> in <c>.claude/probe-axes.md</c>) and per parse strategy.
+/// (the wrapped types of the generation shapes, <c>test/oracles/axes.md</c>) and per parse strategy.
 /// </summary>
 /// <remarks>
 /// A value object over <see cref="string"/> got no <c>ISpanParsable</c>, although <see cref="string"/>
diff --git a/test/CodoMetis.TypeKit.Oracles.Tests/ApiSurface.cs b/test/CodoMetis.TypeKit.Oracles.Tests/ApiSurface.cs
new file mode 100644
index 00000000..8bb093ae
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Oracles.Tests/ApiSurface.cs
@@ -0,0 +1,87 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Text.RegularExpressions;
+using CodoMetis.TypeKit.AspNetCore;
+using CodoMetis.TypeKit.EntityFrameworkCore;
+using CodoMetis.TypeKit.Testing;
+
+namespace CodoMetis.TypeKit.Oracles.Tests;
+
+/// <summary>
+/// The public surface of the shipping libraries, enumerated by reflection: one key per public member declared on a
+/// public type, <c>TypeName.Member</c>, nested types joined with <c>+</c> and generic arity dropped
+/// (<c>Result.CatchAsync</c>, <c>FaultResponse.WithoutFaultName</c>).
+/// </summary>
+/// <remarks>
+/// <para>
+/// Every key must be named by a claim's <c>surfaces</c> or by a waiver in <c>test/oracles/surface-waivers.json</c>,
+/// so a public member cannot be added without deciding which oracle holds it, or saying why none should.
+/// </para>
+/// <para>
+/// Overloads collapse into one key. The compiler's grouping types of C# 14 <c>extension</c> blocks are skipped, their
+/// members are listed on the static class, as are explicit interface implementations and accessors. The generators
+/// and the analyzers are left out: their public surface is what they generate and the diagnostics they report.
+/// </para>
+/// </remarks>
+internal static class ApiSurface
+{
+    /// <summary>One type per shipping library, so a satellite that is split off is still found.</summary>
+    private static readonly Type[] AssemblyMarkers =
+    [
+        typeof(Option<>),
+        typeof(FaultResponse),
+        typeof(ValueObjectConverter<,>),
+        typeof(global::Serilog.TypeKitSerilogExtensions),
+        typeof(TypeKitAssertionException),
+    ];
+
+    /// <summary>Every public member key, sorted ordinally.</summary>
+    internal static IReadOnlyList<string> Members { get; } = Enumerate();
+
+    /// <summary>Compiles a surface pattern: <c>*</c> matches any run of characters, everything else is literal.</summary>
+    internal static Regex Pattern(string glob) =>
+        new("^" + string.Join(".*", glob.Split('*').Select(Regex.Escape)) + "$", RegexOptions.CultureInvariant);
+
+    /// <summary>The members a pattern names.</summary>
+    internal static IReadOnlyList<string> Matching(string glob)
+    {
+        var pattern = Pattern(glob);
+        return [.. Members.Where(member => pattern.IsMatch(member))];
+    }
+
+    private static List<string> Enumerate()
+    {
+        var keys = new SortedSet<string>(StringComparer.Ordinal);
+
+        foreach (var assembly in AssemblyMarkers.Select(marker => marker.Assembly).Distinct())
+        foreach (var type in assembly.GetExportedTypes())
+        {
+            if (type.Name.Contains('<') || type.GetCustomAttribute<CompilerGeneratedAttribute>() is not null) continue;
+
+            var typeName = Name(type);
+            foreach (var member in type.GetMembers(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly))
+            {
+                switch (member)
+                {
+                    case Type:
+                        continue; // listed as its own type
+                    case MethodInfo { IsSpecialName: true } accessor when !accessor.Name.StartsWith("op_", StringComparison.Ordinal):
+                        continue; // property and event accessors; the property is the member
+                    case MethodInfo { Name: var name } when name.Contains('.') || name.Contains('<'):
+                        continue; // explicit interface implementations and compiler-generated members
+                }
+
+                keys.Add($"{typeName}.{(member is ConstructorInfo ? ".ctor" : member.Name)}");
+            }
+        }
+
+        return [.. keys];
+    }
+
+    private static string Name(Type type)
+    {
+        var tick = type.Name.IndexOf('`', StringComparison.Ordinal);
+        var bare = tick < 0 ? type.Name : type.Name[..tick];
+        return type.DeclaringType is { } outer ? Name(outer) + "+" + bare : bare;
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Oracles.Tests/CodoMetis.TypeKit.Oracles.Tests.csproj b/test/CodoMetis.TypeKit.Oracles.Tests/CodoMetis.TypeKit.Oracles.Tests.csproj
new file mode 100644
index 00000000..d9d8cd6c
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Oracles.Tests/CodoMetis.TypeKit.Oracles.Tests.csproj
@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <!--
+      The oracle kit's tests (design/adr/0112): the claim catalogue, the public surface it must cover, the oracle
+      registry and its seeds, the candidates, and the seed verdict tools/Oracles applies. They reference every
+      shipping library but the generators and the analyzers, whose public surface is diagnostics, not members, so
+      the surface is enumerated by reflection over what a consumer calls.
+    -->
+    <ItemGroup>
+        <ProjectReference Include="..\..\src\CodoMetis.TypeKit\CodoMetis.TypeKit.csproj" />
+        <ProjectReference Include="..\..\src\CodoMetis.TypeKit.AspNetCore\CodoMetis.TypeKit.AspNetCore.csproj" />
+        <ProjectReference Include="..\..\src\CodoMetis.TypeKit.EntityFrameworkCore\CodoMetis.TypeKit.EntityFrameworkCore.csproj" />
+        <ProjectReference Include="..\..\src\CodoMetis.TypeKit.Serilog\CodoMetis.TypeKit.Serilog.csproj" />
+        <ProjectReference Include="..\..\src\CodoMetis.TypeKit.Testing\CodoMetis.TypeKit.Testing.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <Compile Include="..\oracles\Candidates.cs" Link="Oracles\Candidates.cs" />
+        <Compile Include="..\oracles\SeedVerdict.cs" Link="Oracles\SeedVerdict.cs" />
+    </ItemGroup>
+
+</Project>
diff --git a/test/CodoMetis.TypeKit.Oracles.Tests/OracleCandidateTests.cs b/test/CodoMetis.TypeKit.Oracles.Tests/OracleCandidateTests.cs
new file mode 100644
index 00000000..035555af
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Oracles.Tests/OracleCandidateTests.cs
@@ -0,0 +1,41 @@
+using System.Text.RegularExpressions;
+
+namespace CodoMetis.TypeKit.Oracles.Tests;
+
+/// <summary>
+/// The candidate registry (<c>test/oracles/candidates.json</c>) names only registered oracles and tracks every entry
+/// to an issue or to a labelled failure (design/adr/0112). A misspelt oracle name would match nothing, and the row
+/// would silently keep failing as unknown.
+/// </summary>
+public sealed class OracleCandidateTests
+{
+    [Fact]
+    public void Every_candidate_names_a_registered_oracle_and_a_row()
+    {
+        var oracles = OracleCatalogue.Oracles.Select(oracle => oracle.Class).ToHashSet(StringComparer.Ordinal);
+        var problems = new List<string>();
+
+        foreach (var candidate in Candidates.All)
+        {
+            if (!oracles.Contains(candidate.Oracle)) problems.Add($"'{candidate.Row}' names oracle '{candidate.Oracle}', which oracles.json does not register");
+            if (candidate.Row.Trim().Length < 3) problems.Add($"a candidate of {candidate.Oracle} has no row text");
+            if (candidate.Family.Trim().Length == 0) problems.Add($"'{candidate.Row}' has no family label");
+            if (candidate.Method is { } method && !Regex.IsMatch(File.ReadAllText(SourceOf(candidate.Oracle)), $@"\b{Regex.Escape(method)}\s*\("))
+                problems.Add($"'{candidate.Row}' is scoped to method '{method}', which {candidate.Oracle} does not declare");
+            if (candidate.Issue.Length > 0 && !candidate.Issue.StartsWith('#') && !candidate.Issue.StartsWith("http", StringComparison.Ordinal))
+                problems.Add($"'{candidate.Row}' has an issue that is neither '#<n>' nor a URL: '{candidate.Issue}'");
+        }
+
+        problems.ShouldBeEmpty();
+    }
+
+    [Fact]
+    public void Candidates_are_unique_per_oracle() =>
+        Candidates.All.GroupBy(candidate => (candidate.Oracle, candidate.Row)).Where(group => group.Count() > 1)
+                  .Select(group => $"{group.Key.Oracle}: '{group.Key.Row}'")
+                  .ShouldBeEmpty("Duplicate candidates.");
+
+    private static string SourceOf(string oracle) =>
+        Directory.EnumerateFiles(Path.Combine(OracleCatalogue.Root, "test"), oracle + ".cs", SearchOption.AllDirectories)
+                 .First(path => !path.Contains($"{Path.DirectorySeparatorChar}obj{Path.DirectorySeparatorChar}", StringComparison.Ordinal));
+}
diff --git a/test/CodoMetis.TypeKit.Oracles.Tests/OracleCatalogue.cs b/test/CodoMetis.TypeKit.Oracles.Tests/OracleCatalogue.cs
new file mode 100644
index 00000000..74d0aea7
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Oracles.Tests/OracleCatalogue.cs
@@ -0,0 +1,191 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Text.RegularExpressions;
+
+namespace CodoMetis.TypeKit.Oracles.Tests;
+
+/// <summary>
+/// The files under <c>test/oracles/</c>, loaded once: the claims the documents make, the oracle classes that hold
+/// them, the seeds that prove the oracles can fail, the waivers for public members no claim covers, and the known
+/// disagreements (design/adr/0112).
+/// </summary>
+/// <remarks>
+/// Everything here is data a maintainer edits by hand, and the <c>Oracle*Tests</c> hold it consistent with the
+/// repository: a claim's quote must still be in its document, a surface must still exist, an oracle must still be a
+/// test class with a seed. The tests are what make the catalogue a worklist rather than a wish list.
+/// </remarks>
+internal static partial class OracleCatalogue
+{
+    // Declared first: static initializers run in textual order, and the loaders below use it.
+    private static readonly JsonSerializerOptions Json = new()
+    {
+        PropertyNameCaseInsensitive = true,
+        ReadCommentHandling = JsonCommentHandling.Skip,
+        AllowTrailingCommas = true,
+    };
+
+    internal static string Root { get; } = FindRoot();
+
+    internal static string Directory { get; } = Path.Combine(Root, "test", "oracles");
+
+    internal static IReadOnlyList<Claim> Claims { get; } = Load<List<Claim>>("claims.json");
+
+    internal static IReadOnlyList<Oracle> Oracles { get; } = Load<List<Oracle>>("oracles.json");
+
+    /// <summary>Surface patterns no claim names, each with the reason it needs no oracle.</summary>
+    internal static IReadOnlyDictionary<string, string> SurfaceWaivers { get; } = Load<Dictionary<string, string>>("surface-waivers.json");
+
+    internal static IReadOnlyList<Seed> Seeds { get; } =
+        [.. new DirectoryInfo(Path.Combine(Directory, "seeds")).EnumerateFiles("*.patch").OrderBy(file => file.Name, StringComparer.Ordinal).Select(Seed.Read)];
+
+    /// <summary>The documents that make promises to consumers; every one must carry at least one claim.</summary>
+    internal static readonly string[] PromiseDocuments =
+    [
+        "README.md",
+        "docs/json.md",
+        "docs/text.md",
+        "docs/merge-patches.md",
+        "docs/option.md",
+        "docs/result.md",
+        "docs/ef-core.md",
+        "docs/type-constraints.md",
+        "docs/walkthrough.md",
+        "src/CodoMetis.TypeKit.AspNetCore/README.md",
+        "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md",
+        "src/CodoMetis.TypeKit.Generators/README.md",
+        "src/CodoMetis.TypeKit.Analyzers/README.md",
+        "src/CodoMetis.TypeKit.Testing/README.md",
+        "src/CodoMetis.TypeKit.Serilog/README.md",
+    ];
+
+    /// <summary>Every test class under <c>test/</c>, a class whose file holds a <c>[Fact]</c> or a <c>[Theory]</c>, with its project.</summary>
+    internal static IReadOnlyDictionary<string, string> TestClasses { get; } = DiscoverTestClasses();
+
+    /// <summary>GitHub's heading slug: lower case, punctuation dropped, spaces to hyphens.</summary>
+    internal static string Slug(string heading) =>
+        Regex.Replace(Regex.Replace(heading.Trim().ToLowerInvariant(), @"[^\p{L}\p{N}\s-]", ""), @"\s", "-");
+
+    /// <summary>Headings of a Markdown file, as slugs, in order.</summary>
+    internal static IReadOnlyList<string> HeadingSlugs(string relativePath)
+    {
+        var inCode = false;
+        var slugs = new List<string>();
+        foreach (var line in File.ReadLines(Path.Combine(Root, relativePath)))
+        {
+            if (line.StartsWith("```", StringComparison.Ordinal)) inCode = !inCode;
+            if (inCode) continue;
+            var match = Regex.Match(line, @"^#{1,6}\s+(.*?)\s*#*\s*$");
+            if (match.Success) slugs.Add(Slug(match.Groups[1].Value));
+        }
+
+        return slugs;
+    }
+
+    /// <summary>A file's text with every run of whitespace collapsed to one space, for quote matching across line wraps.</summary>
+    internal static string Flattened(string relativePath) => Regex.Replace(File.ReadAllText(Path.Combine(Root, relativePath)), @"\s+", " ");
+
+    private static T Load<T>(string file)
+    {
+        var path = Path.Combine(Directory, file);
+        using var stream = File.OpenRead(path);
+        return JsonSerializer.Deserialize<T>(stream, Json) ?? throw new InvalidOperationException($"'{path}' is empty.");
+    }
+
+    private static Dictionary<string, string> DiscoverTestClasses()
+    {
+        var classes = new Dictionary<string, string>(StringComparer.Ordinal);
+        var testRoot = Path.Combine(Root, "test");
+        var separator = Path.DirectorySeparatorChar;
+
+        foreach (var file in System.IO.Directory.EnumerateFiles(testRoot, "*.cs", SearchOption.AllDirectories))
+        {
+            if (file.Contains($"{separator}obj{separator}", StringComparison.Ordinal) || file.Contains($"{separator}bin{separator}", StringComparison.Ordinal)) continue;
+
+            var text = File.ReadAllText(file);
+            if (!TestAttribute().IsMatch(text)) continue;
+
+            var project = Path.GetRelativePath(testRoot, file).Split(separator)[0];
+            foreach (Match match in ClassDeclaration().Matches(text))
+                classes.TryAdd(match.Groups["name"].Value, project);
+        }
+
+        return classes;
+    }
+
+    private static string FindRoot()
+    {
+        const string marker = "CodoMetis.TypeKit.slnx";
+        for (var directory = new DirectoryInfo(AppContext.BaseDirectory); directory is not null; directory = directory.Parent)
+        {
+            if (File.Exists(Path.Combine(directory.FullName, marker))) return directory.FullName;
+        }
+
+        throw new InvalidOperationException($"Could not find '{marker}' above '{AppContext.BaseDirectory}'.");
+    }
+
+    [GeneratedRegex(@"\[(Fact|Theory)\b")]
+    private static partial Regex TestAttribute();
+
+    [GeneratedRegex(@"(?m)^(?:public|internal)\s+(?:sealed\s+|static\s+|partial\s+|abstract\s+)*class\s+(?<name>\w+)")]
+    private static partial Regex ClassDeclaration();
+
+    /// <summary>A sentence a document states about the library's behaviour, and what holds it.</summary>
+    internal sealed class Claim
+    {
+        public string Id { get; init; } = "";
+
+        /// <summary><c>file#heading-slug</c>: where the sentence is.</summary>
+        public string Source { get; init; } = "";
+
+        /// <summary>The sentence, verbatim, so the catalogue test can find it in the file.</summary>
+        public string Quote { get; init; } = "";
+
+        /// <summary>The restatement as "under conditions, observable result".</summary>
+        [JsonPropertyName("claim")]
+        public string Statement { get; init; } = "";
+
+        /// <summary>claim, differential, metamorphic, exception or silent-default.</summary>
+        public string Oracle { get; init; } = "";
+
+        /// <summary>The public members a test of the claim calls, as <see cref="ApiSurface"/> patterns.</summary>
+        public IReadOnlyList<string> Surfaces { get; init; } = [];
+
+        /// <summary>The test classes that assert the claim; empty is the worklist.</summary>
+        public IReadOnlyList<string> HeldBy { get; init; } = [];
+
+        /// <summary>The source file, before the <c>#</c>.</summary>
+        internal string File => Source.Split('#')[0];
+
+        /// <summary>The heading slug after the <c>#</c>, or null for a claim about the whole file.</summary>
+        internal string? Heading => Source.Contains('#') ? Source[(Source.IndexOf('#') + 1)..] : null;
+    }
+
+    /// <summary>A test class that checks the library against an independent answer over many cases.</summary>
+    internal sealed record Oracle(string Class, string Project, string Kind, string Against);
+
+    /// <summary>A patch under <c>seeds/</c>: its header lines, the oracles it names and the files it changes.</summary>
+    internal sealed record Seed(FileInfo File, string Defect, IReadOnlyList<string> Oracles, string Body)
+    {
+        internal static Seed Read(FileInfo file)
+        {
+            var text = System.IO.File.ReadAllText(file.FullName);
+            var diffAt = text.IndexOf("diff --git", StringComparison.Ordinal);
+            var header = diffAt < 0 ? text : text[..diffAt];
+            return new Seed(
+                file,
+                HeaderValue(header, "Seed"),
+                HeaderValue(header, "Oracles").Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries),
+                diffAt < 0 ? "" : text[diffAt..]);
+        }
+
+        /// <summary>The <c>a/</c> paths the diff changes.</summary>
+        internal IReadOnlyList<string> ChangedFiles =>
+            [.. Regex.Matches(Body, @"^diff --git a/(?<path>\S+) b/", RegexOptions.Multiline).Select(match => match.Groups["path"].Value)];
+
+        private static string HeaderValue(string header, string key)
+        {
+            var match = Regex.Match(header, $@"^{key}:\s*(?<value>.+?)\s*$", RegexOptions.Multiline);
+            return match.Success ? match.Groups["value"].Value : "";
+        }
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Oracles.Tests/OracleCatalogueTests.cs b/test/CodoMetis.TypeKit.Oracles.Tests/OracleCatalogueTests.cs
new file mode 100644
index 00000000..3fe3a0b8
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Oracles.Tests/OracleCatalogueTests.cs
@@ -0,0 +1,118 @@
+using System.Text.RegularExpressions;
+
+namespace CodoMetis.TypeKit.Oracles.Tests;
+
+/// <summary>
+/// The claim catalogue (<c>test/oracles/claims.json</c>) stays true to the documents it quotes and to the tests it
+/// names (design/adr/0112).
+/// </summary>
+/// <remarks>
+/// A claim is a sentence a consumer-facing document states about the library, in a form a test can decide, with the
+/// oracle kind, the public members a test of it calls and the test classes that hold it. The catalogue is only worth
+/// keeping if it cannot drift: a reworded sentence stales its claim, a renamed test class is found, a surface that no
+/// longer exists is noticed. A claim with an empty <c>heldBy</c> is allowed: that is the worklist.
+/// </remarks>
+public sealed class OracleCatalogueTests
+{
+    /// <summary>150 at the first catalogue (2026-10-28). A floor, not a target: discovery would otherwise pass on an empty array.</summary>
+    private const int KnownClaims = 150;
+
+    private static readonly string[] Kinds = ["claim", "differential", "metamorphic", "exception", "silent-default"];
+
+    [Fact]
+    public void The_catalogue_is_not_empty_and_its_ids_are_unique_and_sorted()
+    {
+        var ids = OracleCatalogue.Claims.Select(claim => claim.Id).ToList();
+
+        ids.Count.ShouldBeGreaterThanOrEqualTo(KnownClaims);
+        ids.Distinct(StringComparer.Ordinal).Count().ShouldBe(ids.Count, "Duplicate claim ids.");
+        ids.ShouldBe(ids.Order(StringComparer.Ordinal).ToList(), "Claims are sorted by id.");
+        ids.Where(id => !Regex.IsMatch(id, @"^[A-Z]\d{2}-[a-z0-9-]+$"))
+           .ShouldBeEmpty("Every id is a letter, two digits, a hyphen and a kebab-case slug.");
+    }
+
+    [Fact]
+    public void Every_claim_names_an_oracle_kind() =>
+        OracleCatalogue.Claims.Where(claim => !Kinds.Contains(claim.Oracle)).Select(claim => $"{claim.Id}: '{claim.Oracle}'")
+                       .ShouldBeEmpty("The oracle kind is one of " + string.Join("|", Kinds) + ".");
+
+    [Fact]
+    public void Every_claim_quotes_its_source_verbatim()
+    {
+        var problems = new List<string>();
+        var flattened = new Dictionary<string, string>(StringComparer.Ordinal);
+        var headings = new Dictionary<string, IReadOnlyList<string>>(StringComparer.Ordinal);
+
+        foreach (var claim in OracleCatalogue.Claims)
+        {
+            if (!File.Exists(Path.Combine(OracleCatalogue.Root, claim.File)))
+            {
+                problems.Add($"{claim.Id}: source file '{claim.File}' does not exist");
+                continue;
+            }
+
+            if (claim.Heading is { } heading)
+            {
+                if (!headings.TryGetValue(claim.File, out var slugs)) headings[claim.File] = slugs = OracleCatalogue.HeadingSlugs(claim.File);
+                if (!slugs.Contains(heading)) problems.Add($"{claim.Id}: '{claim.File}' has no heading '#{heading}'");
+            }
+
+            if (!flattened.TryGetValue(claim.File, out var text)) flattened[claim.File] = text = OracleCatalogue.Flattened(claim.File);
+
+            var quote = Regex.Replace(claim.Quote, @"\s+", " ").Trim();
+            if (quote.Length < 20)
+                problems.Add($"{claim.Id}: the quote is too short to pin a sentence: '{quote}'");
+            else if (!text.Contains(quote, StringComparison.Ordinal))
+                problems.Add($"{claim.Id}: '{claim.File}' no longer contains the quoted sentence; reword the claim or retire it: '{quote}'");
+        }
+
+        problems.ShouldBeEmpty("Claims out of step with their documents.");
+    }
+
+    [Fact]
+    public void Every_claim_names_test_classes_that_exist()
+    {
+        OracleCatalogue.TestClasses.Count.ShouldBeGreaterThanOrEqualTo(200, "Too few test classes were discovered under test/.");
+
+        OracleCatalogue.Claims.SelectMany(claim => claim.HeldBy.Select(held => (claim.Id, held)))
+                       .Where(pair => !OracleCatalogue.TestClasses.ContainsKey(pair.held))
+                       .Select(pair => $"{pair.Id} -> {pair.held}")
+                       .ShouldBeEmpty("heldBy names a test class that does not exist.");
+    }
+
+    [Fact]
+    public void Every_claim_names_surfaces_that_exist() =>
+        OracleCatalogue.Claims.SelectMany(claim => claim.Surfaces.Select(surface => (claim.Id, surface)))
+                       .Where(pair => ApiSurface.Matching(pair.surface).Count == 0)
+                       .Select(pair => $"{pair.Id} -> '{pair.surface}'")
+                       .ShouldBeEmpty("A claim names a public member that does not exist (keys are TypeName.Member, nested types with '+', '*' is a wildcard).");
+
+    [Fact]
+    public void Every_claim_names_at_least_one_surface() =>
+        OracleCatalogue.Claims.Where(claim => claim.Surfaces.Count == 0).Select(claim => claim.Id)
+                       .ShouldBeEmpty("A claim with no surface cannot be tested.");
+
+    [Fact]
+    public void Every_promise_document_carries_a_claim()
+    {
+        var claimed = OracleCatalogue.Claims.Select(claim => claim.File).ToHashSet(StringComparer.Ordinal);
+
+        OracleCatalogue.PromiseDocuments.Where(document => !claimed.Contains(document))
+                       .ShouldBeEmpty("A consumer-facing document has no claim in the catalogue.");
+    }
+
+    /// <summary>
+    /// heldBy may name any test class, but a class named like an oracle, a sweep over generated cases or a probe over
+    /// the product of consumer settings (<c>test/oracles/axes.md</c>), is registered, so that it has a seed.
+    /// </summary>
+    [Fact]
+    public void A_class_named_like_an_oracle_that_holds_a_claim_is_registered()
+    {
+        var oracles = OracleCatalogue.Oracles.Select(oracle => oracle.Class).ToHashSet(StringComparer.Ordinal);
+
+        OracleCatalogue.Claims.SelectMany(claim => claim.HeldBy).Distinct()
+                       .Where(held => held.EndsWith("OracleTests", StringComparison.Ordinal) || held.EndsWith("ParityTests", StringComparison.Ordinal) || held.EndsWith("ProbeTests", StringComparison.Ordinal))
+                       .Where(held => !oracles.Contains(held))
+                       .ShouldBeEmpty("A class named like an oracle holds a claim but is not in oracles.json, so no seed is required of it.");
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Oracles.Tests/OracleSeedTests.cs b/test/CodoMetis.TypeKit.Oracles.Tests/OracleSeedTests.cs
new file mode 100644
index 00000000..40070919
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Oracles.Tests/OracleSeedTests.cs
@@ -0,0 +1,94 @@
+using System.Diagnostics;
+
+namespace CodoMetis.TypeKit.Oracles.Tests;
+
+/// <summary>
+/// Every registered oracle ships a seed, and every seed still plants its defect (design/adr/0112).
+/// </summary>
+/// <remarks>
+/// <para>
+/// A test that passes with and without a defect is not a guard. The rule has always been to prove a guard by
+/// reverting its fix (<c>.claude/skills/verify-the-guard</c>); a seed is that revert kept as a file.
+/// <c>test/oracles/seeds/&lt;defect&gt;.patch</c> changes <c>src/</c> only, names the oracle classes it fails in an
+/// <c>Oracles:</c> header line, and was shown to fail them by <c>oracles seeds</c>.
+/// </para>
+/// <para>
+/// These tests build nothing: an oracle without a seed, a seed that names no oracle, a seed that touches a test, and a
+/// seed a refactor has stranded all fail here. Whether a seed is still caught is the local tool's job, a copy, a build
+/// of one project and a run of one class per seed, before a release.
+/// </para>
+/// </remarks>
+public sealed class OracleSeedTests
+{
+    private const int KnownOracles = 5;
+
+    [Fact]
+    public void Every_oracle_is_a_test_class_in_its_project()
+    {
+        OracleCatalogue.Oracles.Count.ShouldBeGreaterThanOrEqualTo(KnownOracles);
+
+        OracleCatalogue.Oracles
+                       .Where(oracle => !OracleCatalogue.TestClasses.TryGetValue(oracle.Class, out var project) || project != oracle.Project)
+                       .Select(oracle => $"{oracle.Class} (registered in {oracle.Project}, found in {(OracleCatalogue.TestClasses.TryGetValue(oracle.Class, out var found) ? found : "no project")})")
+                       .ShouldBeEmpty("oracles.json names a class that is not a test class in that project.");
+    }
+
+    [Fact]
+    public void Every_oracle_has_a_seed()
+    {
+        var seeded = OracleCatalogue.Seeds.SelectMany(seed => seed.Oracles).ToHashSet(StringComparer.Ordinal);
+
+        OracleCatalogue.Oracles.Select(oracle => oracle.Class).Where(oracle => !seeded.Contains(oracle))
+                       .ShouldBeEmpty("An oracle has no seed: add test/oracles/seeds/<defect>.patch with an 'Oracles:' line naming it, and show it caught with `oracles seeds`.");
+    }
+
+    [Fact]
+    public void Every_seed_names_a_defect_and_registered_oracles()
+    {
+        OracleCatalogue.Seeds.ShouldNotBeEmpty("No seeds under test/oracles/seeds/.");
+
+        var oracles = OracleCatalogue.Oracles.Select(oracle => oracle.Class).ToHashSet(StringComparer.Ordinal);
+        var problems = new List<string>();
+        foreach (var seed in OracleCatalogue.Seeds)
+        {
+            if (seed.Defect.Length == 0) problems.Add($"{seed.File.Name}: no 'Seed:' header line describing the defect");
+            if (seed.Oracles.Count == 0) problems.Add($"{seed.File.Name}: no 'Oracles:' header line naming the classes it fails");
+            problems.AddRange(seed.Oracles.Where(oracle => !oracles.Contains(oracle)).Select(oracle => $"{seed.File.Name}: names '{oracle}', which oracles.json does not register"));
+            if (seed.Body.Length == 0) problems.Add($"{seed.File.Name}: holds no diff");
+        }
+
+        problems.ShouldBeEmpty();
+    }
+
+    [Fact]
+    public void Every_seed_touches_only_source() =>
+        OracleCatalogue.Seeds.SelectMany(seed => seed.ChangedFiles.Select(file => (seed.File.Name, file)))
+                       .Where(pair => !pair.file.StartsWith("src/", StringComparison.Ordinal))
+                       .Select(pair => $"{pair.Name} changes '{pair.file}'")
+                       .ShouldBeEmpty("A seed plants a defect in the library, never in a test.");
+
+    [Fact]
+    public void Every_seed_applies_to_the_current_tree()
+    {
+        var problems = new List<string>();
+        foreach (var seed in OracleCatalogue.Seeds)
+        {
+            var (exit, output) = Git("apply", "--check", seed.File.FullName);
+            if (exit != 0) problems.Add($"{seed.File.Name} no longer applies; refresh it against src/: {output.Trim()}");
+        }
+
+        problems.ShouldBeEmpty();
+    }
+
+    private static (int Exit, string Output) Git(params string[] arguments)
+    {
+        var info = new ProcessStartInfo("git") { WorkingDirectory = OracleCatalogue.Root, RedirectStandardOutput = true, RedirectStandardError = true };
+        foreach (var argument in arguments) info.ArgumentList.Add(argument);
+
+        using var git = Process.Start(info) ?? throw new InvalidOperationException("git could not be started; the seed checks need it on PATH.");
+        var error = git.StandardError.ReadToEndAsync();
+        var output = git.StandardOutput.ReadToEnd();
+        git.WaitForExit();
+        return (git.ExitCode, output + error.Result);
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Oracles.Tests/OracleSurfaceCoverageTests.cs b/test/CodoMetis.TypeKit.Oracles.Tests/OracleSurfaceCoverageTests.cs
new file mode 100644
index 00000000..cc46ca96
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Oracles.Tests/OracleSurfaceCoverageTests.cs
@@ -0,0 +1,59 @@
+namespace CodoMetis.TypeKit.Oracles.Tests;
+
+/// <summary>
+/// Every public member of the shipping libraries is named by a claim's surfaces or waived with a reason, so the API
+/// cannot grow without deciding which oracle holds it (design/adr/0112).
+/// </summary>
+/// <remarks>
+/// <see cref="ApiSurface"/> enumerates the members by reflection, <c>test/oracles/claims.json</c> says which a claim
+/// covers, and <c>test/oracles/surface-waivers.json</c> says which need no oracle and why. A waiver that no longer
+/// matches an unclaimed member is stale and fails too, so the list shrinks as the claims grow.
+/// </remarks>
+public sealed class OracleSurfaceCoverageTests
+{
+    /// <summary>A floor against the enumeration going quiet.</summary>
+    private const int KnownMembers = 300;
+
+    [Fact]
+    public void The_surface_is_enumerated()
+    {
+        ApiSurface.Members.Count.ShouldBeGreaterThanOrEqualTo(KnownMembers);
+        ApiSurface.Members.ShouldContain("Result.CatchAsync");
+        ApiSurface.Members.ShouldContain("Option.Some");
+        ApiSurface.Members.ShouldContain("FaultResponse.WithType");
+    }
+
+    [Fact]
+    public void Every_public_member_is_claimed_or_waived()
+    {
+        var claimed = Claimed();
+        var waived = OracleCatalogue.SurfaceWaivers.Keys.SelectMany(ApiSurface.Matching).ToHashSet(StringComparer.Ordinal);
+
+        ApiSurface.Members.Where(member => !claimed.Contains(member) && !waived.Contains(member))
+                  .ShouldBeEmpty("These public members are named by no claim and no waiver. Either a document promises something about "
+                               + "them, and the claim goes into test/oracles/claims.json, or they need no oracle, and test/oracles/surface-waivers.json says why.");
+    }
+
+    [Fact]
+    public void No_waiver_is_stale()
+    {
+        var claimed = Claimed();
+        var stale = new List<string>();
+
+        foreach (var (glob, reason) in OracleCatalogue.SurfaceWaivers)
+        {
+            var members = ApiSurface.Matching(glob);
+            if (members.Count == 0)
+                stale.Add($"'{glob}' matches no public member");
+            else if (members.All(claimed.Contains))
+                stale.Add($"'{glob}' matches only members a claim already covers ({members.Count}): remove the waiver");
+            if (reason.Trim().Length < 10)
+                stale.Add($"'{glob}' needs a reason");
+        }
+
+        stale.ShouldBeEmpty("Waivers to clean up.");
+    }
+
+    private static HashSet<string> Claimed() =>
+        OracleCatalogue.Claims.SelectMany(claim => claim.Surfaces).Distinct().SelectMany(ApiSurface.Matching).ToHashSet(StringComparer.Ordinal);
+}
diff --git a/test/CodoMetis.TypeKit.Oracles.Tests/SeedVerdictTests.cs b/test/CodoMetis.TypeKit.Oracles.Tests/SeedVerdictTests.cs
new file mode 100644
index 00000000..aa420722
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Oracles.Tests/SeedVerdictTests.cs
@@ -0,0 +1,194 @@
+using System.Xml.Linq;
+
+namespace CodoMetis.TypeKit.Oracles.Tests;
+
+/// <summary>
+/// The rule <c>oracles seeds</c> judges a seed by (<see cref="SeedVerdict"/>): a seed is caught when its oracle passes
+/// without it and one of its tests fails with it, with a row that is not a known candidate, whatever else shares its
+/// message, and never by a failure xunit wrote for a fixture it could not set up or by a run that did not reach the
+/// tests (design/adr/0117).
+/// </summary>
+/// <remarks>
+/// The TRX documents here have the shape xunit.v3 4.0.2 writes through <c>--report-xunit-trx</c>, measured on
+/// 2026-10-29 with one class per kind of failure: the messages are xunit's own, a fixture's <c>Dispose</c> that throws
+/// is a counter and no result, a crashed host writes no file.
+/// </remarks>
+public sealed class SeedVerdictTests
+{
+    private static readonly Candidates.Candidate Unfiled = new("AnyOracle", "row 1:", "a known disagreement", Issue: "");
+
+    [Fact]
+    public void A_message_with_a_known_row_and_another_row_catches() =>
+        SeedVerdict.Catches(MessageOf([Unfiled], ["row 1: expected 1, got 2", "row 2: expected 1, got 3"])).ShouldBeTrue();
+
+    [Fact]
+    public void A_message_whose_every_row_is_known_does_not_catch() =>
+        SeedVerdict.Catches(MessageOf([Unfiled], ["row 1: expected 1, got 2"])).ShouldBeFalse();
+
+    /// <summary>The other rows come first, so a message cut short still shows one; known rows are what is cut.</summary>
+    [Fact]
+    public void A_message_cut_short_still_shows_the_row_that_catches()
+    {
+        var message = MessageOf([Unfiled], [.. Enumerable.Range(0, 30).Select(i => $"row 1: known variant {i}"), "row 2: expected 1, got 3"], shown: 5);
+
+        message.ShouldContain("… and 26 more");
+        SeedVerdict.Catches(message).ShouldBeTrue();
+    }
+
+    [Fact]
+    public void A_message_cut_short_whose_every_row_is_known_does_not_catch()
+    {
+        var message = MessageOf([Unfiled], [.. Enumerable.Range(0, 30).Select(i => $"row 1: known variant {i}")], shown: 5);
+
+        message.ShouldContain("… and 25 more");
+        SeedVerdict.Catches(message).ShouldBeFalse();
+    }
+
+    /// <summary>A known row whose text spans lines is still one known row: its continuation has no marker and read as a caught row.</summary>
+    [Fact]
+    public void A_known_row_spanning_lines_does_not_catch()
+    {
+        var unfiled = new Candidates.Candidate("AnyOracle", "text {1,", "a known disagreement", Issue: "");
+        var message = MessageOf([unfiled], ["text {1,\n2}: expected {1,2}, refused"]);
+
+        SeedVerdict.Catches(message).ShouldBeFalse(message);
+        message.ShouldContain("{1,⏎2}");
+    }
+
+    /// <summary>A seed that makes a known row agree changes what the sweep answers, which is a catch.</summary>
+    [Fact]
+    public void A_candidate_fixed_catches() => SeedVerdict.Catches(MessageOf([Unfiled], [])).ShouldBeTrue();
+
+    [Theory]
+    [InlineData("Shouldly.ShouldAssertException: value should be 1 but was 2")]
+    [InlineData("Assert.Fail: the text '[known candidate: x]' appears inside a line, not as a row")]
+    public void Any_other_assertion_catches(string message) => SeedVerdict.Catches(message).ShouldBeTrue();
+
+    [Fact]
+    public void A_sweep_with_no_failure_and_no_candidate_passes() =>
+        Should.NotThrow(() => Candidates.Judge([], [], "a sweep"));
+
+    /// <summary>What SQL Server 2022 under QEMU wrote for every test of a SQL Server oracle (#151).</summary>
+    private const string DeadSqlServer =
+        "Collection fixture type 'CodoMetis.TypeKit.EntityFrameworkCore.Tests.SqlServer' threw in InitializeAsync\n" +
+        "---- DotNet.Testcontainers.Containers.ContainerNotRunningException : Container is not running.";
+
+    // Before Passing: static fields initialize in the order they are written.
+    private static readonly XNamespace Ns = "http://microsoft.com/schemas/VisualStudio/TeamTest/2010";
+
+    private static readonly SeedVerdict.Run Passing = Read(Result("Passed"), Result("Passed"));
+
+    /// <summary>The defect of #151: a dead fixture failed every test with and without the seed, and the seed read as caught.</summary>
+    [Fact]
+    public void A_fixture_that_fails_to_initialize_is_an_error_with_or_without_the_seed()
+    {
+        var dead = Read(Result("Failed", DeadSqlServer), Result("Failed", DeadSqlServer));
+
+        dead.Error.ShouldNotBeNull().ShouldContain("2 of 2 tests failed in setup");
+        SeedVerdict.Judge(dead, dead).ShouldStartWith("ERROR   without the seed");
+        SeedVerdict.Judge(Passing, dead).ShouldStartWith("ERROR   with the seed");
+    }
+
+    /// <summary>A seed that breaks a fixture is not credited either: only a test of the oracle's own catches.</summary>
+    [Fact]
+    public void A_fixture_failure_beside_a_caught_test_is_an_error()
+    {
+        var seeded = Read(Result("Failed", "Shouldly.ShouldAssertException : value should be 1 but was 2"), Result("Failed", DeadSqlServer));
+
+        SeedVerdict.Judge(Passing, seeded).ShouldStartWith("ERROR   with the seed");
+    }
+
+    /// <summary>Every message xunit.v3.core 4.0.2 holds for a test it could not set up.</summary>
+    [Theory]
+    [InlineData(DeadSqlServer)]
+    [InlineData("Class fixture type 'Probe.ThrowingCtorFixture' threw in its constructor\n---- System.InvalidOperationException : fixture ctor threw")]
+    [InlineData("Class fixture type 'Probe.ThrowingInitFixture' threw in InitializeAsync\n---- System.InvalidOperationException : threw")]
+    [InlineData("Assembly fixture type 'Probe.Fixture' threw in InitializeAsync\n---- System.Exception : threw")]
+    [InlineData("Collection fixture type 'Probe.Fixture' had one or more unresolved constructor arguments: Probe.Other other")]
+    [InlineData("Class fixture type 'Probe.Fixture' may only define a single public constructor.")]
+    [InlineData("The following constructor parameters did not have matching fixture data: SqlServer server")]
+    [InlineData("Cannot create type 'Probe.Fixture' due to missing constructor arguments: Probe.Other")]
+    public void A_message_xunit_writes_for_a_fixture_it_could_not_set_up_is_setup(string message) =>
+        SeedVerdict.IsSetupFailure(message).ShouldBeTrue();
+
+    /// <summary>An assertion, an exception from the code a test calls, and a sweep's verdict are the test's own failures.</summary>
+    [Theory]
+    [InlineData("Shouldly.ShouldAssertException : [Fact] public void Shouldly_fails1\n    should be\n2\n    but was\n1")]
+    [InlineData("Assert.Equal() Failure: Values differ\nExpected: 1\nActual:   2")]
+    [InlineData("System.InvalidOperationException : product threw")]
+    [InlineData("a sweep: 3 of 170 rows disagree\n(shape: TptRoot, kind: \"ushort\"): the key reads back as 0")]
+    [InlineData("row 1: the Collection fixture type 'X' threw in InitializeAsync, quoted by a test")]
+    public void A_failure_in_the_test_itself_is_not_setup(string message) => SeedVerdict.IsSetupFailure(message).ShouldBeFalse();
+
+    [Fact]
+    public void An_oracle_that_fails_without_the_seed_is_an_error()
+    {
+        var failing = Read(Result("Passed"), Result("Failed", "Assert.Equal() Failure: Values differ"));
+
+        SeedVerdict.Judge(failing, failing).ShouldBe("ERROR   1 of 2 tests fail without the seed, e.g. Probe.Oracle.T1");
+    }
+
+    [Fact]
+    public void A_test_failing_only_with_the_seed_catches() =>
+        SeedVerdict.Judge(Passing, Read(Result("Passed"), Result("Failed", "Assert.Equal() Failure: Values differ")))
+                   .ShouldBe("CAUGHT  1 of 2 tests fail, e.g. Probe.Oracle.T1");
+
+    [Fact]
+    public void An_oracle_that_passes_with_the_seed_misses_it() =>
+        SeedVerdict.Judge(Passing, Passing).ShouldBe("MISSED  all 2 tests pass with the defect planted");
+
+    /// <summary>An unfiled candidate fails its sweep without a seed; the baseline passes, and the seed is judged by its other rows.</summary>
+    [Fact]
+    public void A_baseline_failing_only_on_known_candidates_passes()
+    {
+        var known = Read(Result("Passed"), Result("Failed", MessageOf([Unfiled], ["row 1: expected 1, got 2"])));
+        var seeded = Read(Result("Passed"), Result("Failed", MessageOf([Unfiled], ["row 1: expected 1, got 2", "row 2: expected 1, got 3"])));
+
+        known.Error.ShouldBeNull();
+        SeedVerdict.Judge(known, known).ShouldBe("MISSED  1 of 2 tests fail, every row a known candidate");
+        SeedVerdict.Judge(known, seeded).ShouldStartWith("CAUGHT");
+    }
+
+    /// <summary>A fixture whose Dispose throws fails no test; the TRX counts it as an error outside any result.</summary>
+    [Fact]
+    public void An_error_counted_outside_any_test_is_an_error() =>
+        SeedVerdict.Read(2, Trx([Result("Passed")], error: 1), "Probe.Oracle").Error.ShouldNotBeNull().ShouldContain("1 error outside any test");
+
+    /// <summary>A host that crashes writes no TRX; one that exits otherwise than 0 or 2 did not finish its tests.</summary>
+    [Theory]
+    [InlineData(134, false)]
+    [InlineData(7, true)]
+    [InlineData(3, true)]
+    public void A_host_that_did_not_finish_is_an_error(int exitCode, bool wroteResults) =>
+        SeedVerdict.Read(exitCode, wroteResults ? Trx([Result("Failed", "Assert.Equal() Failure: Values differ")]) : null, "Probe.Oracle")
+                   .Error.ShouldNotBeNull().ShouldContain($"exited {exitCode}");
+
+    [Fact]
+    public void A_run_whose_every_test_is_skipped_is_an_error() =>
+        SeedVerdict.Read(0, Trx([Result("NotExecuted"), Result("NotExecuted")]), "Probe.Oracle").Error.ShouldBe("no test of Probe.Oracle ran");
+
+    private static SeedVerdict.Run Read(params XElement[] results) =>
+        SeedVerdict.Read(results.Any(result => (string?)result.Attribute("outcome") == "Failed") ? 2 : 0, Trx(results), "Probe.Oracle");
+
+    private static XElement Result(string outcome, string? message = null) =>
+        new(Ns + "UnitTestResult", new XAttribute("testName", "?"), new XAttribute("outcome", outcome),
+            message is null ? null : new XElement(Ns + "Output", new XElement(Ns + "ErrorInfo", new XElement(Ns + "Message", message), new XElement(Ns + "StackTrace", "   at Probe.Oracle.T()"))));
+
+    private static XDocument Trx(IReadOnlyList<XElement> results, int error = 0)
+    {
+        var named = results.Select(result => new XElement(result)).ToList();
+        for (var i = 0; i < named.Count; i++) named[i].SetAttributeValue("testName", $"Probe.Oracle.T{i}");
+
+        int Count(string outcome) => named.Count(result => (string?)result.Attribute("outcome") == outcome);
+        return new XDocument(new XElement(Ns + "TestRun",
+            new XElement(Ns + "Results", named),
+            new XElement(Ns + "ResultSummary", new XAttribute("outcome", Count("Failed") > 0 || error > 0 ? "Failed" : "Completed"),
+                new XElement(Ns + "Counters",
+                    new XAttribute("total", named.Count), new XAttribute("executed", Count("Passed") + Count("Failed")),
+                    new XAttribute("passed", Count("Passed")), new XAttribute("failed", Count("Failed")), new XAttribute("error", error),
+                    new XAttribute("timeout", 0), new XAttribute("aborted", 0), new XAttribute("notExecuted", Count("NotExecuted")), new XAttribute("disconnected", 0)))));
+    }
+
+    private static string MessageOf(IReadOnlyList<Candidates.Candidate> known, IReadOnlyList<string> failures, int shown = 25) =>
+        Should.Throw<Exception>(() => Candidates.Judge(known, failures, "a sweep", shown)).Message;
+}
diff --git a/test/CodoMetis.TypeKit.PrHygiene.Tests/CodoMetis.TypeKit.PrHygiene.Tests.csproj b/test/CodoMetis.TypeKit.PrHygiene.Tests/CodoMetis.TypeKit.PrHygiene.Tests.csproj
new file mode 100644
index 00000000..a0a4c5c4
--- /dev/null
+++ b/test/CodoMetis.TypeKit.PrHygiene.Tests/CodoMetis.TypeKit.PrHygiene.Tests.csproj
@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <!--
+      Runs the built pr-hygiene.dll as a process, from a throwaway repository that holds its sources and its
+      output (ToolSandbox.cs). The reference only orders the build; ToolOutput says where the output is.
+    -->
+    <ItemGroup>
+        <ProjectReference Include="../../tools/PrHygiene/PrHygiene.csproj" ReferenceOutputAssembly="false" />
+        <AssemblyAttribute Include="System.Reflection.AssemblyMetadataAttribute">
+            <_Parameter1>ToolOutput</_Parameter1>
+            <_Parameter2>$([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)../../tools/PrHygiene/bin/$(Configuration)/$(TargetFramework)/'))</_Parameter2>
+        </AssemblyAttribute>
+    </ItemGroup>
+
+    <ItemGroup>
+        <Compile Include="../CodoMetis.TypeKit.BuildVerdict.Tests/ToolSandbox.cs" Link="ToolSandbox.cs" />
+    </ItemGroup>
+</Project>
diff --git a/test/CodoMetis.TypeKit.PrHygiene.Tests/HygieneTests.cs b/test/CodoMetis.TypeKit.PrHygiene.Tests/HygieneTests.cs
new file mode 100644
index 00000000..eb0fac60
--- /dev/null
+++ b/test/CodoMetis.TypeKit.PrHygiene.Tests/HygieneTests.cs
@@ -0,0 +1,179 @@
+using System.Text.Json;
+
+namespace CodoMetis.TypeKit.PrHygiene.Tests;
+
+/// <summary>
+/// The pull requests the check must pass and the ones it must fail, one rule at a time. Each case writes the
+/// event payload GitHub would and runs the built tool on it as its own process, the way the workflow does.
+/// Each failing case starts from <see cref="InOrder"/>, which passes, and breaks one thing, so a case that
+/// fails proves the rule it names; each rule was also proved by deleting it from the tool and watching its
+/// cases fail.
+/// </summary>
+public sealed class HygieneTests(HygieneTests.Sandbox sandbox) : IClassFixture<HygieneTests.Sandbox>
+{
+    public sealed class Sandbox : IDisposable
+    {
+        public ToolSandbox Tool { get; } = new("PrHygiene", "pr-hygiene");
+
+        public void Dispose() => Tool.Dispose();
+    }
+
+    private sealed record Pr(
+        string[] Labels,
+        string? Body = "Closes #12",
+        string Head = "fix/serilog-max-length",
+        string Base = "release/2.3.0",
+        string? Milestone = "2.3.0",
+        string Author = "CaffeinatedCoder");
+
+    private static readonly Pr InOrder = new(["bug", "severity/high", "package/serilog"]);
+
+    private (int Code, string Output) Check(Pr pr)
+    {
+        var payload = new
+        {
+            action = "opened",
+            pull_request = new
+            {
+                user = new { login = pr.Author },
+                labels = pr.Labels.Select(name => new { name }).ToArray(),
+                body = pr.Body,
+                head = new { @ref = pr.Head },
+                @base = new { @ref = pr.Base },
+                milestone = pr.Milestone is null ? null : new { title = pr.Milestone },
+            },
+        };
+        var file = Path.Combine(sandbox.Tool.Work, $"{Guid.NewGuid():N}.json");
+        File.WriteAllText(file, JsonSerializer.Serialize(payload));
+        var (code, output, _) = sandbox.Tool.Run(arguments: file);
+        return (code, output);
+    }
+
+    private void Passes(Pr pr)
+    {
+        var (code, output) = Check(pr);
+        code.ShouldBe(0, output);
+        output.ShouldNotContain("::error::");
+    }
+
+    private void Fails(Pr pr, string problem)
+    {
+        var (code, output) = Check(pr);
+        code.ShouldBe(1, output);
+        output.ShouldContain($"::error::{problem}", customMessage: output);
+    }
+
+    [Fact]
+    public void A_pull_request_in_order_passes() => Passes(InOrder);
+
+    [Theory]
+    [InlineData("feat/cause-on-fault", "enhancement")]
+    [InlineData("docs/plain-voice", "documentation")]
+    [InlineData("test/variant-catalogue", "tests")]
+    [InlineData("build/pr-hygiene", "chore")]
+    [InlineData("refactor/split-plan", "chore")]
+    [InlineData("spike/mutation-base", "chore")]
+    public void Each_branch_type_passes_with_its_label(string head, string type) => Passes(InOrder with { Head = head, Labels = [type] });
+
+    [Fact]
+    public void A_release_into_main_passes_with_its_milestone() =>
+        Passes(InOrder with { Head = "release/2.3.0", Base = "main", Labels = ["chore", "area/release"], Body = "Closes #70" });
+
+    [Fact]
+    public void Dependabot_is_not_checked() =>
+        Passes(new Pr([], Body: null, Head: "dependabot/github_actions/actions-abc", Base: "main", Milestone: null, Author: "dependabot[bot]"));
+
+    [Fact]
+    public void No_type_label_fails() => Fails(InOrder with { Labels = ["package/serilog"] }, "Needs exactly one type label");
+
+    [Fact]
+    public void Two_type_labels_fail() => Fails(InOrder with { Labels = ["bug", "chore", "severity/low"] }, "Needs exactly one type label (bug, enhancement, documentation, tests, chore); it has 2: bug, chore.");
+
+    [Fact]
+    public void A_bug_without_a_severity_fails() => Fails(InOrder with { Labels = ["bug"] }, "A bug needs exactly one severity/* label");
+
+    [Fact]
+    public void A_bug_with_two_severities_fails() => Fails(InOrder with { Labels = ["bug", "severity/high", "severity/low"] }, "A bug needs exactly one severity/* label (critical, high, medium, low); it has 2.");
+
+    [Fact]
+    public void Silent_on_no_bug_fails() => Fails(InOrder with { Head = "feat/x", Labels = ["enhancement", "silent"] }, "Only a bug is silent");
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    [InlineData("Refs #12")]
+    [InlineData("Closes the gap in #12")]
+    [InlineData("Closes #")]
+    [InlineData("Discloses #12")]
+    public void A_description_without_a_closing_reference_fails(string? body) =>
+        Fails(InOrder with { Body = body }, "The description needs a closing reference to its issue");
+
+    [Theory]
+    [InlineData("closes #12")]
+    [InlineData("Fixes: #3")]
+    [InlineData("Problem first.\n\nResolved CaffeinatedCoder/CodoMetis.TypeKit#4")]
+    [InlineData("FIXED #5, close #6")]
+    public void Each_closing_keyword_passes(string body) => Passes(InOrder with { Body = body });
+
+    [Theory]
+    [InlineData("claude/quirky-panini")]
+    [InlineData("pr-hygiene")]
+    [InlineData("fix/")]
+    [InlineData("/x")]
+    public void A_branch_not_named_type_slash_slug_fails(string head) => Fails(InOrder with { Head = head }, $"The branch '{head}' is not named <type>/<slug>");
+
+    [Fact]
+    public void A_branch_whose_type_disagrees_with_the_label_fails() =>
+        Fails(InOrder with { Head = "feat/cause-on-fault" }, "The branch 'feat/cause-on-fault' is a feat branch, which is labelled enhancement, not bug.");
+
+    [Fact]
+    public void A_pull_request_into_a_release_without_a_milestone_fails() =>
+        Fails(InOrder with { Milestone = null }, "A pull request into 2.3.0 has the milestone 2.3.0; it has none.");
+
+    [Fact]
+    public void A_pull_request_into_a_release_with_another_milestone_fails() =>
+        Fails(InOrder with { Milestone = "2.4.0" }, "A pull request into 2.3.0 has the milestone 2.3.0; it has '2.4.0'.");
+
+    [Fact]
+    public void A_release_into_main_without_its_milestone_fails() =>
+        Fails(InOrder with { Head = "release/2.3.0", Base = "main", Labels = ["chore"], Milestone = null }, "A pull request into 2.3.0 has the milestone 2.3.0; it has none.");
+
+    [Fact]
+    public void A_topic_into_main_needs_no_milestone() => Passes(InOrder with { Base = "main", Milestone = null });
+
+    [Theory]
+    [InlineData("2.3.0")]
+    [InlineData("2.2.1")]
+    public void A_breaking_change_into_a_minor_or_a_patch_fails(string version) =>
+        Fails(InOrder with { Base = $"release/{version}", Milestone = version, Labels = ["bug", "severity/high", "breaking"] },
+              $"A breaking change needs a major, and {version} is not one");
+
+    [Fact]
+    public void A_breaking_change_into_a_major_passes() =>
+        Passes(InOrder with { Base = "release/3.0.0", Milestone = "3.0.0", Labels = ["bug", "severity/high", "breaking"] });
+
+    [Fact]
+    public void Every_problem_is_reported_at_once()
+    {
+        var (code, output) = Check(new Pr([], Body: null, Head: "claude/x", Milestone: null));
+
+        code.ShouldBe(1);
+        output.Split('\n').Count(line => line.StartsWith("::error::", StringComparison.Ordinal)).ShouldBe(4, output);
+    }
+
+    [Fact]
+    public void A_payload_without_a_pull_request_is_a_usage_error()
+    {
+        var file = Path.Combine(sandbox.Tool.Work, "push.json");
+        File.WriteAllText(file, """{"ref":"refs/heads/main"}""");
+
+        sandbox.Tool.Run(arguments: file).Code.ShouldBe(2);
+    }
+
+    [Fact]
+    public void A_missing_payload_is_a_usage_error()
+    {
+        sandbox.Tool.Run(arguments: Path.Combine(sandbox.Tool.Work, "absent.json")).Code.ShouldBe(2);
+        sandbox.Tool.Run().Code.ShouldBe(2);
+    }
+}
diff --git a/test/CodoMetis.TypeKit.PrHygiene.Tests/StaleToolTests.cs b/test/CodoMetis.TypeKit.PrHygiene.Tests/StaleToolTests.cs
new file mode 100644
index 00000000..9b542b78
--- /dev/null
+++ b/test/CodoMetis.TypeKit.PrHygiene.Tests/StaleToolTests.cs
@@ -0,0 +1,30 @@
+namespace CodoMetis.TypeKit.PrHygiene.Tests;
+
+/// <summary>
+/// A check built from other sources than the checkout holds says so and checks nothing: exit 3, the
+/// difference, and the command that rebuilds it. A stale check would pass or fail pull requests by rules
+/// nobody can read in the checkout.
+/// </summary>
+public sealed class StaleToolTests
+{
+    [Fact]
+    public void A_tool_built_from_its_sources_runs()
+    {
+        using var sandbox = new ToolSandbox("PrHygiene", "pr-hygiene");
+
+        sandbox.Run().Code.ShouldBe(2, "a usage error, so the tool ran");
+    }
+
+    [Fact]
+    public void A_changed_source_stops_it()
+    {
+        using var sandbox = new ToolSandbox("PrHygiene", "pr-hygiene");
+        File.AppendAllText(Path.Combine(sandbox.Repo, "tools", "PrHygiene", "Program.cs"), "\n// edited\n");
+
+        var (code, output, _) = sandbox.Run();
+
+        code.ShouldBe(3);
+        output.ShouldStartWith("TOOL STALE: tools/PrHygiene was built from other sources than the checkout holds (tools/PrHygiene/Program.cs differs)");
+        output.ShouldContain("rebuild it: dotnet build tools/PrHygiene -c ");
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/ClaimsFileTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/ClaimsFileTests.cs
deleted file mode 100644
index c7fa558b..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/ClaimsFileTests.cs
+++ /dev/null
@@ -1,159 +0,0 @@
-using System.Text.Json.Nodes;
-using Prober;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>
-/// claims.json is read against its schema, and each exclusion carries the reason a reviewer reads (decision 102):
-/// a field nobody reads is refused, not kept, and a publish rewrites the file only where it changed.
-/// </summary>
-public sealed class ClaimsFileTests : IDisposable
-{
-    private readonly Fixture fx = new();
-    public void Dispose() => fx.Dispose();
-
-    private void Claims(JsonObject claim)
-    {
-        var c = new JsonObject { ["id"] = "C1", ["source"] = "README.md#a", ["surfaces"] = new JsonArray("s") };
-        foreach (var (key, value) in claim) c[key] = value?.DeepClone();
-        fx.Write("tools/probe/corpus/claims.json", new JsonArray(c).ToJsonString());
-    }
-
-    private static JsonArray Pairs(params (string A, string B)[] pairs) => new([.. pairs.Select(p => (JsonNode)new JsonArray(p.A, p.B))]);
-
-    [Theory]
-    [InlineData(null, "claim C1: exclude[0].reason is required")]
-    [InlineData("", "claim C1: exclude[0].reason does not match")]
-    [InlineData("   ", "claim C1: exclude[0].reason does not match")]
-    public void An_exclusion_without_a_reason_is_refused_naming_the_claim(string? reason, string expected)
-    {
-        var exclusion = new JsonObject { ["pairs"] = Pairs(("x=1", "y=2")) };
-        if (reason is not null) exclusion["reason"] = reason;
-        Claims(new JsonObject { ["exclude"] = new JsonArray(exclusion) });
-        var (exit, _, error) = fx.Ledger("universe", "--base", "HEAD");
-        exit.ShouldBe(1);
-        error.ShouldContain(expected);
-    }
-
-    [Fact]
-    public void A_bare_pair_is_refused_as_an_exclusion_without_its_reason()
-    {
-        Claims(new JsonObject { ["exclude"] = Pairs(("x=1", "y=2")) });
-        var (exit, _, error) = fx.Ledger("universe", "--base", "HEAD");
-        exit.ShouldBe(1);
-        error.ShouldContain("claim C1: exclude[0] is not an object");
-    }
-
-    [Theory]
-    [InlineData("excludeReasons")]
-    [InlineData("excludeWhy")]
-    public void A_reason_field_of_its_own_is_refused(string field)
-    {
-        Claims(new JsonObject
-        {
-            ["exclude"] = new JsonArray(new JsonObject { ["reason"] = "No row holds both.", ["pairs"] = Pairs(("x=1", "y=2")) }),
-            [field] = new JsonArray(new JsonObject { ["match"] = "x=1 x y=2", ["reason"] = "No row holds both." }),
-        });
-        var (exit, _, error) = fx.Ledger("universe", "--base", "HEAD");
-        exit.ShouldBe(1);
-        error.ShouldContain($"claim C1: {field} is not a field the schema has");
-    }
-
-    [Fact]
-    public void A_field_of_its_own_in_an_exclusion_is_refused()
-    {
-        Claims(new JsonObject
-        {
-            ["exclude"] = new JsonArray(new JsonObject { ["reason"] = "No row holds both.", ["why"] = "twice", ["pairs"] = Pairs(("x=1", "y=2")) }),
-        });
-        var (exit, _, error) = fx.Ledger("universe", "--base", "HEAD");
-        exit.ShouldBe(1);
-        error.ShouldContain("claim C1: exclude[0].why is not a field the schema has");
-    }
-
-    [Theory]
-    [InlineData("\n")]
-    [InlineData("\r\n")]
-    public void The_universe_shows_each_exclusion_with_its_reason(string newLine)
-    {
-        Claims(new JsonObject
-        {
-            ["exclude"] = new JsonArray(new JsonObject { ["reason"] = "No row holds x=1 with y=2.", ["pairs"] = Pairs(("y=2", "x=1")) }),
-        });
-        var (exit, output, error) = fx.LedgerEnding([], newLine, "universe", "--base", "HEAD");
-        exit.ShouldBe(0, error);
-        output.ReplaceLineEndings("\n").ShouldContain("C1: 2 axes, 3 pairs\n  exclude 1 pair(s), first x=1 y=2: No row holds x=1 with y=2.\n");
-    }
-
-    [Theory]
-    [InlineData("\n")]
-    [InlineData("\r\n")]
-    public void The_universe_shows_each_narrowing_with_its_quote(string newLine)
-    {
-        Claims(new JsonObject { ["narrow"] = new JsonObject { ["y"] = "The claim." } });
-        var (exit, output, error) = fx.LedgerEnding([], newLine, "universe", "--base", "HEAD");
-        exit.ShouldBe(0, error);
-        output.ReplaceLineEndings("\n").ShouldContain("C1: 1 axes, 0 pairs\n  narrow y: \"The claim.\"\n");
-    }
-
-    [Theory]
-    [InlineData("\n")]
-    [InlineData("\r\n")]
-    public void A_publish_that_changes_nothing_keeps_the_file_as_it_is(string staged)
-    {
-        // The form publish writes, by hand: a reason with a backtick, a plus and angle brackets, all literal, and \n line
-        // ends, whatever this source file was checked out with. The staged copy may come with either line end.
-        var tracked = """
-            [
-              {
-                "id": "C1",
-                "source": "README.md#a",
-                "surfaces": [
-                  "s"
-                ],
-                "exclude": [
-                  {
-                    "reason": "A `+` row and an Option<T> row cannot meet.",
-                    "pairs": [
-                      [
-                        "x=1",
-                        "y=2"
-                      ]
-                    ]
-                  }
-                ]
-              }
-            ]
-
-            """.ReplaceLineEndings("\n");
-        fx.Write("tools/probe/corpus/claims.json", tracked);
-        fx.Commit("claims");
-        fx.Write(".claude/agent-memory-local/prober/branches/main/staging/claims.json", tracked.ReplaceLineEndings(staged));
-        var (exit, _, error) = fx.Ledger("publish");
-        exit.ShouldBe(0, error);
-        fx.Sh("git", "diff", "--exit-code", "--", "tools/probe/corpus/claims.json");
-        File.ReadAllText(Path.Combine(fx.Root, "tools/probe/corpus/claims.json")).ShouldBe(tracked, "byte for byte: the escapes and the line ends are the ones publish writes");
-    }
-
-    [Theory]
-    [InlineData("\n")]
-    [InlineData("\r\n")]
-    public void The_corpus_claims_match_their_schema_in_the_form_publish_writes(string checkedOut)
-    {
-        var root = AppContext.BaseDirectory;
-        while (!File.Exists(Path.Combine(root, "CodoMetis.TypeKit.slnx"))) root = Path.GetDirectoryName(root) ?? throw new InvalidOperationException("no CodoMetis.TypeKit.slnx above the test output");
-        var path = Path.Combine(root, "tools/probe/corpus/claims.json");
-        var claims = Ledger.ReadClaims(path, "tools/probe/corpus/claims.json");
-        claims.ShouldNotBeEmpty();
-        // Git may check the file out with either line end (core.autocrlf on Windows); what it stores, and diffs, has \n.
-        var text = File.ReadAllText(path).ReplaceLineEndings(checkedOut);
-        Files.Format(JsonNode.Parse(text)!).ShouldBe(text.ReplaceLineEndings("\n"), "claims.json is in the form `prober publish` writes, so a publish diffs only what it changes");
-    }
-
-    [Fact]
-    public void A_schema_keyword_the_check_does_not_read_is_an_error_not_a_pass()
-    {
-        var schema = new JsonObject { ["type"] = "string", ["maxLength"] = 3 };
-        Should.Throw<InvalidOperationException>(() => SchemaCheck.Problems("abcd", schema)).Message.ShouldContain("maxLength");
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/CodoMetis.TypeKit.Prober.Tests.csproj b/test/CodoMetis.TypeKit.Prober.Tests/CodoMetis.TypeKit.Prober.Tests.csproj
deleted file mode 100644
index 2126c5f2..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/CodoMetis.TypeKit.Prober.Tests.csproj
+++ /dev/null
@@ -1,29 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-    <!--
-      prober's tests, the behavioural spec of its ledger: each against a fixture repository of its own
-      (git, one claim, a corpus, a state directory), commands run in-process, and the racing lock tests
-      against real processes of the built dll.
-    -->
-    <ItemGroup>
-        <ProjectReference Include="..\..\tools\Prober\Prober.csproj" />
-    </ItemGroup>
-
-    <!--
-      The probe corpus's row harness, compiled in as the replay compiles it into the Samples, so HarnessErrorTests
-      runs the real Rec.Run and feeds the lines it writes to `seeds` (decision 103).
-    -->
-    <ItemGroup>
-        <Compile Include="../../tools/probe/corpus/harness/Row.cs" Link="Harness/Row.cs" />
-    </ItemGroup>
-
-    <!-- The stale-tool test runs the built prober.dll from a throwaway repository (ToolSandbox.cs); ToolOutput says where the output is. -->
-    <ItemGroup>
-        <Compile Include="../CodoMetis.TypeKit.BuildVerdict.Tests/ToolSandbox.cs" Link="ToolSandbox.cs" />
-        <AssemblyAttribute Include="System.Reflection.AssemblyMetadataAttribute">
-            <_Parameter1>ToolOutput</_Parameter1>
-            <_Parameter2>$([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)../../tools/Prober/bin/$(Configuration)/$(TargetFramework)/'))</_Parameter2>
-        </AssemblyAttribute>
-    </ItemGroup>
-
-</Project>
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/CoveringTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/CoveringTests.cs
deleted file mode 100644
index 0a824ae1..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/CoveringTests.cs
+++ /dev/null
@@ -1,80 +0,0 @@
-using Prober;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>
-/// The covering array never puts an excluded pair or one no obligation wants in a row, not even to fill an axis whose every
-/// value would bring one (#54 and #59 saw `rows` place them): such an axis is left out of that row, and an axis with no wanted
-/// pair at all is left out of every row.
-/// </summary>
-public sealed class CoveringTests
-{
-    private static Inapplicability Declared(string cite, params (string Axis, string[] Values)[] axes) =>
-        new(axes.ToDictionary(a => a.Axis, a => a.Values.ToList(), StringComparer.Ordinal), cite);
-
-    private static Claim Over(string[] axes, IEnumerable<Pair>? excluded = null, params Inapplicability[] declared) => new()
-    {
-        Id = "C1", Source = "README.md#a", Surfaces = ["s"], Watched = [], Excluded = [.. excluded ?? []],
-        Obligations = declared.Length == 0 ? [] : [new("keys", "The claim.", new SortedDictionary<string, List<string>>(StringComparer.Ordinal)) { Inapplicable = declared }],
-        Axes = new(axes.ToDictionary(a => a, _ => new List<string> { "1", "2" }), StringComparer.Ordinal),
-    };
-
-    private static bool Holds(IReadOnlyDictionary<string, string> row, Pair pair) =>
-        new[] { pair.A, pair.B }.All(item => row.TryGetValue(item[..item.IndexOf('=', StringComparison.Ordinal)], out var v) && v == item[(item.IndexOf('=', StringComparison.Ordinal) + 1)..]);
-
-    private static IEnumerable<string> Shown(IEnumerable<Pair> pairs) => pairs.Select(p => p.ToString()).Order(StringComparer.Ordinal);
-
-    [Fact]
-    public void An_axis_whose_every_value_brings_an_excluded_pair_is_left_out_of_the_row()
-    {
-        // x=1 goes with no y (as shape.containing goes with no shape.position=root): a row holding x=1 holds no y.
-        Pair[] excluded = [new("x=1", "y=1"), new("x=1", "y=2")];
-        var claim = Over(["x", "y", "z"], excluded);
-        for (var seed = 1; seed <= 20; seed++)
-        {
-            var rows = Covering.Rows(claim, claim.Pairs(), 2000, seed);
-            rows.ShouldNotContain(r => excluded.Any(p => Holds(r.Row, p)), $"seed {seed}");
-            rows.Where(r => r.Row["x"] == "1").ShouldAllBe(r => !r.Row.ContainsKey("y"), $"seed {seed}");
-            Shown(rows.SelectMany(r => r.Pairs)).ShouldBe(Shown(claim.Pairs()), $"seed {seed}: every pair once, x=1 with z among them");
-        }
-    }
-
-    [Fact]
-    public void An_axis_whose_every_value_brings_a_pair_no_obligation_wants_is_left_out_of_the_row()
-    {
-        var claim = Over(["x", "y", "z"], null, Declared("record:0001", ("x", ["1"]), ("y", ["1", "2"])));
-        var dead = claim.DeclaredInapplicable().Keys.ToList();
-        dead.Count.ShouldBe(2);
-        for (var seed = 1; seed <= 20; seed++)
-        {
-            var rows = Covering.Rows(claim, claim.PairsWanted(), 2000, seed);
-            rows.ShouldNotContain(r => dead.Any(p => Holds(r.Row, p)), $"seed {seed}");
-            Shown(rows.SelectMany(r => r.Pairs)).ShouldBe(Shown(claim.PairsWanted()), $"seed {seed}");
-        }
-    }
-
-    [Fact]
-    public void An_axis_with_no_wanted_pair_is_in_no_row()
-    {
-        // every pair of z is excluded (as shape.refused-kind is where the refusal is not the claim): rows over x and y alone.
-        var claim = Over(["x", "y", "z"], [.. from x in new[] { "x=1", "x=2", "y=1", "y=2" } from z in new[] { "z=1", "z=2" } select new Pair(x, z)]);
-        for (var seed = 1; seed <= 5; seed++)
-        {
-            var rows = Covering.Rows(claim, claim.Pairs(), 2000, seed);
-            rows.ShouldAllBe(r => !r.Row.ContainsKey("z"), $"seed {seed}");
-            Shown(rows.SelectMany(r => r.Pairs)).ShouldBe(["x=1 y=1", "x=1 y=2", "x=2 y=1", "x=2 y=2"], $"seed {seed}");
-        }
-    }
-
-    [Fact]
-    public void A_seeded_row_leaves_out_an_axis_no_value_of_which_can_join_it()
-    {
-        // c=1 goes with no d: the row seeded from a=1 c=1 is a, b and c.
-        var claim = Over(["a", "b", "c", "d"], [new("c=1", "d=1"), new("c=1", "d=2")]);
-        Covering.Seeded(claim, new Pair("a=1", "c=1"), claim.DeclaredInapplicable())
-                .ShouldBe(new SortedDictionary<string, string>(StringComparer.Ordinal) { ["a"] = "1", ["b"] = "1", ["c"] = "1" });
-        Covering.Seeded(claim, new Pair("a=1", "b=2"), claim.DeclaredInapplicable())
-                .ShouldBe(new SortedDictionary<string, string>(StringComparer.Ordinal) { ["a"] = "1", ["b"] = "2", ["c"] = "1" },
-                          "c=1 is c's first value, and d then has none");
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/DeclaredApplicabilityTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/DeclaredApplicabilityTests.cs
deleted file mode 100644
index aae5e585..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/DeclaredApplicabilityTests.cs
+++ /dev/null
@@ -1,439 +0,0 @@
-using System.Text.Json.Nodes;
-using Prober;
-using Probes.Shapes;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>
-/// An obligation declares where it does not apply, as axis values with a citation: <c>Axes.Build</c> holds the
-/// declaration to the claim's axes, values and not-promised list; a pair is wanted by an obligation unless one of
-/// its declarations matches it, and a pair no obligation wants is declared inapplicable, which `universe`, `gaps`
-/// and `status` show with its citations, the gate leaves out as it leaves out an exclusion, and the covering
-/// generator never puts in a row. Fixture: C1 over x and y, each 1 and 2, so four pairs.
-/// </summary>
-public sealed class DeclaredApplicabilityTests : IDisposable
-{
-    private readonly Fixture fx = new();
-    public void Dispose() => fx.Dispose();
-
-    private static JsonObject Declared(string cite, params (string Axis, string[] Values)[] axes) => new()
-    {
-        ["axes"] = new JsonObject(axes.Select(a => KeyValuePair.Create(a.Axis, (JsonNode?)new JsonArray([.. a.Values.Select(v => (JsonNode)v)])))),
-        ["cite"] = cite,
-    };
-
-    private static JsonObject Obligation(string id, params JsonObject[] inapplicable)
-    {
-        var o = new JsonObject { ["id"] = id, ["sentence"] = "The claim." };
-        if (inapplicable.Length > 0) o["inapplicable"] = new JsonArray([.. inapplicable]);
-        return o;
-    }
-
-    /// <summary>C1 with the obligations given and one not-promised entry, <c>no-one</c>.</summary>
-    private void Claim(params JsonObject[] obligations) =>
-        fx.Write("tools/probe/corpus/claims.json", new JsonArray(new JsonObject
-        {
-            ["id"] = "C1", ["source"] = "README.md#a", ["surfaces"] = new JsonArray("s"),
-            ["obligations"] = new JsonArray([.. obligations]),
-            ["not-promised"] = new JsonArray(new JsonObject { ["id"] = "no-one", ["source"] = "README.md#a", ["sentence"] = "The claim." }),
-        }).ToJsonString());
-
-    /// <summary>
-    /// keys does not apply where x=1 and y=1 (one declaration over both axes), nulls nowhere x=1: the pair x=1 y=1 is
-    /// wanted by neither, x=1 y=2 by keys alone.
-    /// </summary>
-    private void OnePairWantedByNone() => Claim(
-        Obligation("keys", Declared("docs:README.md#a", ("x", ["1"]), ("y", ["1"]))),
-        Obligation("nulls", Declared("not-promised:no-one", ("x", ["1"]))));
-
-    private string Refused()
-    {
-        var (exit, _, error) = fx.Ledger("universe", "--base", "HEAD");
-        exit.ShouldBe(1);
-        return error;
-    }
-
-    [Fact]
-    public void A_declaration_naming_an_axis_the_claim_does_not_have_is_refused()
-    {
-        Claim(Obligation("keys", Declared("not-promised:no-one", ("z", ["1"]))));
-        Refused().ShouldContain("claim C1: obligation keys: inapplicable[0] names axis z, which the claim does not have");
-    }
-
-    [Fact]
-    public void A_declaration_naming_a_value_the_claim_does_not_list_is_refused()
-    {
-        Claim(Obligation("keys", Declared("not-promised:no-one", ("x", ["1"]))), Obligation("nulls", Declared("not-promised:no-one", ("x", ["3"]))));
-        Refused().ShouldContain("claim C1: obligation nulls: inapplicable[0] names x=3, a value the claim does not list for x");
-    }
-
-    [Theory]
-    [InlineData("fact:KB-31", "is not a knowledge entry's id (fact:KB-031)")]
-    [InlineData("record:94", "is not a decision record's number (record:0094)")]
-    [InlineData("docs:../README.md#a", "is not a docs source (docs:docs/json.md#decimals-in-one-spelling)")]
-    [InlineData("not-promised:No-one", "is not a not-promised id (not-promised:closed-set-has-no-text)")]
-    public void A_malformed_cite_is_refused(string cite, string why)
-    {
-        Claim(Obligation("keys", Declared(cite, ("x", ["1"]))));
-        Refused().ShouldContain($"claim C1: obligation keys: inapplicable[0]: cite {cite} {why}");
-    }
-
-    [Fact]
-    public void A_cite_of_a_not_promised_id_the_claim_lacks_is_refused()
-    {
-        Claim(Obligation("keys", Declared("not-promised:no-such-entry", ("x", ["1"]))));
-        Refused().ShouldContain("claim C1: obligation keys: inapplicable[0] cites not-promised:no-such-entry, which the claim's not-promised list does not hold");
-    }
-
-    [Fact]
-    public void A_field_a_declaration_does_not_have_is_refused_by_the_schema()
-    {
-        var declaration = Declared("not-promised:no-one", ("x", ["1"]));
-        declaration["reason"] = "x=1 has no key";
-        Claim(Obligation("keys", declaration));
-        Refused().ShouldContain("claim C1: obligations[0].inapplicable[0].reason is not a field the schema has");
-    }
-
-    [Fact]
-    public void A_pair_wanted_by_no_obligation_is_listed_by_universe_with_its_citations_and_the_claim_keeps_its_pairs()
-    {
-        OnePairWantedByNone();
-        var (exit, output, error) = fx.Ledger("universe", "--base", "HEAD");
-        exit.ShouldBe(0, error);
-        output.ReplaceLineEndings("\n").ShouldContain(
-            "C1: 2 axes, 4 pairs\n  inapplicable 1 pair(s), wanted by no obligation, first x=1 y=1: docs:README.md#a, not-promised:no-one\n");
-    }
-
-    [Fact]
-    public void Gaps_lists_the_pairs_no_obligation_wants_under_their_own_heading()
-    {
-        OnePairWantedByNone();
-        var (exit, output, error) = fx.Ledger("gaps", "--base", "HEAD");
-        exit.ShouldBe(0, error);
-        output.ReplaceLineEndings("\n").ShouldContain(
-            "pairs no obligation wants (declared inapplicable): 1\n  C1: inapplicable 1 pair(s), wanted by no obligation, first x=1 y=1: docs:README.md#a, not-promised:no-one\n");
-    }
-
-    private static Dictionary<string, string> R(string x, string y) => new(StringComparer.Ordinal) { ["x"] = x, ["y"] = y };
-
-    /// <summary>P passes rows over the three pairs some obligation wants, never x=1 y=1.</summary>
-    private void RecordTheWantedPairs()
-    {
-        fx.Rows([("1", "2"), ("2", "1"), ("2", "2")]);
-        fx.Commit("claims and rows");
-        fx.Ledger("universe", "--base", "HEAD").Exit.ShouldBe(0);
-        fx.Footprint();
-        fx.Ledger("record-run", "--probe", "P", "--result", "pass", "--evidence", fx.Evidence([R("1", "2"), R("2", "1"), R("2", "2")])).Exit.ShouldBe(0);
-    }
-
-    [Fact]
-    public void Status_reports_the_inapplicable_pairs_and_is_done_once_every_wanted_pair_is_current()
-    {
-        OnePairWantedByNone();
-        RecordTheWantedPairs();
-        var (exit, output, error) = fx.Ledger("status", "--json");
-        exit.ShouldBe(0, error);
-        var status = JsonNode.Parse(output)!;
-        var c1 = status["claims"]!["C1"]!;
-        c1["pairs"]!.GetValue<int>().ShouldBe(4, "the claim's pairs stay its pairs");
-        c1["current"]!.GetValue<int>().ShouldBe(3);
-        c1["inapplicable_pairs"]!.GetValue<int>().ShouldBe(1);
-        status["inapplicable_pairs"]!.GetValue<int>().ShouldBe(1);
-        status["done"]!.GetValue<bool>().ShouldBeTrue("the one pair not current is wanted by no obligation");
-        fx.Ledger("status").Out.ShouldContain("  C1: 3/4, 1 inapplicable");
-    }
-
-    [Fact]
-    public void Status_is_not_done_while_a_wanted_pair_is_not_current()
-    {
-        Claim(Obligation("keys"), Obligation("nulls"));
-        RecordTheWantedPairs();
-        var status = JsonNode.Parse(fx.Ledger("status", "--json").Out)!;
-        status["claims"]!["C1"]!["inapplicable_pairs"]!.GetValue<int>().ShouldBe(0);
-        status["done"]!.GetValue<bool>().ShouldBeFalse("x=1 y=1 is wanted and not current");
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void The_gate_leaves_out_a_pair_wanted_by_no_obligation_as_it_leaves_out_an_exclusion(bool declared)
-    {
-        fx.Sh("git", "tag", "v1");
-        if (declared) OnePairWantedByNone(); else Claim(Obligation("keys"), Obligation("nulls"));
-        RecordTheWantedPairs();
-        fx.Write("README.md", "# a\n\nThe claim.\n\nMore words.\n");
-        fx.Commit("touch the claim");
-
-        var (exit, output, _) = fx.Ledger("gate", "--since", "v1", "--json");
-        var gate = JsonNode.Parse(output)!;
-        gate["touched"]!.AsArray().Select(c => c!.GetValue<string>()).ShouldBe(["C1"]);
-        if (declared)
-        {
-            exit.ShouldBe(0, output);
-            gate["uncovered_pairs"]!.GetValue<int>().ShouldBe(0);
-            gate["inapplicable_pairs"]!.GetValue<int>().ShouldBe(1);
-        }
-        else
-        {
-            exit.ShouldBe(1);
-            gate["reasons"]!.AsArray().Select(r => r!.GetValue<string>()).ShouldContain("C1: 1 of 4 pairs uncovered (touched since v1)");
-        }
-    }
-
-    [Fact]
-    public void Rows_for_a_claim_ask_for_no_pair_no_obligation_wants()
-    {
-        OnePairWantedByNone();
-        fx.Commit("claims");
-        fx.Ledger("universe", "--base", "HEAD").Exit.ShouldBe(0);
-        var rows = JsonNode.Parse(fx.Ledger("rows", "--claim", "C1", "--full").Out)!;
-        rows["rows"]!.AsArray().Select(r => $"{r!["row"]!["x"]} {r["row"]!["y"]}").ShouldNotContain("1 1");
-        rows["uncovered_after"]!.GetValue<int>().ShouldBe(0, "a pair wanted by no obligation is not left uncovered");
-    }
-
-    [Fact]
-    public void A_declaration_changes_the_identity_of_its_claim_s_probes()
-    {
-        Claim(Obligation("keys"), Obligation("nulls"));
-        fx.Commit("claims");
-        var before = fx.Ledger("identity", "--probe", "P").Out;
-        OnePairWantedByNone();
-        fx.Commit("declared");
-        fx.Ledger("identity", "--probe", "P").Out.ShouldNotBe(before, "Row.Check applies the declarations, so a result under others is not this one");
-    }
-
-    [Fact]
-    public void The_overlay_stages_the_claims_beside_the_rows_with_the_staging_s_over_the_corpus_s()
-    {
-        Claim(Obligation("keys"), Obligation("nulls"));
-        fx.Commit("claims");
-        var ledger = new Ledger(new Context(fx.Root, new Dictionary<string, string?>(), TextWriter.Null, TextWriter.Null), "main");
-        var staged = new JsonArray(new JsonObject
-        {
-            ["id"] = "C1", ["source"] = "README.md#a", ["surfaces"] = new JsonArray("s"),
-            ["obligations"] = new JsonArray(Obligation("keys", Declared("docs:README.md#a", ("x", ["1"])))),
-        });
-        fx.Write(Path.GetRelativePath(fx.Root, Path.Combine(ledger.StagingDir, "claims.json")), staged.ToJsonString());
-        var worktree = fx.Root + "-overlay";
-        try
-        {
-            var probeDir = global::Prober.Replay.Overlay(ledger, new JsonObject { ["probeDir"] = "probes" }, worktree);
-            var claims = JsonNode.Parse(File.ReadAllText(Path.Combine(probeDir, "claims.json")))!.AsArray();
-            JsonNode.DeepEquals(claims, staged).ShouldBeTrue(claims.ToJsonString());
-            global::Prober.Replay.Overlay(ledger, new JsonObject { ["probeDir"] = "probes" }, worktree);
-            File.Exists(Path.Combine(probeDir, "claims.json")).ShouldBeTrue("a second overlay keeps it");
-        }
-        finally
-        {
-            try { Directory.Delete(worktree, recursive: true); } catch (IOException) { }
-        }
-    }
-}
-
-/// <summary>The wanted pairs of a claim, computed on the claim itself, and the covering generator over them.</summary>
-public sealed class WantedPairsTests
-{
-    private static Inapplicability Declared(string cite, params (string Axis, string[] Values)[] axes) =>
-        new(axes.ToDictionary(a => a.Axis, a => a.Values.ToList(), StringComparer.Ordinal), cite);
-
-    private static global::Prober.Obligation Obligation(string id, params Inapplicability[] inapplicable) =>
-        new(id, "The claim.", new SortedDictionary<string, List<string>>(StringComparer.Ordinal)) { Inapplicable = inapplicable };
-
-    private static Claim Over(int axes, params global::Prober.Obligation[] obligations) => new()
-    {
-        Id = "C1", Source = "README.md#a", Surfaces = ["s"], Watched = [], Excluded = [], Obligations = obligations,
-        Axes = new(new[] { "x", "y", "z" }.Take(axes).ToDictionary(a => a, _ => new List<string> { "1", "2" }), StringComparer.Ordinal),
-    };
-
-    private static IEnumerable<string> Shown(IEnumerable<Pair> pairs) => pairs.Select(p => p.ToString()).Order(StringComparer.Ordinal);
-
-    [Fact]
-    public void An_obligation_wants_the_pairs_none_of_its_declarations_matches_on_either_side()
-    {
-        // keys: not where x=1 (the first of a pair, ordinally); nulls: not where y=1 (the second); counts: nowhere declared.
-        var claim = Over(2, Obligation("keys", Declared("record:0001", ("x", ["1"]))), Obligation("nulls", Declared("record:0002", ("y", ["1"]))), Obligation("counts"));
-        Shown(claim.PairsWantedBy("keys")).ShouldBe(["x=2 y=1", "x=2 y=2"]);
-        Shown(claim.PairsWantedBy("nulls")).ShouldBe(["x=1 y=2", "x=2 y=2"]);
-        Shown(claim.PairsWantedBy("counts")).ShouldBe(["x=1 y=1", "x=1 y=2", "x=2 y=1", "x=2 y=2"]);
-        claim.Pairs().Count.ShouldBe(4, "the claim's pairs stay its pairs");
-        claim.DeclaredInapplicable().ShouldBeEmpty("counts wants every pair");
-    }
-
-    [Fact]
-    public void A_pair_no_obligation_wants_is_declared_inapplicable_with_the_citations_that_match_it()
-    {
-        // keys wants x=2 y=1 alone, nulls x=1 y=2 alone.
-        var claim = Over(2,
-            Obligation("keys", Declared("record:0001", ("x", ["1"])), Declared("record:0003", ("y", ["2"]))),
-            Obligation("nulls", Declared("record:0002", ("y", ["1"])), Declared("record:0004", ("x", ["2"]))));
-        Shown(claim.PairsWanted()).ShouldBe(["x=1 y=2", "x=2 y=1"]);
-        var dead = claim.DeclaredInapplicable();
-        Shown(dead.Keys).ShouldBe(["x=1 y=1", "x=2 y=2"]);
-        dead[new Pair("x=1", "y=1")].ShouldBe(["record:0001", "record:0002"]);
-        dead[new Pair("x=2", "y=2")].ShouldBe(["record:0003", "record:0004"]);
-    }
-
-    [Fact]
-    public void A_declaration_over_two_axes_matches_only_the_pair_holding_both()
-    {
-        var claim = Over(3, Obligation("keys", Declared("record:0001", ("x", ["1"]), ("y", ["1"]))));
-        Shown(claim.DeclaredInapplicable().Keys).ShouldBe(["x=1 y=1"], "x=1 with z, or y=1 with z, is in rows where the other axis is 2");
-    }
-
-    [Fact]
-    public void The_covering_rows_never_hold_a_pair_no_obligation_wants_and_count_each_wanted_pair_once()
-    {
-        // Both obligations want the same eleven pairs: none of x=1 with y=1.
-        var claim = Over(3, Obligation("keys", Declared("record:0001", ("x", ["1"]), ("y", ["1"]))), Obligation("nulls", Declared("record:0002", ("x", ["1"]), ("y", ["1"]))));
-        for (var seed = 1; seed <= 20; seed++)
-        {
-            var rows = Covering.Rows(claim, claim.Pairs(), 2000, seed);
-            rows.ShouldNotContain(r => r.Row["x"] == "1" && r.Row["y"] == "1", $"seed {seed}");
-            var gained = rows.SelectMany(r => r.Pairs).ToList();
-            gained.Count.ShouldBe(11, $"seed {seed}: each wanted pair once");
-            Shown(gained).ShouldBe(Shown(claim.PairsWanted()), $"seed {seed}");
-        }
-    }
-
-    [Fact]
-    public void A_seeded_row_fills_each_other_axis_with_a_value_that_puts_no_unwanted_pair_in_it()
-    {
-        var claim = Over(3, Obligation("keys", Declared("record:0001", ("x", ["1"]), ("z", ["1"]))));
-        var row = Covering.Seeded(claim, new Pair("y=1", "z=1"), claim.DeclaredInapplicable());
-        row.ShouldBe(new SortedDictionary<string, string>(StringComparer.Ordinal) { ["x"] = "2", ["y"] = "1", ["z"] = "1" });
-    }
-
-    [Theory]
-    [InlineData("not-promised:closed-set-has-no-text")]
-    [InlineData("not-promised:Closed")]
-    [InlineData("docs:docs/json.md#decimals-in-one-spelling")]
-    [InlineData("docs:README.md")]
-    [InlineData("docs:README.md#What TypeKit guarantees")]
-    [InlineData("docs:/etc/passwd.md")]
-    [InlineData("docs:../README.md#a")]
-    [InlineData("fact:KB-031")]
-    [InlineData("fact:KB-31")]
-    [InlineData("record:0094")]
-    [InlineData("record:94")]
-    [InlineData("README.md#a")]
-    [InlineData("note:x")]
-    public void A_cite_the_universe_accepts_is_one_the_harness_can_cite(string cite)
-    {
-        var harness = Record.Exception(() => Cite.Parse(cite)) is null;
-        (Axes.CiteProblem(cite) is null).ShouldBe(harness, harness ? "the harness cites it" : "the harness refuses it");
-    }
-}
-
-/// <summary>
-/// The harness applies the claim's declarations before a check's body runs: where one matches the row's values the
-/// check is inapplicable with the declaration's citation, for that check only, and the body does not run. Without a
-/// staged claims file, as for a probe these tests run in-process, no claim declares anything.
-/// </summary>
-[Collection(nameof(ProbeOut))]
-public sealed class DeclaredCheckTests : IDisposable
-{
-    private readonly string dir = Path.Combine(Path.GetTempPath(), "prober-tests", Guid.NewGuid().ToString("N"));
-    private readonly string? before = Rows.ClaimsFile;
-
-    public DeclaredCheckTests()
-    {
-        Directory.CreateDirectory(dir);
-        File.WriteAllText(Path.Combine(dir, "claims.json"), new JsonArray(new JsonObject
-        {
-            ["id"] = "C1", ["source"] = "README.md#a", ["surfaces"] = new JsonArray("s"),
-            ["obligations"] = new JsonArray(
-                new JsonObject
-                {
-                    ["id"] = "keys", ["sentence"] = "The claim.",
-                    ["inapplicable"] = new JsonArray(
-                        new JsonObject { ["axes"] = new JsonObject { ["x"] = new JsonArray("1"), ["y"] = new JsonArray("2") }, ["cite"] = "not-promised:no-key-here" },
-                        new JsonObject { ["axes"] = new JsonObject { ["y"] = new JsonArray("3") }, ["cite"] = "fact:KB-031" }),
-                },
-                new JsonObject { ["id"] = "nulls", ["sentence"] = "The claim." }),
-        }).ToJsonString());
-        Rows.ClaimsFile = Path.Combine(dir, "claims.json");
-    }
-
-    public void Dispose()
-    {
-        Rows.ClaimsFile = before;
-        try { Directory.Delete(dir, recursive: true); } catch (IOException) { } catch (UnauthorizedAccessException) { }
-    }
-
-    /// <summary>Runs one row of C1 through <c>Rec.Run</c> with a check of keys and one of nulls, synchronous or not; which bodies ran, and the line written.</summary>
-    private (List<string> Ran, Exception? Ended, JsonObject Line) Run(string x, string y, bool async = false, string? claim = "C1")
-    {
-        var ran = new List<string>();
-        var outDir = Path.Combine(dir, "out");
-        var previous = Environment.GetEnvironmentVariable("PROBE_OUT");
-        Environment.SetEnvironmentVariable("PROBE_OUT", outDir);
-        Exception? ended = null;
-        try
-        {
-            Rec.Run("P", new Row(0, new Dictionary<string, string> { ["x"] = x, ["y"] = y }, claim), async r =>
-            {
-                foreach (var obligation in new[] { "keys", "nulls" })
-                    _ = async
-                        ? await r.Check(obligation, Baseline.Twin, c => { ran.Add(obligation); return Task.FromResult<string?>(c["x"] == "0" ? "differs" : null); })
-                        : r.Check(obligation, Baseline.Twin, c => { ran.Add(obligation); return c["x"] == "0" ? "differs" : null; });
-                return null;
-            }).GetAwaiter().GetResult();
-        }
-        catch (Exception e) { ended = e; }
-        finally { Environment.SetEnvironmentVariable("PROBE_OUT", previous); }
-        var line = File.ReadAllLines(Path.Combine(outDir, "P.jsonl")).Select(l => JsonNode.Parse(l)!.AsObject()).Last();
-        File.Delete(Path.Combine(outDir, "P.jsonl"));
-        return (ran, ended, line);
-    }
-
-    [Theory]
-    [InlineData(false)]
-    [InlineData(true)]
-    public void A_check_its_claim_declares_inapplicable_for_the_row_s_values_does_not_run_and_records_the_cite(bool async)
-    {
-        var (ran, ended, line) = Run("1", "2", async);
-        ran.ShouldBe(["nulls"], "keys does not apply where x=1 and y=2");
-        ended.ShouldBeNull("nulls compared and passed; keys did not apply, which voids nothing");
-        var keys = HarnessRun.Check(line, "keys");
-        Files.Str(keys["category"]).ShouldBe("inapplicable");
-        Files.Strings(keys["reasons"]).ShouldBe(["inapplicable:not-promised:no-key-here(declared x=1 y=2)"]);
-        Files.StringMap(keys["applied"]).ShouldBe(new Dictionary<string, string> { ["x"] = "1", ["y"] = "2" }, "the axes the declaration matched");
-        Files.Str(HarnessRun.Check(line, "nulls")["category"]).ShouldBe("pass", "the declaration is keys', for that check only");
-    }
-
-    [Fact]
-    public void Each_declaration_of_the_obligation_is_applied_and_one_over_two_axes_needs_both()
-    {
-        Run("1", "1").Ran.ShouldBe(["keys", "nulls"], "x=1 with y=1 is not x=1 with y=2");
-        Run("2", "2").Ran.ShouldBe(["keys", "nulls"], "x=2 with y=2 is not x=1 with y=2");
-        var (ran, _, line) = Run("2", "3");
-        ran.ShouldBe(["nulls"]);
-        Files.Strings(HarnessRun.Check(line, "keys")["reasons"]).ShouldBe(["inapplicable:fact:KB-031(declared y=3)"]);
-    }
-
-    [Fact]
-    public void A_row_in_hand_without_a_claim_or_without_a_staged_claims_file_sees_no_declarations()
-    {
-        Run("1", "2", claim: null).Ran.ShouldBe(["keys", "nulls"]);
-        Rows.ClaimsFile = null;
-        Run("1", "2").Ran.ShouldBe(["keys", "nulls"]);
-        Rows.ClaimsFile = Path.Combine(dir, "none.json");
-        Run("1", "2").Ran.ShouldBe(["keys", "nulls"]);
-    }
-
-    [Fact]
-    public void A_copy_of_a_row_keeps_its_claim()
-    {
-        var row = new Row(0, new Dictionary<string, string> { ["x"] = "1", ["y"] = "2" }, "C1");
-        row.Fresh().Claim.ShouldBe("C1");
-        row.With("y", "1").Claim.ShouldBe("C1");
-    }
-
-    [Fact]
-    public void A_row_of_a_rows_file_holds_the_file_s_claim()
-    {
-        var path = Path.Combine(dir, "P.json");
-        File.WriteAllText(path, """{"claim": "C1", "rows": [{"row": {"x": "1", "y": "2"}}]}""");
-        Rows.Read(path).ShouldHaveSingleItem().Claim.ShouldBe("C1");
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/DotnetTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/DotnetTests.cs
deleted file mode 100644
index 40c07acf..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/DotnetTests.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>
-/// Which dotnet a tool starts (tools/Shared/Dotnet.cs, design/adr/0105): the one on PATH when it satisfies
-/// global.json, the SDK installer's when only that one does, and otherwise the one on PATH, whose own error then
-/// reaches whoever reads the output.
-/// </summary>
-public sealed class DotnetTests : IDisposable
-{
-    private readonly string installer = Directory.CreateTempSubdirectory("dotnet-installer-").FullName;
-    public void Dispose() => Directory.Delete(installer, recursive: true);
-
-    private string Executable => Path.Combine(installer, OperatingSystem.IsWindows() ? "dotnet.exe" : "dotnet");
-
-    private void Install() => File.WriteAllText(Executable, "");
-
-    [Fact]
-    public void The_one_on_path_when_it_satisfies_the_pin()
-    {
-        Install();
-        var asked = new List<string>();
-        Dotnet.Choose(installer, d => { asked.Add(d); return true; }).ShouldBe(("dotnet", null));
-        asked.ShouldBe(["dotnet"], "the installer's is not even asked");
-    }
-
-    [Fact]
-    public void The_installers_when_only_it_satisfies_the_pin()
-    {
-        Install();
-        Dotnet.Choose(installer, d => d != "dotnet").ShouldBe((Executable, installer));
-    }
-
-    [Fact]
-    public void The_one_on_path_when_neither_does()
-    {
-        Install();
-        Dotnet.Choose(installer, _ => false).ShouldBe(("dotnet", null));
-    }
-
-    [Fact]
-    public void The_one_on_path_when_the_installer_put_none()
-    {
-        var asked = new List<string>();
-        Dotnet.Choose(installer, d => { asked.Add(d); return d != "dotnet"; }).ShouldBe(("dotnet", null));
-        asked.ShouldBe(["dotnet"]);
-    }
-
-    [Fact]
-    public void A_dotnet_satisfies_a_directory_whose_pin_it_has_and_not_one_whose_pin_it_lacks()
-    {
-        Dotnet.Satisfies("dotnet", installer).ShouldBeTrue("no global.json: any SDK");
-        File.WriteAllText(Path.Combine(installer, "global.json"), """{"sdk": {"version": "0.0.1", "rollForward": "disable"}}""");
-        Dotnet.Satisfies("dotnet", installer).ShouldBeFalse("an SDK no dotnet has");
-    }
-
-    [Fact]
-    public void A_program_that_does_not_start_satisfies_nothing() =>
-        Dotnet.Satisfies(Path.Combine(installer, "no-such-dotnet"), installer).ShouldBeFalse();
-
-    [Fact]
-    public void A_child_is_pointed_at_the_chosen_directory()
-    {
-        var environment = new Dictionary<string, string?> { ["PATH"] = "/usr/bin" };
-        Dotnet.Apply(installer, environment);
-        environment["PATH"].ShouldBe(installer + Path.PathSeparator + "/usr/bin");
-        environment["DOTNET_ROOT"].ShouldBe(installer);
-
-        var untouched = new Dictionary<string, string?> { ["PATH"] = "/usr/bin" };
-        Dotnet.Apply(null, untouched);
-        untouched.Keys.ShouldBe(["PATH"]);
-        untouched["PATH"].ShouldBe("/usr/bin");
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/FixTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/FixTests.cs
deleted file mode 100644
index 38cf460c..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/FixTests.cs
+++ /dev/null
@@ -1,90 +0,0 @@
-using System.Text.Json.Nodes;
-using Prober;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>
-/// <c>prober fix F --commit SHA</c> writes the fixed line of findings.jsonl as finding-line.schema.json wants it, where a
-/// fixed finding was a line written by hand (F3, #45): the open line's claim and probe, the commit's full id.
-/// </summary>
-public sealed class FixTests : IDisposable
-{
-    private readonly Fixture fx = new();
-    public void Dispose() => fx.Dispose();
-
-    private string Findings => Path.Combine(fx.BranchDir, "findings.jsonl");
-
-    private void Open(string id) =>
-        File.AppendAllText(Findings, new JsonObject
-        {
-            ["schemaVersion"] = 1, ["id"] = id, ["claim"] = "C1", ["status"] = "open", ["probe"] = "P", ["reason"] = "row 3 differs",
-        }.ToJsonString() + "\n");
-
-    private JsonObject Last() => JsonNode.Parse(File.ReadAllLines(Findings)[^1])!.AsObject();
-
-    private Ledger Ledger() => new(new Context(fx.Root, new Dictionary<string, string?>(), TextWriter.Null, TextWriter.Null), null);
-
-    [Fact]
-    public void It_writes_the_fixed_line_with_the_open_lines_claim_and_probe_and_the_full_commit()
-    {
-        Open("F9");
-        var head = fx.Sh("git", "rev-parse", "HEAD").Trim();
-        var (exit, output, error) = fx.Ledger("fix", "F9", "--commit", head[..7], "--reason", "fixed by the converter's null");
-        exit.ShouldBe(0, error);
-        output.ShouldBe($"F9 fixed at {head[..7]}{Environment.NewLine}");
-        var line = Last();
-        line.Select(kv => kv.Key).ShouldBe(["schemaVersion", "id", "claim", "status", "commit", "probe", "reason"]);
-        line["schemaVersion"]!.GetValue<int>().ShouldBe(1);
-        line["id"]!.GetValue<string>().ShouldBe("F9");
-        line["claim"]!.GetValue<string>().ShouldBe("C1");
-        line["status"]!.GetValue<string>().ShouldBe("fixed");
-        line["commit"]!.GetValue<string>().ShouldBe(head);
-        line["probe"]!.GetValue<string>().ShouldBe("P");
-        line["reason"]!.GetValue<string>().ShouldBe("fixed by the converter's null");
-        Ledger().OpenFindings().ShouldBeEmpty();
-        Ledger().Findings()["F9"]["status"]!.GetValue<string>().ShouldBe("fixed");
-    }
-
-    [Fact]
-    public void A_commit_outside_heads_history_is_recorded_and_counts_once_it_is_in_it()
-    {
-        Open("F9");
-        fx.Sh("git", "checkout", "-q", "-b", "fix");
-        fx.Write("src/a.cs", "class A { }\n");
-        fx.Sh("git", "-c", "user.name=t", "-c", "user.email=t@t", "commit", "-qam", "the fix");   // the state stays untracked
-        var fix = fx.Sh("git", "rev-parse", "HEAD").Trim();
-        fx.Sh("git", "checkout", "-q", "main");
-        var (exit, output, error) = fx.Ledger("fix", "F9", "--commit", fix);
-        exit.ShouldBe(0, error);
-        output.ShouldContain($"F9 fixed at {fix[..7]}; it counts once that commit is in HEAD's history");
-        Ledger().OpenFindings().ShouldBe(["F9"]);
-        fx.Sh("git", "merge", "-q", "--ff-only", "fix");
-        Ledger().OpenFindings().ShouldBeEmpty();
-    }
-
-    [Theory]
-    [InlineData("F8", "HEAD", 1, "F8 is no finding of this ledger")]
-    [InlineData("F9", "0123456789abcdef0123456789abcdef01234567", 1, "--commit 0123456789abcdef0123456789abcdef01234567 is no commit of this repository")]
-    [InlineData("F9", "", 2, "--commit is required")]
-    public void It_refuses_a_finding_the_ledger_does_not_hold_and_a_commit_the_repository_lacks(string id, string commit, int code, string message)
-    {
-        Open("F9");
-        var before = File.ReadAllText(Findings);
-        var (exit, _, error) = commit.Length > 0 ? fx.Ledger("fix", id, "--commit", commit) : fx.Ledger("fix", id);
-        exit.ShouldBe(code);
-        error.ShouldContain(message);
-        File.ReadAllText(Findings).ShouldBe(before);
-    }
-
-    [Fact]
-    public void It_refuses_a_finding_already_fixed_and_a_call_without_one_id()
-    {
-        Open("F9");
-        fx.Ledger("fix", "F9", "--commit", "HEAD").Exit.ShouldBe(0);
-        var (exit, _, error) = fx.Ledger("fix", "F9", "--commit", "HEAD");
-        exit.ShouldBe(1);
-        error.ShouldContain("F9 is fixed, not open");
-        fx.Ledger("fix", "--commit", "HEAD").Exit.ShouldBe(2);
-        fx.Ledger("fix", "F9", "F10", "--commit", "HEAD").Exit.ShouldBe(2);
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/Fixture.cs b/test/CodoMetis.TypeKit.Prober.Tests/Fixture.cs
deleted file mode 100644
index b388e557..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/Fixture.cs
+++ /dev/null
@@ -1,167 +0,0 @@
-using System.Diagnostics;
-using System.Text.Json.Nodes;
-using Prober;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>A repository with one claim C1 over axes x and y (values 1 and 2) and one probe P covering it.</summary>
-internal sealed class Fixture : IDisposable
-{
-    public Fixture()
-    {
-        Root = Path.Combine(Path.GetTempPath(), "prober-tests", Guid.NewGuid().ToString("N"));
-        Directory.CreateDirectory(Root);
-        Memory = Path.Combine(Root, ".claude", "agent-memory-local", "prober");
-        BranchDir = Path.Combine(Memory, "branches", "main");
-        Sh("git", "init", "-q", "-b", "main");
-        Write("README.md", "# a\n\nThe claim.\n");
-        Write("src/a.cs", "class A {}\n");
-        Write(".claude/probe-axes.md", "```json probe-axes\n" + new JsonObject
-        {
-            ["axes"] = new JsonObject { ["x"] = new JsonArray("1", "2"), ["y"] = new JsonArray("1", "2") },
-            ["surfaces"] = new JsonObject { ["s"] = new JsonObject { ["axes"] = new JsonArray("x", "y"), ["watched"] = new JsonArray("src") } },
-        }.ToJsonString() + "\n```\n");
-        Write("tools/probe/corpus/claims.json", """[{"id": "C1", "source": "README.md#a", "surfaces": ["s"]}]""");
-        Write("tools/probe/corpus/registry.json", """{"probes": {"P": {"claim": "C1", "filter": "*P"}}}""");
-        Write("tools/probe/corpus/harness/P.cs", "// probe P\n");
-        Rows([("1", "1"), ("2", "2")]);
-        Commit("init");
-        Directory.CreateDirectory(BranchDir);
-        File.WriteAllText(Path.Combine(Memory, "axes-generated.json"), """{"axes": {}, "needsValues": []}""");
-        Ledger("universe", "--base", "HEAD").Exit.ShouldBe(0);
-    }
-
-    public string Root { get; }
-    public string Memory { get; }
-    public string BranchDir { get; }
-
-    public void Write(string relative, string text)
-    {
-        var path = Path.Combine(Root, relative);
-        Directory.CreateDirectory(Path.GetDirectoryName(path)!);
-        File.WriteAllText(path, text);
-    }
-
-    /// <summary>P's rows: each probe has a rows file of its own, its claim inside.</summary>
-    public void Rows(IEnumerable<(string X, string Y)> rows) =>
-        Write("tools/probe/corpus/rows/P.json", new JsonObject
-        {
-            ["claim"] = "C1",
-            ["rows"] = new JsonArray([.. rows.Select(r => (JsonNode)new JsonObject { ["row"] = new JsonObject { ["x"] = r.X, ["y"] = r.Y } })]),
-        }.ToJsonString());
-
-    public void Commit(string message)
-    {
-        Sh("git", "add", "-A");
-        Sh("git", "-c", "user.name=t", "-c", "user.email=t@t", "commit", "-qm", message);
-    }
-
-    public string Sh(string file, params string[] args)
-    {
-        var start = new ProcessStartInfo(file) { WorkingDirectory = Root, RedirectStandardOutput = true, RedirectStandardError = true };
-        foreach (var a in args) start.ArgumentList.Add(a);
-        using var p = Process.Start(start)!;
-        var output = p.StandardOutput.ReadToEnd(); var error = p.StandardError.ReadToEnd();
-        p.WaitForExit();
-        p.ExitCode.ShouldBe(0, $"{file} {string.Join(' ', args)}: {output}{error}");
-        return output;
-    }
-
-    /// <summary>Runs a prober command in-process, in this repository, with the environment given.</summary>
-    public (int Exit, string Out, string Err) Ledger(params string[] args) => LedgerWith(new Dictionary<string, string?>(), args);
-
-    public (int Exit, string Out, string Err) LedgerWith(Dictionary<string, string?> env, params string[] args) => LedgerEnding(env, Environment.NewLine, args);
-
-    /// <summary>As <see cref="LedgerWith"/>, with the line end the output writers use, so a test sees Windows' output on any OS.</summary>
-    public (int Exit, string Out, string Err) LedgerEnding(Dictionary<string, string?> env, string newLine, params string[] args)
-    {
-        var output = new StringWriter { NewLine = newLine }; var error = new StringWriter { NewLine = newLine };
-        var exit = Program.Run(new Context(Root, env, output, error), args);
-        return (exit, output.ToString(), error.ToString());
-    }
-
-    /// <summary>Runs a prober command in-process in another checkout of this repository (a linked worktree).</summary>
-    public (int Exit, string Out, string Err) LedgerIn(string checkout, params string[] args)
-    {
-        var output = new StringWriter(); var error = new StringWriter();
-        var exit = Program.Run(new Context(checkout, new Dictionary<string, string?>(), output, error), args);
-        return (exit, output.ToString(), error.ToString());
-    }
-
-    /// <summary>A linked worktree of this repository (<c>git worktree add</c>) on a new branch, beside it; removed with the fixture.</summary>
-    public string Linked(string branch)
-    {
-        var path = Root + "-" + branch;
-        Sh("git", "worktree", "add", "-q", "-b", branch, path);
-        linked.Add(path);
-        return path;
-    }
-
-    private readonly List<string> linked = [];
-
-    /// <summary>The lock file of a branch's state, wherever the tool puts it.</summary>
-    public string LockFile(string branch = "main") =>
-        RoundLock.LockPath(new Ledger(new Context(Root, new Dictionary<string, string?>(), TextWriter.Null, TextWriter.Null), branch));
-
-    /// <summary>Runs the built dll as its own process: for the tests that race several takers.</summary>
-    public Process Spawn(params string[] args)
-    {
-        var start = new ProcessStartInfo("dotnet") { WorkingDirectory = Root, RedirectStandardOutput = true, RedirectStandardError = true };
-        start.ArgumentList.Add(typeof(Program).Assembly.Location);
-        foreach (var a in args) start.ArgumentList.Add(a);
-        return Process.Start(start)!;
-    }
-
-    public void Footprint()
-    {
-        var blob = Sh("git", "rev-parse", "HEAD:src/a.cs").Trim();
-        File.AppendAllText(Path.Combine(BranchDir, "footprints.jsonl"),
-            new JsonObject { ["probe"] = "P", ["footprint"] = new JsonObject { ["src/a.cs"] = blob }, ["compileTime"] = new JsonObject(), ["toolchain"] = new JsonObject() }.ToJsonString() + "\n");
-    }
-
-    /// <summary>
-    /// What a replay of P records: the rows it ran, how each ended and the settings that applied; outcomes, when
-    /// given, sets each row's category and the finding it skips for.
-    /// </summary>
-    public string Evidence(IReadOnlyList<Dictionary<string, string>> applied, string category = "pass", int[]? executed = null,
-                           IReadOnlyList<(string Category, string? Finding)>? outcomes = null)
-    {
-        var idx = Enumerable.Range(0, applied.Count).ToArray();
-        var path = Path.Combine(Root, "evidence.json");
-        File.WriteAllText(path, new JsonObject
-        {
-            ["variants"] = new JsonArray(new JsonObject
-            {
-                ["env"] = new JsonObject(), ["expected"] = new JsonArray([.. idx.Select(i => (JsonNode)i)]),
-                ["executed"] = new JsonArray([.. (executed ?? idx).Select(i => (JsonNode)i)]),
-            }),
-            ["rows"] = new JsonObject(idx.Select(i => KeyValuePair.Create(i.ToString(System.Globalization.CultureInfo.InvariantCulture), (JsonNode?)new JsonObject
-            {
-                ["category"] = outcomes?[i].Category ?? category, ["applied"] = new JsonObject(applied[i].Select(kv => KeyValuePair.Create(kv.Key, (JsonNode?)kv.Value))),
-                ["findings"] = outcomes?[i].Finding is { } finding ? new JsonArray(finding) : new JsonArray(),
-            }))),
-        }.ToJsonString());
-        return path;
-    }
-
-    public int Covered()
-    {
-        var (exit, output, error) = Ledger("status", "--json");
-        exit.ShouldBe(0, error);
-        return (int)JsonNode.Parse(output)!["claims"]!["C1"]!["current"]!.GetValue<double>();
-    }
-
-    public void AgeTheLock()
-    {
-        var path = LockFile();
-        var held = JsonNode.Parse(File.ReadAllText(path))!.AsObject();
-        held["heartbeat"] = held["heartbeat"]!.GetValue<double>() - 21 * 60;
-        File.WriteAllText(path, held.ToJsonString());
-    }
-
-    public void Dispose()
-    {
-        foreach (var dir in linked.Append(Root))
-            try { Directory.Delete(dir, recursive: true); } catch (IOException) { } catch (UnauthorizedAccessException) { }
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/FreshnessTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/FreshnessTests.cs
deleted file mode 100644
index c71a4a7a..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/FreshnessTests.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>
-/// The dll refuses to answer from other sources than the ones it was built from, its schemas among them,
-/// as every tool does (tools/Directory.Build.targets, tools/Shared/SourceFingerprint.cs).
-/// </summary>
-public sealed class FreshnessTests
-{
-    [Fact]
-    public void The_stamp_covers_the_schemas() =>
-        SourceFingerprint.Embedded.ShouldContain(line => line.StartsWith("tools/Prober/Schemas/", StringComparison.Ordinal) && line.Contains(".json|", StringComparison.Ordinal));
-
-    [Theory]
-    [InlineData("tools/Prober/Program.cs")]
-    [InlineData("tools/Prober/Schemas/round.schema.json")]
-    public void A_stale_dll_refuses_and_names_the_rebuild(string source)
-    {
-        using var sandbox = new ToolSandbox("Prober", "prober");
-        File.AppendAllText(Path.Combine(sandbox.Repo, source), "\n");
-
-        var (code, _, error) = sandbox.Run(arguments: ["status"]);
-
-        code.ShouldBe(3);
-        error.ShouldContain($"({source} differs)");
-        error.ShouldContain("Run `dotnet build tools/Prober -c ");
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/GapsTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/GapsTests.cs
deleted file mode 100644
index d9db71e3..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/GapsTests.cs
+++ /dev/null
@@ -1,160 +0,0 @@
-using System.Text.Json.Nodes;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>
-/// `prober gaps` prints what the corpus leaves out, each under its heading with its recorded reason, and says
-/// none under a heading with nothing: a report from the tracked corpus and the generated axes that decides
-/// nothing (decision 104).
-/// </summary>
-public sealed class GapsTests : IDisposable
-{
-    private readonly Fixture fx = new();
-    public void Dispose() => fx.Dispose();
-
-    /// <summary>The output after its first line, which names the branch and the commit.</summary>
-    private string Gaps(string newLine)
-    {
-        var (exit, output, error) = fx.LedgerEnding([], newLine, "gaps", "--base", "HEAD");
-        exit.ShouldBe(0, "a report decides nothing: " + error);
-        var text = output.ReplaceLineEndings("\n");
-        text.ShouldStartWith("prober gaps: main at ");
-        return text[(text.IndexOf('\n', StringComparison.Ordinal) + 1)..];
-    }
-
-    [Theory]
-    [InlineData("\n")]
-    [InlineData("\r\n")]
-    public void Each_gap_is_listed_under_its_heading_with_its_reason(string newLine)
-    {
-        fx.Write("design/adr/0001-limits.md", "# 1. Limits\n\nAn ordering of keys is not promised.\n\nNo culture but the invariant one is promised.\n");
-        fx.Write(".claude/probe-axes.md", "```json probe-axes\n" + new JsonObject
-        {
-            ["axes"] = new JsonObject
-            {
-                ["x"] = new JsonArray("1", "2", "3"), ["y"] = new JsonArray("1", "2"),
-                ["shape.refused-kind"] = new JsonArray("in-generic-type"),
-            },
-            ["surfaces"] = new JsonObject { ["s"] = new JsonObject { ["axes"] = new JsonArray("x", "y"), ["watched"] = new JsonArray("src") } },
-            ["refused"] = new JsonObject { ["x"] = new JsonObject { ["3"] = "the framework refuses 3 on its own (KB-001)" } },
-            ["out-of-reach"] = new JsonObject { ["postgresql"] = "needs a server" },
-        }.ToJsonString() + "\n```\n");
-        File.WriteAllText(Path.Combine(fx.Memory, "axes-generated.json"), new JsonObject
-        {
-            ["axes"] = new JsonObject { ["json.z"] = new JsonArray("true", "false") },
-            ["needsValues"] = new JsonArray("json.w"),
-            ["versions"] = new JsonObject { ["System.Text.Json"] = "10.0.0" },
-        }.ToJsonString());
-        fx.Write("tools/probe/corpus/claims.json", new JsonArray(new JsonObject
-        {
-            ["id"] = "C1", ["source"] = "README.md#a", ["surfaces"] = new JsonArray("s"),
-            ["narrow"] = new JsonObject { ["y"] = "The claim." },
-            ["not-promised"] = new JsonArray(
-                new JsonObject
-                {
-                    ["id"] = "order", ["source"] = "design/adr/0001-limits.md#1-limits", ["sentence"] = "An ordering of keys is not promised.",
-                    ["axes"] = new JsonObject { ["x"] = new JsonArray("1", "2") },
-                },
-                new JsonObject { ["id"] = "culture", ["source"] = "design/adr/0001-limits.md#1-limits", ["sentence"] = "No culture but the invariant one is promised." }),
-        }).ToJsonString());
-
-        Gaps(newLine).ShouldBe("""
-            settings no surface reaches and nothing ignores (enumerated at System.Text.Json 10.0.0): 1
-              json.z (no surface reaches it and it is not ignored)
-            settings without values: 1
-              json.w (no hand values and not ignored)
-            declarations the generators refuse (shape.refused-kind): 1
-              in-generic-type
-            values the frameworks refuse on their own: 1
-              x=3: the framework refuses 3 on its own (KB-001)
-            not promised, by what it concerns: 3
-              the whole claim: C1/culture "No culture but the invariant one is promised." (design/adr/0001-limits.md#1-limits)
-              x=1|2: C1/order "An ordering of keys is not promised." (design/adr/0001-limits.md#1-limits)
-              y: C1 narrows it, "The claim." (README.md#a)
-            pairs no obligation wants (declared inapplicable): none
-            pairs no passing check read both axes of (the last replay's evidence): none
-            out of reach: 1
-              postgresql: needs a server
-
-            """.ReplaceLineEndings("\n"));
-    }
-
-    [Theory]
-    [InlineData("\n")]
-    [InlineData("\r\n")]
-    public void A_corpus_without_gaps_says_none_under_each_heading(string newLine) =>
-        Gaps(newLine).ShouldBe("""
-            settings no surface reaches and nothing ignores: none
-            settings without values: none
-            declarations the generators refuse (shape.refused-kind): none
-            values the frameworks refuse on their own: none
-            not promised, by what it concerns: none
-            pairs no obligation wants (declared inapplicable): none
-            pairs no passing check read both axes of (the last replay's evidence): none
-            out of reach: none
-
-            """.ReplaceLineEndings("\n"));
-
-    /// <summary>
-    /// C1 over x, y and z: shape wants every pair and its passing checks read x and y; parse does not apply where x=1 and
-    /// z=1 and its passing checks read x and z. x=1 z=1 is wanted by shape alone, which never read z, and no passing check
-    /// read y with z: those five pairs are listed. A check that did not pass reads nothing for the listing.
-    /// </summary>
-    [Fact]
-    public void The_pairs_no_obligation_wanting_them_read_both_axes_of_are_listed()
-    {
-        fx.Write(".claude/probe-axes.md", "```json probe-axes\n" + new JsonObject
-        {
-            ["axes"] = new JsonObject { ["x"] = new JsonArray("1", "2"), ["y"] = new JsonArray("1", "2"), ["z"] = new JsonArray("1", "2") },
-            ["surfaces"] = new JsonObject { ["s"] = new JsonObject { ["axes"] = new JsonArray("x", "y", "z"), ["watched"] = new JsonArray("src") } },
-        }.ToJsonString() + "\n```\n");
-        fx.Write("tools/probe/corpus/claims.json", new JsonArray(new JsonObject
-        {
-            ["id"] = "C1", ["source"] = "README.md#a", ["surfaces"] = new JsonArray("s"),
-            ["obligations"] = new JsonArray(
-                new JsonObject { ["id"] = "shape", ["sentence"] = "The claim." },
-                new JsonObject
-                {
-                    ["id"] = "parse", ["sentence"] = "The claim.",
-                    ["inapplicable"] = new JsonArray(new JsonObject { ["axes"] = new JsonObject { ["x"] = new JsonArray("1"), ["z"] = new JsonArray("1") }, ["cite"] = "docs:README.md#a" }),
-                }),
-        }).ToJsonString());
-        fx.Commit("three axes");
-        fx.Ledger("universe", "--base", "HEAD").Exit.ShouldBe(0);
-        Gaps("\n").ShouldContain("pairs no passing check read both axes of (the last replay's evidence): none\n", Case.Sensitive, "no evidence yet: nothing to say");
-
-        static JsonObject Check(string obligation, string category, params (string Axis, string Value)[] read) => new()
-        {
-            ["obligation"] = obligation, ["category"] = category, ["baseline"] = "twin",
-            ["applied"] = new JsonObject(read.Select(r => KeyValuePair.Create(r.Axis, (JsonNode?)r.Value))),
-        };
-        var evidence = Path.Combine(fx.Root, "evidence.json");
-        File.WriteAllText(evidence, new JsonObject
-        {
-            ["variants"] = new JsonArray(new JsonObject { ["env"] = new JsonObject(), ["expected"] = new JsonArray(0), ["executed"] = new JsonArray(0) }),
-            ["rows"] = new JsonObject
-            {
-                ["0"] = new JsonObject
-                {
-                    ["category"] = "pass", ["applied"] = new JsonObject(), ["findings"] = new JsonArray(),
-                    ["checks"] = new JsonArray(
-                        Check("shape", "pass", ("x", "1"), ("y", "1")),
-                        Check("parse", "pass", ("x", "2"), ("z", "1")),
-                        Check("parse", "inapplicable", ("y", "2"), ("z", "2"))),
-                },
-            },
-        }.ToJsonString());
-        fx.Footprint();
-        fx.Ledger("record-run", "--probe", "P", "--result", "pass", "--evidence", evidence).Exit.ShouldBe(0);
-
-        Gaps("\n").ShouldContain("""
-            pairs no passing check read both axes of (the last replay's evidence): 5
-              C1: x=1 z=1
-              C1: y=1 z=1
-              C1: y=1 z=2
-              C1: y=2 z=1
-              C1: y=2 z=2
-
-            """.ReplaceLineEndings("\n"));
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/HarnessErrorTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/HarnessErrorTests.cs
deleted file mode 100644
index be0ec024..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/HarnessErrorTests.cs
+++ /dev/null
@@ -1,141 +0,0 @@
-using System.Text.Json.Nodes;
-using Prober;
-using Probes.Shapes;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>The harness writes rows to the process's PROBE_OUT, so its tests run one at a time.</summary>
-[CollectionDefinition(nameof(ProbeOut), DisableParallelization = true)]
-public sealed class ProbeOut;
-
-/// <summary>
-/// A harness error is never a catch (decision 103): the probe corpus's own <c>Rec.Run</c> (harness/Row.cs,
-/// compiled in) ends a row whose check throws as a harness error, not as a violation, and `seeds`, reading
-/// the lines it writes, counts no such row caught, nor a violation whose reasons carry a harness error.
-/// </summary>
-[Collection(nameof(ProbeOut))]
-public sealed class HarnessErrorTests : IDisposable
-{
-    private readonly Fixture fx = new();
-    private readonly string cache;
-
-    public HarnessErrorTests()
-    {
-        cache = fx.Root + "-cache";
-        fx.Sh("git", "config", "core.autocrlf", "false");
-        fx.Write(".claude/probe-axes.md", "```json probe-axes\n" + new JsonObject
-        {
-            ["axes"] = new JsonObject { ["x"] = new JsonArray("1", "2"), ["y"] = new JsonArray("1", "2") },
-            ["surfaces"] = new JsonObject { ["s"] = new JsonObject { ["axes"] = new JsonArray("x", "y"), ["watched"] = new JsonArray("src") } },
-            ["replay"] = new JsonObject { ["probeDir"] = "probes", ["include"] = new JsonArray("src") },
-        }.ToJsonString() + "\n```\n");
-        fx.Write("src/a.cs", "class A { /* DEFECT */ }\n");
-        fx.Write("tools/probe/corpus/seeds/C1.patch", fx.Sh("git", "diff", "--", "src/a.cs"));
-        fx.Write("src/a.cs", "class A {}\n");
-        fx.Write("tools/probe/corpus/registry.json", new JsonObject
-        {
-            ["probes"] = new JsonObject
-            {
-                ["P"] = new JsonObject { ["claim"] = "C1", ["filter"] = "*P", ["seed"] = new JsonObject { ["defect"] = "A holds the defect.", ["patch"] = "seeds/C1.patch" } },
-            },
-        }.ToJsonString());
-        fx.Commit("seed");
-    }
-
-    public void Dispose()
-    {
-        fx.Dispose();
-        try { Directory.Delete(cache, recursive: true); } catch (IOException) { } catch (UnauthorizedAccessException) { }
-    }
-
-    /// <summary>Runs one row through the harness's <c>Rec.Run</c>, writing to <paramref name="outDir"/>; the exception it ends the test with, if any.</summary>
-    private static Exception? Harness(string outDir, int idx, Func<Row, Task<string?>> check)
-    {
-        var previous = Environment.GetEnvironmentVariable("PROBE_OUT");
-        Environment.SetEnvironmentVariable("PROBE_OUT", outDir);
-        try
-        {
-            Rec.Run("C1", new Row(idx, new Dictionary<string, string> { ["x"] = "1", ["y"] = "1" }), check).GetAwaiter().GetResult();
-            return null;
-        }
-        catch (Exception ended) { return ended; }
-        finally { Environment.SetEnvironmentVariable("PROBE_OUT", previous); }
-    }
-
-    private static Task<string?> Throws(Row _) => throw new InvalidOperationException("the check broke");
-
-    [Fact]
-    public void A_check_that_throws_ends_as_a_harness_error_and_fails_the_test_naming_the_exception()
-    {
-        var outDir = Path.Combine(fx.Root, "rows-out");
-        var ended = Harness(outDir, 1, Throws);
-        ended.ShouldNotBeNull().Message.ShouldContain("UNEXPECTED InvalidOperationException: the check broke");
-
-        var line = JsonNode.Parse(File.ReadAllLines(Path.Combine(outDir, "C1.jsonl")).ShouldHaveSingleItem())!;
-        Files.Str(line["category"]).ShouldBe("harness-error", "an exception is the harness breaking, never the claim's check firing");
-        Files.Strings(line["reasons"]).ShouldBe(["harness-error:UNEXPECTED InvalidOperationException: the check broke"]);
-        Files.Str(line["status"]).ShouldBe("fail");
-    }
-
-    [Fact]
-    public void A_seed_that_only_makes_a_check_throw_is_missed_not_caught()
-    {
-        var (exit, output) = Seeds(new HarnessAdapter(Throws));
-        exit.ShouldBe(1, output);
-        output.ShouldContain("P (C1): missed, no row violates that did not already (2 rows: harness-error 1, pass 1; 1 ended in a harness error, which is no catch;");
-        output.ShouldNotContain("caught,");
-    }
-
-    [Fact]
-    public void A_violation_whose_reasons_carry_a_harness_error_is_no_catch()
-    {
-        var (exit, output) = Seeds(new HarnessAdapter(r =>
-        {
-            r.Outcome("harness-error", "the check could not tell");
-            return Task.FromResult<string?>("and failed anyway");
-        }));
-        exit.ShouldBe(1, output);
-        output.ShouldContain("P (C1): missed, no row violates that did not already (2 rows: pass 1, violation 1; 1 ended in a harness error, which is no catch;");
-    }
-
-    [Fact]
-    public void A_violation_through_the_harness_is_a_catch()
-    {
-        var (exit, output) = Seeds(new HarnessAdapter(_ => Task.FromResult<string?>("the claim does not hold")));
-        exit.ShouldBe(0, output);
-        output.ShouldContain("P (C1): caught, 1 of 2 rows violate; e.g. #1: violation:the claim does not hold");
-    }
-
-    private (int Exit, string Out) Seeds(IProbeAdapter adapter)
-    {
-        var output = new StringWriter();
-        var context = new Context(fx.Root, new Dictionary<string, string?> { ["PROBE_CACHE_DIR"] = cache }, output, output);
-        int exit;
-        try { exit = global::Prober.Seeds.Run(context, new Args([], new HashSet<string>(StringComparer.Ordinal)), adapter); }
-        catch (Refusal refusal) { output.WriteLine(refusal.Message); exit = refusal.ExitCode; }
-        return (exit, output.ToString());
-    }
-
-    /// <summary>
-    /// The probe P over C1's two rows, each run through the real harness: row 0 passes, and row 1 runs
-    /// <paramref name="seeded"/> while src/a.cs holds DEFECT.
-    /// </summary>
-    private sealed class HarnessAdapter(Func<Row, Task<string?>> seeded) : IProbeAdapter
-    {
-        public Ran Build(string worktree, IReadOnlyDictionary<string, string?> environment) => new(0, "Build: OK", "");
-
-        public Ran RunProbe(string worktree, string filter, string results, string coverageFile, IReadOnlyDictionary<string, string?> environment)
-        {
-            var defect = File.ReadAllText(Path.Combine(worktree, "src", "a.cs")).Contains("DEFECT", StringComparison.Ordinal);
-            var outDir = environment["PROBE_OUT"]!;
-            var failed = false;
-            for (var idx = 0; idx < 2; idx++)
-                failed |= Harness(outDir, idx, idx == 1 && defect ? seeded : _ => Task.FromResult<string?>(null)) is not null;
-            return new Ran(failed ? 1 : 0, "", "");
-        }
-
-        public (JsonObject? Axes, string? Error) DeriveAxes(string checkout, string workDirectory) => (null, "none");
-
-        public IReadOnlyDictionary<string, string?> Environment(string cacheDirectory) => new Dictionary<string, string?>();
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/LedgerTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/LedgerTests.cs
deleted file mode 100644
index 62ec4ad4..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/LedgerTests.cs
+++ /dev/null
@@ -1,350 +0,0 @@
-using System.Text.Json.Nodes;
-using Prober;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>Coverage is earned only by replayed evidence, bound to the identity it ran under (the review's priority 1).</summary>
-public sealed class AccountingTests : IDisposable
-{
-    private readonly Fixture fx = new();
-    public void Dispose() => fx.Dispose();
-
-    private static Dictionary<string, string> R(string x, string y) => new(StringComparer.Ordinal) { ["x"] = x, ["y"] = y };
-    private static readonly IReadOnlyList<Dictionary<string, string>> TwoRows = [R("1", "1"), R("2", "2")];
-
-    private void RecordPass(IReadOnlyList<Dictionary<string, string>> applied, string category = "pass", int[]? executed = null)
-    {
-        fx.Footprint();
-        fx.Ledger("record-run", "--probe", "P", "--result", "pass", "--evidence", fx.Evidence(applied, category, executed)).Exit.ShouldBe(0);
-    }
-
-    [Fact]
-    public void A_pass_credits_the_pairs_of_the_rows_it_ran()
-    {
-        RecordPass(TwoRows);
-        fx.Covered().ShouldBe(2);
-    }
-
-    [Fact]
-    public void The_status_line_counts_what_the_json_counts()
-    {
-        RecordPass(TwoRows);
-        fx.Ledger("status").Out.ShouldStartWith("main at ");
-        fx.Ledger("status").Out.ShouldContain(": 2 of 4 pairs current (50.0%), 0 open finding(s)");
-    }
-
-    [Fact]
-    public void An_old_pass_does_not_credit_a_row_added_since()
-    {
-        RecordPass(TwoRows);
-        fx.Rows([("1", "1"), ("2", "2"), ("1", "2")]);
-        fx.Commit("a new row");
-        fx.Covered().ShouldBe(0, "the pass was for another corpus: nothing of it may count now");
-    }
-
-    [Fact]
-    public void A_changed_harness_voids_the_pass()
-    {
-        RecordPass(TwoRows);
-        fx.Write("tools/probe/corpus/harness/P.cs", "// probe P, changed\n");
-        fx.Commit("harness");
-        fx.Covered().ShouldBe(0);
-    }
-
-    [Fact]
-    public void A_changed_axes_file_voids_the_pass()
-    {
-        RecordPass(TwoRows);
-        var path = Path.Combine(fx.Root, ".claude/probe-axes.md");
-        fx.Write(".claude/probe-axes.md", File.ReadAllText(path).Replace("\"watched\":[\"src\"]", "\"watched\":[\"src\",\"README.md\"]", StringComparison.Ordinal));
-        fx.Commit("axes");
-        fx.Covered().ShouldBe(0);
-    }
-
-    [Fact]
-    public void Only_the_settings_that_applied_earn_credit()
-    {
-        RecordPass([R("1", "1"), R("1", "2")]);   // row 2 asked for x=2 and ran as x=1
-        fx.Covered().ShouldBe(2, "x1y1 and the applied x1y2, never the requested x2y2");
-        var rows = JsonNode.Parse(fx.Ledger("rows", "--claim", "C1").Out)!["rows"]!.AsArray();
-        rows.SelectMany(r => r!["pairs"]!.AsArray()).Select(p => $"{p![0]} {p[1]}").ShouldContain("x=2 y=2");
-    }
-
-    [Fact]
-    public void An_axis_the_harness_never_read_earns_nothing()
-    {
-        RecordPass([new(StringComparer.Ordinal) { ["x"] = "1" }, new(StringComparer.Ordinal) { ["x"] = "2" }]);
-        fx.Covered().ShouldBe(0);
-    }
-
-    [Fact]
-    public void A_refusal_is_no_evidence_of_success()
-    {
-        RecordPass(TwoRows, category: "expected-refusal");
-        fx.Covered().ShouldBe(0);
-    }
-
-    [Fact]
-    public void A_row_that_did_not_run_is_never_credited()
-    {
-        RecordPass(TwoRows, executed: [0]);
-        fx.Covered().ShouldBe(1);
-    }
-}
-
-/// <summary>
-/// What earned nothing is counted where the coverage is read, and a row that steps around a finding binds: the
-/// gate refuses while one does, and the ledger names a skip whose finding is fixed or dismissed.
-/// </summary>
-public sealed class OutcomeTests : IDisposable
-{
-    private readonly Fixture fx = new();
-    public void Dispose() => fx.Dispose();
-
-    private static Dictionary<string, string> R(string x, string y) => new(StringComparer.Ordinal) { ["x"] = x, ["y"] = y };
-
-    private string Record(params (string Category, string? Finding)[] outcomes)
-    {
-        fx.Footprint();
-        var evidence = fx.Evidence([R("1", "1"), R("2", "2")], outcomes: outcomes);
-        fx.Ledger("record-run", "--probe", "P", "--result", "pass", "--evidence", evidence).Exit.ShouldBe(0);
-        return evidence;
-    }
-
-    private List<string> StaleSkips(string evidence) =>
-        new Ledger(new Context(fx.Root, new Dictionary<string, string?>(), TextWriter.Null, TextWriter.Null), null)
-            .StaleSkips(JsonNode.Parse(File.ReadAllText(evidence)) as JsonObject);
-
-    private void Finding(string status, string commit) =>
-        File.AppendAllText(Path.Combine(fx.BranchDir, "findings.jsonl"),
-            new JsonObject { ["id"] = "F9", ["claim"] = "C1", ["status"] = status, ["commit"] = commit }.ToJsonString() + "\n");
-
-    [Fact]
-    public void Status_counts_how_the_rows_of_a_claim_ended()
-    {
-        Record(("pass", null), ("expected-refusal", null));
-        var outcomes = JsonNode.Parse(fx.Ledger("status", "--json").Out)!["claims"]!["C1"]!["outcomes"]!;
-        outcomes["pass"]!.GetValue<double>().ShouldBe(1);
-        outcomes["expected-refusal"]!.GetValue<double>().ShouldBe(1);
-        fx.Ledger("status").Out.ShouldContain("C1: 1/4  (rows: expected-refusal 1, pass 1; checks: expected-refusal 1, pass 1)");
-    }
-
-    [Fact]
-    public void A_skip_for_a_finding_is_shown_and_refused_by_the_gate_without_any_ledger_of_findings()
-    {
-        fx.Sh("git", "tag", "v1");
-        Record(("pass", null), ("known-finding", "F9"));
-        fx.Ledger("status").Out.ShouldContain("1 row(s) skip for finding F9");
-        var (exit, output, _) = fx.Ledger("gate", "--since", "v1", "--json");
-        exit.ShouldNotBe(0);
-        JsonNode.Parse(output)!["reasons"]!.AsArray().Select(r => r!.GetValue<string>()).ShouldContain("P: 1 row(s) skip for finding F9; fix it and remove the skip, or dismiss it");
-    }
-
-    [Fact]
-    public void A_skip_for_an_open_finding_stands()
-    {
-        var evidence = Record(("known-finding", "F9"), ("pass", null));
-        Finding("open", "");
-        StaleSkips(evidence).ShouldBeEmpty();
-    }
-
-    [Fact]
-    public void A_skip_for_a_fixed_finding_is_stale()
-    {
-        var evidence = Record(("known-finding", "F9"), ("pass", null));
-        var head = fx.Sh("git", "rev-parse", "HEAD").Trim();
-        Finding("open", "");
-        Finding("fixed", head);
-        StaleSkips(evidence).ShouldBe([$"1 row(s) skip for F9, which is fixed at {head[..7]}: remove the skip"]);
-    }
-
-    [Fact]
-    public void A_skip_for_a_dismissed_finding_is_stale()
-    {
-        var evidence = Record(("known-finding", "F9"), ("pass", null));
-        Finding("open", "");
-        fx.Write("tools/probe/corpus/dismissed.jsonl", new JsonObject { ["id"] = "F9", ["reason"] = "intended", ["date"] = "2026-10-15" }.ToJsonString() + "\n");
-        StaleSkips(evidence).ShouldBe(["1 row(s) skip for F9, which is dismissed: remove the skip"]);
-    }
-}
-
-/// <summary>One round at a time, on every OS: an exclusive create, liveness by heartbeat, a mutex for takeovers.</summary>
-public sealed class LockTests : IDisposable
-{
-    private readonly Fixture fx = new();
-    public void Dispose() => fx.Dispose();
-
-    [Fact]
-    public void A_second_holder_is_refused_while_the_first_is_alive()
-    {
-        fx.Ledger("lock", "--holder", "a", "--mode", "explore").Exit.ShouldBe(0);
-        fx.Ledger("lock", "--holder", "b", "--mode", "replay").Exit.ShouldNotBe(0);
-    }
-
-    [Fact]
-    public void A_holder_whose_heartbeat_stopped_is_taken_over()
-    {
-        fx.Ledger("lock", "--holder", "a", "--mode", "explore").Exit.ShouldBe(0);
-        fx.AgeTheLock();
-        fx.Ledger("lock", "--holder", "b", "--mode", "replay").Exit.ShouldBe(0);
-    }
-
-    [Fact]
-    public void A_heartbeat_keeps_the_holder_alive()
-    {
-        fx.Ledger("lock", "--holder", "a", "--mode", "explore").Exit.ShouldBe(0);
-        fx.AgeTheLock();
-        fx.Ledger("heartbeat", "--holder", "a").Exit.ShouldBe(0);
-        fx.Ledger("lock", "--holder", "b", "--mode", "replay").Exit.ShouldNotBe(0);
-    }
-
-    [Fact]
-    public void Two_takers_at_once_get_one_lock() => RaceOf(8).ShouldBe(1);
-
-    [Fact]
-    public void Racing_takers_of_a_dead_holder_get_one_lock()
-    {
-        fx.Ledger("lock", "--holder", "dead", "--mode", "explore").Exit.ShouldBe(0);
-        fx.AgeTheLock();
-        RaceOf(8).ShouldBe(1);
-    }
-
-    [Fact]
-    public void Racing_threads_over_a_dead_holder_get_one_lock()
-    {
-        // Threads released together by a barrier collide in the critical section far more tightly than
-        // processes can; ten rounds, each must end with exactly one holder.
-        for (var round = 0; round < 10; round++)
-        {
-            fx.Ledger("lock", "--holder", $"dead{round}", "--mode", "explore").Exit.ShouldBe(0);
-            fx.AgeTheLock();
-            const int takers = 16;
-            using var barrier = new Barrier(takers);
-            var exits = new int[takers];
-            var threads = Enumerable.Range(0, takers).Select(i => new Thread(() =>
-            {
-                barrier.SignalAndWait();
-                exits[i] = fx.Ledger("lock", "--holder", $"t{round}-{i}", "--mode", "replay").Exit;
-            })).ToList();
-            threads.ForEach(t => t.Start());
-            threads.ForEach(t => t.Join());
-            exits.Count(e => e == 0).ShouldBe(1, $"round {round}");
-            File.Delete(fx.LockFile());
-        }
-    }
-
-    /// <summary>
-    /// What crashed the test host on windows-latest (run 38732628888): a taker creating round.lock.mutex while
-    /// its last holder's delete was still pending got UnauthorizedAccessException, which Windows throws there
-    /// instead of IOException, and the mutex loop let it through. Here the OS refuses the create every time,
-    /// the same exception on every platform: a directory in the mutex's place on Windows, a state directory
-    /// without write permission elsewhere. A taker waits, then refuses; it never throws.
-    /// </summary>
-    [Fact]
-    public void A_mutex_the_OS_refuses_to_create_is_waited_for_and_refused_not_thrown()
-    {
-        var directory = Path.GetDirectoryName(fx.LockFile())!;
-        Directory.CreateDirectory(directory);
-        var mutex = fx.LockFile() + ".mutex";
-        if (OperatingSystem.IsWindows()) Directory.CreateDirectory(mutex);
-        else File.SetUnixFileMode(directory, UnixFileMode.UserRead | UnixFileMode.UserExecute);
-        try
-        {
-            var (exit, _, error) = fx.Ledger("lock", "--holder", "a", "--mode", "explore");
-
-            exit.ShouldNotBe(0);
-            error.ShouldContain("mutex");
-        }
-        finally
-        {
-            if (OperatingSystem.IsWindows()) Directory.Delete(mutex);
-            else File.SetUnixFileMode(directory, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute);
-        }
-    }
-
-    [Fact]
-    public void A_lock_of_one_branch_leaves_another_branchs_lock_free()
-    {
-        var other = fx.Linked("other");
-        fx.Ledger("lock", "--holder", "a", "--mode", "explore").Exit.ShouldBe(0);
-
-        var (exit, output, error) = fx.LedgerIn(other, "lock", "--holder", "b", "--mode", "explore");
-
-        exit.ShouldBe(0, error + output);
-        File.Exists(fx.LockFile("other")).ShouldBeTrue();
-        File.Exists(fx.LockFile("main")).ShouldBeTrue("a's lock is still held");
-    }
-
-    [Fact]
-    public void A_second_lock_of_one_branch_is_refused_from_another_checkout()
-    {
-        var other = fx.Linked("other");
-        fx.Ledger("lock", "--holder", "a", "--mode", "explore").Exit.ShouldBe(0);
-
-        fx.LedgerIn(other, "lock", "--branch", "main", "--holder", "b", "--mode", "replay").Exit.ShouldNotBe(0);
-    }
-
-    private int RaceOf(int takers)
-    {
-        var processes = Enumerable.Range(0, takers).Select(i => fx.Spawn("lock", "--holder", $"h{i}", "--mode", "replay")).ToList();
-        foreach (var p in processes) { p.StandardOutput.ReadToEnd(); p.StandardError.ReadToEnd(); p.WaitForExit(); }
-        return processes.Count(p => p.ExitCode == 0);
-    }
-}
-
-/// <summary>The release gate needs no model: every obligation is a probe or a reviewed waiver.</summary>
-public sealed class GateTests : IDisposable
-{
-    private readonly Fixture fx = new();
-    public void Dispose() => fx.Dispose();
-
-    private void TouchTheClaim()
-    {
-        fx.Write("README.md", "# a\n\nThe claim, reworded.\n");
-        fx.Commit("docs");
-    }
-
-    [Fact]
-    public void An_unprobed_touched_claim_fails_with_what_is_missing()
-    {
-        fx.Sh("git", "tag", "v1");
-        TouchTheClaim();
-        var (exit, output, _) = fx.Ledger("gate", "--since", "v1", "--json");
-        exit.ShouldNotBe(0);
-        JsonNode.Parse(output)!["reasons"]!.AsArray().Select(r => r!.GetValue<string>()).ShouldContain(r => r.StartsWith("C1:", StringComparison.Ordinal));
-    }
-
-    [Fact]
-    public void A_reviewed_waiver_meets_the_obligation_without_a_probe()
-    {
-        fx.Sh("git", "tag", "v1");
-        fx.Write("tools/probe/corpus/registry.json", """{"probes": {}}""");
-        fx.Write("tools/probe/corpus/waivers.json", """[{"claim": "C1", "reason": "covered by the suite's C1Tests", "reviewed_by": "maintainer", "date": "2026-10-15"}]""");
-        TouchTheClaim();
-        var (exit, _, error) = fx.Ledger("gate", "--since", "v1");
-        exit.ShouldBe(0, error);
-    }
-
-    [Fact]
-    public void An_unsigned_waiver_meets_nothing()
-    {
-        fx.Sh("git", "tag", "v1");
-        fx.Write("tools/probe/corpus/registry.json", """{"probes": {}}""");
-        fx.Write("tools/probe/corpus/waivers.json", """[{"claim": "C1", "reason": "later"}]""");
-        TouchTheClaim();
-        fx.Ledger("gate", "--since", "v1").Exit.ShouldNotBe(0);
-    }
-
-    [Fact]
-    public void State_goes_where_PROBE_STATE_DIR_says()
-    {
-        var state = Path.Combine(Path.GetTempPath(), "prober-state-" + Guid.NewGuid().ToString("N"));
-        try
-        {
-            fx.LedgerWith(new() { ["PROBE_STATE_DIR"] = state }, "lock", "--holder", "ci", "--mode", "replay").Exit.ShouldBe(0);
-            Directory.EnumerateFiles(state, "round.lock", SearchOption.AllDirectories).ShouldNotBeEmpty();
-            File.Exists(fx.LockFile()).ShouldBeFalse();
-        }
-        finally { if (Directory.Exists(state)) Directory.Delete(state, recursive: true); }
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/NewProbeTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/NewProbeTests.cs
deleted file mode 100644
index 2d9071e6..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/NewProbeTests.cs
+++ /dev/null
@@ -1,193 +0,0 @@
-using System.Text.Json.Nodes;
-using System.Text.RegularExpressions;
-using Prober;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>
-/// `new` stages what a probe writer used to do by hand: the skeleton in the harness's form with the claim's
-/// obligations quoted and one throwing check each, the claim's rows, and the registry entry with no seed yet,
-/// so the seeds every obligation owes are named. C1 lists two obligations; C7-two-words lists none.
-/// </summary>
-public sealed class NewProbeTests : IDisposable
-{
-    private readonly Fixture fx = new();
-
-    public NewProbeTests()
-    {
-        fx.Write("README.md", "# a\n\nThe claim.\n\nA key is written as the wrapped type writes it.\n\nA null is refused.\n");
-        fx.Write(".claude/probe-axes.md", "```json probe-axes\n" + new JsonObject
-        {
-            ["axes"] = new JsonObject { ["x"] = new JsonArray("1", "2"), ["y"] = new JsonArray("1", "2") },
-            ["surfaces"] = new JsonObject { ["s"] = new JsonObject { ["axes"] = new JsonArray("x", "y"), ["watched"] = new JsonArray("src") } },
-            ["replay"] = new JsonObject { ["probeDir"] = "probes", ["include"] = new JsonArray("src"), ["families"] = new JsonObject { ["f"] = new JsonArray("s") } },
-        }.ToJsonString() + "\n```\n");
-        fx.Write("tools/probe/corpus/claims.json", new JsonArray(
-            new JsonObject
-            {
-                ["id"] = "C1", ["source"] = "README.md#a", ["surfaces"] = new JsonArray("s"),
-                ["obligations"] = new JsonArray(
-                    new JsonObject { ["id"] = "keys", ["sentence"] = "A key is written as the wrapped type writes it." },
-                    new JsonObject { ["id"] = "nulls", ["sentence"] = "A null is refused." }),
-            },
-            new JsonObject { ["id"] = "C7-two-words", ["source"] = "README.md#a", ["surfaces"] = new JsonArray("s") }).ToJsonString());
-        fx.Commit("claims with obligations");
-        fx.Ledger("universe", "--base", "HEAD").Exit.ShouldBe(0);
-    }
-
-    public void Dispose() => fx.Dispose();
-
-    private string Staged(string relative) => Path.Combine(fx.BranchDir, "staging", relative);
-
-    [Fact]
-    public void It_stages_the_skeleton_the_rows_and_the_registry_entry()
-    {
-        var (exit, output, error) = fx.Ledger("new", "--claim", "C1", "--probe", "C1KeysProbe");
-        exit.ShouldBe(0, output + error);
-
-        var source = File.ReadAllText(Staged("probes/C1KeysProbe.cs"));
-        source.ShouldContain("// Claim C1 (README.md#a), surfaces s, family f.");
-        source.ShouldContain("//   keys: \"A key is written as the wrapped type writes it.\"");
-        source.ShouldContain("//   nulls: \"A null is refused.\"");
-        source.ShouldContain("// TODO keys: \"A key is written as the wrapped type writes it.\"");
-        source.ShouldContain("// TODO nulls: \"A null is refused.\"");
-
-        // The probe's own rows, C1's other probe P's untouched: P has covered nothing, so a covering array over all four pairs.
-        var staged = JsonNode.Parse(File.ReadAllText(Staged("rows/C1KeysProbe.json")))!;
-        staged["claim"]!.GetValue<string>().ShouldBe("C1");
-        staged["rows"]!.AsArray().Select(r => $"{r!["row"]!["x"]}{r["row"]!["y"]}").Order().ShouldBe(["11", "12", "21", "22"]);
-        File.Exists(Staged("rows/P.json")).ShouldBeFalse("a new probe leaves its sibling's rows as they are");
-
-        var entry = JsonNode.Parse(File.ReadAllText(Staged("registry.json")))!["probes"]!["C1KeysProbe"]!.AsObject();
-        entry["claim"]!.GetValue<string>().ShouldBe("C1");
-        entry["filter"]!.GetValue<string>().ShouldBe("*C1KeysProbe");
-        entry["seeds"]!.AsArray().ShouldBeEmpty();
-        entry.ContainsKey("seed").ShouldBeFalse();
-
-        output.ShouldContain("still owed, per obligation:");
-        output.ShouldContain("  keys: the check CheckKeys");
-        output.ShouldContain("  nulls: the check CheckNulls");
-    }
-
-    [Fact]
-    public void The_seeds_each_obligation_owes_are_named()
-    {
-        fx.Ledger("new", "--claim", "C1", "--probe", "C1KeysProbe").Exit.ShouldBe(0);
-        var problems = global::Prober.Seeds.Problems(new Ledger(new Context(fx.Root, new Dictionary<string, string?>(), TextWriter.Null, TextWriter.Null), null));
-        problems.ShouldContain("C1KeysProbe: no seed, its registry entry names none");
-        problems.ShouldContain("C1: obligation keys has no seed in any of its probes");
-        problems.ShouldContain("C1: obligation nulls has no seed in any of its probes");
-
-        var (exit, output, _) = fx.Ledger("seeds", "--dry-run");
-        exit.ShouldBe(0);
-        output.ShouldContain("  C1KeysProbe/keys: (none)");
-        output.ShouldContain("  C1KeysProbe/nulls: (none)");
-    }
-
-    [Fact]
-    public void A_claim_not_in_the_claims_is_refused_and_nothing_staged()
-    {
-        var (exit, _, error) = fx.Ledger("new", "--claim", "C9");
-        exit.ShouldBe(1);
-        error.ShouldContain("no claim C9 in claims.json");
-        Directory.Exists(Path.Combine(fx.BranchDir, "staging")).ShouldBeFalse();
-    }
-
-    [Fact]
-    public void A_name_a_probe_has_is_refused_and_nothing_changes()
-    {
-        fx.Write("tools/probe/corpus/registry.json", """{"probes": {"P": {"claim": "C1", "filter": "*P"}, "C1OldProbe": {"claim": "C1", "filter": "*C1OldProbe"}}}""");
-        fx.Commit("a second probe of C1");
-        var (exit, _, error) = fx.Ledger("new", "--claim", "C1", "--probe", "C1OldProbe");
-        exit.ShouldBe(1);
-        error.ShouldContain("a probe C1OldProbe exists already (in the registry)");
-        fx.Ledger("new", "--claim", "C1", "--probe", "P").Exit.ShouldBe(2, "a name that does not end in Probe");
-        Directory.Exists(Path.Combine(fx.BranchDir, "staging")).ShouldBeFalse();
-
-        fx.Ledger("new", "--claim", "C1", "--probe", "C1KeysProbe").Exit.ShouldBe(0);
-        var registry = File.ReadAllText(Staged("registry.json"));
-        var source = File.ReadAllText(Staged("probes/C1KeysProbe.cs"));
-        fx.Ledger("new", "--claim", "C7-two-words", "--probe", "C1KeysProbe").Exit.ShouldBe(1, "a second `new` of one name");
-        File.ReadAllText(Staged("registry.json")).ShouldBe(registry);
-        File.ReadAllText(Staged("probes/C1KeysProbe.cs")).ShouldBe(source);
-    }
-
-    [Theory]
-    [InlineData("C20-testing-shouldhold", "C20TestingShouldholdProbe")]
-    [InlineData("E02-value-translates-to-column", "E02ValueTranslatesToColumnProbe")]
-    [InlineData("L01-json-bytes", "L01JsonBytesProbe")]
-    public void The_name_defaults_to_the_claim_s_prefix_and_words(string claim, string probe) => NewProbe.DefaultName(claim).ShouldBe(probe);
-
-    [Fact]
-    public void Without_a_name_the_default_is_staged()
-    {
-        fx.Ledger("new", "--claim", "C7-two-words").Exit.ShouldBe(0);
-        // The registry's key, not the file: a file system that ignores case finds the file under another spelling.
-        JsonNode.Parse(File.ReadAllText(Staged("registry.json")))!["probes"]!.AsObject().Select(kv => kv.Key).ShouldBe(["C7TwoWordsProbe"]);
-        File.ReadAllText(Staged("probes/C7TwoWordsProbe.cs")).ShouldContain("//   claim: the claim as a whole");
-    }
-
-    [Fact]
-    public void A_family_that_is_not_the_claim_s_is_refused()
-    {
-        var (exit, _, error) = fx.Ledger("new", "--claim", "C1", "--probe", "C1KeysProbe", "--family", "g");
-        exit.ShouldBe(2);
-        error.ShouldContain("claim C1 is of family f (its first surface, s), not g");
-        fx.Ledger("new", "--claim", "C1", "--probe", "C1KeysProbe", "--family", "f").Exit.ShouldBe(0);
-    }
-
-    /// <summary>
-    /// The lines that make a probe a probe of this harness, with its own names taken out: the namespace, the
-    /// class, the rows as member data, the theory and the row's run through Rec.Run with a check of the row.
-    /// </summary>
-    private static List<string> Form(string source) =>
-        [.. source.Split('\n').Select(line => line.Trim()).Select(line => line switch
-        {
-            _ when line.StartsWith("namespace ", StringComparison.Ordinal) => line,
-            _ when Regex.IsMatch(line, @"^public sealed class \w+Probe$") => "public sealed class {probe}",
-            _ when line.StartsWith("public static TheoryData<string, int> Data()", StringComparison.Ordinal) =>
-                Regex.Replace(line, @"Rows\.Data\(""[^""]+""\)", "Rows.Data({probe})"),
-            _ when line.StartsWith("[Theory", StringComparison.Ordinal) => line,
-            _ when line.StartsWith("public Task ", StringComparison.Ordinal) => Regex.Replace(line, @"Rec\.Run\(probe, idx, [^;]+\);$", "Rec.Run(probe, idx, {check});"),
-            _ => null,
-        }).OfType<string>()];
-
-    private static readonly string Corpus = Path.Combine(RepositoryRoot(), "tools", "probe", "corpus", "probes");
-
-    [Theory]
-    [InlineData("C08SameNameWarningProbe")]
-    [InlineData("C12DescribedConverterProbe")]
-    [InlineData("C20ShouldHoldProbe")]
-    public void The_skeleton_has_the_form_of_the_corpus_s_probes(string probe)
-    {
-        fx.Ledger("new", "--claim", "C1", "--probe", "C1KeysProbe").Exit.ShouldBe(0);
-        var skeleton = File.ReadAllText(Staged("probes/C1KeysProbe.cs"));
-        var corpus = File.ReadAllText(Path.Combine(Corpus, probe + ".cs"));
-        Form(skeleton).ShouldBe(Form(corpus));
-        Form(skeleton).Count.ShouldBe(5, "namespace, class, rows, theory and run");
-        var usings = corpus.Split('\n').Where(l => l.StartsWith("using ", StringComparison.Ordinal)).Select(l => l.Trim()).ToList();
-        skeleton.Split('\n').Where(l => l.StartsWith("using ", StringComparison.Ordinal)).ShouldAllBe(l => usings.Contains(l.Trim()));
-    }
-
-    [Fact]
-    public void Every_obligation_s_check_throws_until_it_is_written()
-    {
-        fx.Ledger("new", "--claim", "C1", "--probe", "C1KeysProbe").Exit.ShouldBe(0);
-        var skeleton = File.ReadAllText(Staged("probes/C1KeysProbe.cs"));
-        foreach (var method in new[] { "CheckKeys", "CheckNulls" })
-        {
-            skeleton.ShouldContain($"static Task<string?> {method}(Row r) => throw new NotImplementedException(");
-            Regex.IsMatch(skeleton, $@"static async Task<string\?> Check\(Row r\) =>[^;]*await {method}\(r\)").ShouldBeTrue($"Check runs {method}");
-        }
-        Regex.Matches(skeleton, @"=> throw new NotImplementedException\(").Count.ShouldBe(2);
-        skeleton.ShouldNotContain("return null");
-        skeleton.ShouldNotContain("FromResult");
-    }
-
-    private static string RepositoryRoot()
-    {
-        var root = AppContext.BaseDirectory;
-        while (!File.Exists(Path.Combine(root, "CodoMetis.TypeKit.slnx"))) root = Path.GetDirectoryName(root) ?? throw new InvalidOperationException("no CodoMetis.TypeKit.slnx above the test output");
-        return root;
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/ObligationsTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/ObligationsTests.cs
deleted file mode 100644
index 94369bb4..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/ObligationsTests.cs
+++ /dev/null
@@ -1,228 +0,0 @@
-using System.Text.Json.Nodes;
-using Prober;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>
-/// A claim lists what it promises, each obligation a sentence quoted from its source, and what it does not
-/// promise, each with the sentence that makes it intended; every obligation of a claim with probes has a seed
-/// that names it (decision 104). The probe here is a fake adapter: row N of C1 violates while SEED_ROW is N.
-/// </summary>
-public sealed class ObligationsTests : IDisposable
-{
-    private readonly Fixture fx = new();
-    private readonly string cache;
-    private readonly FakeAdapter adapter = new();
-
-    public ObligationsTests()
-    {
-        cache = fx.Root + "-cache";
-        fx.Sh("git", "config", "core.autocrlf", "false");
-        fx.Write("README.md", "# a\n\nThe claim.\n\nA key is written as the wrapped type writes it.\n\nA null is refused.\n");
-        fx.Write("design/adr/0001-limits.md", "# 1. Limits\n\nAn ordering of keys is not promised.\n");
-        fx.Write(".claude/probe-axes.md", "```json probe-axes\n" + new JsonObject
-        {
-            ["axes"] = new JsonObject { ["x"] = new JsonArray("1", "2"), ["y"] = new JsonArray("1", "2") },
-            ["surfaces"] = new JsonObject { ["s"] = new JsonObject { ["axes"] = new JsonArray("x", "y"), ["watched"] = new JsonArray("src") } },
-            ["replay"] = new JsonObject { ["probeDir"] = "probes", ["include"] = new JsonArray("src") },
-        }.ToJsonString() + "\n```\n");
-        fx.Commit("sources and replay configuration");
-    }
-
-    public void Dispose()
-    {
-        fx.Dispose();
-        try { Directory.Delete(cache, recursive: true); } catch (IOException) { } catch (UnauthorizedAccessException) { }
-    }
-
-    private static JsonObject Obligation(string id, string sentence) => new() { ["id"] = id, ["sentence"] = sentence };
-
-    private static JsonArray TwoObligations() => new(
-        Obligation("keys", "A key is written as the wrapped type writes it."),
-        Obligation("nulls", "A null is refused."));
-
-    private void Claims(JsonObject claim)
-    {
-        var c = new JsonObject { ["id"] = "C1", ["source"] = "README.md#a", ["surfaces"] = new JsonArray("s") };
-        foreach (var (key, value) in claim) c[key] = value?.DeepClone();
-        fx.Write("tools/probe/corpus/claims.json", new JsonArray(c).ToJsonString());
-    }
-
-    /// <summary>Registers P for C1 with the seeds given, each an environment toggle that makes the check of its obligation violate in row <c>row</c>.</summary>
-    private void Register(JsonObject? seed = null, params (string Obligation, string Row)[] seeds)
-    {
-        var entry = new JsonObject { ["claim"] = "C1", ["filter"] = "*P" };
-        if (seed is not null) entry["seed"] = seed;
-        if (seeds.Length > 0)
-            entry["seeds"] = new JsonArray([.. seeds.Select(s => (JsonNode)new JsonObject
-            {
-                ["obligation"] = s.Obligation, ["env"] = new JsonObject { ["SEED_ROW"] = s.Row, ["SEED_CHECK"] = s.Obligation }, ["defect"] = $"{s.Obligation} is broken.",
-            })]);
-        fx.Write("tools/probe/corpus/registry.json", new JsonObject { ["probes"] = new JsonObject { ["P"] = entry } }.ToJsonString());
-        fx.Commit("register");
-    }
-
-    private static JsonObject EnvSeed() => new() { ["env"] = new JsonObject { ["SEED_ROW"] = "1" }, ["defect"] = "Row 1 is broken." };
-
-    private List<string> Problems() => Seeds.Problems(new Ledger(new Context(fx.Root, new Dictionary<string, string?>(), TextWriter.Null, TextWriter.Null), null));
-
-    private JsonObject Status()
-    {
-        var (exit, output, error) = fx.Ledger("status", "--json");
-        exit.ShouldBe(0, error);
-        return JsonNode.Parse(output)!["claims"]!["C1"]!.AsObject();
-    }
-
-    /// <summary>Each obligation of the claim in `status --json`, as "id: the probes whose seeds break it".</summary>
-    private static List<string> ObligationsOf(JsonObject claim) =>
-        [.. claim["obligations"]!.AsArray().Select(o => $"{o!["id"]!.GetValue<string>()}: {string.Join(", ", o["seeded_by"]!.AsArray().Select(p => p!.GetValue<string>()))}")];
-
-    [Fact]
-    public void An_obligation_quoting_a_sentence_its_source_does_not_hold_is_refused()
-    {
-        Claims(new JsonObject { ["obligations"] = new JsonArray(Obligation("keys", "A key is written by ToString().")) });
-        var (exit, _, error) = fx.Ledger("universe", "--base", "HEAD");
-        exit.ShouldBe(1);
-        error.ShouldContain("claim C1: obligation keys quotes a sentence not found in README.md");
-    }
-
-    [Fact]
-    public void A_not_promised_entry_is_checked_against_its_own_source()
-    {
-        // The sentence is in the claim's README, not in the record the entry names, so it is refused.
-        Claims(new JsonObject
-        {
-            ["not-promised"] = new JsonArray(new JsonObject { ["id"] = "order", ["source"] = "design/adr/0001-limits.md#1-limits", ["sentence"] = "A null is refused." }),
-        });
-        var (exit, _, error) = fx.Ledger("universe", "--base", "HEAD");
-        exit.ShouldBe(1);
-        error.ShouldContain("claim C1: not-promised order quotes a sentence not found in design/adr/0001-limits.md");
-    }
-
-    [Fact]
-    public void A_not_promised_entry_its_source_holds_is_kept()
-    {
-        Claims(new JsonObject
-        {
-            ["not-promised"] = new JsonArray(new JsonObject { ["id"] = "order", ["source"] = "design/adr/0001-limits.md#1-limits", ["sentence"] = "An ordering of keys is not promised." }),
-        });
-        var (exit, _, error) = fx.Ledger("universe", "--base", "HEAD");
-        exit.ShouldBe(0, error);
-    }
-
-    [Fact]
-    public void A_duplicate_obligation_id_is_refused()
-    {
-        Claims(new JsonObject
-        {
-            ["obligations"] = new JsonArray(Obligation("keys", "A key is written as the wrapped type writes it."), Obligation("keys", "A null is refused.")),
-        });
-        var (exit, _, error) = fx.Ledger("universe", "--base", "HEAD");
-        exit.ShouldBe(1);
-        error.ShouldContain("claim C1: obligation keys is listed twice");
-    }
-
-    [Fact]
-    public void A_claim_without_obligations_has_one_the_claim_seeded_by_a_seed_naming_none()
-    {
-        Register(EnvSeed());
-        ObligationsOf(Status()).ShouldBe(["claim: P"]);
-        Problems().ShouldBeEmpty();
-    }
-
-    [Theory]
-    [InlineData("\n")]
-    [InlineData("\r\n")]
-    public void Status_shows_the_obligations_no_seed_breaks(string newLine)
-    {
-        Claims(new JsonObject { ["obligations"] = TwoObligations() });
-        Register(null, ("keys", "1"));
-        ObligationsOf(Status()).ShouldBe(["keys: P", "nulls: "]);
-        var (exit, output, error) = fx.LedgerEnding([], newLine, "status");
-        exit.ShouldBe(0, error);
-        output.ReplaceLineEndings("\n").ShouldContain("\n  C1: 0/4  obligations 2 (1 without a seed: nulls), 2 uncredited\n");
-
-        Register(null, ("keys", "1"), ("nulls", "0"));
-        fx.LedgerEnding([], newLine, "status").Out.ReplaceLineEndings("\n").ShouldContain("\n  C1: 0/4  obligations 2, each seeded, 2 uncredited\n");
-    }
-
-    [Fact]
-    public void The_check_without_a_build_names_an_obligation_no_seed_breaks()
-    {
-        Claims(new JsonObject { ["obligations"] = TwoObligations() });
-        Register(EnvSeed(), ("keys", "1"));
-        Problems().ShouldBe(["C1: obligation nulls has no seed in any of its probes"], "a seed naming no obligation proves the probe, not an obligation the claim lists");
-        Register(null, ("keys", "1"), ("nulls", "0"));
-        Problems().ShouldBeEmpty();
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void The_check_without_a_build_names_a_seed_naming_an_obligation_the_claim_does_not_list(bool listed)
-    {
-        if (listed) Claims(new JsonObject { ["obligations"] = new JsonArray(Obligation("keys", "A key is written as the wrapped type writes it.")) });
-        Register(null, ("keys", "1"), ("kyes", "0"));
-        Problems().ShouldBe(listed
-            ? ["P/kyes: names obligation kyes, which claim C1 does not list"]
-            : ["P/keys: names obligation keys, which claim C1 does not list", "P/kyes: names obligation kyes, which claim C1 does not list"]);
-    }
-
-    [Fact]
-    public void Seeds_runs_each_seed_under_its_obligation()
-    {
-        Claims(new JsonObject { ["obligations"] = TwoObligations() });
-        Register(null, ("keys", "1"), ("nulls", "7"));
-        var output = new StringWriter(); var error = new StringWriter();
-        var context = new Context(fx.Root, new Dictionary<string, string?> { ["PROBE_CACHE_DIR"] = cache }, output, error);
-        var exit = Seeds.Run(context, new Args([], new HashSet<string>(StringComparer.Ordinal) { "dry-run" }), adapter);
-
-        exit.ShouldBe(1, "the nulls seed makes no row violate, so it is missed and fails the command");
-        var text = output.ToString().ReplaceLineEndings("\n");
-        text.ShouldContain(": 2 seeds of 1 probes, in ");
-        text.ShouldContain("\n  P/keys (C1): caught, 1 of 2 rows violate; e.g. #1 keys: violation:row 1 is broken\n");
-        text.ShouldContain("\n  P/nulls (C1): missed, no row violates that did not already (2 rows: pass 2;");
-        var last = JsonNode.Parse(File.ReadAllText(Path.Combine(fx.BranchDir, "seeds-last.json")))!["seeds"]!.AsArray()
-                           .Select(s => (s!["probe"]!.GetValue<string>(), s["obligation"]!.GetValue<string>(), s["seed"]!.GetValue<string>(), s["result"]!.GetValue<string>()));
-        last.ShouldBe([("P", "keys", "SEED_ROW=1,SEED_CHECK=keys", "caught"), ("P", "nulls", "SEED_ROW=7,SEED_CHECK=nulls", "missed")]);
-    }
-
-    /// <summary>
-    /// The probe P over C1's two rows, without a build: row N violates where SEED_ROW is N, by its check of the
-    /// obligation SEED_CHECK names where it names one (each row then runs that check), else as a row without checks.
-    /// </summary>
-    private sealed class FakeAdapter : IProbeAdapter
-    {
-        public Ran Build(string worktree, IReadOnlyDictionary<string, string?> environment) => new(0, "Build: OK", "");
-
-        public Ran RunProbe(string worktree, string filter, string results, string coverageFile, IReadOnlyDictionary<string, string?> environment)
-        {
-            var broken = environment.GetValueOrDefault("SEED_ROW");
-            var check = environment.GetValueOrDefault("SEED_CHECK");
-            var outDir = environment["PROBE_OUT"]!;
-            Directory.CreateDirectory(outDir);
-            var lines = Enumerable.Range(0, 2).Select(idx =>
-            {
-                var violates = broken == idx.ToString(System.Globalization.CultureInfo.InvariantCulture);
-                var line = new JsonObject
-                {
-                    ["idx"] = idx, ["category"] = violates ? "violation" : "pass",
-                    ["reasons"] = violates && check is null ? new JsonArray($"violation:row {idx} is broken") : new JsonArray(),
-                };
-                if (check is not null)
-                    line["checks"] = new JsonArray(new JsonObject
-                    {
-                        ["obligation"] = check, ["baseline"] = "twin", ["category"] = violates ? "violation" : "pass",
-                        ["reasons"] = violates ? new JsonArray($"violation:row {idx} is broken") : new JsonArray(),
-                    });
-                return line.ToJsonString();
-            }).ToList();
-            File.WriteAllText(Path.Combine(outDir, "C1.jsonl"), string.Join('\n', lines) + "\n");
-            return new Ran(lines.Any(l => l.Contains("\"violation\"", StringComparison.Ordinal)) ? 1 : 0, "", "");
-        }
-
-        public (JsonObject? Axes, string? Error) DeriveAxes(string checkout, string workDirectory) => (null, "none");
-
-        public IReadOnlyDictionary<string, string?> Environment(string cacheDirectory) => new Dictionary<string, string?>();
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/PerCheckTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/PerCheckTests.cs
deleted file mode 100644
index 6602c34b..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/PerCheckTests.cs
+++ /dev/null
@@ -1,492 +0,0 @@
-using System.Text.Json.Nodes;
-using Prober;
-using Probes.Shapes;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>Runs rows through the probe corpus's own harness (harness/Row.cs, compiled in) and reads the lines it writes.</summary>
-internal static class HarnessRun
-{
-    /// <summary>
-    /// Runs one row of axes x and y through <c>Rec.Run</c>, writing to <paramref name="outDir"/>: the exception the
-    /// test ends with (a failure or a skip), if any, and the line the harness wrote for the row.
-    /// </summary>
-    public static (Exception? Ended, JsonObject Line) Row(string outDir, int idx, Func<Row, Task<string?>> check, string x = "1", string y = "1")
-    {
-        var previous = Environment.GetEnvironmentVariable("PROBE_OUT");
-        Environment.SetEnvironmentVariable("PROBE_OUT", outDir);
-        Exception? ended = null;
-        try { Rec.Run("C1", new Row(idx, new Dictionary<string, string> { ["x"] = x, ["y"] = y }), check).GetAwaiter().GetResult(); }
-        catch (Exception e) { ended = e; }
-        finally { Environment.SetEnvironmentVariable("PROBE_OUT", previous); }
-        var line = File.ReadAllLines(Path.Combine(outDir, "C1.jsonl")).Select(l => JsonNode.Parse(l)!.AsObject()).Last(l => (int)Files.Num(l["idx"]) == idx);
-        return (ended, line);
-    }
-
-    public static JsonObject Check(JsonObject line, string obligation) =>
-        line["checks"]!.AsArray().OfType<JsonObject>().Single(c => Files.Str(c["obligation"]) == obligation);
-}
-
-/// <summary>
-/// A check of a row (<c>Row.Check</c>) has one obligation, one baseline, and reads, notes and an outcome of its own: a
-/// failure it returns is a violation, an exception a harness error that the other checks of the row survive, and a
-/// pass with no baseline a harness error. The row passes when no check failed and one passed, and is skipped, each
-/// check's outcome listed, when none passed.
-/// </summary>
-[Collection(nameof(ProbeOut))]
-public sealed class CheckHarnessTests : IDisposable
-{
-    private readonly string outDir = Path.Combine(Path.GetTempPath(), "prober-tests", Guid.NewGuid().ToString("N"));
-
-    public void Dispose()
-    {
-        try { Directory.Delete(outDir, recursive: true); } catch (IOException) { } catch (UnauthorizedAccessException) { }
-    }
-
-    [Fact]
-    public void A_failure_a_check_returns_is_its_violation_with_its_own_reads()
-    {
-        string? returned = "not run";
-        var (ended, line) = HarnessRun.Row(outDir, 0, async r =>
-        {
-            _ = r["x"];
-            returned = await r.Check("keys", Baseline.Twin, c => Task.FromResult<string?>(c["y"] == "1" ? "the key differs" : null));
-            return returned;
-        });
-        returned.ShouldBe("the key differs", "Check returns the failure, so a probe can stop the row at it");
-        ended.ShouldNotBeNull().Message.ShouldContain("keys violation: the key differs");
-        Files.Str(line["category"]).ShouldBe("violation");
-        Files.StringMap(line["applied"]).ShouldBe(new Dictionary<string, string> { ["x"] = "1" }, "the row's own reads are those outside any check");
-        Files.Strings(line["reasons"]).ShouldBeEmpty("the failure is the check's, not the row's own");
-        var check = HarnessRun.Check(line, "keys");
-        Files.Str(check["baseline"]).ShouldBe("twin");
-        Files.Str(check["category"]).ShouldBe("violation");
-        Files.StringMap(check["applied"]).ShouldBe(new Dictionary<string, string> { ["y"] = "1" });
-        Files.Strings(check["reasons"]).ShouldBe(["violation:the key differs"]);
-    }
-
-    [Fact]
-    public void An_exception_in_a_check_is_a_harness_error_the_other_checks_survive()
-    {
-        string? returned = "not run";
-        var (ended, line) = HarnessRun.Row(outDir, 0, async r =>
-        {
-            returned = await r.Check("keys", Baseline.Twin, (Func<Check, Task<string?>>)(_ => throw new InvalidOperationException("the check broke")));
-            return r.Check("nulls", Baseline.RoundTrip, c => c.Is("x", "1") ? null : "never");
-        });
-        returned.ShouldBeNull("an exception never reads as a failure, so a probe returning it makes no violation");
-        ended.ShouldNotBeNull().Message.ShouldContain("keys harness-error: UNEXPECTED InvalidOperationException: the check broke");
-        Files.Str(line["category"]).ShouldBe("harness-error");
-        Files.Str(HarnessRun.Check(line, "keys")["category"]).ShouldBe("harness-error");
-        Files.Str(HarnessRun.Check(line, "nulls")["category"]).ShouldBe("pass", "the next check of the row still ran");
-    }
-
-    [Fact]
-    public void The_synchronous_form_keeps_an_exception_from_the_row_too()
-    {
-        var (ended, line) = HarnessRun.Row(outDir, 0, r =>
-        {
-            var returned = r.Check("keys", Baseline.Twin, (Func<Check, string?>)(_ => throw new FormatException("bad")));
-            return Task.FromResult(returned);
-        });
-        ended.ShouldNotBeNull().Message.ShouldContain("keys harness-error: UNEXPECTED FormatException: bad");
-        Files.Strings(line["reasons"]).ShouldBeEmpty("the exception stayed in the check");
-    }
-
-    [Fact]
-    public void A_pass_without_a_baseline_is_a_harness_error()
-    {
-        var (ended, line) = HarnessRun.Row(outDir, 0, r => Task.FromResult(r.Check("keys", null, c => c.Is("x", "1") ? null : "differs")));
-        ended.ShouldNotBeNull().Message.ShouldContain("keys harness-error: pass-without-baseline");
-        Files.Str(HarnessRun.Check(line, "keys")["category"]).ShouldBe("harness-error");
-        HarnessRun.Check(line, "keys")["baseline"].ShouldBeNull();
-    }
-
-    [Fact]
-    public void A_row_with_a_passing_check_and_one_that_did_not_apply_passes()
-    {
-        var (ended, line) = HarnessRun.Row(outDir, 0, r =>
-        {
-            r.Check("keys", Baseline.Twin, c => c.Is("x", "1") ? null : "differs");
-            r.Check("nulls", Baseline.Twin, c => c.Inapplicable(Cite.NotPromised("closed-set-has-no-null"), "x=1"));
-            return Task.FromResult<string?>(null);
-        });
-        ended.ShouldBeNull("one check compared and passed; the other did not apply, which voids nothing");
-        Files.Str(line["status"]).ShouldBe("pass");
-        Files.Str(line["category"]).ShouldBe("inapplicable", "the row's category is the highest of its checks'");
-        Files.Strings(HarnessRun.Check(line, "nulls")["reasons"]).ShouldBe(["inapplicable:not-promised:closed-set-has-no-null(x=1)"]);
-        Files.Str(HarnessRun.Check(line, "nulls")["notes"]).ShouldBe("not-promised:closed-set-has-no-null(x=1)");
-    }
-
-    [Fact]
-    public void A_row_where_no_check_passed_is_skipped_listing_each_check()
-    {
-        var (ended, line) = HarnessRun.Row(outDir, 0, r =>
-        {
-            r.Check("smallest-scale", Baseline.Twin, c => c.Inapplicable(Cite.NotPromised("closed-set-has-no-scale")));
-            r.Check("number-is-a-number", Baseline.Fact("KB-031"), c => c.Refused(Cite.Fact("KB-031")));
-            r.Check("reads-a-number", Baseline.Model, c => c.Inconclusive("both threw, not alike"));
-            r.Check("covers", Baseline.Docs("docs/json.md#decimals-in-one-spelling"), c => c.Refused(Cite.Docs("docs/json.md#decimals-in-one-spelling")));
-            r.Check("keeps", Baseline.Cost, c => c.Inapplicable(Cite.Record("0094")));
-            return Task.FromResult<string?>(null);
-        });
-        ended.ShouldNotBeNull().GetType().Name.ShouldBe("SkipException");
-        ended.Message.ShouldContain("smallest-scale inapplicable: not-promised:closed-set-has-no-scale; number-is-a-number expected-refusal: fact:KB-031; " +
-                                    "reads-a-number inconclusive: both threw, not alike; covers expected-refusal: docs:docs/json.md#decimals-in-one-spelling; " +
-                                    "keeps inapplicable: record:0094");
-        Files.Str(line["status"]).ShouldBe("fail");
-        Files.Str(line["category"]).ShouldBe("inconclusive");
-        line["checks"]!.AsArray().Select(c => Files.Str(c!["baseline"])).ShouldBe(["twin", "fact:KB-031", "model", "docs:docs/json.md#decimals-in-one-spelling", "cost"]);
-    }
-
-    [Fact]
-    public void A_violation_fails_the_row_even_beside_a_passing_check()
-    {
-        var (ended, line) = HarnessRun.Row(outDir, 0, r =>
-        {
-            r.Check("keys", Baseline.Twin, _ => (string?)null);
-            r.Check("nulls", Baseline.Twin, _ => "a null was written");
-            return Task.FromResult<string?>(null);
-        });
-        ended.ShouldNotBeNull().GetType().Name.ShouldNotBe("SkipException");
-        ended.Message.ShouldContain("nulls violation: a null was written");
-        ended.Message.ShouldNotContain("keys pass");
-        Files.Str(line["status"]).ShouldBe("fail");
-    }
-
-    [Fact]
-    public void A_row_that_runs_no_check_is_written_as_before()
-    {
-        var (ended, line) = HarnessRun.Row(outDir, 0, r => Task.FromResult<string?>(r["x"] == "1" ? null : "differs"));
-        ended.ShouldBeNull();
-        line.ContainsKey("checks").ShouldBeFalse();
-        line.Select(kv => kv.Key).ShouldBe(["idx", "status", "category", "completed", "applied", "reasons", "findings", "note"]);
-    }
-
-    [Fact]
-    public void Reads_notes_and_substitutions_through_the_row_inside_a_check_are_the_checks()
-    {
-        var (ended, line) = HarnessRun.Row(outDir, 0, async r =>
-        {
-            await r.Check("keys", Baseline.Twin, async c =>
-            {
-                await Task.Yield();
-                _ = r["y"];                                            // a helper handed the row, inside the check
-                _ = r.Get("x");
-                r.Substituted("x", "2", "the options ran as x=2");
-                r.Note(NoteKeys.Compared, "write");
-                return null;
-            });
-            return null;
-        });
-        ended.ShouldBeNull();
-        Files.StringMap(line["applied"]).ShouldBeEmpty("the row read nothing outside the check");
-        Files.Str(line["note"]).ShouldBeEmpty();
-        var check = HarnessRun.Check(line, "keys");
-        Files.StringMap(check["applied"]).OrderBy(kv => kv.Key, StringComparer.Ordinal).Select(kv => $"{kv.Key}={kv.Value}").ShouldBe(["x=2", "y=1"]);
-        Files.Str(check["notes"]).ShouldBe("substituted(x=2, the options ran as x=2);compared(write)");
-    }
-
-    [Fact]
-    public void A_malformed_citation_or_baseline_is_refused_at_construction()
-    {
-        Should.Throw<ArgumentException>(() => Cite.Fact("KB-31"));
-        Should.Throw<ArgumentException>(() => Cite.Record("94"));
-        Should.Throw<ArgumentException>(() => Cite.NotPromised("Closed set"));
-        Should.Throw<ArgumentException>(() => Cite.Docs("README.md#What TypeKit guarantees"));
-        Should.Throw<ArgumentException>(() => Cite.Docs("../outside.md"));
-        Should.Throw<ArgumentException>(() => Baseline.Fact("fact:KB-031"));
-        Should.Throw<ArgumentException>(() => Baseline.Docs("#anchor-alone"));
-        new[] { Baseline.Twin, Baseline.Framework, Baseline.RoundTrip, Baseline.Model, Baseline.Refusal, Baseline.Cost, Baseline.Fact("KB-031"), Baseline.Docs("README.md") }
-            .Select(b => b.Spelling).ShouldBe(["twin", "framework", "round-trip", "model", "refusal", "cost", "fact:KB-031", "docs:README.md"]);
-        new[] { Cite.NotPromised("a-b"), Cite.Docs("CHANGELOG.md#2.1.0-fixed"), Cite.Fact("KB-001"), Cite.Record("0094") }
-            .Select(c => c.Spelling).ShouldBe(["not-promised:a-b", "docs:CHANGELOG.md#2.1.0-fixed", "fact:KB-001", "record:0094"]);
-
-        var (ended, line) = HarnessRun.Row(outDir, 0, r => Task.FromResult(r.Check("keys", Baseline.Twin, c => c.Refused(Cite.Fact("KB-31")))));
-        ended.ShouldNotBeNull().Message.ShouldContain("keys harness-error: UNEXPECTED ArgumentException:");
-        Files.Str(HarnessRun.Check(line, "keys")["category"]).ShouldBe("harness-error");
-    }
-}
-
-/// <summary>
-/// The ledger credits checks, not rows: a passing check earns the pairs of the settings it ran under (the row's, its
-/// own laid over them) whatever another check of the row ended as, never a pair put together from two checks' reads,
-/// and `status` says per obligation what current checks earned and which no passing check named. The evidence is the
-/// harness's own lines, copied as the replay copies them.
-/// </summary>
-[Collection(nameof(ProbeOut))]
-public sealed class CheckLedgerTests : IDisposable
-{
-    private readonly Fixture fx = new();
-    public void Dispose() => fx.Dispose();
-
-    /// <summary>Runs P's two rows (x=1 y=1, x=2 y=2) through the harness and records the run as the replay would.</summary>
-    private JsonObject Record(Func<Row, Task<string?>> check)
-    {
-        var outDir = Path.Combine(fx.Root, "rows-out");
-        var rows = new JsonObject();
-        foreach (var (idx, v) in new[] { (0, "1"), (1, "2") })
-            rows[idx.ToString(System.Globalization.CultureInfo.InvariantCulture)] = Replay.EvidenceRow(HarnessRun.Row(outDir, idx, check, v, v).Line);
-        var path = Path.Combine(fx.Root, "evidence.json");
-        File.WriteAllText(path, new JsonObject
-        {
-            ["variants"] = new JsonArray(new JsonObject { ["env"] = new JsonObject(), ["expected"] = new JsonArray(0, 1), ["executed"] = new JsonArray(0, 1) }),
-            ["rows"] = rows,
-        }.ToJsonString());
-        fx.Footprint();
-        fx.Ledger("record-run", "--probe", "P", "--result", "pass", "--evidence", path).Exit.ShouldBe(0);
-        return JsonNode.Parse(File.ReadAllText(Path.Combine(fx.BranchDir, "evidence", "P.json")))!.AsObject();
-    }
-
-    private void Obligations()
-    {
-        fx.Write("README.md", "# a\n\nThe claim.\n\nA key is written as the wrapped type writes it.\n\nA null is refused.\n");
-        fx.Write("tools/probe/corpus/claims.json", """
-            [{"id": "C1", "source": "README.md#a", "surfaces": ["s"], "obligations": [
-              {"id": "keys", "sentence": "A key is written as the wrapped type writes it."},
-              {"id": "nulls", "sentence": "A null is refused."}]}]
-            """);
-        fx.Commit("obligations");
-        fx.Ledger("universe", "--base", "HEAD").Exit.ShouldBe(0);
-    }
-
-    private JsonObject Status()
-    {
-        var (exit, output, error) = fx.Ledger("status", "--json");
-        exit.ShouldBe(0, error);
-        return JsonNode.Parse(output)!["claims"]!["C1"]!.AsObject();
-    }
-
-    [Fact]
-    public void A_passing_check_earns_its_pairs_beside_a_check_that_did_not_apply()
-    {
-        var evidence = Record(r =>
-        {
-            r.Check("keys", Baseline.Twin, c => c["x"] == c["y"] ? null : "differs");
-            r.Check("nulls", Baseline.Twin, c => c.Inapplicable(Cite.NotPromised("no-null-here")));
-            return Task.FromResult<string?>(null);
-        });
-        Files.Num(evidence["schemaVersion"]).ShouldBe(2);
-        fx.Covered().ShouldBe(2, "x1y1 and x2y2, each read by the passing check, though every row ended inapplicable");
-    }
-
-    [Fact]
-    public void A_pair_is_never_put_together_from_two_checks_reads()
-    {
-        Record(r =>
-        {
-            r.Check("keys", Baseline.Twin, c => c["x"] is not null ? null : "never");
-            if (r.Index == 0) r.Check("nulls", Baseline.Twin, c => c["y"] is not null ? null : "never");
-            else r.Check("nulls", Baseline.Twin, c => c["x"] is not null && c["y"] is not null ? null : "never");
-            return Task.FromResult<string?>(null);
-        });
-        fx.Covered().ShouldBe(1, "row 0's checks read x and y apart, which credits no pair; row 1's second check read both");
-    }
-
-    [Fact]
-    public void The_rows_own_reads_are_what_every_check_ran_under()
-    {
-        Record(r =>
-        {
-            _ = r["x"];
-            r.Check("keys", Baseline.Twin, c => c["y"] is not null ? null : "never");
-            return Task.FromResult<string?>(null);
-        });
-        fx.Covered().ShouldBe(2);
-    }
-
-    [Fact]
-    public void A_row_without_checks_is_one_check_of_the_claim()
-    {
-        Record(r => Task.FromResult<string?>(r["x"] == r["y"] ? null : "differs"));
-        fx.Covered().ShouldBe(2);
-        var obligation = Status()["obligations"]!.AsArray().ShouldHaveSingleItem()!;
-        Files.Str(obligation["id"]).ShouldBe("claim");
-        Files.Num(obligation["current"]).ShouldBe(2);
-    }
-
-    [Fact]
-    public void Status_gives_each_obligation_its_current_pairs_and_counts_those_no_passing_check_named()
-    {
-        Obligations();
-        Record(r =>
-        {
-            r.Check("keys", Baseline.Twin, c => c["x"] == c["y"] ? null : "differs");
-            r.Check("nulls", Baseline.Twin, c => c.Inapplicable(Cite.NotPromised("no-null-here")));
-            return Task.FromResult<string?>(null);
-        });
-        var claim = Status();
-        claim["obligations"]!.AsArray().Select(o => $"{Files.Str(o!["id"])} {Files.Num(o["current"])} {o["passed"]!.GetValue<bool>()}").ShouldBe(["keys 2 True", "nulls 0 False"]);
-        claim["check_outcomes"]!.AsObject().Select(kv => $"{kv.Key} {Files.Num(kv.Value)}").ShouldBe(["inapplicable 2", "pass 2"]);
-        claim["outcomes"]!.AsObject().Select(kv => $"{kv.Key} {Files.Num(kv.Value)}").ShouldBe(["inapplicable 2"]);
-        fx.Ledger("status").Out.ReplaceLineEndings("\n")
-          .ShouldContain("\n  C1: 2/4  (rows: inapplicable 2; checks: inapplicable 2, pass 2)  obligations 2 (2 without a seed: keys, nulls), 1 uncredited\n");
-    }
-
-    [Fact]
-    public void The_replay_keeps_each_checks_fields_and_six_reasons()
-    {
-        var line = JsonNode.Parse("""
-            {"idx": 0, "category": "inapplicable", "applied": {"x": "1"}, "reasons": [], "findings": [], "note": "",
-             "checks": [{"obligation": "keys", "baseline": "twin", "category": "inapplicable", "applied": {"y": "1"},
-                         "reasons": ["inapplicable:1", "inapplicable:2", "inapplicable:3", "inapplicable:4", "inapplicable:5", "inapplicable:6", "inapplicable:7"], "notes": "n"},
-                        {"obligation": "nulls", "baseline": null, "category": "harness-error", "applied": {}, "reasons": [], "notes": ""}]}
-            """)!.AsObject();
-        var row = Replay.EvidenceRow(line);
-        var checks = row["checks"]!.AsArray();
-        checks.Count.ShouldBe(2);
-        Files.Str(checks[0]!["obligation"]).ShouldBe("keys");
-        Files.Str(checks[0]!["baseline"]).ShouldBe("twin");
-        Files.StringMap(checks[0]!["applied"]).ShouldBe(new Dictionary<string, string> { ["y"] = "1" });
-        Files.Strings(checks[0]!["reasons"]).Count().ShouldBe(6);
-        Files.Str(checks[0]!["notes"]).ShouldBe("n");
-        checks[1]!["baseline"].ShouldBeNull();
-        Replay.EvidenceRow(JsonNode.Parse("""{"idx": 0, "category": "pass", "applied": {}}""")!.AsObject()).ContainsKey("checks").ShouldBeFalse();
-    }
-}
-
-/// <summary>
-/// `seeds` judges a seed by the checks it fires: a seed naming obligation O is caught only by a clean violation of a
-/// check naming O, in a row whose unseeded run had no violation of O; a seed naming none by any check. P's rows run a
-/// check of each obligation through the real harness; SEED names the check the seeded build breaks.
-/// </summary>
-[Collection(nameof(ProbeOut))]
-public sealed class CheckSeedsTests : IDisposable
-{
-    private readonly Fixture fx = new();
-    private readonly string cache;
-
-    public CheckSeedsTests()
-    {
-        cache = fx.Root + "-cache";
-        fx.Sh("git", "config", "core.autocrlf", "false");
-        fx.Write("README.md", "# a\n\nThe claim.\n\nA key is written as the wrapped type writes it.\n\nA null is refused.\n");
-        fx.Write("tools/probe/corpus/claims.json", """
-            [{"id": "C1", "source": "README.md#a", "surfaces": ["s"], "obligations": [
-              {"id": "keys", "sentence": "A key is written as the wrapped type writes it."},
-              {"id": "nulls", "sentence": "A null is refused."}]}]
-            """);
-        fx.Write(".claude/probe-axes.md", "```json probe-axes\n" + new JsonObject
-        {
-            ["axes"] = new JsonObject { ["x"] = new JsonArray("1", "2"), ["y"] = new JsonArray("1", "2") },
-            ["surfaces"] = new JsonObject { ["s"] = new JsonObject { ["axes"] = new JsonArray("x", "y"), ["watched"] = new JsonArray("src") } },
-            ["replay"] = new JsonObject { ["probeDir"] = "probes", ["include"] = new JsonArray("src") },
-        }.ToJsonString() + "\n```\n");
-        fx.Commit("obligations and the replay configuration");
-    }
-
-    public void Dispose()
-    {
-        fx.Dispose();
-        try { Directory.Delete(cache, recursive: true); } catch (IOException) { } catch (UnauthorizedAccessException) { }
-    }
-
-    /// <summary>Registers P with one seed per (obligation, SEED value): the seed names the obligation, and its build breaks the check SEED names.</summary>
-    private void Register(params (string? Obligation, string Breaks)[] seeds)
-    {
-        fx.Write("tools/probe/corpus/registry.json", new JsonObject
-        {
-            ["probes"] = new JsonObject
-            {
-                ["P"] = new JsonObject
-                {
-                    ["claim"] = "C1", ["filter"] = "*P",
-                    ["seeds"] = new JsonArray([.. seeds.Select(s => (JsonNode)new JsonObject
-                    {
-                        ["obligation"] = s.Obligation, ["env"] = new JsonObject { ["SEED"] = s.Breaks }, ["defect"] = $"{s.Breaks} breaks.",
-                    })]),
-                },
-            },
-        }.ToJsonString());
-        fx.Commit("register");
-    }
-
-    private (int Exit, string Out) Seeds(HarnessAdapter adapter)
-    {
-        var output = new StringWriter();
-        var context = new Context(fx.Root, new Dictionary<string, string?> { ["PROBE_CACHE_DIR"] = cache }, output, output);
-        int exit;
-        try { exit = global::Prober.Seeds.Run(context, new Args([], new HashSet<string>(StringComparer.Ordinal)), adapter); }
-        catch (Refusal refusal) { output.WriteLine(refusal.Message); exit = refusal.ExitCode; }
-        return (exit, output.ToString().ReplaceLineEndings("\n"));
-    }
-
-    /// <summary>Row 1 runs a check of keys and one of nulls; the one SEED names fails. <paramref name="unseeded"/> fails a check of row 1 without a seed.</summary>
-    private static Func<Row, string?, Task<string?>> TwoChecks(string? unseeded = null) => (r, seed) =>
-    {
-        foreach (var obligation in new[] { "keys", "nulls" })
-            r.Check(obligation, Baseline.Twin, _ => r.Index == 1 && (seed == obligation || unseeded == obligation) ? $"{obligation} broke" : null);
-        return Task.FromResult<string?>(null);
-    };
-
-    [Fact]
-    public void A_seed_naming_an_obligation_is_caught_only_by_a_check_naming_it()
-    {
-        Register(("keys", "nulls"), ("nulls", "nulls"));
-        var (exit, output) = Seeds(new HarnessAdapter(TwoChecks()));
-        exit.ShouldBe(1, output);
-        output.ShouldContain("\n  P/keys (C1): missed, no row violates that did not already (2 rows: pass 1, violation 1; 1 violate by a check naming nulls, not keys;");
-        output.ShouldContain("\n  P/nulls (C1): caught, 1 of 2 rows violate; e.g. #1 nulls: violation:nulls broke\n");
-    }
-
-    [Fact]
-    public void The_baseline_is_per_row_and_obligation()
-    {
-        Register(("keys", "keys"));
-        var (exit, output) = Seeds(new HarnessAdapter(TwoChecks(unseeded: "nulls")));
-        exit.ShouldBe(0, output);
-        output.ShouldContain("\n  P/keys (C1): caught, 1 of 2 rows violate; e.g. #1 keys: violation:keys broke\n",
-                             Case.Sensitive, "row 1 violated nulls unseeded, which takes nothing from a violation of keys there");
-    }
-
-    [Fact]
-    public void A_seed_naming_none_is_caught_by_any_check()
-    {
-        Register((null, "nulls"));
-        var (exit, output) = Seeds(new HarnessAdapter(TwoChecks()));
-        exit.ShouldBe(0, output);
-        output.ShouldContain("\n  P (C1): caught, 1 of 2 rows violate; e.g. #1 nulls: violation:nulls broke\n");
-    }
-
-    [Fact]
-    public void A_harness_error_of_the_row_outside_its_checks_makes_no_check_a_catch()
-    {
-        Register(("keys", "keys"));
-        var (exit, output) = Seeds(new HarnessAdapter((r, seed) =>
-        {
-            if (seed is not null && r.Index == 1) r.Outcome("harness-error", "the host did not start");
-            return TwoChecks()(r, seed);
-        }));
-        exit.ShouldBe(1, output);
-        output.ShouldContain("\n  P/keys (C1): missed, no row violates that did not already (2 rows: pass 1, violation 1; 1 ended in a harness error, which is no catch;");
-    }
-
-    [Fact]
-    public void A_row_without_checks_catches_no_seed_naming_an_obligation()
-    {
-        Register(("keys", "keys"));
-        var (exit, output) = Seeds(new HarnessAdapter((r, seed) => Task.FromResult<string?>(seed is not null && r.Index == 1 ? "row 1 broke" : null)));
-        exit.ShouldBe(1, output);
-        output.ShouldContain("1 violate by a check naming claim, not keys;");
-    }
-
-    /// <summary>The probe P over two rows, each run through the real harness with the value of SEED (null unseeded).</summary>
-    private sealed class HarnessAdapter(Func<Row, string?, Task<string?>> check) : IProbeAdapter
-    {
-        public Ran Build(string worktree, IReadOnlyDictionary<string, string?> environment) => new(0, "Build: OK", "");
-
-        public Ran RunProbe(string worktree, string filter, string results, string coverageFile, IReadOnlyDictionary<string, string?> environment)
-        {
-            var seed = environment.GetValueOrDefault("SEED");
-            var outDir = environment["PROBE_OUT"]!;
-            var failed = false;
-            for (var idx = 0; idx < 2; idx++)
-                failed |= HarnessRun.Row(outDir, idx, r => check(r, seed)).Ended is not null;
-            return new Ran(failed ? 1 : 0, "", "");
-        }
-
-        public (JsonObject? Axes, string? Error) DeriveAxes(string checkout, string workDirectory) => (null, "none");
-
-        public IReadOnlyDictionary<string, string?> Environment(string cacheDirectory) => new Dictionary<string, string?>();
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/RegisterTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/RegisterTests.cs
deleted file mode 100644
index a8e95229..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/RegisterTests.cs
+++ /dev/null
@@ -1,171 +0,0 @@
-using System.Text.Json.Nodes;
-using System.Text.RegularExpressions;
-using Prober;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>
-/// `register --obligation O` writes a seed per obligation (decision 104) into the entry's `seeds`, in place of
-/// any seed that names O already, and refuses an O the claim does not list; `new` prints that command for each
-/// listed obligation, so no seed is written into the registry by hand. C1 lists keys and nulls; C7 lists none.
-/// </summary>
-public sealed class RegisterTests : IDisposable
-{
-    private readonly Fixture fx = new();
-
-    public RegisterTests()
-    {
-        fx.Write(".claude/probe-axes.md", "```json probe-axes\n" + new JsonObject
-        {
-            ["axes"] = new JsonObject { ["x"] = new JsonArray("1", "2"), ["y"] = new JsonArray("1", "2") },
-            ["surfaces"] = new JsonObject { ["s"] = new JsonObject { ["axes"] = new JsonArray("x", "y"), ["watched"] = new JsonArray("src") } },
-            ["replay"] = new JsonObject { ["probeDir"] = "probes", ["include"] = new JsonArray("src"), ["families"] = new JsonObject { ["f"] = new JsonArray("s") } },
-        }.ToJsonString() + "\n```\n");
-        fx.Write("tools/probe/corpus/claims.json", new JsonArray(
-            new JsonObject
-            {
-                ["id"] = "C1", ["source"] = "README.md#a", ["surfaces"] = new JsonArray("s"),
-                ["obligations"] = new JsonArray(
-                    new JsonObject { ["id"] = "keys", ["sentence"] = "The claim." },
-                    new JsonObject { ["id"] = "nulls", ["sentence"] = "The claim." }),
-            },
-            new JsonObject { ["id"] = "C7", ["source"] = "README.md#a", ["surfaces"] = new JsonArray("s") }).ToJsonString());
-        fx.Commit("claims with obligations");
-        fx.Ledger("universe", "--base", "HEAD").Exit.ShouldBe(0);
-    }
-
-    public void Dispose() => fx.Dispose();
-
-    private string StagedRegistry => Path.Combine(fx.BranchDir, "staging", "registry.json");
-
-    private JsonObject Entry(string probe = "P") => JsonNode.Parse(File.ReadAllText(StagedRegistry))!["probes"]![probe]!.AsObject();
-
-    private (int Exit, string Out, string Err) Register(params string[] more) =>
-        fx.Ledger(["register", "--probe", "P", "--claim", "C1", "--filter", "*P", .. more]);
-
-    private static string Seeds(JsonObject entry) =>
-        string.Join("; ", entry["seeds"]!.AsArray().Select(s => $"{s!["obligation"]}={s["patch"]}:{s["defect"]}"));
-
-    [Fact]
-    public void An_obligation_s_seed_goes_into_seeds()
-    {
-        var (exit, output, error) = Register("--obligation", "keys", "--seed", "seeds/C1-keys.patch", "--defect", "A key is written with ToString().");
-        exit.ShouldBe(0, output + error);
-        var entry = Entry();
-        entry["seeds"]!.ToJsonString().ShouldBe("""[{"obligation":"keys","patch":"seeds/C1-keys.patch","defect":"A key is written with ToString()."}]""");
-        entry.ContainsKey("seed").ShouldBeFalse("a seed naming an obligation is not the probe's one `seed`");
-        output.ShouldContain("seed for obligation keys of P");
-    }
-
-    [Fact]
-    public void A_seed_for_an_obligation_that_has_one_replaces_it()
-    {
-        Register("--obligation", "keys", "--seed", "seeds/C1-keys.patch", "--defect", "first").Exit.ShouldBe(0);
-        Register("--obligation", "nulls", "--seed", "seeds/C1-nulls.patch", "--defect", "nulls").Exit.ShouldBe(0);
-        var (exit, output, _) = Register("--obligation", "keys", "--seed", "seeds/C1-keys-2.patch", "--defect", "second");
-        exit.ShouldBe(0);
-        output.ShouldContain("seed for obligation keys of P, in place of the 1 it had");
-        Seeds(Entry()).ShouldBe("nulls=seeds/C1-nulls.patch:nulls; keys=seeds/C1-keys-2.patch:second");
-    }
-
-    [Fact]
-    public void The_one_seed_naming_the_obligation_is_replaced_and_one_naming_another_kept()
-    {
-        fx.Write("tools/probe/corpus/registry.json", """
-            {"probes": {
-              "P": {"claim": "C1", "filter": "*P", "seed": {"patch": "seeds/C1.patch", "defect": "old", "obligation": "keys"}},
-              "Q": {"claim": "C1", "filter": "*Q", "seed": {"patch": "seeds/C1-q.patch", "defect": "kept", "obligation": "nulls"}}}}
-            """);
-        fx.Commit("probes whose one seed names an obligation");
-
-        Register("--obligation", "keys", "--seed", "seeds/C1-keys.patch", "--defect", "new").Exit.ShouldBe(0);
-        Entry().ContainsKey("seed").ShouldBeFalse("the seed that named keys is replaced, not kept beside the new one");
-        Seeds(Entry()).ShouldBe("keys=seeds/C1-keys.patch:new");
-
-        fx.Ledger("register", "--probe", "Q", "--claim", "C1", "--filter", "*Q", "--obligation", "keys", "--seed", "seeds/C1-qk.patch", "--defect", "q").Exit.ShouldBe(0);
-        Entry("Q")["seed"]!["obligation"]!.GetValue<string>().ShouldBe("nulls");
-        Seeds(Entry("Q")).ShouldBe("keys=seeds/C1-qk.patch:q");
-    }
-
-    [Theory]
-    [InlineData("C1", "kyes", "claim C1 lists no obligation kyes (it lists keys, nulls)")]
-    [InlineData("C1", "claim", "claim C1 lists no obligation claim (it lists keys, nulls)")]
-    [InlineData("C7", "keys", "claim C7 lists no obligation keys (it lists claim)")]
-    public void An_obligation_the_claim_does_not_list_is_refused_and_nothing_staged(string claim, string obligation, string message)
-    {
-        var (exit, _, error) = fx.Ledger("register", "--probe", "P", "--claim", claim, "--filter", "*P", "--obligation", obligation, "--seed", "seeds/x.patch", "--defect", "d");
-        exit.ShouldBe(2);
-        error.ShouldContain(message);
-        File.Exists(StagedRegistry).ShouldBeFalse();
-    }
-
-    [Fact]
-    public void A_claim_without_obligations_takes_a_seed_for_its_one()
-    {
-        fx.Ledger("register", "--probe", "P", "--claim", "C7", "--filter", "*P", "--obligation", "claim", "--seed", "seeds/C7.patch", "--defect", "d").Exit.ShouldBe(0);
-        Seeds(Entry()).ShouldBe("claim=seeds/C7.patch:d");
-    }
-
-    [Fact]
-    public void A_claim_that_is_not_in_the_claims_is_refused()
-    {
-        var (exit, _, error) = fx.Ledger("register", "--probe", "P", "--claim", "C9", "--filter", "*P", "--obligation", "keys", "--seed", "seeds/x.patch", "--defect", "d");
-        exit.ShouldBe(1);
-        error.ShouldContain("no claim C9 in claims.json");
-        File.Exists(StagedRegistry).ShouldBeFalse();
-    }
-
-    [Fact]
-    public void An_obligation_without_a_seed_or_a_defect_is_refused()
-    {
-        var (exit, _, error) = Register("--obligation", "keys", "--defect", "d");
-        exit.ShouldBe(2);
-        error.ShouldContain("give the seed with --seed PATCH or --seed-env NAME=VALUE");
-        Register("--obligation", "keys", "--seed", "seeds/C1-keys.patch").Exit.ShouldBe(2, "a seed without its defect");
-        File.Exists(StagedRegistry).ShouldBeFalse();
-    }
-
-    [Fact]
-    public void An_environment_toggle_is_a_seed_too()
-    {
-        Register("--obligation", "nulls", "--seed-env", "A=1", "B=x=y", "--defect", "d").Exit.ShouldBe(0);
-        Entry()["seeds"]!.ToJsonString().ShouldBe("""[{"obligation":"nulls","env":{"A":"1","B":"x=y"},"defect":"d"}]""");
-        Register("--seed-env", "C=2", "--defect", "one").Exit.ShouldBe(0);
-        Entry()["seed"]!.ToJsonString().ShouldBe("""{"env":{"C":"2"},"defect":"one"}""");
-        Register("--obligation", "nulls", "--seed-env", "=1", "--defect", "d").Exit.ShouldBe(2, "a toggle without a name");
-    }
-
-    [Fact]
-    public void A_seed_stales_no_result()
-    {
-        var before = new Ledger(new Context(fx.Root, new Dictionary<string, string?>(), TextWriter.Null, TextWriter.Null), null).Identity("P");
-        Register("--obligation", "keys", "--seed", "seeds/C1-keys.patch", "--defect", "d").Exit.ShouldBe(0);
-        Register("--seed", "seeds/C1.patch", "--defect", "d").Exit.ShouldBe(0);
-        Entry().ContainsKey("seeds").ShouldBeTrue();
-        new Ledger(new Context(fx.Root, new Dictionary<string, string?>(), TextWriter.Null, TextWriter.Null), null).Identity("P").ShouldBe(before);
-    }
-
-    [Fact]
-    public void The_commands_new_prints_register_each_obligation_s_seed()
-    {
-        var (exit, output, _) = fx.Ledger("new", "--claim", "C1", "--probe", "C1KeysProbe");
-        exit.ShouldBe(0);
-        var commands = Regex.Matches(output, @"`prober (register [^`]*)`").Select(m => m.Groups[1].Value).ToList();
-        commands.Count.ShouldBe(2, output);
-        output.ShouldNotContain("in the entry's `seeds`");
-        foreach (var command in commands)
-        {
-            var args = Regex.Matches(command, @"""([^""]*)""|(\S+)").Select(m => m.Groups[1].Success ? m.Groups[1].Value : m.Groups[2].Value)
-                            .Select(arg => arg == "..." ? "What the seed breaks." : arg).ToArray();
-            var (registered, said, error) = fx.Ledger(args);
-            registered.ShouldBe(0, command + ": " + said + error);
-        }
-
-        var entry = Entry("C1KeysProbe");
-        entry["filter"]!.GetValue<string>().ShouldBe("*C1KeysProbe");
-        Seeds(entry).ShouldBe("keys=seeds/C1-keys.patch:What the seed breaks.; nulls=seeds/C1-nulls.patch:What the seed breaks.");
-        var problems = global::Prober.Seeds.Problems(new Ledger(new Context(fx.Root, new Dictionary<string, string?>(), TextWriter.Null, TextWriter.Null), null));
-        problems.ShouldNotContain(p => p.StartsWith("C1KeysProbe: no seed", StringComparison.Ordinal));
-        problems.ShouldNotContain(p => p.StartsWith("C1: obligation", StringComparison.Ordinal));
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/ReplayTemplateTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/ReplayTemplateTests.cs
deleted file mode 100644
index 6c0b723b..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/ReplayTemplateTests.cs
+++ /dev/null
@@ -1,98 +0,0 @@
-using System.Text.Json.Nodes;
-using Prober;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>
-/// The replay's templates name only what the repository has. A tool that moves (a script ported to a tool
-/// project) must not leave the replay starting a file that is gone: that fails only on the next replay, far
-/// from the commit that caused it.
-/// </summary>
-public sealed class ReplayTemplateTests
-{
-    private static string RepositoryRoot()
-    {
-        for (var dir = new DirectoryInfo(AppContext.BaseDirectory); dir is not null; dir = dir.Parent)
-            if (File.Exists(Path.Combine(dir.FullName, "CodoMetis.TypeKit.slnx"))) return dir.FullName;
-        throw new InvalidOperationException("no CodoMetis.TypeKit.slnx above the test output");
-    }
-
-    /// <summary>
-    /// Every path a template names: a file must be tracked in the repository; a dll under a project's bin/ must
-    /// come from a project there that a "prepare" command builds (a fresh worktree has no build output).
-    /// </summary>
-    internal static List<string> Problems(string root, JsonObject replay)
-    {
-        var problems = new List<string>();
-        var prepared = (replay["prepare"] as JsonArray ?? []).OfType<JsonArray>()
-            .SelectMany(c => c.Select(a => a?.GetValue<string>() ?? "")).ToHashSet(StringComparer.Ordinal);
-        var templates = new List<(string Name, IEnumerable<string> Args)>();
-        foreach (var name in new[] { "build", "test" })
-            templates.Add((name, (replay[name] as JsonArray ?? []).Select(a => a?.GetValue<string>() ?? "")));
-        foreach (var (i, command) in (replay["prepare"] as JsonArray ?? []).OfType<JsonArray>().Index())
-            templates.Add(($"prepare[{i}]", command.Select(a => a?.GetValue<string>() ?? "")));
-        if (replay["enumerate"]?["script"]?.GetValue<string>() is { } script) templates.Add(("enumerate", [script]));
-
-        foreach (var (name, args) in templates)
-            foreach (var arg in args.Where(a => a.Contains('/') && !a.Contains('{')))
-            {
-                var bin = arg.IndexOf("/bin/", StringComparison.Ordinal);
-                if (bin >= 0)
-                {
-                    var project = arg[..bin];
-                    if (!Directory.Exists(Path.Combine(root, project)) || !Directory.EnumerateFiles(Path.Combine(root, project), "*.csproj").Any())
-                        problems.Add($"{name}: {arg} comes from {project}, which is no project in the repository");
-                    else if (!prepared.Contains(project))
-                        problems.Add($"{name}: {arg} is build output of {project}, which no \"prepare\" command builds");
-                }
-                else if (!File.Exists(Path.Combine(root, arg)) && !Directory.Exists(Path.Combine(root, arg)))
-                    problems.Add($"{name}: {arg} is not in the repository");
-            }
-        return problems;
-    }
-
-    private static JsonObject RepositoryReplay(string root) =>
-        Axes.Block(Path.Combine(root, ".claude", "probe-axes.md"))["replay"] as JsonObject ?? throw new InvalidOperationException("no replay object");
-
-    [Fact]
-    public void The_replay_templates_name_only_what_the_repository_has()
-    {
-        var root = RepositoryRoot();
-        Problems(root, RepositoryReplay(root)).ShouldBeEmpty();
-    }
-
-    [Fact]
-    public void A_template_naming_a_removed_script_is_caught()
-    {
-        // The seed: the templates as they were before the verdict script became a tool project.
-        var root = RepositoryRoot();
-        var replay = (JsonObject)RepositoryReplay(root).DeepClone();
-        replay["build"] = new JsonArray("tools/build-verdict.sh", "build", "{project}");
-        Problems(root, replay).ShouldContain(p => p.Contains("tools/build-verdict.sh is not in the repository", StringComparison.Ordinal));
-    }
-
-    [Fact]
-    public void A_tool_dll_no_prepare_command_builds_is_caught()
-    {
-        var root = RepositoryRoot();
-        var replay = (JsonObject)RepositoryReplay(root).DeepClone();
-        replay.Remove("prepare");
-        Problems(root, replay).ShouldContain(p => p.Contains("which no \"prepare\" command builds", StringComparison.Ordinal));
-    }
-
-    [Fact]
-    public void A_bare_command_is_found_on_PATH_and_a_path_must_exist_in_the_worktree()
-    {
-        var worktree = Path.Combine(Path.GetTempPath(), "prober-exe-" + Guid.NewGuid().ToString("N"));
-        Directory.CreateDirectory(Path.Combine(worktree, "tools"));
-        try
-        {
-            DotNetAdapter.Executable(worktree, "dotnet").ShouldBe("dotnet");
-            File.WriteAllText(Path.Combine(worktree, "tools", "run.sh"), "");
-            DotNetAdapter.Executable(worktree, "tools/run.sh").ShouldBe(Path.Combine(worktree, "tools/run.sh"));
-            Should.Throw<Refusal>(() => DotNetAdapter.Executable(worktree, "tools/build-verdict.sh"))
-                  .Message.ShouldContain("tools/build-verdict.sh");
-        }
-        finally { Directory.Delete(worktree, recursive: true); }
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/ReplayTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/ReplayTests.cs
deleted file mode 100644
index b4502eec..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/ReplayTests.cs
+++ /dev/null
@@ -1,368 +0,0 @@
-using System.Text.Json.Nodes;
-using Prober;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>
-/// The replay runs probes in parallel, by family, with or without a footprint, and `merge` joins the states
-/// of a replay split by family (decision 101). The probes here are a fake adapter: P covers C1 (surface s)
-/// and Q covers C2 (surface t); a run writes its rows and, when asked for one, a coverage report that names
-/// src/a.cs.
-/// </summary>
-public sealed class ReplayTests : IDisposable
-{
-    private readonly Fixture fx = new();
-    private readonly string cache;
-    private readonly FakeAdapter adapter = new();
-    private readonly List<string> states = [];
-
-    public ReplayTests()
-    {
-        cache = fx.Root + "-cache";
-        fx.Sh("git", "config", "core.autocrlf", "false");
-        Axes(new JsonObject { ["a"] = new JsonArray("s"), ["b"] = new JsonArray("t") });
-        fx.Write("tools/probe/corpus/claims.json", """[{"id": "C1", "source": "README.md#a", "surfaces": ["s"]}, {"id": "C2", "source": "README.md#a", "surfaces": ["t"]}]""");
-        fx.Write("tools/probe/corpus/registry.json", """{"probes": {"P": {"claim": "C1", "filter": "*P"}, "Q": {"claim": "C2", "filter": "*Q"}}}""");
-        fx.Write("tools/probe/corpus/harness/Q.cs", "// probe Q\n");
-        fx.Write("tools/probe/corpus/rows/Q.json", new JsonObject
-        {
-            ["claim"] = "C2", ["rows"] = new JsonArray(new JsonObject { ["row"] = new JsonObject { ["x"] = "1", ["y"] = "1" } }),
-        }.ToJsonString());
-        fx.Commit("two probes of two families");
-    }
-
-    public void Dispose()
-    {
-        fx.Dispose();
-        foreach (var dir in states.Append(cache))
-            try { Directory.Delete(dir, recursive: true); } catch (IOException) { } catch (UnauthorizedAccessException) { }
-    }
-
-    /// <summary>The axes file with a replay configuration; its families are the given ones, or none.</summary>
-    private void Axes(JsonObject? families)
-    {
-        var replay = new JsonObject { ["probeDir"] = "probes", ["include"] = new JsonArray("src") };
-        if (families is not null) replay["families"] = families;
-        fx.Write(".claude/probe-axes.md", "```json probe-axes\n" + new JsonObject
-        {
-            ["axes"] = new JsonObject { ["x"] = new JsonArray("1", "2"), ["y"] = new JsonArray("1", "2") },
-            ["surfaces"] = new JsonObject
-            {
-                ["s"] = new JsonObject { ["axes"] = new JsonArray("x", "y"), ["watched"] = new JsonArray("src") },
-                ["t"] = new JsonObject { ["axes"] = new JsonArray("x", "y"), ["watched"] = new JsonArray("src") },
-            },
-            ["replay"] = replay,
-        }.ToJsonString() + "\n```\n");
-    }
-
-    /// <summary>A state directory of its own, as a leg of a matrix or the job that merges them has.</summary>
-    private string State(string name)
-    {
-        var dir = fx.Root + "-" + name;
-        states.Add(dir);
-        return dir;
-    }
-
-    private static readonly HashSet<string> Flags = new(StringComparer.Ordinal) { "all", "dry-run", "where", "no-footprint" };
-
-    private (int Exit, string Out, string Err) Replay(string? state, params string[] args)
-    {
-        var output = new StringWriter(); var error = new StringWriter();
-        var env = new Dictionary<string, string?> { ["PROBE_CACHE_DIR"] = cache };
-        if (state is not null) env["PROBE_STATE_DIR"] = state;
-        int exit;
-        try { exit = global::Prober.Replay.Run(new Context(fx.Root, env, output, error), new Args(args, Flags), adapter); }
-        catch (Refusal refusal) { error.WriteLine(refusal.Message); exit = refusal.ExitCode; }
-        return (exit, output.ToString(), error.ToString());
-    }
-
-    /// <summary>A replay in another checkout of the repository, a linked worktree, with the fake adapter.</summary>
-    private (int Exit, string Out, string Err) ReplayIn(string checkout, params string[] args)
-    {
-        var output = new StringWriter(); var error = new StringWriter();
-        int exit;
-        try { exit = global::Prober.Replay.Run(new Context(checkout, new Dictionary<string, string?> { ["PROBE_CACHE_DIR"] = cache }, output, error), new Args(args, Flags), adapter); }
-        catch (Refusal refusal) { error.WriteLine(refusal.Message); exit = refusal.ExitCode; }
-        return (exit, output.ToString(), error.ToString());
-    }
-
-    private string Home(string checkout) =>
-        global::Prober.Replay.Home(new Context(checkout, new Dictionary<string, string?> { ["PROBE_CACHE_DIR"] = cache }, TextWriter.Null, TextWriter.Null),
-                                   new global::Prober.Ledger(new Context(checkout, new Dictionary<string, string?>(), TextWriter.Null, TextWriter.Null), null));
-
-    private (int Exit, string Out, string Err) Ledger(string? state, params string[] args) =>
-        state is null ? fx.Ledger(args) : fx.LedgerWith(new Dictionary<string, string?> { ["PROBE_STATE_DIR"] = state }, args);
-
-    private string BranchDir(string? state) => Path.Combine(state ?? fx.Memory, "branches", "main");
-    private bool HasEvidence(string? state, string probe) => File.Exists(Path.Combine(BranchDir(state), "evidence", probe + ".json"));
-    private JsonObject Last(string? state) => (JsonObject)JsonNode.Parse(File.ReadAllText(Path.Combine(BranchDir(state), "replay-last.json")))!;
-    private int Lines(string? state, string file) =>
-        File.Exists(Path.Combine(BranchDir(state), file)) ? File.ReadAllLines(Path.Combine(BranchDir(state), file)).Count(l => l.Trim().Length > 0) : 0;
-
-    [Fact]
-    public void A_family_replays_the_probes_whose_claim_surface_it_holds()
-    {
-        var (exit, output, error) = Replay(null, "--all", "--family", "a");
-        exit.ShouldBe(0, error + output);
-        output.ShouldContain("1 of 1 probes to replay (family a)");
-        HasEvidence(null, "P").ShouldBeTrue();
-        HasEvidence(null, "Q").ShouldBeFalse("Q's claim is of surface t, family b");
-        Files.Strings(Last(null)["selected"]).ShouldBe(["P"]);
-        Files.Str(Last(null)["family"]).ShouldBe("a");
-
-        Replay(null, "--all", "--family", "b").Exit.ShouldBe(0);
-        HasEvidence(null, "Q").ShouldBeTrue();
-    }
-
-    [Fact]
-    public void A_probe_whose_surface_is_in_no_family_refuses_the_replay()
-    {
-        Axes(new JsonObject { ["a"] = new JsonArray("s") });
-        fx.Commit("family b dropped");
-        var (exit, _, error) = Replay(null, "--all", "--family", "a");
-        exit.ShouldBe(1, "a matrix by family would never run Q");
-        error.ShouldContain("Q");
-        error.ShouldContain("in no family");
-        HasEvidence(null, "P").ShouldBeFalse("nothing ran");
-    }
-
-    [Fact]
-    public void An_unknown_family_and_a_bad_parallel_are_usage_errors()
-    {
-        Replay(null, "--all", "--family", "c").Exit.ShouldBe(2);
-        Replay(null, "--all", "--parallel", "0").Exit.ShouldBe(2);
-        Replay(null, "--all", "--parallel", "two").Exit.ShouldBe(2);
-        Axes(null);
-        fx.Commit("no families");
-        var (exit, _, error) = Replay(null, "--all", "--family", "a");
-        exit.ShouldBe(2);
-        error.ShouldContain("names no families");
-    }
-
-    [Fact]
-    public void A_replay_without_a_footprint_records_evidence_and_leaves_the_probes_stale()
-    {
-        var (exit, output, error) = Replay(null, "--all", "--no-footprint");
-        exit.ShouldBe(0, error + output);
-        adapter.CoverageAsked.ShouldBeEmpty("no coverage report is asked for without a footprint");
-        output.ShouldContain("footprint: not recorded (--no-footprint)");
-        HasEvidence(null, "P").ShouldBeTrue();
-        HasEvidence(null, "Q").ShouldBeTrue();
-        Lines(null, "footprints.jsonl").ShouldBe(0);
-        Last(null)["footprint"]!.GetValue<bool>().ShouldBeFalse();
-        Ledger(null, "stale").Out.ShouldStartWith("2 of 2 probes to replay");
-
-        Replay(null, "--all").Exit.ShouldBe(0);
-        adapter.CoverageAsked.Count.ShouldBe(2);
-        Lines(null, "footprints.jsonl").ShouldBe(2);
-        Ledger(null, "stale").Out.ShouldStartWith("0 of 2 probes to replay");
-    }
-
-    [Fact]
-    public void The_rows_a_probe_is_expected_to_run_are_those_of_its_own_rows_file()
-    {
-        Replay(null, "--all", "--no-footprint").Exit.ShouldBe(0);
-        List<int> Expected(string probe) =>
-            [.. JsonNode.Parse(File.ReadAllText(Path.Combine(BranchDir(null), "evidence", probe + ".json")))!["variants"]![0]!["expected"]!.AsArray().Select(i => i!.GetValue<int>())];
-        Expected("P").ShouldBe([0, 1], "rows/P.json holds two rows");
-        Expected("Q").ShouldBe([0], "rows/Q.json holds one");
-    }
-
-    [Fact]
-    public void Probes_run_as_many_at_a_time_as_asked_without_a_footprint_and_are_recorded_in_registry_order()
-    {
-        var (exit, output, error) = Replay(null, "--all", "--no-footprint", "--parallel", "2");
-        exit.ShouldBe(0, error + output);
-        adapter.MostAtOnce.ShouldBe(2);
-        output.IndexOf("  P:", StringComparison.Ordinal).ShouldBeLessThan(output.IndexOf("  Q:", StringComparison.Ordinal));
-        Last(null)["parallel"]!.GetValue<int>().ShouldBe(2);
-
-        adapter.MostAtOnce = 0;
-        Replay(null, "--all", "--no-footprint", "--parallel", "1").Exit.ShouldBe(0);
-        adapter.MostAtOnce.ShouldBe(1);
-    }
-
-    /// <summary>
-    /// The coverage collector rewrites the assemblies on disk, so two hosts from one output directory corrupt
-    /// each other (KB-025): a replay that records a footprint runs one host at a time, whatever --parallel says.
-    /// </summary>
-    [Fact]
-    public void A_replay_with_a_footprint_runs_one_host_at_a_time()
-    {
-        var (exit, output, error) = Replay(null, "--all", "--parallel", "2");
-        exit.ShouldBe(0, error + output);
-        adapter.MostAtOnce.ShouldBe(1);
-        output.ShouldContain("one at a time (the coverage collector rewrites the assemblies on disk)");
-        Last(null)["parallel"]!.GetValue<int>().ShouldBe(1);
-    }
-
-    [Fact]
-    public void Merge_joins_the_legs_and_refuses_a_probe_no_leg_saw()
-    {
-        var legA = State("leg-a"); var legB = State("leg-b"); var merged = State("merged");
-        Replay(legA, "--all", "--family", "a").Exit.ShouldBe(0);
-        Replay(legB, "--all", "--family", "b").Exit.ShouldBe(0);
-
-        var (exit, output, error) = Ledger(merged, "merge", "--from", legA, legB);
-        exit.ShouldBe(0, error + output);
-        output.ShouldContain("2 leg(s)");
-        HasEvidence(merged, "P").ShouldBeTrue();
-        HasEvidence(merged, "Q").ShouldBeTrue();
-        Lines(merged, "runs.jsonl").ShouldBe(2);
-        Lines(merged, "footprints.jsonl").ShouldBe(2);
-        Files.Strings(Last(merged)["selected"]).ShouldBe(["P", "Q"]);
-        Files.Strings(Last(merged)["legs"]).ShouldBe(["a", "b"]);
-        Ledger(merged, "stale").Out.ShouldStartWith("0 of 2 probes to replay");
-
-        Ledger(merged, "merge", "--from", legA, legB).Exit.ShouldBe(0);
-        Lines(merged, "runs.jsonl").ShouldBe(2, "a line a leg carried is added once");
-
-        var (shortExit, _, shortError) = Ledger(State("short"), "merge", "--from", legA);
-        shortExit.ShouldBe(1, "Q was in no leg");
-        shortError.ShouldContain("Q");
-
-        var (noneExit, _, noneError) = Ledger(State("none"), "merge", "--from", State("empty"));
-        noneExit.ShouldBe(1);
-        noneError.ShouldContain("no replay of main");
-    }
-
-    [Fact]
-    public void Merge_fails_when_a_leg_failed()
-    {
-        adapter.Violating.Add("C1");
-        var legA = State("leg-a"); var legB = State("leg-b"); var merged = State("merged");
-        var (legExit, legOutput, _) = Replay(legA, "--all", "--family", "a");
-        legExit.ShouldBe(1, "P violates");
-        File.Exists(Path.Combine(BranchDir(legA), "logs", "P-0-host.log")).ShouldBeTrue("a failed run's full log is kept in the state");
-        legOutput.ShouldContain("    log: ");
-        Replay(legB, "--all", "--family", "b").Exit.ShouldBe(0);
-        Directory.Exists(Path.Combine(BranchDir(legB), "logs")).ShouldBeFalse("a passing run keeps no log");
-
-        var (exit, output, _) = Ledger(merged, "merge", "--from", legA, legB);
-        exit.ShouldBe(1);
-        output.ShouldContain("failed: P");
-        Files.Strings(Last(merged)["failed"]).ShouldBe(["P"]);
-        HasEvidence(merged, "Q").ShouldBeTrue("the merge still joined every leg");
-        File.Exists(Path.Combine(BranchDir(merged), "logs", "P-0-host.log")).ShouldBeTrue("the merge carries the legs' logs");
-    }
-
-    [Fact]
-    public void Two_checkouts_of_one_repository_get_scratch_worktrees_of_their_own()
-    {
-        var other = fx.Linked("other");
-
-        var (main, linked) = (Home(fx.Root), Home(other));
-
-        linked.ShouldNotBe(main);
-        Path.GetFileName(linked).ShouldStartWith(Path.GetFileName(other) + "-");
-        ReplayIn(other, "--where").Out.ShouldContain(Path.Combine(linked, "seeds"));
-    }
-
-    /// <summary>Removing a linked worktree leaves its cache behind; the line `--where` prints removes it, worktrees first.</summary>
-    [Fact]
-    public void The_remove_line_of_where_removes_the_cache_and_its_worktrees()
-    {
-        var other = fx.Linked("other");
-        var home = Home(other);
-        fx.Sh("git", "worktree", "add", "-q", "--detach", Path.Combine(home, "seeds"), "HEAD");
-        var line = ReplayIn(other, "--where").Out.Split('\n').Single(l => l.StartsWith("remove:", StringComparison.Ordinal))["remove:".Length..].Trim();
-
-        static string Slashed(string path) => path.Replace('\\', '/');
-        Slashed(line).ShouldContain($"'{Slashed(home)}'");
-        fx.Sh("sh", "-c", line);
-
-        Directory.Exists(home).ShouldBeFalse();
-        Slashed(fx.Sh("git", "worktree", "list", "--porcelain")).ShouldNotContain(Slashed(home));
-    }
-
-    /// <summary>The main checkout's cache is keyed as it was before linked worktrees had their own, so its warm copy is kept.</summary>
-    [Fact]
-    public void The_main_checkout_keeps_the_cache_it_had()
-    {
-        var root = Path.GetDirectoryName(fx.Sh("git", "rev-parse", "--path-format=absolute", "--git-common-dir").Trim().TrimEnd('/', '\\'))!;
-        var key = Convert.ToHexStringLower(System.Security.Cryptography.SHA1.HashData(System.Text.Encoding.UTF8.GetBytes(root)))[..8];
-
-        Home(fx.Root).ShouldBe(Path.Combine(cache, $"{Path.GetFileName(root)}-{key}"));
-    }
-
-    [Fact]
-    public void A_round_on_one_branch_does_not_skip_a_replay_of_another()
-    {
-        var other = fx.Linked("other");
-        fx.Ledger("lock", "--holder", "round-explore-1", "--mode", "explore").Exit.ShouldBe(0);
-
-        var (exit, output, error) = ReplayIn(other, "--all");
-
-        exit.ShouldBe(0, error + output);
-        output.ShouldNotContain("skipped");
-        File.Exists(Path.Combine(fx.Memory, "branches", "other", "evidence", "P.json")).ShouldBeTrue(output);
-    }
-
-    /// <summary>
-    /// The lock is per branch and the replay worktree per checkout: a replay of another branch in this checkout (the
-    /// branch switched while the post-commit replay runs) skips while one holds the worktree, and never shares it.
-    /// </summary>
-    [Fact]
-    public void A_replay_skips_while_another_branchs_replay_in_its_checkout_holds_the_worktree()
-    {
-        using (global::Prober.Replay.HoldWorktree(Home(fx.Root)))
-        {
-            var (exit, output, error) = Replay(null, "--all", "--branch", "other");
-
-            exit.ShouldBe(0, error);
-            output.ShouldContain("skipped, another branch's replay in this checkout");
-            File.Exists(Path.Combine(fx.Memory, "branches", "other", "evidence", "P.json")).ShouldBeFalse();
-        }
-        Replay(null, "--all", "--branch", "other").Out.ShouldNotContain("skipped");
-    }
-
-    /// <summary>P over C1's two rows and Q over C2's one; a run takes a moment, so runs at once can be counted.</summary>
-    private sealed class FakeAdapter : IProbeAdapter
-    {
-        private int running;
-        public int MostAtOnce;
-        public List<string> CoverageAsked { get; } = [];
-        public HashSet<string> Violating { get; } = new(StringComparer.Ordinal);
-
-        public Ran Build(string worktree, IReadOnlyDictionary<string, string?> environment) => new(0, "Build: OK", "");
-
-        public Ran RunProbe(string worktree, string filter, string results, string coverageFile, IReadOnlyDictionary<string, string?> environment)
-        {
-            var now = Interlocked.Increment(ref running);
-            lock (this) MostAtOnce = Math.Max(MostAtOnce, now);
-            try
-            {
-                Thread.Sleep(300);
-                var claim = filter.EndsWith('P') ? "C1" : "C2";
-                var violates = Violating.Contains(claim);
-                var outDir = environment["PROBE_OUT"]!;
-                Directory.CreateDirectory(outDir);
-                var lines = Enumerable.Range(0, claim == "C1" ? 2 : 1).Select(idx => new JsonObject
-                {
-                    ["idx"] = idx, ["category"] = violates ? "violation" : "pass", ["applied"] = new JsonObject { ["x"] = "1", ["y"] = "1" },
-                    ["reasons"] = violates ? new JsonArray("violation:seeded") : new JsonArray(),
-                }.ToJsonString());
-                File.WriteAllText(Path.Combine(outDir, claim + ".jsonl"), string.Join('\n', lines) + "\n");
-                if (violates)
-                {
-                    Directory.CreateDirectory(environment["PROBE_LOG_DIR"]!);
-                    File.WriteAllText(Path.Combine(environment["PROBE_LOG_DIR"]!, "host.log"), "the host's full output");
-                }
-                if (coverageFile.Length > 0)
-                {
-                    lock (this) CoverageAsked.Add(coverageFile);
-                    Directory.CreateDirectory(results);
-                    File.WriteAllText(Path.Combine(results, coverageFile),
-                        $"<coverage><sources><source>{worktree}</source></sources><packages><package name=\"p\"><classes>" +
-                        "<class name=\"A\" filename=\"src/a.cs\"><lines><line number=\"1\" hits=\"1\"/></lines></class></classes></package></packages></coverage>");
-                }
-                return new Ran(violates ? 1 : 0, violates ? "TESTS FAILED" : "TESTS OK", "");
-            }
-            finally { Interlocked.Decrement(ref running); }
-        }
-
-        public (JsonObject? Axes, string? Error) DeriveAxes(string checkout, string workDirectory) => (null, "none");
-
-        public IReadOnlyDictionary<string, string?> Environment(string cacheDirectory) => new Dictionary<string, string?>();
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/RowsPerProbeTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/RowsPerProbeTests.cs
deleted file mode 100644
index c52e5b5d..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/RowsPerProbeTests.cs
+++ /dev/null
@@ -1,299 +0,0 @@
-using System.Text.Json.Nodes;
-using Prober;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>
-/// Rows are per probe: each probe of a claim runs a rows file of its own, its identity reads that file only, and
-/// <c>rows --probe P</c> writes it whole, over the claim's pairs the other probes of the claim have not credited.
-/// </summary>
-public sealed class RowsPerProbeTests : IDisposable
-{
-    private readonly Fixture fx = new();
-    public void Dispose() => fx.Dispose();
-
-    private static Dictionary<string, string> R(string x, string y) => new(StringComparer.Ordinal) { ["x"] = x, ["y"] = y };
-
-    /// <summary>C1 gets a second probe, Q, with a rows file of its own; P credits the pairs of rows 11 and 22.</summary>
-    public RowsPerProbeTests()
-    {
-        fx.Write("tools/probe/corpus/registry.json", """{"probes": {"P": {"claim": "C1", "filter": "*P"}, "Q": {"claim": "C1", "filter": "*Q"}}}""");
-        QRows("1", "2");
-        fx.Commit("a second probe of C1");
-        fx.Footprint();
-        fx.Ledger("record-run", "--probe", "P", "--result", "pass", "--evidence", fx.Evidence([R("1", "1"), R("2", "2")])).Exit.ShouldBe(0);
-    }
-
-    private void QRows(string x, string y) =>
-        fx.Write("tools/probe/corpus/rows/Q.json", $$$"""{"claim": "C1", "rows": [{"row": {"x": "{{{x}}}", "y": "{{{y}}}"}}]}""");
-
-    private string Staged(string relative) => Path.Combine(fx.BranchDir, "staging", relative);
-
-    private List<string> StagedRows(string probe)
-    {
-        var staged = JsonNode.Parse(File.ReadAllText(Staged($"rows/{probe}.json")))!;
-        staged["claim"]!.GetValue<string>().ShouldBe("C1", "a probe's rows file keeps its claim inside");
-        return [.. staged["rows"]!.AsArray().Select(r => $"{r!["row"]!["x"]}{r["row"]!["y"]}").Order(StringComparer.Ordinal)];
-    }
-
-    private string Identity(string probe)
-    {
-        var (exit, output, error) = fx.Ledger("identity", "--probe", probe);
-        exit.ShouldBe(0, error);
-        return output.Trim();
-    }
-
-    [Fact]
-    public void Rows_for_a_probe_leave_out_the_pairs_its_siblings_credited()
-    {
-        var (exit, output, error) = fx.Ledger("rows", "--probe", "Q");
-        exit.ShouldBe(0, output + error);
-        StagedRows("Q").ShouldBe(["12", "21"], "P credited the pairs of 11 and 22, so Q's rows cover the other two");
-        File.Exists(Staged("rows/P.json")).ShouldBeFalse("writing one probe's rows leaves its sibling's as they are");
-    }
-
-    [Fact]
-    public void Rows_for_a_probe_do_not_subtract_its_own_credit()
-    {
-        fx.Ledger("rows", "--probe", "P").Exit.ShouldBe(0);
-        StagedRows("P").ShouldBe(["11", "12", "21", "22"], "P's credit came from the rows the file replaces, so it would end with them");
-    }
-
-    [Fact]
-    public void The_file_is_written_whole_never_appended()
-    {
-        fx.Write(Path.GetRelativePath(fx.Root, Staged("rows/Q.json")), """{"claim": "C1", "rows": [{"row": {"x": "2", "y": "1"}}, {"row": {"x": "1", "y": "2"}}, {"row": {"x": "1", "y": "2"}}]}""");
-        fx.Ledger("rows", "--probe", "Q").Exit.ShouldBe(0);
-        StagedRows("Q").ShouldBe(["12", "21"], "the staged rows are regenerated, not kept and added to");
-    }
-
-    [Fact]
-    public void A_probe_that_is_not_registered_is_refused()
-    {
-        var (exit, _, error) = fx.Ledger("rows", "--probe", "Nope");
-        exit.ShouldBe(2);
-        error.ShouldContain("no probe Nope in the registry");
-    }
-
-    [Fact]
-    public void Publish_moves_the_staged_rows_by_probe_with_their_claim()
-    {
-        fx.Ledger("rows", "--probe", "Q").Exit.ShouldBe(0);
-        fx.Ledger("publish").Exit.ShouldBe(0);
-        JsonNode published;
-        using (var gz = new System.IO.Compression.GZipStream(File.OpenRead(Path.Combine(fx.Root, "tools/probe/corpus/rows/Q.json.gz")), System.IO.Compression.CompressionMode.Decompress))
-            published = JsonNode.Parse(gz)!;
-        published["claim"]!.GetValue<string>().ShouldBe("C1");
-        published["rows"]!.AsArray().Select(r => $"{r!["row"]!["x"]}{r["row"]!["y"]}").Order(StringComparer.Ordinal).ShouldBe(["12", "21"]);
-        File.Exists(Path.Combine(fx.Root, "tools/probe/corpus/rows/C1.json.gz")).ShouldBeFalse("rows are published under the probe's name, not the claim's");
-    }
-
-    [Fact]
-    public void A_sibling_s_rows_changing_leaves_the_probe_s_identity_and_credit()
-    {
-        var before = Identity("P");
-        QRows("2", "1");
-        fx.Commit("Q's rows changed");
-        Identity("P").ShouldBe(before, "P's identity reads P's rows, not Q's");
-        fx.Covered().ShouldBe(2, "P's pass still counts");
-    }
-
-    [Fact]
-    public void The_overlay_unpacks_each_probe_s_rows_and_drops_a_file_the_corpus_no_longer_has()
-    {
-        var worktree = fx.Root + "-overlay";
-        try
-        {
-            var ledger = new Ledger(new Context(fx.Root, new Dictionary<string, string?>(), TextWriter.Null, TextWriter.Null), "main");
-            var config = new JsonObject { ["probeDir"] = "probes" };
-            var rows = Path.Combine(global::Prober.Replay.Overlay(ledger, config, worktree), "rows");
-            Directory.EnumerateFiles(rows).Select(Path.GetFileName).Order(StringComparer.Ordinal).ShouldBe(["P.json", "Q.json"]);
-            File.Delete(Path.Combine(fx.Root, "tools/probe/corpus/rows/Q.json"));
-            global::Prober.Replay.Overlay(ledger, config, worktree);
-            Directory.EnumerateFiles(rows).Select(Path.GetFileName).ShouldBe(["P.json"], "a rows file left from an earlier overlay would be read by a probe of that name");
-        }
-        finally
-        {
-            try { Directory.Delete(worktree, recursive: true); } catch (IOException) { }
-        }
-    }
-
-    [Fact]
-    public void The_probe_s_own_rows_changing_moves_its_identity()
-    {
-        var before = Identity("P");
-        fx.Rows([("1", "1"), ("2", "2"), ("1", "2")]);
-        fx.Commit("P's rows changed");
-        Identity("P").ShouldNotBe(before);
-        fx.Covered().ShouldBe(0);
-    }
-}
-
-/// <summary>
-/// A registry entry's <c>watched</c> paths stale its footprint: what the probe's result depends on that the footprint,
-/// the paths its own process ran under <c>src/</c>, cannot see.
-/// </summary>
-public sealed class WatchedTests : IDisposable
-{
-    private readonly Fixture fx = new();
-    public void Dispose() => fx.Dispose();
-
-    private const string Catalogue = "test/Variants/Catalogue.cs";
-
-    private static Dictionary<string, string> R(string x, string y) => new(StringComparer.Ordinal) { ["x"] = x, ["y"] = y };
-
-    private void Registry(bool watched) =>
-        fx.Write("tools/probe/corpus/registry.json", watched
-            ? $$$$"""{"probes": {"P": {"claim": "C1", "filter": "*P", "watched": ["{{{{Catalogue}}}}"]}}}"""
-            : """{"probes": {"P": {"claim": "C1", "filter": "*P"}}}""");
-
-    private void ChangeTheCatalogue()
-    {
-        fx.Write(Catalogue, "class Catalogue { int Site; }\n");
-        fx.Commit("the catalogue gains a site");
-    }
-
-    /// <summary>A replay's record of P: the footprint from a coverage report of src/a.cs, through the command the replay runs, and a pass.</summary>
-    private void Replayed()
-    {
-        var report = Path.Combine(fx.Root, "coverage.cobertura.xml");
-        File.WriteAllText(report, $"""<coverage><sources><source>{fx.Root}</source></sources><packages><package><classes><class filename="src/a.cs"><lines><line number="1" hits="1" /></lines></class></classes></package></packages></coverage>""");
-        var (exit, output, error) = fx.Ledger("footprint", "--probe", "P", "--root", fx.Root, "--cobertura", report);
-        exit.ShouldBe(0, output + error);
-        File.Delete(report);
-        fx.Ledger("record-run", "--probe", "P", "--result", "pass", "--evidence", fx.Evidence([R("1", "1"), R("2", "2")])).Exit.ShouldBe(0);
-    }
-
-    private bool Stale()
-    {
-        var (exit, output, error) = fx.Ledger("stale", "--json");
-        exit.ShouldBe(0, error);
-        return JsonNode.Parse(output)!.AsArray().Single(s => s!["probe"]!.GetValue<string>() == "P")!["stale"]!.GetValue<bool>();
-    }
-
-    private Ledger Ledger() => new(new Context(fx.Root, new Dictionary<string, string?>(), TextWriter.Null, TextWriter.Null), "main");
-
-    [Fact]
-    public void The_footprint_records_each_watched_path_with_its_id()
-    {
-        Registry(watched: true);
-        fx.Write(Catalogue, "class Catalogue {}\n");
-        fx.Commit("a probe watching a catalogue");
-        Replayed();
-        var line = JsonNode.Parse(File.ReadLines(Path.Combine(fx.BranchDir, "footprints.jsonl")).Last())!;
-        line["watched"]![Catalogue]!.GetValue<string>().ShouldBe(fx.Sh("git", "rev-parse", $"HEAD:{Catalogue}").Trim());
-        Stale().ShouldBeFalse();
-        fx.Covered().ShouldBe(2);
-    }
-
-    [Fact]
-    public void A_change_to_a_watched_path_stales_the_footprint()
-    {
-        Registry(watched: true);
-        fx.Write(Catalogue, "class Catalogue {}\n");
-        fx.Commit("a probe watching a catalogue");
-        Replayed();
-        ChangeTheCatalogue();
-        Stale().ShouldBeTrue("the catalogue P watches changed");
-        fx.Covered().ShouldBe(0);
-    }
-
-    [Fact]
-    public void Without_watched_the_footprint_does_not_see_the_path()
-    {
-        Registry(watched: false);
-        fx.Write(Catalogue, "class Catalogue {}\n");
-        fx.Commit("a probe watching nothing");
-        Replayed();
-        ChangeTheCatalogue();
-        Stale().ShouldBeFalse("the control: nothing P ran or watches changed, which is the gap watched closes");
-        fx.Covered().ShouldBe(2);
-    }
-
-    [Fact]
-    public void A_watched_path_the_footprint_did_not_record_is_not_current()
-    {
-        Registry(watched: true);
-        fx.Write(Catalogue, "class Catalogue {}\n");
-        fx.Commit("a probe watching a catalogue");
-        fx.Footprint();
-        var ledger = Ledger();
-        ledger.FootprintCurrent("P", ledger.Footprints()).ShouldBeFalse("the footprint line records nothing of the catalogue P watches");
-    }
-
-    [Fact]
-    public void A_change_to_a_watched_path_changes_the_footprint_since_a_release()
-    {
-        Registry(watched: true);
-        fx.Write(Catalogue, "class Catalogue {}\n");
-        fx.Commit("a probe watching a catalogue");
-        Replayed();
-        fx.Sh("git", "tag", "v1");
-        var ledger = Ledger();
-        ledger.FootprintChangedSince("P", "v1", ledger.Footprints()).ShouldBeFalse();
-        ChangeTheCatalogue();
-        ledger = Ledger();
-        ledger.FootprintChangedSince("P", "v1", ledger.Footprints()).ShouldBeTrue();
-    }
-
-    /// <summary>A replay's record of a probe that runs nothing under src/ in its own process, as C22, which builds its consumer in a child process.</summary>
-    private (int Exit, string Output, string Error) RanNothingUnderSrc()
-    {
-        var report = Path.Combine(fx.Root, "coverage.cobertura.xml");
-        File.WriteAllText(report, $"""<coverage><sources><source>{fx.Root}</source></sources><packages><package><classes><class filename="test/Harness.cs"><lines><line number="1" hits="1" /></lines></class></classes></package></packages></coverage>""");
-        var result = fx.Ledger("footprint", "--probe", "P", "--root", fx.Root, "--cobertura", report);
-        File.Delete(report);
-        return result;
-    }
-
-    [Fact]
-    public void A_probe_that_ran_nothing_under_src_is_recorded_by_what_it_watches()
-    {
-        Registry(watched: true);
-        fx.Write(Catalogue, "class Catalogue {}\n");
-        fx.Commit("a probe watching a catalogue, building in a child process");
-        var (exit, output, error) = RanNothingUnderSrc();
-        exit.ShouldBe(0, output + error);
-        var line = JsonNode.Parse(File.ReadLines(Path.Combine(fx.BranchDir, "footprints.jsonl")).Last())!;
-        line["footprint"]!.AsObject().Count.ShouldBe(0);
-        line["watched"]![Catalogue]!.GetValue<string>().ShouldBe(fx.Sh("git", "rev-parse", $"HEAD:{Catalogue}").Trim());
-        fx.Ledger("record-run", "--probe", "P", "--result", "pass", "--evidence", fx.Evidence([R("1", "1"), R("2", "2")])).Exit.ShouldBe(0);
-        Stale().ShouldBeFalse("what P watches is unchanged");
-        fx.Covered().ShouldBe(2);
-        ChangeTheCatalogue();
-        Stale().ShouldBeTrue("the catalogue P watches changed");
-        fx.Covered().ShouldBe(0);
-    }
-
-    [Fact]
-    public void A_probe_that_ran_nothing_under_src_and_watches_nothing_is_refused()
-    {
-        Registry(watched: false);
-        fx.Write(Catalogue, "class Catalogue {}\n");
-        fx.Commit("a probe watching nothing, building in a child process");
-        var (exit, output, error) = RanNothingUnderSrc();
-        exit.ShouldBe(1, output + error);
-        (output + error).ShouldContain("refusing to record an empty footprint");
-        File.Exists(Path.Combine(fx.BranchDir, "footprints.jsonl")).ShouldBeFalse();
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void The_gate_counts_a_change_to_a_watched_path_as_touching_the_claim(bool watched)
-    {
-        Registry(watched);
-        fx.Write(Catalogue, "class Catalogue {}\n");
-        fx.Commit("a probe and a catalogue");
-        fx.Footprint();
-        fx.Sh("git", "tag", "v1");
-        ChangeTheCatalogue();
-        var (_, output, _) = fx.Ledger("gate", "--since", "v1", "--json");
-        var gate = JsonNode.Parse(output)!;
-        static List<string> Names(JsonNode? list) => [.. list!.AsArray().Select(x => x!.GetValue<string>())];
-        Names(gate["touched"]).ShouldBe(watched ? ["C1"] : [], "a change to what a probe of the claim watches touches the claim, and nothing else does here");
-        // The conservative rule and the footprint agree: neither selects the claim without the other.
-        Names(gate["selected_by_footprint_only"]).ShouldBeEmpty();
-        Names(gate["missed_by_footprint_alone"]).ShouldBeEmpty();
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/SeedsTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/SeedsTests.cs
deleted file mode 100644
index 2fce1dab..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/SeedsTests.cs
+++ /dev/null
@@ -1,408 +0,0 @@
-using System.Text.Json.Nodes;
-using Prober;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>
-/// A probe proves it can fail (decision 100): `seeds` applies the defect its registry entry names in a scratch
-/// worktree, runs the probe there, and counts the seed caught only for a violation the unseeded probe does
-/// not have. The probe here is a fake adapter: row 1 of C1 violates while the product holds DEFECT.
-/// </summary>
-public sealed class SeedsTests : IDisposable
-{
-    private readonly Fixture fx = new();
-    private readonly string cache;
-    private readonly FakeAdapter adapter = new();
-
-    public SeedsTests()
-    {
-        cache = fx.Root + "-cache";
-        fx.Sh("git", "config", "core.autocrlf", "false");
-        fx.Write(".claude/probe-axes.md", "```json probe-axes\n" + new JsonObject
-        {
-            ["axes"] = new JsonObject { ["x"] = new JsonArray("1", "2"), ["y"] = new JsonArray("1", "2") },
-            ["surfaces"] = new JsonObject { ["s"] = new JsonObject { ["axes"] = new JsonArray("x", "y"), ["watched"] = new JsonArray("src") } },
-            ["replay"] = new JsonObject { ["probeDir"] = "probes", ["include"] = new JsonArray("src") },
-        }.ToJsonString() + "\n```\n");
-        fx.Commit("replay configuration");
-    }
-
-    public void Dispose()
-    {
-        fx.Dispose();
-        try { Directory.Delete(cache, recursive: true); } catch (IOException) { } catch (UnauthorizedAccessException) { }
-    }
-
-    /// <summary>Writes the seed for P: a patch made by editing the file and taking the diff, and the registry entry naming it.</summary>
-    private void Seed(string? file = "src/a.cs", string? edit = "class A { /* DEFECT */ }\n", JsonObject? env = null)
-    {
-        var seed = new JsonObject { ["defect"] = "A holds the defect." };
-        if (file is not null)
-        {
-            var original = File.ReadAllText(Path.Combine(fx.Root, file));
-            fx.Write(file, edit!);
-            fx.Write("tools/probe/corpus/seeds/C1.patch", fx.Sh("git", "diff", "--", file));
-            fx.Write(file, original);
-            seed["patch"] = "seeds/C1.patch";
-        }
-        if (env is not null) seed["env"] = env;
-        fx.Write("tools/probe/corpus/registry.json", new JsonObject
-        {
-            ["probes"] = new JsonObject { ["P"] = new JsonObject { ["claim"] = "C1", ["filter"] = "*P", ["seed"] = seed } },
-        }.ToJsonString());
-        fx.Commit("seed");
-    }
-
-    private (int Exit, string Out, string Err) Seeds(params string[] args)
-    {
-        var output = new StringWriter(); var error = new StringWriter();
-        var context = new Context(fx.Root, new Dictionary<string, string?> { ["PROBE_CACHE_DIR"] = cache }, output, error);
-        int exit;
-        try { exit = global::Prober.Seeds.Run(context, new Args(args, new HashSet<string>(StringComparer.Ordinal) { "dry-run", "all" }), adapter); }
-        catch (Refusal refusal) { error.WriteLine(refusal.Message); exit = refusal.ExitCode; }
-        return (exit, output.ToString(), error.ToString());
-    }
-
-    private string Worktree => Directory.GetDirectories(cache).Single() is var home ? Path.Combine(home, "seeds") : "";
-
-    [Fact]
-    public void A_seed_the_probe_catches_passes()
-    {
-        Seed();
-        var (exit, output, error) = Seeds();
-        exit.ShouldBe(0, output + error);
-        output.ShouldContain("P (C1): caught, 1 of 2 rows violate; e.g. #1: violation:");
-        output.ShouldContain("1 caught");
-    }
-
-    [Fact]
-    public void A_seed_the_probe_misses_fails_the_command()
-    {
-        Seed(edit: "class A { /* harmless */ }\n");
-        var (exit, output, _) = Seeds();
-        exit.ShouldBe(1);
-        output.ShouldContain("P (C1): missed, no row violates that did not already (2 rows: pass 2;");
-    }
-
-    [Fact]
-    public void A_violation_the_probe_has_without_the_seed_is_not_the_seeds()
-    {
-        adapter.AlwaysViolates = 1;
-        Seed();
-        var (exit, output, _) = Seeds();
-        exit.ShouldBe(1, "row 1 fails unseeded too, so the seed proved nothing");
-        output.ShouldContain("1 violations unseeded");
-        output.ShouldContain("P (C1): missed");
-    }
-
-    [Fact]
-    public void A_probe_without_a_seed_fails_the_command()
-    {
-        var (exit, output, _) = Seeds();
-        exit.ShouldBe(1);
-        output.ShouldContain("P (C1): no seed, its registry entry names none");
-    }
-
-    [Fact]
-    public void An_environment_toggle_is_a_seed()
-    {
-        Seed(file: null, env: new JsonObject { ["SEED_DEFECT"] = "1" });
-        var (exit, output, error) = Seeds();
-        exit.ShouldBe(0, output + error);
-        output.ShouldContain("P (C1): caught");
-    }
-
-    [Fact]
-    public void A_seed_outside_the_product_files_is_refused()
-    {
-        Seed(file: "README.md", edit: "# a\n\nThe claim, DEFECT.\n");
-        var (exit, output, _) = Seeds();
-        exit.ShouldBe(1);
-        output.ShouldContain("P (C1): does not apply, it patches README.md, outside the product files (src)");
-    }
-
-    [Fact]
-    public void A_seed_that_no_longer_applies_fails_the_command()
-    {
-        Seed();
-        fx.Write("src/a.cs", "class B {}\n");
-        fx.Commit("the product moved on");
-        var (exit, output, _) = Seeds();
-        exit.ShouldBe(1);
-        output.ShouldContain("P (C1): does not apply");
-    }
-
-    [Fact]
-    public void A_seed_that_breaks_the_build_proves_nothing()
-    {
-        adapter.BreaksOn = "DEFECT";
-        Seed();
-        var (exit, output, _) = Seeds();
-        exit.ShouldBe(1);
-        output.ShouldContain("P (C1): build failed");
-    }
-
-    [Fact]
-    public void The_seed_is_applied_only_in_the_scratch_worktree_and_undone()
-    {
-        Seed();
-        Seeds().Exit.ShouldBe(0);
-        File.ReadAllText(Path.Combine(fx.Root, "src/a.cs")).ShouldBe("class A {}\n");
-        File.ReadAllText(Path.Combine(Worktree, "src/a.cs")).ShouldBe("class A {}\n");
-        adapter.Worktrees.ShouldAllBe(w => w == Worktree);
-    }
-
-    [Fact]
-    public void A_seeded_run_is_never_evidence()
-    {
-        Seed();
-        Seeds().Exit.ShouldBe(0);
-        File.Exists(Path.Combine(fx.BranchDir, "runs.jsonl")).ShouldBeFalse();
-        Directory.Exists(Path.Combine(fx.BranchDir, "evidence")).ShouldBeFalse();
-        File.Exists(Path.Combine(fx.BranchDir, "seeds-last.json")).ShouldBeTrue();
-    }
-
-    [Fact]
-    public void The_seed_is_not_part_of_the_probe_s_identity()
-    {
-        var before = fx.Ledger("identity", "--probe", "P").Out;
-        Seed();
-        fx.Ledger("identity", "--probe", "P").Out.ShouldBe(before, "a seed proves the probe; adding or changing one must not stale its results");
-    }
-
-    /// <summary>What the replay records for P: the product files it ran, at HEAD.</summary>
-    private void Footprint(params string[] files) =>
-        File.AppendAllText(Path.Combine(fx.BranchDir, "footprints.jsonl"), new JsonObject
-        {
-            ["probe"] = "P",
-            ["footprint"] = new JsonObject(files.Select(f => KeyValuePair.Create(f, (JsonNode?)fx.Sh("git", "rev-parse", "HEAD:" + f).Trim()))),
-            ["compileTime"] = new JsonObject(), ["toolchain"] = new JsonObject(),
-        }.ToJsonString() + "\n");
-
-    /// <summary>P seeded and caught once, with a footprint over src/a.cs and src/b.cs or the files given, so the next run has a record to skip by.</summary>
-    private void CaughtOnce(params string[] footprint)
-    {
-        fx.Write("src/b.cs", "class B {}\n");
-        fx.Commit("a second product file");
-        Seed();
-        Footprint(footprint.Length > 0 ? footprint : ["src/a.cs", "src/b.cs"]);
-        var (exit, output, error) = Seeds();
-        exit.ShouldBe(0, output + error);
-        output.ShouldContain("  runs P: no run caught every seed of it yet");
-        output.ShouldContain("P (C1): caught");
-    }
-
-    private JsonObject Last() => (JsonObject)JsonNode.Parse(File.ReadAllText(Path.Combine(fx.BranchDir, "seeds-last.json")))!;
-
-    [Fact]
-    public void An_unchanged_probe_is_skipped_and_says_why()
-    {
-        CaughtOnce();
-        var builds = adapter.Worktrees.Count;
-
-        var (exit, output, error) = Seeds();
-
-        exit.ShouldBe(0, output + error);
-        output.ShouldContain("  skips P: every seed caught at " + fx.Sh("git", "rev-parse", "--short=7", "HEAD").Trim() + ", and neither its identity nor its product footprint changed since");
-        output.ShouldContain("0 seeds of 0 probes");
-        output.ShouldContain("1 probes skipped");
-        adapter.Worktrees.Count.ShouldBe(builds, "nothing built or ran");
-        Last()["skipped"]!.AsArray().Single()!["probe"]!.GetValue<string>().ShouldBe("P");
-        Last()["probes"]!["P"]!["commit"]!.GetValue<string>().ShouldBe(fx.Sh("git", "rev-parse", "HEAD").Trim(), "a skipped probe's record is carried forward");
-    }
-
-    [Fact]
-    public void A_changed_identity_reruns()
-    {
-        CaughtOnce();
-        fx.Write("tools/probe/corpus/harness/P.cs", "// probe P, changed\n");
-        fx.Commit("the harness changed");
-
-        var (_, output, _) = Seeds();
-
-        output.ShouldContain("  runs P: its identity or its seeds changed since they were caught at ");
-        output.ShouldContain("P (C1): caught");
-    }
-
-    [Fact]
-    public void A_changed_seed_reruns()
-    {
-        CaughtOnce();
-        Seed(edit: "class A { /* DEFECT, another */ }\n");
-
-        Seeds().Out.ShouldContain("  runs P: its identity or its seeds changed since they were caught at ");
-    }
-
-    [Fact]
-    public void A_changed_product_footprint_reruns()
-    {
-        CaughtOnce();
-        fx.Write("src/b.cs", "class B { int changed; }\n");
-        fx.Commit("the product changed where P runs");
-
-        var (_, output, _) = Seeds();
-
-        output.ShouldContain("  runs P: its product footprint changed since ");
-        output.ShouldContain("P (C1): caught");
-    }
-
-    /// <summary>The seed's own file may be outside what the probe ran; a change there may leave the seed behind, so it reruns.</summary>
-    [Fact]
-    public void A_change_to_the_file_the_seed_patches_reruns()
-    {
-        CaughtOnce("src/b.cs");
-        fx.Write("src/a.cs", "class A {}\n// moved on\n");
-        fx.Commit("the seeded file changed");
-
-        Seeds().Out.ShouldContain("  runs P: a file its seeds patch changed since ");
-    }
-
-    [Fact]
-    public void A_change_outside_the_footprint_skips()
-    {
-        CaughtOnce();
-        fx.Write("src/c.cs", "class C {}\n");
-        fx.Commit("the product changed where P does not run");
-
-        Seeds().Out.ShouldContain("  skips P: ");
-    }
-
-    [Fact]
-    public void A_probe_without_a_recorded_footprint_runs()
-    {
-        Seed();
-        Seeds().Exit.ShouldBe(0);
-
-        Seeds().Out.ShouldContain("  runs P: no product footprint recorded for it (a replay records one)");
-    }
-
-    [Fact]
-    public void All_ignores_the_record()
-    {
-        CaughtOnce();
-
-        var (exit, output, _) = Seeds("--all");
-
-        exit.ShouldBe(0);
-        output.ShouldNotContain("skips P");
-        output.ShouldContain("P (C1): caught");
-        Last()["all"]!.GetValue<bool>().ShouldBeTrue();
-    }
-
-    [Fact]
-    public void A_probe_named_runs_whatever_its_record_says()
-    {
-        CaughtOnce();
-
-        Seeds("--probe", "P").Out.ShouldContain("P (C1): caught");
-    }
-
-    [Fact]
-    public void A_missed_seed_is_never_skipped_next_time()
-    {
-        fx.Write("src/b.cs", "class B {}\n");
-        fx.Commit("a second product file");
-        Seed(edit: "class A { /* harmless */ }\n");
-        Footprint("src/a.cs", "src/b.cs");
-        Seeds().Exit.ShouldBe(1);
-        Last()["probes"]!.AsObject().ShouldBeEmpty();
-
-        var (exit, output, _) = Seeds();
-
-        exit.ShouldBe(1);
-        output.ShouldContain("  runs P: no run caught every seed of it yet");
-        output.ShouldContain("P (C1): missed");
-    }
-
-    [Fact]
-    public void A_seed_missed_after_a_catch_drops_the_record()
-    {
-        CaughtOnce();
-        Seed(edit: "class A { /* harmless */ }\n");
-        Seeds().Exit.ShouldBe(1);
-
-        Last()["probes"]!.AsObject().ContainsKey("P").ShouldBeFalse();
-        Seeds().Out.ShouldContain("  runs P: no run caught every seed of it yet");
-    }
-
-    [Fact]
-    public void The_record_is_what_its_schema_says()
-    {
-        CaughtOnce();
-        Seeds();
-        var root = AppContext.BaseDirectory;
-        while (!File.Exists(Path.Combine(root, "CodoMetis.TypeKit.slnx"))) root = Path.GetDirectoryName(root) ?? throw new InvalidOperationException("no CodoMetis.TypeKit.slnx above the test output");
-        var schema = (JsonObject)JsonNode.Parse(File.ReadAllText(Path.Combine(root, "tools", "Prober", "Schemas", "seeds-run.schema.json")))!["properties"]!;
-
-        foreach (var field in new[] { "probes", "skipped", "all" })
-            SchemaCheck.Problems(Last()[field], (JsonObject)schema[field]!, field).ShouldBeEmpty(field);
-        Last()["probes"]!["P"]!["identity"]!.GetValue<string>().ShouldBe(global::Prober.Seeds.SeedsIdentity(new Ledger(new Context(fx.Root, new Dictionary<string, string?>(), TextWriter.Null, TextWriter.Null), null), "P"));
-    }
-
-    private List<string> Problems() => global::Prober.Seeds.Problems(new Ledger(new Context(fx.Root, new Dictionary<string, string?>(), TextWriter.Null, TextWriter.Null), null));
-
-    [Fact]
-    public void The_check_without_a_build_names_a_probe_without_a_seed()
-    {
-        Problems().ShouldBe(["P: no seed, its registry entry names none"]);
-        Seed();
-        Problems().ShouldBeEmpty();
-    }
-
-    [Fact]
-    public void The_check_without_a_build_names_a_seed_the_product_left_behind()
-    {
-        Seed();
-        fx.Write("src/a.cs", "class B {}\n");
-        fx.Commit("the product moved on");
-        Problems().ShouldHaveSingleItem().ShouldStartWith("P: does not apply, ");
-    }
-
-    [Fact]
-    public void Every_probe_in_the_repository_has_a_seed_that_applies()
-    {
-        var root = AppContext.BaseDirectory;
-        while (!File.Exists(Path.Combine(root, "CodoMetis.TypeKit.slnx"))) root = Path.GetDirectoryName(root) ?? throw new InvalidOperationException("no CodoMetis.TypeKit.slnx above the test output");
-        global::Prober.Seeds.Problems(new Ledger(new Context(root, new Dictionary<string, string?>(), TextWriter.Null, TextWriter.Null), null)).ShouldBeEmpty();
-    }
-
-    /// <summary>The probe P over C1's two rows, without a build: row 1 violates where src/a.cs holds DEFECT or SEED_DEFECT is set.</summary>
-    private sealed class FakeAdapter : IProbeAdapter
-    {
-        public int? AlwaysViolates { get; set; }
-        public string? BreaksOn { get; set; }
-        public List<string> Worktrees { get; } = [];
-
-        public Ran Build(string worktree, IReadOnlyDictionary<string, string?> environment)
-        {
-            Worktrees.Add(worktree);
-            return BreaksOn is { } marker && File.ReadAllText(Path.Combine(worktree, "src", "a.cs")).Contains(marker, StringComparison.Ordinal)
-                       ? new Ran(1, "Build: FAILED", "")
-                       : new Ran(0, "Build: OK", "");
-        }
-
-        public Ran RunProbe(string worktree, string filter, string results, string coverageFile, IReadOnlyDictionary<string, string?> environment)
-        {
-            Worktrees.Add(worktree);
-            var defect = File.ReadAllText(Path.Combine(worktree, "src", "a.cs")).Contains("DEFECT", StringComparison.Ordinal)
-                      || environment.GetValueOrDefault("SEED_DEFECT") == "1";
-            var outDir = environment["PROBE_OUT"]!;
-            Directory.CreateDirectory(outDir);
-            var lines = Enumerable.Range(0, 2).Select(idx =>
-            {
-                var violates = idx == AlwaysViolates || (defect && idx == 1);
-                return new JsonObject
-                {
-                    ["idx"] = idx, ["category"] = violates ? "violation" : "pass",
-                    ["reasons"] = violates ? new JsonArray("violation:A holds the defect") : new JsonArray(),
-                }.ToJsonString();
-            });
-            File.WriteAllText(Path.Combine(outDir, "C1.jsonl"), string.Join('\n', lines) + "\n");
-            return new Ran(lines.Any(l => l.Contains("violation", StringComparison.Ordinal)) ? 1 : 0, "", "");
-        }
-
-        public (JsonObject? Axes, string? Error) DeriveAxes(string checkout, string workDirectory) => (null, "none");
-
-        public IReadOnlyDictionary<string, string?> Environment(string cacheDirectory) => new Dictionary<string, string?>();
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/SourceLintTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/SourceLintTests.cs
deleted file mode 100644
index 7e28922b..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/SourceLintTests.cs
+++ /dev/null
@@ -1,231 +0,0 @@
-using System.Text.Json.Nodes;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>
-/// `register` and `publish` read the staged sources before anything is built (decision 103): a note names a
-/// key of the catalogue as <c>NoteKeys.Name</c>, the harness's two-argument skip names an open finding of
-/// this ledger as a string literal, and a check's <c>Inapplicable</c> or <c>Refused</c> cites by a <c>Cite</c>
-/// factory with a string literal something that exists. Each refusal names the file and the line.
-/// </summary>
-public sealed class SourceLintTests : IDisposable
-{
-    private readonly Fixture fx = new();
-
-    public SourceLintTests()
-    {
-        fx.Write("tools/probe/corpus/harness/Row.cs", """
-            public sealed class NoteKeys
-            {
-                // public static readonly NoteKeys InAComment = new("in-a-comment", Pass);
-                public static readonly NoteKeys Compared = new("compared", Pass);
-                public static readonly NoteKeys BothThrew = new("both-threw", ExpectedRefusal);
-            }
-            """);
-        // C1's not-promised entry, C2's, and what a citation may name besides: a file of the docs, a knowledge entry, a record.
-        fx.Write("tools/probe/corpus/claims.json", new JsonArray(
-            new JsonObject { ["id"] = "C1", ["source"] = "README.md#a", ["surfaces"] = new JsonArray("s"),
-                             ["not-promised"] = new JsonArray(new JsonObject { ["id"] = "c1-limit", ["source"] = "README.md#a", ["sentence"] = "The claim." }) },
-            new JsonObject { ["id"] = "C2", ["source"] = "README.md#a", ["surfaces"] = new JsonArray("s"),
-                             ["not-promised"] = new JsonArray(new JsonObject { ["id"] = "c2-limit", ["source"] = "README.md#a", ["sentence"] = "The claim." }) }).ToJsonString());
-        fx.Write("design/knowledge/KB-007-a-fact.md", "# KB-007\n");
-        fx.Write("design/adr/0094-a-record.md", "# 94\n");
-        fx.Commit("the catalogue");
-    }
-
-    public void Dispose() => fx.Dispose();
-
-    private string Staged => Path.Combine(fx.BranchDir, "staging");
-
-    private void Stage(string body) =>
-        fx.Write(Path.GetRelativePath(fx.Root, Path.Combine(Staged, "probes", "C1Probe.cs")), $$"""
-            public sealed class C1Probe
-            {
-                static string? Check(Row r, string x)
-                {
-                    var rest = new[] { 1, 2 }.Skip(x.Length);
-                    // r.Note("a comment is no call", x);
-                    var text = "r.Note(\"a string is no call\")";
-            {{body}}
-                    return null;
-                }
-            }
-            """);
-
-    /// <summary>Stages a source of the probe P (C1's), or a harness source no one probe owns, holding <paramref name="body"/> in a check.</summary>
-    private void StageCheck(string body, string file = "probes/P.cs") =>
-        fx.Write(Path.GetRelativePath(fx.Root, Path.Combine(Staged, file)), $$"""
-            public sealed class P
-            {
-                static string? Check(Check c, string x)
-                {
-                    var refused = new Entry().Refused();
-                    // c.Inapplicable(Cite.NotPromised("in-a-comment"));
-                    var text = "c.Refused(Cite.Docs(\"in-a-string.md\"))";
-            {{body}}
-                    return null;
-                }
-            }
-            """);
-
-    private (int Exit, string Out, string Err) Register() => fx.Ledger("register", "--probe", "P", "--claim", "C1", "--filter", "*C1Probe");
-
-    private void Finding(string id, string status) =>
-        File.AppendAllText(Path.Combine(fx.BranchDir, "findings.jsonl"),
-            new JsonObject { ["id"] = id, ["claim"] = "C1", ["status"] = status }.ToJsonString() + "\n");
-
-    [Fact]
-    public void A_probe_whose_notes_and_skips_are_written_out_registers()
-    {
-        Finding("F7", "open");
-        Stage("""
-                    r.Note(NoteKeys.Compared, $"{x}: {(x.Length > 1 ? "long" : "short")}");
-                    r.Note(NoteKeys.BothThrew);
-                    r.Skip("F7", "the open finding");
-            """);
-        var (exit, output, error) = Register();
-        exit.ShouldBe(0, output + error);
-    }
-
-    [Fact]
-    public void A_note_key_built_from_text_is_refused_by_file_and_line()
-    {
-        Stage("""        r.Note("msg:" + x, "detail");""");
-        var (exit, _, error) = Register();
-        exit.ShouldBe(1);
-        error.ShouldContain("staging/probes/C1Probe.cs:8: Note(\"msg:\" + x, ...) does not name a key of NoteKeys");
-    }
-
-    [Fact]
-    public void A_note_key_the_catalogue_does_not_declare_is_refused()
-    {
-        Stage("""        r.Note(NoteKeys.InAComment);""");
-        var (exit, _, error) = Register();
-        exit.ShouldBe(1);
-        error.ShouldContain("C1Probe.cs:8: Note(NoteKeys.InAComment, ...) names no key of NoteKeys");
-    }
-
-    [Fact]
-    public void A_finding_built_from_text_is_refused()
-    {
-        Stage("""        r.Skip("F" + x, "why");""");
-        var (exit, _, error) = Register();
-        exit.ShouldBe(1);
-        error.ShouldContain("C1Probe.cs:8: Skip(\"F\" + x, ...) does not name its finding as a string literal");
-    }
-
-    [Fact]
-    public void A_skip_for_a_finding_that_is_not_open_is_refused()
-    {
-        Finding("F7", "open");
-        Finding("F7", "withdrawn");
-        Stage("""
-                    r.Skip("F7", "withdrawn since");
-                    r.Skip("F8", "never filed");
-            """);
-        var (exit, _, error) = Register();
-        exit.ShouldBe(1);
-        error.ShouldContain("C1Probe.cs:8: Skip(\"F7\", ...) names finding F7, which is withdrawn");
-        error.ShouldContain("C1Probe.cs:9: Skip(\"F8\", ...) names no finding this ledger has");
-    }
-
-    [Fact]
-    public void Publish_refuses_what_register_refuses_and_moves_nothing()
-    {
-        Stage("""        r.Note("msg:" + x, "detail");""");
-        var (exit, _, error) = fx.Ledger("publish");
-        exit.ShouldBe(1);
-        error.ShouldContain("publish: ");
-        error.ShouldContain("C1Probe.cs:8: Note(\"msg:\" + x, ...)");
-        File.Exists(Path.Combine(fx.Root, "tools/probe/corpus/probes/C1Probe.cs")).ShouldBeFalse();
-    }
-
-    [Fact]
-    public void A_check_citing_what_exists_registers()
-    {
-        StageCheck("""
-                    c.Inapplicable(Cite.NotPromised("c1-limit"), x);
-                    c.Refused(Cite.Docs("README.md#a"));
-                    c.Refused(Cite.Docs("README.md"));
-                    c.Inapplicable(Cite.Fact("KB-007"));
-                    c.Refused(Cite.Record( "0094" ), "detail");
-            """);
-        var (exit, output, error) = Register();
-        exit.ShouldBe(0, output + error);
-    }
-
-    [Fact]
-    public void A_citation_that_is_not_a_factory_with_a_string_literal_is_refused()
-    {
-        StageCheck("""
-                    var cite = Cite.NotPromised("c1-limit");
-                    c.Inapplicable(cite);
-                    c.Refused(Cite.NotPromised("c1-" + x));
-                    c.Inapplicable(Cite.Text("c1-limit"));
-            """);
-        var (exit, _, error) = Register();
-        exit.ShouldBe(1);
-        error.ShouldContain("staging/probes/P.cs:9: Inapplicable(cite, ...) does not cite by a Cite factory with a string literal");
-        error.ShouldContain("P.cs:10: Refused(Cite.NotPromised(\"c1-\" + x), ...) does not cite by a Cite factory with a string literal");
-        error.ShouldContain("P.cs:11: Inapplicable(Cite.Text(\"c1-limit\"), ...) does not cite by a Cite factory with a string literal");
-    }
-
-    [Fact]
-    public void A_not_promised_id_the_probes_claim_does_not_list_is_refused()
-    {
-        StageCheck("""        c.Inapplicable(Cite.NotPromised("c2-limit"));""");
-        var (exit, _, error) = Register();
-        exit.ShouldBe(1);
-        error.ShouldContain("P.cs:8: Inapplicable(Cite.NotPromised(\"c2-limit\"), ...) names no not-promised entry of its claim C1");
-    }
-
-    [Fact]
-    public void A_harness_source_cites_any_claims_not_promised_entry_and_none_that_no_claim_lists()
-    {
-        StageCheck("""
-                    c.Inapplicable(Cite.NotPromised("c2-limit"));
-                    c.Inapplicable(Cite.NotPromised("no-claim-lists-it"));
-            """, "harness/Shared.cs");
-        var (exit, _, error) = Register();
-        exit.ShouldBe(1);
-        error.ShouldNotContain("Shared.cs:8:");
-        error.ShouldContain("staging/harness/Shared.cs:9: Inapplicable(Cite.NotPromised(\"no-claim-lists-it\"), ...) names no not-promised entry of any claim");
-    }
-
-    [Fact]
-    public void A_docs_source_naming_no_file_is_refused()
-    {
-        StageCheck("""        c.Refused(Cite.Docs("docs/gone.md#a"));""");
-        var (exit, _, error) = Register();
-        exit.ShouldBe(1);
-        error.ShouldContain("P.cs:8: Refused(Cite.Docs(\"docs/gone.md#a\"), ...) names no file docs/gone.md in the repository");
-    }
-
-    [Fact]
-    public void A_fact_with_no_knowledge_entry_is_refused()
-    {
-        StageCheck("""        c.Refused(Cite.Fact("KB-070"));""");
-        var (exit, _, error) = Register();
-        exit.ShouldBe(1);
-        error.ShouldContain("P.cs:8: Refused(Cite.Fact(\"KB-070\"), ...) names no entry under design/knowledge/");
-    }
-
-    [Fact]
-    public void A_record_with_no_file_under_design_adr_is_refused()
-    {
-        StageCheck("""        c.Inapplicable(Cite.Record("0095"));""");
-        var (exit, _, error) = Register();
-        exit.ShouldBe(1);
-        error.ShouldContain("P.cs:8: Inapplicable(Cite.Record(\"0095\"), ...) names no record under design/adr/");
-    }
-
-    [Fact]
-    public void Publish_refuses_a_citation_that_names_nothing()
-    {
-        StageCheck("""        c.Inapplicable(Cite.Record("0095"));""");
-        var (exit, _, error) = fx.Ledger("publish");
-        exit.ShouldBe(1);
-        error.ShouldContain("publish: ");
-        error.ShouldContain("P.cs:8: Inapplicable(Cite.Record(\"0095\"), ...) names no record under design/adr/");
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/ToolchainTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/ToolchainTests.cs
deleted file mode 100644
index 3c22bc0d..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/ToolchainTests.cs
+++ /dev/null
@@ -1,142 +0,0 @@
-using System.Text.Json.Nodes;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>
-/// A result is bound to what the axes file's toolchain commands print. A command that cannot say it refuses, by
-/// name: hashed into the identity, its error text made every result read as stale, so `status` showed 0% current
-/// when the dotnet first on PATH had no SDK global.json accepts.
-/// </summary>
-public sealed class ToolchainTests : IDisposable
-{
-    private readonly Fixture fx = new();
-    public void Dispose() => fx.Dispose();
-
-    private static Dictionary<string, string> R(string x, string y) => new(StringComparer.Ordinal) { ["x"] = x, ["y"] = y };
-
-    private void Toolchain(params string[] command)
-    {
-        var path = Path.Combine(fx.Root, ".claude/probe-axes.md");
-        var text = File.ReadAllText(path);
-        var block = text[(text.IndexOf('\n') + 1)..text.LastIndexOf("```", StringComparison.Ordinal)];
-        var axes = JsonNode.Parse(block)!.AsObject();
-        axes["replay"] = new JsonObject { ["toolchain"] = new JsonObject { ["sdk"] = new JsonArray([.. command.Select(c => (JsonNode)c)]) } };
-        fx.Write(".claude/probe-axes.md", "```json probe-axes\n" + axes.ToJsonString() + "\n```\n");
-        fx.Commit("toolchain");
-    }
-
-    /// <summary>A pass recorded under a toolchain that names itself, then read under one that cannot.</summary>
-    private void RecordedThenBroken(params string[] command)
-    {
-        Toolchain("git", "--version");
-        RecordPass();
-        Toolchain(command);
-    }
-
-    private void RecordPass()
-    {
-        fx.Footprint();
-        fx.Ledger("record-run", "--probe", "P", "--result", "pass", "--evidence", fx.Evidence([R("1", "1"), R("2", "2")])).Exit.ShouldBe(0);
-    }
-
-    /// <summary>The ways a toolchain command fails to name the toolchain, each with what the refusal must say.</summary>
-    public static TheoryData<string[], string> Failing() => new()
-    {
-        { ["git", "no-such-subcommand"], "exited 1" },
-        { ["cmtk-no-such-program"], "did not start" },
-        { ["git", "diff", "--quiet"], "printed nothing" },
-        { [], "is empty" },
-    };
-
-    [Theory, MemberData(nameof(Failing))]
-    public void A_toolchain_command_that_cannot_name_the_toolchain_refuses(string[] command, string reason)
-    {
-        RecordedThenBroken(command);
-        var (exit, output, error) = fx.Ledger("status");
-        exit.ShouldBe(1, output);
-        error.ShouldContain("the toolchain command sdk");
-        error.ShouldContain(reason);
-        output.ShouldNotContain("pairs current", Case.Sensitive, "a refusal, never a status of 0% current");
-    }
-
-    /// <summary>
-    /// The case that was found: a dotnet with no SDK global.json accepts lists the installed SDKs on stdout, which
-    /// reads like a version, and says why on stderr. The refusal quotes the why.
-    /// </summary>
-    [Fact]
-    public void A_dotnet_without_the_pinned_sdk_refuses_with_its_error_not_its_sdk_list()
-    {
-        fx.Write("global.json", """{"sdk": {"version": "0.0.1"}}""");
-        RecordedThenBroken("dotnet", "--version");
-        var (exit, output, error) = fx.Ledger("status");
-        exit.ShouldBe(1, output);
-        error.ShouldContain("the toolchain command sdk (`dotnet --version`) exited");
-        error.ShouldNotContain("sdk]", Case.Insensitive, "the installed SDKs on stdout are not the reason");
-    }
-
-    /// <summary>Every command that reads an identity, not only status.</summary>
-    [Theory]
-    [InlineData("status")]
-    [InlineData("gate")]
-    [InlineData("stale")]
-    [InlineData("rows", "--claim", "C1")]
-    [InlineData("identity", "--probe", "P")]
-    public void Every_reader_of_an_identity_refuses(params string[] command)
-    {
-        RecordedThenBroken("git", "no-such-subcommand");
-        var (exit, _, error) = fx.Ledger(command);
-        exit.ShouldBe(1, error);
-        error.ShouldContain("the toolchain command sdk");
-    }
-
-    /// <summary>
-    /// The case that was found next: Homebrew's dotnet first on PATH (10.0.401 against the 10.0.402 pin) made every
-    /// `dotnet` the prober starts fail, though the SDK installer's had the pinned SDK. Here the dotnet that runs the
-    /// built prober has no SDK the pin accepts, and a stub in the installer's place (TOOLS_DOTNET_FALLBACK_DIR) answers:
-    /// the prober falls back to it, records the pass under what it prints, and keeps the pass current.
-    /// </summary>
-    [Fact]
-    public void A_dotnet_without_the_pinned_sdk_falls_back_to_the_installers()
-    {
-        Assert.SkipWhen(OperatingSystem.IsWindows(), "the stub installer is a shell script");
-        Toolchain("dotnet", "--version");
-        fx.Write("global.json", """{"sdk": {"version": "0.0.1", "rollForward": "disable"}}""");
-        fx.Commit("a pin no dotnet here has");
-        fx.Footprint();
-        var evidence = fx.Evidence([R("1", "1"), R("2", "2")]);
-
-        var installer = Directory.CreateTempSubdirectory("prober-installer-").FullName;
-        try
-        {
-            var stub = Path.Combine(installer, "dotnet");
-            File.WriteAllText(stub, "#!/bin/sh\necho 0.0.1\n");
-            if (!OperatingSystem.IsWindows()) File.SetUnixFileMode(stub, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute);
-            using var sandbox = new ToolSandbox("Prober", "prober");
-            // The prober runs as its own process, so the caller's state settings would reach it: under a PROBE_STATE_DIR it
-            // recorded the run there, not in this repository's state, and status found no claim (#58). None reaches it.
-            var environment = new Dictionary<string, string?>
-            {
-                ["TOOLS_DOTNET_FALLBACK_DIR"] = installer, ["PROBE_STATE_DIR"] = null, ["PROBE_CACHE_DIR"] = null, ["PROBE_HOLDER"] = null,
-            };
-            (int, string, string) Prober(params string[] arguments) => ToolSandbox.RunProcess("dotnet", [sandbox.Dll, .. arguments], fx.Root, environment);
-
-            var (recorded, _, why) = Prober("record-run", "--probe", "P", "--result", "pass", "--evidence", evidence);
-            recorded.ShouldBe(0, why);
-            var (exit, output, error) = Prober("status", "--json");
-            exit.ShouldBe(0, error);
-            ((int)JsonNode.Parse(output)!["claims"]!["C1"]!["current"]!.GetValue<double>()).ShouldBe(2, "the pass, recorded under the fallback, is current");
-        }
-        finally
-        {
-            Directory.Delete(installer, recursive: true);
-        }
-    }
-
-    [Fact]
-    public void A_toolchain_that_names_itself_keeps_the_result_current()
-    {
-        Toolchain("git", "--version");
-        RecordPass();
-        fx.Covered().ShouldBe(2);
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Prober.Tests/TryProbeTests.cs b/test/CodoMetis.TypeKit.Prober.Tests/TryProbeTests.cs
deleted file mode 100644
index 7b0076f4..00000000
--- a/test/CodoMetis.TypeKit.Prober.Tests/TryProbeTests.cs
+++ /dev/null
@@ -1,265 +0,0 @@
-using System.Security.Cryptography;
-using System.Text;
-using System.Text.Json.Nodes;
-using Prober;
-
-namespace CodoMetis.TypeKit.Prober.Tests;
-
-/// <summary>
-/// `try` is the writer's loop for one probe: it builds once in the replay's worktree, runs that probe alone,
-/// prints how each row ended and exits with the probe's code, and records nothing. The probes here are a fake
-/// adapter: P runs C1's three rows (row 1 violates, and the run then exits 7) and Q runs C2's.
-/// </summary>
-public sealed class TryProbeTests : IDisposable
-{
-    private readonly Fixture fx = new();
-    private readonly string cache;
-    private readonly FakeAdapter adapter = new();
-
-    public TryProbeTests()
-    {
-        cache = fx.Root + "-cache";
-        fx.Sh("git", "config", "core.autocrlf", "false");
-        fx.Write(".claude/probe-axes.md", "```json probe-axes\n" + new JsonObject
-        {
-            ["axes"] = new JsonObject { ["x"] = new JsonArray("1", "2"), ["y"] = new JsonArray("1", "2") },
-            ["surfaces"] = new JsonObject { ["s"] = new JsonObject { ["axes"] = new JsonArray("x", "y"), ["watched"] = new JsonArray("src") } },
-            ["replay"] = new JsonObject { ["probeDir"] = "probes", ["include"] = new JsonArray("src") },
-        }.ToJsonString() + "\n```\n");
-        fx.Write("tools/probe/corpus/claims.json", """[{"id": "C1", "source": "README.md#a", "surfaces": ["s"]}, {"id": "C2", "source": "README.md#a", "surfaces": ["s"]}]""");
-        fx.Write("tools/probe/corpus/rows/Q.json", """{"claim": "C2", "rows": [{"row": {"x": "1", "y": "1"}}]}""");
-        fx.Write("tools/probe/corpus/harness/Q.cs", "// probe Q\n");
-        Registry(new JsonObject { ["claim"] = "C1", ["filter"] = "*P" });
-        fx.Rows([("1", "1"), ("2", "2"), ("1", "2")]);
-        fx.Commit("two probes, C1 of three rows");
-    }
-
-    public void Dispose()
-    {
-        fx.Dispose();
-        try { Directory.Delete(cache, recursive: true); } catch (IOException) { } catch (UnauthorizedAccessException) { }
-    }
-
-    private void Registry(JsonObject p) =>
-        fx.Write("tools/probe/corpus/registry.json", new JsonObject
-        {
-            ["probes"] = new JsonObject { ["P"] = p, ["Q"] = new JsonObject { ["claim"] = "C2", ["filter"] = "*Q" } },
-        }.ToJsonString());
-
-    private (int Exit, string Out, string Err) Try(params string[] args) => TryEnding(Environment.NewLine, args);
-
-    /// <summary>As <see cref="Try"/>, with the line end the output writers use, so a test sees Windows' output on any OS.</summary>
-    private (int Exit, string Out, string Err) TryEnding(string newLine, params string[] args)
-    {
-        var output = new StringWriter { NewLine = newLine }; var error = new StringWriter { NewLine = newLine };
-        var context = new Context(fx.Root, new Dictionary<string, string?> { ["PROBE_CACHE_DIR"] = cache }, output, error);
-        int exit;
-        try { exit = TryProbe.Run(context, new Args(args, new HashSet<string>(StringComparer.Ordinal) { "no-build" }), adapter); }
-        catch (Refusal refusal) { error.WriteLine(refusal.Message); exit = refusal.ExitCode; }
-        return (exit, output.ToString(), error.ToString());
-    }
-
-    /// <summary>The output's lines, whatever line end the writer used.</summary>
-    private static string[] Lines(string output) => output.ReplaceLineEndings("\n").Split('\n');
-
-    [Theory]
-    [InlineData("\n")]
-    [InlineData("\r\n")]
-    public void It_runs_the_one_probe_and_prints_how_each_row_ended(string newLine)
-    {
-        var (exit, output, error) = TryEnding(newLine, "--probe", "P");
-        exit.ShouldBe(7, output + error);
-        adapter.Builds.ShouldBe(1);
-        adapter.Runs.ShouldHaveSingleItem().Filter.ShouldBe("*P");
-        adapter.Runs[0].Rows.ShouldBeNull("every row, as the registry runs it");
-        var lines = Lines(output);
-        lines.ShouldContain(l => l.StartsWith("  P: Tests: 1 failed of 3 (exit 7, ", StringComparison.Ordinal));
-        lines.ShouldContain("    #0 pass");
-        lines.ShouldContain("    #1 violation: row 1 breaks the claim");
-        lines.ShouldContain("    #2 pass");
-        lines.ShouldContain("prober try: P: pass 2, violation 1; exit 7");
-    }
-
-    [Fact]
-    public void A_probe_that_passes_exits_0()
-    {
-        adapter.Violates = null;
-        var (exit, output, _) = Try("--probe", "P");
-        exit.ShouldBe(0, output);
-        output.ShouldContain("prober try: P: pass 3; exit 0");
-    }
-
-    [Fact]
-    public void It_records_nothing_under_the_state_directory()
-    {
-        // A staged probe and a ledger with runs and evidence, as a round leaves them.
-        fx.Write(".claude/agent-memory-local/prober/branches/main/staging/probes/R.cs", "// staged\n");
-        fx.Write(".claude/agent-memory-local/prober/branches/main/runs.jsonl", """{"probe": "P", "result": "pass"}""" + "\n");
-        var before = Hash(fx.Memory);
-        Try("--probe", "P").Exit.ShouldBe(7);
-        Try("--probe", "P", "--rows", "0").Exit.ShouldBe(0);
-        Hash(fx.Memory).ShouldBe(before);
-    }
-
-    [Fact]
-    public void Rows_runs_the_rows_given_one_stretch_at_a_time()
-    {
-        var (exit, output, _) = Try("--probe", "P", "--rows", "0,2");
-        exit.ShouldBe(0, output);
-        adapter.Runs.Select(r => r.Rows).ShouldBe(["0-0", "2-2"]);
-        output.ShouldContain("#0 pass");
-        output.ShouldContain("#2 pass");
-        output.ShouldNotContain("#1 ");
-        Try("--probe", "P", "--rows", "1,2").Exit.ShouldBe(7);
-        adapter.Runs.Skip(2).Select(r => r.Rows).ShouldBe(["1-2"]);
-    }
-
-    [Fact]
-    public void Rows_runs_each_row_in_the_variant_that_selects_it()
-    {
-        Registry(new JsonObject
-        {
-            ["claim"] = "C1", ["filter"] = "*P",
-            ["variants"] = new JsonArray(new JsonObject { ["PROBE_ONLY"] = "x=1" }, new JsonObject { ["PROBE_ONLY"] = "x=2" }),
-        });
-        fx.Commit("variants");
-        var (exit, output, _) = Try("--probe", "P", "--rows", "1,2");
-        exit.ShouldBe(7, output);
-        adapter.Runs.Select(r => (r.Only, r.Rows)).ShouldBe([("x=1", "2-2"), ("x=2", "1-1")]);
-        output.ShouldContain("  P [PROBE_ONLY=x=1] rows 2-2: ");
-    }
-
-    [Fact]
-    public void A_row_the_claim_does_not_have_is_refused_before_anything_runs()
-    {
-        var (exit, _, error) = Try("--probe", "P", "--rows", "3");
-        exit.ShouldBe(2);
-        error.ShouldContain("--rows 3: the claim has 3 row(s), 0 to 2");
-        adapter.Builds.ShouldBe(0);
-        adapter.Runs.ShouldBeEmpty();
-    }
-
-    [Fact]
-    public void A_probe_not_in_the_registry_is_refused()
-    {
-        var (exit, _, error) = Try("--probe", "Nope");
-        exit.ShouldBe(2);
-        error.ShouldContain("no probe Nope in the registry");
-    }
-
-    [Fact]
-    public void No_build_runs_without_building()
-    {
-        Try("--probe", "P", "--no-build").Exit.ShouldBe(2, "no worktree yet, so nothing was ever built");
-        Try("--probe", "P").Exit.ShouldBe(7);
-        Try("--probe", "P", "--no-build").Exit.ShouldBe(7);
-        adapter.Builds.ShouldBe(1);
-        adapter.Runs.Count.ShouldBe(2);
-    }
-
-    [Fact]
-    public void A_failed_build_runs_nothing()
-    {
-        adapter.BuildFails = true;
-        var (exit, output, _) = Try("--probe", "P");
-        exit.ShouldBe(1);
-        output.ShouldContain("Build: FAILED");
-        adapter.Runs.ShouldBeEmpty();
-    }
-
-    [Fact]
-    public void The_staging_is_overlaid_where_the_probe_runs()
-    {
-        fx.Write(".claude/agent-memory-local/prober/branches/main/staging/probes/R.cs", "// staged\n");
-        Try("--probe", "P").Exit.ShouldBe(7);
-        var worktree = Path.Combine(Directory.GetDirectories(cache).Single(), "wt");
-        adapter.Worktrees.ShouldAllBe(w => w == worktree);
-        File.ReadAllText(Path.Combine(worktree, "probes", "R.cs")).ShouldBe("// staged\n");
-        File.Exists(Path.Combine(worktree, "probes", "P.cs")).ShouldBeTrue();
-    }
-
-    /// <summary>Every file and directory under <paramref name="dir"/>, by relative path and content.</summary>
-    private static string Hash(string dir) =>
-        Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(string.Join("\n",
-            Directory.EnumerateFileSystemEntries(dir, "*", SearchOption.AllDirectories).Order(StringComparer.Ordinal)
-                     .Select(p => Path.GetRelativePath(dir, p) + ":" + (File.Exists(p) ? Convert.ToHexString(SHA256.HashData(File.ReadAllBytes(p))) : "dir"))))));
-
-    [Fact]
-    public void It_holds_the_replay_worktree_while_it_runs()
-    {
-        var (exit, output, error) = Try("--probe", "P");
-        exit.ShouldBe(7, output + error);
-        adapter.WorktreeFreeDuringRun.ShouldBe([false], "a replay of the same checkout must not take the worktree while a try runs in it");
-    }
-
-    [Fact]
-    public void It_refuses_while_a_replay_holds_the_worktree_and_runs_nothing()
-    {
-        var context = new Context(fx.Root, new Dictionary<string, string?> { ["PROBE_CACHE_DIR"] = cache }, TextWriter.Null, TextWriter.Null);
-        var home = global::Prober.Replay.Home(context, new Ledger(context, null));
-        using (global::Prober.Replay.HoldWorktree(home).ShouldNotBeNull())
-        {
-            var (exit, _, error) = Try("--probe", "P");
-            exit.ShouldBe(1);
-            error.ShouldContain($"a replay in this checkout is using {Path.Combine(home, "wt")}; run `prober try` when it ends");
-            adapter.Runs.ShouldBeEmpty();
-        }
-        Try("--probe", "P").Exit.ShouldBe(7, "the worktree is free again once the replay ends");
-    }
-
-    /// <summary>
-    /// Runs the probe the filter names over its claim's rows in the worktree, as the harness does: PROBE_ONLY and
-    /// PROBE_ROWS select, and each row it ran is one line of PROBE_OUT's jsonl. Row 1 of C1 violates.
-    /// </summary>
-    private sealed class FakeAdapter : IProbeAdapter
-    {
-        public int? Violates { get; set; } = 1;
-        public bool BuildFails { get; set; }
-        public int Builds { get; private set; }
-        public List<(string Filter, string? Only, string? Rows)> Runs { get; } = [];
-        public List<string> Worktrees { get; } = [];
-        /// <summary>For each run, whether a replay could have taken the worktree (<c>replay.lock</c> beside it) while the probe ran.</summary>
-        public List<bool> WorktreeFreeDuringRun { get; } = [];
-
-        public Ran Build(string worktree, IReadOnlyDictionary<string, string?> environment)
-        {
-            Builds++;
-            Worktrees.Add(worktree);
-            return BuildFails ? new Ran(1, "Build: FAILED\nerror X", "") : new Ran(0, "Build: OK", "");
-        }
-
-        public Ran RunProbe(string worktree, string filter, string results, string coverageFile, IReadOnlyDictionary<string, string?> environment)
-        {
-            Worktrees.Add(worktree);
-            using (var replay = global::Prober.Replay.HoldWorktree(Path.GetDirectoryName(worktree)!)) WorktreeFreeDuringRun.Add(replay is not null);
-            var only = environment.GetValueOrDefault("PROBE_ONLY");
-            var range = environment.GetValueOrDefault("PROBE_ROWS");
-            Runs.Add((filter, only, range));
-            coverageFile.ShouldBeEmpty("try asks for no coverage");
-            // The probe's own rows: P's are C1's, Q's C2's.
-            var probe = filter.TrimStart('*');
-            var rows = JsonNode.Parse(File.ReadAllText(Path.Combine(worktree, "probes", "rows", probe + ".json")))!["rows"]!.AsArray();
-            var (lo, hi) = range is null ? (0, int.MaxValue) : (int.Parse(range.Split('-')[0]), int.Parse(range.Split('-')[1]));
-            var lines = new List<string>(); var failed = 0;
-            for (var i = 0; i < rows.Count; i++)
-            {
-                if (i < lo || i > hi || !global::Prober.Replay.Selected(Files.StringMap(rows[i]!["row"]), only ?? "")) continue;
-                var violates = probe == "P" && i == Violates;
-                if (violates) failed++;
-                lines.Add(new JsonObject
-                {
-                    ["idx"] = i, ["category"] = violates ? "violation" : "pass",
-                    ["reasons"] = violates ? new JsonArray("violation:row 1 breaks the claim") : new JsonArray(), ["note"] = "compared",
-                }.ToJsonString());
-            }
-            var outDir = environment["PROBE_OUT"]!;
-            Directory.CreateDirectory(outDir);
-            File.WriteAllText(Path.Combine(outDir, probe + ".jsonl"), string.Join('\n', lines) + "\n");
-            return failed > 0 ? new Ran(7, $"Tests: {failed} failed of {lines.Count}\n", "") : new Ran(0, $"Tests: {lines.Count} passed\n", "");
-        }
-
-        public (JsonObject? Axes, string? Error) DeriveAxes(string checkout, string workDirectory) => (null, "none");
-
-        public IReadOnlyDictionary<string, string?> Environment(string cacheDirectory) => new Dictionary<string, string?>();
-    }
-}
diff --git a/test/CodoMetis.TypeKit.Samples/Analyzers/QueryConditionSamples.cs b/test/CodoMetis.TypeKit.Samples/Analyzers/QueryConditionSamples.cs
new file mode 100644
index 00000000..da47dda7
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Samples/Analyzers/QueryConditionSamples.cs
@@ -0,0 +1,30 @@
+using CodoMetis.TypeKit;
+using Microsoft.EntityFrameworkCore;
+
+namespace ReadmeSamples.Analyzers.QueryConditions;
+
+public sealed class Order
+{
+    public int Id { get; init; }
+
+    public bool Open { get; set; }
+}
+
+public sealed class OrdersDb(DbContextOptions<OrdersDb> options) : DbContext(options)
+{
+    public DbSet<Order> Orders => Set<Order>();
+}
+
+public static class QueryConditionSamples
+{
+    public static void DelegateCondition(OrdersDb db)
+    {
+#pragma warning disable CMTK0009 // what the sample shows the rule reporting
+        // sample: CodoMetis.TypeKit.Analyzers/cmtk0009-query
+        Func<Order, bool> isOpen = o => o.Open;
+        var first = db.Orders.FirstOrNone(isOpen);           // CMTK0009: binds to the IEnumerable<T> overload and reads every row
+        var found = db.Orders.FirstOrNone(o => o.Open);      // the database runs the condition and returns one row
+        // end sample
+#pragma warning restore CMTK0009
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Samples/AspNetCore/AspNetCoreSamples.cs b/test/CodoMetis.TypeKit.Samples/AspNetCore/AspNetCoreSamples.cs
index e957852e..3b638173 100644
--- a/test/CodoMetis.TypeKit.Samples/AspNetCore/AspNetCoreSamples.cs
+++ b/test/CodoMetis.TypeKit.Samples/AspNetCore/AspNetCoreSamples.cs
@@ -1,8 +1,3 @@
-// sample: CodoMetis.TypeKit.AspNetCore/inline
-using System.Reflection;
-using CodoMetis.TypeKit.CompilerServices;   // GeneratedValueObjectAttribute, on every value object
-
-// end sample
 // sample: CodoMetis.TypeKit.AspNetCore/every-document
 using Microsoft.AspNetCore.OpenApi;   // OpenApiOptions
 
@@ -12,6 +7,7 @@
 
 // end sample
 using System.Net;
+using System.Reflection;
 using System.Text;
 using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
@@ -102,20 +98,6 @@ public static void Use(WebApplicationBuilder builder)
     }
 }
 
-public static class Inlining
-{
-    public static void Use(OpenApiOptions options)
-    {
-        // sample: CodoMetis.TypeKit.AspNetCore/inline
-        options.AddTypeKit();
-        options.CreateSchemaReferenceId = type =>
-            (Nullable.GetUnderlyingType(type.Type) ?? type.Type).GetCustomAttribute<GeneratedValueObjectAttribute>() is not null
-                ? null
-                : OpenApiOptions.CreateDefaultSchemaReferenceId(type);
-        // end sample
-    }
-}
-
 public static class RequiredProperties
 {
     public static void Use(WebApplicationBuilder builder)
diff --git a/test/CodoMetis.TypeKit.Samples/AspNetCore/FaultResponseSamples.cs b/test/CodoMetis.TypeKit.Samples/AspNetCore/FaultResponseSamples.cs
index d094614b..15033077 100644
--- a/test/CodoMetis.TypeKit.Samples/AspNetCore/FaultResponseSamples.cs
+++ b/test/CodoMetis.TypeKit.Samples/AspNetCore/FaultResponseSamples.cs
@@ -39,6 +39,14 @@ public sealed record Account(int Id, string Email);
 
 public sealed record NewAccount(string Email);
 
+/// <summary>What a store throws when a unique index rejects a row.</summary>
+public sealed class UniqueViolationException(string message) : Exception(message);
+
+public interface IAccountStore
+{
+    Account Save(Account account);
+}
+
 public interface IAccounts
 {
     Result<Account, AccountFault> Open(NewAccount body);
@@ -79,6 +87,25 @@ public static void Endpoints(WebApplication app, ISignIn accounts)
     }
 }
 
+/// <summary>The README's sign-in with the name withheld: the domain's faults answered as they are, and alike.</summary>
+public static class WithheldSignIns
+{
+    public static void Responses(WebApplicationBuilder builder)
+    {
+        // sample: CodoMetis.TypeKit.AspNetCore/withheld-fault-name
+        builder.Services.AddFaultResponses<SignInFault>(_ => FaultResponse.Status(StatusCodes.Status401Unauthorized).WithoutFaultName());
+
+        // end sample
+    }
+
+    public static void Endpoints(WebApplication app, ISignIn accounts)
+    {
+        // sample: CodoMetis.TypeKit.AspNetCore/withheld-fault-name
+        app.MapPost("/login", (Credentials credentials) => accounts.SignIn(credentials).ToHttpResult());   // no fault, no rule
+        // end sample
+    }
+}
+
 public static class Faults
 {
     public static void Responses(WebApplicationBuilder builder)
@@ -142,6 +169,28 @@ public static Result<Account, Fault<AccountFault>> Reserved()
         return reserved;
     }
 
+    public static Result<Account, Fault<AccountFault>> Saved(IAccountStore store, Account account)
+    {
+        // sample: CodoMetis.TypeKit.AspNetCore/fault-cause-domain
+        Result<Account, Fault<AccountFault>> saved = Result.Catch<Account, UniqueViolationException>(() => store.Save(account))
+            .MapError(e => Fault.Of(AccountFault.EmailTaken, "Another account took the address a moment ago.", e));
+        // end sample
+
+        return saved;
+    }
+
+    public static void Logged(WebApplicationBuilder builder)
+    {
+        // sample: CodoMetis.TypeKit.AspNetCore/fault-cause-log
+        builder.Services.AddProblemDetails(options => options.CustomizeProblemDetails = context =>
+        {
+            if (context.HttpContext.Features.Get<IFaultFeature>() is { Cause: { } cause } fault)
+                context.HttpContext.RequestServices.GetRequiredService<ILoggerFactory>().CreateLogger("Faults")
+                    .LogWarning(cause, "Answered {Fault} for an exception", fault.Name);   // your log gets the exception, the client doesn't
+        });
+        // end sample
+    }
+
     public static void Shaped(WebApplicationBuilder builder)
     {
         // sample: CodoMetis.TypeKit.AspNetCore/fault-feature
@@ -222,6 +271,25 @@ private static async Task<WebApplication> StartWithAsync(Action<WebApplicationBu
         return app;
     }
 
+    private sealed class TakenStore(Exception thrown) : IAccountStore
+    {
+        public Account Save(Account account) => throw thrown;
+    }
+
+    /// <summary>The README's cause: the store's exception is kept on the fault, and the fault is still the one the client sees.</summary>
+    [Fact]
+    public void A_caught_exception_is_kept_as_the_cause()
+    {
+        var thrown = new UniqueViolationException("duplicate key value violates unique constraint \"ix_accounts_email\"");
+
+        var saved = Faults.Saved(new TakenStore(thrown), new Account(7, "ada@example.com"));
+
+        saved.TryGetValue(out _, out var fault).ShouldBeFalse();
+        fault.Reason.ShouldBe(AccountFault.EmailTaken);
+        fault.Cause.ShouldBeSameAs(thrown);
+        fault.ShouldBe(Fault.Of(AccountFault.EmailTaken, "Another account took the address a moment ago."));
+    }
+
     /// <summary>The README's one call for every fault set: AccountFault answered by its kind with no mapping of its own.</summary>
     [Fact]
     public async Task Every_fault_set_is_answered_by_its_kind_with_one_call()
@@ -408,6 +476,28 @@ public async Task Two_causes_mapped_to_one_fault_answer_alike_where_one_status_a
         (await AnswerAsync(app, "/login-telling", "ann")).Body["fault"]!.GetValue<string>().ShouldBe("WrongPassword");
     }
 
+    /// <summary>The README's second way: the domain's two faults answered as they are, the name withheld, and alike.</summary>
+    [Fact]
+    public async Task Two_causes_whose_name_the_mapping_withholds_answer_alike_without_a_fault()
+    {
+        var builder = WebApplication.CreateBuilder(new WebApplicationOptions { EnvironmentName = Environments.Production });
+        builder.WebHost.UseTestServer();
+        builder.Logging.ClearProviders();
+        WithheldSignIns.Responses(builder);
+
+        await using var app = builder.Build();
+        WithheldSignIns.Endpoints(app, new Refusing());
+        await app.StartAsync(TestContext.Current.CancellationToken);
+
+        var unknownUser = await AnswerAsync(app, "/login", "nobody");
+        var wrongPassword = await AnswerAsync(app, "/login", "ann");
+        unknownUser.Status.ShouldBe(HttpStatusCode.Unauthorized);
+        unknownUser.Body.ContainsKey("fault").ShouldBeFalse(unknownUser.Body.ToJsonString());
+        wrongPassword.Status.ShouldBe(unknownUser.Status);
+        JsonNode.DeepEquals(wrongPassword.Body, unknownUser.Body)
+            .ShouldBeTrue($"{wrongPassword.Body.ToJsonString()} tells itself apart from {unknownUser.Body.ToJsonString()}");
+    }
+
     private static async Task<(HttpStatusCode Status, JsonObject Body)> AnswerAsync(WebApplication app, string path, string user)
     {
         using var content = new StringContent($$"""{"user":"{{user}}","password":"secret"}""", System.Text.Encoding.UTF8, "application/json");
diff --git a/test/CodoMetis.TypeKit.Samples/Base/ResultSamples.cs b/test/CodoMetis.TypeKit.Samples/Base/ResultSamples.cs
index 219d70db..d1481893 100644
--- a/test/CodoMetis.TypeKit.Samples/Base/ResultSamples.cs
+++ b/test/CodoMetis.TypeKit.Samples/Base/ResultSamples.cs
@@ -83,6 +83,21 @@ from price in pricing.For(item, customer)
         Result<IReadOnlyList<Sku>, SkuFault> all = parsed.Sequence();
         // end sample
     }
+
+    public static async Task<(List<Sku>, Result<IReadOnlyList<Sku>, SkuFault>, Result<IReadOnlyList<Order>, OrderFault>)> Streams(
+        IOrders orders,
+        IAsyncEnumerable<string> lines,
+        IAsyncEnumerable<Result<Sku, SkuFault>> rows,
+        IAsyncEnumerable<OrderId> ids,
+        CancellationToken cancellationToken)
+    {
+        // sample: CodoMetis.TypeKit/streams
+        IAsyncEnumerable<Sku> known = lines.Choose(line => Sku.TryFrom(line));                        // the lines that are SKUs, as they arrive
+        Result<IReadOnlyList<Sku>, SkuFault> imported = await rows.SequenceAsync(cancellationToken);   // every SKU, or the first fault
+        Result<IReadOnlyList<Order>, OrderFault> found = await ids.TraverseAsync(orders.FindAsync);    // one lookup at a time, in order
+        // end sample
+        return (await known.ToListAsync(cancellationToken), imported, found);
+    }
 }
 
 public readonly partial record struct OrderId : IValue<Guid>;
diff --git a/test/CodoMetis.TypeKit.Samples/CodoMetis.TypeKit.Samples.csproj b/test/CodoMetis.TypeKit.Samples/CodoMetis.TypeKit.Samples.csproj
index 8116a63d..a79cceb7 100644
--- a/test/CodoMetis.TypeKit.Samples/CodoMetis.TypeKit.Samples.csproj
+++ b/test/CodoMetis.TypeKit.Samples/CodoMetis.TypeKit.Samples.csproj
@@ -16,6 +16,11 @@
       The samples' namespaces are outside CodoMetis.TypeKit on purpose: inside it, the enclosing
       namespace would supply Option, Result and OrderId.New() to a sample whose README forgot the using.
     -->
+    <PropertyGroup>
+        <!-- The woven code, written to obj/…/metalama: GeneratedCodeBlockTests holds the READMEs' generated-code blocks to it. -->
+        <MetalamaEmitCompilerTransformedFiles>true</MetalamaEmitCompilerTransformedFiles>
+    </PropertyGroup>
+
     <ItemGroup>
         <FrameworkReference Include="Microsoft.AspNetCore.App" />
         <PackageReference Include="Microsoft.AspNetCore.OpenApi" />
@@ -26,6 +31,17 @@
         <PackageReference Include="NodaTime.Serialization.SystemTextJson" />
     </ItemGroup>
 
+    <!--
+      docs/walkthrough.md shows a sample application, whose sources are the consumer smoke test's walkthrough
+      consumer, so that the packed packages build it too. Its regions are read there; this project compiles them
+      for WalkthroughTests, which runs the service in memory and reads the page with the smoke test's own reader.
+      Program.cs, the host, stays the consumer's.
+    -->
+    <ItemGroup>
+        <Compile Include="..\..\tools\ConsumerSmokeTest\Consumers\walkthrough\*.cs" Exclude="..\..\tools\ConsumerSmokeTest\Consumers\walkthrough\Program.cs" LinkBase="Walkthrough" />
+        <Compile Include="..\..\tools\ConsumerSmokeTest\WalkthroughPage.cs" LinkBase="Walkthrough" />
+    </ItemGroup>
+
     <ItemGroup>
         <ProjectReference Include="..\..\src\CodoMetis.TypeKit.Generators\CodoMetis.TypeKit.Generators.csproj" />
         <ProjectReference Include="..\..\src\CodoMetis.TypeKit.EntityFrameworkCore\CodoMetis.TypeKit.EntityFrameworkCore.csproj" />
@@ -35,27 +51,4 @@
         <ProjectReference Include="..\..\src\CodoMetis.TypeKit.Analyzers\CodoMetis.TypeKit.Analyzers.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
     </ItemGroup>
 
-    <!--
-      For the analyzer probes of tools/probe/corpus (CMTK0010, CMTK0014): they run the CMTK analyzers
-      in-process over a CSharpCompilation, as the analyzer tests do, so the analyzer assembly is also
-      referenced as a library, with the compiler it runs on. The type-argument variant catalogues are
-      the analyzer tests' own, compiled in rather than copied, so a site the catalogue gains reaches
-      the probes too.
-    -->
-    <ItemGroup>
-        <ProjectReference Include="..\..\src\CodoMetis.TypeKit.Analyzers\CodoMetis.TypeKit.Analyzers.csproj" />
-        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" />
-        <Compile Include="..\CodoMetis.TypeKit.Analyzers.Tests\Variants\TypeArgumentSites.cs" Link="Variants\TypeArgumentSites.cs" />
-        <Compile Include="..\CodoMetis.TypeKit.Analyzers.Tests\Variants\TypeArgumentKinds.cs" Link="Variants\TypeArgumentKinds.cs" />
-    </ItemGroup>
-
-    <!--
-      The probes' side (1), the framework without TypeKit, is read from a fact's fixture where one covers a row (the harness's Sides,
-      design/adr/0107): the facts' reader is compiled in as it is, BCL only, rather than the Facts project referenced, which is a test
-      project of its own and references no TypeKit project. The fixtures are read from the repository, beside the facts' tests.
-    -->
-    <ItemGroup>
-        <Compile Include="..\CodoMetis.TypeKit.Facts\FactFixture.cs" Link="Facts\FactFixture.cs" />
-    </ItemGroup>
-
 </Project>
diff --git a/test/CodoMetis.TypeKit.Samples/Docs/AspNetCoreSamples.cs b/test/CodoMetis.TypeKit.Samples/Docs/AspNetCoreSamples.cs
index 1e4fb9e4..c530b4f2 100644
--- a/test/CodoMetis.TypeKit.Samples/Docs/AspNetCoreSamples.cs
+++ b/test/CodoMetis.TypeKit.Samples/Docs/AspNetCoreSamples.cs
@@ -89,6 +89,13 @@ public static void Configure(WebApplicationBuilder builder)
         // end sample
     }
 
+    public static void Inline(WebApplicationBuilder builder)
+    {
+        // sample: aspnet-core/inline
+        builder.Services.AddOpenApi(options => options.AddTypeKit(typeKit => typeKit.InlineValueObjects = true));
+        // end sample
+    }
+
     public static void Map(WebApplication app, ICustomers customers)
     {
 #pragma warning disable ASP0020 // the value objects are declared in this project, as the page says
@@ -136,7 +143,7 @@ public sealed partial class AspNetCoreTests
 {
     private const string Readme = "docs/aspnet-core.md";
 
-    private static async Task<(WebApplication App, InMemoryCustomers Customers)> StartAsync(bool customize = false)
+    private static async Task<(WebApplication App, InMemoryCustomers Customers)> StartAsync(bool customize = false, bool inline = false)
     {
         var builder = WebApplication.CreateBuilder(new WebApplicationOptions { EnvironmentName = Environments.Production });
         builder.WebHost.UseTestServer();
@@ -146,6 +153,7 @@ public sealed partial class AspNetCoreTests
         builder.Services.AddControllers().AddApplicationPart(typeof(CustomersController).Assembly);
         Host.Configure(builder);
         if (customize) Host.Customize(builder);
+        if (inline) Host.Inline(builder);   // a second AddTypeKit on the same document: the setting's names come first
 
         var app = builder.Build();
         app.MapOpenApi();
@@ -248,6 +256,24 @@ public async Task The_document_says_what_the_page_shows()
         page!["schema"]!["type"]!.ToJsonString().ShouldContain("integer", Case.Sensitive, "a query parameter is described as a parameter of the wrapped type, inline");
     }
 
+    /// <summary>The component the page shows under "Describe value objects as plain types", read from its third JSON block.</summary>
+    [Fact]
+    public async Task With_InlineValueObjects_the_document_says_what_the_page_shows()
+    {
+        var (app, _) = await StartAsync(inline: true);
+        await using var _ = app;
+
+        var json = await app.GetTestClient().GetStringAsync("/openapi/v1.json", TestContext.Current.CancellationToken);
+        var document = JsonNode.Parse(json)!;
+        var shown = JsonBlocks()[2].AsObject();
+
+        foreach (var (name, schema) in shown) document.Component(name).ShouldContainSchema(schema!, name);
+        document["components"]!["schemas"]!.AsObject().Select(component => component.Key).ShouldNotContain("CustomerId");
+        document["components"]!["schemas"]!.AsObject().Select(component => component.Key).ShouldNotContain("Email");
+        var page = document["paths"]!["/customers"]!["get"]!["parameters"]!.AsArray().Single(parameter => parameter!["name"]!.GetValue<string>() == "page");
+        page!["schema"]!["type"]!.ToJsonString().ShouldContain("integer", Case.Sensitive, "a query parameter is still a parameter of the underlying type");
+    }
+
     private static List<JsonNode> JsonBlocks() =>
         [.. JsonBlock().Matches(SampleOutputs.Readme(Readme)).Select(block => JsonNode.Parse(block.Groups["body"].Value.TrimStart().StartsWith('{') ? block.Groups["body"].Value : $"{{{block.Groups["body"].Value}}}")!)];
 
diff --git a/test/CodoMetis.TypeKit.Samples/Docs/ResultSamples.cs b/test/CodoMetis.TypeKit.Samples/Docs/ResultSamples.cs
index ad225150..2c49a521 100644
--- a/test/CodoMetis.TypeKit.Samples/Docs/ResultSamples.cs
+++ b/test/CodoMetis.TypeKit.Samples/Docs/ResultSamples.cs
@@ -175,16 +175,18 @@ public static (Result<IReadOnlyList<Line>, CheckoutFault> Lines, Result<IReadOnl
         return (lines, all, amount, bulk, summary, stopped);
     }
 
-    public static async Task<(Result<IReadOnlyList<Reservation>, CheckoutFault> Reserved, Result<CheckoutFault> Charged, Result<IReadOnlyList<Cart>, CheckoutFault> Found)> CollectAsync(
-        Checkout checkout, List<Cart> carts, List<decimal> totals, List<CartId> ids, CancellationToken cancellationToken)
+    public static async Task<(Result<IReadOnlyList<Reservation>, CheckoutFault> Reserved, Result<CheckoutFault> Charged, Result<IReadOnlyList<Cart>, CheckoutFault> Found, Result<Option<Cart>, CheckoutFault> Saved, Result<Patch<Cart>, CheckoutFault> Moved)> CollectAsync(
+        Checkout checkout, List<Cart> carts, List<decimal> totals, List<CartId> ids, Option<CartId> savedCart, Patch<CartId> movedTo, CancellationToken cancellationToken)
     {
         // sample: result/collect-async
         Result<IReadOnlyList<Reservation>, CheckoutFault> reserved = await carts.TraverseAsync(checkout.ReserveAsync);     // one at a time, in order; nothing starts after a fault
         Result<CheckoutFault> charged = await totals.TraverseAsync(checkout.ChargeAsync);                                   // a command per element, likewise
         Result<IReadOnlyList<Cart>, CheckoutFault> found = await ids.TraverseAsync(checkout.LoadCartAsync, cancellationToken);   // the token checked before each, and handed to it
+        Result<Option<Cart>, CheckoutFault> saved = await savedCart.TraverseAsync(checkout.FindCartAsync);           // None calls nothing; a value is looked up
+        Result<Patch<Cart>, CheckoutFault> moved = await movedTo.TraverseAsync(checkout.FindCartAsync);              // a clear or an absence passes through
         // end sample
 
-        return (reserved, charged, found);
+        return (reserved, charged, found, saved, moved);
     }
 
     public static async Task<(Result<Uri, Exception> Url, Result<Uri, UriFormatException> Narrowed, Result<Uri, ApiFault> AsFault, Result<Exception> Written, Result<string, Exception> Read)> Catching(string text, string path)
@@ -331,13 +333,24 @@ public async Task Collecting_asynchronously_runs_one_operation_at_a_time_and_sto
     {
         var checkout = new Checkout();
 
-        var (reserved, charged, found) = await Usage.CollectAsync(checkout, [checkout.Cart, checkout.Empty], [10m, 20m], [checkout.Cart.Id], TestContext.Current.CancellationToken);
+        var (reserved, charged, found, saved, moved) = await Usage.CollectAsync(
+            checkout, [checkout.Cart, checkout.Empty], [10m, 20m], [checkout.Cart.Id], Option.Some(checkout.Cart.Id), Patch.Null<CartId>(), TestContext.Current.CancellationToken);
 
         reserved.TryGetValue(out _, out var fault).ShouldBeFalse();
         fault.ShouldBe(CheckoutFault.CartEmpty);
         ((bool)charged).ShouldBeTrue();
         found.TryGetValue(out var carts, out _).ShouldBeTrue();
         carts.ShouldBe([checkout.Cart]);
+        saved.TryGetValue(out var savedCart, out _).ShouldBeTrue();
+        savedCart.ShouldBe(Option.Some(checkout.Cart));
+        moved.TryGetValue(out var movedTo, out _).ShouldBeTrue();
+        movedTo.State.ShouldBe(PatchState.Null);
+
+        var (_, _, _, none, absent) = await Usage.CollectAsync(checkout, [], [], [], Option.None<CartId>(), Patch.Absent<CartId>(), TestContext.Current.CancellationToken);
+        none.TryGetValue(out var noCart, out _).ShouldBeTrue();
+        noCart.IsNone().ShouldBeTrue();
+        absent.TryGetValue(out var untouched, out _).ShouldBeTrue();
+        untouched.State.ShouldBe(PatchState.Absent);
     }
 
     [Fact]
diff --git a/test/CodoMetis.TypeKit.Samples/Docs/WalkthroughTests.cs b/test/CodoMetis.TypeKit.Samples/Docs/WalkthroughTests.cs
new file mode 100644
index 00000000..8cc3ac5f
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Samples/Docs/WalkthroughTests.cs
@@ -0,0 +1,110 @@
+using System.Collections.Concurrent;
+using CodoMetis.TypeKit.AspNetCore;
+using ConsumerSmokeTest;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.TestHost;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using Serilog;
+using Walkthrough;
+
+namespace ReadmeSamples.Docs;
+
+/// <summary>
+/// The walkthrough's orders service, run in memory from the project references: every answer, log line and SQL
+/// statement <c>docs/walkthrough.md</c> states in a comment is what the service gives. The consumer smoke test
+/// runs the same service from the packed packages (<c>tools/ConsumerSmokeTest</c>, its <c>walkthrough</c>
+/// consumer, whose sources this project compiles too); this runs it on every pull request's test leg.
+/// </summary>
+/// <remarks>
+/// The expected text is read from the page by <see cref="WalkthroughPage"/>, the smoke test's own reader, compiled
+/// here too: never written into this test, so a changed answer is corrected in the page's comment.
+/// </remarks>
+[Collection(nameof(Serilog.ConsoleOutput))]
+public sealed class WalkthroughTests
+{
+    private static readonly string Page = SampleOutputs.Readme(WalkthroughPage.Path);
+
+    [Fact]
+    public async Task The_service_answers_what_the_page_states()
+    {
+        await using var connection = new SqliteConnection("Data Source=:memory:");
+        connection.Open();
+        var sql = new ConcurrentQueue<string>();
+
+        // The setup Program.cs has, but for the host's address and the SQL, which is kept here rather than printed.
+        // The log is written to the console as there, with the console captured: the collection runs alone.
+        var builder = WebApplication.CreateBuilder(new WebApplicationOptions { EnvironmentName = Environments.Production });
+        builder.WebHost.UseTestServer();
+        builder.Logging.ClearProviders();
+        builder.Services.AddOpenApi(options => options.AddTypeKit());
+        builder.Services.AddFaultResponses<OrderFault>(fault => fault switch
+        {
+            OrderFault.NotFound => StatusCodes.Status404NotFound,
+            OrderFault.AlreadyShipped or OrderFault.Cancelled => StatusCodes.Status409Conflict,
+            OrderFault.Cleared => StatusCodes.Status422UnprocessableEntity,
+            _ => throw new ArgumentOutOfRangeException(nameof(fault)),
+        });
+        builder.Services.ConfigureHttpJsonOptions(options => options.SerializerOptions.RespectRequiredConstructorParameters = true);
+        builder.Services.AddDbContext<OrdersDb>(options => options.UseSqlite(connection).UseTypeKit()
+            .LogTo(sql.Enqueue, [RelationalEventId.CommandExecuted]));
+        builder.Services.AddSingleton<global::Serilog.ILogger>(new LoggerConfiguration()
+            .Destructure.WithTypeKit()
+            .WriteTo.Console(outputTemplate: "[{Level:u3}] {Message:lj}{NewLine}")
+            .CreateLogger());
+
+        await using var app = builder.Build();
+        app.UseStatusCodePages();
+        app.MapOpenApi();
+        app.MapOrders();
+        using (var scope = app.Services.CreateScope()) scope.ServiceProvider.GetRequiredService<OrdersDb>().Database.EnsureCreated();
+        await app.StartAsync(TestContext.Current.CancellationToken);
+
+        var reported = new List<(string Name, string Value)>();
+        var console = new StringWriter();
+        var original = Console.Out;
+        Console.SetOut(console);
+        try
+        {
+            await Tour.RunAsync(app.GetTestClient(), (name, value) => reported.Add((name, value)));
+        }
+        finally
+        {
+            Console.SetOut(original);
+        }
+        await app.StopAsync(TestContext.Current.CancellationToken);
+
+        var problems = new List<string>();
+        foreach (var (name, value) in reported)
+        {
+            var stated = WalkthroughPage.Stated(Page, WalkthroughPage.Answer(name));
+            if (!WalkthroughPage.Is(stated, value)) problems.Add($"the page states '{stated.Single()}' for {name}, but it is '{value}'");
+        }
+
+        WalkthroughPage.Declarations(Page).Except(reported.Select(answer => answer.Name))
+                       .ShouldBeEmpty("The page states these answers, which the tour never reports.");
+
+        var logged = console.ToString().ReplaceLineEndings("\n").Split('\n').Where(line => line.StartsWith("[INF] ", StringComparison.Ordinal)).ToArray();
+        Within(problems, "log.Information(\"Placed", logged, "the log");
+
+        var statements = sql.SelectMany(message => message.Split('\n')).ToArray();
+        Within(problems, "order.Quantity.Value >= minimum.Value", statements, "the SQL");
+        Within(problems, "Database.EnsureCreated()", statements, "the SQL");
+
+        logged.ShouldNotContain(line => line.Contains("ann@example.com", StringComparison.Ordinal), "The e-mail address is masked in every log line.");
+        problems.ShouldBeEmpty();
+    }
+
+    private static void Within(List<string> problems, string fragment, IReadOnlyList<string> lines, string what)
+    {
+        var stated = WalkthroughPage.Stated(Page, fragment);
+        if (!WalkthroughPage.Within(stated, lines))
+            problems.Add($"the page states '{string.Join(" / ", stated)}' for '{fragment}', which {what} does not hold: {string.Join(" | ", lines)}");
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Samples/Generators/AddCreateSamples.cs b/test/CodoMetis.TypeKit.Samples/Generators/AddCreateSamples.cs
new file mode 100644
index 00000000..a40a6257
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Samples/Generators/AddCreateSamples.cs
@@ -0,0 +1,30 @@
+using CodoMetis.TypeKit;
+using CodoMetis.TypeKit.Testing;
+using CodoMetis.TypeKit.ValueObjects;
+
+namespace ReadmeSamples.Generators.AddCreate;
+
+// sample: CodoMetis.TypeKit.Generators/add-create
+public enum NameFault { Blank, TooLong }
+
+public readonly partial record struct Name : IValidatedValue<Name, string, NameFault>
+{
+    public static Result<Name, NameFault> Create(string value)
+    {
+        // Add your rules: if (...) return Result.Error(NameFault.Blank);
+        return new Name(value);
+    }
+}
+// end sample
+
+/// <summary>What the fix writes is generated as any hand-written <c>Create</c> is: every factory runs it.</summary>
+public sealed class AddCreateTests
+{
+    [Fact]
+    public void The_written_Create_accepts_every_value_and_the_factories_run_it()
+    {
+        Name.Create("").ShouldBeSuccess().Value.ShouldBe("");
+        Name.TryFrom("Ada").ShouldBeSome().Value.ShouldBe("Ada");
+        Name.FromKnownGood("Ada").Value.ShouldBe("Ada");
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Samples/Root/IntroSamples.cs b/test/CodoMetis.TypeKit.Samples/Root/IntroSamples.cs
index 7b5b15af..d5f1fdd5 100644
--- a/test/CodoMetis.TypeKit.Samples/Root/IntroSamples.cs
+++ b/test/CodoMetis.TypeKit.Samples/Root/IntroSamples.cs
@@ -8,7 +8,9 @@ public enum EmailFault { NoAt }
 
 // sample: README/intro
 public readonly partial record struct OrderId : IValue<Guid>;
+// end sample
 
+// sample: README/intro-validated
 public readonly partial record struct Email : IValidatedValue<Email, string, EmailFault>
 {
     public static Result<Email, EmailFault> Create(string value) =>
@@ -16,6 +18,44 @@ public static Result<Email, EmailFault> Create(string value) =>
 }
 // end sample
 
+public readonly partial record struct CustomerId : IValue<Guid>;
+
+public sealed record Customer(CustomerId Id, Email Email);
+
+public enum SignUpFault { InvalidEmail, EmailTaken }
+
+public sealed class IntroUsage(List<Customer> customers)
+{
+    public string Greet(Email email)
+    {
+        // sample: README/intro-option
+        Option<Customer> found = customers.FirstOrNone(c => c.Email == email);
+
+        string greeting = found.Match(
+            customer => $"Welcome back, {customer.Email}",
+            () => "Please sign up first");
+        // end sample
+
+        return greeting;
+    }
+
+    public string SignUp(string input)
+    {
+        // sample: README/intro-result
+        Result<Customer, SignUpFault> signedUp = Email.Create(input)
+            .MapError(_ => SignUpFault.InvalidEmail)
+            .Ensure(email => !customers.Exists(c => c.Email == email), SignUpFault.EmailTaken)
+            .Map(email => new Customer(CustomerId.New(), email));
+
+        string reply = signedUp.Match(
+            customer => $"Welcome, {customer.Email}",
+            fault => $"Sign-up failed: {fault}");
+        // end sample
+
+        return reply;
+    }
+}
+
 // sample: README/closed-set
 public sealed partial class OrderStatus : IClosedSet<OrderStatus>
 {
diff --git a/test/CodoMetis.TypeKit.Samples/Root/QuickStartSamples.cs b/test/CodoMetis.TypeKit.Samples/Root/QuickStartSamples.cs
index b3b7f686..1f4d48fe 100644
--- a/test/CodoMetis.TypeKit.Samples/Root/QuickStartSamples.cs
+++ b/test/CodoMetis.TypeKit.Samples/Root/QuickStartSamples.cs
@@ -1,8 +1,5 @@
-// sample: README/quick-start-declaration
 using CodoMetis.TypeKit;
 using CodoMetis.TypeKit.ValueObjects;
-
-// end sample
 using System.Text.Json;
 using System.Text.Json.Nodes;
 using CodoMetis.TypeKit.AspNetCore;
@@ -14,7 +11,6 @@
 
 namespace ReadmeSamples.Root.QuickStart;
 
-// sample: README/quick-start-declaration
 public enum EmailFault { Blank, NoAt }
 
 public readonly partial record struct Email : IValidatedValue<Email, string, EmailFault>
@@ -27,7 +23,6 @@ public static Result<Email, EmailFault> Create(string value)
         return new Email(value.Trim());
     }
 }
-// end sample
 
 public readonly partial record struct OrderId : IValue<Guid>;
 
@@ -49,17 +44,13 @@ public static class QuickStart
 {
     public static void Use(string input)
     {
-        // sample: README/quick-start-use
+        // sample: README/factories
         var id = OrderId.New();                                   // a version 7 Guid
 
         Result<Email, EmailFault> created = Email.Create(input);  // the fault says which rule refused it
         Option<Email> maybe = Email.TryFrom(input);               // is it valid?
         Email known = Email.FromKnownGood("ops@example.com");     // a literal you vouch for; throws otherwise
 
-        string reply = created.Match(
-            email => $"Welcome, {email}",
-            fault => $"Please check the address ({fault})");
-
         JsonSerializer.Serialize(known);                          // "ops@example.com"
         JsonSerializer.Deserialize<Email>("\"nobody\"");          // JsonException naming Email and NoAt, never the text
         Email.Parse("ops@example.com", null);                     // IParsable, so it binds as a route or query parameter
@@ -68,7 +59,7 @@ public static void Use(string input)
 
     public static void UseTheSatellites(IServiceCollection services, string connectionString, ShopDb db)
     {
-        // sample: README/quick-start-satellites
+        // sample: README/setup
         services.AddDbContext<ShopDb>(options => options.UseNpgsql(connectionString).UseTypeKit());
 
         db.Customers.Where(c => c.Email.Value.EndsWith("@example.com"));        // WHERE c."Email" LIKE '%@example.com'
diff --git a/test/CodoMetis.TypeKit.Samples/Testing/TestingSamples.cs b/test/CodoMetis.TypeKit.Samples/Testing/TestingSamples.cs
index 974c5016..c4e84f1b 100644
--- a/test/CodoMetis.TypeKit.Samples/Testing/TestingSamples.cs
+++ b/test/CodoMetis.TypeKit.Samples/Testing/TestingSamples.cs
@@ -22,6 +22,18 @@ public Result<Fault<OrderFault, EditFault>> Rename(int id, int version) =>
         Fault<OrderFault, EditFault>.Of(EditFault.Stale, $"Order {id} is at version {version + 1}, not {version}.");
 }
 
+/// <summary>A service answering through tasks, for the asynchronous block.</summary>
+public sealed class Signups
+{
+    public async Task<Result<Email, EmailFault>> RegisterAsync(string address)
+    {
+        await Task.Yield();
+        return Email.Create(address);
+    }
+
+    public ValueTask<Option<Email>> FindAsync(string address) => new(Option.None<Email>());
+}
+
 public sealed partial class TestingSamples
 {
     private const string Readme = "src/CodoMetis.TypeKit.Testing/README.md";
@@ -74,6 +86,21 @@ public void A_composed_fault_hands_back_the_fault_it_holds()
         Should.Throw<TypeKitAssertionException>(() => refusal.ShouldHold(OrderFault.NotFound));
     }
 
+    /// <summary>The README's asynchronous block, run: each line awaits and passes, or this test fails with its assertion.</summary>
+    [Fact]
+    public async Task The_assertions_on_a_task_pass_as_the_README_shows()
+    {
+        var signups = new Signups();
+
+        // sample: CodoMetis.TypeKit.Testing/async
+        Email email = await signups.RegisterAsync("ops@example.com").ShouldBeSuccess();   // awaited, then asserted
+        await signups.RegisterAsync("nobody").ShouldBeError(EmailFault.NoAt);
+        await signups.FindAsync("ops@example.com").ShouldBeNone();                         // a ValueTask too
+        // end sample
+
+        email.Value.ShouldBe("ops@example.com");
+    }
+
     /// <summary>The failure message the README quotes, read from the README, is the one the assertion throws.</summary>
     [Fact]
     public void A_failure_says_what_the_README_quotes()
diff --git a/test/CodoMetis.TypeKit.Testing.Tests/AsyncAssertionTests.cs b/test/CodoMetis.TypeKit.Testing.Tests/AsyncAssertionTests.cs
new file mode 100644
index 00000000..d3f3ddef
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Testing.Tests/AsyncAssertionTests.cs
@@ -0,0 +1,244 @@
+using System.Reflection;
+
+namespace CodoMetis.TypeKit.Testing.Tests;
+
+/// <summary>
+/// Every assertion has a form on a <c>Task</c> and on a <c>ValueTask</c> of what it asserts on, which
+/// awaits it and answers as the synchronous form does: the same content back, the same message on a
+/// failure. A task that faults is the test's own failure, and its exception propagates as it is.
+/// </summary>
+public sealed class AsyncAssertionTests
+{
+    public enum Fault { NotFound, AlreadyShipped }
+
+    public enum Other { Conflict }
+
+    public enum Third { Gone }
+
+    private const string Secret = "s3cr3t-value";
+
+    private static readonly Result<string, Fault> Success = Secret;
+    private static readonly Result<string, Fault> Error = Result.Error(Fault.NotFound);
+    private static readonly Result<Fault> Done = Result.Success();
+    private static readonly Result<Fault> Refused = Result.Error(Fault.AlreadyShipped);
+    private static readonly Fault<Fault, Other> Pair = Fault<Fault, Other>.Of(Fault.NotFound);
+    private static readonly Fault<Fault, Other, Third> Triple = Fault<Fault, Other, Third>.Of(Third.Gone);
+
+    private static async Task<T> Later<T>(T value)
+    {
+        await Task.Yield();
+        return value;
+    }
+
+    private static async ValueTask<T> LaterValue<T>(T value)
+    {
+        await Task.Yield();
+        return value;
+    }
+
+    /// <summary>
+    /// Each synchronous assertion, keyed by its signature, with inputs it passes and fails on: the
+    /// synchronous call, the <c>Task</c> form's and the <c>ValueTask</c> form's over the same input.
+    /// </summary>
+    private static readonly Dictionary<string, (Func<object?> Sync, Func<Task<object?>> OnTask, Func<Task<object?>> OnValueTask)[]> Cases = new()
+    {
+        ["ShouldBeSome(Option<T>)"] =
+        [
+            (() => Option.Some(Secret).ShouldBeSome(), async () => await Later(Option.Some(Secret)).ShouldBeSome(), async () => await LaterValue(Option.Some(Secret)).ShouldBeSome()),
+            (() => Option.None<string>().ShouldBeSome(), async () => await Later(Option.None<string>()).ShouldBeSome(), async () => await LaterValue(Option.None<string>()).ShouldBeSome()),
+        ],
+        ["ShouldBeNone(Option<T>)"] =
+        [
+            (Void(() => Option.None<string>().ShouldBeNone()), Void(() => Later(Option.None<string>()).ShouldBeNone()), Void(() => LaterValue(Option.None<string>()).ShouldBeNone())),
+            (Void(() => Option.Some(Secret).ShouldBeNone()), Void(() => Later(Option.Some(Secret)).ShouldBeNone()), Void(() => LaterValue(Option.Some(Secret)).ShouldBeNone())),
+        ],
+        ["ShouldBeSuccess(Result<T, TError>)"] =
+        [
+            (() => Success.ShouldBeSuccess(), async () => await Later(Success).ShouldBeSuccess(), async () => await LaterValue(Success).ShouldBeSuccess()),
+            (() => Error.ShouldBeSuccess(), async () => await Later(Error).ShouldBeSuccess(), async () => await LaterValue(Error).ShouldBeSuccess()),
+            (() => default(Result<string, Fault>).ShouldBeSuccess(), async () => await Later(default(Result<string, Fault>)).ShouldBeSuccess(), async () => await LaterValue(default(Result<string, Fault>)).ShouldBeSuccess()),
+        ],
+        ["ShouldBeError(Result<T, TError>)"] =
+        [
+            (() => Error.ShouldBeError(), async () => await Later(Error).ShouldBeError(), async () => await LaterValue(Error).ShouldBeError()),
+            (() => Success.ShouldBeError(), async () => await Later(Success).ShouldBeError(), async () => await LaterValue(Success).ShouldBeError()),
+        ],
+        ["ShouldBeError(Result<T, TError>, TError)"] =
+        [
+            (Void(() => Error.ShouldBeError(Fault.NotFound)), Void(() => Later(Error).ShouldBeError(Fault.NotFound)), Void(() => LaterValue(Error).ShouldBeError(Fault.NotFound))),
+            (Void(() => Error.ShouldBeError(Fault.AlreadyShipped)), Void(() => Later(Error).ShouldBeError(Fault.AlreadyShipped)), Void(() => LaterValue(Error).ShouldBeError(Fault.AlreadyShipped))),
+        ],
+        ["ShouldBeSuccess(Result<TError>)"] =
+        [
+            (Void(() => Done.ShouldBeSuccess()), Void(() => Later(Done).ShouldBeSuccess()), Void(() => LaterValue(Done).ShouldBeSuccess())),
+            (Void(() => Refused.ShouldBeSuccess()), Void(() => Later(Refused).ShouldBeSuccess()), Void(() => LaterValue(Refused).ShouldBeSuccess())),
+        ],
+        ["ShouldBeError(Result<TError>)"] =
+        [
+            (() => Refused.ShouldBeError(), async () => await Later(Refused).ShouldBeError(), async () => await LaterValue(Refused).ShouldBeError()),
+            (() => Done.ShouldBeError(), async () => await Later(Done).ShouldBeError(), async () => await LaterValue(Done).ShouldBeError()),
+        ],
+        ["ShouldBeError(Result<TError>, TError)"] =
+        [
+            (Void(() => Refused.ShouldBeError(Fault.AlreadyShipped)), Void(() => Later(Refused).ShouldBeError(Fault.AlreadyShipped)), Void(() => LaterValue(Refused).ShouldBeError(Fault.AlreadyShipped))),
+            (Void(() => Refused.ShouldBeError(Fault.NotFound)), Void(() => Later(Refused).ShouldBeError(Fault.NotFound)), Void(() => LaterValue(Refused).ShouldBeError(Fault.NotFound))),
+        ],
+        ["ShouldBeValue(Patch<T>)"] =
+        [
+            (() => Patch.Value(Secret).ShouldBeValue(), async () => await Later(Patch.Value(Secret)).ShouldBeValue(), async () => await LaterValue(Patch.Value(Secret)).ShouldBeValue()),
+            (() => Patch.Null<string>().ShouldBeValue(), async () => await Later(Patch.Null<string>()).ShouldBeValue(), async () => await LaterValue(Patch.Null<string>()).ShouldBeValue()),
+        ],
+        ["ShouldBeNull(Patch<T>)"] =
+        [
+            (Void(() => Patch.Null<string>().ShouldBeNull()), Void(() => Later(Patch.Null<string>()).ShouldBeNull()), Void(() => LaterValue(Patch.Null<string>()).ShouldBeNull())),
+            (Void(() => Patch.Value(Secret).ShouldBeNull()), Void(() => Later(Patch.Value(Secret)).ShouldBeNull()), Void(() => LaterValue(Patch.Value(Secret)).ShouldBeNull())),
+        ],
+        ["ShouldBeAbsent(Patch<T>)"] =
+        [
+            (Void(() => Patch.Absent<string>().ShouldBeAbsent()), Void(() => Later(Patch.Absent<string>()).ShouldBeAbsent()), Void(() => LaterValue(Patch.Absent<string>()).ShouldBeAbsent())),
+            (Void(() => Patch.Null<string>().ShouldBeAbsent()), Void(() => Later(Patch.Null<string>()).ShouldBeAbsent()), Void(() => LaterValue(Patch.Null<string>()).ShouldBeAbsent())),
+        ],
+        ["ShouldHold(Fault<T1, T2>, T1)"] =
+        [
+            (() => Pair.ShouldHold(Fault.NotFound), async () => await Later(Pair).ShouldHold(Fault.NotFound), async () => await LaterValue(Pair).ShouldHold(Fault.NotFound)),
+            (() => Pair.ShouldHold(Fault.AlreadyShipped), async () => await Later(Pair).ShouldHold(Fault.AlreadyShipped), async () => await LaterValue(Pair).ShouldHold(Fault.AlreadyShipped)),
+        ],
+        ["ShouldHold(Fault<T1, T2>, T2)"] =
+        [
+            (() => Pair.ShouldHold(Other.Conflict), async () => await Later(Pair).ShouldHold(Other.Conflict), async () => await LaterValue(Pair).ShouldHold(Other.Conflict)),
+        ],
+        ["ShouldHold(Fault<T1, T2, T3>, T1)"] =
+        [
+            (() => Triple.ShouldHold(Fault.NotFound), async () => await Later(Triple).ShouldHold(Fault.NotFound), async () => await LaterValue(Triple).ShouldHold(Fault.NotFound)),
+        ],
+        ["ShouldHold(Fault<T1, T2, T3>, T2)"] =
+        [
+            (() => Triple.ShouldHold(Other.Conflict), async () => await Later(Triple).ShouldHold(Other.Conflict), async () => await LaterValue(Triple).ShouldHold(Other.Conflict)),
+        ],
+        ["ShouldHold(Fault<T1, T2, T3>, T3)"] =
+        [
+            (() => Triple.ShouldHold(Third.Gone), async () => await Later(Triple).ShouldHold(Third.Gone), async () => await LaterValue(Triple).ShouldHold(Third.Gone)),
+        ],
+    };
+
+    public static TheoryData<string> CaseNames => [.. Cases.Keys];
+
+    [Theory]
+    [MemberData(nameof(CaseNames))]
+    public async Task Each_form_answers_as_the_synchronous_assertion_does(string assertion)
+    {
+        foreach (var (sync, onTask, onValueTask) in Cases[assertion])
+        {
+            var expected = Outcome(sync);
+
+            (await OutcomeAsync(onTask)).ShouldBe(expected, $"{assertion} on a Task");
+            (await OutcomeAsync(onValueTask)).ShouldBe(expected, $"{assertion} on a ValueTask");
+        }
+    }
+
+    /// <summary>A task that faults failed the code under test, not the assertion: its exception comes out as it was thrown.</summary>
+    [Fact]
+    public async Task A_faulted_task_s_exception_propagates_as_it_is()
+    {
+        var thrown = new InvalidOperationException("the store is down");
+
+        async Task<Result<string, Fault>> Faults() { await Task.Yield(); throw thrown; }
+        async ValueTask<Option<string>> FaultsValue() { await Task.Yield(); throw thrown; }
+
+        (await Should.ThrowAsync<InvalidOperationException>(() => Faults().ShouldBeSuccess())).ShouldBeSameAs(thrown);
+        (await Should.ThrowAsync<InvalidOperationException>(() => Faults().ShouldBeError(Fault.NotFound))).ShouldBeSameAs(thrown);
+        (await Should.ThrowAsync<InvalidOperationException>(async () => await FaultsValue().ShouldBeSome())).ShouldBeSameAs(thrown);
+
+        var cancelled = Task.FromCanceled<Option<string>>(new CancellationToken(canceled: true));
+        await Should.ThrowAsync<TaskCanceledException>(() => cancelled.ShouldBeNone());
+    }
+
+    [Fact]
+    public async Task A_null_task_is_refused_by_name()
+    {
+        (await Should.ThrowAsync<ArgumentNullException>(() => ((Task<Option<string>>)null!).ShouldBeSome())).ParamName.ShouldBe("option");
+        (await Should.ThrowAsync<ArgumentNullException>(() => ((Task<Result<string, Fault>>)null!).ShouldBeSuccess())).ParamName.ShouldBe("result");
+        (await Should.ThrowAsync<ArgumentNullException>(() => ((Task<Patch<string>>)null!).ShouldBeAbsent())).ParamName.ShouldBe("patch");
+        (await Should.ThrowAsync<ArgumentNullException>(() => ((Task<Fault<Fault, Other>>)null!).ShouldHold(Other.Conflict))).ParamName.ShouldBe("fault");
+    }
+
+    /// <summary>
+    /// Every public assertion on a value has a case here, a form on a <c>Task</c> and one on a
+    /// <c>ValueTask</c> of the value, with its other parameters, and nothing else is public.
+    /// </summary>
+    [Fact]
+    public void Every_assertion_has_a_Task_and_a_ValueTask_form()
+    {
+        var methods = (from type in typeof(TypeKitAssertionException).Assembly.GetExportedTypes()
+                       from method in type.GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly)
+                       select method).ToList();
+
+        var synchronous = methods.Where(method => Pending(method.GetParameters()[0].ParameterType) is null).ToList();
+        var keys = synchronous.Select(Key).ToList();
+
+        keys.Count.ShouldBe(16);
+        keys.Except(Cases.Keys).ShouldBeEmpty("These assertions have no case here.");
+        Cases.Keys.Except(keys).ShouldBeEmpty("These cases name no assertion.");
+
+        foreach (var wrapper in new[] { typeof(Task<>), typeof(ValueTask<>) })
+        {
+            var forms = methods.Where(method => Pending(method.GetParameters()[0].ParameterType) == wrapper).ToList();
+            forms.Select(form => Key(form)).Order(StringComparer.Ordinal).ShouldBe(keys.Order(StringComparer.Ordinal), $"each assertion has one form on a {wrapper.Name}");
+
+            foreach (var form in forms)
+            {
+                var twin = synchronous.Single(method => Key(method) == Key(form));
+                form.DeclaringType.ShouldBe(twin.DeclaringType, $"{Key(form)} sits beside its synchronous form");
+                Describe(form.ReturnType).ShouldBe(twin.ReturnType == typeof(void) ? "Task" : $"Task<{Describe(twin.ReturnType)}>", Key(form));
+            }
+        }
+    }
+
+    private static Type? Pending(Type type) =>
+        type.IsGenericType && (type.GetGenericTypeDefinition() == typeof(Task<>) || type.GetGenericTypeDefinition() == typeof(ValueTask<>))
+            ? type.GetGenericTypeDefinition()
+            : null;
+
+    private static string Key(MethodInfo method) =>
+        $"{method.Name}({string.Join(", ", method.GetParameters().Select(p => Describe(Pending(p.ParameterType) is null || p.Position > 0 ? p.ParameterType : p.ParameterType.GetGenericArguments()[0])))})";
+
+    private static string Describe(Type type) =>
+        type.IsGenericType ? $"{type.Name[..type.Name.IndexOf('`')]}<{string.Join(", ", type.GetGenericArguments().Select(Describe))}>" : type.Name;
+
+    private static string Outcome(Func<object?> call)
+    {
+        try
+        {
+            return $"passes: {Show(call())}";
+        }
+        catch (TypeKitAssertionException failure)
+        {
+            return $"fails: {failure.Message}";
+        }
+    }
+
+    private static async Task<string> OutcomeAsync(Func<Task<object?>> call)
+    {
+        try
+        {
+            return $"passes: {Show(await call())}";
+        }
+        catch (TypeKitAssertionException failure)
+        {
+            return $"fails: {failure.Message}";
+        }
+    }
+
+    private static string Show(object? value) => value switch
+    {
+        null => "nothing",
+        Fault<Fault> held => $"{held.Reason} {held.Detail}",
+        Fault<Other> held => $"{held.Reason} {held.Detail}",
+        Fault<Third> held => $"{held.Reason} {held.Detail}",
+        _ => value.ToString()!,
+    };
+
+    private static Func<object?> Void(Action call) => () => { call(); return null; };
+
+    private static Func<Task<object?>> Void(Func<Task> call) => async () => { await call(); return null; };
+}
diff --git a/test/CodoMetis.TypeKit.Tests/AsyncStreamTests.cs b/test/CodoMetis.TypeKit.Tests/AsyncStreamTests.cs
new file mode 100644
index 00000000..148e4f8d
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Tests/AsyncStreamTests.cs
@@ -0,0 +1,445 @@
+namespace CodoMetis.TypeKit.Tests;
+
+/// <summary>
+/// <c>Choose</c>, <c>SequenceAsync</c> and <c>TraverseAsync</c> over an <see cref="IAsyncEnumerable{T}"/>:
+/// in order, the caller's token reaching the stream's enumerator, nothing read after the first error,
+/// and the enumerator disposed however the reading ends.
+/// </summary>
+/// <remarks>
+/// Every case runs over a stream whose elements arrive at once and over one whose elements each wait,
+/// since an async iterator that never waits completes every step synchronously and hides a step that
+/// resumes in the wrong place.
+/// </remarks>
+public sealed class AsyncStreamTests
+{
+    public static TheoryData<bool> Waits => [false, true];
+
+    private static Option<int> Even(int n) => n % 2 == 0 ? Option.Some(n) : Option.None();
+
+    private static Result<int, string> Ok(int value) => Result<int, string>.Success(value);
+
+    private static Result<int, string> Fail(string error) => Result<int, string>.Error(error);
+
+    [Theory]
+    [MemberData(nameof(Waits))]
+    public async Task Choose_keeps_the_values_of_the_options_that_hold_one_in_order(bool waits)
+    {
+        var options = new TrackedStream<Option<int>>(waits, Option.Some(1), Option.None(), Option.Some(3), default, Option.Some(5));
+
+        (await options.Choose().ToListAsync(TestContext.Current.CancellationToken)).ShouldBe([1, 3, 5]);
+        (await new TrackedStream<Option<int>>(waits).Choose().ToListAsync(TestContext.Current.CancellationToken)).ShouldBeEmpty();
+        options.Disposed.ShouldBeTrue();
+    }
+
+    /// <summary>A <c>default</c> option is <c>None</c>, so a stream holding one answers what the same sequence does.</summary>
+    [Theory]
+    [MemberData(nameof(Waits))]
+    public async Task Choose_over_a_stream_answers_what_it_answers_over_the_same_sequence(bool waits)
+    {
+        Option<int>[] options = [default, Option.Some(2), Option.None(), default, Option.Some(4)];
+        int[] numbers = [1, 2, 3, 4, 5, 6];
+
+        (await new TrackedStream<Option<int>>(waits, options).Choose().ToListAsync(TestContext.Current.CancellationToken)).ShouldBe(options.Choose().ToList());
+        (await new TrackedStream<int>(waits, numbers).Choose(Even).ToListAsync(TestContext.Current.CancellationToken)).ShouldBe(numbers.Choose(Even).ToList());
+    }
+
+    [Theory]
+    [MemberData(nameof(Waits))]
+    public async Task Choose_with_a_selector_keeps_what_it_answers_Some_for_and_reads_null_elements(bool waits)
+    {
+        (await new TrackedStream<int>(waits, 1, 2, 3, 4, 5, 6).Choose(Even).ToListAsync(TestContext.Current.CancellationToken)).ShouldBe([2, 4, 6]);
+        (await new TrackedStream<string?>(waits, "Annie", null, "Bo").Choose(nickname => nickname.ToOption()).ToListAsync(TestContext.Current.CancellationToken)).ShouldBe(["Annie", "Bo"]);
+        (await new TrackedStream<int?>(waits, 3, null, 5).Choose(floor => floor.ToOption()).ToListAsync(TestContext.Current.CancellationToken)).ShouldBe([3, 5]);
+    }
+
+    /// <summary>An async LINQ operator reads its source when it is enumerated, not when it is called, and only as far as the caller reads.</summary>
+    [Theory]
+    [MemberData(nameof(Waits))]
+    public async Task Choose_is_lazy_and_disposes_the_stream_when_the_caller_stops(bool waits)
+    {
+        var numbers = new TrackedStream<int>(waits, 1, 2, 3, 4, 5, 6);
+
+        var chosen = numbers.Choose(Even);
+        numbers.Enumerations.ShouldBe(0, "nothing is read until the result is enumerated");
+
+        await foreach (var value in chosen)
+        {
+            value.ShouldBe(2);
+            break;
+        }
+
+        numbers.Read.ShouldBe(2, "the stream is read only as far as the first value found");
+        numbers.Disposed.ShouldBeTrue("a break disposes the stream's enumerator");
+    }
+
+    /// <summary>The arguments are checked when the call is made, as LINQ's are, not when the stream is first read.</summary>
+    [Fact]
+    public void Choose_checks_its_arguments_before_the_stream_is_read()
+    {
+        Should.Throw<ArgumentNullException>(() => ((IAsyncEnumerable<int>)null!).Choose(Even)).ParamName.ShouldBe("source");
+        Should.Throw<ArgumentNullException>(() => ((IAsyncEnumerable<Option<int>>)null!).Choose()).ParamName.ShouldBe("options");
+        Should.Throw<ArgumentNullException>(() => new TrackedStream<int>(false, 1).Choose((Func<int, Option<int>>)null!)).ParamName.ShouldBe("selector");
+    }
+
+    [Theory]
+    [MemberData(nameof(Waits))]
+    public async Task Choose_hands_the_token_of_WithCancellation_and_of_GetAsyncEnumerator_to_the_stream(bool waits)
+    {
+        using var cancellation = new CancellationTokenSource();
+        var numbers = new TrackedStream<int>(waits, 1, 2);
+        var options = new TrackedStream<Option<int>>(waits, Option.Some(1));
+
+        await foreach (var _ in numbers.Choose(Even).WithCancellation(cancellation.Token)) { }
+        numbers.Token.ShouldBe(cancellation.Token);
+
+        await foreach (var _ in options.Choose().WithCancellation(cancellation.Token)) { }
+        options.Token.ShouldBe(cancellation.Token);
+
+        var held = new TrackedStream<int>(waits, 1, 2, 3, 4);
+        await using (var enumerator = held.Choose(Even).GetAsyncEnumerator(cancellation.Token))
+        {
+            (await enumerator.MoveNextAsync()).ShouldBeTrue();
+            held.Disposed.ShouldBeFalse();
+        }
+
+        held.Token.ShouldBe(cancellation.Token);
+        held.Disposed.ShouldBeTrue("disposing the chosen values disposes the stream's enumerator");
+    }
+
+    /// <summary>A stream that honours its token stops the chosen values when the caller cancels.</summary>
+    [Theory]
+    [MemberData(nameof(Waits))]
+    public async Task Choose_stops_when_the_caller_cancels_a_stream_that_honours_its_token(bool waits)
+    {
+        using var cancellation = new CancellationTokenSource();
+        var numbers = new TrackedStream<int>(waits, 2, 4, 6) { OnRead = n => { if (n == 4) cancellation.Cancel(); }, HonoursToken = true };
+        var seen = new List<int>();
+
+        await Should.ThrowAsync<OperationCanceledException>(async () =>
+        {
+            await foreach (var value in numbers.Choose(Even).WithCancellation(cancellation.Token)) seen.Add(value);
+        });
+
+        seen.ShouldBe([2, 4]);
+        numbers.Disposed.ShouldBeTrue();
+    }
+
+    [Theory]
+    [MemberData(nameof(Waits))]
+    public async Task Choose_disposes_the_stream_when_the_selector_throws(bool waits)
+    {
+        var numbers = new TrackedStream<int>(waits, 1, 2, 3);
+
+        await Should.ThrowAsync<FormatException>(() => numbers.Choose(n => n == 2 ? throw new FormatException() : Option.Some(n)).ToListAsync(TestContext.Current.CancellationToken).AsTask());
+
+        numbers.Read.ShouldBe(2);
+        numbers.Disposed.ShouldBeTrue();
+    }
+
+    [Theory]
+    [MemberData(nameof(Waits))]
+    public async Task SequenceAsync_collects_every_value_in_order(bool waits)
+    {
+        var values = await new TrackedStream<Result<int, string>>(waits, Ok(1), Ok(2), Ok(3)).SequenceAsync(TestContext.Current.CancellationToken);
+        values.Match(list => list, _ => []).ShouldBe([1, 2, 3]);
+
+        var none = await new TrackedStream<Result<int, string>>(waits).SequenceAsync(TestContext.Current.CancellationToken);
+        none.Match(list => list.Count, _ => -1).ShouldBe(0);
+
+        ((bool)await new TrackedStream<Result<string>>(waits, Result<string>.Success(), Result<string>.Success()).SequenceAsync(TestContext.Current.CancellationToken)).ShouldBeTrue();
+        ((bool)await new TrackedStream<Result<string>>(waits).SequenceAsync(TestContext.Current.CancellationToken)).ShouldBeTrue();
+    }
+
+    [Theory]
+    [MemberData(nameof(Waits))]
+    public async Task SequenceAsync_answers_the_first_error_reads_nothing_after_it_and_disposes_the_stream(bool waits)
+    {
+        var results = new TrackedStream<Result<int, string>>(waits, Ok(1), Fail("x"), Fail("y"), Ok(4));
+
+        (await results.SequenceAsync(TestContext.Current.CancellationToken)).Match(_ => "", error => error).ShouldBe("x");
+        results.Read.ShouldBe(2);
+        results.Disposed.ShouldBeTrue();
+
+        var commands = new TrackedStream<Result<string>>(waits, Result<string>.Success(), Result<string>.Error("refused"), default);
+
+        (await commands.SequenceAsync(TestContext.Current.CancellationToken)).TryGetError(out var refused).ShouldBeTrue();
+        refused.ShouldBe("refused");
+        commands.Read.ShouldBe(2, "the uninitialized result after the error is never read");
+        commands.Disposed.ShouldBeTrue();
+    }
+
+    [Theory]
+    [MemberData(nameof(Waits))]
+    public async Task SequenceAsync_refuses_an_uninitialized_result_and_disposes_the_stream(bool waits)
+    {
+        var results = new TrackedStream<Result<int, string>>(waits, Ok(1), default, Ok(3));
+        var commands = new TrackedStream<Result<string>>(waits, Result<string>.Success(), default);
+
+        (await Should.ThrowAsync<InvalidOperationException>(() => results.SequenceAsync())).Message.ShouldContain("never initialized");
+        (await Should.ThrowAsync<InvalidOperationException>(() => commands.SequenceAsync())).Message.ShouldContain("never initialized");
+        results.Disposed.ShouldBeTrue();
+        commands.Disposed.ShouldBeTrue();
+    }
+
+    /// <summary>
+    /// The token reaches the stream's enumerator and is checked before each result is read, so a stream
+    /// that ignores its token still stops: the cancellation propagates rather than becoming an error.
+    /// </summary>
+    [Theory]
+    [MemberData(nameof(Waits))]
+    public async Task SequenceAsync_hands_the_token_to_the_stream_and_stops_once_cancelled(bool waits)
+    {
+        using var cancellation = new CancellationTokenSource();
+        var results = new TrackedStream<Result<int, string>>(waits, Ok(1), Ok(2), Ok(3)) { OnRead = r => { if (r == Ok(2)) cancellation.Cancel(); } };
+
+        await Should.ThrowAsync<OperationCanceledException>(() => results.SequenceAsync(cancellation.Token));
+        results.Token.ShouldBe(cancellation.Token);
+        results.Read.ShouldBe(2, "nothing is read after the token was cancelled");
+        results.Disposed.ShouldBeTrue();
+
+        using var commandCancellation = new CancellationTokenSource();
+        var commands = new TrackedStream<Result<string>>(waits, Result<string>.Success(), Result<string>.Success(), Result<string>.Success());
+        commands.OnRead = _ => { if (commands.Read == 2) commandCancellation.Cancel(); };
+
+        await Should.ThrowAsync<OperationCanceledException>(() => commands.SequenceAsync(commandCancellation.Token));
+        commands.Token.ShouldBe(commandCancellation.Token);
+        commands.Read.ShouldBe(2);
+        commands.Disposed.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task SequenceAsync_with_a_cancelled_token_reads_nothing()
+    {
+        var results = new TrackedStream<Result<int, string>>(false, Ok(1));
+        var commands = new TrackedStream<Result<string>>(false, Result<string>.Success());
+
+        await Should.ThrowAsync<OperationCanceledException>(() => results.SequenceAsync(new CancellationToken(canceled: true)));
+        await Should.ThrowAsync<OperationCanceledException>(() => commands.SequenceAsync(new CancellationToken(canceled: true)));
+        results.Read.ShouldBe(0);
+        commands.Read.ShouldBe(0);
+    }
+
+    [Theory]
+    [MemberData(nameof(Waits))]
+    public async Task TraverseAsync_awaits_each_operation_in_order_and_collects_the_values(bool waits)
+    {
+        var order = new List<string>();
+        var texts = new TrackedStream<string>(waits, "1", "2", "3") { OnRead = text => order.Add($"read {text}") };
+
+        async Task<Result<int, string>> Parse(string text)
+        {
+            order.Add($"start {text}");
+            await Task.Yield();
+            order.Add($"end {text}");
+            return int.TryParse(text, out var n) ? Ok(n) : Fail(text);
+        }
+
+        var parsed = await texts.TraverseAsync(Parse);
+
+        parsed.Match(values => values, _ => []).ShouldBe([1, 2, 3]);
+        order.ShouldBe(["read 1", "start 1", "end 1", "read 2", "start 2", "end 2", "read 3", "start 3", "end 3"], "one element at a time, its operation finished before the next is read");
+        texts.Disposed.ShouldBeTrue();
+    }
+
+    [Theory]
+    [MemberData(nameof(Waits))]
+    public async Task TraverseAsync_stops_reading_after_an_error_and_disposes_the_stream(bool waits)
+    {
+        var started = new List<string>();
+        var texts = new TrackedStream<string>(waits, "1", "x", "y", "4");
+
+        Task<Result<int, string>> Parse(string text)
+        {
+            started.Add(text);
+            return Task.FromResult(int.TryParse(text, out var n) ? Ok(n) : Fail(text));
+        }
+
+        (await texts.TraverseAsync(Parse)).Match(_ => "", error => error).ShouldBe("x");
+        started.ShouldBe(["1", "x"]);
+        texts.Read.ShouldBe(2);
+        texts.Disposed.ShouldBeTrue();
+
+        var sent = new List<int>();
+        var numbers = new TrackedStream<int>(waits, 1, 2, 3, 4);
+
+        Task<Result<string>> Send(int n)
+        {
+            if (n == 3) return Task.FromResult(Result<string>.Error($"refused {n}"));
+
+            sent.Add(n);
+            return Task.FromResult(Result<string>.Success());
+        }
+
+        (await numbers.TraverseAsync(Send)).TryGetError(out var error).ShouldBeTrue();
+        error.ShouldBe("refused 3");
+        sent.ShouldBe([1, 2]);
+        numbers.Read.ShouldBe(3);
+        numbers.Disposed.ShouldBeTrue();
+
+        ((bool)await new TrackedStream<int>(waits, 1, 2).TraverseAsync(Send)).ShouldBeTrue();
+        ((bool)await new TrackedStream<int>(waits).TraverseAsync(Send)).ShouldBeTrue();
+        (await new TrackedStream<string>(waits).TraverseAsync(Parse)).Match(list => list.Count, _ => -1).ShouldBe(0);
+    }
+
+    [Theory]
+    [MemberData(nameof(Waits))]
+    public async Task TraverseAsync_disposes_the_stream_when_the_selector_throws(bool waits)
+    {
+        var numbers = new TrackedStream<int>(waits, 1, 2, 3);
+        var commands = new TrackedStream<int>(waits, 1, 2, 3);
+
+        await Should.ThrowAsync<FormatException>(() => numbers.TraverseAsync(n => n == 2 ? throw new FormatException() : Task.FromResult(Ok(n))));
+        await Should.ThrowAsync<FormatException>(() => commands.TraverseAsync((n, _) => n == 2 ? throw new FormatException() : Task.FromResult(Result<string>.Success()), CancellationToken.None));
+
+        numbers.Read.ShouldBe(2);
+        numbers.Disposed.ShouldBeTrue();
+        commands.Read.ShouldBe(2);
+        commands.Disposed.ShouldBeTrue();
+    }
+
+    /// <summary>
+    /// The token is handed to the stream and to each operation, and checked before each element is read
+    /// and before each operation: once cancelled, nothing more is read or started, and the cancellation
+    /// propagates rather than becoming an error.
+    /// </summary>
+    [Theory]
+    [MemberData(nameof(Waits))]
+    public async Task TraverseAsync_hands_the_token_on_and_stops_once_cancelled(bool waits)
+    {
+        using var cancellation = new CancellationTokenSource();
+        var numbers = new TrackedStream<int>(waits, 1, 2, 3);
+        var started = new List<int>();
+
+        Task<Result<int, string>> Load(int n, CancellationToken token)
+        {
+            token.ShouldBe(cancellation.Token, "the operation receives the caller's token");
+            started.Add(n);
+            if (n == 2) cancellation.Cancel();
+            return Task.FromResult(Ok(n));
+        }
+
+        await Should.ThrowAsync<OperationCanceledException>(() => numbers.TraverseAsync(Load, cancellation.Token));
+        numbers.Token.ShouldBe(cancellation.Token, "the stream's enumerator receives the caller's token");
+        started.ShouldBe([1, 2]);
+        numbers.Read.ShouldBe(2, "the third element is not read after the token was cancelled");
+        numbers.Disposed.ShouldBeTrue();
+
+        using var commandCancellation = new CancellationTokenSource();
+        var commands = new TrackedStream<int>(waits, 1, 2, 3) { OnRead = n => { if (n == 2) commandCancellation.Cancel(); } };
+        started.Clear();
+
+        Task<Result<string>> Send(int n, CancellationToken token)
+        {
+            token.ShouldBe(commandCancellation.Token);
+            started.Add(n);
+            return Task.FromResult(Result<string>.Success());
+        }
+
+        await Should.ThrowAsync<OperationCanceledException>(() => commands.TraverseAsync(Send, commandCancellation.Token));
+        commands.Token.ShouldBe(commandCancellation.Token);
+        started.ShouldBe([1], "the command for an element read after the token was cancelled is not started");
+        commands.Disposed.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task TraverseAsync_with_a_cancelled_token_reads_and_starts_nothing()
+    {
+        var numbers = new TrackedStream<int>(false, 1);
+        var started = 0;
+
+        await Should.ThrowAsync<OperationCanceledException>(() => numbers.TraverseAsync((n, _) => { started++; return Task.FromResult(Ok(n)); }, new CancellationToken(canceled: true)));
+        await Should.ThrowAsync<OperationCanceledException>(() => numbers.TraverseAsync((_, _) => { started++; return Task.FromResult(Result<string>.Success()); }, new CancellationToken(canceled: true)));
+
+        started.ShouldBe(0);
+        numbers.Read.ShouldBe(0);
+    }
+
+    [Theory]
+    [MemberData(nameof(Waits))]
+    public async Task TraverseAsync_with_a_token_that_is_not_cancelled_runs_every_operation(bool waits)
+    {
+        var values = await new TrackedStream<int>(waits, 1, 2).TraverseAsync((n, _) => Task.FromResult(Ok(n * 10)), CancellationToken.None);
+        values.Match(list => list, _ => []).ShouldBe([10, 20]);
+
+        var command = await new TrackedStream<int>(waits, 1, 2).TraverseAsync((_, _) => Task.FromResult(Result<string>.Success()), CancellationToken.None);
+        ((bool)command).ShouldBeTrue();
+
+        var refused = new TrackedStream<int>(waits, 1, 2, 3);
+        (await refused.TraverseAsync((n, _) => Task.FromResult(n == 2 ? Fail("two") : Ok(n)), CancellationToken.None)).Match(_ => "", error => error).ShouldBe("two");
+        refused.Read.ShouldBe(2);
+        refused.Disposed.ShouldBeTrue();
+    }
+
+    /// <summary>The calls in a consumer's compilation, nullable annotations on, beside <c>System.Linq.AsyncEnumerable</c>'s operators: no warning and no ambiguity.</summary>
+    [Theory]
+    [InlineData("IAsyncEnumerable<string?> nicknames", "nicknames.Choose(nickname => nickname.ToOption())")]
+    [InlineData("IAsyncEnumerable<int?> floors", "floors.Where(floor => floor > 0).Choose(floor => floor.ToOption()).Select(floor => floor * 10)")]
+    [InlineData("IAsyncEnumerable<int> numbers", "numbers.Select(n => n > 0 ? Option.Some(n) : Option.None<int>()).Choose()")]
+    [InlineData("IAsyncEnumerable<Result<int, string>> results", "results.SequenceAsync()")]
+    [InlineData("IAsyncEnumerable<Result<string>> results", "results.Where(result => true).SequenceAsync(CancellationToken.None)")]
+    [InlineData("IAsyncEnumerable<string> texts", "texts.TraverseAsync(text => Task.FromResult(Result<int, string>.Success(text.Length)))")]
+    [InlineData("IAsyncEnumerable<string> texts", "texts.TraverseAsync(async (text, token) => { await Task.Delay(1, token); return Result<string>.Success(); }, CancellationToken.None)")]
+    [InlineData("int[] numbers", "numbers.Choose(n => Option.Some(n))")]
+    [InlineData("int[] numbers", "numbers.TraverseAsync(n => Task.FromResult(Result<int, string>.Success(n)))")]
+    public void The_stream_members_compile_without_a_warning_beside_the_async_LINQ_operators(string parameter, string call) =>
+        ConsumerCompilation.Of($$"""
+            using System.Collections.Generic;
+            using System.Linq;
+            using System.Threading;
+            using System.Threading.Tasks;
+            using CodoMetis.TypeKit;
+
+            public static class Checks
+            {
+                public static object Run({{parameter}}) => {{call}};
+            }
+            """).Problems().ShouldBeEmpty();
+
+    /// <summary>
+    /// A stream that records what its enumerator was given and how far it was read, and whether it was
+    /// disposed. It ignores its token unless told to honour it, as many producers do.
+    /// </summary>
+    private sealed class TrackedStream<T>(bool waits, params T[] elements) : IAsyncEnumerable<T>
+    {
+        public CancellationToken Token { get; private set; }
+
+        public int Enumerations { get; private set; }
+
+        /// <summary>How many elements were handed out.</summary>
+        public int Read { get; private set; }
+
+        public bool Disposed { get; private set; }
+
+        public Action<T>? OnRead { get; set; }
+
+        public bool HonoursToken { get; init; }
+
+        public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            Token = cancellationToken;
+            Enumerations++;
+
+            return Enumerate(cancellationToken);
+        }
+
+        private async IAsyncEnumerator<T> Enumerate(CancellationToken cancellationToken)
+        {
+            try
+            {
+                foreach (var element in elements)
+                {
+                    if (waits) await Task.Yield();
+                    if (HonoursToken) cancellationToken.ThrowIfCancellationRequested();
+
+                    Read++;
+                    OnRead?.Invoke(element);
+                    yield return element;
+                }
+            }
+            finally
+            {
+                Disposed = true;
+            }
+        }
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Tests/AsynchronousContextTests.cs b/test/CodoMetis.TypeKit.Tests/AsynchronousContextTests.cs
index 9b2ca8bc..7a9f7ce8 100644
--- a/test/CodoMetis.TypeKit.Tests/AsynchronousContextTests.cs
+++ b/test/CodoMetis.TypeKit.Tests/AsynchronousContextTests.cs
@@ -20,7 +20,7 @@ namespace CodoMetis.TypeKit.Tests;
 /// (<c>.Result</c>, <c>.Wait()</c>, <c>GetAwaiter().GetResult()</c>) never does. A member that resumed on it
 /// would hang that caller, which is why <c>ConfigureAwait(false)</c> stays; such a post fails here at once.
 /// The cases are written by hand, and the completeness test holds them to every public member of the
-/// assembly that returns a task.
+/// assembly that returns a task or an <see cref="IAsyncEnumerable{T}"/>, whose cases read it to the end.
 /// </para>
 /// </remarks>
 public sealed class AsynchronousContextTests
@@ -72,11 +72,30 @@ public sealed class AsynchronousContextTests
         ["Result.TraverseAsync(IEnumerable<T>, Func<T, CancellationToken, Task<Result<TError>>>, CancellationToken)"] =
             p => new[] { 1, 2 }.TraverseAsync((x, _) => x == 1 ? p.First(Ok) : p.Later(p.Seen(Ok)), CancellationToken.None),
 
+        // A stream's first element is what the rest wait for, so the member's own await of the stream is
+        // the one that would resume on the caller's context; a selector runs as each element arrives.
+        ["Result.TraverseAsync(IAsyncEnumerable<T>, Func<T, Task<Result<TResult, TError>>>)"] =
+            p => p.Stream(1, 2).TraverseAsync(x => x == 1 ? p.First(Value) : p.Later(p.Seen(Value))),
+        ["Result.TraverseAsync(IAsyncEnumerable<T>, Func<T, CancellationToken, Task<Result<TResult, TError>>>, CancellationToken)"] =
+            p => p.Stream(1, 2).TraverseAsync((x, _) => x == 1 ? p.First(Value) : p.Later(p.Seen(Value)), CancellationToken.None),
+        ["Result.TraverseAsync(IAsyncEnumerable<T>, Func<T, Task<Result<TError>>>)"] =
+            p => p.Stream(1, 2).TraverseAsync(x => x == 1 ? p.First(Ok) : p.Later(p.Seen(Ok))),
+        ["Result.TraverseAsync(IAsyncEnumerable<T>, Func<T, CancellationToken, Task<Result<TError>>>, CancellationToken)"] =
+            p => p.Stream(1, 2).TraverseAsync((x, _) => x == 1 ? p.First(Ok) : p.Later(p.Seen(Ok)), CancellationToken.None),
+        ["Result.SequenceAsync(IAsyncEnumerable<Result<T, TError>>, CancellationToken)"] = p => p.Stream(Value, Value).SequenceAsync(),
+        ["Result.SequenceAsync(IAsyncEnumerable<Result<TError>>, CancellationToken)"]    = p => p.Stream(Ok, Ok).SequenceAsync(),
+        ["Option.Choose(IAsyncEnumerable<Option<T>>)"]                                   = p => Drain(p.Stream(Some, Some).Choose()),
+        ["SequenceOptionExtensions.Choose(IAsyncEnumerable<T>, Func<T, Option<TResult>>)"] = p => Drain(p.Stream(1, 2).Choose(x => p.Seen(Some))),
+
         // The delegate runs at once, on the caller's context; the task it returns is awaited without it.
         ["Result.CatchAsync<T>(Func<Task<T>>)"]             = p => Result.CatchAsync(() => p.Later(p.Seen(1))),
         ["Result.CatchAsync(Func<Task>)"]                   = p => Result.CatchAsync(() => (Task)p.Later(p.Seen(1))),
         ["Result.CatchAsync<T, TException>(Func<Task<T>>)"] = p => Result.CatchAsync<int, InvalidOperationException>(() => p.Later(p.Seen(1))),
         ["Result.CatchAsync<TException>(Func<Task>)"]       = p => Result.CatchAsync<InvalidOperationException>(() => (Task)p.Later(p.Seen(1))),
+        ["Result.CatchAsync<T>(Func<ValueTask<T>>)"]             = p => Result.CatchAsync(() => new ValueTask<int>(p.Later(p.Seen(1)))),
+        ["Result.CatchAsync(Func<ValueTask>)"]                   = p => Result.CatchAsync(() => new ValueTask(p.Later(p.Seen(1)))),
+        ["Result.CatchAsync<T, TException>(Func<ValueTask<T>>)"] = p => Result.CatchAsync<int, InvalidOperationException>(() => new ValueTask<int>(p.Later(p.Seen(1)))),
+        ["Result.CatchAsync<TException>(Func<ValueTask>)"]       = p => Result.CatchAsync<InvalidOperationException>(() => new ValueTask(p.Later(p.Seen(1)))),
 
         ["Option.MapAsync(Task<Option<T>>, Func<T, TResult>)"]               = p => p.First(Some).MapAsync(x => p.Seen(x)),
         ["Option.MapAsync(Task<Option<T>>, Func<T, Task<TResult>>)"]         = p => p.First(Some).MapAsync(x => p.Later(p.Seen(x))),
@@ -91,6 +110,12 @@ public sealed class AsynchronousContextTests
         ["Option<T>.MapAsync(Func<T, Task<TResult>>)"]          = p => Some.MapAsync(x => p.Later(p.Seen(x))),
         ["Option<T>.BindAsync(Func<T, Task<Option<TResult>>>)"] = p => Some.BindAsync(x => p.Later(p.Seen(Some))),
         ["Option<T>.TapAsync(Func<T, Task>)"]                   = p => Some.TapAsync(x => p.Later(p.Seen(x))),
+        ["Result.TraverseAsync(Option<T>, Func<T, Task<Result<TResult, TError>>>)"] = p => Some.TraverseAsync(x => p.Later(p.Seen(Value))),
+        ["Result.TraverseAsync(Option<T>, Func<T, CancellationToken, Task<Result<TResult, TError>>>, CancellationToken)"] =
+            p => Some.TraverseAsync((x, _) => p.Later(p.Seen(Value)), CancellationToken.None),
+        ["Result.TraverseAsync(Patch<T>, Func<T, Task<Result<TResult, TError>>>)"] = p => Patch.Value(1).TraverseAsync(x => p.Later(p.Seen(Value))),
+        ["Result.TraverseAsync(Patch<T>, Func<T, CancellationToken, Task<Result<TResult, TError>>>, CancellationToken)"] =
+            p => Patch.Value(1).TraverseAsync((x, _) => p.Later(p.Seen(Value)), CancellationToken.None),
 
         ["Result<TError>.TapAsync(Func<Task>)"]                          = p => Ok.TapAsync(() => p.Later(p.Seen(0))),
         ["Result<TError>.TapErrorAsync(Func<TError, Task>)"]             = p => Failed.TapErrorAsync(e => p.Later(p.Seen(e))),
@@ -107,7 +132,13 @@ public sealed class AsynchronousContextTests
     };
 
     /// <summary>Members that take no callback: only that nothing resumes on the caller's context is checked.</summary>
-    private static readonly HashSet<string> WithoutCallback = ["Option.ToResultAsync(Task<Option<T>>, TError)"];
+    private static readonly HashSet<string> WithoutCallback =
+    [
+        "Option.ToResultAsync(Task<Option<T>>, TError)",
+        "Result.SequenceAsync(IAsyncEnumerable<Result<T, TError>>, CancellationToken)",
+        "Result.SequenceAsync(IAsyncEnumerable<Result<TError>>, CancellationToken)",
+        "Option.Choose(IAsyncEnumerable<Option<T>>)",
+    ];
 
     public static TheoryData<string> CaseNames => [.. Cases.Keys];
 
@@ -163,15 +194,21 @@ await caller.Run(async () =>
     }
 
     [Fact]
-    public void Every_public_member_that_returns_a_task_has_a_case()
+    public void Every_public_member_that_returns_a_task_or_a_stream_has_a_case()
     {
         var members = AsynchronousMembers().ToList();
 
         members.Count.ShouldBeGreaterThanOrEqualTo(50);
-        members.Except(Cases.Keys).ShouldBeEmpty("These public members return a task and have no case here.");
+        members.Except(Cases.Keys).ShouldBeEmpty("These public members return a task or a stream and have no case here.");
         Cases.Keys.Except(members).ShouldBeEmpty("These cases name no public member of the assembly.");
     }
 
+    /// <summary>Reads a stream to the end without capturing the caller's context, as a member's own awaits must not.</summary>
+    private static async Task Drain<T>(IAsyncEnumerable<T> stream)
+    {
+        await foreach (var _ in stream.ConfigureAwait(false)) { }
+    }
+
     private static Task Start(Func<Probe, Task> chain, Probe probe, SynchronizationContext caller)
     {
         var previous = SynchronizationContext.Current;
@@ -192,7 +229,7 @@ private static IEnumerable<string> AsynchronousMembers()
             from type in typeof(Option<>).Assembly.GetExportedTypes()
             where !type.Name.Contains('<') && type.GetCustomAttribute<CompilerGeneratedAttribute>() is null
             from method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly)
-            where typeof(Task).IsAssignableFrom(method.ReturnType)
+            where typeof(Task).IsAssignableFrom(method.ReturnType) || method.ReturnType.IsGenericType && method.ReturnType.GetGenericTypeDefinition() == typeof(IAsyncEnumerable<>)
             where method.GetCustomAttribute<ObsoleteAttribute>() is not { IsError: true }
             select (Type: type, Method: method, Signature: $"({string.Join(", ", method.GetParameters().Select(p => Describe(p.ParameterType)))})");
 
@@ -240,6 +277,13 @@ public async Task<T> Later<T>(T value)
             return value;
         }
 
+        /// <summary>A stream whose first element is <see cref="First{T}"/>'s task, the second following it at once.</summary>
+        public async IAsyncEnumerable<T> Stream<T>(T first, T second)
+        {
+            yield return await First(first).ConfigureAwait(false);
+            yield return second;
+        }
+
         public T Seen<T>(T value)
         {
             Called = true;
diff --git a/test/CodoMetis.TypeKit.Tests/CatchAsyncValueTaskTests.cs b/test/CodoMetis.TypeKit.Tests/CatchAsyncValueTaskTests.cs
new file mode 100644
index 00000000..2704c09e
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Tests/CatchAsyncValueTaskTests.cs
@@ -0,0 +1,190 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace CodoMetis.TypeKit.Tests;
+
+/// <summary>
+/// <c>CatchAsync</c> over a call that returns a <c>ValueTask</c>: the same outcomes as the <c>Task</c>
+/// forms, and the overloads' lower priority, which keeps every <c>async</c> lambda on the <c>Task</c> form
+/// it bound to before they existed (decision 110).
+/// </summary>
+public sealed class CatchAsyncValueTaskTests
+{
+    private static readonly InvalidOperationException Boom = new("boom");
+
+    private static readonly TaskCanceledException Timeout = new("timed out", new TimeoutException());
+
+    private static async ValueTask<int> ThrowsLaterAsync()
+    {
+        await Task.Yield();
+        throw Boom;
+    }
+
+    private static async ValueTask ThrowsLaterCommandAsync()
+    {
+        await Task.Yield();
+        throw Boom;
+    }
+
+    private static async ValueTask<int> AnswersLaterAsync()
+    {
+        await Task.Yield();
+        return 7;
+    }
+
+    private static async ValueTask DoesLaterAsync() => await Task.Yield();
+
+    [Fact]
+    public async Task Every_form_answers_the_value_or_a_success()
+    {
+        (await Result.CatchAsync(AnswersLaterAsync)).Match(value => value, _ => -1).ShouldBe(7);
+        (await Result.CatchAsync(() => new ValueTask<int>(7))).Match(value => value, _ => -1).ShouldBe(7);
+        ((bool)await Result.CatchAsync(DoesLaterAsync)).ShouldBeTrue();
+        (await Result.CatchAsync<int, InvalidOperationException>(AnswersLaterAsync)).Match(value => value, _ => -1).ShouldBe(7);
+        ((bool)await Result.CatchAsync<InvalidOperationException>(DoesLaterAsync)).ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task Every_form_catches_an_exception_thrown_after_the_first_await()
+    {
+        (await Result.CatchAsync(ThrowsLaterAsync)).TryGetValue(out _, out var valued).ShouldBeFalse();
+        valued.ShouldBeSameAs(Boom);
+        (await Result.CatchAsync(ThrowsLaterCommandAsync)).TryGetError(out var command).ShouldBeTrue();
+        command.ShouldBeSameAs(Boom);
+        (await Result.CatchAsync<int, InvalidOperationException>(ThrowsLaterAsync)).TryGetValue(out _, out var narrowed).ShouldBeFalse();
+        narrowed.ShouldBeSameAs(Boom);
+        (await Result.CatchAsync<InvalidOperationException>(ThrowsLaterCommandAsync)).TryGetError(out var narrowedCommand).ShouldBeTrue();
+        narrowedCommand.ShouldBeSameAs(Boom);
+    }
+
+    [Fact]
+    public async Task Every_form_catches_an_exception_thrown_before_any_task()
+    {
+        static ValueTask<int> ThrowsForAValue() => throw Boom;
+        static ValueTask ThrowsForACommand() => throw Boom;
+
+        (await Result.CatchAsync(ThrowsForAValue)).TryGetValue(out _, out var valued).ShouldBeFalse();
+        valued.ShouldBeSameAs(Boom);
+        (await Result.CatchAsync(ThrowsForACommand)).TryGetError(out var command).ShouldBeTrue();
+        command.ShouldBeSameAs(Boom);
+        (await Result.CatchAsync<int, InvalidOperationException>(ThrowsForAValue)).TryGetValue(out _, out var narrowed).ShouldBeFalse();
+        narrowed.ShouldBeSameAs(Boom);
+        (await Result.CatchAsync<InvalidOperationException>(ThrowsForACommand)).TryGetError(out var narrowedCommand).ShouldBeTrue();
+        narrowedCommand.ShouldBeSameAs(Boom);
+    }
+
+    [Fact]
+    public async Task A_narrowed_form_lets_any_other_exception_propagate()
+    {
+        (await Should.ThrowAsync<InvalidOperationException>(() => Result.CatchAsync<int, FormatException>(ThrowsLaterAsync))).ShouldBeSameAs(Boom);
+        (await Should.ThrowAsync<InvalidOperationException>(() => Result.CatchAsync<FormatException>(ThrowsLaterCommandAsync))).ShouldBeSameAs(Boom);
+    }
+
+    [Fact]
+    public async Task A_cancellation_passes_through_every_form()
+    {
+        using var cancellation = new CancellationTokenSource();
+        await cancellation.CancelAsync();
+
+        async ValueTask<int> Read() { await Task.Delay(10, cancellation.Token); return 1; }
+        async ValueTask Write() => await Task.Delay(10, cancellation.Token);
+
+        await Should.ThrowAsync<OperationCanceledException>(() => Result.CatchAsync(Read));
+        await Should.ThrowAsync<OperationCanceledException>(() => Result.CatchAsync(Write));
+        await Should.ThrowAsync<OperationCanceledException>(() => Result.CatchAsync<int, Exception>(Read));
+        await Should.ThrowAsync<OperationCanceledException>(() => Result.CatchAsync<Exception>(Write));
+    }
+
+    /// <summary>A cancellation over a <see cref="TimeoutException"/> is how <c>HttpClient</c> reports its timeout: the error, as the <c>Task</c> forms answer it.</summary>
+    [Fact]
+    public async Task A_timeout_is_the_error_in_every_form()
+    {
+        async ValueTask<int> Read() { await Task.Yield(); throw Timeout; }
+        async ValueTask Write() { await Task.Yield(); throw Timeout; }
+
+        (await Result.CatchAsync(Read)).TryGetValue(out _, out var valued).ShouldBeFalse();
+        valued.ShouldBeSameAs(Timeout);
+        (await Result.CatchAsync(Write)).TryGetError(out var command).ShouldBeTrue();
+        command.ShouldBeSameAs(Timeout);
+        (await Result.CatchAsync<int, OperationCanceledException>(Read)).TryGetValue(out _, out var narrowed).ShouldBeFalse();
+        narrowed.ShouldBeSameAs(Timeout);
+        (await Result.CatchAsync<TaskCanceledException>(Write)).TryGetError(out var narrowedCommand).ShouldBeTrue();
+        narrowedCommand.ShouldBeSameAs(Timeout);
+    }
+
+    [Fact]
+    public async Task A_cancellation_that_Result_wraps_passes_through_every_form()
+    {
+        var cancelled = Task.FromCanceled<int>(new CancellationToken(canceled: true));
+
+        async ValueTask<int> Read() { await Task.Yield(); return cancelled.Result; }
+        async ValueTask Write() { await Task.Yield(); cancelled.Wait(); }
+
+        await Should.ThrowAsync<AggregateException>(() => Result.CatchAsync(Read));
+        await Should.ThrowAsync<AggregateException>(() => Result.CatchAsync(Write));
+        await Should.ThrowAsync<AggregateException>(() => Result.CatchAsync<int, AggregateException>(Read));
+        await Should.ThrowAsync<AggregateException>(() => Result.CatchAsync<AggregateException>(Write));
+    }
+
+    [Fact]
+    public async Task A_null_value_and_a_task_of_a_task_are_refused_rather_than_caught()
+    {
+        await Should.ThrowAsync<ArgumentNullException>(() => Result.CatchAsync(() => new ValueTask<string>((string)null!)));
+        await Should.ThrowAsync<ArgumentNullException>(() => Result.CatchAsync<string, FormatException>(() => new ValueTask<string>((string)null!)));
+
+        (await Should.ThrowAsync<ArgumentException>(() => Result.CatchAsync(() => new ValueTask<Task<int>>(Task.FromResult(1))))).Message.ShouldContain("Await the inner task");
+        await Should.ThrowAsync<ArgumentException>(() => Result.CatchAsync<ValueTask<int>, InvalidOperationException>(() => new ValueTask<ValueTask<int>>(new ValueTask<int>(1))));
+    }
+
+    /// <summary>
+    /// An <c>async</c> lambda converts to a delegate over either task type, and without the
+    /// <c>ValueTask</c> forms' lower priority every one of them was ambiguous (CS0121, decision 30). Each
+    /// call here compiles and binds to the form it names; the <c>Task</c> rows are what bound before the
+    /// <c>ValueTask</c> forms existed.
+    /// </summary>
+    [Theory]
+    [InlineData("Result.CatchAsync(async () => { await Task.Yield(); return 1; })", "Task")]
+    [InlineData("Result.CatchAsync(async () => await FetchAsync())", "Task")]
+    [InlineData("Result.CatchAsync(async () => await FetchValueAsync())", "Task")]
+    [InlineData("Result.CatchAsync(async () => { await DoAsync(); })", "Task")]
+    [InlineData("Result.CatchAsync(async () => await DoValueAsync())", "Task")]
+    [InlineData("Result.CatchAsync<int, InvalidOperationException>(async () => await FetchAsync())", "Task")]
+    [InlineData("Result.CatchAsync<InvalidOperationException>(async () => await DoAsync())", "Task")]
+    [InlineData("Result.CatchAsync<int>(() => throw new Exception())", "Task")]
+    [InlineData("Result.CatchAsync<int, InvalidOperationException>(() => throw new Exception())", "Task")]
+    [InlineData("Result.CatchAsync(() => FetchAsync())", "Task")]
+    [InlineData("Result.CatchAsync(FetchAsync)", "Task")]
+    [InlineData("Result.CatchAsync(DoAsync)", "Task")]
+    [InlineData("Result.CatchAsync(() => FetchValueAsync())", "ValueTask")]
+    [InlineData("Result.CatchAsync(FetchValueAsync)", "ValueTask")]
+    [InlineData("Result.CatchAsync(() => DoValueAsync())", "ValueTask")]
+    [InlineData("Result.CatchAsync(DoValueAsync)", "ValueTask")]
+    [InlineData("Result.CatchAsync<int, InvalidOperationException>(FetchValueAsync)", "ValueTask")]
+    [InlineData("Result.CatchAsync<InvalidOperationException>(() => DoValueAsync())", "ValueTask")]
+    public void A_call_binds_to_the_form_of_its_task_and_an_async_lambda_to_the_Task_form(string call, string task)
+    {
+        var compilation = ConsumerCompilation.Of($$"""
+            using System;
+            using System.Threading.Tasks;
+            using CodoMetis.TypeKit;
+
+            static class Consumer
+            {
+                static Task<int> FetchAsync() => Task.FromResult(1);
+                static Task DoAsync() => Task.CompletedTask;
+                static ValueTask<int> FetchValueAsync() => new(1);
+                static ValueTask DoValueAsync() => ValueTask.CompletedTask;
+                static object Call() => {{call}};
+            }
+            """);
+
+        compilation.ErrorIds().ShouldBeEmpty(compilation.Problems());
+
+        var tree = compilation.SyntaxTrees.Single();
+        var invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType<InvocationExpressionSyntax>()
+                             .Single(node => node.Expression.ToString().StartsWith("Result.CatchAsync", StringComparison.Ordinal));
+        var method = (IMethodSymbol)compilation.GetSemanticModel(tree).GetSymbolInfo(invocation, TestContext.Current.CancellationToken).Symbol!;
+
+        ((INamedTypeSymbol)method.Parameters.Single().Type).DelegateInvokeMethod!.ReturnType.Name.ShouldBe(task, call);
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Tests/ComposedFaultTests.cs b/test/CodoMetis.TypeKit.Tests/ComposedFaultTests.cs
index 8348827b..e9dac228 100644
--- a/test/CodoMetis.TypeKit.Tests/ComposedFaultTests.cs
+++ b/test/CodoMetis.TypeKit.Tests/ComposedFaultTests.cs
@@ -67,6 +67,31 @@ public void Of_names_the_type_where_a_fault_becomes_a_result()
         thirdFault.ShouldBe(Fault.Of(RemovalFault.StillReferenced));
     }
 
+    /// <summary>
+    /// A fault of several types holds the fault intact, its cause included, whether it converts or is made
+    /// by <c>Of</c>; and a cause takes no part in its equality, as in the fault's own (decision 52).
+    /// </summary>
+    [Fact]
+    public void The_cause_is_kept_and_takes_no_part_in_equality()
+    {
+        var timeout = new TimeoutException();
+
+        Fault<OrderFault, ConcurrencyFault> converted = Fault.Of(ConcurrencyFault.Stale, null, timeout);
+        var first = Fault<OrderFault, ConcurrencyFault>.Of(OrderFault.NotFound, "Order 7 is gone.", timeout);
+        var second = Fault<OrderFault, ConcurrencyFault>.Of(ConcurrencyFault.Conflict, null, timeout);
+        var third = Fault<OrderFault, ConcurrencyFault, RemovalFault>.Of(RemovalFault.StillReferenced, null, timeout);
+
+        converted.Match(f => f.Cause, f => f.Cause).ShouldBeSameAs(timeout);
+        first.Match(f => f.Cause, f => f.Cause).ShouldBeSameAs(timeout);
+        second.Match(f => f.Cause, f => f.Cause).ShouldBeSameAs(timeout);
+        third.Match(f => f.Cause, f => f.Cause, f => f.Cause).ShouldBeSameAs(timeout);
+        Fault<OrderFault, ConcurrencyFault, RemovalFault>.Of(OrderFault.NameTaken, null, timeout).Match(f => f.Cause, f => null, f => null).ShouldBeSameAs(timeout);
+        Fault<OrderFault, ConcurrencyFault, RemovalFault>.Of(ConcurrencyFault.Stale, null, timeout).Match(f => null, f => f.Cause, f => null).ShouldBeSameAs(timeout);
+        first.ShouldBe(Fault<OrderFault, ConcurrencyFault>.Of(OrderFault.NotFound, "Order 7 is gone."));
+        first.GetHashCode().ShouldBe(Fault<OrderFault, ConcurrencyFault>.Of(OrderFault.NotFound, "Order 7 is gone.").GetHashCode());
+        first.ToString().ShouldBe(Fault<OrderFault, ConcurrencyFault>.Of(OrderFault.NotFound, "Order 7 is gone.").ToString());
+    }
+
     [Fact]
     public void Two_faults_are_equal_when_they_hold_the_same_type_s_equal_fault()
     {
diff --git a/test/CodoMetis.TypeKit.Tests/FaultTests.cs b/test/CodoMetis.TypeKit.Tests/FaultTests.cs
index e13485b2..cc192cd9 100644
--- a/test/CodoMetis.TypeKit.Tests/FaultTests.cs
+++ b/test/CodoMetis.TypeKit.Tests/FaultTests.cs
@@ -104,6 +104,77 @@ public void Two_faults_are_equal_by_reason_and_detail()
         Fault.Of(OrderFault.NotFound, "Order 7 is gone.").Reason.ShouldBe(OrderFault.NotFound);
     }
 
+    /// <summary>A cause is kept for the log beside the reason and the detail (decision 52).</summary>
+    [Fact]
+    public void A_fault_keeps_the_exception_that_caused_it()
+    {
+        var timeout = new TimeoutException("db-host-7 timed out");
+
+        var fault = Fault.Of(OrderFault.NotFound, "Order 7 could not be read.", timeout);
+
+        fault.Cause.ShouldBeSameAs(timeout);
+        fault.Reason.ShouldBe(OrderFault.NotFound);
+        fault.Detail.ShouldBe("Order 7 could not be read.");
+        Fault.Of(OrderFault.NotFound, null, timeout).Detail.ShouldBeNull();
+        new Fault<OrderFault>(OrderFault.NotFound, null, timeout).Cause.ShouldBeSameAs(timeout);
+        Fault.Of(OrderFault.NotFound, "Order 7 is gone.").Cause.ShouldBeNull();
+    }
+
+    /// <summary>The pattern the docs show: a caught exception mapped to a fault keeps the exception as its cause.</summary>
+    [Fact]
+    public void MapError_from_a_caught_exception_keeps_it_as_the_cause()
+    {
+        var thrown = new InvalidOperationException("the file is locked");
+
+        var mapped = Result.Catch(() => Read(thrown))
+            .MapError(e => Fault.Of(OrderFault.NotFound, "The order could not be read.", e));
+
+        mapped.TryGetValue(out _, out var fault).ShouldBeFalse();
+        fault.Cause.ShouldBeSameAs(thrown);
+
+        static int Read(Exception thrown) => throw thrown;
+    }
+
+    /// <summary>
+    /// The cause is for the log: a fault with one equals the same fault without one and hashes alike, so a
+    /// test that compares faults, or a set of them, is unchanged by where the fault came from; and it
+    /// prints as 2.2 printed it, since assertion messages quote it.
+    /// </summary>
+    [Fact]
+    public void A_cause_takes_no_part_in_equality_or_printing()
+    {
+        var caused = Fault.Of(OrderFault.NotFound, "Order 7 is gone.", new TimeoutException("db-host-7"));
+        var plain = Fault.Of(OrderFault.NotFound, "Order 7 is gone.");
+
+        caused.ShouldBe(plain);
+        (caused == plain).ShouldBeTrue();
+        caused.GetHashCode().ShouldBe(plain.GetHashCode());
+        caused.ToString().ShouldBe(plain.ToString());
+        caused.ToString().ShouldNotContain("db-host-7");
+        caused.ShouldNotBe(Fault.Of(OrderFault.NotFound, "Order 8 is gone.", new TimeoutException()));
+        caused.WithRule(Access.Read).ShouldNotBe(plain);
+    }
+
+    [Fact]
+    public void A_rule_and_a_copy_keep_the_cause()
+    {
+        var timeout = new TimeoutException();
+        var fault = Fault.Of(OrderFault.NotFound, null, timeout);
+
+        fault.WithRule(Access.Read).Cause.ShouldBeSameAs(timeout);
+        fault.WithRule(EmailRule.NoAt).Cause.ShouldBeSameAs(timeout);
+        (fault with { }).Cause.ShouldBeSameAs(timeout);
+    }
+
+    /// <summary>A null cause is a mistake where one is given: leave it out for none.</summary>
+    [Fact]
+    public void A_null_cause_is_refused()
+    {
+        Should.Throw<ArgumentNullException>(() => Fault.Of(OrderFault.NotFound, "Order 7 is gone.", null!)).ParamName.ShouldBe("cause");
+        Should.Throw<ArgumentNullException>(() => new Fault<OrderFault>(OrderFault.NotFound, null, null!)).ParamName.ShouldBe("cause");
+        Should.Throw<ArgumentException>(() => Fault.Of(OrderFault.NotFound, " ", new TimeoutException())).ParamName.ShouldBe("detail");
+    }
+
     [Flags]
     private enum Access { Read = 1, Write = 2 }
 
diff --git a/test/CodoMetis.TypeKit.Tests/NullDelegateTests.cs b/test/CodoMetis.TypeKit.Tests/NullDelegateTests.cs
index 6da0bf37..9a1ef06a 100644
--- a/test/CodoMetis.TypeKit.Tests/NullDelegateTests.cs
+++ b/test/CodoMetis.TypeKit.Tests/NullDelegateTests.cs
@@ -115,6 +115,24 @@ public sealed class NullDelegateTests
             [() => new[] { 1 }.TraverseAsync(Null<Func<int, Task<Result<string>>>>()), () => Array.Empty<int>().TraverseAsync(Null<Func<int, Task<Result<string>>>>())],
         ["Result.TraverseAsync(IEnumerable<T>, Func<T, CancellationToken, Task<Result<TError>>>, CancellationToken): selector"] =
             [() => new[] { 1 }.TraverseAsync(Null<Func<int, CancellationToken, Task<Result<string>>>>(), CancellationToken.None), () => Array.Empty<int>().TraverseAsync(Null<Func<int, CancellationToken, Task<Result<string>>>>(), CancellationToken.None)],
+        ["SequenceOptionExtensions.Choose(IAsyncEnumerable<T>, Func<T, Option<TResult>>): selector"] =
+            [() => new[] { 1 }.ToAsyncEnumerable().Choose(Null<Func<int, Option<int>>>()), () => Array.Empty<int>().ToAsyncEnumerable().Choose(Null<Func<int, Option<int>>>())],
+        ["Result.TraverseAsync(IAsyncEnumerable<T>, Func<T, Task<Result<TResult, TError>>>): selector"] =
+            [() => new[] { 1 }.ToAsyncEnumerable().TraverseAsync(Null<Func<int, Task<Result<int, string>>>>()), () => Array.Empty<int>().ToAsyncEnumerable().TraverseAsync(Null<Func<int, Task<Result<int, string>>>>())],
+        ["Result.TraverseAsync(IAsyncEnumerable<T>, Func<T, CancellationToken, Task<Result<TResult, TError>>>, CancellationToken): selector"] =
+            [() => new[] { 1 }.ToAsyncEnumerable().TraverseAsync(Null<Func<int, CancellationToken, Task<Result<int, string>>>>(), CancellationToken.None), () => Array.Empty<int>().ToAsyncEnumerable().TraverseAsync(Null<Func<int, CancellationToken, Task<Result<int, string>>>>(), CancellationToken.None)],
+        ["Result.TraverseAsync(IAsyncEnumerable<T>, Func<T, Task<Result<TError>>>): selector"] =
+            [() => new[] { 1 }.ToAsyncEnumerable().TraverseAsync(Null<Func<int, Task<Result<string>>>>()), () => Array.Empty<int>().ToAsyncEnumerable().TraverseAsync(Null<Func<int, Task<Result<string>>>>())],
+        ["Result.TraverseAsync(IAsyncEnumerable<T>, Func<T, CancellationToken, Task<Result<TError>>>, CancellationToken): selector"] =
+            [() => new[] { 1 }.ToAsyncEnumerable().TraverseAsync(Null<Func<int, CancellationToken, Task<Result<string>>>>(), CancellationToken.None), () => Array.Empty<int>().ToAsyncEnumerable().TraverseAsync(Null<Func<int, CancellationToken, Task<Result<string>>>>(), CancellationToken.None)],
+        ["Result.TraverseAsync(Option<T>, Func<T, Task<Result<TResult, TError>>>): selector"] =
+            [() => Some.TraverseAsync(Null<Func<int, Task<Result<int, string>>>>()), () => None.TraverseAsync(Null<Func<int, Task<Result<int, string>>>>())],
+        ["Result.TraverseAsync(Option<T>, Func<T, CancellationToken, Task<Result<TResult, TError>>>, CancellationToken): selector"] =
+            [() => Some.TraverseAsync(Null<Func<int, CancellationToken, Task<Result<int, string>>>>(), CancellationToken.None), () => None.TraverseAsync(Null<Func<int, CancellationToken, Task<Result<int, string>>>>(), CancellationToken.None)],
+        ["Result.TraverseAsync(Patch<T>, Func<T, Task<Result<TResult, TError>>>): selector"] =
+            [() => Patch.Value(1).TraverseAsync(Null<Func<int, Task<Result<int, string>>>>()), () => Patch.Null<int>().TraverseAsync(Null<Func<int, Task<Result<int, string>>>>()), () => Patch.Absent<int>().TraverseAsync(Null<Func<int, Task<Result<int, string>>>>())],
+        ["Result.TraverseAsync(Patch<T>, Func<T, CancellationToken, Task<Result<TResult, TError>>>, CancellationToken): selector"] =
+            [() => Patch.Value(1).TraverseAsync(Null<Func<int, CancellationToken, Task<Result<int, string>>>>(), CancellationToken.None), () => Patch.Null<int>().TraverseAsync(Null<Func<int, CancellationToken, Task<Result<int, string>>>>(), CancellationToken.None), () => Patch.Absent<int>().TraverseAsync(Null<Func<int, CancellationToken, Task<Result<int, string>>>>(), CancellationToken.None)],
         ["Patch.IfPresent(Patch<T>, Action<Nullable<T>>): action"] = [() => { Patch.Value(1).IfPresent(Null<Action<int?>>()); return null; }, () => { Patch.Null<int>().IfPresent(Null<Action<int?>>()); return null; }, () => { Patch.Absent<int>().IfPresent(Null<Action<int?>>()); return null; }],
 
         // Catch has no branches: the delegate is checked before anything runs. Overloads that differ
@@ -127,6 +145,10 @@ public sealed class NullDelegateTests
         ["Result.CatchAsync(Func<Task>): action"]                        = [() => Result.CatchAsync(Null<Func<Task>>())],
         ["Result.CatchAsync<T, TException>(Func<Task<T>>): action"]      = [() => Result.CatchAsync<int, FormatException>(Null<Func<Task<int>>>())],
         ["Result.CatchAsync<TException>(Func<Task>): action"]            = [() => Result.CatchAsync<FormatException>(Null<Func<Task>>())],
+        ["Result.CatchAsync<T>(Func<ValueTask<T>>): action"]             = [() => Result.CatchAsync(Null<Func<ValueTask<int>>>())],
+        ["Result.CatchAsync(Func<ValueTask>): action"]                   = [() => Result.CatchAsync(Null<Func<ValueTask>>())],
+        ["Result.CatchAsync<T, TException>(Func<ValueTask<T>>): action"] = [() => Result.CatchAsync<int, FormatException>(Null<Func<ValueTask<int>>>())],
+        ["Result.CatchAsync<TException>(Func<ValueTask>): action"]       = [() => Result.CatchAsync<FormatException>(Null<Func<ValueTask>>())],
 
         ["Result<TError>.Match(Func<TResult>, Func<TError, TResult>): onSuccess"] = [() => Ok.Match(Null<Func<int>>(), _ => 0), () => Failed.Match(Null<Func<int>>(), _ => 0)],
         ["Result<TError>.Match(Func<TResult>, Func<TError, TResult>): onError"]   = [() => Ok.Match(() => 0, Null<Func<string, int>>()), () => Failed.Match(() => 0, Null<Func<string, int>>())],
diff --git a/test/CodoMetis.TypeKit.Tests/NullTaskTests.cs b/test/CodoMetis.TypeKit.Tests/NullTaskTests.cs
index b203c377..5407e0da 100644
--- a/test/CodoMetis.TypeKit.Tests/NullTaskTests.cs
+++ b/test/CodoMetis.TypeKit.Tests/NullTaskTests.cs
@@ -22,6 +22,14 @@ public sealed class NullTaskTests
         ["TraverseAsync(selector, token)"]            = ("TraverseAsync", "selector", () => Elements.TraverseAsync((_, _) => (Task<Result<int, string>>)null!, CancellationToken.None)),
         ["command TraverseAsync(selector)"]           = ("TraverseAsync", "selector", () => Elements.TraverseAsync(_ => (Task<Result<string>>)null!)),
         ["command TraverseAsync(selector, token)"]    = ("TraverseAsync", "selector", () => Elements.TraverseAsync((_, _) => (Task<Result<string>>)null!, CancellationToken.None)),
+        ["stream TraverseAsync(selector)"]            = ("TraverseAsync", "selector", () => Elements.ToAsyncEnumerable().TraverseAsync(_ => (Task<Result<int, string>>)null!)),
+        ["stream TraverseAsync(selector, token)"]     = ("TraverseAsync", "selector", () => Elements.ToAsyncEnumerable().TraverseAsync((_, _) => (Task<Result<int, string>>)null!, CancellationToken.None)),
+        ["stream command TraverseAsync(selector)"]    = ("TraverseAsync", "selector", () => Elements.ToAsyncEnumerable().TraverseAsync(_ => (Task<Result<string>>)null!)),
+        ["stream command TraverseAsync(selector, token)"] = ("TraverseAsync", "selector", () => Elements.ToAsyncEnumerable().TraverseAsync((_, _) => (Task<Result<string>>)null!, CancellationToken.None)),
+        ["Option.TraverseAsync(selector)"]          = ("TraverseAsync", "selector", () => Some.TraverseAsync(_ => (Task<Result<int, string>>)null!)),
+        ["Option.TraverseAsync(selector, token)"]     = ("TraverseAsync", "selector", () => Some.TraverseAsync((_, _) => (Task<Result<int, string>>)null!, CancellationToken.None)),
+        ["Patch.TraverseAsync(selector)"]             = ("TraverseAsync", "selector", () => Patch.Value(1).TraverseAsync(_ => (Task<Result<int, string>>)null!)),
+        ["Patch.TraverseAsync(selector, token)"]      = ("TraverseAsync", "selector", () => Patch.Value(1).TraverseAsync((_, _) => (Task<Result<int, string>>)null!, CancellationToken.None)),
         ["Option.MapAsync"]                           = ("MapAsync", "selector", () => Some.MapAsync(_ => (Task<int>)null!)),
         ["Option.BindAsync"]                          = ("BindAsync", "selector", () => Some.BindAsync(_ => (Task<Option<int>>)null!)),
         ["Option.TapAsync"]                           = ("TapAsync", "action", () => Some.TapAsync(_ => null!)),
diff --git a/test/CodoMetis.TypeKit.Tests/OptionPatchTraverseAsyncTests.cs b/test/CodoMetis.TypeKit.Tests/OptionPatchTraverseAsyncTests.cs
new file mode 100644
index 00000000..e886e53c
--- /dev/null
+++ b/test/CodoMetis.TypeKit.Tests/OptionPatchTraverseAsyncTests.cs
@@ -0,0 +1,106 @@
+namespace CodoMetis.TypeKit.Tests;
+
+/// <summary>
+/// <c>TraverseAsync</c> on an <c>Option</c> and a <c>Patch</c>: the synchronous <c>Traverse</c> with the
+/// operation awaited. <c>None</c>, a clear and an absent field never call the selector, and the token is
+/// checked before the one operation, as the sequence's <c>TraverseAsync</c> checks it before each.
+/// </summary>
+public sealed class OptionPatchTraverseAsyncTests
+{
+    private static async Task<Result<int, string>> ParseLater(string text)
+    {
+        await Task.Yield();
+        return int.TryParse(text, out var n) ? Result<int, string>.Success(n) : Result<int, string>.Error($"not a number: {text}");
+    }
+
+    private static Task<Result<int, string>> Unexpected(string _) => throw new InvalidOperationException("the selector was called");
+
+    private static Task<Result<int, string>> Unexpected(string _, CancellationToken __) => throw new InvalidOperationException("the selector was called");
+
+    [Fact]
+    public async Task An_option_with_a_value_is_awaited_into_some_or_the_error()
+    {
+        var parsed = await Option.Some("42").TraverseAsync(ParseLater);
+        parsed.TryGetValue(out var option, out _).ShouldBeTrue();
+        option.TryGetValue(out var value).ShouldBeTrue();
+        value.ShouldBe(42);
+
+        var refused = await Option.Some("x").TraverseAsync(ParseLater);
+        refused.TryGetValue(out _, out var error).ShouldBeFalse();
+        error.ShouldBe("not a number: x");
+    }
+
+    [Fact]
+    public async Task None_is_a_success_without_a_value_and_the_selector_is_not_called()
+    {
+        var none = await Option.None<string>().TraverseAsync(Unexpected);
+        none.TryGetValue(out var option, out _).ShouldBeTrue();
+        option.IsNone().ShouldBeTrue();
+
+        var noneWithToken = await Option.None<string>().TraverseAsync(Unexpected, new CancellationToken(canceled: true));
+        noneWithToken.TryGetValue(out var withToken, out _).ShouldBeTrue("None checks no token: there is no operation to start");
+        withToken.IsNone().ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task A_patch_with_a_value_is_awaited_into_a_value_or_the_error()
+    {
+        var parsed = await Patch.Value("42").TraverseAsync(ParseLater);
+        parsed.TryGetValue(out var patch, out _).ShouldBeTrue();
+        patch.State.ShouldBe(PatchState.Value);
+        patch.TryGetValue(out var value).ShouldBeTrue();
+        value.ShouldBe(42);
+
+        var refused = await Patch.Value("x").TraverseAsync(ParseLater);
+        refused.TryGetValue(out _, out var error).ShouldBeFalse();
+        error.ShouldBe("not a number: x");
+    }
+
+    [Theory]
+    [InlineData(PatchState.Null)]
+    [InlineData(PatchState.Absent)]
+    public async Task A_clear_or_an_absent_field_passes_through_and_the_selector_is_not_called(PatchState state)
+    {
+        var patch = state == PatchState.Null ? Patch.Null<string>() : Patch.Absent<string>();
+
+        var passed = await patch.TraverseAsync(Unexpected);
+        passed.TryGetValue(out var produced, out _).ShouldBeTrue();
+        produced.State.ShouldBe(state);
+
+        var passedWithToken = await patch.TraverseAsync(Unexpected, new CancellationToken(canceled: true));
+        passedWithToken.TryGetValue(out var withToken, out _).ShouldBeTrue("a field without a value checks no token");
+        withToken.State.ShouldBe(state);
+    }
+
+    [Fact]
+    public async Task The_token_is_handed_to_the_operation()
+    {
+        using var cancellation = new CancellationTokenSource();
+        var seen = new List<CancellationToken>();
+
+        Task<Result<int, string>> Load(string text, CancellationToken token)
+        {
+            seen.Add(token);
+            return ParseLater(text);
+        }
+
+        (await Option.Some("1").TraverseAsync(Load, cancellation.Token)).TryGetValue(out var option, out _).ShouldBeTrue();
+        option.TryGetValue(out var fromOption).ShouldBeTrue();
+        fromOption.ShouldBe(1);
+
+        (await Patch.Value("2").TraverseAsync(Load, cancellation.Token)).TryGetValue(out var patch, out _).ShouldBeTrue();
+        patch.TryGetValue(out var fromPatch).ShouldBeTrue();
+        fromPatch.ShouldBe(2);
+
+        seen.ShouldBe([cancellation.Token, cancellation.Token]);
+    }
+
+    [Fact]
+    public async Task A_cancelled_token_starts_nothing_and_propagates()
+    {
+        var cancelled = new CancellationToken(canceled: true);
+
+        await Should.ThrowAsync<OperationCanceledException>(() => Option.Some("1").TraverseAsync(Unexpected, cancelled));
+        await Should.ThrowAsync<OperationCanceledException>(() => Patch.Value("1").TraverseAsync(Unexpected, cancelled));
+    }
+}
diff --git a/test/CodoMetis.TypeKit.Tests/ResultCatchTests.cs b/test/CodoMetis.TypeKit.Tests/ResultCatchTests.cs
index 04f41f98..1b98ef8f 100644
--- a/test/CodoMetis.TypeKit.Tests/ResultCatchTests.cs
+++ b/test/CodoMetis.TypeKit.Tests/ResultCatchTests.cs
@@ -90,6 +90,32 @@ static class Consumer
         if (error.Length > 0) compilation.Problems().ShouldContain("Catch<T, TException>");
     }
 
+    /// <summary>
+    /// A delegate that returns a <c>Task</c>, an <c>async</c> lambda among them, is a compile error whose message
+    /// names <c>CatchAsync</c>: its exception would be thrown after <c>Catch</c> had returned a success.
+    /// </summary>
+    [Theory]
+    [InlineData("Result.Catch(() => Task.FromResult(1))")]
+    [InlineData("Result.Catch(() => Task.CompletedTask)")]
+    [InlineData("Result.Catch(async () => await Task.Yield())")]
+    [InlineData("Result.Catch<InvalidOperationException>(() => Task.CompletedTask)")]
+    public void Catch_over_a_task_is_a_compile_error_naming_CatchAsync(string call)
+    {
+        var compilation = ConsumerCompilation.Of($$"""
+            using System;
+            using System.Threading.Tasks;
+            using CodoMetis.TypeKit;
+
+            static class Consumer
+            {
+                static object Call() => {{call}};
+            }
+            """);
+
+        compilation.ErrorIds().ShouldBe(["CS0619"], compilation.Problems());
+        compilation.Problems().ShouldContain("Use CatchAsync.");
+    }
+
     /// <summary>
     /// A task's type spelled as the value, or inferred where no overload can name it (a
     /// <c>ValueTask</c>), would make the task's exception arrive after a success was returned. It is
@@ -425,9 +451,9 @@ public void The_combinators_are_unchanged_so_a_throwing_selector_propagates()
     /// nothing it throws, and given to the command form <c>Catch&lt;TException&gt;</c> would be
     /// discarded, an <c>async</c> lambda as <c>async void</c>. The overloads over a task-returning
     /// delegate are more specific, so the compiler picks them, and they are errors that name
-    /// <c>CatchAsync</c>. A <c>ValueTask</c> has no such overload (it would make every <c>async</c> lambda
-    /// ambiguous): the command form's refusal of any value covers it, and the valued form refuses it at
-    /// run time.
+    /// <c>CatchAsync</c>. A <c>ValueTask</c> has no such overload, since it would break a build that works
+    /// today (decision 110): the command form's refusal of any value covers it, and the valued form
+    /// refuses it at run time.
     /// </summary>
     [Theory]
     [InlineData("Result.Catch(() => FetchAsync())")]
diff --git a/test/CodoMetis.TypeKit.Tests/ResultContinuationTests.cs b/test/CodoMetis.TypeKit.Tests/ResultContinuationTests.cs
index dc2668b4..bcd6a785 100644
--- a/test/CodoMetis.TypeKit.Tests/ResultContinuationTests.cs
+++ b/test/CodoMetis.TypeKit.Tests/ResultContinuationTests.cs
@@ -1,4 +1,7 @@
 using System.Reflection;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace CodoMetis.TypeKit.Tests;
 
@@ -228,6 +231,40 @@ public async Task A_task_returning_selector_is_awaited_rather_than_wrapped()
         order.Match(o => o.Id, _ => -1).ShouldBe(4);
     }
 
+    /// <summary>
+    /// What the Result page warns of: a callback that returns a <c>ValueTask</c> is no <c>Func&lt;T, Task&gt;</c>, so
+    /// <c>TapAsync</c> and <c>TapErrorAsync</c> on a pending result bind to the overload that takes an action and
+    /// waits for nothing, and <c>MapAsync</c> to the one that takes a value, which keeps the <c>ValueTask</c> as the
+    /// value. <c>.AsTask()</c> or an <c>async</c> lambda binds to the overload that waits.
+    /// </summary>
+    [Theory]
+    [InlineData("pending.TapAsync(x => new ValueTask())", "System.Action<int>", "int")]
+    [InlineData("pending.TapErrorAsync(e => new ValueTask())", "System.Action<string>", "int")]
+    [InlineData("pending.MapAsync(x => new ValueTask<int>(x))", "System.Func<int, System.Threading.Tasks.ValueTask<int>>", "System.Threading.Tasks.ValueTask<int>")]
+    [InlineData("pending.TapAsync(x => new ValueTask().AsTask())", "System.Func<int, System.Threading.Tasks.Task>", "int")]
+    [InlineData("pending.TapErrorAsync(async e => await new ValueTask())", "System.Func<string, System.Threading.Tasks.Task>", "int")]
+    [InlineData("pending.MapAsync(async x => await new ValueTask<int>(x))", "System.Func<int, System.Threading.Tasks.Task<int>>", "int")]
+    public void A_callback_that_returns_a_ValueTask_binds_to_the_overload_that_does_not_wait(string call, string parameter, string value)
+    {
+        var compilation = ConsumerCompilation.Of($$"""
+            using System.Threading.Tasks;
+            using CodoMetis.TypeKit;
+
+            static class Consumer
+            {
+                static object Call(Task<Result<int, string>> pending) => {{call}};
+            }
+            """);
+        compilation.ErrorIds().ShouldBeEmpty(compilation.Problems());
+
+        var tree = compilation.SyntaxTrees.Single();
+        var outermost = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType<InvocationExpressionSyntax>().First();
+        var called = compilation.GetSemanticModel(tree).GetSymbolInfo(outermost, TestContext.Current.CancellationToken).Symbol.ShouldBeAssignableTo<IMethodSymbol>()!;
+
+        called.Parameters.ShouldHaveSingleItem().Type.ToDisplayString().ShouldBe(parameter);
+        called.ReturnType.ToDisplayString().ShouldBe($"System.Threading.Tasks.Task<CodoMetis.TypeKit.Result<{value}, string>>");
+    }
+
     /// <summary>
     /// Everything that can be done to a result can be done to one still being produced: every
     /// combinator of both shapes that returns a result has a continuation on
diff --git a/test/CodoMetis.TypeKit.Tests/ResultWithValueTests.cs b/test/CodoMetis.TypeKit.Tests/ResultWithValueTests.cs
index c9a210b3..2d8575c2 100644
--- a/test/CodoMetis.TypeKit.Tests/ResultWithValueTests.cs
+++ b/test/CodoMetis.TypeKit.Tests/ResultWithValueTests.cs
@@ -280,6 +280,52 @@ public void Select_enables_query_syntax()
         value.ShouldBe(42);
     }
 
+    /// <summary>
+    /// A result has no <c>where</c>: a value filtered out would need an error the query cannot name.
+    /// <c>Ensure(predicate, error)</c> is the filter, and the query pattern finds no <c>Where</c>.
+    /// </summary>
+    [Fact]
+    public void Query_syntax_has_no_where()
+    {
+        var compilation = ConsumerCompilation.Of("""
+            using CodoMetis.TypeKit;
+
+            static class Consumer
+            {
+                static object Call(Result<int, string> result) => from x in result where x > 1 select x;
+            }
+            """);
+
+        compilation.ErrorIds().ShouldBe(["CS1936"], compilation.Problems());
+        compilation.Problems().ShouldContain("'Where'");
+    }
+
+    /// <summary>
+    /// A bare value converts to a success, and a bare error does not: in a <c>Result&lt;long, int&gt;</c> a
+    /// bare <c>5</c> could be either, so only <c>Result.Error(...)</c> makes an error.
+    /// </summary>
+    [Theory]
+    [InlineData("Result<int, string> result = \"boom\";", "CS0029")]
+    [InlineData("Result<int, string> result = Result.Error(\"boom\");", "")]
+    [InlineData("Result<long, int> result = 5;", "")]
+    public void A_bare_error_does_not_convert(string statement, string error)
+    {
+        var compilation = ConsumerCompilation.Of($$"""
+            using CodoMetis.TypeKit;
+
+            static class Consumer
+            {
+                static object Call()
+                {
+                    {{statement}}
+                    return result;
+                }
+            }
+            """);
+
+        compilation.ErrorIds().ShouldBe(error.Length == 0 ? [] : [error], compilation.Problems());
+    }
+
     /// <summary>
     /// A second <c>from</c> needs the two-selector <c>SelectMany</c>: each step can use every earlier
     /// value, and the first error ends the query.
diff --git a/test/CodoMetis.TypeKit.Tests/UninitializedResultTests.cs b/test/CodoMetis.TypeKit.Tests/UninitializedResultTests.cs
index 8c7e7320..0f334910 100644
--- a/test/CodoMetis.TypeKit.Tests/UninitializedResultTests.cs
+++ b/test/CodoMetis.TypeKit.Tests/UninitializedResultTests.cs
@@ -84,6 +84,8 @@ public sealed class UninitializedResultTests
         ["Transpose(Option<Result<T, TError>>)"]       = () => Task.FromResult(Option.Some(default(Result<int, string>)).Transpose()),
         ["Transpose(Result<Option<T>, TError>)"]       = () => Task.FromResult(default(Result<Option<int>, string>).Transpose()),
         ["Traverse(Option<T>, Func<T, Result<TResult, TError>>)"] = () => Task.FromResult(Option.Some(1).Traverse(_ => default(Result<int, string>))),
+        ["TraverseAsync(Option<T>, Func<T, Task<Result<TResult, TError>>>)"] = () => Option.Some(1).TraverseAsync(_ => Task.FromResult(default(Result<int, string>))),
+        ["TraverseAsync(Option<T>, Func<T, CancellationToken, Task<Result<TResult, TError>>>, CancellationToken)"] = () => Option.Some(1).TraverseAsync((_, _) => Task.FromResult(default(Result<int, string>)), CancellationToken.None),
         ["SelectMany(Result<T, TError>, Func<T, Result<TNext, TError>>, Func<T, TNext, TResult>)"] =
             () => Task.FromResult(default(Result<int, string>).SelectMany(_ => Value, (x, _) => x)),
 
@@ -127,12 +129,20 @@ public sealed class UninitializedResultTests
         ["Traverse(IEnumerable<T>, Func<T, Result<TResult, TError>>)"] = () => Task.FromResult(new[] { 1 }.Traverse(_ => default(Result<int, string>))),
         ["Traverse(IEnumerable<T>, Func<T, Result<TError>>)"]          = () => Task.FromResult(new[] { 1 }.Traverse(_ => default(Result<string>))),
         ["Traverse(Patch<T>, Func<T, Result<TResult, TError>>)"]        = () => Task.FromResult(Patch.Value(1).Traverse(_ => default(Result<int, string>))),
+        ["TraverseAsync(Patch<T>, Func<T, Task<Result<TResult, TError>>>)"] = () => Patch.Value(1).TraverseAsync(_ => Task.FromResult(default(Result<int, string>))),
+        ["TraverseAsync(Patch<T>, Func<T, CancellationToken, Task<Result<TResult, TError>>>, CancellationToken)"] = () => Patch.Value(1).TraverseAsync((_, _) => Task.FromResult(default(Result<int, string>)), CancellationToken.None),
         ["TraverseAsync(IEnumerable<T>, Func<T, Task<Result<TResult, TError>>>)"] = () => new[] { 1 }.TraverseAsync(_ => Task.FromResult(default(Result<int, string>))),
         ["TraverseAsync(IEnumerable<T>, Func<T, CancellationToken, Task<Result<TResult, TError>>>, CancellationToken)"] = () => new[] { 1 }.TraverseAsync((_, _) => Task.FromResult(default(Result<int, string>)), CancellationToken.None),
         ["TraverseAsync(IEnumerable<T>, Func<T, Task<Result<TError>>>)"]          = () => new[] { 1 }.TraverseAsync(_ => Task.FromResult(default(Result<string>))),
         ["TraverseAsync(IEnumerable<T>, Func<T, CancellationToken, Task<Result<TError>>>, CancellationToken)"] = () => new[] { 1 }.TraverseAsync((_, _) => Task.FromResult(default(Result<string>)), CancellationToken.None),
         ["Sequence(IEnumerable<Result<T, TError>>)"]                   = () => Task.FromResult(new[] { Value, default }.Sequence()),
         ["Sequence(IEnumerable<Result<TError>>)"]                      = () => Task.FromResult(new[] { Result<string>.Success(), default }.Sequence()),
+        ["TraverseAsync(IAsyncEnumerable<T>, Func<T, Task<Result<TResult, TError>>>)"] = () => new[] { 1 }.ToAsyncEnumerable().TraverseAsync(_ => Task.FromResult(default(Result<int, string>))),
+        ["TraverseAsync(IAsyncEnumerable<T>, Func<T, CancellationToken, Task<Result<TResult, TError>>>, CancellationToken)"] = () => new[] { 1 }.ToAsyncEnumerable().TraverseAsync((_, _) => Task.FromResult(default(Result<int, string>)), CancellationToken.None),
+        ["TraverseAsync(IAsyncEnumerable<T>, Func<T, Task<Result<TError>>>)"]          = () => new[] { 1 }.ToAsyncEnumerable().TraverseAsync(_ => Task.FromResult(default(Result<string>))),
+        ["TraverseAsync(IAsyncEnumerable<T>, Func<T, CancellationToken, Task<Result<TError>>>, CancellationToken)"] = () => new[] { 1 }.ToAsyncEnumerable().TraverseAsync((_, _) => Task.FromResult(default(Result<string>)), CancellationToken.None),
+        ["SequenceAsync(IAsyncEnumerable<Result<T, TError>>, CancellationToken)"] = () => new[] { Value, default }.ToAsyncEnumerable().SequenceAsync(),
+        ["SequenceAsync(IAsyncEnumerable<Result<TError>>, CancellationToken)"]    = () => new[] { Result<string>.Success(), default }.ToAsyncEnumerable().SequenceAsync(),
     };
 
     public static TheoryData<string> ExtensionMemberNames => [.. ExtensionMembers.Keys];
diff --git a/test/Prose.slnf b/test/Prose.slnf
new file mode 100644
index 00000000..d62947f8
--- /dev/null
+++ b/test/Prose.slnf
@@ -0,0 +1,12 @@
+{
+  "solution": {
+    "path": "../CodoMetis.TypeKit.slnx",
+    "projects": [
+      "test/CodoMetis.TypeKit.Conventions.Tests/CodoMetis.TypeKit.Conventions.Tests.csproj",
+      "test/CodoMetis.TypeKit.DocsQuery.Tests/CodoMetis.TypeKit.DocsQuery.Tests.csproj",
+      "test/CodoMetis.TypeKit.Generators.Probes/CodoMetis.TypeKit.Generators.Probes.csproj",
+      "test/CodoMetis.TypeKit.Oracles.Tests/CodoMetis.TypeKit.Oracles.Tests.csproj",
+      "test/CodoMetis.TypeKit.Samples/CodoMetis.TypeKit.Samples.csproj"
+    ]
+  }
+}
diff --git a/test/oracles/Candidates.cs b/test/oracles/Candidates.cs
new file mode 100644
index 00000000..52aa41ef
--- /dev/null
+++ b/test/oracles/Candidates.cs
@@ -0,0 +1,112 @@
+using System.Text.Json;
+
+namespace CodoMetis.TypeKit.Oracles;
+
+/// <summary>
+/// The known disagreements of an oracle, read from <c>test/oracles/candidates.json</c>, and the verdict a sweep
+/// reaches once its failures are matched against them (design/adr/0112).
+/// </summary>
+/// <remarks>
+/// <para>
+/// An oracle sweep collects one line per disagreement and hands them here instead of asserting the list empty.
+/// A line that matches no candidate fails. A line that matches a candidate whose issue is still empty fails too,
+/// labelled <c>[known candidate: family]</c>, so nothing is quarantined before it is filed. A line that matches a
+/// candidate with an issue is written as <c>SKIPPED [known candidate: family, issue]</c> and does not fail. A
+/// candidate that no line matched fails with <c>candidate fixed: remove the entry</c>, so the registry cannot
+/// outlive the defect it recorded.
+/// </para>
+/// <para>
+/// A candidate matches a failure line when the line contains the candidate's <c>row</c> text (ordinal): the stable
+/// prefix of the sweep's own line, the operands and the operation, never the actual value, which changes with the fix.
+/// This file is linked into every test project that holds an oracle rather than referenced.
+/// </para>
+/// </remarks>
+public static class Candidates
+{
+    /// <summary>
+    /// One known disagreement: the oracle class, the row's stable text, its family and the issue that tracks it.
+    /// <paramref name="Method"/> scopes the row to one test method of the class.
+    /// </summary>
+    public sealed record Candidate(string Oracle, string Row, string Family, string Issue, string? Method = null);
+
+    private static readonly Lazy<IReadOnlyList<Candidate>> All_ = new(Load);
+
+    /// <summary>Every registered candidate.</summary>
+    public static IReadOnlyList<Candidate> All => All_.Value;
+
+    /// <summary>Candidates registered for <paramref name="oracle"/>.</summary>
+    public static IReadOnlyList<Candidate> For(string oracle) =>
+        [.. All.Where(candidate => string.Equals(candidate.Oracle, oracle, StringComparison.Ordinal))];
+
+    /// <summary>
+    /// Passes when every failure line is a filed candidate and every candidate of the oracle still fails;
+    /// otherwise fails with <paramref name="header"/> followed by the offending lines.
+    /// </summary>
+    /// <param name="oracle">The oracle class, as registered in <c>test/oracles/oracles.json</c>.</param>
+    /// <param name="failures">The sweep's disagreements, one line each.</param>
+    /// <param name="header">The first line of the failure message, naming the sweep.</param>
+    /// <param name="shown">How many lines of the failure message to show.</param>
+    /// <param name="method">The calling test method; a candidate scoped to another method is not this sweep's.</param>
+    public static void Verdict(string oracle, IReadOnlyList<string> failures, string header, int shown = 25, string? method = null) =>
+        Judge([.. For(oracle).Where(candidate => candidate.Method is null || method is null || string.Equals(candidate.Method, method, StringComparison.Ordinal))],
+              failures, header, shown);
+
+    /// <summary><see cref="Verdict"/> over the candidates given directly, as <c>SeedVerdictTests</c> drives it.</summary>
+    internal static void Judge(IReadOnlyList<Candidate> known, IReadOnlyList<string> failures, string header, int shown = 25)
+    {
+        var failing = new List<string>();
+        var unfiled = new List<string>();
+        var matched = new HashSet<Candidate>();
+
+        foreach (var line in failures)
+        {
+            var candidate = known.FirstOrDefault(c => line.Contains(c.Row, StringComparison.Ordinal));
+            if (candidate is null)
+            {
+                failing.Add(OneLine(line));
+                continue;
+            }
+
+            matched.Add(candidate);
+            if (candidate.Issue.Length == 0)
+                unfiled.Add($"{SeedVerdict.KnownMarker} {candidate.Family}] {OneLine(line.TrimStart())}");
+            else
+                Console.WriteLine($"SKIPPED [known candidate: {candidate.Family}, {candidate.Issue}] {OneLine(line.TrimStart())}");
+        }
+
+        foreach (var fixedCandidate in known.Where(candidate => !matched.Contains(candidate)))
+            failing.Add($"candidate fixed: remove the entry for '{fixedCandidate.Row}' ({fixedCandidate.Family}) from test/oracles/candidates.json");
+
+        // Known rows last, so a message cut short hides them first (SeedVerdict).
+        failing.AddRange(unfiled);
+        if (failing.Count == 0) return;
+
+        Assert.Fail(
+            $"{OneLine(header)} ({failing.Count} failures):" + Environment.NewLine
+          + string.Join(Environment.NewLine, failing.Take(shown))
+          + (failing.Count > shown ? $"{Environment.NewLine}{SeedVerdict.MorePrefix}{failing.Count - shown} more" : ""));
+    }
+
+    /// <summary>A row as one line, line breaks shown as ⏎: the message is one row per line, and SeedVerdict reads it so.</summary>
+    private static string OneLine(string text) =>
+        text.Contains('\n') || text.Contains('\r') ? text.Replace("\r\n", "⏎").Replace('\n', '⏎').Replace('\r', '⏎') : text;
+
+    private static IReadOnlyList<Candidate> Load()
+    {
+        var path = Path.Combine(RepositoryRoot(), "test", "oracles", "candidates.json");
+        using var stream = File.OpenRead(path);
+        return JsonSerializer.Deserialize<List<Candidate>>(stream, new JsonSerializerOptions { PropertyNameCaseInsensitive = true, ReadCommentHandling = JsonCommentHandling.Skip, AllowTrailingCommas = true })
+            ?? throw new InvalidOperationException($"'{path}' holds no array.");
+    }
+
+    private static string RepositoryRoot()
+    {
+        const string marker = "CodoMetis.TypeKit.slnx";
+        for (var directory = new DirectoryInfo(AppContext.BaseDirectory); directory is not null; directory = directory.Parent)
+        {
+            if (File.Exists(Path.Combine(directory.FullName, marker))) return directory.FullName;
+        }
+
+        throw new InvalidOperationException($"Could not find '{marker}' above '{AppContext.BaseDirectory}'.");
+    }
+}
diff --git a/test/oracles/README.md b/test/oracles/README.md
new file mode 100644
index 00000000..deceee86
--- /dev/null
+++ b/test/oracles/README.md
@@ -0,0 +1,54 @@
+# Oracles
+
+How bug-finding works here as a system rather than one sweep per bug (design/adr/0112): a catalogue of what the
+documents promise, an enumeration of what the API offers, oracle tests that check the library against an
+independent answer, seeds that prove each oracle can fail, and a registry of the disagreements found but not yet
+fixed. It is CodoMetis.ValueRanges' kit, kept to what pays for itself: no covering arrays, no ledger, no replay by
+footprint, no agent. The oracles are ordinary tests in the projects that already have their harness, and run with
+the suite.
+
+| File | What it holds | Held by |
+|---|---|---|
+| `claims.json` | One entry per sentence a consumer-facing document promises: its `source` heading, the `quote` verbatim, the `oracle` kind, the `surfaces` (public members, `TypeName.Member`, `*` a wildcard) and `heldBy`, the test classes that assert it. An empty `heldBy` is the worklist. | `OracleCatalogueTests` |
+| `surface-waivers.json` | The public members no claim names, each with why it needs no oracle. A reason that starts `unread:` names a document not yet read for claims, and the issue that reads it. | `OracleSurfaceCoverageTests` |
+| `oracles.json` | The test classes that are oracles: checks against an independent answer over many cases, not worked examples. | `OracleSeedTests` |
+| `seeds/*.patch` | A defect in `src/` with a `Seed:` line, the `Oracles:` it fails and what `Fails:`. Every oracle has one. | `OracleSeedTests`, and `oracles seeds` |
+| `candidates.json` | Disagreements an oracle found that are not fixed yet, each tied to an issue (`Candidates.Verdict`). | `OracleCandidateTests` |
+| `axes.md` | What a consumer varies, which tests vary it, and the pairs none varies yet. | read by hand |
+
+`test/CodoMetis.TypeKit.Oracles.Tests` holds all of it in CI without building anything but itself: a quote its
+document no longer holds, a surface or a test class that does not exist, a public member neither claimed nor
+waived, an oracle without a seed, and a seed that no longer applies all fail there.
+
+Whether a seed is still **caught** takes a build, so it is a local tool, run before a release and after changing an
+oracle or the code a seed patches:
+
+```bash
+dotnet tools/Oracles/bin/Release/net10.0/oracles.dll seeds [name filter]   # each seed: a copy, the patch, one project built, one class run
+dotnet tools/Oracles/bin/Release/net10.0/oracles.dll status                # the worklist: unheld claims, unread waivers, unseeded oracles, candidates
+```
+
+`seeds` copies the working tree (without `bin/`, `obj/` and `.git/`, so uncommitted work is included), builds each
+oracle the selected seeds name and runs that one class: the baseline, with no seed. Then, for each seed, it copies
+the tree again, applies the patch, and builds and runs the same classes with the same filter. A seed is caught when
+its oracle passes without it and fails with it, in a test of its own: a failed test with a row that is not a known
+candidate (`SeedVerdict`, design/adr/0117). It prints one `BASELINE` line per oracle, then one line per seed and
+oracle:
+
+| Verdict | Meaning | Exit code |
+|---|---|---|
+| `CAUGHT` | The baseline passes, and with the seed a test fails on its own assertion or on what the code it calls throws. | 0 when every pair is caught |
+| `MISSED` | The baseline passes, and with the seed every test passes, or fails only on known candidates. | 1 |
+| `ERROR` | A run never reached the tests' own code, or the baseline fails. | 4 |
+
+The TRX decides what reached the tests. A fixture that fails to construct or initialize fails every test with
+xunit's own message (`Collection fixture type 'SqlServer' threw in InitializeAsync`). A fixture that throws in
+`Dispose` shows up only as an `error` in the TRX's counters. A crashed host writes no TRX and exits with something
+other than 0 or 2. A run whose every test was skipped ran nothing. Each of these is `ERROR`, with or without the
+seed: a dead fixture fails every test either way, so its failures prove nothing about the seed. On an arm64 Mac,
+run it with `TYPEKIT_MSSQL_IMAGE=mcr.microsoft.com/azure-sql-edge:latest`, as the suite runs (CONTRIBUTING's Docker
+bullet), or the SQL Server oracles are `ERROR`.
+
+To add an oracle: write the test class, register it in `oracles.json`, write a seed by planting the defect it
+guards against, `git diff` it into `seeds/<defect>.patch` under its header lines, undo the edit, and run
+`oracles seeds <defect>`.
diff --git a/test/oracles/SeedVerdict.cs b/test/oracles/SeedVerdict.cs
new file mode 100644
index 00000000..536bce3d
--- /dev/null
+++ b/test/oracles/SeedVerdict.cs
@@ -0,0 +1,131 @@
+using System.Text.RegularExpressions;
+using System.Xml.Linq;
+
+namespace CodoMetis.TypeKit.Oracles;
+
+/// <summary>
+/// Whether an oracle caught a seed: the rule <c>oracles seeds</c> applies, compiled into <c>tools/Oracles</c> and
+/// linked into <c>CodoMetis.TypeKit.Oracles.Tests</c> (<c>SeedVerdictTests</c>), so the two cannot disagree
+/// (design/adr/0112, design/adr/0117).
+/// </summary>
+/// <remarks>
+/// <para>
+/// A seed is caught when its oracle passes without it and fails with it, in a test of its own. Each oracle class is
+/// run twice with the same filter in the same environment: once on a copy of the tree with no seed (the baseline),
+/// once with the seed planted, and each run is <see cref="Read"/> from the exit code of <c>dotnet test</c> and its
+/// TRX. A run that did not reach the tests' own code is an <see cref="Run.Error"/>, and an error on either side makes
+/// the pair ERROR, never CAUGHT: a dead fixture fails every test, with or without a seed.
+/// </para>
+/// <para>
+/// What the TRX holds, measured with xunit.v3 4.0.2 on Microsoft Testing Platform (2026-10-29): a class, collection
+/// or assembly fixture that fails to construct or to initialize fails every test that uses it, each with xunit's own
+/// message, <c>Collection fixture type 'T' threw in InitializeAsync</c>, the fixture's exception below it
+/// (<see cref="IsSetupFailure"/>). A fixture that throws in <c>Dispose</c> fails no test and is counted only as an
+/// <c>error</c> in the TRX's counters. A test host that crashes writes no TRX and exits with a code that is not
+/// Microsoft Testing Platform's 0 (passed) or 2 (a test failed). A failure in the test's own constructor or
+/// <c>InitializeAsync</c> is written like one in its body, the exception's message and the stack trace below the
+/// test's code, so it counts as the test's: the oracles build what they assert on there.
+/// </para>
+/// <para>
+/// A sweep reports through <c>Candidates.Verdict</c>: a header line, then one line per failing row, where a
+/// row that matches an unfiled candidate starts with <see cref="KnownMarker"/>. A failed test catches the
+/// seed when at least one of its rows is not a known candidate (<see cref="Catches"/>). Counting a test as known
+/// whenever its message held the marker anywhere read a seed that broke a row beside a known one as missed, as
+/// CodoMetis.ValueRanges found (its #55). A baseline whose only failures are known candidates passes.
+/// </para>
+/// <para>
+/// <c>Candidates.Verdict</c> lists the other rows before the known ones, so a message cut short
+/// (<c>… and N more</c>) hides known rows first: when every row shown is known, the hidden ones are too.
+/// A message with no known row at all is any other assertion, and catches.
+/// </para>
+/// </remarks>
+public static class SeedVerdict
+{
+    /// <summary>The prefix <c>Candidates.Verdict</c> gives a row that matches an unfiled candidate.</summary>
+    public const string KnownMarker = "[known candidate:";
+
+    /// <summary>The line <c>Candidates.Verdict</c> ends a cut-short message with.</summary>
+    public const string MorePrefix = "… and ";
+
+    /// <summary>The exit codes of a run that reached its tests: Microsoft Testing Platform's success and "a test failed".</summary>
+    private static readonly int[] RanExitCodes = [0, 2];
+
+    /// <summary>The TRX counters of a result outside any test, such as a fixture's <c>Dispose</c>, or of a run cut short.</summary>
+    private static readonly string[] ErrorCounters = ["error", "aborted", "timeout", "disconnected"];
+
+    private static readonly XNamespace Trx = "http://microsoft.com/schemas/VisualStudio/TeamTest/2010";
+
+    /// <summary>
+    /// xunit's own messages for a test it could not set up, every one in xunit.v3.core 4.0.2 (its fixture kind is
+    /// <c>Assembly</c>, <c>Collection</c> or <c>Class</c>).
+    /// </summary>
+    private static readonly Regex SetupMessage = new(
+        @"\A(\w+ fixture type '[^']*' (threw in |had one or more unresolved constructor arguments|may only define a single public constructor)"
+        + @"|The following constructor parameters did not have matching fixture data"
+        + @"|Cannot create type '[^']*' due to missing constructor arguments)",
+        RegexOptions.CultureInvariant);
+
+    /// <summary>One run of one oracle class, read from the exit code of <c>dotnet test</c> and its TRX.</summary>
+    /// <param name="Executed">The tests that ran, passed or failed; a skipped test is neither.</param>
+    /// <param name="Failed">The tests that failed.</param>
+    /// <param name="Caught">The failed tests with a row that is not a known candidate.</param>
+    /// <param name="Example">The first test in <paramref name="Caught"/>, or empty.</param>
+    /// <param name="Error">Why the run never reached the tests' own code, or <see langword="null"/> when it did.</param>
+    public sealed record Run(int Executed, int Failed, int Caught, string Example, string? Error);
+
+    /// <summary>Whether a failed test's message holds at least one row that is not a known candidate.</summary>
+    public static bool Catches(string message)
+    {
+        var lines = message.Split('\n').Select(line => line.Trim()).Where(line => line.Length > 0).ToList();
+        if (!lines.Any(IsKnown)) return true;
+
+        // A Verdict message: the first line is its header, the last may say how many rows were cut.
+        return lines.Skip(1).Any(line => !IsKnown(line) && !line.StartsWith(MorePrefix, StringComparison.Ordinal));
+    }
+
+    /// <summary>Whether a failed test's message is xunit's own for a fixture or a constructor it could not set up.</summary>
+    public static bool IsSetupFailure(string message) => SetupMessage.IsMatch(message);
+
+    /// <summary>Reads one run of <paramref name="oracle"/>: the exit code of <c>dotnet test</c> and its TRX, if it wrote one.</summary>
+    public static Run Read(int exitCode, XDocument? trx, string oracle)
+    {
+        if (trx is null) return Failure($"no test results written: the test host exited {exitCode}");
+        if (!RanExitCodes.Contains(exitCode)) return Failure($"the test host exited {exitCode}, not 0 or 2");
+
+        var counters = trx.Descendants(Trx + "Counters").FirstOrDefault();
+        var outside = ErrorCounters.Select(name => (Name: name, Count: (int?)counters?.Attribute(name) ?? 0)).Where(counter => counter.Count > 0).ToList();
+        if (outside.Count > 0) return Failure($"the run counts {string.Join(", ", outside.Select(counter => $"{counter.Count} {counter.Name}"))} outside any test (a fixture's Dispose, a host cut short)");
+
+        var results = trx.Descendants(Trx + "UnitTestResult")
+                         .Select(result => (Outcome: (string?)result.Attribute("outcome"), Test: (string?)result.Attribute("testName") ?? "?", Message: result.Descendants(Trx + "Message").FirstOrDefault()?.Value ?? ""))
+                         .Where(result => result.Outcome is "Passed" or "Failed")
+                         .ToList();
+        if (results.Count == 0) return Failure($"no test of {oracle} ran");
+
+        var failed = results.Where(result => result.Outcome == "Failed").ToList();
+        var setup = failed.Where(result => IsSetupFailure(result.Message)).ToList();
+        if (setup.Count > 0) return Failure($"{setup.Count} of {results.Count} tests failed in setup, not in the test: {setup[0].Message.Split('\n')[0].Trim()}");
+
+        var caught = failed.Where(result => Catches(result.Message)).ToList();
+        return new Run(results.Count, failed.Count, caught.Count, caught.Count > 0 ? caught[0].Test : "", Error: null);
+
+        static Run Failure(string error) => new(0, 0, 0, "", error);
+    }
+
+    /// <summary>
+    /// The verdict on one seed and one oracle: <c>CAUGHT</c>, <c>MISSED</c> or <c>ERROR</c>, padded to eight
+    /// characters, then what was seen.
+    /// </summary>
+    public static string Judge(Run baseline, Run seeded)
+    {
+        if (baseline.Error is not null) return $"ERROR   without the seed, {baseline.Error}";
+        if (baseline.Caught > 0) return $"ERROR   {baseline.Caught} of {baseline.Executed} tests fail without the seed, e.g. {baseline.Example}";
+        if (seeded.Error is not null) return $"ERROR   with the seed, {seeded.Error}";
+        if (seeded.Caught > 0) return $"CAUGHT  {seeded.Caught} of {seeded.Executed} tests fail, e.g. {seeded.Example}";
+        return seeded.Failed == 0
+            ? $"MISSED  all {seeded.Executed} tests pass with the defect planted"
+            : $"MISSED  {seeded.Failed} of {seeded.Executed} tests fail, every row a known candidate";
+    }
+
+    private static bool IsKnown(string line) => line.StartsWith(KnownMarker, StringComparison.Ordinal);
+}
diff --git a/test/oracles/axes.md b/test/oracles/axes.md
new file mode 100644
index 00000000..05e1cbff
--- /dev/null
+++ b/test/oracles/axes.md
@@ -0,0 +1,45 @@
+# What a consumer varies
+
+The claims say what is promised, and the surface says what is offered. Neither says which settings a consumer
+combines: the JSON options of the host, the OpenAPI version, MVC or a minimal API, the EF provider, the shape of
+their own type. This is the hand-written list (design/adr/0112): one section per surface family, each axis with
+its values, the tests that already vary it, and the pairs no test varies yet, which are the next probe class.
+
+A **probe class** (`*ProbeTests`) is an ordinary test over the full product of a few axes, in the project that
+already has the harness. Its oracle is the document's promise, it ends in `Candidates.Verdict`, and it is
+registered in `oracles.json` with a seed like every other oracle. It stays under a minute: nothing replays it by
+footprint, it runs with the suite.
+
+## The oracles this repository promises
+
+- **JSON parity (differential).** A shape with a value object and the same shape with the wrapped type serialize
+  to the same bytes, as a value, a property and a dictionary key. `JsonParityTests`.
+- **Schema parity (differential).** The OpenAPI schema of a value-object property equals the wrapped type's, with
+  value objects as components and inlined (`InlineValueObjects`). `SchemaTests`, `NullablePositionTests`.
+- **Column parity (differential).** The EF model gives a value-object property the wrapped type's column, and a
+  key the wrapped type's generation. `MappingTests`, `KeyGenerationVariantTests`, `ColumnFacetVariantTests`.
+- **One set of rules (differential).** `TryFrom`, `Parse`, the JSON converter, the type converter and the
+  binders refuse what `Create` refuses. `EntryPointValidationTests`.
+- **No refusal quotes the input (exception).** A sentinel in refused input never reaches a message.
+  `UnreadableInputTests`.
+- **Off the wire (exception).** `Option` and `Result` refuse System.Text.Json in both directions. `NotWireTypeTests`.
+- **Every member, by reflection (completeness).** A null delegate on every branch, an uninitialized result, the
+  context an asynchronous callback runs on. `NullDelegateTests`, `UninitializedResultTests`, `AsynchronousContextTests`.
+
+## The axes
+
+| Family | Axis | Values | Varied by | Pairs no test varies yet |
+|---|---|---|---|---|
+| JSON | the host's options | defaults, Web, a naming policy, a dictionary-key policy, number handling, a host converter | `JsonParityTests` | reference preservation beside a dictionary key |
+| JSON | the wrapped type | every built-in the generators wrap, nullable or not | `JsonParityTests`, `JsonTests` | |
+| OpenAPI | the version | 3.1, 3.0, 2.0 | `SchemaTests`, `FaultResponseTests` | a withheld fault name under 2.0 |
+| OpenAPI | where value objects are described | components, inlined by `InlineValueObjects`, everything inlined by the host | `SchemaTests`, `NullablePositionTests`, `DescribedParameterTests` | `InlineValueObjects` beside a described type's parameter (`DescribedParameterTests` inlines by the host's own delegate) |
+| HTTP | the host | minimal API, MVC with `[ApiController]`, MVC without | `MvcBindingTests`, `FaultStatusScopeTests` | |
+| EF | the provider | SQLite, Npgsql, SQL Server | `KeyGenerationVariantTests`, `QueryTranslationVariantTests` | |
+| EF | where a key sits | `KeyShapes` (`test/CodoMetis.TypeKit.EntityFrameworkCore.Tests/Variants/`) | `KeyGenerationVariantTests` | |
+| EF | the query | `QueryShapes` | `QueryTranslationVariantTests` | |
+| Analyzers | where a type argument is written, and what it is | `TypeArgumentSites`, `TypeArgumentKinds` (`test/CodoMetis.TypeKit.Analyzers.Tests/Variants/`) | `TypeArgumentConstraintVariantTests` | |
+| Generation | the declaration's shape | record struct, record class, struct, class; sealed or not; over each wrapped kind | `BuildOutcomeTests`, `GeneratedSurfaceTests` | |
+
+An empty last column means nobody has looked yet, not that nothing is missing. Fill it when a feature lands or a
+finding names a combination no test varied.
diff --git a/test/oracles/candidates.json b/test/oracles/candidates.json
new file mode 100644
index 00000000..fe51488c
--- /dev/null
+++ b/test/oracles/candidates.json
@@ -0,0 +1 @@
+[]
diff --git a/test/oracles/claims.json b/test/oracles/claims.json
new file mode 100644
index 00000000..47a89c5b
--- /dev/null
+++ b/test/oracles/claims.json
@@ -0,0 +1,5058 @@
+[
+  {
+    "id": "A01-choose-reads-a-stream",
+    "source": "src/CodoMetis.TypeKit/README.md#find-one-in-a-collection",
+    "quote": "Both read an async stream too, as its elements arrive.",
+    "claim": "Both read an async stream too, as its elements arrive.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.Choose",
+      "SequenceOptionExtensions.Choose"
+    ],
+    "heldBy": [
+      "AsyncStreamTests"
+    ]
+  },
+  {
+    "id": "A01-dispose-however-they-stop",
+    "source": "src/CodoMetis.TypeKit/README.md#chain-steps",
+    "quote": "All three read the stream in order, and dispose its enumerator however they stop: at an error, at a `break`, or when your selector throws.",
+    "claim": "All three read the stream in order, and dispose its enumerator however they stop: at an error, at a `break`, or when your selector throws.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.Choose",
+      "SequenceOptionExtensions.Choose",
+      "Result.SequenceAsync",
+      "Result.TraverseAsync"
+    ],
+    "heldBy": [
+      "AsyncStreamTests"
+    ]
+  },
+  {
+    "id": "A01-stop-at-the-first-error",
+    "source": "src/CodoMetis.TypeKit/README.md#chain-steps",
+    "quote": "`SequenceAsync` and `TraverseAsync` stop at the first error and read nothing after it.",
+    "claim": "`SequenceAsync` and `TraverseAsync` stop at the first error and read nothing after it.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.SequenceAsync",
+      "Result.TraverseAsync"
+    ],
+    "heldBy": [
+      "AsyncStreamTests"
+    ]
+  },
+  {
+    "id": "A01-token-reaches-the-stream",
+    "source": "src/CodoMetis.TypeKit/README.md#chain-steps",
+    "quote": "The token you give `SequenceAsync` or `TraverseAsync` reaches the stream.",
+    "claim": "The token you give `SequenceAsync` or `TraverseAsync` reaches the stream.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.SequenceAsync",
+      "Result.TraverseAsync"
+    ],
+    "heldBy": [
+      "AsyncStreamTests"
+    ]
+  },
+  {
+    "id": "A01-with-cancellation-for-choose",
+    "source": "src/CodoMetis.TypeKit/README.md#chain-steps",
+    "quote": "For `Choose`, pass yours to `WithCancellation` on what it returns.",
+    "claim": "For `Choose`, pass yours to `WithCancellation` on what it returns.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.Choose",
+      "SequenceOptionExtensions.Choose"
+    ],
+    "heldBy": [
+      "AsyncStreamTests"
+    ]
+  },
+  {
+    "id": "C01-covers-every-decimal",
+    "source": "docs/json.md#decimals-in-one-spelling",
+    "quote": "Register either one once, and it covers every decimal: nullable ones, dictionary keys, and every value object over a decimal, since its JSON is the underlying type's.",
+    "claim": "Register either one once, and it covers every decimal: nullable ones, dictionary keys, and every value object over a decimal, since its JSON is the underlying type's.",
+    "oracle": "claim",
+    "surfaces": [
+      "DecimalNumberJsonConverter.*",
+      "DecimalStringJsonConverter.*"
+    ],
+    "heldBy": [
+      "DecimalJsonConvertersTests"
+    ]
+  },
+  {
+    "id": "C01-number-is-a-number",
+    "source": "docs/json.md#decimals-in-one-spelling",
+    "quote": "**`DecimalNumberJsonConverter`** writes it as a number.",
+    "claim": "**`DecimalNumberJsonConverter`** writes it as a number.",
+    "oracle": "claim",
+    "surfaces": [
+      "DecimalNumberJsonConverter.*",
+      "DecimalStringJsonConverter.*"
+    ],
+    "heldBy": [
+      "DecimalJsonConvertersTests"
+    ]
+  },
+  {
+    "id": "C01-reads-a-number-or-a-string",
+    "source": "docs/json.md#decimals-in-one-spelling",
+    "quote": "Both read a number, or a string holding one, and keep the scale they read.",
+    "claim": "Both read a number, or a string holding one, and keep the scale they read.",
+    "oracle": "claim",
+    "surfaces": [
+      "DecimalNumberJsonConverter.*",
+      "DecimalStringJsonConverter.*"
+    ],
+    "heldBy": [
+      "DecimalJsonConvertersTests"
+    ]
+  },
+  {
+    "id": "C01-smallest-scale",
+    "source": "docs/json.md#decimals-in-one-spelling",
+    "quote": "Two converters write the smallest scale instead:",
+    "claim": "Two converters write the smallest scale instead:",
+    "oracle": "claim",
+    "surfaces": [
+      "DecimalNumberJsonConverter.*",
+      "DecimalStringJsonConverter.*"
+    ],
+    "heldBy": [
+      "DecimalJsonConvertersTests"
+    ]
+  },
+  {
+    "id": "C01-string-is-a-string",
+    "source": "docs/json.md#decimals-in-one-spelling",
+    "quote": "**`DecimalStringJsonConverter`** writes it as a string.",
+    "claim": "**`DecimalStringJsonConverter`** writes it as a string.",
+    "oracle": "claim",
+    "surfaces": [
+      "DecimalNumberJsonConverter.*",
+      "DecimalStringJsonConverter.*"
+    ],
+    "heldBy": [
+      "DecimalJsonConvertersTests"
+    ]
+  },
+  {
+    "id": "C02-hidden-is-an-error-in-both",
+    "source": "docs/text.md#required-and-optional",
+    "quote": "`Hidden` is an error in both cases.",
+    "claim": "`Hidden` is an error in both cases.",
+    "oracle": "claim",
+    "surfaces": [
+      "StringTextExtensions.*",
+      "TextFault.*"
+    ],
+    "heldBy": [
+      "StringTextExtensionsTests"
+    ]
+  },
+  {
+    "id": "C02-null-is-blank",
+    "source": "docs/text.md#required-and-optional",
+    "quote": "A null string is `Blank`.",
+    "claim": "A null string is `Blank`.",
+    "oracle": "claim",
+    "surfaces": [
+      "StringTextExtensions.*",
+      "TextFault.*"
+    ],
+    "heldBy": [
+      "StringTextExtensionsTests"
+    ]
+  },
+  {
+    "id": "C02-optional-blank-is-no-value",
+    "source": "docs/text.md#required-and-optional",
+    "quote": "For an optional one, a blank means \"no value\", and `AsOptionalText()` and `AsOptionalIdentifier()` return a `Result<Option<string>, TextFault>`.",
+    "claim": "For an optional one, a blank means \"no value\", and `AsOptionalText()` and `AsOptionalIdentifier()` return a `Result<Option<string>, TextFault>`.",
+    "oracle": "claim",
+    "surfaces": [
+      "StringTextExtensions.*",
+      "TextFault.*"
+    ],
+    "heldBy": [
+      "StringTextExtensionsTests"
+    ]
+  },
+  {
+    "id": "C02-required-blank-is-an-error",
+    "source": "docs/text.md#required-and-optional",
+    "quote": "For a required field, `Blank` is an error.",
+    "claim": "For a required field, `Blank` is an error.",
+    "oracle": "claim",
+    "surfaces": [
+      "StringTextExtensions.*",
+      "TextFault.*"
+    ],
+    "heldBy": [
+      "StringTextExtensionsTests"
+    ]
+  },
+  {
+    "id": "C03-detail-and-rule-intact",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#faults-of-several-types",
+    "quote": "`Fault<AccountFault, EditFault>` (from CodoMetis.TypeKit) holds one error of either set, with its detail and rule intact.",
+    "claim": "`Fault<AccountFault, EditFault>` (from CodoMetis.TypeKit) holds one error of either set, with its detail and rule intact.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitHttpResultExtensions.ToHttpResult",
+      "Fault.*"
+    ],
+    "heldBy": [
+      "ComposedFaultResponseTests"
+    ]
+  },
+  {
+    "id": "C03-each-error-own-set",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#faults-of-several-types",
+    "quote": "Each error is answered as its own set maps it.",
+    "claim": "Each error is answered as its own set maps it.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitHttpResultExtensions.ToHttpResult",
+      "Fault.*"
+    ],
+    "heldBy": [
+      "ComposedFaultResponseTests"
+    ]
+  },
+  {
+    "id": "C03-statuses-ascending",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#faults-of-several-types",
+    "quote": "So its operation lists the statuses of both sets, in ascending order, with the problem types of both where they share a status.",
+    "claim": "So its operation lists the statuses of both sets, in ascending order, with the problem types of both where they share a status.",
+    "oracle": "claim",
+    "surfaces": [
+      "Fault.*",
+      "TypeKitHttpResultExtensions.ToHttpResult"
+    ],
+    "heldBy": [
+      "ComposedFaultResponseTests"
+    ]
+  },
+  {
+    "id": "C03-unmapped-set-stops-start",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#faults-of-several-types",
+    "quote": "The host doesn't start while either set is unmapped.",
+    "claim": "The host doesn't start while either set is unmapped.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitHttpResultExtensions.ToHttpResult",
+      "Fault.*"
+    ],
+    "heldBy": [
+      "ComposedFaultResponseTests"
+    ]
+  },
+  {
+    "id": "C04-doc-omits-left-out",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#leaving-out-what-a-route-cannot-answer",
+    "quote": "The operation then lists no status and no problem type for a member left out.",
+    "claim": "The operation then lists no status and no problem type for a member left out.",
+    "oracle": "exception",
+    "surfaces": [
+      "WithoutFaultsAttribute.*",
+      "TypeKitWithoutFaultsEndpointConventionBuilderExtensions.*"
+    ],
+    "heldBy": [
+      "FaultExclusionTests"
+    ]
+  },
+  {
+    "id": "C04-left-out-everywhere-stops-start",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#leaving-out-what-a-route-cannot-answer",
+    "quote": "**These stop the host from starting**, as for a status: a value or a name no member has, a status that every endpoint it's set on leaves out (on the endpoint itself, or on a group whose endpoints all leave the member out), and a group or a controller none of whose endpoints answers with the type.",
+    "claim": "**These stop the host from starting**, as for a status: a value or a name no member has, a status that every endpoint it's set on leaves out (on the endpoint itself, or on a group whose endpoints all leave the member out), and a group or a controller none of whose endpoints answers with the type.",
+    "oracle": "exception",
+    "surfaces": [
+      "WithoutFaultsAttribute.*",
+      "TypeKitWithoutFaultsEndpointConventionBuilderExtensions.*"
+    ],
+    "heldBy": [
+      "FaultExclusionTests"
+    ]
+  },
+  {
+    "id": "C04-narrows-wider-status",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#leaving-out-what-a-route-cannot-answer",
+    "quote": "If a group gives `NotFound` a status and one endpoint inside leaves `NotFound` out, that endpoint drops it, and the group's other endpoints keep the status.",
+    "claim": "If a group gives `NotFound` a status and one endpoint inside leaves `NotFound` out, that endpoint drops it, and the group's other endpoints keep the status.",
+    "oracle": "exception",
+    "surfaces": [
+      "WithoutFaultsAttribute.*",
+      "TypeKitWithoutFaultsEndpointConventionBuilderExtensions.*"
+    ],
+    "heldBy": [
+      "FaultExclusionTests"
+    ]
+  },
+  {
+    "id": "C04-reporting-left-out-throws",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#leaving-out-what-a-route-cannot-answer",
+    "quote": "Reporting a member left out anyway throws an `InvalidOperationException` naming the endpoint and the member, rather than answering with a status the document doesn't list.",
+    "claim": "Reporting a member left out anyway throws an `InvalidOperationException` naming the endpoint and the member, rather than answering with a status the document doesn't list.",
+    "oracle": "exception",
+    "surfaces": [
+      "WithoutFaultsAttribute.*",
+      "TypeKitWithoutFaultsEndpointConventionBuilderExtensions.*"
+    ],
+    "heldBy": [
+      "FaultExclusionTests"
+    ]
+  },
+  {
+    "id": "C05-nested-chain",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#the-rule-that-refused",
+    "quote": "A rule of a nested type is named after its nesting chain, whatever `QualifiedFaultNames` says.",
+    "claim": "A rule of a nested type is named after its nesting chain, whatever `QualifiedFaultNames` says.",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultRuleExtensions.*",
+      "FaultClosedSetRuleExtensions.*"
+    ],
+    "heldBy": [
+      "FaultResponsePartsTests"
+    ]
+  },
+  {
+    "id": "C05-no-namespace",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#the-rule-that-refused",
+    "quote": "**The name carries no namespace**, which would publish your application's structure to every client.",
+    "claim": "**The name carries no namespace**, which would publish your application's structure to every client.",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultRuleExtensions.*",
+      "FaultClosedSetRuleExtensions.*"
+    ],
+    "heldBy": [
+      "FaultResponsePartsTests"
+    ]
+  },
+  {
+    "id": "C05-rule-qualified",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#the-rule-that-refused",
+    "quote": "The problem carries it as `rule`, qualified with its type's name, so two types' `Blank` can be told apart:",
+    "claim": "The problem carries it as `rule`, qualified with its type's name, so two types' `Blank` can be told apart:",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultRuleExtensions.*",
+      "FaultClosedSetRuleExtensions.*"
+    ],
+    "heldBy": [
+      "FaultResponsePartsTests"
+    ]
+  },
+  {
+    "id": "C05-stays-the-errors",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#the-rule-that-refused",
+    "quote": "The status, the mapping and the document stay the error's.",
+    "claim": "The status, the mapping and the document stay the error's.",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultRuleExtensions.*",
+      "FaultClosedSetRuleExtensions.*"
+    ],
+    "heldBy": [
+      "FaultResponsePartsTests"
+    ]
+  },
+  {
+    "id": "C05-unnamed-value-throws",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#the-rule-that-refused",
+    "quote": "A value no member names, such as a combination of flags or a cast number, throws where it's given.",
+    "claim": "A value no member names, such as a combination of flags or a cast number, throws where it's given.",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultRuleExtensions.*",
+      "FaultClosedSetRuleExtensions.*"
+    ],
+    "heldBy": [
+      "FaultResponsePartsTests"
+    ]
+  },
+  {
+    "id": "C06-description-as-detail",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#a-closed-set-as-the-fault-type",
+    "quote": "The description becomes the problem's `detail`, so a client can show it.",
+    "claim": "The description becomes the problem's `detail`, so a client can show it.",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultKind.*",
+      "IFault.*",
+      "FaultResponse.For",
+      "TypeKitClosedSetHttpResultExtensions.ToHttpResult"
+    ],
+    "heldBy": [
+      "FaultSetDefaultTests"
+    ]
+  },
+  {
+    "id": "C06-kind-gives-status",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#a-closed-set-as-the-fault-type",
+    "quote": "The kind gives the status:",
+    "claim": "The kind gives the status:",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultKind.*",
+      "IFault.*",
+      "FaultResponse.For",
+      "TypeKitClosedSetHttpResultExtensions.ToHttpResult"
+    ],
+    "heldBy": [
+      "FaultResponsePartsTests",
+      "FaultSetDefaultTests"
+    ]
+  },
+  {
+    "id": "C06-member-must-have-kind",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#a-closed-set-as-the-fault-type",
+    "quote": "**A member must have a kind.** A member whose kind is `default`, which is no kind, fails this call.",
+    "claim": "**A member must have a kind.** A member whose kind is `default`, which is no kind, fails this call.",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultKind.*",
+      "IFault.*",
+      "FaultResponse.For",
+      "TypeKitClosedSetHttpResultExtensions.ToHttpResult"
+    ],
+    "heldBy": [
+      "FaultResponsePartsTests",
+      "FaultSetDefaultTests"
+    ]
+  },
+  {
+    "id": "C06-no-description-no-detail",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#a-closed-set-as-the-fault-type",
+    "quote": "A member without one has no `detail`.",
+    "claim": "A member without one has no `detail`.",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultKind.*",
+      "IFault.*",
+      "FaultResponse.For",
+      "TypeKitClosedSetHttpResultExtensions.ToHttpResult"
+    ],
+    "heldBy": [
+      "FaultResponsePartsTests"
+    ]
+  },
+  {
+    "id": "C07-by-kind",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#every-fault-set-at-once",
+    "quote": "every fault set an endpoint answers with, by its kind",
+    "claim": "every fault set an endpoint answers with, by its kind",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitFaultResponsesServiceCollectionExtensions.*",
+      "TypeKitClosedSetFaultResponsesServiceCollectionExtensions.*"
+    ],
+    "heldBy": [
+      "FaultSetDefaultTests"
+    ]
+  },
+  {
+    "id": "C07-enum-needs-own-mapping",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#every-fault-set-at-once",
+    "quote": "Neither has a kind, and the host doesn't start while an endpoint answers with one that's unmapped.",
+    "claim": "Neither has a kind, and the host doesn't start while an endpoint answers with one that's unmapped.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitFaultResponsesServiceCollectionExtensions.*",
+      "TypeKitClosedSetFaultResponsesServiceCollectionExtensions.*"
+    ],
+    "heldBy": [
+      "FaultSetDefaultTests"
+    ]
+  },
+  {
+    "id": "C07-member-without-kind-stops-start",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#every-fault-set-at-once",
+    "quote": "A member with no kind stops the start, and so does one the mapping throws for or gives a status that isn't an error.",
+    "claim": "A member with no kind stops the start, and so does one the mapping throws for or gives a status that isn't an error.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitClosedSetFaultResponsesServiceCollectionExtensions.*",
+      "TypeKitFaultResponsesServiceCollectionExtensions.*"
+    ],
+    "heldBy": [
+      "FaultSetDefaultTests"
+    ]
+  },
+  {
+    "id": "C07-own-mapping",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#every-fault-set-at-once",
+    "quote": "The mapping can be your own. It reads each member's kind and description through `IFault`:",
+    "claim": "The mapping can be your own. It reads each member's kind and description through `IFault`:",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitFaultResponsesServiceCollectionExtensions.*",
+      "TypeKitClosedSetFaultResponsesServiceCollectionExtensions.*"
+    ],
+    "heldBy": [
+      "FaultSetDefaultTests"
+    ]
+  },
+  {
+    "id": "C07-own-set-keeps-mapping",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#every-fault-set-at-once",
+    "quote": "A set mapped on its own keeps its mapping.",
+    "claim": "A set mapped on its own keeps its mapping.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitFaultResponsesServiceCollectionExtensions.*",
+      "TypeKitClosedSetFaultResponsesServiceCollectionExtensions.*"
+    ],
+    "heldBy": [
+      "FaultSetDefaultTests"
+    ]
+  },
+  {
+    "id": "C08-bare-names-warn",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#faults-of-several-types",
+    "quote": "With bare names, the default, that's `AccountFault.NotFound` beside an `EditFault.NotFound`.",
+    "claim": "With bare names, the default, that's `AccountFault.NotFound` beside an `EditFault.NotFound`.",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultResponseOptions.*"
+    ],
+    "heldBy": [
+      "ComposedFaultResponseTests"
+    ]
+  },
+  {
+    "id": "C08-qualified-chain-warns",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#faults-of-several-types",
+    "quote": "With qualified names, it's two sets with one nesting chain in two namespaces, since the name carries no namespace.",
+    "claim": "With qualified names, it's two sets with one nesting chain in two namespaces, since the name carries no namespace.",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultResponseOptions.*"
+    ],
+    "heldBy": [
+      "ComposedFaultResponseTests"
+    ]
+  },
+  {
+    "id": "C08-qualified-names-fix",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#faults-of-several-types",
+    "quote": "Fix it with `QualifiedFaultNames`, a rename, or by leaving one out of the route",
+    "claim": "Fix it with `QualifiedFaultNames`, a rename, or by leaving one out of the route",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultResponseOptions.*"
+    ],
+    "heldBy": [
+      "ComposedFaultResponseTests"
+    ]
+  },
+  {
+    "id": "C08-warning-names-both",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#faults-of-several-types",
+    "quote": "A client reads the two errors as one, so the host logs a warning at startup naming both.",
+    "claim": "A client reads the two errors as one, so the host logs a warning at startup naming both.",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultResponseOptions.*"
+    ],
+    "heldBy": [
+      "ComposedFaultResponseTests"
+    ]
+  },
+  {
+    "id": "C09-equal-by-the-wrapped-value",
+    "source": "CHANGELOG.md",
+    "quote": "Over a base record, a value object's equality is its wrapped value's",
+    "claim": "Over a base record, a value object's equality is its wrapped value's",
+    "oracle": "metamorphic",
+    "surfaces": [
+      "IValueObject.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "C09-in-a-collection-of-the-base",
+    "source": "CHANGELOG.md",
+    "quote": "in a collection of the base too, whatever equality the base declares.",
+    "claim": "in a collection of the base too, whatever equality the base declares.",
+    "oracle": "metamorphic",
+    "surfaces": [
+      "IValueObject.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "C10-ignore-cycles-unaffected",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#json",
+    "quote": "a struct of such values, and `ReferenceHandler.IgnoreCycles`.",
+    "claim": "a struct of such values, and `ReferenceHandler.IgnoreCycles`.",
+    "oracle": "claim",
+    "surfaces": [
+      "GeneratedJson.*"
+    ],
+    "heldBy": [
+      "ReferenceHandlingTests"
+    ]
+  },
+  {
+    "id": "C10-own-converters-unaffected",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#json",
+    "quote": "anything a converter of your own writes, on the options or on one property",
+    "claim": "anything a converter of your own writes, on the options or on one property",
+    "oracle": "claim",
+    "surfaces": [
+      "GeneratedJson.*"
+    ],
+    "heldBy": [
+      "ReferenceHandlingTests"
+    ]
+  },
+  {
+    "id": "C10-refused-where-references-could-be-written",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#json",
+    "quote": "**Preserved references** (`ReferenceHandler.Preserve`) throw a `NotSupportedException` where the serializer could write `$id` or `$ref` inside the underlying value.",
+    "claim": "**Preserved references** (`ReferenceHandler.Preserve`) throw a `NotSupportedException` where the serializer could write `$id` or `$ref` inside the underlying value.",
+    "oracle": "claim",
+    "surfaces": [
+      "GeneratedJson.*"
+    ],
+    "heldBy": [
+      "ReferenceHandlingTests"
+    ]
+  },
+  {
+    "id": "C10-value-converters-unaffected",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#json",
+    "quote": "These are unaffected: a value the serializer writes with a value converter (a number, a string, a `Guid`, a `Uri`)",
+    "claim": "These are unaffected: a value the serializer writes with a value converter (a number, a string, a `Guid`, a `Uri`)",
+    "oracle": "claim",
+    "surfaces": [
+      "GeneratedJson.*"
+    ],
+    "heldBy": [
+      "ReferenceHandlingTests"
+    ]
+  },
+  {
+    "id": "C11-abstract-string-constructor",
+    "source": "CHANGELOG.md",
+    "quote": "or an abstract class's string constructor, no longer breaks the build; the value object has no parsing.",
+    "claim": "or an abstract class's string constructor, no longer breaks the build; the value object has no parsing.",
+    "oracle": "claim",
+    "surfaces": [
+      "GeneratedParsing.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "C11-implicit-result",
+    "source": "CHANGELOG.md",
+    "quote": "A wrapped type's `Parse` whose result can't be assigned to it",
+    "claim": "A wrapped type's `Parse` whose result can't be assigned to it",
+    "oracle": "claim",
+    "surfaces": [
+      "GeneratedParsing.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "C11-parsing-where-it-can-be-parsed",
+    "source": "CHANGELOG.md",
+    "quote": "`IParsable`/`ISpanParsable`/`IUtf8SpanParsable`, formatting in the invariant culture",
+    "claim": "`IParsable`/`ISpanParsable`/`IUtf8SpanParsable`, formatting in the invariant culture",
+    "oracle": "claim",
+    "surfaces": [
+      "GeneratedParsing.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "C11-ref-text",
+    "source": "CHANGELOG.md",
+    "quote": "or that takes its text by `ref`",
+    "claim": "or that takes its text by `ref`",
+    "oracle": "claim",
+    "surfaces": [
+      "GeneratedParsing.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "C12-every-position",
+    "source": "docs/json.md#describing-what-a-converter-writes",
+    "quote": "With CodoMetis.TypeKit.AspNetCore, `AddTypeKit()` writes the same descriptions into the OpenAPI document, in every position, a list's elements and a dictionary's values included.",
+    "claim": "With CodoMetis.TypeKit.AspNetCore, `AddTypeKit()` writes the same descriptions into the OpenAPI document, in every position, a list's elements and a dictionary's values included.",
+    "oracle": "claim",
+    "surfaces": [
+      "IDescribedJsonConverter.*",
+      "JsonSchemaDescriptions.*",
+      "JsonSchemaDescription.*"
+    ],
+    "heldBy": [
+      "DescribedSchemaTests"
+    ]
+  },
+  {
+    "id": "C12-options-describe",
+    "source": "docs/json.md#describing-what-a-converter-writes",
+    "quote": "**A converter someone else wrote**, or the serializer's own enum converter, is described in the options by `JsonSchemaDescriptions`.",
+    "claim": "**A converter someone else wrote**, or the serializer's own enum converter, is described in the options by `JsonSchemaDescriptions`.",
+    "oracle": "claim",
+    "surfaces": [
+      "IDescribedJsonConverter.*",
+      "JsonSchemaDescriptions.*",
+      "JsonSchemaDescription.*"
+    ],
+    "heldBy": [
+      "DescribedSchemaTests"
+    ]
+  },
+  {
+    "id": "C12-own-converter-describes-itself",
+    "source": "docs/json.md#describing-what-a-converter-writes",
+    "quote": "**Your own converter** implements `IDescribedJsonConverter` and describes itself, as both decimal converters do.",
+    "claim": "**Your own converter** implements `IDescribedJsonConverter` and describes itself, as both decimal converters do.",
+    "oracle": "claim",
+    "surfaces": [
+      "IDescribedJsonConverter.*",
+      "JsonSchemaDescriptions.*",
+      "JsonSchemaDescription.*"
+    ],
+    "heldBy": [
+      "DescribedSchemaTests"
+    ]
+  },
+  {
+    "id": "C12-parameter-keeps-aspnet",
+    "source": "docs/json.md#describing-what-a-converter-writes",
+    "quote": "So it keeps the description ASP.NET gives the type without your converters",
+    "claim": "So it keeps the description ASP.NET gives the type without your converters",
+    "oracle": "claim",
+    "surfaces": [
+      "IDescribedJsonConverter.*",
+      "JsonSchemaDescriptions.*",
+      "JsonSchemaDescription.*"
+    ],
+    "heldBy": [
+      "DescribedSchemaTests"
+    ]
+  },
+  {
+    "id": "C13-absent-is-default",
+    "source": "docs/merge-patches.md#required-constructor-parameters",
+    "quote": "a property the request leaves out keeps its default, which is `Absent`.",
+    "claim": "a property the request leaves out keeps its default, which is `Absent`.",
+    "oracle": "claim",
+    "surfaces": [
+      "PatchJsonConverterFactory.*",
+      "PatchState.*"
+    ],
+    "heldBy": [
+      "PatchSchemaTests"
+    ]
+  },
+  {
+    "id": "C13-doc-optional-where-absent",
+    "source": "docs/merge-patches.md#required-constructor-parameters",
+    "quote": "`AddTypeKit()` leaves a patch out of `required` where the serializer lets it be absent, and keeps it there where the options reject a body without it.",
+    "claim": "`AddTypeKit()` leaves a patch out of `required` where the serializer lets it be absent, and keeps it there where the options reject a body without it.",
+    "oracle": "claim",
+    "surfaces": [
+      "PatchJsonConverterFactory.*",
+      "PatchState.*"
+    ],
+    "heldBy": [
+      "PatchSchemaTests"
+    ]
+  },
+  {
+    "id": "C13-doc-required-where-rejected",
+    "source": "docs/merge-patches.md#required-constructor-parameters",
+    "quote": "So the document never calls a field optional when the endpoint rejects a request without it.",
+    "claim": "So the document never calls a field optional when the endpoint rejects a request without it.",
+    "oracle": "claim",
+    "surfaces": [
+      "PatchJsonConverterFactory.*",
+      "PatchState.*"
+    ],
+    "heldBy": [
+      "PatchSchemaTests"
+    ]
+  },
+  {
+    "id": "C14-application-json-declared",
+    "source": "CHANGELOG.md",
+    "quote": "OpenAPI: a problem response an endpoint declares as `application/json`, such as `Produces<ProblemDetails>(404)` or `[ProducesResponseType<ProblemDetails>(404)]`, describes `fault` and `rule` and names its problem types, and keeps its media type",
+    "claim": "OpenAPI: a problem response an endpoint declares as `application/json`, such as `Produces<ProblemDetails>(404)` or `[ProducesResponseType<ProblemDetails>(404)]`, describes `fault` and `rule` and names its problem types, and keeps its media type",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultProblem.*",
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit"
+    ],
+    "heldBy": [
+      "FaultResponseTests"
+    ]
+  },
+  {
+    "id": "C14-ascending-with-declared",
+    "source": "CHANGELOG.md",
+    "quote": "OpenAPI: an operation with fault responses lists every status ascending, the ones its endpoint declares itself among them",
+    "claim": "OpenAPI: an operation with fault responses lists every status ascending, the ones its endpoint declares itself among them",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultProblem.*",
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit"
+    ],
+    "heldBy": [
+      "FaultResponseTests"
+    ]
+  },
+  {
+    "id": "C14-declared-describes-fault",
+    "source": "CHANGELOG.md",
+    "quote": "OpenAPI: a problem response an endpoint declares itself (`ProducesProblem`, `[ProducesResponseType]`) describes `fault`, and names its problem types.",
+    "claim": "OpenAPI: a problem response an endpoint declares itself (`ProducesProblem`, `[ProducesResponseType]`) describes `fault`, and names its problem types.",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultProblem.*",
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit"
+    ],
+    "heldBy": [
+      "FaultResponseTests"
+    ]
+  },
+  {
+    "id": "C15-builder-reaches-doc",
+    "source": "CHANGELOG.md",
+    "quote": "OpenAPI: a `WithFaultStatus` on the builder `MapControllers()` returns reaches the document, as it reached the response.",
+    "claim": "OpenAPI: a `WithFaultStatus` on the builder `MapControllers()` returns reaches the document, as it reached the response.",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultStatusAttribute.*",
+      "TypeKitFaultStatusEndpointConventionBuilderExtensions.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "C15-status-per-scope",
+    "source": "CHANGELOG.md",
+    "quote": "`WithFaultStatus`/`[FaultStatus<T>]` per endpoint, group or controller",
+    "claim": "`WithFaultStatus`/`[FaultStatus<T>]` per endpoint, group or controller",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultStatusAttribute.*",
+      "TypeKitFaultStatusEndpointConventionBuilderExtensions.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "C15-without-faults-leaves-doc",
+    "source": "CHANGELOG.md",
+    "quote": "**`WithoutFaults`** and `[WithoutFaults<T>]`: a route leaves out of its document the members it never answers with, and reporting one throws",
+    "claim": "**`WithoutFaults`** and `[WithoutFaults<T>]`: a route leaves out of its document the members it never answers with, and reporting one throws",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultStatusAttribute.*",
+      "TypeKitFaultStatusEndpointConventionBuilderExtensions.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "C16-differing-refused",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says",
+    "quote": "Otherwise building the document fails rather than describe JSON the controllers don't write.",
+    "claim": "Otherwise building the document fails rather than describe JSON the controllers don't write.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "C16-error-names-type-and-descriptions",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says",
+    "quote": "The error names the type and what each set of options says of it, also for a type held only inside a patch.",
+    "claim": "The error names the type and what each set of options says of it, also for a type held only inside a patch.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "C16-same-converters-build",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says",
+    "quote": "A host with controllers registers the same converters and descriptions on both, in the same order.",
+    "claim": "A host with controllers registers the same converters and descriptions on both, in the same order.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "C17-a-cast-naming-no-member",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0014",
+    "quote": "A `FaultKind` or a `ConstructorAccessibility` that names no member: a cast",
+    "claim": "A `FaultKind` or a `ConstructorAccessibility` that names no member: a cast",
+    "oracle": "exception",
+    "surfaces": [
+      "FaultKind.*",
+      "ConstructorAccessibility.*",
+      "RequireParameterlessConstructorAttribute.*"
+    ],
+    "heldBy": [
+      "UndefinedEnumValueAnalyzerTests"
+    ]
+  },
+  {
+    "id": "C17-a-member-is-silent",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0014",
+    "quote": "public static readonly ImportFault Duplicate = new(FaultKind.Conflict);",
+    "claim": "public static readonly ImportFault Duplicate = new(FaultKind.Conflict);",
+    "oracle": "exception",
+    "surfaces": [
+      "FaultKind.*",
+      "ConstructorAccessibility.*",
+      "RequireParameterlessConstructorAttribute.*"
+    ],
+    "heldBy": [
+      "UndefinedEnumValueAnalyzerTests"
+    ]
+  },
+  {
+    "id": "C17-constructor-accessibility-too",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0014",
+    "quote": "[RequireParameterlessConstructor((ConstructorAccessibility)7)] // CMTK0014: no member, read as public",
+    "claim": "[RequireParameterlessConstructor((ConstructorAccessibility)7)] // CMTK0014: no member, read as public",
+    "oracle": "exception",
+    "surfaces": [
+      "FaultKind.*",
+      "ConstructorAccessibility.*",
+      "RequireParameterlessConstructorAttribute.*"
+    ],
+    "heldBy": [
+      "UndefinedEnumValueAnalyzerTests"
+    ]
+  },
+  {
+    "id": "C17-default-and-zero",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0014",
+    "quote": "`default(FaultKind)`, a zero",
+    "claim": "`default(FaultKind)`, a zero",
+    "oracle": "exception",
+    "surfaces": [
+      "FaultKind.*",
+      "ConstructorAccessibility.*",
+      "RequireParameterlessConstructorAttribute.*"
+    ],
+    "heldBy": [
+      "UndefinedEnumValueAnalyzerTests"
+    ]
+  },
+  {
+    "id": "C17-reported-where-written",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0014",
+    "quote": "Both are reported where the value is written:",
+    "claim": "Both are reported where the value is written:",
+    "oracle": "exception",
+    "surfaces": [
+      "FaultKind.*",
+      "ConstructorAccessibility.*",
+      "RequireParameterlessConstructorAttribute.*"
+    ],
+    "heldBy": [
+      "UndefinedEnumValueAnalyzerTests"
+    ]
+  },
+  {
+    "id": "C18-a-warning-and-generated",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#build-errors",
+    "quote": "A warning, and the value object is generated.",
+    "claim": "A warning, and the value object is generated.",
+    "oracle": "exception",
+    "surfaces": [
+      "IValueObject.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "C18-generated-equality-never-calls-the-base",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#build-errors",
+    "quote": "Over a base record, the generated `Equals(TSelf)` and `GetHashCode()` compare the underlying value alone, and never call the base's.",
+    "claim": "Over a base record, the generated `Equals(TSelf)` and `GetHashCode()` compare the underlying value alone, and never call the base's.",
+    "oracle": "exception",
+    "surfaces": [
+      "IValueObject.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "C18-names-each-base-member",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#build-errors",
+    "quote": "So a hand-written `Equals(TBase)`, `GetHashCode()` or `IEquatable<TBase>.Equals` on a base record isn't used, and a warning names it (CMTK1023).",
+    "claim": "So a hand-written `Equals(TBase)`, `GetHashCode()` or `IEquatable<TBase>.Equals` on a base record isn't used, and a warning names it (CMTK1023).",
+    "oracle": "exception",
+    "surfaces": [
+      "IValueObject.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "C19-a-pair-once-at-the-later-argument",
+    "source": "docs/type-constraints.md#the-kind-of-a-type-argument",
+    "quote": "A breach is reported once, at the later argument.",
+    "claim": "A breach is reported once, at the later argument.",
+    "oracle": "exception",
+    "surfaces": [
+      "InterfaceAttribute.*",
+      "UnsealedAttribute.*",
+      "ValueObjectAttribute.*",
+      "FlagsEnumAttribute.*",
+      "ReadOnlyStructAttribute.*",
+      "SealedAttribute.*",
+      "RecordAttribute.*",
+      "UnrelatedAttribute.*"
+    ],
+    "heldBy": [
+      "TypeArgumentConstraintKindTests"
+    ]
+  },
+  {
+    "id": "C19-flags-enum-and-read-only-struct",
+    "source": "docs/type-constraints.md#the-kind-of-a-type-argument",
+    "quote": "**`[FlagsEnum]` and `[ReadOnlyStruct]`** narrow what `where T : Enum` and `where T : struct` admit.",
+    "claim": "**`[FlagsEnum]` and `[ReadOnlyStruct]`** narrow what `where T : Enum` and `where T : struct` admit.",
+    "oracle": "exception",
+    "surfaces": [
+      "InterfaceAttribute.*",
+      "UnsealedAttribute.*",
+      "ValueObjectAttribute.*",
+      "FlagsEnumAttribute.*",
+      "ReadOnlyStructAttribute.*",
+      "SealedAttribute.*",
+      "RecordAttribute.*",
+      "UnrelatedAttribute.*"
+    ],
+    "heldBy": [
+      "TypeArgumentConstraintKindTests"
+    ]
+  },
+  {
+    "id": "C19-interface-and-unsealed",
+    "source": "docs/type-constraints.md#the-kind-of-a-type-argument",
+    "quote": "**`[Interface]` and `[Unsealed]`** are what a proxy needs: a contract to implement, or a class to derive from.",
+    "claim": "**`[Interface]` and `[Unsealed]`** are what a proxy needs: a contract to implement, or a class to derive from.",
+    "oracle": "exception",
+    "surfaces": [
+      "InterfaceAttribute.*",
+      "UnsealedAttribute.*",
+      "ValueObjectAttribute.*",
+      "FlagsEnumAttribute.*",
+      "ReadOnlyStructAttribute.*",
+      "SealedAttribute.*",
+      "RecordAttribute.*",
+      "UnrelatedAttribute.*"
+    ],
+    "heldBy": [
+      "TypeArgumentConstraintKindTests"
+    ]
+  },
+  {
+    "id": "C19-methods-the-compiler-calls",
+    "source": "docs/type-constraints.md#the-kind-of-a-type-argument",
+    "quote": "**Methods the compiler calls for you:** a `foreach`'s `GetEnumerator`, an `await`'s `GetAwaiter`, a `Deconstruct` (in `var (a, b) = x`, a `foreach`, or a pattern like `x is (1, 2)`), and a collection expression's `Add` or builder method.",
+    "claim": "**Methods the compiler calls for you:** a `foreach`'s `GetEnumerator`, an `await`'s `GetAwaiter`, a `Deconstruct` (in `var (a, b) = x`, a `foreach`, or a pattern like `x is (1, 2)`), and a collection expression's `Add` or builder method.",
+    "oracle": "exception",
+    "surfaces": [
+      "InterfaceAttribute.*",
+      "UnsealedAttribute.*",
+      "ValueObjectAttribute.*",
+      "FlagsEnumAttribute.*",
+      "ReadOnlyStructAttribute.*",
+      "SealedAttribute.*",
+      "RecordAttribute.*",
+      "UnrelatedAttribute.*"
+    ],
+    "heldBy": [
+      "TypeArgumentConstraintKindTests"
+    ]
+  },
+  {
+    "id": "C19-value-object-and-closed-set",
+    "source": "docs/type-constraints.md#the-kind-of-a-type-argument",
+    "quote": "**`[ValueObject]` and `[ClosedSet]`** accept their marker interface with any type argument.",
+    "claim": "**`[ValueObject]` and `[ClosedSet]`** accept their marker interface with any type argument.",
+    "oracle": "exception",
+    "surfaces": [
+      "InterfaceAttribute.*",
+      "UnsealedAttribute.*",
+      "ValueObjectAttribute.*",
+      "FlagsEnumAttribute.*",
+      "ReadOnlyStructAttribute.*",
+      "SealedAttribute.*",
+      "RecordAttribute.*",
+      "UnrelatedAttribute.*"
+    ],
+    "heldBy": [
+      "TypeArgumentConstraintKindTests"
+    ]
+  },
+  {
+    "id": "C20-a-failure-says-the-outcome",
+    "source": "src/CodoMetis.TypeKit.Testing/README.md",
+    "quote": "**A failure says what the outcome was**",
+    "claim": "**A failure says what the outcome was**",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultAssertions.*"
+    ],
+    "heldBy": [
+      "ComposedFaultAssertionTests"
+    ]
+  },
+  {
+    "id": "C20-fails-unless-it-holds-that-reason",
+    "source": "src/CodoMetis.TypeKit.Testing/README.md",
+    "quote": "`ShouldHold(reason)` fails unless the fault holds that reason, whichever of its types the reason belongs to.",
+    "claim": "`ShouldHold(reason)` fails unless the fault holds that reason, whichever of its types the reason belongs to.",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultAssertions.*"
+    ],
+    "heldBy": [
+      "ComposedFaultAssertionTests"
+    ]
+  },
+  {
+    "id": "C20-hands-back-detail-and-rule",
+    "source": "src/CodoMetis.TypeKit.Testing/README.md",
+    "quote": "It hands back the `Fault<TFault>` with its detail and rule intact.",
+    "claim": "It hands back the `Fault<TFault>` with its detail and rule intact.",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultAssertions.*"
+    ],
+    "heldBy": [
+      "ComposedFaultAssertionTests"
+    ]
+  },
+  {
+    "id": "C20-uninitialized-fails",
+    "source": "src/CodoMetis.TypeKit.Testing/README.md",
+    "quote": "**An uninitialized result fails every assertion.**",
+    "claim": "**An uninitialized result fails every assertion.**",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultAssertions.*"
+    ],
+    "heldBy": [
+      "ComposedFaultAssertionTests"
+    ]
+  },
+  {
+    "id": "C20-whichever-of-its-types",
+    "source": "src/CodoMetis.TypeKit.Testing/README.md",
+    "quote": "whichever of its types the reason belongs to",
+    "claim": "whichever of its types the reason belongs to",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultAssertions.*"
+    ],
+    "heldBy": [
+      "ComposedFaultAssertionTests"
+    ]
+  },
+  {
+    "id": "C21-nullable-admits-null-as-the-wrapped-does",
+    "source": "README.md#what-you-get",
+    "quote": "Its OpenAPI schema is the one ASP.NET Core publishes for the underlying type.",
+    "claim": "Its OpenAPI schema is the one ASP.NET Core publishes for the underlying type.",
+    "oracle": "differential",
+    "surfaces": [
+      "GeneratedJsonPlan.*",
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "C21-the-underlying-types-schema",
+    "source": "README.md#what-you-get",
+    "quote": "The JSON, the database column and the OpenAPI schema are the same as the underlying type's.",
+    "claim": "The JSON, the database column and the OpenAPI schema are the same as the underlying type's.",
+    "oracle": "differential",
+    "surfaces": [
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit",
+      "GeneratedJsonPlan.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "C22-abstract",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#build-errors",
+    "quote": "An abstract type with a value-object marker. It would get no member, and a value held as it, of a type derived from it, would have no `Value` and be written as `{}`.",
+    "claim": "An abstract type with a value-object marker. It would get no member, and a value held as it, of a type derived from it, would have no `Value` and be written as `{}`.",
+    "oracle": "exception",
+    "surfaces": [
+      "IPlainValueObject.*",
+      "IValidatedValue.*",
+      "IClosedSet.*"
+    ],
+    "heldBy": [
+      "BuildOutcomeTests"
+    ]
+  },
+  {
+    "id": "C22-closed-set-named-as-generated-member",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#build-errors",
+    "quote": "a set itself named as one of them (a member can't have the name of its type)",
+    "claim": "a set itself named as one of them (a member can't have the name of its type)",
+    "oracle": "exception",
+    "surfaces": [
+      "IPlainValueObject.*",
+      "IValidatedValue.*",
+      "IClosedSet.*"
+    ],
+    "heldBy": [
+      "BuildOutcomeTests"
+    ]
+  },
+  {
+    "id": "C22-equality-operator",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#build-errors",
+    "quote": "So a hand-written `Equals(TSelf)`, `GetHashCode()`, `IEquatable<TSelf>.Equals`, or `operator ==` or `!=` between two of the type, fails the build (CMTK1011).",
+    "claim": "So a hand-written `Equals(TSelf)`, `GetHashCode()`, `IEquatable<TSelf>.Equals`, or `operator ==` or `!=` between two of the type, fails the build (CMTK1011).",
+    "oracle": "exception",
+    "surfaces": [
+      "IPlainValueObject.*",
+      "IValidatedValue.*",
+      "IClosedSet.*"
+    ],
+    "heldBy": [
+      "BuildOutcomeTests"
+    ]
+  },
+  {
+    "id": "C22-every-error-links-the-table",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#build-errors",
+    "quote": "Every error ends with a link to this table.",
+    "claim": "Every error ends with a link to this table.",
+    "oracle": "exception",
+    "surfaces": [
+      "IPlainValueObject.*",
+      "IValidatedValue.*",
+      "IClosedSet.*"
+    ],
+    "heldBy": [
+      "BuildOutcomeTests"
+    ]
+  },
+  {
+    "id": "C22-generic-wrapped",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#build-errors",
+    "quote": "A generic underlying type, a tuple included, fails the build (CMTK1005).",
+    "claim": "A generic underlying type, a tuple included, fails the build (CMTK1005).",
+    "oracle": "exception",
+    "surfaces": [
+      "IPlainValueObject.*",
+      "IValidatedValue.*",
+      "IClosedSet.*"
+    ],
+    "heldBy": [
+      "BuildOutcomeTests"
+    ]
+  },
+  {
+    "id": "C22-named-as-generated-member",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#build-errors",
+    "quote": "named `Value` or as another member the generators add (`From`, `TryFrom`, `FromKnownGood`, `Revalidate`, `Parse`, `TryParse`, `TryFormat`, `MinValue`, `MaxValue`, `CompareTo`)",
+    "claim": "named `Value` or as another member the generators add (`From`, `TryFrom`, `FromKnownGood`, `Revalidate`, `Parse`, `TryParse`, `TryFormat`, `MinValue`, `MaxValue`, `CompareTo`)",
+    "oracle": "exception",
+    "surfaces": [
+      "IPlainValueObject.*",
+      "IValidatedValue.*",
+      "IClosedSet.*"
+    ],
+    "heldBy": [
+      "BuildOutcomeTests"
+    ]
+  },
+  {
+    "id": "C22-no-type-half-generated",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#build-errors",
+    "quote": "A declaration that can't be generated fails the build, so no type is left half-generated.",
+    "claim": "A declaration that can't be generated fails the build, so no type is left half-generated.",
+    "oracle": "exception",
+    "surfaces": [
+      "IPlainValueObject.*",
+      "IValidatedValue.*",
+      "IClosedSet.*"
+    ],
+    "heldBy": [
+      "BuildOutcomeTests"
+    ]
+  },
+  {
+    "id": "C22-over-object",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#build-errors",
+    "quote": "or wrapping `object`, `System.Enum`, an array, a pointer, a nullable type, a generic type (a tuple included) or a value object (itself included).",
+    "claim": "or wrapping `object`, `System.Enum`, an array, a pointer, a nullable type, a generic type (a tuple included) or a value object (itself included).",
+    "oracle": "exception",
+    "surfaces": [
+      "IClosedSet.*",
+      "IPlainValueObject.*",
+      "IValidatedValue.*"
+    ],
+    "heldBy": [
+      "BuildOutcomeTests"
+    ]
+  },
+  {
+    "id": "C22-over-value-object",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#build-errors",
+    "quote": "or a value object (itself included). Wrap what the other value object wraps instead.",
+    "claim": "or a value object (itself included). Wrap what the other value object wraps instead.",
+    "oracle": "exception",
+    "surfaces": [
+      "IPlainValueObject.*",
+      "IValidatedValue.*",
+      "IClosedSet.*"
+    ],
+    "heldBy": [
+      "BuildOutcomeTests"
+    ]
+  },
+  {
+    "id": "C22-unsealed-record-class",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#build-errors",
+    "quote": "A record class not declared `sealed`.",
+    "claim": "A record class not declared `sealed`.",
+    "oracle": "exception",
+    "surfaces": [
+      "IPlainValueObject.*",
+      "IValidatedValue.*",
+      "IClosedSet.*"
+    ],
+    "heldBy": [
+      "BuildOutcomeTests"
+    ]
+  },
+  {
+    "id": "C23-withheld-host-sees",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#faults-a-client-must-not-tell-apart",
+    "quote": "**Your host still sees the fault.** `IFaultFeature` carries its name, and `NameWithheld` says the mapping keeps it from the client",
+    "claim": "**Your host still sees the fault.** `IFaultFeature` carries its name, and `NameWithheld` says the mapping keeps it from the client",
+    "oracle": "claim",
+    "surfaces": [
+      "IFaultFeature.*"
+    ],
+    "heldBy": [
+      "WithheldFaultNameTests"
+    ]
+  },
+  {
+    "id": "C23-withheld-says-nothing",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#faults-a-client-must-not-tell-apart",
+    "quote": "**The problem says nothing of the member**: no `fault`, no `rule`, and no fault set member's description as its `detail`.",
+    "claim": "**The problem says nothing of the member**: no `fault`, no `rule`, and no fault set member's description as its `detail`.",
+    "oracle": "claim",
+    "surfaces": [
+      "FaultResponse.*"
+    ],
+    "heldBy": [
+      "WithheldFaultNameTests"
+    ]
+  },
+  {
+    "id": "C24-content-comes-back",
+    "source": "src/CodoMetis.TypeKit.Testing/README.md",
+    "quote": "**The content comes back.** `ShouldBeSome()`, `ShouldBeSuccess()`, `ShouldBeError()` and `ShouldBeValue()` return the value or the error.",
+    "claim": "**The content comes back.** `ShouldBeSome()`, `ShouldBeSuccess()`, `ShouldBeError()` and `ShouldBeValue()` return the value or the error.",
+    "oracle": "claim",
+    "surfaces": [
+      "OptionAssertions.*",
+      "ResultAssertions.*",
+      "PatchAssertions.*"
+    ],
+    "heldBy": [
+      "AssertionTests",
+      "PatchAssertionTests"
+    ]
+  },
+  {
+    "id": "C25-add-create-accepts-every-value",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#declare-a-value-object",
+    "quote": "It writes a `Create` that accepts every value, ready for your rules:",
+    "claim": "It writes a `Create` that accepts every value, ready for your rules:",
+    "oracle": "claim",
+    "surfaces": [
+      "IValidatedValue.Create"
+    ],
+    "heldBy": [
+      "MissingCreateCodeFixTests",
+      "AddCreateTests"
+    ]
+  },
+  {
+    "id": "C25-add-create-offered",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#declare-a-value-object",
+    "quote": "The build then fails because `Create` is missing (CS0535), and your editor offers a fix for that error: **Add Create**.",
+    "claim": "The build then fails because `Create` is missing (CS0535), and your editor offers a fix for that error: **Add Create**.",
+    "oracle": "claim",
+    "surfaces": [
+      "IValidatedValue.Create"
+    ],
+    "heldBy": [
+      "MissingCreateCodeFixTests"
+    ]
+  },
+  {
+    "id": "C25-create-taking-t",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#add-create",
+    "quote": "**The type already has a `Create` that takes a `T`**, static or not.",
+    "claim": "**The type already has a `Create` that takes a `T`**, static or not.",
+    "oracle": "claim",
+    "surfaces": [
+      "IValidatedValue.Create"
+    ],
+    "heldBy": [
+      "MissingCreateCodeFixTests"
+    ]
+  },
+  {
+    "id": "C25-first-member",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#add-create",
+    "quote": "`Create` goes in as the type's first member, indented as the other members are.",
+    "claim": "`Create` goes in as the type's first member, indented as the other members are.",
+    "oracle": "claim",
+    "surfaces": [
+      "IValidatedValue.Create"
+    ],
+    "heldBy": [
+      "MissingCreateCodeFixTests"
+    ]
+  },
+  {
+    "id": "C25-one-line-body",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#add-create",
+    "quote": "**The type's body is on one line and already holds members.**",
+    "claim": "**The type's body is on one line and already holds members.**",
+    "oracle": "claim",
+    "surfaces": [
+      "IValidatedValue.Create"
+    ],
+    "heldBy": [
+      "MissingCreateCodeFixTests"
+    ]
+  },
+  {
+    "id": "C25-semicolon-gets-a-body",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#add-create",
+    "quote": "A declaration that ends in `;` gets a body.",
+    "claim": "A declaration that ends in `;` gets a body.",
+    "oracle": "claim",
+    "surfaces": [
+      "IValidatedValue.Create"
+    ],
+    "heldBy": [
+      "MissingCreateCodeFixTests",
+      "MissingCreateVariantTests"
+    ]
+  },
+  {
+    "id": "C25-tself-another-type",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#add-create",
+    "quote": "**`TSelf` is another type.** The value to return isn't this type's to build.",
+    "claim": "**`TSelf` is another type.** The value to return isn't this type's to build.",
+    "oracle": "claim",
+    "surfaces": [
+      "IValidatedValue.Create"
+    ],
+    "heldBy": [
+      "MissingCreateCodeFixTests"
+    ]
+  },
+  {
+    "id": "C25-types-spelled-as-the-file-names-them",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#add-create",
+    "quote": "The types are spelled as your file names them, so a type from a namespace the file doesn't import is qualified.",
+    "claim": "The types are spelled as your file names them, so a type from a namespace the file doesn't import is qualified.",
+    "oracle": "claim",
+    "surfaces": [
+      "IValidatedValue.Create"
+    ],
+    "heldBy": [
+      "MissingCreateCodeFixTests",
+      "MissingCreateVariantTests"
+    ]
+  },
+  {
+    "id": "C26-sized-array-warns",
+    "source": "README.md#value-objects",
+    "quote": "An array created with a length, whose slots all start out as `default`, gets a warning (CMTK0005).",
+    "claim": "An array created with a length, whose slots all start out as `default`, gets a warning (CMTK0005).",
+    "oracle": "claim",
+    "surfaces": [
+      "IValueObject.*",
+      "IValidatedValue.*"
+    ],
+    "heldBy": [
+      "DefaultFilledCollectionAnalyzerTests"
+    ]
+  },
+  {
+    "id": "C26-struct-default-fails-the-build",
+    "source": "README.md#value-objects",
+    "quote": "So the analyzers make `new OrderId()` and `default(OrderId)` build errors (CMTK0001).",
+    "claim": "So the analyzers make `new OrderId()` and `default(OrderId)` build errors (CMTK0001).",
+    "oracle": "claim",
+    "surfaces": [
+      "IValueObject.*",
+      "IValidatedValue.*"
+    ],
+    "heldBy": [
+      "ForbiddenDefaultInitializationAnalyzerTests"
+    ]
+  },
+  {
+    "id": "C27-inline-every-position",
+    "source": "docs/aspnet-core.md#describe-value-objects-as-plain-types",
+    "quote": "Each one gets exactly the schema the underlying type gets in that place.",
+    "claim": "Each one gets exactly the schema the underlying type gets in that place.",
+    "oracle": "differential",
+    "surfaces": [
+      "TypeKitOpenApiOptions.*",
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit"
+    ],
+    "heldBy": [
+      "SchemaTests",
+      "NullablePositionTests"
+    ]
+  },
+  {
+    "id": "C27-inline-no-component",
+    "source": "docs/aspnet-core.md#describe-value-objects-as-plain-types",
+    "quote": "Turn on `InlineValueObjects`, and every value object is described in place by the schema of the type inside it:",
+    "claim": "Turn on `InlineValueObjects`, and every value object is described in place by the schema of the type inside it:",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitOpenApiOptions.*",
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit"
+    ],
+    "heldBy": [
+      "InlineValueObjectsSettingTests",
+      "AspNetCoreTests"
+    ]
+  },
+  {
+    "id": "C27-inline-nullable-in-2-0",
+    "source": "docs/aspnet-core.md#describe-value-objects-as-plain-types",
+    "quote": "That holds under OpenAPI 2.0 too, where a nullable property of a component loses its type.",
+    "claim": "That holds under OpenAPI 2.0 too, where a nullable property of a component loses its type.",
+    "oracle": "differential",
+    "surfaces": [
+      "TypeKitOpenApiOptions.*",
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit"
+    ],
+    "heldBy": [
+      "SchemaTests",
+      "NullablePositionTests"
+    ]
+  },
+  {
+    "id": "C27-inline-off-unchanged",
+    "source": "docs/aspnet-core.md#describe-value-objects-as-plain-types",
+    "quote": "`AddTypeKit()` writes the same document as before, with a component per value object.",
+    "claim": "`AddTypeKit()` writes the same document as before, with a component per value object.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitOpenApiOptions.*",
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit"
+    ],
+    "heldBy": [
+      "InlineValueObjectsSettingTests"
+    ]
+  },
+  {
+    "id": "C27-inline-same-name",
+    "source": "docs/aspnet-core.md#describe-value-objects-as-plain-types",
+    "quote": "Neither has a component, so neither needs a name of its own.",
+    "claim": "Neither has a component, so neither needs a name of its own.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitOpenApiOptions.*",
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit"
+    ],
+    "heldBy": [
+      "InlineValueObjectsSettingTests"
+    ]
+  },
+  {
+    "id": "E01-column-type",
+    "source": "docs/ef-core.md#the-model",
+    "quote": "Every property maps as a column of the underlying type, nullable where the property is.",
+    "claim": "Every property maps as a column of the underlying type, nullable where the property is.",
+    "oracle": "differential",
+    "surfaces": [
+      "TypeKitDbContextOptionsBuilderExtensions.UseTypeKit",
+      "ValueObjectConverter.*"
+    ],
+    "heldBy": [
+      "MappingTests"
+    ]
+  },
+  {
+    "id": "E01-facet-kept",
+    "source": "docs/ef-core.md#the-model",
+    "quote": "A facet you configure on it is kept: a precision, a length, a column type.",
+    "claim": "A facet you configure on it is kept: a precision, a length, a column type.",
+    "oracle": "differential",
+    "surfaces": [
+      "TypeKitDbContextOptionsBuilderExtensions.UseTypeKit",
+      "ValueObjectConverter.*"
+    ],
+    "heldBy": [
+      "MappingTests"
+    ]
+  },
+  {
+    "id": "E01-nullable",
+    "source": "docs/ef-core.md#the-model",
+    "quote": "nullable where the property is",
+    "claim": "nullable where the property is",
+    "oracle": "differential",
+    "surfaces": [
+      "TypeKitDbContextOptionsBuilderExtensions.UseTypeKit",
+      "ValueObjectConverter.*"
+    ],
+    "heldBy": [
+      "MappingTests"
+    ]
+  },
+  {
+    "id": "E02-column-not-cast",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
+    "quote": "A table's column is re-typed, not cast, so an index on it still serves the query.",
+    "claim": "A table's column is re-typed, not cast, so an index on it still serves the query.",
+    "oracle": "differential",
+    "surfaces": [
+      "TranslatedAsWrappedValueAttribute.*",
+      "IValueObject.Value"
+    ],
+    "heldBy": [
+      "SqlTranslationTests"
+    ]
+  },
+  {
+    "id": "E02-get-value",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
+    "quote": "db.Orders.Where(o => o.Total.GetValue() > 100m);",
+    "claim": "db.Orders.Where(o => o.Total.GetValue() > 100m);",
+    "oracle": "differential",
+    "surfaces": [
+      "TranslatedAsWrappedValueAttribute.*",
+      "IValueObject.Value"
+    ],
+    "heldBy": [
+      "SqlTranslationTests"
+    ]
+  },
+  {
+    "id": "E02-value",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
+    "quote": "`.Value`, `GetValue()` and `ValueOrNull()` translate to the column itself.",
+    "claim": "`.Value`, `GetValue()` and `ValueOrNull()` translate to the column itself.",
+    "oracle": "differential",
+    "surfaces": [
+      "TranslatedAsWrappedValueAttribute.*",
+      "IValueObject.Value"
+    ],
+    "heldBy": [
+      "SqlTranslationTests"
+    ]
+  },
+  {
+    "id": "E02-value-or-null",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
+    "quote": "Use `ValueOrNull()` for an optional value object, where `.Value` would first unwrap the `Nullable`.",
+    "claim": "Use `ValueOrNull()` for an optional value object, where `.Value` would first unwrap the `Nullable`.",
+    "oracle": "differential",
+    "surfaces": [
+      "TranslatedAsWrappedValueAttribute.*",
+      "IValueObject.Value"
+    ],
+    "heldBy": [
+      "SqlTranslationTests"
+    ]
+  },
+  {
+    "id": "E03-keys",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#what-maps",
+    "quote": "Keys, foreign keys, nullable properties, primitive collections and query parameters all map as plain columns of the underlying type.",
+    "claim": "Keys, foreign keys, nullable properties, primitive collections and query parameters all map as plain columns of the underlying type.",
+    "oracle": "metamorphic",
+    "surfaces": [
+      "ValueObjectConverter.*"
+    ],
+    "heldBy": [
+      "PostgreSqlRoundTripTests"
+    ]
+  },
+  {
+    "id": "E03-stored-as-underlying",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#what-maps",
+    "quote": "Every value object is stored in a plain column of its underlying type",
+    "claim": "Every value object is stored in a plain column of its underlying type",
+    "oracle": "metamorphic",
+    "surfaces": [
+      "ValueObjectConverter.*"
+    ],
+    "heldBy": [
+      "PostgreSqlRoundTripTests"
+    ]
+  },
+  {
+    "id": "E04-byte-not-generated",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
+    "quote": "That's EF's own list: `int`, `long`, `short`, `sbyte`, `uint`, `ulong` and `ushort`, and not `byte`.",
+    "claim": "That's EF's own list: `int`, `long`, `short`, `sbyte`, `uint`, `ulong` and `ushort`, and not `byte`.",
+    "oracle": "claim",
+    "surfaces": [
+      "WrappedTypeValueGeneratorFactory.*"
+    ],
+    "heldBy": [
+      "KeyGenerationTests"
+    ]
+  },
+  {
+    "id": "E04-char-key-yours",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
+    "quote": "A key over `char` is yours to assign.",
+    "claim": "A key over `char` is yours to assign.",
+    "oracle": "claim",
+    "surfaces": [
+      "WrappedTypeValueGeneratorFactory.*"
+    ],
+    "heldBy": [
+      "KeyGenerationTests"
+    ]
+  },
+  {
+    "id": "E04-generated-on-add",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
+    "quote": "A single-column key over an integer is generated on add, like a key of that integer type.",
+    "claim": "A single-column key over an integer is generated on add, like a key of that integer type.",
+    "oracle": "claim",
+    "surfaces": [
+      "WrappedTypeValueGeneratorFactory.*"
+    ],
+    "heldBy": [
+      "KeyGenerationTests"
+    ]
+  },
+  {
+    "id": "E04-guid-key-yours",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
+    "quote": "A key over a `Guid` is yours to assign",
+    "claim": "A key over a `Guid` is yours to assign",
+    "oracle": "claim",
+    "surfaces": [
+      "WrappedTypeValueGeneratorFactory.*"
+    ],
+    "heldBy": [
+      "KeyGenerationTests"
+    ]
+  },
+  {
+    "id": "E04-hilo-and-own-generator-first",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
+    "quote": "HiLo and a value generator of your own still come first.",
+    "claim": "HiLo and a value generator of your own still come first.",
+    "oracle": "claim",
+    "surfaces": [
+      "WrappedTypeValueGeneratorFactory.*"
+    ],
+    "heldBy": [
+      "KeyGenerationTests"
+    ]
+  },
+  {
+    "id": "E04-own-configuration-wins",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
+    "quote": "A configuration you write yourself always wins over these defaults.",
+    "claim": "A configuration you write yourself always wins over these defaults.",
+    "oracle": "claim",
+    "surfaces": [
+      "WrappedTypeValueGeneratorFactory.*"
+    ],
+    "heldBy": [
+      "KeyGenerationTests"
+    ]
+  },
+  {
+    "id": "E04-temporary-as-plain",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
+    "quote": "At `Add`, a key that is generated gets the same temporary value a plain key of the underlying type gets, also where the column is of another type, such as the `decimal` that holds a `ulong`.",
+    "claim": "At `Add`, a key that is generated gets the same temporary value a plain key of the underlying type gets, also where the column is of another type, such as the `decimal` that holds a `ulong`.",
+    "oracle": "claim",
+    "surfaces": [
+      "WrappedTypeValueGeneratorFactory.*"
+    ],
+    "heldBy": [
+      "KeyGenerationTests",
+      "KeyGenerationVariantTests"
+    ]
+  },
+  {
+    "id": "E04-ulong-key-native-aot",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
+    "quote": "Otherwise the key gets a temporary `ulong`, as a plain one does.",
+    "claim": "A default key over `ulong` throws at `Add` where the column is a `decimal` in a compiled model made with `--nativeaot` and where `ValueObjectConverter` is configured by hand; otherwise it gets a temporary `ulong`, as a plain one does.",
+    "oracle": "claim",
+    "surfaces": [
+      "WrappedTypeValueGeneratorFactory.*"
+    ],
+    "heldBy": [
+      "KeyGenerationTests"
+    ]
+  },
+  {
+    "id": "E05-comparison",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
+    "quote": "a comparison (`<`, `>`, `<=`, `>=`, `CompareTo`);",
+    "claim": "a comparison (`<`, `>`, `<=`, `>=`, `CompareTo`);",
+    "oracle": "exception",
+    "surfaces": [
+      "HandWrittenOrderingAttribute.*"
+    ],
+    "heldBy": [
+      "HandWrittenOrderingTests"
+    ]
+  },
+  {
+    "id": "E05-equality-allowed",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
+    "quote": "Equality isn't ordering, and stays allowed.",
+    "claim": "Equality isn't ordering, and stays allowed.",
+    "oracle": "exception",
+    "surfaces": [
+      "HandWrittenOrderingAttribute.*"
+    ],
+    "heldBy": [
+      "HandWrittenOrderingTests"
+    ]
+  },
+  {
+    "id": "E05-ordering",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
+    "quote": "an ordering (`OrderBy`, `ThenBy`, their descending forms, `Order`);",
+    "claim": "an ordering (`OrderBy`, `ThenBy`, their descending forms, `Order`);",
+    "oracle": "exception",
+    "surfaces": [
+      "HandWrittenOrderingAttribute.*"
+    ],
+    "heldBy": [
+      "HandWrittenOrderingTests"
+    ]
+  },
+  {
+    "id": "E05-query-filter",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
+    "quote": "A query filter (`HasQueryFilter`, named or not) that does the same fails when the model is built, naming the entity type, since it applies to every query of that type.",
+    "claim": "A query filter (`HasQueryFilter`, named or not) that does the same fails when the model is built, naming the entity type, since it applies to every query of that type.",
+    "oracle": "exception",
+    "surfaces": [
+      "HandWrittenOrderingAttribute.*"
+    ],
+    "heldBy": [
+      "HandWrittenOrderingTests"
+    ]
+  },
+  {
+    "id": "E05-value-order-allowed",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
+    "quote": "Compare or order by `.Value` where the underlying value's order is what you mean",
+    "claim": "Compare or order by `.Value` where the underlying value's order is what you mean",
+    "oracle": "exception",
+    "surfaces": [
+      "HandWrittenOrderingAttribute.*"
+    ],
+    "heldBy": [
+      "HandWrittenOrderingTests"
+    ]
+  },
+  {
+    "id": "E06-value-not-translated",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
+    "quote": "So a filter, a sort, a grouping or an aggregate that reads `.Value` there fails with EF's \"could not be translated\", rather than comparing against what the column really holds.",
+    "claim": "So a filter, a sort, a grouping or an aggregate that reads `.Value` there fails with EF's \"could not be translated\", rather than comparing against what the column really holds.",
+    "oracle": "exception",
+    "surfaces": [
+      "ValueObjectConverter.*"
+    ],
+    "heldBy": [
+      "ForeignConverterTests"
+    ]
+  },
+  {
+    "id": "E06-value-object-comparison",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
+    "quote": "Comparing the value object itself (`o.Code == code`) goes through that converter and still works.",
+    "claim": "Comparing the value object itself (`o.Code == code`) goes through that converter and still works.",
+    "oracle": "exception",
+    "surfaces": [
+      "ValueObjectConverter.*"
+    ],
+    "heldBy": [
+      "ForeignConverterTests"
+    ]
+  },
+  {
+    "id": "E07-in-collections-and-json",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#closed-sets",
+    "quote": "That holds in a table, in a primitive collection of names (`text[]` on PostgreSQL, a JSON array elsewhere) and in a JSON column alike, with nothing registered per set.",
+    "claim": "That holds in a table, in a primitive collection of names (`text[]` on PostgreSQL, a JSON array elsewhere) and in a JSON column alike, with nothing registered per set.",
+    "oracle": "claim",
+    "surfaces": [
+      "ClosedSetConverter.*"
+    ],
+    "heldBy": [
+      "ClosedSetMappingTests"
+    ]
+  },
+  {
+    "id": "E07-non-member-throws",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#closed-sets",
+    "quote": "An instance that isn't a member throws when it's written.",
+    "claim": "An instance that isn't a member throws when it's written.",
+    "oracle": "claim",
+    "surfaces": [
+      "ClosedSetConverter.*"
+    ],
+    "heldBy": [
+      "ClosedSetMappingTests"
+    ]
+  },
+  {
+    "id": "E07-stored-as-name",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#closed-sets",
+    "quote": "A closed set (`IClosedSet<TSelf>`) is stored as a text column of the member's name, and read back as the member itself.",
+    "claim": "A closed set (`IClosedSet<TSelf>`) is stored as a text column of the member's name, and read back as the member itself.",
+    "oracle": "claim",
+    "surfaces": [
+      "ClosedSetConverter.*"
+    ],
+    "heldBy": [
+      "ClosedSetMappingTests"
+    ]
+  },
+  {
+    "id": "E07-unknown-name-throws",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#closed-sets",
+    "quote": "A name the set no longer has throws when it's read, rather than reading as null.",
+    "claim": "A name the set no longer has throws when it's read, rather than reading as null.",
+    "oracle": "claim",
+    "surfaces": [
+      "ClosedSetConverter.*"
+    ],
+    "heldBy": [
+      "ClosedSetMappingTests"
+    ]
+  },
+  {
+    "id": "E08-error-says-so",
+    "source": "docs/ef-core.md#option-and-result",
+    "quote": "building the model fails with an error that says so",
+    "claim": "building the model fails with an error that says so",
+    "oracle": "exception",
+    "surfaces": [
+      "TypeKitDbContextOptionsBuilderExtensions.UseTypeKit"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "E08-model-fails",
+    "source": "docs/ef-core.md#option-and-result",
+    "quote": "EF can't map an `Option` or a `Result` property",
+    "claim": "EF can't map an `Option` or a `Result` property",
+    "oracle": "exception",
+    "surfaces": [
+      "TypeKitDbContextOptionsBuilderExtensions.UseTypeKit"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "E09-element-at-skips",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#an-option-for-nothing-found",
+    "quote": "skips to its row: `OFFSET @p`.",
+    "claim": "skips to its row: `OFFSET @p`.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitQueryableExtensions.*",
+      "Option.FirstOrNone",
+      "Option.SingleOrNone"
+    ],
+    "heldBy": [
+      "QueryOptionTests"
+    ]
+  },
+  {
+    "id": "E09-first-reads-one-row",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#an-option-for-nothing-found",
+    "quote": "read one row: `WHERE ... LIMIT @p`.",
+    "claim": "read one row: `WHERE ... LIMIT @p`.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitQueryableExtensions.*",
+      "Option.FirstOrNone",
+      "Option.SingleOrNone"
+    ],
+    "heldBy": [
+      "QueryOptionTests"
+    ]
+  },
+  {
+    "id": "E09-single-asks-for-two",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#an-option-for-nothing-found",
+    "quote": "ask for two rows, and throw for more than one.",
+    "claim": "ask for two rows, and throw for more than one.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitQueryableExtensions.*",
+      "Option.FirstOrNone",
+      "Option.SingleOrNone"
+    ],
+    "heldBy": [
+      "QueryOptionTests"
+    ]
+  },
+  {
+    "id": "E10-reads-without-create",
+    "source": "docs/ef-core.md#reading-back-without-validation",
+    "quote": "EF reads a column back without validation, through the value object's `Materialize` rather than `Create`.",
+    "claim": "EF reads a column back without validation, through the value object's `Materialize` rather than `Create`.",
+    "oracle": "claim",
+    "surfaces": [
+      "IValueObjectMaterializer.*",
+      "ValueObjectConverter.Materialize"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "E10-revalidate-finds",
+    "source": "docs/ef-core.md#reading-back-without-validation",
+    "quote": "`Revalidate()` finds the rows that today's rules reject, as above.",
+    "claim": "`Revalidate()` finds the rows that today's rules reject, as above.",
+    "oracle": "claim",
+    "surfaces": [
+      "IValueObjectMaterializer.*",
+      "ValueObjectConverter.Materialize"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "E11-order-does-not-matter",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#setup",
+    "quote": "it doesn't matter whether you call it before or after `UseNpgsql` or `UseSqlite`",
+    "claim": "it doesn't matter whether you call it before or after `UseNpgsql` or `UseSqlite`",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitDbContextOptionsBuilderExtensions.UseTypeKit"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "E12-underlying-type-does-not-reach",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#model-wide-conventions-follow-the-propertys-type",
+    "quote": "So `configurationBuilder.Properties<decimal>().HavePrecision(18, 2)` reaches `decimal` properties, and not an `Amount` that wraps one.",
+    "claim": "So `configurationBuilder.Properties<decimal>().HavePrecision(18, 2)` reaches `decimal` properties, and not an `Amount` that wraps one.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitDbContextOptionsBuilderExtensions.UseTypeKit"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "E12-value-object-type-reaches",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#model-wide-conventions-follow-the-propertys-type",
+    "quote": "Configure the value object instead: `configurationBuilder.Properties<Amount>().HavePrecision(18, 2)`.",
+    "claim": "Configure the value object instead: `configurationBuilder.Properties<Amount>().HavePrecision(18, 2)`.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitDbContextOptionsBuilderExtensions.UseTypeKit"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "E13-contains",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
+    "quote": "db.Orders.Where(o => o.Tags.Contains(tag));",
+    "claim": "db.Orders.Where(o => o.Tags.Contains(tag));",
+    "oracle": "claim",
+    "surfaces": [
+      "ValueObjectConverter.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "E13-element-value",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
+    "quote": "db.Orders.Where(o => o.Tags.Any(t => t.Value == \"x\"));",
+    "claim": "db.Orders.Where(o => o.Tags.Any(t => t.Value == \"x\"));",
+    "oracle": "claim",
+    "surfaces": [
+      "ValueObjectConverter.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "E14-tpc-assign-on-sqlite",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
+    "quote": "SQLite has no such sequence, so there you assign it.",
+    "claim": "SQLite has no such sequence, so there you assign it.",
+    "oracle": "claim",
+    "surfaces": [
+      "WrappedTypeValueGeneratorFactory.*"
+    ],
+    "heldBy": [
+      "KeyGenerationTests"
+    ]
+  },
+  {
+    "id": "E14-tph-tpt-root",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
+    "quote": "The root of an inheritance hierarchy follows the same rules under TPH and TPT.",
+    "claim": "The root of an inheritance hierarchy follows the same rules under TPH and TPT.",
+    "oracle": "claim",
+    "surfaces": [
+      "WrappedTypeValueGeneratorFactory.*"
+    ],
+    "heldBy": [
+      "KeyGenerationTests"
+    ]
+  },
+  {
+    "id": "E15-as-for-primitives",
+    "source": "docs/ef-core.md#keys",
+    "quote": "A composite key of value objects is `HasKey(x => new { x.Order, x.Line })`, as for primitives.",
+    "claim": "A composite key of value objects is `HasKey(x => new { x.Order, x.Line })`, as for primitives.",
+    "oracle": "claim",
+    "surfaces": [
+      "WrappedTypeValueGeneratorFactory.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "E16-column-type",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
+    "quote": "A facet you configure on the property, such as a maximum length or a column type, is kept.",
+    "claim": "A facet you configure on the property, such as a maximum length or a column type, is kept.",
+    "oracle": "claim",
+    "surfaces": [
+      "WrappedTypeValueGeneratorFactory.*"
+    ],
+    "heldBy": [
+      "KeyGenerationTests"
+    ]
+  },
+  {
+    "id": "E17-as-the-underlying-type",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#on-sql-server",
+    "quote": "A value object behaves on SQL Server as the type inside it does there.",
+    "claim": "A value object behaves on SQL Server as the type inside it does there.",
+    "oracle": "differential",
+    "surfaces": [
+      "TranslatedAsWrappedValueAttribute.*",
+      "IValueObject.Value"
+    ],
+    "heldBy": [
+      "SqlServerQueryVariantTests",
+      "SqlServerKeyVariantTests",
+      "SqlServerRoundTripTests"
+    ]
+  },
+  {
+    "id": "E17-datetime-kind",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#on-sql-server",
+    "quote": "`datetime2` keeps every tick, and a UTC value reads back with `Kind` `Unspecified`.",
+    "claim": "`datetime2` keeps every tick, and a UTC value reads back with `Kind` `Unspecified`.",
+    "oracle": "metamorphic",
+    "surfaces": [
+      "ValueObjectConverter.*"
+    ],
+    "heldBy": [
+      "SqlServerRoundTripTests"
+    ]
+  },
+  {
+    "id": "E17-decimal-scale",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#on-sql-server",
+    "quote": "`10m` comes back as `10.00m`, which is equal but prints `10.00`.",
+    "claim": "`10m` comes back as `10.00m`, which is equal but prints `10.00`.",
+    "oracle": "metamorphic",
+    "surfaces": [
+      "ValueObjectConverter.*"
+    ],
+    "heldBy": [
+      "SqlServerRoundTripTests",
+      "SqlServerQueryVariantTests",
+      "SqlServerKeyVariantTests"
+    ]
+  },
+  {
+    "id": "E17-greatest-level-160",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#on-sql-server",
+    "quote": "`EF.Functions.Greatest` and `Least` need compatibility level 160.",
+    "claim": "`EF.Functions.Greatest` and `Least` need compatibility level 160.",
+    "oracle": "differential",
+    "surfaces": [
+      "TranslatedAsWrappedValueAttribute.*",
+      "IValueObject.Value"
+    ],
+    "heldBy": [
+      "SqlServerQueryVariantTests"
+    ]
+  },
+  {
+    "id": "E17-guid-order",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#on-sql-server",
+    "quote": "SQL Server orders a `uniqueidentifier` by its last six bytes first.",
+    "claim": "SQL Server orders a `uniqueidentifier` by its last six bytes first.",
+    "oracle": "metamorphic",
+    "surfaces": [
+      "ValueObjectConverter.*"
+    ],
+    "heldBy": [
+      "SqlServerQueryVariantTests"
+    ]
+  },
+  {
+    "id": "E17-text-ignores-case",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#on-sql-server",
+    "quote": "Under SQL Server's default collation, `o.Note == note`, `notes.Contains(o.Note)` and `StartsWith` also match text that differs in case or in trailing spaces.",
+    "claim": "Under SQL Server's default collation, `o.Note == note`, `notes.Contains(o.Note)` and `StartsWith` also match text that differs in case or in trailing spaces.",
+    "oracle": "metamorphic",
+    "surfaces": [
+      "ValueObjectConverter.*"
+    ],
+    "heldBy": [
+      "SqlServerRoundTripTests",
+      "SqlServerQueryVariantTests"
+    ]
+  },
+  {
+    "id": "E17-timespan-under-a-day",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#on-sql-server",
+    "quote": "A longer one fails `SaveChanges` in a column.",
+    "claim": "A longer one fails `SaveChanges` in a column.",
+    "oracle": "metamorphic",
+    "surfaces": [
+      "ValueObjectConverter.*"
+    ],
+    "heldBy": [
+      "SqlServerQueryVariantTests"
+    ]
+  },
+  {
+    "id": "G01-a-version-7-guid",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#declare-a-value-object",
+    "quote": "var id = OrderId.New(); // a version 7 Guid",
+    "claim": "var id = OrderId.New(); // a version 7 Guid",
+    "oracle": "claim",
+    "surfaces": [
+      "GuidValueExtensions.New"
+    ],
+    "heldBy": [
+      "GuidValueExtensionsTests"
+    ]
+  },
+  {
+    "id": "H01-any-closed-set",
+    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#a-closed-set-as-the-fault-type",
+    "quote": "**Any closed set can be an error type**, with a mapping of its own: `AddFaultResponses<TSet>(fault => ...)`. `ToHttpResult()` takes a result over either.",
+    "claim": "**Any closed set can be an error type**, with a mapping of its own: `AddFaultResponses<TSet>(fault => ...)`. `ToHttpResult()` takes a result over either.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitClosedSetHttpResultExtensions.ToHttpResult"
+    ],
+    "heldBy": [
+      "FaultSetDefaultTests",
+      "FaultResponsePartsTests"
+    ]
+  },
+  {
+    "id": "I01-mark-it",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0001",
+    "quote": "Mark it with `[RequireCustomInitialization]`, and CMTK0001, CMTK0005, CMTK0006 and CMTK0009 then treat it as they treat a value object.",
+    "claim": "Mark it with `[RequireCustomInitialization]`, and CMTK0001, CMTK0005, CMTK0006 and CMTK0009 then treat it as they treat a value object.",
+    "oracle": "claim",
+    "surfaces": [
+      "RequireCustomInitializationAttribute..ctor",
+      "RequireCustomInitializationAttribute.ErrorMessage"
+    ],
+    "heldBy": [
+      "ForbiddenDefaultInitializationAnalyzerTests",
+      "DefaultFilledCollectionAnalyzerTests",
+      "UnassignedNoDefaultMemberAnalyzerTests",
+      "DefaultProducingCallAnalyzerTests"
+    ]
+  },
+  {
+    "id": "I01-not-one-itself",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0001",
+    "quote": "Its `default` holds default value objects that no rule sees, because the rules don't look inside another struct.",
+    "claim": "Its `default` holds default value objects that no rule sees, because the rules don't look inside another struct.",
+    "oracle": "claim",
+    "surfaces": [
+      "RequireCustomInitializationAttribute..ctor",
+      "RequireCustomInitializationAttribute.ErrorMessage"
+    ],
+    "heldBy": [
+      "UnassignedNoDefaultMemberAnalyzerTests"
+    ]
+  },
+  {
+    "id": "I01-the-message-you-give",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0001",
+    "quote": "The rule reports the message you give, as `Option` and `Result` name their own factories.",
+    "claim": "The rule reports the message you give, as `Option` and `Result` name their own factories.",
+    "oracle": "claim",
+    "surfaces": [
+      "RequireCustomInitializationAttribute..ctor",
+      "RequireCustomInitializationAttribute.ErrorMessage"
+    ],
+    "heldBy": [
+      "ForbiddenDefaultInitializationAnalyzerTests"
+    ]
+  },
+  {
+    "id": "L01-read-as-the-underlying-type-reads",
+    "source": "README.md#what-typekit-guarantees",
+    "quote": "**Swapping a primitive for a value object keeps the JSON, the column and the schema.**",
+    "claim": "**Swapping a primitive for a value object keeps the JSON, the column and the schema.**",
+    "oracle": "differential",
+    "surfaces": [
+      "GeneratedJson.*",
+      "GeneratedJsonPlan.*",
+      "StoredJsonConverterFactory.*"
+    ],
+    "heldBy": [
+      "JsonParityTests"
+    ]
+  },
+  {
+    "id": "L01-the-underlying-types-json",
+    "source": "README.md#what-typekit-guarantees",
+    "quote": "Its JSON is the underlying type's under your options",
+    "claim": "Its JSON is the underlying type's under your options",
+    "oracle": "differential",
+    "surfaces": [
+      "GeneratedJson.*",
+      "GeneratedJsonPlan.*",
+      "StoredJsonConverterFactory.*"
+    ],
+    "heldBy": [
+      "JsonParityTests"
+    ]
+  },
+  {
+    "id": "L02-json-never-repeats",
+    "source": "README.md#what-typekit-guarantees",
+    "quote": "A JSON or parsing rejection names the value object and the rule, or the underlying type it could not read.",
+    "claim": "A JSON or parsing rejection names the value object and the rule, or the underlying type it could not read.",
+    "oracle": "exception",
+    "surfaces": [
+      "GeneratedParsing.*",
+      "GeneratedFactories.*"
+    ],
+    "heldBy": [
+      "UnreadableInputTests"
+    ]
+  },
+  {
+    "id": "L02-no-inner-that-quotes",
+    "source": "README.md#what-typekit-guarantees",
+    "quote": "It carries no inner exception that quotes the text.",
+    "claim": "It carries no inner exception that quotes the text.",
+    "oracle": "exception",
+    "surfaces": [
+      "GeneratedParsing.*",
+      "GeneratedFactories.*"
+    ],
+    "heldBy": [
+      "UnreadableInputTests"
+    ]
+  },
+  {
+    "id": "L02-parsing-never-repeats",
+    "source": "README.md#what-typekit-guarantees",
+    "quote": "**Rejections never repeat the input.**",
+    "claim": "**Rejections never repeat the input.**",
+    "oracle": "exception",
+    "surfaces": [
+      "GeneratedParsing.*",
+      "GeneratedFactories.*"
+    ],
+    "heldBy": [
+      "UnreadableInputTests"
+    ]
+  },
+  {
+    "id": "L03-refusals-name-the-fault",
+    "source": "README.md#what-typekit-guarantees",
+    "quote": "the `JsonException`, the `FormatException` and the `FromKnownGood` exception all name your `EmailFault.NoAt`",
+    "claim": "the `JsonException`, the `FormatException` and the `FromKnownGood` exception all name your `EmailFault.NoAt`",
+    "oracle": "claim",
+    "surfaces": [
+      "IValidatedValue.Create",
+      "GeneratedFactories.*"
+    ],
+    "heldBy": [
+      "EntryPointValidationTests"
+    ]
+  },
+  {
+    "id": "L03-tryfrom-runs-create",
+    "source": "README.md#what-typekit-guarantees",
+    "quote": "The generated `TryFrom`, `FromKnownGood`, JSON converter, parsing and type converter all run it",
+    "claim": "The generated `TryFrom`, `FromKnownGood`, JSON converter, parsing and type converter all run it",
+    "oracle": "claim",
+    "surfaces": [
+      "GeneratedFactories.*",
+      "IValidatedValue.Create"
+    ],
+    "heldBy": [
+      "EntryPointValidationTests"
+    ]
+  },
+  {
+    "id": "L04-invariant-whatever-the-culture",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#parsing-and-formatting",
+    "quote": "A null `IFormatProvider` means the invariant culture in every generated `Parse`, `TryParse`, `ToString` and `TryFormat`, so the text doesn't depend on the culture the process runs in.",
+    "claim": "A null `IFormatProvider` means the invariant culture in every generated `Parse`, `TryParse`, `ToString` and `TryFormat`, so the text doesn't depend on the culture the process runs in.",
+    "oracle": "metamorphic",
+    "surfaces": [
+      "GeneratedFormatting.*",
+      "GeneratedParsing.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "L04-json-refusal-is-a-json-exception",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#parsing-and-formatting",
+    "quote": "Input it can't read throws a `JsonException` naming the value object and the underlying type",
+    "claim": "Input it can't read throws a `JsonException` naming the value object and the underlying type",
+    "oracle": "metamorphic",
+    "surfaces": [
+      "GeneratedFormatting.*",
+      "GeneratedParsing.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "L04-text-reads-back",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#parsing-and-formatting",
+    "quote": "That text reads back as the same value wherever the underlying type's own does",
+    "claim": "That text reads back as the same value wherever the underlying type's own does",
+    "oracle": "metamorphic",
+    "surfaces": [
+      "GeneratedFormatting.*",
+      "GeneratedParsing.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "L04-the-type-converter-writes-the-same",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#parsing-and-formatting",
+    "quote": "`ToString()` is the underlying type's own default text under the invariant culture, and the type converter and `$\"{x}\"` write the same.",
+    "claim": "`ToString()` is the underlying type's own default text under the invariant culture, and the type converter and `$\"{x}\"` write the same.",
+    "oracle": "metamorphic",
+    "surfaces": [
+      "GeneratedFormatting.*",
+      "GeneratedParsing.*"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "L05-equality-is-the-underlying-values",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#equality",
+    "quote": "Equality is the underlying value's, like the ordering, the JSON and the column.",
+    "claim": "Equality is the underlying value's, like the ordering, the JSON and the column.",
+    "oracle": "metamorphic",
+    "surfaces": [
+      "IValueObject.op_Equality",
+      "IValueObject.op_Inequality"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "L05-ordering-follows-the-underlying-type",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#equality",
+    "quote": "`CompareTo` and the operators follow the underlying type's ordering, ordinal for a string.",
+    "claim": "`CompareTo` and the operators follow the underlying type's ordering, ordinal for a string.",
+    "oracle": "metamorphic",
+    "surfaces": [
+      "IValueObject.op_Equality",
+      "IValueObject.op_Inequality"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "L05-through-every-base",
+    "source": "src/CodoMetis.TypeKit.Generators/README.md#equality",
+    "quote": "The value object implements each base's `IEquatable<TBase>` again (`IReimplementedEquatable<TBase>`), so a collection of the base compares it the way the value object does.",
+    "claim": "The value object implements each base's `IEquatable<TBase>` again (`IReimplementedEquatable<TBase>`), so a collection of the base compares it the way the value object does.",
+    "oracle": "metamorphic",
+    "surfaces": [
+      "IValueObject.op_Equality",
+      "IValueObject.op_Inequality"
+    ],
+    "heldBy": []
+  },
+  {
+    "id": "L06-never-written",
+    "source": "README.md#what-typekit-guarantees",
+    "quote": "System.Text.Json throws `NotSupportedException` for either, in both directions, instead of writing `{}` that reads back as `None`.",
+    "claim": "System.Text.Json throws `NotSupportedException` for either, in both directions, instead of writing `{}` that reads back as `None`.",
+    "oracle": "exception",
+    "surfaces": [
+      "NotWireTypeJsonConverterFactory.*"
+    ],
+    "heldBy": [
+      "NotWireTypeTests"
+    ]
+  },
+  {
+    "id": "O01-default-is-none",
+    "source": "docs/option.md#option",
+    "quote": "An option that says it has a value always has one: `T` is `notnull`, `Option.Some(null)` throws, and a `default(Option<T>)` is `None`.",
+    "claim": "An option that says it has a value always has one: `T` is `notnull`, `Option.Some(null)` throws, and a `default(Option<T>)` is `None`.",
+    "oracle": "exception",
+    "surfaces": [
+      "Option.Some",
+      "Option..ctor",
+      "Option.IsSome"
+    ],
+    "heldBy": [
+      "OptionTests"
+    ]
+  },
+  {
+    "id": "O01-tostring-never-prints",
+    "source": "docs/option.md#option",
+    "quote": "`ToString()` never prints the content.",
+    "claim": "`ToString()` never prints the content.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.ToString"
+    ],
+    "heldBy": [
+      "TextRepresentationTests"
+    ]
+  },
+  {
+    "id": "O02-element-at-or-none",
+    "source": "docs/option.md#create-one",
+    "quote": "**`ElementAtOrNone(index)`**, for the element at a position.",
+    "claim": "**`ElementAtOrNone(index)`**, for the element at a position.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.ElementAtOrNone"
+    ],
+    "heldBy": [
+      "OptionLookupTests"
+    ]
+  },
+  {
+    "id": "O02-first-and-last-or-none",
+    "source": "docs/option.md#create-one",
+    "quote": "**`FirstOrNone()` and `LastOrNone()`** on a sequence, with or without a predicate.",
+    "claim": "**`FirstOrNone()` and `LastOrNone()`** on a sequence, with or without a predicate.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.FirstOrNone",
+      "Option.LastOrNone"
+    ],
+    "heldBy": [
+      "OptionExtensionsTests"
+    ]
+  },
+  {
+    "id": "O02-get-value-or-none",
+    "source": "docs/option.md#create-one",
+    "quote": "**`GetValueOrNone(key)`** on a dictionary.",
+    "claim": "**`GetValueOrNone(key)`** on a dictionary.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.GetValueOrNone"
+    ],
+    "heldBy": [
+      "OptionExtensionsTests"
+    ]
+  },
+  {
+    "id": "O02-none-takes-its-type",
+    "source": "docs/option.md#create-one",
+    "quote": "`None()` takes its type from where it goes: a `return`, a conditional beside a `Some`, or a parameter.",
+    "claim": "`None()` takes its type from where it goes: a `return`, a conditional beside a `Some`, or a parameter.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.None",
+      "Option.op_Implicit"
+    ],
+    "heldBy": [
+      "OptionTests"
+    ]
+  },
+  {
+    "id": "O02-single-or-none-throws",
+    "source": "docs/option.md#create-one",
+    "quote": "**`SingleOrNone()`**, which throws when there is more than one element.",
+    "claim": "**`SingleOrNone()`**, which throws when there is more than one element.",
+    "oracle": "exception",
+    "surfaces": [
+      "Option.SingleOrNone"
+    ],
+    "heldBy": [
+      "OptionLookupTests"
+    ]
+  },
+  {
+    "id": "O02-to-option-null-is-none",
+    "source": "docs/option.md#create-one",
+    "quote": "**`ToOption()`** on a nullable, such as an `int?` or a `string?`. A null becomes `None`.",
+    "claim": "**`ToOption()`** on a nullable, such as an `int?` or a `string?`. A null becomes `None`.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.ToOption"
+    ],
+    "heldBy": [
+      "OptionExtensionsTests",
+      "OrNullTests"
+    ]
+  },
+  {
+    "id": "O03-a-func-reads-every-row",
+    "source": "docs/option.md#in-a-database-query",
+    "quote": "A `Func<T, bool>` held in a variable, or a method group, binds to the sequence overload instead. That reads every row and checks the condition in memory",
+    "claim": "A `Func<T, bool>` held in a variable, or a method group, binds to the sequence overload instead. That reads every row and checks the condition in memory",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.FirstOrNone"
+    ],
+    "heldBy": [
+      "QueryOptionTests"
+    ]
+  },
+  {
+    "id": "O03-last-on-a-query-does-not-compile",
+    "source": "docs/option.md#in-a-database-query",
+    "quote": "`LastOrNone` on a query fails to compile, because a query has no last row until you order it.",
+    "claim": "`LastOrNone` on a query fails to compile, because a query has no last row until you order it.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.LastOrNone"
+    ],
+    "heldBy": [
+      "QueryableOptionTests"
+    ]
+  },
+  {
+    "id": "O03-provider-runs-the-predicate",
+    "source": "docs/option.md#in-a-database-query",
+    "quote": "The database provider runs the predicate and fetches only the rows they need.",
+    "claim": "The database provider runs the predicate and fetches only the rows they need.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.FirstOrNone",
+      "Option.SingleOrNone",
+      "Option.ElementAtOrNone"
+    ],
+    "heldBy": [
+      "QueryableOptionTests",
+      "QueryOptionTests"
+    ]
+  },
+  {
+    "id": "O03-work-on-a-query",
+    "source": "docs/option.md#in-a-database-query",
+    "quote": "`FirstOrNone`, `SingleOrNone` and `ElementAtOrNone` also work on an `IQueryable<T>`.",
+    "claim": "`FirstOrNone`, `SingleOrNone` and `ElementAtOrNone` also work on an `IQueryable<T>`.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.FirstOrNone",
+      "Option.SingleOrNone",
+      "Option.ElementAtOrNone"
+    ],
+    "heldBy": [
+      "QueryableOptionTests",
+      "QueryOptionTests"
+    ]
+  },
+  {
+    "id": "O04-as-enumerable",
+    "source": "docs/option.md#get-the-value-out",
+    "quote": "**`AsEnumerable()`** gives you zero or one element, for a `foreach` or LINQ.",
+    "claim": "**`AsEnumerable()`** gives you zero or one element, for a `foreach` or LINQ.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.AsEnumerable"
+    ],
+    "heldBy": [
+      "OptionTests"
+    ]
+  },
+  {
+    "id": "O04-is-some-and-is-none",
+    "source": "docs/option.md#get-the-value-out",
+    "quote": "**`IsSome()` and `IsNone()`** answer the question on its own.",
+    "claim": "**`IsSome()` and `IsNone()`** answer the question on its own.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.IsSome",
+      "Option.IsNone"
+    ],
+    "heldBy": [
+      "OptionTests"
+    ]
+  },
+  {
+    "id": "O04-match-takes-both-branches",
+    "source": "docs/option.md#get-the-value-out",
+    "quote": "`Match` takes one branch for a value and one for nothing, and returns what they return.",
+    "claim": "`Match` takes one branch for a value and one for nothing, and returns what they return.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.Match"
+    ],
+    "heldBy": [
+      "OptionTests"
+    ]
+  },
+  {
+    "id": "O04-or-and-or-default",
+    "source": "docs/option.md#get-the-value-out",
+    "quote": "**`Or(fallback)` and `OrDefault()`** give you the value, or a fallback when there is none.",
+    "claim": "**`Or(fallback)` and `OrDefault()`** give you the value, or a fallback when there is none.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.Or",
+      "Option.OrDefault"
+    ],
+    "heldBy": [
+      "OptionTests",
+      "OptionExtensionsTests"
+    ]
+  },
+  {
+    "id": "O04-or-null",
+    "source": "docs/option.md#get-the-value-out",
+    "quote": "**`OrNull()`** gives you a nullable: an `int?` for an `Option<int>`, a `string?` for an `Option<string>`.",
+    "claim": "**`OrNull()`** gives you a nullable: an `int?` for an `Option<int>`, a `string?` for an `Option<string>`.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.OrNull",
+      "ValueTypeOptionExtensions.OrNull"
+    ],
+    "heldBy": [
+      "OrNullTests",
+      "OptionExtensionsTests"
+    ]
+  },
+  {
+    "id": "O04-try-get-value",
+    "source": "docs/option.md#get-the-value-out",
+    "quote": "**`TryGetValue(out value)`** fits an `if`, and the value is non-null inside the branch.",
+    "claim": "**`TryGetValue(out value)`** fits an `if`, and the value is non-null inside the branch.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.TryGetValue"
+    ],
+    "heldBy": [
+      "OptionTests"
+    ]
+  },
+  {
+    "id": "O05-bind-flattens",
+    "source": "docs/option.md#combine-options",
+    "quote": "**`Bind`** takes a selector that returns an option itself, so you never end up with an `Option<Option<T>>`.",
+    "claim": "**`Bind`** takes a selector that returns an option itself, so you never end up with an `Option<Option<T>>`.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.Bind"
+    ],
+    "heldBy": [
+      "OptionTests",
+      "OptionExtensionsTests"
+    ]
+  },
+  {
+    "id": "O05-choose-is-lazy",
+    "source": "docs/option.md#combine-options",
+    "quote": "It runs lazily, like any LINQ operator.",
+    "claim": "It runs lazily, like any LINQ operator.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.Choose",
+      "SequenceOptionExtensions.Choose"
+    ],
+    "heldBy": [
+      "ChooseTests"
+    ]
+  },
+  {
+    "id": "O05-choose-keeps-in-order",
+    "source": "docs/option.md#combine-options",
+    "quote": "It keeps, in order, the values the selector returns `Some` for, and drops the rest: a filter and a map in one.",
+    "claim": "It keeps, in order, the values the selector returns `Some` for, and drops the rest: a filter and a map in one.",
+    "oracle": "claim",
+    "surfaces": [
+      "SequenceOptionExtensions.Choose"
+    ],
+    "heldBy": [
+      "ChooseTests"
+    ]
+  },
+  {
+    "id": "O05-choose-without-a-selector",
+    "source": "docs/option.md#combine-options",
+    "quote": "On a sequence of options, `Choose()` without a selector keeps the values they hold.",
+    "claim": "On a sequence of options, `Choose()` without a selector keeps the values they hold.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.Choose"
+    ],
+    "heldBy": [
+      "ChooseTests"
+    ]
+  },
+  {
+    "id": "O05-each-from-sees-the-earlier",
+    "source": "docs/option.md#combine-options",
+    "quote": "Each `from` after the first can use the ones before it.",
+    "claim": "Each `from` after the first can use the ones before it.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.SelectMany"
+    ],
+    "heldBy": [
+      "OptionExtensionsTests"
+    ]
+  },
+  {
+    "id": "O05-filter",
+    "source": "docs/option.md#combine-options",
+    "quote": "**`Filter`** turns a value that fails the predicate into `None`.",
+    "claim": "**`Filter`** turns a value that fails the predicate into `None`.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.Filter"
+    ],
+    "heldBy": [
+      "OptionTests"
+    ]
+  },
+  {
+    "id": "O05-map",
+    "source": "docs/option.md#combine-options",
+    "quote": "**`Map`** changes the value, and a missing value stays missing.",
+    "claim": "**`Map`** changes the value, and a missing value stays missing.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.Map"
+    ],
+    "heldBy": [
+      "OptionTests"
+    ]
+  },
+  {
+    "id": "O05-query-syntax",
+    "source": "docs/option.md#combine-options",
+    "quote": "`Select`, `SelectMany` and `Where` make query syntax work, as in the last example.",
+    "claim": "`Select`, `SelectMany` and `Where` make query syntax work, as in the last example.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.Select",
+      "Option.SelectMany",
+      "Option.Where"
+    ],
+    "heldBy": [
+      "OptionExtensionsTests"
+    ]
+  },
+  {
+    "id": "O05-tap",
+    "source": "docs/option.md#combine-options",
+    "quote": "**`Tap`** runs an action on the value and hands the option on unchanged.",
+    "claim": "**`Tap`** runs an action on the value and hands the option on unchanged.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.Tap"
+    ],
+    "heldBy": [
+      "OptionTests"
+    ]
+  },
+  {
+    "id": "O05-zip",
+    "source": "docs/option.md#combine-options",
+    "quote": "**`Zip`** combines two to six options into one value, when every one of them has a value.",
+    "claim": "**`Zip`** combines two to six options into one value, when every one of them has a value.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.Zip"
+    ],
+    "heldBy": [
+      "OptionExtensionsTests"
+    ]
+  },
+  {
+    "id": "O06-a-finished-lookup-runs-at-once",
+    "source": "docs/option.md#continue-a-pending-lookup",
+    "quote": "If the lookup had already finished, the callback runs at once, on your synchronization context.",
+    "claim": "If the lookup had already finished, the callback runs at once, on your synchronization context.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.MapAsync",
+      "Option.BindAsync",
+      "Option.FilterAsync",
+      "Option.TapAsync",
+      "Option.ToResultAsync"
+    ],
+    "heldBy": [
+      "AsynchronousContextTests"
+    ]
+  },
+  {
+    "id": "O06-a-pending-lookup-runs-without-the-context",
+    "source": "docs/option.md#continue-a-pending-lookup",
+    "quote": "If it had not, the callback runs without that context, usually on a thread-pool thread",
+    "claim": "If it had not, the callback runs without that context, usually on a thread-pool thread",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.MapAsync",
+      "Option.BindAsync",
+      "Option.FilterAsync",
+      "Option.TapAsync",
+      "Option.ToResultAsync"
+    ],
+    "heldBy": [
+      "AsynchronousContextTests"
+    ]
+  },
+  {
+    "id": "O06-continue-a-pending-option",
+    "source": "docs/option.md#continue-a-pending-lookup",
+    "quote": "`MapAsync`, `BindAsync`, `FilterAsync`, `TapAsync` and `ToResultAsync` continue it the way [Result's async chains](result.md#async-chains) continue a pending result.",
+    "claim": "`MapAsync`, `BindAsync`, `FilterAsync`, `TapAsync` and `ToResultAsync` continue it the way [Result's async chains](result.md#async-chains) continue a pending result.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.MapAsync",
+      "Option.BindAsync",
+      "Option.FilterAsync",
+      "Option.TapAsync",
+      "Option.ToResultAsync"
+    ],
+    "heldBy": [
+      "OptionAsyncTests"
+    ]
+  },
+  {
+    "id": "O07-rejected-by-system-text-json",
+    "source": "docs/option.md#at-the-boundary",
+    "quote": "System.Text.Json rejects it in both directions",
+    "claim": "System.Text.Json rejects it in both directions",
+    "oracle": "exception",
+    "surfaces": [
+      "NotWireTypeJsonConverterFactory.*"
+    ],
+    "heldBy": [
+      "NotWireTypeTests"
+    ]
+  },
+  {
+    "id": "O07-to-option-in-or-null-out",
+    "source": "docs/option.md#at-the-boundary",
+    "quote": "Use `ToOption()` on the way in and `OrNull()` on the way out.",
+    "claim": "Use `ToOption()` on the way in and `OrNull()` on the way out.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.ToOption",
+      "Option.OrNull"
+    ],
+    "heldBy": [
+      "OrNullTests"
+    ]
+  },
+  {
+    "id": "O07-to-result",
+    "source": "docs/option.md#at-the-boundary",
+    "quote": "`ToResult(error)` turns the option into a [Result](result.md)",
+    "claim": "`ToResult(error)` turns the option into a [Result](result.md)",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.ToResult"
+    ],
+    "heldBy": [
+      "OptionExtensionsTests"
+    ]
+  },
+  {
+    "id": "O08-choose-reads-null-elements",
+    "source": "docs/option.md#the-surface",
+    "quote": "the elements `Choose(selector)` reads may be null, and only what the selector finds counts as a value.",
+    "claim": "the elements `Choose(selector)` reads may be null, and only what the selector finds counts as a value.",
+    "oracle": "claim",
+    "surfaces": [
+      "SequenceOptionExtensions.Choose"
+    ],
+    "heldBy": [
+      "ChooseTests"
+    ]
+  },
+  {
+    "id": "O08-default-is-rejected-by-the-analyzer",
+    "source": "docs/option.md#the-surface",
+    "quote": "A `default(Option<T>)` is `None`, but the analyzer still rejects writing it (CMTK0001).",
+    "claim": "A `default(Option<T>)` is `None`, but the analyzer still rejects writing it (CMTK0001).",
+    "oracle": "claim",
+    "surfaces": [
+      "Option..ctor"
+    ],
+    "heldBy": [
+      "OptionTests",
+      "ForbiddenDefaultInitializationAnalyzerTests"
+    ]
+  },
+  {
+    "id": "O08-equality",
+    "source": "docs/option.md#the-surface",
+    "quote": "Two options are equal when both are `None`, or when both hold equal values, as with any record struct.",
+    "claim": "Two options are equal when both are `None`, or when both hold equal values, as with any record struct.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.Equals",
+      "Option.GetHashCode",
+      "Option.op_Equality",
+      "Option.op_Inequality"
+    ],
+    "heldBy": [
+      "OptionTests"
+    ]
+  },
+  {
+    "id": "O08-filter-async",
+    "source": "docs/option.md#the-surface",
+    "quote": "| `FilterAsync(predicate)` | `Task<Option<T>>` | `Filter`, once the option is known |",
+    "claim": "| `FilterAsync(predicate)` | `Task<Option<T>>` | `Filter`, once the option is known |",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.FilterAsync"
+    ],
+    "heldBy": [
+      "OptionAsyncTests"
+    ]
+  },
+  {
+    "id": "O08-implicit-from-none",
+    "source": "docs/option.md#the-surface",
+    "quote": "| implicit from `None` | `Option<T>` | `None` |",
+    "claim": "| implicit from `None` | `Option<T>` | `None` |",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.op_Implicit"
+    ],
+    "heldBy": [
+      "OptionTests"
+    ]
+  },
+  {
+    "id": "O08-index-on-a-query-does-not-compile",
+    "source": "docs/option.md#the-surface",
+    "quote": "an `Index` on a query is a compile error",
+    "claim": "an `Index` on a query is a compile error",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.ElementAtOrNone"
+    ],
+    "heldBy": [
+      "QueryableOptionTests"
+    ]
+  },
+  {
+    "id": "O08-map-refuses-null",
+    "source": "docs/option.md#the-surface",
+    "quote": "| `Map(selector)` | `Option<T>` | `Option<TResult>`; throws if the selector returns null |",
+    "claim": "| `Map(selector)` | `Option<T>` | `Option<TResult>`; throws if the selector returns null |",
+    "oracle": "exception",
+    "surfaces": [
+      "Option.Map"
+    ],
+    "heldBy": [
+      "OptionTests"
+    ]
+  },
+  {
+    "id": "O08-none-marker-converts",
+    "source": "docs/option.md#the-surface",
+    "quote": "a `None` marker that converts to any `Option<T>`",
+    "claim": "a `None` marker that converts to any `Option<T>`",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.None",
+      "Option.op_Implicit"
+    ],
+    "heldBy": [
+      "OptionTests"
+    ]
+  },
+  {
+    "id": "O08-or-default-is-reported-for-a-value-object",
+    "source": "docs/option.md#the-surface",
+    "quote": "`T`, `default` for `None`; CMTK0009 for a value object, whose `default` is no value",
+    "claim": "`T`, `default` for `None`; CMTK0009 for a value object, whose `default` is no value",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.OrDefault"
+    ],
+    "heldBy": [
+      "OptionExtensionsTests",
+      "DefaultProducingCallAnalyzerTests"
+    ]
+  },
+  {
+    "id": "O08-single-or-none-asks-for-two-rows",
+    "source": "docs/option.md#the-surface",
+    "quote": "throws for more than one. A query is asked for two rows",
+    "claim": "throws for more than one. A query is asked for two rows",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.SingleOrNone"
+    ],
+    "heldBy": [
+      "OptionLookupTests",
+      "QueryOptionTests"
+    ]
+  },
+  {
+    "id": "O08-some-refuses-null",
+    "source": "docs/option.md#the-surface",
+    "quote": "`Option<T>`; throws `ArgumentNullException` for null",
+    "claim": "`Option<T>`; throws `ArgumentNullException` for null",
+    "oracle": "exception",
+    "surfaces": [
+      "Option.Some"
+    ],
+    "heldBy": [
+      "OptionTests"
+    ]
+  },
+  {
+    "id": "O08-to-result-async",
+    "source": "docs/option.md#the-surface",
+    "quote": "`Task<Result<T, TError>>`: a pending lookup into a `Result` pipeline",
+    "claim": "`Task<Result<T, TError>>`: a pending lookup into a `Result` pipeline",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.ToResultAsync"
+    ],
+    "heldBy": [
+      "OptionAsyncTests"
+    ]
+  },
+  {
+    "id": "P01-a-value",
+    "source": "docs/merge-patches.md#tell-absent-null-and-a-value-apart",
+    "quote": "| a value | `Value` | `onValue` | true | with the value | with the value | `Some` |",
+    "claim": "| a value | `Value` | `onValue` | true | with the value | with the value | `Some` |",
+    "oracle": "claim",
+    "surfaces": [
+      "Patch.State",
+      "Patch.Match",
+      "Patch.TryGetValue",
+      "Patch.Tap",
+      "Patch.IfPresent",
+      "Patch.ToOption"
+    ],
+    "heldBy": [
+      "PatchTests",
+      "MergePatchesTests"
+    ]
+  },
+  {
+    "id": "P01-default-is-absent",
+    "source": "docs/merge-patches.md#tell-absent-null-and-a-value-apart",
+    "quote": "**`default(Patch<T>)` is `Absent`.** The serializer never touches a property the document leaves out, so it keeps the struct's default.",
+    "claim": "**`default(Patch<T>)` is `Absent`.** The serializer never touches a property the document leaves out, so it keeps the struct's default.",
+    "oracle": "claim",
+    "surfaces": [
+      "Patch.Absent",
+      "Patch.State"
+    ],
+    "heldBy": [
+      "PatchTests",
+      "MergePatchesTests"
+    ]
+  },
+  {
+    "id": "P01-left-alone-by-the-analyzers",
+    "source": "docs/merge-patches.md#tell-absent-null-and-a-value-apart",
+    "quote": "That's why the analyzers, which reject a `default` of every other struct in this package, leave a patch alone.",
+    "claim": "That's why the analyzers, which reject a `default` of every other struct in this package, leave a patch alone.",
+    "oracle": "claim",
+    "surfaces": [
+      "Patch.Absent"
+    ],
+    "heldBy": [
+      "PatchIsDefaultableTests"
+    ]
+  },
+  {
+    "id": "P01-not-mentioned",
+    "source": "docs/merge-patches.md#tell-absent-null-and-a-value-apart",
+    "quote": "| not mentioned | `Absent` | `onAbsent` | false | no | no | `None` |",
+    "claim": "| not mentioned | `Absent` | `onAbsent` | false | no | no | `None` |",
+    "oracle": "claim",
+    "surfaces": [
+      "Patch.State",
+      "Patch.Match",
+      "Patch.TryGetValue",
+      "Patch.Tap",
+      "Patch.IfPresent",
+      "Patch.ToOption"
+    ],
+    "heldBy": [
+      "PatchTests",
+      "MergePatchesTests"
+    ]
+  },
+  {
+    "id": "P01-null",
+    "source": "docs/merge-patches.md#tell-absent-null-and-a-value-apart",
+    "quote": "| `null` | `Null` | `onNull` | false | no | with `null` | `None` |",
+    "claim": "| `null` | `Null` | `onNull` | false | no | with `null` | `None` |",
+    "oracle": "claim",
+    "surfaces": [
+      "Patch.State",
+      "Patch.Match",
+      "Patch.TryGetValue",
+      "Patch.Tap",
+      "Patch.IfPresent",
+      "Patch.ToOption"
+    ],
+    "heldBy": [
+      "PatchTests",
+      "MergePatchesTests"
+    ]
+  },
+  {
+    "id": "P01-reading-accepts-a-null",
+    "source": "docs/merge-patches.md#tell-absent-null-and-a-value-apart",
+    "quote": "**Reading always accepts a `null`, whatever `T` is.**",
+    "claim": "**Reading always accepts a `null`, whatever `T` is.**",
+    "oracle": "claim",
+    "surfaces": [
+      "Patch.Null",
+      "PatchJsonConverterFactory.*"
+    ],
+    "heldBy": [
+      "MergePatchesTests",
+      "PatchTests"
+    ]
+  },
+  {
+    "id": "P01-to-string-prints-the-state",
+    "source": "docs/merge-patches.md#tell-absent-null-and-a-value-apart",
+    "quote": "**`ToString()` prints the state**, never the value.",
+    "claim": "**`ToString()` prints the state**, never the value.",
+    "oracle": "claim",
+    "surfaces": [
+      "Patch.ToString",
+      "Patch.Equals",
+      "Patch.GetHashCode",
+      "Patch.op_Equality",
+      "Patch.op_Inequality"
+    ],
+    "heldBy": [
+      "PatchTests"
+    ]
+  },
+  {
+    "id": "P02-a-struct-s-clear-is-null",
+    "source": "docs/merge-patches.md#apply-a-patch",
+    "quote": "A field of a value type receives the clear as `null`, never as `0`.",
+    "claim": "A field of a value type receives the clear as `null`, never as `0`.",
+    "oracle": "claim",
+    "surfaces": [
+      "Patch.IfPresent"
+    ],
+    "heldBy": [
+      "PatchTests",
+      "MergePatchesTests"
+    ]
+  },
+  {
+    "id": "P02-if-present",
+    "source": "docs/merge-patches.md#apply-a-patch",
+    "quote": "**`IfPresent`** runs for a value and for a clear.",
+    "claim": "**`IfPresent`** runs for a value and for a clear.",
+    "oracle": "claim",
+    "surfaces": [
+      "Patch.IfPresent"
+    ],
+    "heldBy": [
+      "PatchTests"
+    ]
+  },
+  {
+    "id": "P02-match",
+    "source": "docs/merge-patches.md#apply-a-patch",
+    "quote": "**`Match`** takes all three, for a rule that has to say what each one means.",
+    "claim": "**`Match`** takes all three, for a rule that has to say what each one means.",
+    "oracle": "claim",
+    "surfaces": [
+      "Patch.Match"
+    ],
+    "heldBy": [
+      "PatchTests"
+    ]
+  },
+  {
+    "id": "P02-tap",
+    "source": "docs/merge-patches.md#apply-a-patch",
+    "quote": "**`Tap`** runs only for a value, as `Option`'s `Tap` does.",
+    "claim": "**`Tap`** runs only for a value, as `Option`'s `Tap` does.",
+    "oracle": "claim",
+    "surfaces": [
+      "Patch.Tap"
+    ],
+    "heldBy": [
+      "PatchTests"
+    ]
+  },
+  {
+    "id": "P02-tap-and-if-present-return-the-patch",
+    "source": "docs/merge-patches.md#apply-a-patch",
+    "quote": "`Tap` and `IfPresent` both return the patch unchanged.",
+    "claim": "`Tap` and `IfPresent` both return the patch unchanged.",
+    "oracle": "claim",
+    "surfaces": [
+      "Patch.Tap",
+      "Patch.IfPresent"
+    ],
+    "heldBy": [
+      "PatchTests"
+    ]
+  },
+  {
+    "id": "P02-to-option",
+    "source": "docs/merge-patches.md#apply-a-patch",
+    "quote": "**`ToOption()`** is for code that treats a clear and an absence the same.",
+    "claim": "**`ToOption()`** is for code that treats a clear and an absence the same.",
+    "oracle": "claim",
+    "surfaces": [
+      "Patch.ToOption"
+    ],
+    "heldBy": [
+      "PatchTests"
+    ]
+  },
+  {
+    "id": "P03-a-null-is-no-error",
+    "source": "docs/merge-patches.md#a-value-object-inside-a-patch",
+    "quote": "**A `null` isn't an error.** It's the `Null` state",
+    "claim": "**A `null` isn't an error.** It's the `Null` state",
+    "oracle": "claim",
+    "surfaces": [
+      "Patch.Null",
+      "PatchJsonConverterFactory.*"
+    ],
+    "heldBy": [
+      "MergePatchesTests"
+    ]
+  },
+  {
+    "id": "P03-a-refused-patch-is-a-400",
+    "source": "docs/merge-patches.md#a-value-object-inside-a-patch",
+    "quote": "In an endpoint, the client gets the same 400 as for any body a value object rejects, with problem details where the host adds `UseStatusCodePages()`",
+    "claim": "In an endpoint, the client gets the same 400 as for any body a value object rejects, with problem details where the host adds `UseStatusCodePages()`",
+    "oracle": "claim",
+    "surfaces": [
+      "PatchJsonConverterFactory.*"
+    ],
+    "heldBy": [
+      "HostConfigurationTests"
+    ]
+  },
+  {
+    "id": "P03-not-null-warning",
+    "source": "docs/merge-patches.md#a-value-object-inside-a-patch",
+    "quote": "`Patch<Email?>` or `Patch<string?>` gets a warning at the declaration (CS8714).",
+    "claim": "`Patch<Email?>` or `Patch<string?>` gets a warning at the declaration (CS8714).",
+    "oracle": "claim",
+    "surfaces": [
+      "Patch.Value"
+    ],
+    "heldBy": [
+      "PatchNullabilityTests"
+    ]
+  },
+  {
+    "id": "P03-not-quoted",
+    "source": "docs/merge-patches.md#a-value-object-inside-a-patch",
+    "quote": "A value `Create` rejects is rejected here as anywhere else, and the error doesn't quote it.",
+    "claim": "A value `Create` rejects is rejected here as anywhere else, and the error doesn't quote it.",
+    "oracle": "exception",
+    "surfaces": [
+      "PatchJsonConverterFactory.*"
+    ],
+    "heldBy": [
+      "MergePatchesTests",
+      "SourceGeneratedJsonTests"
+    ]
+  },
+  {
+    "id": "P03-the-field-s-path",
+    "source": "docs/merge-patches.md#a-value-object-inside-a-patch",
+    "quote": "The exception's `Path` is the field's, `$.email`, as it is for any property.",
+    "claim": "The exception's `Path` is the field's, `$.email`, as it is for any property.",
+    "oracle": "claim",
+    "surfaces": [
+      "PatchJsonConverterFactory.*"
+    ],
+    "heldBy": [
+      "MergePatchesTests",
+      "SourceGeneratedJsonTests"
+    ]
+  },
+  {
+    "id": "P03-the-value-object-s-converter",
+    "source": "docs/merge-patches.md#a-value-object-inside-a-patch",
+    "quote": "A patch reads its value with the value object's own converter, so the value object keeps its rule.",
+    "claim": "A patch reads its value with the value object's own converter, so the value object keeps its rule.",
+    "oracle": "claim",
+    "surfaces": [
+      "PatchJsonConverterFactory.*"
+    ],
+    "heldBy": [
+      "MergePatchesTests",
+      "SourceGeneratedJsonTests"
+    ]
+  },
+  {
+    "id": "P04-a-clear-or-an-absence-passes",
+    "source": "docs/merge-patches.md#validate-a-patch",
+    "quote": "**A clear or an absent field** passes through, since there's nothing to validate.",
+    "claim": "**A clear or an absent field** passes through, since there's nothing to validate.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Traverse"
+    ],
+    "heldBy": [
+      "PatchCombinationTests",
+      "MergePatchesTests"
+    ]
+  },
+  {
+    "id": "P04-a-value-is-validated",
+    "source": "docs/merge-patches.md#validate-a-patch",
+    "quote": "**A value** is validated, and a failure gives `Create`'s own error.",
+    "claim": "**A value** is validated, and a failure gives `Create`'s own error.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Traverse"
+    ],
+    "heldBy": [
+      "PatchCombinationTests",
+      "MergePatchesTests"
+    ]
+  },
+  {
+    "id": "P04-map",
+    "source": "docs/merge-patches.md#validate-a-patch",
+    "quote": "`Map` changes the value the same way, and keeps a clear and an absence as they are.",
+    "claim": "`Map` changes the value the same way, and keeps a clear and an absence as they are.",
+    "oracle": "claim",
+    "surfaces": [
+      "Patch.Map"
+    ],
+    "heldBy": [
+      "PatchCombinationTests",
+      "MergePatchesTests"
+    ]
+  },
+  {
+    "id": "P05-an-absent-patch-is-not-written",
+    "source": "docs/merge-patches.md#write-a-patch",
+    "quote": "So writing an absent patch throws a `NotSupportedException`, unless the property says to skip a default, as above.",
+    "claim": "So writing an absent patch throws a `NotSupportedException`, unless the property says to skip a default, as above.",
+    "oracle": "exception",
+    "surfaces": [
+      "PatchJsonConverterFactory.*",
+      "Patch.Absent"
+    ],
+    "heldBy": [
+      "MergePatchesTests"
+    ]
+  },
+  {
+    "id": "P05-value-of-null-is-a-clear",
+    "source": "docs/merge-patches.md#write-a-patch",
+    "quote": "`Patch.Value(null)` is the `Null` state, so a client that holds a nullable value can pass it as it is.",
+    "claim": "`Patch.Value(null)` is the `Null` state, so a client that holds a nullable value can pass it as it is.",
+    "oracle": "claim",
+    "surfaces": [
+      "Patch.Value",
+      "Patch.Null"
+    ],
+    "heldBy": [
+      "PatchTests"
+    ]
+  },
+  {
+    "id": "P06-absent-when-left-out",
+    "source": "docs/merge-patches.md#use-it-in-an-endpoint-and-in-the-document",
+    "quote": "Each property of `ContactPatch` is read by its patch, and one the request leaves out is `Absent`.",
+    "claim": "Each property of `ContactPatch` is read by its patch, and one the request leaves out is `Absent`.",
+    "oracle": "claim",
+    "surfaces": [
+      "PatchJsonConverterFactory.*",
+      "Patch.State"
+    ],
+    "heldBy": [
+      "PatchSchemaTests",
+      "MergePatchesTests"
+    ]
+  },
+  {
+    "id": "P06-admitting-null",
+    "source": "docs/merge-patches.md#use-it-in-an-endpoint-and-in-the-document",
+    "quote": "So a validator accepts null, and judges every other value as it judges the argument's.",
+    "claim": "So a validator accepts null, and judges every other value as it judges the argument's.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit"
+    ],
+    "heldBy": [
+      "PatchSchemaTests"
+    ]
+  },
+  {
+    "id": "P06-inlined",
+    "source": "docs/merge-patches.md#use-it-in-an-endpoint-and-in-the-document",
+    "quote": "**Inlined**, rather than as a component of its own.",
+    "claim": "**Inlined**, rather than as a component of its own.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit"
+    ],
+    "heldBy": [
+      "PatchSchemaTests"
+    ]
+  },
+  {
+    "id": "P06-through-the-underlying-type",
+    "source": "docs/merge-patches.md#use-it-in-an-endpoint-and-in-the-document",
+    "quote": "A value object inside a patch is described through its underlying type, so `email` is a `string`.",
+    "claim": "A value object inside a patch is described through its underlying type, so `email` is a `string`.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit"
+    ],
+    "heldBy": [
+      "PatchSchemaTests",
+      "MergePatchesTests"
+    ]
+  },
+  {
+    "id": "P07-default-breaks-the-document",
+    "source": "docs/merge-patches.md#required-constructor-parameters",
+    "quote": "But System.Text.Json's schema exporter, which ASP.NET Core builds the document with, throws on a parameter of a struct type whose default is `default`. So the endpoint's document fails.",
+    "claim": "But System.Text.Json's schema exporter, which ASP.NET Core builds the document with, throws on a parameter of a struct type whose default is `default`. So the endpoint's document fails.",
+    "oracle": "exception",
+    "surfaces": [
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit"
+    ],
+    "heldBy": [
+      "PatchSchemaTests"
+    ]
+  },
+  {
+    "id": "P07-required-too",
+    "source": "docs/merge-patches.md#required-constructor-parameters",
+    "quote": "It makes every constructor parameter without a default required, a patch's too.",
+    "claim": "It makes every constructor parameter without a default required, a patch's too.",
+    "oracle": "claim",
+    "surfaces": [
+      "PatchJsonConverterFactory.*"
+    ],
+    "heldBy": [
+      "MergePatchesTests",
+      "PatchSchemaTests"
+    ]
+  },
+  {
+    "id": "P08-a-built-in-type",
+    "source": "docs/merge-patches.md#source-generated-contexts-and-native-aot",
+    "quote": "**A primitive, a `string`, a `Guid`, a date or a `Uri`** is read with the serializer's built-in converter.",
+    "claim": "**A primitive, a `string`, a `Guid`, a date or a `Uri`** is read with the serializer's built-in converter.",
+    "oracle": "claim",
+    "surfaces": [
+      "PatchJsonConverterFactory.*"
+    ],
+    "heldBy": [
+      "PatchTests"
+    ]
+  },
+  {
+    "id": "P08-a-value-object",
+    "source": "docs/merge-patches.md#source-generated-contexts-and-native-aot",
+    "quote": "**A value object** is read with its own converter.",
+    "claim": "**A value object** is read with its own converter.",
+    "oracle": "claim",
+    "surfaces": [
+      "PatchJsonConverterFactory.*"
+    ],
+    "heldBy": [
+      "SourceGeneratedJsonTests"
+    ]
+  },
+  {
+    "id": "P08-any-other-type-is-listed",
+    "source": "docs/merge-patches.md#source-generated-contexts-and-native-aot",
+    "quote": "**Any other type, a class or an enum,** must be listed in the context. Otherwise the serializer throws with its own message naming the type.",
+    "claim": "**Any other type, a class or an enum,** must be listed in the context. Otherwise the serializer throws with its own message naming the type.",
+    "oracle": "exception",
+    "surfaces": [
+      "PatchJsonConverterFactory.*"
+    ],
+    "heldBy": [
+      "PatchTests",
+      "MergePatchesTests"
+    ]
+  },
+  {
+    "id": "Q01-delegate-condition-reported",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#a-condition-that-reads-every-row",
+    "quote": "The rule reports that call, and its message names the overload it fell to.",
+    "claim": "The rule reports that call, and its message names the overload it fell to.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.FirstOrNone",
+      "Option.SingleOrNone",
+      "Option.LastOrNone",
+      "Result.FirstOrError",
+      "Result.LastOrError"
+    ],
+    "heldBy": [
+      "QueryDelegateConditionTests"
+    ]
+  },
+  {
+    "id": "Q02-last-forms-too",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#a-condition-that-reads-every-row",
+    "quote": "`LastOrNone` and `LastOrError` are reported as well.",
+    "claim": "`LastOrNone` and `LastOrError` are reported as well.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.FirstOrNone",
+      "Option.SingleOrNone",
+      "Option.LastOrNone",
+      "Result.FirstOrError",
+      "Result.LastOrError"
+    ],
+    "heldBy": [
+      "QueryDelegateConditionTests"
+    ]
+  },
+  {
+    "id": "Q03-as-enumerable-silent",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#a-condition-that-reads-every-row",
+    "quote": "To read every row on purpose, call `AsEnumerable()` first, and the rule stays silent.",
+    "claim": "To read every row on purpose, call `AsEnumerable()` first, and the rule stays silent.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.FirstOrNone",
+      "Option.SingleOrNone",
+      "Option.LastOrNone",
+      "Result.FirstOrError",
+      "Result.LastOrError"
+    ],
+    "heldBy": [
+      "QueryDelegateConditionTests"
+    ]
+  },
+  {
+    "id": "Q04-sequence-held-query-silent",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#a-condition-that-reads-every-row",
+    "quote": "A query held as an `IEnumerable<T>` is a sequence to the rule.",
+    "claim": "A query held as an `IEnumerable<T>` is a sequence to the rule.",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.FirstOrNone",
+      "Option.SingleOrNone",
+      "Option.LastOrNone",
+      "Result.FirstOrError",
+      "Result.LastOrError"
+    ],
+    "heldBy": [
+      "QueryDelegateConditionTests"
+    ]
+  },
+  {
+    "id": "Q05-ef-readme-warns",
+    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#an-option-for-nothing-found",
+    "quote": "Then every row is read and the condition runs in memory, and the analyzer warns at the call",
+    "claim": "Then every row is read and the condition runs in memory, and the analyzer warns at the call",
+    "oracle": "claim",
+    "surfaces": [
+      "Option.FirstOrNone",
+      "Option.SingleOrNone",
+      "Option.LastOrNone",
+      "Result.FirstOrError",
+      "Result.LastOrError"
+    ],
+    "heldBy": [
+      "QueryDelegateConditionTests"
+    ]
+  },
+  {
+    "id": "R01-a-bare-error-converts-to-a-command",
+    "source": "docs/result.md#pick-a-shape",
+    "quote": "A `Result<TError>` has no value to confuse it with, so there a bare error converts on its own, and so does the `Result.Success()` marker.",
+    "claim": "A `Result<TError>` has no value to confuse it with, so there a bare error converts on its own, and so does the `Result.Success()` marker.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.op_Implicit",
+      "Result.Success"
+    ],
+    "heldBy": [
+      "ResultTests"
+    ]
+  },
+  {
+    "id": "R01-a-bare-value-is-a-success",
+    "source": "docs/result.md#pick-a-shape",
+    "quote": "Return a bare value for a success. Wrap an error in `Result.Error(...)`, because in a `Result<long, int>` a bare `5` could be either.",
+    "claim": "Return a bare value for a success. Wrap an error in `Result.Error(...)`, because in a `Result<long, int>` a bare `5` could be either.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.op_Implicit",
+      "Result.Error"
+    ],
+    "heldBy": [
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R01-to-http-result-accepts-four",
+    "source": "docs/result.md#pick-a-shape",
+    "quote": "`ToHttpResult()` accepts the first four.",
+    "claim": "`ToHttpResult()` accepts the first four.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitHttpResultExtensions.ToHttpResult",
+      "TypeKitClosedSetHttpResultExtensions.ToHttpResult"
+    ],
+    "heldBy": [
+      "FaultResponsePartsTests",
+      "ComposedFaultResponseTests"
+    ]
+  },
+  {
+    "id": "R02-a-default-result-throws",
+    "source": "docs/result.md#get-the-outcome-out",
+    "quote": "Every branching member throws on it, rather than inventing a `default(TError)`.",
+    "claim": "Every branching member throws on it, rather than inventing a `default(TError)`.",
+    "oracle": "exception",
+    "surfaces": [
+      "Result..ctor",
+      "Result.Match"
+    ],
+    "heldBy": [
+      "UninitializedResultTests"
+    ]
+  },
+  {
+    "id": "R02-match",
+    "source": "docs/result.md#get-the-outcome-out",
+    "quote": "`Match` takes one branch for a success and one for an error, and returns what they return.",
+    "claim": "`Match` takes one branch for a success and one for an error, and returns what they return.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Match"
+    ],
+    "heldBy": [
+      "ResultTests",
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R02-only-a-command-converts-to-bool",
+    "source": "docs/result.md#get-the-outcome-out",
+    "quote": "Only `Result<TError>` converts to `bool`, so `if (checkout.Charge(total))` reads as it should. A result with a value doesn't convert.",
+    "claim": "Only `Result<TError>` converts to `bool`, so `if (checkout.Charge(total))` reads as it should. A result with a value doesn't convert.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.op_Implicit"
+    ],
+    "heldBy": [
+      "ResultWithValueTests",
+      "ResultTests"
+    ]
+  },
+  {
+    "id": "R02-state",
+    "source": "docs/result.md#get-the-outcome-out",
+    "quote": "`State` tells the three states apart without throwing: `Success`, `Error`, and `Uninitialized`.",
+    "claim": "`State` tells the three states apart without throwing: `Success`, `Error`, and `Uninitialized`.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.State"
+    ],
+    "heldBy": [
+      "UninitializedResultTests"
+    ]
+  },
+  {
+    "id": "R02-the-analyzer-reports-defaults",
+    "source": "docs/result.md#get-the-outcome-out",
+    "quote": "It reports an array of results created with a length (CMTK0005), and a `default` written in your code (CMTK0001).",
+    "claim": "It reports an array of results created with a length (CMTK0005), and a `default` written in your code (CMTK0001).",
+    "oracle": "claim",
+    "surfaces": [
+      "Result..ctor"
+    ],
+    "heldBy": [
+      "DefaultFilledCollectionAnalyzerTests",
+      "ForbiddenDefaultInitializationAnalyzerTests"
+    ]
+  },
+  {
+    "id": "R02-try-get-value",
+    "source": "docs/result.md#get-the-outcome-out",
+    "quote": "`value` is non-null when it returns true, and `error` is non-null when it returns false.",
+    "claim": "`value` is non-null when it returns true, and `error` is non-null when it returns false.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.TryGetValue"
+    ],
+    "heldBy": [
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R03-on-a-success",
+    "source": "docs/result.md#chain-steps",
+    "quote": "**On a success:** `Map`, `Bind`, `Tap` and `Ensure`. An error passes through them.",
+    "claim": "**On a success:** `Map`, `Bind`, `Tap` and `Ensure`. An error passes through them.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Map",
+      "Result.Bind",
+      "Result.Tap",
+      "Result.Ensure"
+    ],
+    "heldBy": [
+      "ResultTests",
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R03-on-an-error",
+    "source": "docs/result.md#chain-steps",
+    "quote": "**On an error:** `MapError`, `TapError` and `Recover`. A success passes through them.",
+    "claim": "**On an error:** `MapError`, `TapError` and `Recover`. A success passes through them.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.MapError",
+      "Result.TapError",
+      "Result.Recover"
+    ],
+    "heldBy": [
+      "ResultTests",
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R03-recover-is-a-second-chance",
+    "source": "docs/result.md#chain-steps",
+    "quote": "Its selector returns a success or another error, which gives the operation a second chance",
+    "claim": "Its selector returns a success or another error, which gives the operation a second chance",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Recover"
+    ],
+    "heldBy": [
+      "ResultTests",
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R03-the-first-error-stops-the-chain",
+    "source": "docs/result.md#chain-steps",
+    "quote": "The first error stops the chain, and every step after it is skipped.",
+    "claim": "The first error stops the chain, and every step after it is skipped.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Bind",
+      "Result.Map",
+      "Result.Ensure"
+    ],
+    "heldBy": [
+      "ResultWithValueTests",
+      "ResultContinuationTests"
+    ]
+  },
+  {
+    "id": "R04-a-callback-s-exception-comes-out",
+    "source": "docs/result.md#async-chains",
+    "quote": "So whatever a callback throws comes out of the chain's `await`.",
+    "claim": "So whatever a callback throws comes out of the chain's `await`.",
+    "oracle": "exception",
+    "surfaces": [
+      "Result.BindAsync",
+      "Result.TapErrorAsync"
+    ],
+    "heldBy": [
+      "ResultContinuationTests"
+    ]
+  },
+  {
+    "id": "R04-a-value-task-does-not-wait",
+    "source": "docs/result.md#async-chains",
+    "quote": "Otherwise `TapAsync` and `TapErrorAsync` bind to their synchronous overload and don't wait, and `MapAsync` keeps the `ValueTask` itself as the value.",
+    "claim": "Otherwise `TapAsync` and `TapErrorAsync` bind to their synchronous overload and don't wait, and `MapAsync` keeps the `ValueTask` itself as the value.",
+    "oracle": "silent-default",
+    "surfaces": [
+      "Result.TapAsync",
+      "Result.TapErrorAsync",
+      "Result.MapAsync"
+    ],
+    "heldBy": [
+      "ResultContinuationTests"
+    ]
+  },
+  {
+    "id": "R04-awaited-once",
+    "source": "docs/result.md#async-chains",
+    "quote": "The asynchronous members continue a `Task<Result<...>>` without an `await` at each step.",
+    "claim": "The asynchronous members continue a `Task<Result<...>>` without an `await` at each step.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.MapAsync",
+      "Result.BindAsync",
+      "Result.EnsureAsync",
+      "Result.TapErrorAsync"
+    ],
+    "heldBy": [
+      "ResultContinuationTests"
+    ]
+  },
+  {
+    "id": "R05-a-finished-task-runs-at-once",
+    "source": "docs/result.md#where-a-callback-runs",
+    "quote": "**The task had already finished.** The callback runs at once, on your thread and context.",
+    "claim": "**The task had already finished.** The callback runs at once, on your thread and context.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.MapAsync"
+    ],
+    "heldBy": [
+      "AsynchronousContextTests"
+    ]
+  },
+  {
+    "id": "R05-a-running-task-runs-elsewhere",
+    "source": "docs/result.md#where-a-callback-runs",
+    "quote": "**The task was still running.** The callback runs wherever the task finishes, usually on a thread-pool thread, without your context.",
+    "claim": "**The task was still running.** The callback runs wherever the task finishes, usually on a thread-pool thread, without your context.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.MapAsync"
+    ],
+    "heldBy": [
+      "AsynchronousContextTests"
+    ]
+  },
+  {
+    "id": "R05-configure-await-false",
+    "source": "docs/result.md#where-a-callback-runs",
+    "quote": "Every `await` inside the package uses `ConfigureAwait(false)`. Nothing resumes on your `SynchronizationContext`.",
+    "claim": "Every `await` inside the package uses `ConfigureAwait(false)`. Nothing resumes on your `SynchronizationContext`.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.MapAsync",
+      "Result.BindAsync",
+      "Result.TraverseAsync"
+    ],
+    "heldBy": [
+      "AsynchronousContextTests"
+    ]
+  },
+  {
+    "id": "R05-every-continuation",
+    "source": "docs/result.md#where-a-callback-runs",
+    "quote": "That holds for every continuation of a pending result, for `TraverseAsync` after its first operation, and for every step after one that waited.",
+    "claim": "That holds for every continuation of a pending result, for `TraverseAsync` after its first operation, and for every step after one that waited.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.TraverseAsync",
+      "Result.MapAsync"
+    ],
+    "heldBy": [
+      "AsynchronousContextTests"
+    ]
+  },
+  {
+    "id": "R05-no-deadlock",
+    "source": "docs/result.md#where-a-callback-runs",
+    "quote": "If you block on a chain with `.Result` or `.Wait()`, the package's own awaits don't deadlock you.",
+    "claim": "If you block on a chain with `.Result` or `.Wait()`, the package's own awaits don't deadlock you.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.MapAsync",
+      "Result.BindAsync"
+    ],
+    "heldBy": [
+      "AsynchronousContextTests"
+    ]
+  },
+  {
+    "id": "R06-a-cancellation-propagates",
+    "source": "docs/result.md#collect-many-results",
+    "quote": "A cancellation propagates as an exception and doesn't become an error.",
+    "claim": "A cancellation propagates as an exception and doesn't become an error.",
+    "oracle": "exception",
+    "surfaces": [
+      "Result.TraverseAsync"
+    ],
+    "heldBy": [
+      "ResultTraverseAsyncTests",
+      "OptionPatchTraverseAsyncTests"
+    ]
+  },
+  {
+    "id": "R06-none-calls-nothing",
+    "source": "docs/result.md#collect-many-results",
+    "quote": "`None`, a clear and an absent field call nothing and pass through.",
+    "claim": "`None`, a clear and an absent field call nothing and pass through.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.TraverseAsync"
+    ],
+    "heldBy": [
+      "OptionPatchTraverseAsyncTests"
+    ]
+  },
+  {
+    "id": "R06-one-at-a-time",
+    "source": "docs/result.md#collect-many-results",
+    "quote": "It awaits each operation before it starts the next, so nothing starts after a fault.",
+    "claim": "It awaits each operation before it starts the next, so nothing starts after a fault.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.TraverseAsync"
+    ],
+    "heldBy": [
+      "ResultTraverseAsyncTests"
+    ]
+  },
+  {
+    "id": "R06-option-or-patch-once",
+    "source": "docs/result.md#collect-many-results",
+    "quote": "On an `Option` or a `Patch`, `TraverseAsync` runs the operation once, when there is a value.",
+    "claim": "On an `Option` or a `Patch`, `TraverseAsync` runs the operation once, when there is a value.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.TraverseAsync"
+    ],
+    "heldBy": [
+      "OptionPatchTraverseAsyncTests"
+    ]
+  },
+  {
+    "id": "R06-stop-at-the-first-error",
+    "source": "docs/result.md#collect-many-results",
+    "quote": "`Traverse`, `Sequence` and `Zip` (two to six results) stop at the first error, in the order of the sequence or the arguments.",
+    "claim": "`Traverse`, `Sequence` and `Zip` (two to six results) stop at the first error, in the order of the sequence or the arguments.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Traverse",
+      "Result.Sequence",
+      "Result.Zip"
+    ],
+    "heldBy": [
+      "ResultCombinationTests"
+    ]
+  },
+  {
+    "id": "R06-the-token",
+    "source": "docs/result.md#collect-many-results",
+    "quote": "Give it a cancellation token, and it checks the token before each operation and hands it on.",
+    "claim": "Give it a cancellation token, and it checks the token before each operation and hands it on.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.TraverseAsync"
+    ],
+    "heldBy": [
+      "ResultTraverseAsyncTests",
+      "OptionPatchTraverseAsyncTests"
+    ]
+  },
+  {
+    "id": "R06-traverse-calls-nothing-after-an-error",
+    "source": "docs/result.md#collect-many-results",
+    "quote": "`Traverse` doesn't call its selector for anything after that error.",
+    "claim": "`Traverse` doesn't call its selector for anything after that error.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Traverse"
+    ],
+    "heldBy": [
+      "ResultCombinationTests"
+    ]
+  },
+  {
+    "id": "R07-a-cancellation-is-not-an-outcome",
+    "source": "docs/result.md#an-exception-as-an-outcome",
+    "quote": "An `OperationCanceledException` passes through every overload. So does an `AggregateException` that holds only cancellations, as `Wait()` and `.Result` throw for a cancelled task.",
+    "claim": "An `OperationCanceledException` passes through every overload. So does an `AggregateException` that holds only cancellations, as `Wait()` and `.Result` throw for a cancelled task.",
+    "oracle": "exception",
+    "surfaces": [
+      "Result.Catch",
+      "Result.CatchAsync"
+    ],
+    "heldBy": [
+      "ResultCatchTests",
+      "CatchAsyncValueTaskTests"
+    ]
+  },
+  {
+    "id": "R07-a-timeout-is-an-error",
+    "source": "docs/result.md#an-exception-as-an-outcome",
+    "quote": "A cancellation over a `TimeoutException` is the error, wrapped or not. That is how `HttpClient` reports that its `Timeout` elapsed and the call failed. `.Result` on such a call gives the error too.",
+    "claim": "A cancellation over a `TimeoutException` is the error, wrapped or not. That is how `HttpClient` reports that its `Timeout` elapsed and the call failed. `.Result` on such a call gives the error too.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Catch",
+      "Result.CatchAsync"
+    ],
+    "heldBy": [
+      "ResultCatchTests",
+      "CatchAsyncValueTaskTests"
+    ]
+  },
+  {
+    "id": "R07-a-value-task-alike",
+    "source": "docs/result.md#an-exception-as-an-outcome",
+    "quote": "A `ValueTask` works the same way",
+    "claim": "A `ValueTask` works the same way",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.CatchAsync"
+    ],
+    "heldBy": [
+      "CatchAsyncValueTaskTests"
+    ]
+  },
+  {
+    "id": "R07-an-aggregate-of-anything-else",
+    "source": "docs/result.md#an-exception-as-an-outcome",
+    "quote": "An `AggregateException` that holds anything else is the error, as it was thrown.",
+    "claim": "An `AggregateException` that holds anything else is the error, as it was thrown.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Catch"
+    ],
+    "heldBy": [
+      "ResultCatchTests"
+    ]
+  },
+  {
+    "id": "R07-catch",
+    "source": "docs/result.md#an-exception-as-an-outcome",
+    "quote": "`Result.Catch` runs the call and gives you its value, or the exception as the error",
+    "claim": "`Result.Catch` runs the call and gives you its value, or the exception as the error",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Catch"
+    ],
+    "heldBy": [
+      "ResultCatchTests"
+    ]
+  },
+  {
+    "id": "R07-catch-async-awaits",
+    "source": "docs/result.md#an-exception-as-an-outcome",
+    "quote": "It awaits the task, so an exception thrown after the task's first `await` is the error too.",
+    "claim": "It awaits the task, so an exception thrown after the task's first `await` is the error too.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.CatchAsync"
+    ],
+    "heldBy": [
+      "ResultCatchTests",
+      "CatchAsyncValueTaskTests"
+    ]
+  },
+  {
+    "id": "R07-catch-over-a-task-does-not-compile",
+    "source": "docs/result.md#an-exception-as-an-outcome",
+    "quote": "Passing a delegate that returns a `Task` to `Catch` fails to compile, and the error names `CatchAsync`.",
+    "claim": "Passing a delegate that returns a `Task` to `Catch` fails to compile, and the error names `CatchAsync`.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Catch"
+    ],
+    "heldBy": [
+      "ResultCatchTests"
+    ]
+  },
+  {
+    "id": "R07-only-the-first-of-several",
+    "source": "docs/result.md#an-exception-as-an-outcome",
+    "quote": "A task that faulted with several exceptions throws only the first of them.",
+    "claim": "A task that faulted with several exceptions throws only the first of them.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.CatchAsync"
+    ],
+    "heldBy": [
+      "ResultCatchTests",
+      "ResultTests"
+    ]
+  },
+  {
+    "id": "R07-the-other-members-do-not-catch",
+    "source": "docs/result.md#an-exception-as-an-outcome",
+    "quote": "`Map`, `Bind` and the rest are unchanged: a selector that throws propagates.",
+    "claim": "`Map`, `Bind` and the rest are unchanged: a selector that throws propagates.",
+    "oracle": "exception",
+    "surfaces": [
+      "Result.Map",
+      "Result.Bind"
+    ],
+    "heldBy": [
+      "ResultCatchTests"
+    ]
+  },
+  {
+    "id": "R07-to-http-result-refuses-an-exception",
+    "source": "docs/result.md#an-exception-as-an-outcome",
+    "quote": "`ToHttpResult()` doesn't accept a `Result<T, Exception>`",
+    "claim": "`ToHttpResult()` doesn't accept a `Result<T, Exception>`",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitHttpResultExtensions.ToHttpResult",
+      "TypeKitClosedSetHttpResultExtensions.ToHttpResult"
+    ],
+    "heldBy": [
+      "FaultResponsePartsTests"
+    ]
+  },
+  {
+    "id": "R08-no-where",
+    "source": "docs/result.md#use-query-syntax",
+    "quote": "There is no `where`: a result has no error to give a value that is filtered out.",
+    "claim": "There is no `where`: a result has no error to give a value that is filtered out.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Select",
+      "Result.SelectMany"
+    ],
+    "heldBy": [
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R08-select-and-select-many",
+    "source": "docs/result.md#use-query-syntax",
+    "quote": "`Select` and `SelectMany` make query syntax work.",
+    "claim": "`Select` and `SelectMany` make query syntax work.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Select",
+      "Result.SelectMany"
+    ],
+    "heldBy": [
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R09-a-bare-error-is-not-a-result",
+    "source": "docs/result.md#the-surface",
+    "quote": "a bare value is a success; a bare error is not, since it could be either",
+    "claim": "a bare value is a success; a bare error is not, since it could be either",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.op_Implicit"
+    ],
+    "heldBy": [
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R09-as-enumerable",
+    "source": "docs/result.md#the-surface",
+    "quote": "| `AsEnumerable()` | `Result<T, TError>` | zero or one element |",
+    "claim": "| `AsEnumerable()` | `Result<T, TError>` | zero or one element |",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.AsEnumerable"
+    ],
+    "heldBy": [
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R09-bind",
+    "source": "docs/result.md#the-surface",
+    "quote": "the result the selector returns on a success; a valued one can bind to a command",
+    "claim": "the result the selector returns on a success; a valued one can bind to a command",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Bind"
+    ],
+    "heldBy": [
+      "ResultTests",
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R09-catch-async",
+    "source": "docs/result.md#the-surface",
+    "quote": "the same, awaiting the `Task` or `ValueTask`",
+    "claim": "the same, awaiting the `Task` or `ValueTask`",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.CatchAsync"
+    ],
+    "heldBy": [
+      "ResultCatchTests",
+      "CatchAsyncValueTaskTests"
+    ]
+  },
+  {
+    "id": "R09-catch-narrowed",
+    "source": "docs/result.md#the-surface",
+    "quote": "`Result<T, Exception>` or `Result<Exception>`; narrowed to one exception type",
+    "claim": "`Result<T, Exception>` or `Result<Exception>`; narrowed to one exception type",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Catch"
+    ],
+    "heldBy": [
+      "ResultCatchTests"
+    ]
+  },
+  {
+    "id": "R09-continuations",
+    "source": "docs/result.md#the-surface",
+    "quote": "the same, taking or continuing a task; the chain is awaited once",
+    "claim": "the same, taking or continuing a task; the chain is awaited once",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.MapAsync",
+      "Result.BindAsync",
+      "Result.RecoverAsync",
+      "Result.TapAsync",
+      "Result.TapErrorAsync"
+    ],
+    "heldBy": [
+      "ResultContinuationTests",
+      "ResultTests",
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R09-debugger-shows-both",
+    "source": "docs/result.md#the-surface",
+    "quote": "`ToString()` prints the state and never the value or the error, so a result is safe to log. The debugger shows both.",
+    "claim": "`ToString()` prints the state and never the value or the error, so a result is safe to log. The debugger shows both.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.ToString"
+    ],
+    "heldBy": [
+      "TextRepresentationTests"
+    ]
+  },
+  {
+    "id": "R09-ensure",
+    "source": "docs/result.md#the-surface",
+    "quote": "a success that fails the predicate becomes that error",
+    "claim": "a success that fails the predicate becomes that error",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Ensure"
+    ],
+    "heldBy": [
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R09-equality",
+    "source": "docs/result.md#the-surface",
+    "quote": "Equality works as for any record struct.",
+    "claim": "Equality works as for any record struct.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Equals",
+      "Result.GetHashCode",
+      "Result.op_Equality",
+      "Result.op_Inequality"
+    ],
+    "heldBy": [
+      "ResultTests",
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R09-error-marker-converts-to-either",
+    "source": "docs/result.md#the-surface",
+    "quote": "an `Error<TError>` marker that converts to either shape",
+    "claim": "an `Error<TError>` marker that converts to either shape",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Error",
+      "Result.op_Implicit"
+    ],
+    "heldBy": [
+      "ResultTests",
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R09-first-or-error",
+    "source": "docs/result.md#the-surface",
+    "quote": "the first or last match, or the error; on a query the provider runs the predicate, and `LastOrError` is a compile error",
+    "claim": "the first or last match, or the error; on a query the provider runs the predicate, and `LastOrError` is a compile error",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.FirstOrError",
+      "Result.LastOrError"
+    ],
+    "heldBy": [
+      "ResultWithValueTests",
+      "QueryableOptionTests"
+    ]
+  },
+  {
+    "id": "R09-map",
+    "source": "docs/result.md#the-surface",
+    "quote": "a new value on a success; `Result<T, TError>` from a `Result<TError>`",
+    "claim": "a new value on a success; `Result<T, TError>` from a `Result<TError>`",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Map"
+    ],
+    "heldBy": [
+      "ResultTests",
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R09-map-error",
+    "source": "docs/result.md#the-surface",
+    "quote": "| `MapError(selector)` | both | a new error type |",
+    "claim": "| `MapError(selector)` | both | a new error type |",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.MapError"
+    ],
+    "heldBy": [
+      "ResultTests",
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R09-map-error-and-ensure-async",
+    "source": "docs/result.md#the-surface",
+    "quote": "`MapError` and `Ensure`, once the result is known",
+    "claim": "`MapError` and `Ensure`, once the result is known",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.MapErrorAsync",
+      "Result.EnsureAsync"
+    ],
+    "heldBy": [
+      "ResultContinuationTests"
+    ]
+  },
+  {
+    "id": "R09-match",
+    "source": "docs/result.md#the-surface",
+    "quote": "what the branch returns; `onError` may take the error or nothing",
+    "claim": "what the branch returns; `onError` may take the error or nothing",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Match"
+    ],
+    "heldBy": [
+      "ResultTests",
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R09-recover",
+    "source": "docs/result.md#the-surface",
+    "quote": "the selector's result on an error, a success or another error",
+    "claim": "the selector's result on an error, a success or another error",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Recover",
+      "Result.RecoverAsync"
+    ],
+    "heldBy": [
+      "ResultTests",
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R09-sequence",
+    "source": "docs/result.md#the-surface",
+    "quote": "| `Sequence()` | `IEnumerable<Result<T, TError>>`, `IEnumerable<Result<TError>>` | the list of values, or the first error |",
+    "claim": "| `Sequence()` | `IEnumerable<Result<T, TError>>`, `IEnumerable<Result<TError>>` | the list of values, or the first error |",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Sequence"
+    ],
+    "heldBy": [
+      "ResultCombinationTests"
+    ]
+  },
+  {
+    "id": "R09-success-marker",
+    "source": "docs/result.md#the-surface",
+    "quote": "a `Success` marker that converts to any `Result<TError>`",
+    "claim": "a `Success` marker that converts to any `Result<TError>`",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Success",
+      "Result.op_Implicit"
+    ],
+    "heldBy": [
+      "ResultTests"
+    ]
+  },
+  {
+    "id": "R09-tap",
+    "source": "docs/result.md#the-surface",
+    "quote": "runs the action on that branch, hands the result on",
+    "claim": "runs the action on that branch, hands the result on",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Tap",
+      "Result.TapError"
+    ],
+    "heldBy": [
+      "ResultTests",
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R09-to-option",
+    "source": "docs/result.md#the-surface",
+    "quote": "`Some(value)`, or `None` for an error",
+    "claim": "`Some(value)`, or `None` for an error",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.ToOption"
+    ],
+    "heldBy": [
+      "ResultWithValueTests"
+    ]
+  },
+  {
+    "id": "R09-transpose",
+    "source": "docs/result.md#the-surface",
+    "quote": "the one turned inside out: `None` is a success without a value, an error stays the error",
+    "claim": "the one turned inside out: `None` is a success without a value, an error stays the error",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Transpose"
+    ],
+    "heldBy": [
+      "OptionLookupTests"
+    ]
+  },
+  {
+    "id": "R09-traverse-option",
+    "source": "docs/result.md#the-surface",
+    "quote": "`Result<Option<TResult>, TError>`: an optional input validated when present",
+    "claim": "`Result<Option<TResult>, TError>`: an optional input validated when present",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Traverse"
+    ],
+    "heldBy": [
+      "OptionLookupTests"
+    ]
+  },
+  {
+    "id": "R09-traverse-patch",
+    "source": "docs/result.md#the-surface",
+    "quote": "`Result<Patch<TResult>, TError>`: a patch field validated when it carries a value; a clear or an absence passes through",
+    "claim": "`Result<Patch<TResult>, TError>`: a patch field validated when it carries a value; a clear or an absence passes through",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Traverse"
+    ],
+    "heldBy": [
+      "PatchCombinationTests"
+    ]
+  },
+  {
+    "id": "R09-try-get-error",
+    "source": "docs/result.md#the-surface",
+    "quote": "| `TryGetError(out error)` | `Result<TError>` | `bool` |",
+    "claim": "| `TryGetError(out error)` | `Result<TError>` | `bool` |",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.TryGetError"
+    ],
+    "heldBy": [
+      "ResultTests"
+    ]
+  },
+  {
+    "id": "R09-zip",
+    "source": "docs/result.md#the-surface",
+    "quote": "one value from all, or the first error",
+    "claim": "one value from all, or the first error",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.Zip"
+    ],
+    "heldBy": [
+      "ResultCombinationTests"
+    ]
+  },
+  {
+    "id": "S01-a-closed-set-is-its-name",
+    "source": "src/CodoMetis.TypeKit.Serilog/README.md#codometistypekitserilog",
+    "quote": "**A closed set is logged as its name**, or as what its own `ToString()` prints, never by its properties.",
+    "claim": "**A closed set is logged as its name**, or as what its own `ToString()` prints, never by its properties.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitSerilogExtensions.WithTypeKit"
+    ],
+    "heldBy": [
+      "DestructuringTests"
+    ]
+  },
+  {
+    "id": "S01-a-list-of-them",
+    "source": "src/CodoMetis.TypeKit.Serilog/README.md#codometistypekitserilog",
+    "quote": "A list or a dictionary of them becomes a list or a dictionary of strings.",
+    "claim": "A list or a dictionary of them becomes a list or a dictionary of strings.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitSerilogExtensions.WithTypeKit"
+    ],
+    "heldBy": [
+      "DestructuringTests"
+    ]
+  },
+  {
+    "id": "S01-an-instance-beside-the-members",
+    "source": "src/CodoMetis.TypeKit.Serilog/README.md#codometistypekitserilog",
+    "quote": "An instance that the set's own code made beside its members has no name, and Serilog logs that it could not capture it.",
+    "claim": "An instance that the set's own code made beside its members has no name, and Serilog logs that it could not capture it.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitSerilogExtensions.WithTypeKit"
+    ],
+    "heldBy": [
+      "DestructuringTests"
+    ]
+  },
+  {
+    "id": "S01-as-what-they-print",
+    "source": "src/CodoMetis.TypeKit.Serilog/README.md#codometistypekitserilog",
+    "quote": "value objects and closed sets as what they print, also where it destructures them. A value object that masks itself stays masked.",
+    "claim": "value objects and closed sets as what they print, also where it destructures them. A value object that masks itself stays masked.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitSerilogExtensions.WithTypeKit"
+    ],
+    "heldBy": [
+      "DestructuringTests",
+      "SerilogSamples",
+      "LoggingTests"
+    ]
+  },
+  {
+    "id": "S01-every-other-type-as-before",
+    "source": "src/CodoMetis.TypeKit.Serilog/README.md#codometistypekitserilog",
+    "quote": "Serilog handles every other type as before.",
+    "claim": "Serilog handles every other type as before.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitSerilogExtensions.WithTypeKit"
+    ],
+    "heldBy": [
+      "DestructuringTests"
+    ]
+  },
+  {
+    "id": "S01-every-value-object-is-a-string",
+    "source": "src/CodoMetis.TypeKit.Serilog/README.md#codometistypekitserilog",
+    "quote": "**Every value object becomes a string**, masked or not.",
+    "claim": "**Every value object becomes a string**, masked or not.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitSerilogExtensions.WithTypeKit"
+    ],
+    "heldBy": [
+      "DestructuringTests"
+    ]
+  },
+  {
+    "id": "S01-not-the-generators",
+    "source": "src/CodoMetis.TypeKit.Serilog/README.md#codometistypekitserilog",
+    "quote": "So the host needs this package and the base package, not the generators.",
+    "claim": "So the host needs this package and the base package, not the generators.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitSerilogExtensions.WithTypeKit"
+    ],
+    "heldBy": [
+      "PackageDependencyTests"
+    ]
+  },
+  {
+    "id": "S01-unmasked-without-it",
+    "source": "src/CodoMetis.TypeKit.Serilog/README.md#codometistypekitserilog",
+    "quote": "Without this package, a value object that masks itself with a hand-written `ToString()` is logged unmasked there, as `{ Value: \"k-123\" }`.",
+    "claim": "Without this package, a value object that masks itself with a hand-written `ToString()` is logged unmasked there, as `{ Value: \"k-123\" }`.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitSerilogExtensions.WithTypeKit"
+    ],
+    "heldBy": [
+      "DestructuringTests"
+    ]
+  },
+  {
+    "id": "T01-an-error-learns-only-new-api-forms",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#configuration",
+    "quote": "A minor version may teach an Error a form that only its own new API can write.",
+    "claim": "Within a major version an Error reports nothing more of the code a consumer could already write; a minor version's Error reports only forms that call that version's new API, such as 2.3.0's CMTK0003 on an unawaited Testing assertion over a Task or ValueTask, recognised by the Testing assembly so that a consumer's own extension of the same name stays silent.",
+    "oracle": "claim",
+    "surfaces": [
+      "OptionAssertions.*",
+      "ResultAssertions.*",
+      "PatchAssertions.*"
+    ],
+    "heldBy": [
+      "IgnoredOutcomeAnalyzerTests"
+    ]
+  },
+  {
+    "id": "T02-a-few-2-2-forms-are-reported",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#configuration",
+    "quote": "2.3.0 makes an exception for a few forms that code from before 2.3.0 can contain.",
+    "claim": "2.3.0's CMTK0003 reports, on tasks of results, a Task.WhenAny of tasks the statement made in any use, a dropped Task.WhenEach, Wait() on a branch and an array written in Task.WaitAll or Task.WaitAny, all forms 2.2.0 code can contain; a WhenAny of held tasks stays silent.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.*"
+    ],
+    "heldBy": [
+      "DroppedTaskVariantTests",
+      "IgnoredOutcomeAnalyzerTests"
+    ]
+  },
+  {
+    "id": "T02-a-wrapped-assertion-is-reported",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0003",
+    "quote": "It also reports an assertion passed through `ConfigureAwait` or `WaitAsync`, and one in a branch of a `?:`, `??` or `switch` expression, as it does for a dropped result.",
+    "claim": "It also reports an assertion passed through `ConfigureAwait` or `WaitAsync`, and one in a branch of a `?:`, `??` or `switch` expression, as it does for a dropped result.",
+    "oracle": "claim",
+    "surfaces": [
+      "OptionAssertions.*",
+      "ResultAssertions.*",
+      "PatchAssertions.*",
+      "FaultAssertions.*"
+    ],
+    "heldBy": [
+      "DroppedTaskVariantTests"
+    ]
+  },
+  {
+    "id": "T02-combined-assertions-are-reported",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0003",
+    "quote": "You get the report when you hand assertions to `Task.WhenAll`, `Task.Run` or `Task.WhenEach` and drop what it returns.",
+    "claim": "You get the report when you hand assertions to `Task.WhenAll`, `Task.Run` or `Task.WhenEach` and drop what it returns.",
+    "oracle": "claim",
+    "surfaces": [
+      "OptionAssertions.*",
+      "ResultAssertions.*",
+      "PatchAssertions.*",
+      "FaultAssertions.*"
+    ],
+    "heldBy": [
+      "DroppedTaskVariantTests"
+    ]
+  },
+  {
+    "id": "T02-wait-all-observes-assertions",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0003",
+    "quote": "`Task.WaitAll` throws the failures, so it is silent.",
+    "claim": "`Task.WaitAll` throws the failures, so it is silent.",
+    "oracle": "claim",
+    "surfaces": [
+      "OptionAssertions.*",
+      "ResultAssertions.*",
+      "PatchAssertions.*",
+      "FaultAssertions.*"
+    ],
+    "heldBy": [
+      "DroppedTaskVariantTests"
+    ]
+  },
+  {
+    "id": "T02-when-any-of-results-is-reported",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0003",
+    "quote": "A `WhenAny` of tasks the statement made is reported whether you drop it, await it, wait for it or return it as a plain `Task`.",
+    "claim": "A `WhenAny` of tasks the statement made is reported whether you drop it, await it, wait for it or return it as a plain `Task`.",
+    "oracle": "claim",
+    "surfaces": [
+      "Result.*"
+    ],
+    "heldBy": [
+      "IgnoredOutcomeAnalyzerTests",
+      "DroppedTaskVariantTests"
+    ]
+  },
+  {
+    "id": "T03-a-catch-that-cannot-keep-the-failure-is-reported",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0003",
+    "quote": "A `catch` that throws again, one for another exception, such as `catch (OperationCanceledException)`, and one with a `when (false)` filter are reported.",
+    "claim": "A `catch` that throws again, one for another exception, such as `catch (OperationCanceledException)`, and one with a `when (false)` filter are reported.",
+    "oracle": "claim",
+    "surfaces": [
+      "OptionAssertions.*",
+      "ResultAssertions.*",
+      "PatchAssertions.*",
+      "FaultAssertions.*"
+    ],
+    "heldBy": [
+      "DroppedTaskVariantTests",
+      "IgnoredOutcomeAnalyzerTests"
+    ]
+  },
+  {
+    "id": "T03-a-nested-when-any-is-reported",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0003",
+    "quote": "A `Task.WhenAny` inside a `Task.WhenAll` or a `Task.Run` is reported even when you await the outer task, because that task succeeds with the failed assertion as its value",
+    "claim": "A `Task.WhenAny` inside a `Task.WhenAll` or a `Task.Run` is reported even when you await the outer task, because that task succeeds with the failed assertion as its value",
+    "oracle": "claim",
+    "surfaces": [
+      "OptionAssertions.*",
+      "ResultAssertions.*",
+      "PatchAssertions.*",
+      "FaultAssertions.*"
+    ],
+    "heldBy": [
+      "DroppedTaskVariantTests",
+      "IgnoredOutcomeAnalyzerTests"
+    ]
+  },
+  {
+    "id": "T03-an-unknown-filter-counts-as-catching",
+    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0003",
+    "quote": "A filter the rule can't work out, such as `when (Expected(e))`, counts as catching the failure.",
+    "claim": "A filter the rule can't work out, such as `when (Expected(e))`, counts as catching the failure.",
+    "oracle": "claim",
+    "surfaces": [
+      "OptionAssertions.*",
+      "ResultAssertions.*",
+      "PatchAssertions.*",
+      "FaultAssertions.*"
+    ],
+    "heldBy": [
+      "DroppedTaskVariantTests",
+      "IgnoredOutcomeAnalyzerTests"
+    ]
+  },
+  {
+    "id": "W01-answers-are-real",
+    "source": "docs/walkthrough.md#walkthrough-one-orders-service",
+    "quote": "CI runs it on every change, and builds it from the packed packages too, so every answer below is one it really gives",
+    "claim": "CI runs it on every change, and builds it from the packed packages too, so every answer below is one it really gives",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit",
+      "TypeKitHttpResultExtensions.ToHttpResult",
+      "TypeKitDbContextOptionsBuilderExtensions.UseTypeKit",
+      "TypeKitSerilogExtensions.WithTypeKit"
+    ],
+    "heldBy": [
+      "WalkthroughTests"
+    ]
+  },
+  {
+    "id": "W02-a-column-of-the-underlying-type",
+    "source": "docs/walkthrough.md#store-them",
+    "quote": "The id is a `TEXT` key, as a `Guid` is on SQLite, and the quantity an `INTEGER`. The status is its member's name.",
+    "claim": "The id is a `TEXT` key, as a `Guid` is on SQLite, and the quantity an `INTEGER`. The status is its member's name.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitDbContextOptionsBuilderExtensions.UseTypeKit",
+      "ClosedSetConverter.*",
+      "ValueObjectConverter.*"
+    ],
+    "heldBy": [
+      "WalkthroughTests"
+    ]
+  },
+  {
+    "id": "W03-json-reads-through-create",
+    "source": "docs/walkthrough.md#place-an-order",
+    "quote": "So the handler receives `ann@example.com`, trimmed, and never sees the spaces.",
+    "claim": "So the handler receives `ann@example.com`, trimmed, and never sees the spaces.",
+    "oracle": "claim",
+    "surfaces": [
+      "GeneratedJson.*",
+      "StringTextExtensions.*",
+      "IValidatedValue.Create"
+    ],
+    "heldBy": [
+      "WalkthroughTests"
+    ]
+  },
+  {
+    "id": "W04-json-writes-the-string",
+    "source": "docs/walkthrough.md#place-an-order",
+    "quote": "the JSON is the underlying type's: `\"email\":\"ann@example.com\"`, a plain string, and the closed set is its name",
+    "claim": "the JSON is the underlying type's: `\"email\":\"ann@example.com\"`, a plain string, and the closed set is its name",
+    "oracle": "claim",
+    "surfaces": [
+      "GeneratedJson.*",
+      "IClosedSet.*"
+    ],
+    "heldBy": [
+      "WalkthroughTests"
+    ]
+  },
+  {
+    "id": "W05-log-masks",
+    "source": "docs/walkthrough.md#place-an-order",
+    "quote": "`Destructure.WithTypeKit()` logs each value object as what its `ToString()` prints.",
+    "claim": "`Destructure.WithTypeKit()` logs each value object as what its `ToString()` prints.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitSerilogExtensions.WithTypeKit"
+    ],
+    "heldBy": [
+      "WalkthroughTests"
+    ]
+  },
+  {
+    "id": "W06-rejections-never-quote",
+    "source": "docs/walkthrough.md#reject-what-doesnt-fit",
+    "quote": "Each of these is a 400 with problem details, and none of them quotes what the client sent",
+    "claim": "Each of these is a 400 with problem details, and none of them quotes what the client sent",
+    "oracle": "claim",
+    "surfaces": [
+      "GeneratedJson.*",
+      "GeneratedParsing.*"
+    ],
+    "heldBy": [
+      "WalkthroughTests"
+    ]
+  },
+  {
+    "id": "W07-none-is-a-404",
+    "source": "docs/walkthrough.md#find-an-order",
+    "quote": "`ToResult` turns a missing order into the error `NotFound`, and `ToHttpResult()` answers it with the status the setup maps it to, as problem details.",
+    "claim": "`ToResult` turns a missing order into the error `NotFound`, and `ToHttpResult()` answers it with the status the setup maps it to, as problem details.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitQueryableExtensions.*",
+      "TypeKitHttpResultExtensions.ToHttpResult"
+    ],
+    "heldBy": [
+      "WalkthroughTests"
+    ]
+  },
+  {
+    "id": "W08-left-out-errors-leave-the-document",
+    "source": "docs/walkthrough.md#find-an-order",
+    "quote": "The OpenAPI document then shows only the 404 for it, where it would otherwise list every status `OrderFault` maps to.",
+    "claim": "The OpenAPI document then shows only the 404 for it, where it would otherwise list every status `OrderFault` maps to.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitWithoutFaultsEndpointConventionBuilderExtensions.*",
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit"
+    ],
+    "heldBy": [
+      "WalkthroughTests"
+    ]
+  },
+  {
+    "id": "W09-value-is-the-column",
+    "source": "docs/walkthrough.md#query-on-value",
+    "quote": "In the query, `order.Quantity.Value` is the `Quantity` column itself, so the comparison runs in the database.",
+    "claim": "In the query, `order.Quantity.Value` is the `Quantity` column itself, so the comparison runs in the database.",
+    "oracle": "claim",
+    "surfaces": [
+      "IValueObject.Value",
+      "TypeKitDbContextOptionsBuilderExtensions.UseTypeKit"
+    ],
+    "heldBy": [
+      "WalkthroughTests"
+    ]
+  },
+  {
+    "id": "W10-patch-reads-through-create",
+    "source": "docs/walkthrough.md#change-an-order",
+    "quote": "Each field reads its value through its own `Create`, so `{\"quantity\":0}` is a 400 like any other body.",
+    "claim": "Each field reads its value through its own `Create`, so `{\"quantity\":0}` is a 400 like any other body.",
+    "oracle": "claim",
+    "surfaces": [
+      "PatchJsonConverterFactory.*",
+      "GeneratedJson.*"
+    ],
+    "heldBy": [
+      "WalkthroughTests"
+    ]
+  },
+  {
+    "id": "W11-document-describes-the-underlying-type",
+    "source": "docs/walkthrough.md#read-the-openapi-document",
+    "quote": "`AddTypeKit()` describes every value object as the schema of the type inside it",
+    "claim": "`AddTypeKit()` describes every value object as the schema of the type inside it",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit"
+    ],
+    "heldBy": [
+      "WalkthroughTests"
+    ]
+  },
+  {
+    "id": "W12-closed-set-is-a-string-enum",
+    "source": "docs/walkthrough.md#read-the-openapi-document",
+    "quote": "**The closed set** is a string enum of its names.",
+    "claim": "**The closed set** is a string enum of its names.",
+    "oracle": "claim",
+    "surfaces": [
+      "TypeKitOpenApiOptionsExtensions.AddTypeKit",
+      "IClosedSet.*"
+    ],
+    "heldBy": [
+      "WalkthroughTests"
+    ]
+  }
+]
diff --git a/test/oracles/oracles.json b/test/oracles/oracles.json
new file mode 100644
index 00000000..26396de8
--- /dev/null
+++ b/test/oracles/oracles.json
@@ -0,0 +1,50 @@
+[
+  {
+    "class": "AsynchronousContextTests",
+    "project": "CodoMetis.TypeKit.Tests",
+    "kind": "completeness",
+    "against": "every public member of the base package that returns a task, by reflection: a callback runs where the task it waited for completed, and nothing resumes on the caller's context"
+  },
+  {
+    "class": "JsonParityTests",
+    "project": "CodoMetis.TypeKit.Generators.Tests",
+    "kind": "differential",
+    "against": "the wrapped type's own JSON under the same options, as a value, a property and a dictionary key"
+  },
+  {
+    "class": "KeyGenerationVariantTests",
+    "project": "CodoMetis.TypeKit.EntityFrameworkCore.Tests",
+    "kind": "differential",
+    "against": "the same key shape keyed by the wrapped type, on SQLite, Npgsql and SQL Server"
+  },
+  {
+    "class": "SqlServerKeyVariantTests",
+    "project": "CodoMetis.TypeKit.EntityFrameworkCore.Tests",
+    "kind": "differential",
+    "against": "the same key shape keyed by the wrapped type, inserted into a real SQL Server and read back"
+  },
+  {
+    "class": "SqlServerQueryVariantTests",
+    "project": "CodoMetis.TypeKit.EntityFrameworkCore.Tests",
+    "kind": "differential",
+    "against": "the same query over the wrapped type on a real SQL Server, the objects in memory and SQLite, each difference from memory that is SQL Server's own a pinned fact"
+  },
+  {
+    "class": "NotWireTypeTests",
+    "project": "CodoMetis.TypeKit.Tests",
+    "kind": "completeness",
+    "against": "every exported struct of the base package, by reflection: System.Text.Json refuses it in both directions"
+  },
+  {
+    "class": "NullDelegateTests",
+    "project": "CodoMetis.TypeKit.Tests",
+    "kind": "completeness",
+    "against": "every delegate parameter of the base package, by reflection, on every branch of its receiver"
+  },
+  {
+    "class": "SchemaTests",
+    "project": "CodoMetis.TypeKit.AspNetCore.Tests",
+    "kind": "differential",
+    "against": "the wrapped type's schema in the same document, property by property, with each value object a component and inlined, in OpenAPI 3.1, 3.0 and 2.0"
+  }
+]
diff --git a/tools/probe/corpus/seeds/E02-value-translates-to-column-column-not-cast.patch b/test/oracles/seeds/column-cast-not-re-typed.patch
similarity index 80%
rename from tools/probe/corpus/seeds/E02-value-translates-to-column-column-not-cast.patch
rename to test/oracles/seeds/column-cast-not-re-typed.patch
index 6b2d61d9..1b0c3dc7 100644
--- a/tools/probe/corpus/seeds/E02-value-translates-to-column-column-not-cast.patch
+++ b/test/oracles/seeds/column-cast-not-re-typed.patch
@@ -1,3 +1,7 @@
+Seed: A table column read through .Value is cast to the wrapped type, not re-typed
+Oracles: SqlServerQueryVariantTests
+Fails: the SQL of every query that reads a table column through an accessor, which is no longer the wrapped type's
+
 diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs
 index 4cbf797..074e67d 100644
 --- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs
diff --git a/test/oracles/seeds/inline-value-objects-ignored.patch b/test/oracles/seeds/inline-value-objects-ignored.patch
new file mode 100644
index 00000000..e787cae8
--- /dev/null
+++ b/test/oracles/seeds/inline-value-objects-ignored.patch
@@ -0,0 +1,16 @@
+Seed: InlineValueObjects is ignored, so every value object keeps its component
+Oracles: SchemaTests
+Fails: every inline row but the dictionary keyed by a value object, in 3.1, 3.0 and 2.0
+
+diff --git a/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaReferenceIds.cs b/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaReferenceIds.cs
+--- a/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaReferenceIds.cs
++++ b/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaReferenceIds.cs
+@@ -50,7 +50,7 @@
+         options.CreateSchemaReferenceId = type =>
+         {
+             var claimant = Nullable.GetUnderlyingType(type.Type) ?? type.Type;
+-            if (inlineValueObjects && ValueObjectTypes.IsValueObject(claimant)) return null;
++            if (inlineValueObjects && false) return null;
+ 
+             if (inner(type) is not { } id) return null;
+ 
diff --git a/tools/probe/corpus/seeds/L01-json-bytes-as-a-dictionary-key-too.patch b/test/oracles/seeds/json-key-written-by-to-string.patch
similarity index 77%
rename from tools/probe/corpus/seeds/L01-json-bytes-as-a-dictionary-key-too.patch
rename to test/oracles/seeds/json-key-written-by-to-string.patch
index 832c2257..0e656c20 100644
--- a/tools/probe/corpus/seeds/L01-json-bytes-as-a-dictionary-key-too.patch
+++ b/test/oracles/seeds/json-key-written-by-to-string.patch
@@ -1,3 +1,7 @@
+Seed: A value object as a dictionary key is written by the wrapped value's ToString(), not by its converter's WriteAsPropertyName
+Oracles: JsonParityTests
+Fails: every dictionary-key row whose wrapped type's key is not its ToString(): dates, decimals, a host converter's keys
+
 diff --git a/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs b/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
 index 8597206..1990a4a 100644
 --- a/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
diff --git a/test/oracles/seeds/patch-traverse-takes-a-null-selector.patch b/test/oracles/seeds/patch-traverse-takes-a-null-selector.patch
new file mode 100644
index 00000000..cbe223a7
--- /dev/null
+++ b/test/oracles/seeds/patch-traverse-takes-a-null-selector.patch
@@ -0,0 +1,17 @@
+Seed: Patch<T>.Traverse checks its selector only where it calls it, so a null passes on a clear and an absent field
+Oracles: NullDelegateTests
+Fails: Result.Traverse(Patch<T>, ...): selector, on the Null and Absent branches
+
+diff --git a/src/CodoMetis.TypeKit/ResultExtensions.cs b/src/CodoMetis.TypeKit/ResultExtensions.cs
+index a4394be..1568b0a 100644
+--- a/src/CodoMetis.TypeKit/ResultExtensions.cs
++++ b/src/CodoMetis.TypeKit/ResultExtensions.cs
+@@ -1568,8 +1568,6 @@ public static class Result
+             where TResult : notnull
+             where TError : notnull
+         {
+-            ArgumentNullException.ThrowIfNull(selector);
+-
+             if (!patch.TryGetValue(out var value))
+                 return Result<Patch<TResult>, TError>.Success(patch.State == PatchState.Null ? Patch.Null<TResult>() : Patch.Absent<TResult>());
+ 
diff --git a/test/oracles/seeds/result-reads-as-json.patch b/test/oracles/seeds/result-reads-as-json.patch
new file mode 100644
index 00000000..2f2b00ad
--- /dev/null
+++ b/test/oracles/seeds/result-reads-as-json.patch
@@ -0,0 +1,16 @@
+Seed: Result<TError> loses the converter that refuses System.Text.Json, so a success is written as {} and read back as uninitialized
+Oracles: NotWireTypeTests
+Fails: the completeness row for Result<TError>, and its write and read
+
+diff --git a/src/CodoMetis.TypeKit/Result.cs b/src/CodoMetis.TypeKit/Result.cs
+index b92fd68..1f7da85 100644
+--- a/src/CodoMetis.TypeKit/Result.cs
++++ b/src/CodoMetis.TypeKit/Result.cs
+@@ -29,7 +29,6 @@ namespace CodoMetis.TypeKit;
+ /// </remarks>
+ /// <typeparam name="TError">The type of the error.</typeparam>
+ [RequireCustomInitialization("Use Result.Success() or Result.Error(error).")]
+-[JsonConverter(typeof(NotWireTypeJsonConverterFactory))]
+ [DebuggerDisplay("{DebuggerDisplay,nq}")]
+ public readonly record struct Result<TError> where TError : notnull
+ {
diff --git a/test/oracles/seeds/traverse-async-resumes-on-the-caller-s-context.patch b/test/oracles/seeds/traverse-async-resumes-on-the-caller-s-context.patch
new file mode 100644
index 00000000..cbb6029a
--- /dev/null
+++ b/test/oracles/seeds/traverse-async-resumes-on-the-caller-s-context.patch
@@ -0,0 +1,17 @@
+Seed: The sequence's TraverseAsync awaits each operation without ConfigureAwait(false), so it resumes on the caller's SynchronizationContext
+Oracles: AsynchronousContextTests
+Fails: Result.TraverseAsync(IEnumerable<T>, Func<T, Task<Result<TResult, TError>>>), with the first operation pending
+
+diff --git a/src/CodoMetis.TypeKit/ResultExtensions.cs b/src/CodoMetis.TypeKit/ResultExtensions.cs
+index a4394be..b2eae14 100644
+--- a/src/CodoMetis.TypeKit/ResultExtensions.cs
++++ b/src/CodoMetis.TypeKit/ResultExtensions.cs
+@@ -1286,7 +1286,7 @@ public static class Result
+ 
+             foreach (var element in source)
+             {
+-                var result = await ThrowHelper.Awaitable(selector(element), nameof(TraverseAsync), nameof(selector)).ConfigureAwait(false);
++                var result = await ThrowHelper.Awaitable(selector(element), nameof(TraverseAsync), nameof(selector));
+                 if (!result.TryGetValue(out var value, out var error)) return Result<IReadOnlyList<TResult>, TError>.Error(error);
+ 
+                 values.Add(value);
diff --git a/tools/probe/corpus/seeds/E04-integer-key-generated-char-key-yours.patch b/test/oracles/seeds/ushort-key-not-generated.patch
similarity index 70%
rename from tools/probe/corpus/seeds/E04-integer-key-generated-char-key-yours.patch
rename to test/oracles/seeds/ushort-key-not-generated.patch
index 457da14a..54b876f4 100644
--- a/tools/probe/corpus/seeds/E04-integer-key-generated-char-key-yours.patch
+++ b/test/oracles/seeds/ushort-key-not-generated.patch
@@ -1,5 +1,9 @@
+Seed: A value-object key over ushort is not declared generated, where a ushort key is
+Oracles: KeyGenerationVariantTests, SqlServerKeyVariantTests
+Fails: every key shape over ushort, on the three providers, and on a real SQL Server
+
 diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index 934f884..1f5343b 100644
+index c64d73e..be3d015 100644
 --- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
 +++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
 @@ -77,7 +77,7 @@ internal sealed class ValueObjectKeyValueGenerationConvention : IModelFinalizing
@@ -7,7 +11,7 @@ index 934f884..1f5343b 100644
      private static bool IsGeneratedByTheDatabase(Type wrapped) =>
          wrapped == typeof(int) || wrapped == typeof(long) || wrapped == typeof(short) || wrapped == typeof(sbyte)
 -     || wrapped == typeof(uint) || wrapped == typeof(ulong) || wrapped == typeof(ushort);
-+     || wrapped == typeof(uint) || wrapped == typeof(ulong) || wrapped == typeof(ushort) || wrapped == typeof(char);
++     || wrapped == typeof(uint) || wrapped == typeof(ulong);
  }
  
  /// <summary>
diff --git a/test/oracles/surface-waivers.json b/test/oracles/surface-waivers.json
new file mode 100644
index 00000000..5d9dfe39
--- /dev/null
+++ b/test/oracles/surface-waivers.json
@@ -0,0 +1,19 @@
+{
+  "Error.*": "the error marker's record equality and printing, compiler-generated; the conversions it exists for are claimed through Result",
+  "None.*": "the None marker's record equality and printing, compiler-generated",
+  "Success.*": "the success marker's record equality and printing, compiler-generated",
+  "ResultState.*": "enum members; what each state means is claimed through the members that read it",
+  "AbstractAttribute..ctor": "a constraint attribute's constructor; what it constrains is CMTK0010's, held by the analyzer tests",
+  "ConcreteAttribute..ctor": "a constraint attribute's constructor; what it constrains is CMTK0010's, held by the analyzer tests",
+  "DistinctAttribute..ctor": "a constraint attribute's constructor; what it constrains is CMTK0010's, held by the analyzer tests",
+  "ClosedSetAttribute..ctor": "a constraint attribute's constructor; what it constrains is CMTK0010's, held by the analyzer tests",
+  "GeneratedClosedSetAttribute.*": "plumbing the generators write on a closed set, read by the satellites through Accept",
+  "GeneratedValueObjectAttribute.*": "plumbing the generators write on a value object, read by the satellites through Accept",
+  "GeneratedClosedSets.*": "refusal helpers that generated closed-set code calls; what they refuse is claimed through Parse and the JSON reads",
+  "IClosedSetVisitor.Visit": "the visitor GeneratedClosedSetAttribute.Accept calls, plumbing",
+  "IValueObjectVisitor.Visit": "the visitor GeneratedValueObjectAttribute.Accept calls, plumbing",
+  "IStoredJsonConverterSource.CreateStoredJsonConverter": "plumbing StoredJsonConverterFactory calls on a generated converter",
+  "DescribedJsonSchema.ExporterOptions": "the exporter options the schema descriptions are read with, plumbing",
+  "TypeKitServiceCollectionExtensions.AddEntityFrameworkTypeKit": "the internal-service-provider form of UseTypeKit, whose claims hold it",
+  "TypeKitAssertionException..ctor": "the exception the assertions throw; its messages are claimed through the assertions"
+}
diff --git a/tools/AgentTools.slnf b/tools/AgentTools.slnf
index be0719e0..88c49e3c 100644
--- a/tools/AgentTools.slnf
+++ b/tools/AgentTools.slnf
@@ -3,9 +3,11 @@
     "path": "../CodoMetis.TypeKit.slnx",
     "projects": [
       "tools/BuildVerdict/BuildVerdict.csproj",
+      "tools/CiLanes/CiLanes.csproj",
       "tools/ConsumerSmokeTest/ConsumerSmokeTest.csproj",
       "tools/DocsQuery/DocsQuery.csproj",
-      "tools/Prober/Prober.csproj"
+      "tools/Oracles/Oracles.csproj",
+      "tools/PrHygiene/PrHygiene.csproj"
     ]
   }
 }
diff --git a/tools/BuildVerdict/BuildVerdict.csproj b/tools/BuildVerdict/BuildVerdict.csproj
index 6d4ac2f5..56d0c520 100644
--- a/tools/BuildVerdict/BuildVerdict.csproj
+++ b/tools/BuildVerdict/BuildVerdict.csproj
@@ -3,7 +3,7 @@
     <!--
       Runs the dotnet toolchain and prints a verdict instead of the transcript (Program.cs). Run as its
       built dll: `dotnet tools/BuildVerdict/bin/Release/net10.0/build-verdict.dll build|test ...`.
-      Its command line and its output are a contract: tools/Prober's replay reads both.
+      Its command line and its output are a contract: tools/Oracles' seeds command reads its exit code.
     -->
     <PropertyGroup>
         <OutputType>Exe</OutputType>
diff --git a/tools/CiLanes/CiLanes.csproj b/tools/CiLanes/CiLanes.csproj
new file mode 100644
index 00000000..0732338c
--- /dev/null
+++ b/tools/CiLanes/CiLanes.csproj
@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <!--
+      Decides which lanes of .github/workflows/dotnet.yml a run needs, from the paths it changes, and judges
+      afterwards whether every selected job passed and every other was skipped (Program.cs, design/adr/0113).
+      Run as its built dll: `dotnet tools/CiLanes/bin/Release/net10.0/ci-lanes.dll select|classify|gate ...`.
+    -->
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <AssemblyName>ci-lanes</AssemblyName>
+        <RootNamespace>CiLanes</RootNamespace>
+    </PropertyGroup>
+
+</Project>
diff --git a/tools/CiLanes/Program.cs b/tools/CiLanes/Program.cs
new file mode 100644
index 00000000..754a220f
--- /dev/null
+++ b/tools/CiLanes/Program.cs
@@ -0,0 +1,363 @@
+// Which lanes of .github/workflows/dotnet.yml a run needs, and whether the run did what was selected
+// (design/adr/0113-ci-runs-the-lanes-a-change-can-affect.md). Four lanes: the Linux test leg, in every run;
+// `windows` and `macos`, those test legs; `pack`, the Pack and Consumer jobs. Each changed path selects lanes by
+// the first class of Table whose pattern matches it, and a path no class names selects every lane a selection
+// can: all but macOS, which only the runs that are not selected get.
+//
+// Usage:
+//   ci-lanes select --event <name> --ref <ref> [--base <branch>] [--before <sha>] [--output <file>] [--summary <file>]
+//       A pull request into release/** is selected by `git diff origin/<base>...HEAD`, a push to release/** by
+//       `git diff <before> HEAD`; every other run gets every lane, macOS included. Appends `legs=<json array>`,
+//       `pack=true|false` and `suite=prose|full` to --output (the step's GITHUB_OUTPUT), or prints them, and each path's
+//       class to --summary. The suite is prose when every changed path is: the Linux leg then builds and runs only the
+//       test projects of test/Prose.slnf, the ones that read prose.
+//   ci-lanes classify <path>...
+//       One line per path: the path, its class and its lanes, tab-separated.
+//   ci-lanes gate <needs.json> [--summary <file>]
+//       Reads the workflow's toJSON(needs) and passes only when the changes job succeeded with answers this tool
+//       writes, every job it selected succeeded and every other was skipped.
+//
+// Exit 0 is a pass, 1 a failed gate or a git command that failed, 2 a usage error, 3 a tool built from other
+// sources than the checkout holds, which names the command that rebuilds it.
+using System.Diagnostics;
+using System.Text;
+using System.Text.Json;
+using System.Text.RegularExpressions;
+
+Console.Out.NewLine = "\n";
+Console.Error.NewLine = "\n";
+
+var root = SourceFingerprint.FindRoot();
+var stale = SourceFingerprint.Difference(root);
+if (stale is not null)
+{
+    Console.WriteLine($"TOOL STALE: {SourceFingerprint.Project} was built from other sources than the checkout holds ({stale})");
+    Console.WriteLine($"      rebuild it: {SourceFingerprint.RebuildCommand}");
+    return SourceFingerprint.StaleExitCode;
+}
+
+return args switch
+{
+    ["select", .. var rest] when Options.Parse(rest, ["event", "ref", "base", "before", "output", "summary"]) is { } options
+                                 && options.ContainsKey("event") && options.ContainsKey("ref") => Selection.Run(root!, options),
+    ["classify", _, ..] => Classify(args[1..]),
+    ["gate", var needs, .. var rest] when Options.Parse(rest, ["summary"]) is { } options => Gate.Run(needs, options),
+    _ => Usage(),
+};
+
+static int Classify(string[] paths)
+{
+    foreach (var path in paths)
+    {
+        var @class = Table.Of(path);
+        Console.WriteLine($"{path}\t{@class.Name}\t{Table.Describe(@class.Lanes)}");
+    }
+    return 0;
+}
+
+static int Usage()
+{
+    Console.Error.WriteLine("Usage: dotnet tools/CiLanes/bin/Release/net10.0/ci-lanes.dll");
+    Console.Error.WriteLine("         select --event <name> --ref <ref> [--base <branch>] [--before <sha>] [--output <file>] [--summary <file>]");
+    Console.Error.WriteLine("         classify <path>...");
+    Console.Error.WriteLine("         gate <needs.json> [--summary <file>]");
+    return 2;
+}
+
+[Flags]
+enum Lane
+{
+    Linux = 1,
+    Windows = 2,
+    MacOs = 4,
+    Pack = 8,
+
+    // The most a changed path can select: macOS runs only on the release's pull request, main, the nightly and the release.
+    Selectable = Linux | Windows | Pack,
+    All = Selectable | MacOs,
+}
+
+static class Options
+{
+    // `--name value` pairs, each name one of those allowed and given once; null for anything else.
+    public static Dictionary<string, string>? Parse(string[] args, string[] allowed)
+    {
+        var options = new Dictionary<string, string>(StringComparer.Ordinal);
+        for (var i = 0; i < args.Length; i += 2)
+        {
+            if (i + 1 >= args.Length || !args[i].StartsWith("--", StringComparison.Ordinal)) return null;
+            var name = args[i][2..];
+            if (!allowed.Contains(name) || !options.TryAdd(name, args[i + 1])) return null;
+        }
+        return options;
+    }
+}
+
+static partial class Table
+{
+    public sealed record Class(string Name, Lane Lanes, string[] Patterns, string Why);
+
+    // Read by the test projects of test/Prose.slnf alone, which ProseReaderTests holds; built into nothing. The docs
+    // site's config (site/) is read by the docs workflow and the conventions tests (decision 116).
+    public static readonly Class Prose = new("prose", Lane.Linux, ["docs/**", "design/**", "site/**", ".github/ISSUE_TEMPLATE/**", "**/*.md"],
+        "read by the prose suite, built into nothing");
+
+    // The first class whose pattern matches a path decides its lanes. `**` matches any number of directories,
+    // `*` and `?` stay within one. Decision 113 holds this table; CiLaneTests holds it to the files MSBuild
+    // evaluates for the packages and the smoke test.
+    public static readonly Class[] Classes =
+    [
+        new("changelog", Lane.Linux | Lane.Pack, ["CHANGELOG.md"],
+            "the packages' release notes are its section, read by a property function no evaluation lists"),
+        new("source text", Lane.Selectable, ["src/CodoMetis.TypeKit.Analyzers/**", "src/CodoMetis.TypeKit.Generators/**"],
+            "a package that writes or edits source text, whose line endings a Windows checkout changes"),
+        new("package", Lane.Linux | Lane.Pack, ["src/**"], "a shipping project"),
+        new("smoke test", Lane.Selectable, ["tools/ConsumerSmokeTest/**", "tools/Shared/**", "tools/Directory.Build.*", "tools/CiLanes/**"],
+            "the smoke test, what it compiles in, or this selection"),
+        Prose,
+        new("code no package reads", Lane.Linux | Lane.Windows, ["test/**", "spikes/**", "tools/**"],
+            "built and tested, never packed, and handling paths, line endings and child processes itself"),
+    ];
+
+    public static readonly Class Unlisted = new("unlisted", Lane.Selectable, [], "no class names it");
+
+    static readonly Dictionary<string, Regex> Globs = [];
+
+    public static Class Of(string path) => Classes.FirstOrDefault(c => c.Patterns.Any(p => Glob(p).IsMatch(path))) ?? Unlisted;
+
+    public static string Describe(Lane lanes) =>
+        string.Join(", ", new[] { (Lane.Linux, "linux"), (Lane.Windows, "windows"), (Lane.MacOs, "macos"), (Lane.Pack, "pack") }.Where(l => lanes.HasFlag(l.Item1)).Select(l => l.Item2));
+
+    // The test legs and the lane that selects each, in the order the matrix lists them.
+    public static readonly (Lane Lane, string Runner)[] Runners = [(Lane.Linux, "ubuntu-latest"), (Lane.Windows, "windows-latest"), (Lane.MacOs, "macos-latest")];
+
+    // The test matrix: one leg per selected test lane. Linux is in every selection.
+    public static string[] Legs(Lane lanes) => [.. Runners.Where(r => lanes.HasFlag(r.Lane)).Select(r => r.Runner)];
+
+    static Regex Glob(string pattern)
+    {
+        if (Globs.TryGetValue(pattern, out var regex)) return regex;
+
+        var builder = new StringBuilder("^");
+        for (var i = 0; i < pattern.Length; i++)
+        {
+            if (pattern.AsSpan(i).StartsWith("**/")) { builder.Append("(?:.*/)?"); i += 2; }
+            else if (pattern.AsSpan(i).StartsWith("**")) { builder.Append(".*"); i += 1; }
+            else if (pattern[i] == '*') builder.Append("[^/]*");
+            else if (pattern[i] == '?') builder.Append("[^/]");
+            else builder.Append(Regex.Escape(pattern[i].ToString()));
+        }
+        return Globs[pattern] = new Regex(builder.Append('$').ToString(), RegexOptions.CultureInvariant);
+    }
+}
+
+static class Selection
+{
+    public static int Run(string root, Dictionary<string, string> options)
+    {
+        var @event = options["event"];
+        var @ref = options["ref"];
+        var target = options.GetValueOrDefault("base", "");
+        var before = options.GetValueOrDefault("before", "");
+
+        string? range = null;
+        string why;
+        if (@event == "pull_request" && target.StartsWith("release/", StringComparison.Ordinal))
+        {
+            range = $"origin/{target}...HEAD";
+            why = $"a pull request into {target}, selected by its diff against origin/{target}";
+        }
+        else if (@event == "pull_request" && target == "main")
+            why = "a pull request into main is the release's, which runs every lane";
+        else if (@event == "push" && @ref.StartsWith("refs/heads/release/", StringComparison.Ordinal))
+        {
+            if (before.Length == 0 || before.All(c => c == '0'))
+                why = "the push creates the branch, so there is nothing to diff against";
+            else if (Git(root, out _, "cat-file", "-e", $"{before}^{{commit}}") != 0)
+                why = $"the clone does not have {before}, the commit the push replaced";
+            else
+            {
+                range = $"{before} HEAD";
+                why = $"a push to {@ref["refs/heads/".Length..]}, selected by its diff against {before}";
+            }
+        }
+        else
+            why = $"a {@event} of {@ref} runs every lane";
+
+        var lanes = Lane.All;
+        var classified = new List<(string Path, Table.Class Class)>();
+        if (range is not null)
+        {
+            var code = Git(root, out var output, ["diff", "--name-only", "--no-renames", "-z", .. range.Split(' '), "--"]);
+            if (code != 0)
+            {
+                Console.WriteLine($"::error::git diff {range} failed with exit {code}, so nothing can be selected: {output.Trim()}");
+                return 1;
+            }
+
+            var paths = output.Split('\0', StringSplitOptions.RemoveEmptyEntries);
+            if (paths.Length == 0)
+                why += "; it names no path, so every lane runs";
+            else
+            {
+                classified = [.. paths.Select(path => (path, Table.Of(path)))];
+                lanes = classified.Aggregate(Lane.Linux, (all, row) => all | row.Class.Lanes);
+            }
+        }
+
+        var legs = JsonSerializer.Serialize(Table.Legs(lanes));
+        var pack = lanes.HasFlag(Lane.Pack) ? "true" : "false";
+        var suite = classified.Count > 0 && classified.All(row => row.Class == Table.Prose) ? "prose" : "full";
+
+        Console.WriteLine($"{char.ToUpperInvariant(why[0])}{why[1..]}.");
+        foreach (var (path, @class) in classified) Console.WriteLine($"  {path}: {@class.Name} ({Table.Describe(@class.Lanes)})");
+        Console.WriteLine($"Lanes: {Table.Describe(lanes)}. Test legs: {string.Join(", ", Table.Legs(lanes))}. Pack and Consumer: {(pack == "true" ? "run" : "skipped")}. Suite: {suite}.");
+
+        var answers = $"legs={legs}\npack={pack}\nsuite={suite}\n";
+        if (options.TryGetValue("output", out var file)) File.AppendAllText(file, answers);
+        else Console.Write(answers);
+
+        if (options.TryGetValue("summary", out var summary))
+        {
+            var text = new StringBuilder($"### Lanes: {Table.Describe(lanes)}\n\n{char.ToUpperInvariant(why[0])}{why[1..]}.\n\n");
+            if (classified.Count > 0)
+            {
+                text.Append("| Path | Class | Lanes |\n|---|---|---|\n");
+                foreach (var (path, @class) in classified.Take(200)) text.Append($"| `{path}` | {@class.Name} | {Table.Describe(@class.Lanes)} |\n");
+                if (classified.Count > 200) text.Append($"\nand {classified.Count - 200} more paths.\n");
+            }
+            File.AppendAllText(summary, text.ToString());
+        }
+        return 0;
+    }
+
+    // git in the repository root, its stdout (or stderr, on a failure) as text.
+    static int Git(string root, out string output, params string[] arguments)
+    {
+        var psi = new ProcessStartInfo("git") { WorkingDirectory = root, RedirectStandardOutput = true, RedirectStandardError = true };
+        foreach (var argument in arguments) psi.ArgumentList.Add(argument);
+        using var process = Process.Start(psi)!;
+        var stdout = process.StandardOutput.ReadToEndAsync();
+        var stderr = process.StandardError.ReadToEndAsync();
+        process.WaitForExit();
+        output = process.ExitCode == 0 ? stdout.Result : stderr.Result;
+        return process.ExitCode;
+    }
+}
+
+static class Gate
+{
+    // Every job of dotnet.yml the gate needs, and the lane that selects it: null for the changes job, which
+    // selects, and Linux for the test matrix, which runs in every selection.
+    static readonly Dictionary<string, Lane?> Jobs = new(StringComparer.Ordinal)
+    {
+        ["changes"] = null,
+        ["test"] = Lane.Linux,
+        ["pack"] = Lane.Pack,
+        ["consumer"] = Lane.Pack,
+    };
+
+    public static int Run(string file, Dictionary<string, string> options)
+    {
+        Dictionary<string, (string Result, Dictionary<string, string> Outputs)> needs;
+        try
+        {
+            using var document = JsonDocument.Parse(File.ReadAllText(file));
+            needs = document.RootElement.EnumerateObject().ToDictionary(
+                job => job.Name,
+                job => (Text(job.Value, "result"),
+                        job.Value.TryGetProperty("outputs", out var outputs) && outputs.ValueKind == JsonValueKind.Object
+                            ? outputs.EnumerateObject().ToDictionary(o => o.Name, o => o.Value.ValueKind == JsonValueKind.String ? o.Value.GetString()! : o.Value.GetRawText())
+                            : []),
+                StringComparer.Ordinal);
+        }
+        catch (Exception e) when (e is IOException or UnauthorizedAccessException or JsonException or InvalidOperationException)
+        {
+            Console.Error.WriteLine($"{file} cannot be read as the workflow's needs: {e.Message}");
+            return 2;
+        }
+
+        var problems = new List<string>();
+        foreach (var job in needs.Keys.Where(job => !Jobs.ContainsKey(job)))
+            problems.Add($"The gate does not know the job '{job}': add it to Gate.Jobs in tools/CiLanes with the lane that selects it.");
+        foreach (var job in Jobs.Keys.Where(job => !needs.ContainsKey(job)))
+            problems.Add($"The gate does not need the job '{job}', so it cannot judge it: add it to the CI job's needs.");
+
+        Lane? lanes = null;
+        var changesResult = needs.TryGetValue("changes", out var changes) ? changes.Result : "missing";
+        if (changesResult != "missing")
+        {
+            if (changes.Result != "success")
+                problems.Add($"The changes job ended '{changes.Result}', so nothing it selected can be trusted.");
+            else
+            {
+                var legs = Legs(changes.Outputs.GetValueOrDefault("legs"));
+                var pack = changes.Outputs.GetValueOrDefault("pack");
+                var suite = changes.Outputs.GetValueOrDefault("suite");
+                if (legs is null)
+                    problems.Add($"The changes job's legs output is {Quote(changes.Outputs.GetValueOrDefault("legs"))}, not one of the three matrices ci-lanes writes.");
+                if (pack is not ("true" or "false"))
+                    problems.Add($"The changes job's pack output is {Quote(pack)}, not 'true' or 'false'.");
+                if (suite is not ("prose" or "full"))
+                    problems.Add($"The changes job's suite output is {Quote(suite)}, not 'prose' or 'full'.");
+                else if (suite == "prose" && (legs != Lane.Linux || pack != "false"))
+                    problems.Add("The changes job chose the prose suite for a run with more than the Linux leg: only a prose-only change runs it.");
+                if (legs is not null && pack is ("true" or "false"))
+                    lanes = legs.Value | (pack == "true" ? Lane.Pack : 0);
+            }
+        }
+
+        var rows = new List<string>();
+        foreach (var (job, lane) in Jobs.Where(j => j.Value is not null))
+        {
+            if (!needs.TryGetValue(job, out var need)) continue;
+            var selected = lanes is { } l ? l.HasFlag(lane!.Value) : (bool?)null;
+            rows.Add($"| {job} | {(selected is null ? "unknown" : selected.Value ? "yes" : "no")} | {need.Result} |");
+            if (selected is null) continue;
+
+            var expected = selected.Value ? "success" : "skipped";
+            if (need.Result != expected)
+                problems.Add(selected.Value
+                    ? $"The job '{job}' was selected and ended '{need.Result}'."
+                    : $"The job '{job}' was not selected and ended '{need.Result}', not skipped: its condition no longer reads the selection.");
+        }
+
+        if (options.TryGetValue("summary", out var summary))
+        {
+            var text = new StringBuilder($"### Gate: {(problems.Count == 0 ? "passed" : "failed")}\n\n");
+            text.Append($"Changes: {changesResult}, lanes: {(lanes is { } s ? Table.Describe(s) : "unknown")}.\n\n");
+            text.Append("| Job | Selected | Result |\n|---|---|---|\n").AppendJoin('\n', rows).Append('\n');
+            foreach (var problem in problems) text.Append($"\n- {problem}");
+            File.AppendAllText(summary, text.Append('\n').ToString());
+        }
+
+        if (problems.Count == 0)
+        {
+            Console.WriteLine($"Every selected job passed and every other was skipped (lanes: {Table.Describe(lanes!.Value)}).");
+            return 0;
+        }
+        foreach (var problem in problems) Console.WriteLine($"::error::{problem}");
+        return 1;
+    }
+
+    // The test lanes of every matrix Selection writes: Linux alone, with Windows, and every leg on a run that is not selected.
+    static readonly Lane[] Matrices = [Lane.Linux, Lane.Linux | Lane.Windows, Lane.Linux | Lane.Windows | Lane.MacOs];
+
+    // The lanes a legs output selects, when it is exactly one of the matrices Selection writes; null otherwise.
+    static Lane? Legs(string? legs)
+    {
+        string[]? parsed;
+        try { parsed = legs is null ? null : JsonSerializer.Deserialize<string[]>(legs); }
+        catch (JsonException) { return null; }
+
+        if (parsed is null) return null;
+        foreach (var lanes in Matrices)
+            if (parsed.SequenceEqual(Table.Legs(lanes))) return lanes;
+        return null;
+    }
+
+    static string Text(JsonElement element, string name) =>
+        element.ValueKind == JsonValueKind.Object && element.TryGetProperty(name, out var value) && value.ValueKind == JsonValueKind.String ? value.GetString()! : "";
+
+    static string Quote(string? value) => value is null ? "missing" : $"'{value}'";
+}
diff --git a/tools/ConsumerSmokeTest/Consumers/walkthrough/OrderEndpoints.cs b/tools/ConsumerSmokeTest/Consumers/walkthrough/OrderEndpoints.cs
new file mode 100644
index 00000000..9b3eb015
--- /dev/null
+++ b/tools/ConsumerSmokeTest/Consumers/walkthrough/OrderEndpoints.cs
@@ -0,0 +1,60 @@
+// The orders service's endpoints. docs/walkthrough.md shows each region; test/CodoMetis.TypeKit.Samples
+// compiles this file too, for WalkthroughTests.
+using CodoMetis.TypeKit;
+using CodoMetis.TypeKit.AspNetCore;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.EntityFrameworkCore;
+
+namespace Walkthrough;
+
+// The value objects are declared beside the endpoints, so ASP.NET's route analyzer reads OrderId before the
+// generators make it parsable (docs/aspnet-core.md). In a domain project of their own they would need no pragma.
+#pragma warning disable ASP0020
+public static class OrderEndpoints
+{
+    public static void MapOrders(this IEndpointRouteBuilder app)
+    {
+        // sample: walkthrough/place
+        app.MapPost("/orders", async (PlaceOrder request, OrdersDb db, Serilog.ILogger log) =>
+        {
+            var order = new Order { Id = OrderId.New(), Email = request.Email, Quantity = request.Quantity, Status = OrderStatus.Placed };
+            db.Orders.Add(order);
+            await db.SaveChangesAsync();
+
+            var view = OrderView.Of(order);
+            log.Information("Placed {@Order}", view);   // Placed {"Id": "…", "Email": "a***@example.com", "Quantity": "2", "Status": "Placed", "$type": "OrderView"}
+            return TypedResults.Created($"/orders/{order.Id}", view);
+        });
+        // end sample
+
+        // sample: walkthrough/find
+        app.MapGet("/orders/{id}", async (OrderId id, OrdersDb db) =>
+            (await db.Orders.FirstOrNoneAsync(order => order.Id == id))   // an Option: the order, or none
+                .ToResult(OrderFault.NotFound)
+                .Map(OrderView.Of)
+                .ToHttpResult())
+           .WithoutFaults(OrderFault.AlreadyShipped, OrderFault.Cancelled, OrderFault.Cleared);   // finding one reports only NotFound
+        // end sample
+
+        // sample: walkthrough/list
+        app.MapGet("/orders", async (Quantity minimum, OrdersDb db) =>
+            await db.Orders.Where(order => order.Quantity.Value >= minimum.Value)   // WHERE "o"."Quantity" >= @minimum_Value
+                           .Select(order => OrderView.Of(order))
+                           .ToListAsync());
+        // end sample
+
+        // sample: walkthrough/change
+        app.MapPatch("/orders/{id}", async (OrderId id, OrderPatch patch, OrdersDb db) =>
+        {
+            var changed = (await db.Orders.FirstOrNoneAsync(order => order.Id == id))
+                .ToResult(OrderFault.NotFound)
+                .Bind(order => order.Apply(patch));
+            await db.SaveChangesAsync();
+            return changed.Map(OrderView.Of).ToHttpResult();
+        });
+        // end sample
+    }
+}
+#pragma warning restore ASP0020
diff --git a/tools/ConsumerSmokeTest/Consumers/walkthrough/Orders.cs b/tools/ConsumerSmokeTest/Consumers/walkthrough/Orders.cs
new file mode 100644
index 00000000..2a489b72
--- /dev/null
+++ b/tools/ConsumerSmokeTest/Consumers/walkthrough/Orders.cs
@@ -0,0 +1,88 @@
+// The orders service's domain: its value objects, what it stores, and what it exchanges. docs/walkthrough.md
+// shows each region; test/CodoMetis.TypeKit.Samples compiles this file too, for WalkthroughTests.
+using CodoMetis.TypeKit;
+using CodoMetis.TypeKit.ClosedSets;
+using CodoMetis.TypeKit.ValueObjects;
+using Microsoft.EntityFrameworkCore;
+
+namespace Walkthrough;
+
+// sample: walkthrough/values
+public readonly partial record struct OrderId : IValue<Guid>;
+
+public enum EmailFault { Blank, Hidden, NoAt }
+
+public readonly partial record struct Email : IValidatedValue<Email, string, EmailFault>
+{
+    public static Result<Email, EmailFault> Create(string value) =>
+        value.AsText()                                                                    // trimmed, composed, no hidden characters
+             .MapError(fault => fault == TextFault.Blank ? EmailFault.Blank : EmailFault.Hidden)
+             .Ensure(text => text.IndexOf('@') > 0, EmailFault.NoAt)
+             .Map(text => new Email(text));
+
+    public override string ToString() => $"{Value[0]}***{Value[Value.IndexOf('@')..]}";   // what a log shows
+}
+
+public enum QuantityFault { NotPositive }
+
+public readonly partial record struct Quantity : IValidatedValue<Quantity, int, QuantityFault>
+{
+    public static Result<Quantity, QuantityFault> Create(int value) =>
+        value > 0 ? new Quantity(value) : Result.Error(QuantityFault.NotPositive);
+}
+
+public sealed partial class OrderStatus : IClosedSet<OrderStatus>
+{
+    public static readonly OrderStatus Placed = new();
+    public static readonly OrderStatus Shipped = new();
+    public static readonly OrderStatus Cancelled = new();
+}
+// end sample
+
+// sample: walkthrough/storage
+public sealed class Order
+{
+    public required OrderId Id { get; init; }
+    public required Email Email { get; set; }
+    public required Quantity Quantity { get; set; }
+    public required OrderStatus Status { get; set; }
+}
+
+public sealed class OrdersDb(DbContextOptions<OrdersDb> options) : DbContext(options)
+{
+    public DbSet<Order> Orders => Set<Order>();
+}
+// end sample
+
+// sample: walkthrough/messages
+public sealed record PlaceOrder(Email Email, Quantity Quantity);
+
+public sealed record OrderView(OrderId Id, Email Email, Quantity Quantity, OrderStatus Status)
+{
+    public static OrderView Of(Order order) => new(order.Id, order.Email, order.Quantity, order.Status);
+}
+
+public enum OrderFault { NotFound, AlreadyShipped, Cancelled, Cleared }
+// end sample
+
+// sample: walkthrough/patch
+public sealed record OrderPatch
+{
+    public Patch<Quantity> Quantity { get; init; }
+    public Patch<OrderStatus> Status { get; init; }
+}
+
+public static class OrderPatching
+{
+    public static Result<Order, OrderFault> Apply(this Order order, OrderPatch patch)
+    {
+        if (order.Status == OrderStatus.Shipped) return Result.Error(OrderFault.AlreadyShipped);
+        if (order.Status == OrderStatus.Cancelled) return Result.Error(OrderFault.Cancelled);
+        if (patch.Quantity.State == PatchState.Null || patch.Status.State == PatchState.Null) return Result.Error(OrderFault.Cleared);   // neither field can be cleared
+
+        patch.Quantity.Tap(quantity => order.Quantity = quantity);
+        patch.Status.Tap(status => order.Status = status);
+        return order;
+    }
+}
+// end sample
diff --git a/tools/ConsumerSmokeTest/Consumers/walkthrough/Program.cs b/tools/ConsumerSmokeTest/Consumers/walkthrough/Program.cs
new file mode 100644
index 00000000..85b0c4f5
--- /dev/null
+++ b/tools/ConsumerSmokeTest/Consumers/walkthrough/Program.cs
@@ -0,0 +1,63 @@
+// The orders service docs/walkthrough.md follows: its host, started on a free port, sent the page's requests by
+// Tour.cs. Each answer is printed as name=value, the SQL EF Core runs and the log lines as they are written, and
+// the smoke test compares them with what the page states.
+// sample: walkthrough/usings
+using CodoMetis.TypeKit.AspNetCore;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Serilog;
+using Walkthrough;
+// end sample
+
+// sample: walkthrough/setup
+var builder = WebApplication.CreateBuilder(args);
+// end sample
+builder.WebHost.UseUrls("http://127.0.0.1:0");
+builder.Logging.ClearProviders();
+// sample: walkthrough/setup
+
+builder.Services.AddOpenApi(options => options.AddTypeKit());
+builder.Services.AddFaultResponses<OrderFault>(fault => fault switch
+{
+    OrderFault.NotFound => StatusCodes.Status404NotFound,
+    OrderFault.AlreadyShipped or OrderFault.Cancelled => StatusCodes.Status409Conflict,
+    OrderFault.Cleared => StatusCodes.Status422UnprocessableEntity,
+    _ => throw new ArgumentOutOfRangeException(nameof(fault)),
+});
+builder.Services.ConfigureHttpJsonOptions(options => options.SerializerOptions.RespectRequiredConstructorParameters = true);
+
+var connection = new SqliteConnection("Data Source=:memory:");   // the database lives as long as this connection is open
+connection.Open();
+builder.Services.AddDbContext<OrdersDb>(options => options.UseSqlite(connection).UseTypeKit()
+    .LogTo(Console.WriteLine, [RelationalEventId.CommandExecuted]));
+
+builder.Services.AddSingleton<Serilog.ILogger>(new LoggerConfiguration()
+    .Destructure.WithTypeKit()
+    .WriteTo.Console(outputTemplate: "[{Level:u3}] {Message:lj}{NewLine}")
+    .CreateLogger());
+// end sample
+
+// sample: walkthrough/app
+var app = builder.Build();
+app.UseStatusCodePages();
+app.MapOpenApi();
+app.MapOrders();
+
+using (var scope = app.Services.CreateScope())
+{
+    scope.ServiceProvider.GetRequiredService<OrdersDb>().Database.EnsureCreated();
+    // CREATE TABLE "Orders" (
+    //     "Id" TEXT NOT NULL CONSTRAINT "PK_Orders" PRIMARY KEY,
+    //     "Email" TEXT NOT NULL,
+    //     "Quantity" INTEGER NOT NULL,
+    //     "Status" TEXT NOT NULL
+    // );
+}
+// end sample
+
+await app.StartAsync();
+using var http = new HttpClient { BaseAddress = new Uri(app.Urls.First()) };
+await Tour.RunAsync(http, (name, value) => Console.WriteLine($"{name}={value}"));
+await app.StopAsync();
+connection.Dispose();
diff --git a/tools/ConsumerSmokeTest/Consumers/walkthrough/Tour.cs b/tools/ConsumerSmokeTest/Consumers/walkthrough/Tour.cs
new file mode 100644
index 00000000..bf89dba3
--- /dev/null
+++ b/tools/ConsumerSmokeTest/Consumers/walkthrough/Tour.cs
@@ -0,0 +1,90 @@
+// The requests docs/walkthrough.md follows, sent to a running orders service. Each answer the page states in a
+// comment is reported under the name of the variable that holds it, and the smoke test and WalkthroughTests
+// compare the two (test/CodoMetis.TypeKit.Samples compiles this file too).
+using System.Text;
+using CodoMetis.TypeKit;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace Walkthrough;
+
+/// <summary>An HTTP answer as the page writes it: the status, a space, the body.</summary>
+public sealed record Answer(int Status, string Body)
+{
+    public override string ToString() => $"{Status} {Body}";
+}
+
+public static class Tour
+{
+    public static async Task RunAsync(HttpClient http, Action<string, string> report)
+    {
+        async Task<Answer> Send(string method, string path, string? json = null)
+        {
+            using var request = new HttpRequestMessage(new HttpMethod(method), path);
+            if (json is not null) request.Content = new StringContent(json, Encoding.UTF8, "application/json");
+            using var response = await http.SendAsync(request);
+            return new Answer((int)response.StatusCode, await response.Content.ReadAsStringAsync());
+        }
+
+        // sample: walkthrough/place-request
+        Answer placed = await Send("POST", "/orders", """{"email":"  ann@example.com ","quantity":2}""");   // 201 {"id":"…","email":"ann@example.com","quantity":2,"status":"Placed"}
+        OrderId id = JsonSerializer.Deserialize<OrderView>(placed.Body, JsonSerializerOptions.Web)!.Id;
+        // end sample
+        report(nameof(placed), placed.ToString());
+
+        // sample: walkthrough/refused
+        Answer noAt = await Send("POST", "/orders", """{"email":"ann","quantity":2}""");   // 400 {"type":"https://tools.ietf.org/html/rfc9110#section-15.5.1","title":"Bad Request","status":400,"traceId":"…"}
+        Answer noEmail = await Send("POST", "/orders", """{"quantity":2}""");              // 400 {"type":"https://tools.ietf.org/html/rfc9110#section-15.5.1","title":"Bad Request","status":400,"traceId":"…"}
+        Answer notAnId = await Send("GET", "/orders/42");                                  // 400 {"type":"https://tools.ietf.org/html/rfc9110#section-15.5.1","title":"Bad Request","status":400,"traceId":"…"}
+        Answer noneAtAll = await Send("GET", "/orders?minimum=0");                         // 400 {"type":"https://tools.ietf.org/html/rfc9110#section-15.5.1","title":"Bad Request","status":400,"traceId":"…"}
+        // end sample
+        report(nameof(noAt), noAt.ToString());
+        report(nameof(noEmail), noEmail.ToString());
+        report(nameof(notAnId), notAnId.ToString());
+        report(nameof(noneAtAll), noneAtAll.ToString());
+
+        // sample: walkthrough/find-request
+        Answer found = await Send("GET", $"/orders/{id}");               // 200 {"id":"…","email":"ann@example.com","quantity":2,"status":"Placed"}
+        Answer missing = await Send("GET", $"/orders/{OrderId.New()}");   // 404 {"type":"https://tools.ietf.org/html/rfc9110#section-15.5.5","title":"Not Found","status":404,"fault":"NotFound","traceId":"…"}
+        // end sample
+        report(nameof(found), found.ToString());
+        report(nameof(missing), missing.ToString());
+
+        // sample: walkthrough/list-request
+        Answer atLeastTwo = await Send("GET", "/orders?minimum=2");   // 200 [{"id":"…","email":"ann@example.com","quantity":2,"status":"Placed"}]
+        Answer atLeastFive = await Send("GET", "/orders?minimum=5");  // 200 []
+        // end sample
+        report(nameof(atLeastTwo), atLeastTwo.ToString());
+        report(nameof(atLeastFive), atLeastFive.ToString());
+
+        // sample: walkthrough/change-request
+        Answer three = await Send("PATCH", $"/orders/{id}", """{"quantity":3}""");        // 200 {"id":"…","email":"ann@example.com","quantity":3,"status":"Placed"}
+        Answer zero = await Send("PATCH", $"/orders/{id}", """{"quantity":0}""");         // 400 {"type":"https://tools.ietf.org/html/rfc9110#section-15.5.1","title":"Bad Request","status":400,"traceId":"…"}
+        Answer cleared = await Send("PATCH", $"/orders/{id}", """{"quantity":null}""");   // 422 {"type":"https://tools.ietf.org/html/rfc4918#section-11.2","title":"Unprocessable Entity","status":422,"fault":"Cleared","traceId":"…"}
+        Answer shipped = await Send("PATCH", $"/orders/{id}", """{"status":"Shipped"}""");   // 200 {"id":"…","email":"ann@example.com","quantity":3,"status":"Shipped"}
+        Answer tooLate = await Send("PATCH", $"/orders/{id}", """{"quantity":4}""");      // 409 {"type":"https://tools.ietf.org/html/rfc9110#section-15.5.10","title":"Conflict","status":409,"fault":"AlreadyShipped","traceId":"…"}
+        // end sample
+        report(nameof(three), three.ToString());
+        report(nameof(zero), zero.ToString());
+        report(nameof(cleared), cleared.ToString());
+        report(nameof(shipped), shipped.ToString());
+        report(nameof(tooLate), tooLate.ToString());
+
+        // sample: walkthrough/document
+        JsonNode document = JsonNode.Parse(await http.GetStringAsync("/openapi/v1.json"))!;
+        JsonNode schemas = document["components"]!["schemas"]!;
+        JsonNode find = document["paths"]!["/orders/{id}"]!["get"]!;
+
+        string idParameter = find["parameters"]![0]!["schema"]!.ToJsonString();                         // {"type":"string","format":"uuid"}
+        string findAnswers = string.Join(",", find["responses"]!.AsObject().Select(answer => answer.Key));   // 200,404
+        string emailSchema = schemas["Email"]!.ToJsonString();                                             // {"type":"string"}
+        string statusSchema = schemas["OrderStatus"]!.ToJsonString();                                      // {"enum":["Placed","Shipped","Cancelled"],"type":"string"}
+        string patchType = schemas["OrderPatch"]!["properties"]!["quantity"]!["type"]!.ToJsonString();    // ["null","integer","string"]
+        // end sample
+        report(nameof(idParameter), idParameter);
+        report(nameof(findAnswers), findAnswers);
+        report(nameof(emailSchema), emailSchema);
+        report(nameof(statusSchema), statusSchema);
+        report(nameof(patchType), patchType);
+    }
+}
diff --git a/tools/ConsumerSmokeTest/Program.cs b/tools/ConsumerSmokeTest/Program.cs
index df978a2b..6365952a 100644
--- a/tools/ConsumerSmokeTest/Program.cs
+++ b/tools/ConsumerSmokeTest/Program.cs
@@ -12,7 +12,7 @@
 // consumer builds), compiles real code against them, runs it, and asserts on what it prints, on the
 // diagnostics the build reports, and on the resolved package graph. Never on the exit code alone.
 //
-// Four consumers, their sources under Consumers/:
+// Five consumers, their sources under Consumers/:
 //   core     references only CodoMetis.TypeKit: Option and Result work, no Metalama arrives, and
 //            CMTK0001 and CMTK0002 fire (design/analyzers.md).
 //   layered  a domain library references CodoMetis.TypeKit.Generators, and an app reaches everything
@@ -25,13 +25,17 @@
 //   aot      the same ground published with Native AOT (design/native-aot.md): no trim or AOT warning
 //            from a package or from the code woven into the consumer, and the native binary does
 //            what the JIT build does.
+//   walkthrough  the orders service docs/walkthrough.md follows, on all four packages a web service uses: every
+//            answer, log line and SQL statement the page states in a comment is what it gives, read from the page
+//            (WalkthroughPage.cs).
 //
 // Native AOT needs the platform linker: clang (and zlib on Linux), which the workflows install, or
 // MSVC's C++ build tools on Windows.
 //
-// Usage: dotnet tools/ConsumerSmokeTest/bin/Release/net10.0/consumer-smoke-test.dll [feed-directory]
+// Usage: dotnet tools/ConsumerSmokeTest/bin/Release/net10.0/consumer-smoke-test.dll [feed-directory] [--only <consumer>]
 //   With no argument the packages are packed fresh. Pass a directory of existing .nupkg files (the
-//   release workflow passes its pack output) to test exactly the artifacts being shipped.
+//   release workflow passes its pack output) to test exactly the artifacts being shipped. --only runs one
+//   consumer, for a local check: CI runs them all.
 using System.Diagnostics;
 using System.Text;
 using System.Text.RegularExpressions;
@@ -43,19 +47,22 @@
     Console.Error.WriteLine($"consumer-smoke-test: this dll was built from other sources than the checkout holds ({stale}). Run `{SourceFingerprint.RebuildCommand}`.");
     return SourceFingerprint.StaleExitCode;
 }
-if (args.Length > 1)
+var at = Array.IndexOf(args, "--only");
+var only = at >= 0 && at + 1 < args.Length ? args[at + 1] : null;
+string[] positional = at >= 0 ? [.. args[..at], .. args[Math.Min(at + 2, args.Length)..]] : args;
+if (positional.Length > 1 || (at >= 0 && only is not ("core" or "layered" or "host" or "aot" or "walkthrough")))
 {
-    Console.Error.WriteLine("Usage: consumer-smoke-test.dll [feed-directory]");
+    Console.Error.WriteLine("Usage: consumer-smoke-test.dll [feed-directory] [--only core|layered|host|aot|walkthrough]");
     return 2;
 }
-return new ConsumerSmokeTest.Smoke(root!, args.FirstOrDefault()).Run();
+return new ConsumerSmokeTest.Smoke(root!, positional.FirstOrDefault(), only).Run();
 
 namespace ConsumerSmokeTest
 {
     /// <summary>A command that failed where it had to succeed, or the reverse: the run stops, as the script's <c>set -e</c> did.</summary>
     internal sealed class Stop : Exception;
 
-    internal sealed partial class Smoke(string repoRoot, string? givenFeed)
+    internal sealed partial class Smoke(string repoRoot, string? givenFeed, string? only)
     {
         private readonly DirectoryInfo _created = Directory.CreateTempSubdirectory("consumer-smoke-test-");
         private string Work => _created.FullName;
@@ -184,10 +191,12 @@ private void Main()
                 """);
             File.Copy(Path.Combine(repoRoot, "global.json"), Path.Combine(Work, "global.json"));
 
-            Core();
-            Layered();
-            Host();
-            Aot();
+            // host builds on layered's Domain project, so it brings layered along.
+            if (only is null or "core") Core();
+            if (only is null or "layered" or "host") Layered();
+            if (only is null or "host") Host();
+            if (only is null or "aot") Aot();
+            if (only is null or "walkthrough") Walkthrough();
         }
 
         // ── core: the base package alone ───────────────────────────────────────────────────────────────
@@ -491,6 +500,87 @@ private void AotPublishAndRun(string name)
             File.AppendAllText(Path.Combine(Work, "aot.out"), Run(native) + "\n");
         }
 
+        // ── walkthrough: the orders service of docs/walkthrough.md ─────────────────────────────────────
+        //
+        // One web project on the four packages a service uses, as a reader would set it up: what the page shows is
+        // what it compiles. It prints each answer as name=value, the SQL EF Core runs and its log lines, and every
+        // expectation is read from the page's comments (WalkthroughPage), never written here: a changed answer fails
+        // until the page says it. ReadmeSampleTests holds the page's blocks to these sources, so an edit to a stated
+        // answer is an edit here too, which selects the pack lane; WalkthroughTests runs the same service in memory
+        // on every test leg.
+
+        private void Walkthrough()
+        {
+            Console.WriteLine("==> walkthrough: the orders service docs/walkthrough.md follows");
+            NewProject("web", "walkthrough", "CodoMetis.TypeKit.Generators", "CodoMetis.TypeKit.EntityFrameworkCore", "CodoMetis.TypeKit.AspNetCore", "CodoMetis.TypeKit.Serilog");
+            Run("dotnet", "add", "package", "Microsoft.EntityFrameworkCore.Sqlite", "--version", CentralVersion("Microsoft.EntityFrameworkCore.Relational"));
+            Run("dotnet", "add", "package", "Microsoft.AspNetCore.OpenApi", "--version", CentralVersion("Microsoft.AspNetCore.OpenApi"));
+            Run("dotnet", "add", "package", "Serilog.Sinks.Console", "--version", CentralVersion("Serilog.Sinks.Console"));
+            foreach (var source in (string[])["Orders.cs", "OrderEndpoints.cs", "Tour.cs", "Program.cs"]) Write(source, $"walkthrough/{source}");
+
+            Run("dotnet", "build");
+            ListPackages("walkthrough.packages");
+            Save("walkthrough.out", Run("dotnet", "run", "--no-build", "--no-launch-profile"));
+            Print("walkthrough.out");
+
+            Console.WriteLine("==> walkthrough: asserting against docs/walkthrough.md");
+            AssertContains("> CodoMetis.TypeKit.Generators ", "walkthrough.packages", "the generators resolved from the feed");
+            AssertContains("> CodoMetis.TypeKit.Serilog ", "walkthrough.packages", "the Serilog package resolved from the feed");
+            AssertVersions("walkthrough.packages");
+
+            var page = File.ReadAllText(Path.Combine(repoRoot, WalkthroughPage.Path));
+            var lines = SplitLines(Read("walkthrough.out")).ToList();
+            var answers = lines.Select(line => AnswerLine().Match(line)).Where(match => match.Success)
+                               .ToDictionary(match => match.Groups["name"].Value, match => match.Groups["value"].Value, StringComparer.Ordinal);
+
+            foreach (var name in WalkthroughPage.Declarations(page).Union(answers.Keys, StringComparer.Ordinal))
+            {
+                var value = answers.GetValueOrDefault(name);
+                AssertStated(page, WalkthroughPage.Answer(name), stated => value is not null && WalkthroughPage.Is(stated, value),
+                             value is null ? $"{name} is stated, and the service never answered it" : $"{name} is what the page states");
+            }
+            var logged = lines.Where(line => line.StartsWith("[INF] ", StringComparison.Ordinal)).ToList();
+            AssertStated(page, "log.Information(\"Placed", stated => WalkthroughPage.Within(stated, logged), "the log line is what the page states: the address masked");
+            AssertStated(page, "order.Quantity.Value >= minimum.Value", stated => WalkthroughPage.Within(stated, lines), ".Value in the query is the column in the SQL EF Core logs");
+            AssertStated(page, "Database.EnsureCreated()", stated => WalkthroughPage.Within(stated, lines), "each value object is a column of its underlying type");
+            if (logged.Count == 0 || logged.Any(line => line.Contains("ann@example.com", StringComparison.Ordinal)))
+            {
+                Console.WriteLine("  FAIL: the e-mail address is masked in every log line, and there is one");
+                foreach (var line in logged) Console.WriteLine("      " + line);
+                _failed = true;
+            }
+            else
+            {
+                Console.WriteLine("  ok: the e-mail address is masked in every log line");
+            }
+        }
+
+        // What the page states for the fragment holds; a page that no longer states it fails too.
+        private void AssertStated(string page, string fragment, Func<IReadOnlyList<string>, bool> holds, string message)
+        {
+            IReadOnlyList<string> stated;
+            try
+            {
+                stated = WalkthroughPage.Stated(page, fragment);
+            }
+            catch (InvalidOperationException e)
+            {
+                Console.WriteLine($"  FAIL: {message} ({e.Message})");
+                _failed = true;
+                return;
+            }
+            if (holds(stated))
+            {
+                Console.WriteLine($"  ok: {message}");
+                return;
+            }
+            Console.WriteLine($"  FAIL: {message} (the page states '{string.Join(" / ", stated)}' for '{fragment.Trim()}')");
+            _failed = true;
+        }
+
+        [GeneratedRegex(@"^(?<name>[a-z]\w*)=(?<value>.*)$")]
+        private static partial Regex AnswerLine();
+
         // ── the steps ──────────────────────────────────────────────────────────────────────────────────
 
         // Creates a project from a template under the work directory and installs packages into it. No
diff --git a/tools/ConsumerSmokeTest/WalkthroughPage.cs b/tools/ConsumerSmokeTest/WalkthroughPage.cs
new file mode 100644
index 00000000..190cf75c
--- /dev/null
+++ b/tools/ConsumerSmokeTest/WalkthroughPage.cs
@@ -0,0 +1,94 @@
+using System.Text.RegularExpressions;
+
+namespace ConsumerSmokeTest;
+
+/// <summary>
+/// What docs/walkthrough.md states in its C# comments: the answers, the log line and the SQL of the orders service
+/// its blocks show. The smoke test's walkthrough consumer is that service, and test/CodoMetis.TypeKit.Samples compiles
+/// this file for WalkthroughTests, which runs the service in memory; both compare what it gives with this.
+/// </summary>
+/// <remarks>
+/// A statement is the comment after the one line of C# whose code holds a fragment, or the comment lines right below
+/// that line. An ellipsis (U+2026) in it stands for any text, such as an order's id or a trace id. The expected text
+/// is read from the page, never written into a check, so a changed answer is corrected in the page's comment: and
+/// ReadmeSampleTests holds the page's blocks to the consumer's sources, so the line read here is the line it runs.
+/// </remarks>
+internal static partial class WalkthroughPage
+{
+    public const string Path = "docs/walkthrough.md";
+
+    private const char Ellipsis = (char)0x2026;
+
+    /// <summary>The statement for <paramref name="fragment"/>, one entry per line; throws when no single line holds it, or it states nothing.</summary>
+    public static IReadOnlyList<string> Stated(string page, string fragment)
+    {
+        var lines = CSharpLines(page).ToArray();
+        var matches = Enumerable.Range(0, lines.Length).Where(i => CodeOf(lines[i]).Contains(fragment, StringComparison.Ordinal)).ToArray();
+        if (matches.Length != 1) throw new InvalidOperationException($"{Path} should have one line of C# holding '{fragment}', but has {matches.Length}.");
+
+        if (CommentOf(lines[matches[0]]) is { } comment) return [comment];
+
+        var below = lines.Skip(matches[0] + 1).TakeWhile(line => line.TrimStart().StartsWith("//", StringComparison.Ordinal))
+                         .Select(line => line.TrimStart()[2..].Trim()).ToArray();
+        return below.Length > 0 ? below : throw new InvalidOperationException($"{Path} states nothing for '{fragment}'.");
+    }
+
+    /// <summary>The answers the page states: each <c>Answer</c> or <c>string</c> declared on a line with a comment, by the variable's name.</summary>
+    public static IReadOnlyList<string> Declarations(string page) =>
+    [
+        .. CSharpLines(page).Where(line => CommentOf(line) is not null)
+                            .Select(line => Declaration().Match(CodeOf(line)))
+                            .Where(match => match.Success)
+                            .Select(match => match.Groups["name"].Value)
+    ];
+
+    /// <summary>The fragment that finds the statement of a declared answer: its name and the assignment.</summary>
+    public static string Answer(string name) => $" {name} = ";
+
+    /// <summary>Whether <paramref name="value"/> is the one-line statement, whole.</summary>
+    public static bool Is(IReadOnlyList<string> stated, string value) => stated.Count == 1 && Pattern(stated[0], whole: true).IsMatch(value);
+
+    /// <summary>Whether the stated lines are consecutive lines of <paramref name="lines"/>, each ending in its statement.</summary>
+    public static bool Within(IReadOnlyList<string> stated, IReadOnlyList<string> lines)
+    {
+        var patterns = stated.Select(line => Pattern(line, whole: false)).ToArray();
+        return Enumerable.Range(0, Math.Max(0, lines.Count - patterns.Length + 1))
+                         .Any(start => patterns.Select((pattern, i) => pattern.IsMatch(lines[start + i].Trim())).All(matched => matched));
+    }
+
+    private static Regex Pattern(string statement, bool whole) =>
+        new((whole ? "^" : "") + string.Join(".*?", statement.Split(Ellipsis).Select(Regex.Escape)) + "$", RegexOptions.CultureInvariant);
+
+    private static IEnumerable<string> CSharpLines(string page)
+    {
+        var inCSharp = false;
+        foreach (var line in page.ReplaceLineEndings("\n").Split('\n'))
+        {
+            if (line.TrimStart().StartsWith("```", StringComparison.Ordinal)) inCSharp = !inCSharp && line.TrimStart()[3..].Trim() is "csharp" or "cs";
+            else if (inCSharp) yield return line;
+        }
+    }
+
+    private static string CodeOf(string line) => (CommentStart(line) is var start and >= 0 ? line[..start] : line).Trim();
+
+    // The comment after code on the same line; a line that is only a comment has none.
+    private static string? CommentOf(string line) =>
+        CommentStart(line) is var start and >= 0 && line[..start].Trim().Length > 0 ? line[(start + 2)..].Trim() : null;
+
+    // Where a line's // comment starts, outside any string literal.
+    private static int CommentStart(string line)
+    {
+        var inString = false;
+        for (var i = 0; i < line.Length - 1; i++)
+        {
+            if (inString && line[i] == '\\') i++;
+            else if (line[i] == '"') inString = !inString;
+            else if (!inString && line[i] == '/' && line[i + 1] == '/') return i;
+        }
+
+        return -1;
+    }
+
+    [GeneratedRegex(@"^(?:Answer|string) (?<name>\w+) = ")]
+    private static partial Regex Declaration();
+}
diff --git a/tools/Directory.Build.props b/tools/Directory.Build.props
index e87f7909..443b70ff 100644
--- a/tools/Directory.Build.props
+++ b/tools/Directory.Build.props
@@ -9,7 +9,7 @@
     <PropertyGroup>
         <IsPackable>false</IsPackable>
         <EnablePackageValidation>false</EnablePackageValidation>
-        <!-- The sources a tool's fingerprint covers, relative to its project; a tool adds its own (Prober: Schemas/*.json). -->
+        <!-- The sources a tool's fingerprint covers, relative to its project; a tool adds its own. -->
         <ToolSourcePatterns>**/*.cs</ToolSourcePatterns>
     </PropertyGroup>
 
diff --git a/tools/DocsQuery/Citations.cs b/tools/DocsQuery/Citations.cs
deleted file mode 100644
index ef97fba4..00000000
--- a/tools/DocsQuery/Citations.cs
+++ /dev/null
@@ -1,260 +0,0 @@
-using System.Globalization;
-using System.Text;
-using System.Text.Json;
-using System.Text.RegularExpressions;
-
-namespace DocsQuery;
-
-/// <summary>
-/// Where the probe corpus leans on a verified fact to prune a row or excuse one (design/adr/0107): a <c>refused</c>
-/// entry of the axes file whose reason names <c>KB-NNN</c>, a <c>not-promised</c> entry of claims.json whose
-/// <c>source</c> is a fact's file or which says <c>fact:KB-NNN</c>, an obligation's declaration of where it does not
-/// apply whose <c>cite</c> is <c>fact:KB-NNN</c>, and a <c>Cite.Fact("KB-NNN")</c> or <c>Baseline.Fact("KB-NNN")</c>
-/// literal in the harness and probe sources, read as text with comments blanked out. Each is read from the checkout
-/// at every <c>check</c>, never from the index.
-/// </summary>
-internal static partial class FactCitations
-{
-    public const string AxesFile = ".claude/probe-axes.md", ClaimsFile = "tools/probe/corpus/claims.json";
-
-    public static readonly string[] SourceDirectories = ["tools/probe/corpus/harness", "tools/probe/corpus/probes"];
-
-    /// <summary>The four places, in the order <c>check</c> counts them.</summary>
-    public static readonly string[] Kinds = [Refused, NotPromised, Obligation, Harness];
-
-    public const string Refused = "refused", NotPromised = "not-promised", Obligation = "obligation", Harness = "harness";
-
-    /// <summary>
-    /// One citation: the kind of place, where it is written (<c>path:line</c>), the fact's id, the place in words, and
-    /// whether it reads the fact's fixture as a baseline (<c>Baseline.Fact</c>), which takes a fixture as well as a test.
-    /// </summary>
-    internal sealed record Citation(string Kind, string At, string Fact, string Place, bool Baseline = false);
-
-    /// <summary>What a scan read: every citation, and how many places of each kind it looked at, cited or not.</summary>
-    internal sealed record Scan(IReadOnlyList<Citation> Citations, IReadOnlyDictionary<string, int> Read)
-    {
-        public int Of(string kind) => Citations.Count(citation => citation.Kind == kind);
-    }
-
-    public static Scan Find(string root)
-    {
-        var citations = new List<Citation>();
-        var read      = Kinds.ToDictionary(kind => kind, _ => 0, StringComparer.Ordinal);
-
-        ReadAxes(root, citations, read);
-        ReadClaims(root, citations, read);
-        ReadSources(root, citations, read);
-
-        return new Scan(citations, read);
-    }
-
-    /// <summary>The axes file's <c>refused</c> entries: axis to value to the reason the framework refuses it.</summary>
-    private static void ReadAxes(string root, List<Citation> citations, Dictionary<string, int> read)
-    {
-        var path = Path.Combine(root, AxesFile);
-        if (!File.Exists(path)) return;
-
-        const string marker = "```json probe-axes";
-        var text  = File.ReadAllText(path).ReplaceLineEndings("\n");
-        var start = text.IndexOf(marker, StringComparison.Ordinal);
-        if (start < 0) return;
-        start += marker.Length;
-        var end = text.IndexOf("```", start, StringComparison.Ordinal);
-        if (end < 0) return;
-
-        using var block = JsonDocument.Parse(text[start..end]);
-        if (!block.RootElement.TryGetProperty("refused", out var refused) || refused.ValueKind != JsonValueKind.Object) return;
-
-        var cursor = new Cursor(AxesFile, text, text.IndexOf("\"refused\"", start, StringComparison.Ordinal));
-        foreach (var axis in refused.EnumerateObject().Where(axis => axis.Value.ValueKind == JsonValueKind.Object))
-        {
-            foreach (var value in axis.Value.EnumerateObject())
-            {
-                read[Refused]++;
-                var place = $"the refused entry {axis.Name}={value.Name}";
-                cursor.Seek($"\"{value.Name}\"");
-                foreach (var fact in FactIds(value.Value.ValueKind == JsonValueKind.String ? value.Value.GetString()! : value.Value.GetRawText()))
-                    citations.Add(new Citation(Refused, cursor.At(fact), fact, place));
-            }
-        }
-    }
-
-    /// <summary>Each claim's <c>not-promised</c> entries and its obligations' <c>inapplicable</c> declarations.</summary>
-    private static void ReadClaims(string root, List<Citation> citations, Dictionary<string, int> read)
-    {
-        var path = Path.Combine(root, ClaimsFile);
-        if (!File.Exists(path)) return;
-
-        var text = File.ReadAllText(path).ReplaceLineEndings("\n");
-        using var claims = JsonDocument.Parse(text);
-        if (claims.RootElement.ValueKind != JsonValueKind.Array) return;
-
-        // Walked in the file's order, so each citation's line is the next occurrence of its id from the last one.
-        var cursor = new Cursor(ClaimsFile, text, 0);
-        foreach (var claim in claims.RootElement.EnumerateArray())
-        {
-            var id = Str(claim, "id");
-            cursor.Seek($"\"{id}\"");
-
-            foreach (var property in claim.EnumerateObject())
-            {
-                if (property.NameEquals("obligations") && property.Value.ValueKind == JsonValueKind.Array)
-                {
-                    foreach (var obligation in property.Value.EnumerateArray())
-                    {
-                        cursor.Seek($"\"{Str(obligation, "id")}\"");
-                        var number = 0;
-                        foreach (var declaration in Array(obligation, "inapplicable"))
-                        {
-                            read[Obligation]++;
-                            number++;
-                            if (FactOf(Str(declaration, "cite")) is not { } fact) continue;
-                            citations.Add(new Citation(Obligation, cursor.At("fact:" + fact), fact,
-                                $"claim {id}, obligation {Str(obligation, "id")}, inapplicable declaration {number.ToString(CultureInfo.InvariantCulture)}"));
-                        }
-                    }
-                }
-                else if (property.NameEquals("not-promised") && property.Value.ValueKind == JsonValueKind.Array)
-                {
-                    foreach (var entry in property.Value.EnumerateArray())
-                    {
-                        read[NotPromised]++;
-                        cursor.Seek($"\"{Str(entry, "id")}\"");
-                        var place = $"claim {id}, not-promised {Str(entry, "id")}";
-                        var facts = new List<string>();
-                        if (KnowledgeSource().Match(Str(entry, "source")) is { Success: true } source) facts.Add(source.Groups["id"].Value);
-                        foreach (var field in entry.EnumerateObject().Where(field => field.Value.ValueKind == JsonValueKind.String))
-                            facts.AddRange(CiteFact().Matches(field.Value.GetString()!).Select(match => match.Groups["id"].Value));
-
-                        foreach (var fact in facts.Distinct(StringComparer.Ordinal))
-                            citations.Add(new Citation(NotPromised, cursor.At(fact), fact, place));
-                    }
-                }
-            }
-        }
-    }
-
-    /// <summary>The harness's and the probes' <c>Cite.Fact</c> and <c>Baseline.Fact</c> literals, comments blanked out.</summary>
-    private static void ReadSources(string root, List<Citation> citations, Dictionary<string, int> read)
-    {
-        foreach (var directory in SourceDirectories.Select(directory => Path.Combine(root, directory)).Where(Directory.Exists))
-        {
-            foreach (var file in Directory.EnumerateFiles(directory, "*.cs").Order(StringComparer.Ordinal))
-            {
-                read[Harness]++;
-                var path   = Corpus.Relative(root, file);
-                var source = File.ReadAllText(file).ReplaceLineEndings("\n");
-                foreach (Match match in FactLiteral().Matches(WithoutComments(source)))
-                {
-                    var line = 1 + source.AsSpan(0, match.Index).Count('\n');
-                    citations.Add(new Citation(Harness, $"{path}:{line.ToString(CultureInfo.InvariantCulture)}", match.Groups["id"].Value,
-                        $"{match.Groups["factory"].Value}.Fact(\"{match.Groups["id"].Value}\")", match.Groups["factory"].Value == "Baseline"));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// The source with each comment's content replaced by spaces, newlines kept, and string literals as they are, so a
-    /// citation written in a comment does not count and a line number still holds.
-    /// </summary>
-    internal static string WithoutComments(string source)
-    {
-        var result = new StringBuilder(source);
-        for (var i = 0; i < source.Length; i++)
-        {
-            if (source[i] == '/' && i + 1 < source.Length && source[i + 1] == '/')
-            {
-                for (; i < source.Length && source[i] != '\n'; i++) result[i] = ' ';
-            }
-            else if (source[i] == '/' && i + 1 < source.Length && source[i + 1] == '*')
-            {
-                var close = source.IndexOf("*/", i + 2, StringComparison.Ordinal);
-                var stop  = close < 0 ? source.Length : close + 2;
-                for (; i < stop; i++) if (source[i] != '\n') result[i] = ' ';
-                i--;
-            }
-            else if (source[i] == '"')
-            {
-                i = AfterString(source, i);
-            }
-            else if (source[i] == '\'')
-            {
-                // A character literal: '"' must not open a string.
-                var j = i + 1;
-                if (j < source.Length && source[j] == '\\') j++;
-                if (j + 1 < source.Length && source[j + 1] == '\'') i = j + 1;
-            }
-        }
-
-        return result.ToString();
-    }
-
-    /// <summary>The index of the closing quote of the string literal opened at <paramref name="i"/>: raw, verbatim or regular.</summary>
-    private static int AfterString(string source, int i)
-    {
-        var quotes = 0;
-        while (i + quotes < source.Length && source[i + quotes] == '"') quotes++;
-
-        if (quotes >= 3)
-        {
-            var close = source.IndexOf(new string('"', quotes), i + quotes, StringComparison.Ordinal);
-            return close < 0 ? source.Length : close + quotes - 1;
-        }
-
-        if (quotes == 2) return i + 1;   // ""
-
-        var verbatim = i > 0 && source[i - 1] == '@' || i > 1 && source[i - 1] == '$' && source[i - 2] == '@';
-        for (var j = i + 1; j < source.Length; j++)
-        {
-            if (verbatim && source[j] == '"' && j + 1 < source.Length && source[j + 1] == '"') { j++; continue; }
-            if (!verbatim && source[j] == '\\') { j++; continue; }
-            if (source[j] == '"' || !verbatim && source[j] == '\n') return j;
-        }
-
-        return source.Length;
-    }
-
-    /// <summary>The ids a refused entry's reason names, as <c>fact:KB-NNN</c> or plain <c>KB-NNN</c>.</summary>
-    private static IEnumerable<string> FactIds(string text) => AnyFact().Matches(text).Select(match => match.Value).Distinct(StringComparer.Ordinal);
-
-    private static string? FactOf(string cite) => cite.StartsWith("fact:", StringComparison.Ordinal) ? cite["fact:".Length..] : null;
-
-    private static string Str(JsonElement element, string name) =>
-        element.ValueKind == JsonValueKind.Object && element.TryGetProperty(name, out var value) && value.ValueKind == JsonValueKind.String ? value.GetString()! : "";
-
-    private static IEnumerable<JsonElement> Array(JsonElement element, string name) =>
-        element.ValueKind == JsonValueKind.Object && element.TryGetProperty(name, out var value) && value.ValueKind == JsonValueKind.Array ? value.EnumerateArray() : [];
-
-    /// <summary>Line numbers for places read in a file's order: each needle is looked for from the last place found.</summary>
-    private sealed class Cursor(string path, string text, int offset)
-    {
-        private int at = Math.Max(0, offset);
-
-        public void Seek(string needle)
-        {
-            var found = text.IndexOf(needle, at, StringComparison.Ordinal);
-            if (found >= 0) at = found;
-        }
-
-        public string At(string needle)
-        {
-            var found = text.IndexOf(needle, at, StringComparison.Ordinal);
-            var line  = 1 + text.AsSpan(0, found >= 0 ? found : at).Count('\n');
-            if (found >= 0) at = found + needle.Length;
-            return $"{path}:{line.ToString(CultureInfo.InvariantCulture)}";
-        }
-    }
-
-    [GeneratedRegex(@"\bKB-\d{3}\b")]
-    private static partial Regex AnyFact();
-
-    [GeneratedRegex(@"\bfact:\s?(?<id>KB-\d{3})\b")]
-    private static partial Regex CiteFact();
-
-    [GeneratedRegex(@"^design/knowledge/(?<id>KB-\d{3})-[^/#]*\.md(#.*)?$")]
-    private static partial Regex KnowledgeSource();
-
-    [GeneratedRegex(@"\b(?<factory>Cite|Baseline)\s*\.\s*Fact\s*\(\s*""(?<id>KB-\d{3})""\s*\)")]
-    private static partial Regex FactLiteral();
-}
diff --git a/tools/DocsQuery/Corpus.cs b/tools/DocsQuery/Corpus.cs
index 01bd3b1e..d294e68d 100644
--- a/tools/DocsQuery/Corpus.cs
+++ b/tools/DocsQuery/Corpus.cs
@@ -95,17 +95,24 @@ void Add(string relativeDirectory, string pattern, SearchOption option)
                         .Order(StringComparer.Ordinal)];
     }
 
-    /// <summary>The samples project's C# files, whose <c>// sample:</c> regions compile the pages' blocks.</summary>
-    public static IReadOnlyList<string> Samples(string root)
-    {
-        var directory = Path.Combine(root, SamplesProject);
-        if (!Directory.Exists(directory)) return [];
-
-        return [.. Directory.EnumerateFiles(directory, "*.cs", SearchOption.AllDirectories)
-                            .Select(path => Relative(root, path))
-                            .Where(path => !InBuildOutput(path))
-                            .Order(StringComparer.Ordinal)];
-    }
+    /// <summary>
+    /// Where a page keeps its regions outside the samples project: the walkthrough's sample application, the smoke
+    /// test's consumer that the packed packages build. ReadmeSamples.RegionSources in the conventions tests is the
+    /// same list.
+    /// </summary>
+    public static readonly string[] PageSources = ["tools/ConsumerSmokeTest/Consumers/walkthrough"];
+
+    /// <summary>The C# files whose <c>// sample:</c> regions compile the pages' blocks: the samples project's and each page's own sources.</summary>
+    public static IReadOnlyList<string> Samples(string root) =>
+    [
+        .. new[] { SamplesProject }.Concat(PageSources)
+                                   .Select(relative => Path.Combine(root, relative))
+                                   .Where(Directory.Exists)
+                                   .SelectMany(directory => Directory.EnumerateFiles(directory, "*.cs", SearchOption.AllDirectories))
+                                   .Select(path => Relative(root, path))
+                                   .Where(path => !InBuildOutput(path))
+                                   .Order(StringComparer.Ordinal)
+    ];
 
     /// <summary>
     /// The fingerprint of an index: the schema version, the tool's own version (the hash of its
diff --git a/tools/DocsQuery/Facts.cs b/tools/DocsQuery/Facts.cs
index 9f5d81ec..d4f051eb 100644
--- a/tools/DocsQuery/Facts.cs
+++ b/tools/DocsQuery/Facts.cs
@@ -83,9 +83,25 @@ public static (State State, string Detail) Compare(string pin, Installed install
         };
     }
 
+    /// <summary>
+    /// An <c>external {name} {version}</c> pin's name and version, where the version is one (<c>10.6.0</c>,
+    /// <c>5.0.0-beta-78</c>), or null: another kind of pin, or an external one dated or described rather than
+    /// versioned (<c>external NuGet registration data</c>). A dated pin, <c>external GitHub-Actions 2026-10-29</c>,
+    /// reads as a version: that NuGet has no package of the name is what keeps it from being compared.
+    /// </summary>
+    public static (string Name, string Version)? External(string pin)
+    {
+        var parts = pin.Split(' ', StringSplitOptions.RemoveEmptyEntries);
+        return parts is ["external", var name, var version, ..] && VersionText().IsMatch(version) ? (name, version) : null;
+    }
+
+    /// <summary>Whether a version is a pre-release: a label after a dash.</summary>
+    public static bool IsPreRelease(string version) => version.Contains('-', StringComparison.Ordinal);
+
     /// <summary>
     /// Orders two versions: numeric parts numerically, then a release after any of its pre-releases, and
-    /// pre-release labels ordinally. Enough for the versions <c>Directory.Packages.props</c> holds.
+    /// pre-release labels as SemVer 2 and NuGet order them. Enough for the versions <c>Directory.Packages.props</c>
+    /// holds and the ones NuGet lists.
     /// </summary>
     public static int CompareVersions(string left, string right)
     {
@@ -107,9 +123,30 @@ public static int CompareVersions(string left, string right)
             (null, null) => 0,
             (null, _)    => 1,
             (_, null)    => -1,
-            _            => Math.Sign(string.CompareOrdinal(leftLabel, rightLabel)),
+            _            => Labels(leftLabel, rightLabel),
         };
 
+        // Dot-separated identifiers: numeric ones numerically and before an alphanumeric one, alphanumeric ones
+        // ignoring case, and a label before a longer one it starts (beta.2 before beta.10, beta before beta.1).
+        static int Labels(string left, string right)
+        {
+            var (a, b) = (left.Split('.'), right.Split('.'));
+
+            for (var i = 0; i < Math.Min(a.Length, b.Length); i++)
+            {
+                var order = (long.TryParse(a[i], NumberStyles.None, CultureInfo.InvariantCulture, out var x), long.TryParse(b[i], NumberStyles.None, CultureInfo.InvariantCulture, out var y)) switch
+                {
+                    (true, true)  => x.CompareTo(y),
+                    (true, false) => -1,
+                    (false, true) => 1,
+                    _             => string.Compare(a[i], b[i], StringComparison.OrdinalIgnoreCase),
+                };
+                if (order != 0) return Math.Sign(order);
+            }
+
+            return a.Length.CompareTo(b.Length);
+        }
+
         static (string[] Core, string? Label) Split(string version)
         {
             var dash = version.IndexOf('-', StringComparison.Ordinal);
@@ -119,15 +156,73 @@ public static int CompareVersions(string left, string right)
 
     [GeneratedRegex(@"^(?<major>\d+)\.(?<minor>\d+)\.(?<band>\d)xx$")]
     private static partial Regex Band();
+
+    [GeneratedRegex(@"^\d+(\.\d+)*(-[0-9A-Za-z.-]+)?$")]
+    private static partial Regex VersionText();
+}
+
+/// <summary>
+/// The facts due for a re-read before a release (CONTRIBUTING's "Releasing"). An <c>external</c> pin names what this
+/// checkout never installs, a competitor's release among them, so <c>check</c> never compares it and the fact is as
+/// fresh as its date. A fact with one is due when it was verified more than a number of days ago and, when a feed is
+/// given, when NuGet has a later release of a package it pins: a later stable release for a stable pin, a later one
+/// of any kind for a pre-release. Run by hand, never in CI: a build must not fail because time passed or someone
+/// else released.
+/// </summary>
+internal static class FactReview
+{
+    /// <summary>Six months: a fact read longer ago than this is due, whatever its pins.</summary>
+    public const int DefaultDays = 183;
+
+    internal sealed record Due(string At, string Kind, string Id, string Target, string Detail);
+
+    /// <summary>The versions NuGet lists for a package id, or null where it has no package of that id.</summary>
+    internal delegate IReadOnlyList<string>? Feed(string packageId);
+
+    public static IReadOnlyList<Due> List(DocIndex index, DateOnly today, int days, Feed? feed, out int facts, out int compared)
+    {
+        var due   = new List<Due>();
+        var order = Comparer<string>.Create(Pins.CompareVersions);
+        (facts, compared) = (0, 0);
+
+        foreach (var doc in index.Docs.Where(doc => doc.Kind == Kind.Fact))
+        {
+            var pins = doc.Meta.Where(field => field.Key == "pins" && field.Value.StartsWith("external ", StringComparison.Ordinal)).ToList();
+            if (pins.Count == 0) continue;
+            facts++;
+
+            string At(int line) => $"{doc.Path}:{line.ToString(CultureInfo.InvariantCulture)}";
+
+            if (doc.Meta.FirstOrDefault(field => field.Key == "verified") is { } verified
+             && DateOnly.TryParseExact(verified.Value, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var date)
+             && today.DayNumber - date.DayNumber is var age && age > days)
+                due.Add(new Due(At(verified.Line), "fact-old", doc.Id!, verified.Value, $"verified {age.ToString(CultureInfo.InvariantCulture)} days ago, more than {days.ToString(CultureInfo.InvariantCulture)}: re-read it at its latest release"));
+
+            if (feed is null) continue;
+
+            foreach (var pin in pins)
+            {
+                if (Pins.External(pin.Value) is not { } external || feed(external.Name) is not { Count: > 0 } versions) continue;
+                var (name, version) = external;
+                compared++;
+
+                var track  = Pins.IsPreRelease(version) ? versions : [.. versions.Where(listed => !Pins.IsPreRelease(listed))];
+                var latest = track.Count == 0 ? null : track.Max(order);
+
+                if (latest is not null && Pins.CompareVersions(version, latest) < 0)
+                    due.Add(new Due(At(pin.Line), "fact-released", doc.Id!, pin.Value, $"NuGet's latest{(Pins.IsPreRelease(version) ? "" : " stable")} {name} is {latest}: re-read it there"));
+            }
+        }
+
+        return due;
+    }
 }
 
 /// <summary>
 /// The rules a verified fact is held to (design/adr/0093): its frontmatter is complete and plain, each pin
 /// matches what is installed, and its <c>test:</c> names the characterization test that observes it, or says
 /// <c>none</c> and why. A test of the facts project that no fact names is a problem too. A <c>fixture:</c>, the
-/// measured answer of the fact's test as data, sits beside that test and exists (design/adr/0107). A fact the probe
-/// corpus cites to prune or excuse a row (<see cref="FactCitations"/>) is executable: its test exists, and where the
-/// harness reads it as a baseline, its fixture too.
+/// measured answer of the fact's test as data, sits beside that test and exists (design/adr/0107).
 /// </summary>
 internal static partial class FactRules
 {
@@ -139,9 +234,7 @@ internal sealed record Problem(string At, string Kind, string Target, string Det
 
     public const string FixtureSuffix = ".fixture.json";
 
-    public static IReadOnlyList<Problem> Check(DocIndex index, string root, out int facts) => Check(index, root, out facts, out _);
-
-    public static IReadOnlyList<Problem> Check(DocIndex index, string root, out int facts, out FactCitations.Scan cited)
+    public static IReadOnlyList<Problem> Check(DocIndex index, string root, out int facts)
     {
         var problems  = new List<Problem>();
         var installed = Installed.Read(root);
@@ -149,7 +242,6 @@ public static IReadOnlyList<Problem> Check(DocIndex index, string root, out int
         var fixtures  = new HashSet<string>(StringComparer.Ordinal);
         // Why each fact cannot settle a pruning or an excuse, or null where its test exists; and its fixture, where one exists.
         var notExecutable = new Dictionary<string, string?>(StringComparer.Ordinal);
-        var fixtureOf     = new Dictionary<string, string?>(StringComparer.Ordinal);
         facts = 0;
 
         for (var d = 0; d < index.Docs.Count; d++)
@@ -221,7 +313,6 @@ public static IReadOnlyList<Problem> Check(DocIndex index, string root, out int
                 }
             }
 
-            fixtureOf[doc.Id!] = null;
             if (doc.Meta.FirstOrDefault(field => field.Key == "fixture") is { } fixture)
             {
                 var expected = $"{FactsProject}/{className}{FixtureSuffix}";
@@ -235,23 +326,9 @@ public static IReadOnlyList<Problem> Check(DocIndex index, string root, out int
                     problems.Add(new Problem(At(fixture.Line), "fact-fixture", fixture.Value, $"write it beside the test, as {expected}"));
                 else if (!File.Exists(Path.Combine(root, fixture.Value)))
                     problems.Add(new Problem(At(fixture.Line), "fact-fixture-missing", fixture.Value, "the file does not exist"));
-                else
-                    fixtureOf[doc.Id!] = fixture.Value;
             }
         }
 
-        cited = FactCitations.Find(root);
-        foreach (var citation in cited.Citations)
-        {
-            var why = !notExecutable.TryGetValue(citation.Fact, out var reason) ? "there is no such fact under design/knowledge/"
-                    : reason is not null ? reason
-                    : citation.Baseline && fixtureOf[citation.Fact] is null ? "the harness reads its fixture as a baseline, and it names no fixture: that exists"
-                    : null;
-            if (why is not null)
-                problems.Add(new Problem(citation.At, "fact-not-executable-cited", citation.Fact,
-                    $"{citation.Place} cites {citation.Fact}, and {why}: a fact without its test explains only, never prunes or excuses a row; write its test in {FactsProject}/, or cite a docs sentence"));
-        }
-
         var project = Path.Combine(root, FactsProject);
         if (Directory.Exists(project))
         {
diff --git a/tools/DocsQuery/NuGetFeed.cs b/tools/DocsQuery/NuGetFeed.cs
new file mode 100644
index 00000000..ebc72510
--- /dev/null
+++ b/tools/DocsQuery/NuGetFeed.cs
@@ -0,0 +1,26 @@
+using System.Net;
+using System.Text.Json;
+
+namespace DocsQuery;
+
+/// <summary>
+/// The versions nuget.org lists for a package, from its flat container (<c>v3-flatcontainer/{id}/index.json</c>), for
+/// <c>due --nuget</c>. The one command that reaches the network, and only when asked; nothing in CI asks.
+/// </summary>
+internal static class NuGetFeed
+{
+    private static readonly HttpClient Http = new() { Timeout = TimeSpan.FromSeconds(30) };
+
+    /// <summary>Every version of <paramref name="packageId"/>, or null where nuget.org has no package of that id.</summary>
+    public static IReadOnlyList<string>? Versions(string packageId)
+    {
+        var url = $"https://api.nuget.org/v3-flatcontainer/{Uri.EscapeDataString(packageId.ToLowerInvariant())}/index.json";
+
+        using var response = Http.GetAsync(url).GetAwaiter().GetResult();
+        if (response.StatusCode == HttpStatusCode.NotFound) return null;
+        response.EnsureSuccessStatusCode();
+
+        using var document = JsonDocument.Parse(response.Content.ReadAsStream());
+        return [.. document.RootElement.GetProperty("versions").EnumerateArray().Select(version => version.GetString() ?? "")];
+    }
+}
diff --git a/tools/DocsQuery/Program.cs b/tools/DocsQuery/Program.cs
index 71652172..47881519 100644
--- a/tools/DocsQuery/Program.cs
+++ b/tools/DocsQuery/Program.cs
@@ -18,6 +18,9 @@ internal static class Program
           find <words>           ranked (BM25); --top N, --kind K. A miss proves nothing
           claims [page]          every C# block, stated output and shown block of the README and
                                  docs pages; --kind csharp|stated|block
+          due [days]             the facts to re-read before a release: an external pin verified more than
+                                 days ago (default 183); --nuget also lists a pin NuGet has a later release
+                                 of, read from api.nuget.org. By hand, never in CI
           check                  broken links, missing anchors, ids defined nowhere, and the verified
                                  facts' rules: a pin behind, ahead or naming nothing installed, a
                                  fact without its test, a test without its fact
@@ -36,13 +39,14 @@ private static int Main(string[] args)
         var positional = new List<string>();
         string? root = null, kind = null;
         int top = 10, depth = 1;
-        var json = false;
+        bool json = false, nuget = false;
 
         for (var i = 0; i < args.Length; i++)
         {
             switch (args[i])
             {
                 case "--json": json = true; break;
+                case "--nuget": nuget = true; break;
                 case "--root" when i + 1 < args.Length: root = args[++i]; break;
                 case "--kind" when i + 1 < args.Length: kind = args[++i]; break;
                 case "--top" when i + 1 < args.Length && int.TryParse(args[i + 1], CultureInfo.InvariantCulture, out var n) && n > 0: top = n; i++; break;
@@ -68,7 +72,25 @@ private static int Main(string[] args)
         var queries    = new Queries(index, root);
         var query      = string.Join(' ', positional.Skip(1));
 
-        Answer? answer = positional[0] switch
+        Answer? answer;
+        try
+        {
+            answer = Run(queries, positional, query, top, kind, depth, nuget);
+        }
+        catch (Exception exception) when (exception is HttpRequestException or TaskCanceledException)
+        {
+            Console.Error.WriteLine($"docs-query: nuget.org could not be read ({exception.Message}).");
+            return 1;
+        }
+
+        if (answer is null) return Fail($"'{string.Join(' ', positional)}' is no command; run `help`.");
+
+        Console.Write(json ? answer.Json() : answer.Text());
+        return answer.ExitCode;
+    }
+
+    private static Answer? Run(Queries queries, List<string> positional, string query, int top, string? kind, int depth, bool nuget) =>
+        positional[0] switch
         {
             "entry" when query.Length > 0    => queries.Entry(query),
             "outline" when query.Length > 0  => queries.Outline(query),
@@ -77,14 +99,17 @@ private static int Main(string[] args)
             "list"                           => queries.List([.. positional.Skip(1)]),
             "find" when query.Length > 0     => queries.Find(query, top, kind),
             "claims"                         => queries.Claims(query.Length > 0 ? query : null, kind),
+            "due"                            => Due(queries, positional, nuget),
             "check"                          => queries.Check(),
             _                                => null,
         };
 
-        if (answer is null) return Fail($"'{string.Join(' ', positional)}' is no command; run `help`.");
+    private static Answer? Due(Queries queries, List<string> positional, bool nuget)
+    {
+        var days = FactReview.DefaultDays;
+        if (positional.Count > 2 || positional.Count == 2 && !(int.TryParse(positional[1], NumberStyles.None, CultureInfo.InvariantCulture, out days) && days >= 0)) return null;
 
-        Console.Write(json ? answer.Json() : answer.Text());
-        return answer.ExitCode;
+        return queries.Due(days, DateOnly.FromDateTime(DateTime.UtcNow), nuget ? NuGetFeed.Versions : null);
     }
 
     private static int Fail(string message)
diff --git a/tools/DocsQuery/Queries.cs b/tools/DocsQuery/Queries.cs
index ec174ae0..7d22f716 100644
--- a/tools/DocsQuery/Queries.cs
+++ b/tools/DocsQuery/Queries.cs
@@ -131,6 +131,22 @@ public Answer List(IReadOnlyList<string> filters)
         };
     }
 
+    /// <summary>
+    /// The facts due for a re-read (<see cref="FactReview"/>): an external fact verified more than
+    /// <paramref name="days"/> days before <paramref name="today"/>, and, given a feed, one pinning a package NuGet has
+    /// a later release of. Exit code 0 when one is due, 1 when none is.
+    /// </summary>
+    public Answer Due(int days, DateOnly today, FactReview.Feed? feed)
+    {
+        var due  = FactReview.List(index, today, days, feed, out var facts, out var compared);
+        var rows = due.Select(item => Row.Of(("at", item.At), ("kind", item.Kind), ("id", item.Id), ("target", item.Target), ("detail", item.Detail))).ToList();
+
+        var summary = $"{Count(due.Select(item => item.Id).Distinct().Count(), "fact")} due of {Count(facts, "fact")} pinned external, by a verified: date more than {days.ToString(CultureInfo.InvariantCulture)} days before {today.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture)}"
+                    + (feed is null ? "; --nuget also compares each pin with NuGet's latest release" : $" or a later release on NuGet, against which {Count(compared, "pin")} compared");
+
+        return new Answer(Answer.Exact, "due", feed is null ? days.ToString(CultureInfo.InvariantCulture) : $"{days.ToString(CultureInfo.InvariantCulture)} --nuget", summary, rows, rows.Count == 0 ? 1 : 0);
+    }
+
     /// <summary>
     /// BM25 over the sections of the ranked documents, the heading weighted above the headings over
     /// it, the prose above the code. A section that defines an id the query names (a record's title, a
@@ -206,8 +222,7 @@ public Answer Claims(string? page, string? kind)
     /// <summary>
     /// Links whose file or anchor does not exist, ids that name no record, diagnostic or fact, and the facts'
     /// rules (<see cref="FactRules"/>): a pin behind or ahead of what is installed, or naming nothing installed,
-    /// a fact without its test, a test without its fact, a fixture missing, and a fact the probe corpus cites to prune
-    /// or excuse a row that has no test.
+    /// a fact without its test, a test without its fact, and a fixture missing.
     /// </summary>
     public Answer Check()
     {
@@ -239,12 +254,9 @@ public Answer Check()
             }
         }
 
-        rows.AddRange(FactRules.Check(index, root, out var facts, out var cited).Select(problem => Row.Of(("at", problem.At), ("kind", problem.Kind), ("target", problem.Target), ("detail", problem.Detail))));
-
-        // Each kind of citation counted, so a scan that found none of a kind it should have is seen in the summary.
-        var citations = string.Join(", ", FactCitations.Kinds.Select(kind => $"{cited.Of(kind).ToString(CultureInfo.InvariantCulture)} {kind}"));
+        rows.AddRange(FactRules.Check(index, root, out var facts).Select(problem => Row.Of(("at", problem.At), ("kind", problem.Kind), ("target", problem.Target), ("detail", problem.Detail))));
 
-        return new Answer(Answer.Exact, "check", "", $"{Count(rows.Count, "problem")} in {links} links, {ids} ids, {Count(cited.Citations.Count, "fact citation")} ({citations}) and {Count(facts, "fact")}", rows, rows.Count == 0 ? 0 : 1);
+        return new Answer(Answer.Exact, "check", "", $"{Count(rows.Count, "problem")} in {links} links, {ids} ids and {Count(facts, "fact")}", rows, rows.Count == 0 ? 0 : 1);
 
         Row Problem(Edge edge, string kind, string detail) => Row.Of(("at", At(edge.Doc, edge.Line)), ("kind", kind), ("target", edge.Written), ("detail", detail));
 
diff --git a/tools/DocsQuery/README.md b/tools/DocsQuery/README.md
index 6e8e666e..09f4ec8a 100644
--- a/tools/DocsQuery/README.md
+++ b/tools/DocsQuery/README.md
@@ -16,6 +16,7 @@ dotnet tools/DocsQuery/bin/Release/net10.0/docs-query.dll entry CMTK0010
 | `list [filter...]` | Documents: `kind=adr status=open`, `date>=2026-10-01`, `title~json` | exact |
 | `find <words>` | BM25 over the sections of the ranked documents; `--top N`, `--kind K`. A section that defines an id the query names comes first. A miss proves nothing | ranked |
 | `claims [page]` | Every C# block, every line whose comment states an output, and every other fenced block of the README and the docs pages, with the sample region that compiles it; `--kind csharp\|stated\|block`, `--json` | exact |
+| `due [days]` | The facts to re-read before a release: each fact with an `external` pin verified more than `days` ago (default 183, six months). `--nuget` also lists each pin of a package nuget.org has a later release of. Run by hand, never in CI | exact |
 | `check` | Broken links, missing anchors, ids defined nowhere, and the verified facts' rules (below) | exact |
 
 `--json` prints one object per line, the summary first; a pointer is `path` and `line`. Exit codes: 0
@@ -54,11 +55,21 @@ rules:
 | `fact-orphan-test` | A `KBNNN.cs` in the facts project that no fact names |
 | `fact-fixture-missing`, `fact-fixture` | A `fixture:` whose file does not exist; one that is not `KBNNN.fixture.json` beside the test, or belongs to a fact without a test |
 | `fact-orphan-fixture` | A `KBNNN.fixture.json` in the facts project that no fact names |
-| `fact-not-executable-cited` | The probe corpus cites a fact that has no test: a `refused` entry of `.claude/probe-axes.md` whose reason names `KB-NNN`, a `not-promised` entry of `tools/probe/corpus/claims.json` whose `source` is the fact's file or which says `fact:KB-NNN`, an obligation's `inapplicable` declaration citing `fact:KB-NNN`, or a `Cite.Fact("KB-NNN")` or `Baseline.Fact("KB-NNN")` literal in the harness and probe sources (comments blanked out). No test means `none, …`, no file, a file that does not exist or declares no class of the id; a `Baseline.Fact` takes a fixture as well. Reported at the citing place |
 
-The pins and the corpus's citations are read from the checkout at each `check`, never from the index. The summary
-counts the citations of each kind (`4 fact citations (0 refused, 2 not-promised, 0 obligation, 2 harness)`), and
-`RepositoryTests` holds floors on them, so a scan that finds nothing cannot pass for a clean one.
+The pins are read from the checkout at each `check`, never from the index.
+
+An `external {name} {version}` pin is never compared by `check`: it names what the checkout never installs, a
+competitor's release among them. `due` lists what to re-read (CONTRIBUTING, "Releasing"):
+
+| Problem | When |
+|---|---|
+| `fact-old` | The fact has an `external` pin and its `verified:` date is more than `days` before today |
+| `fact-released` | With `--nuget`: nuget.org lists a later release of a pinned package, a stable one for a stable pin and any for a pre-release (SemVer order, `beta.10` after `beta.2`). Read from `v3-flatcontainer/{id}/index.json`, which lists unlisted versions too |
+
+A pin whose version is no version (`external NuGet registration data, 2026-10-29`) is never looked up, and one whose
+name nuget.org has no package of (`external PostgreSQL 17.11`) finds nothing to compare: both are due by their date alone.
+`--nuget` is the only command that reaches the network. Exit codes: 0 when a fact is due, 1 when none is or nuget.org
+could not be read.
 
 ## Freshness
 
diff --git a/tools/Oracles/Oracles.csproj b/tools/Oracles/Oracles.csproj
new file mode 100644
index 00000000..3ee2c980
--- /dev/null
+++ b/tools/Oracles/Oracles.csproj
@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <!--
+      The oracle kit's local tool (design/adr/0112, test/oracles/README.md): `seeds [filter]` shows each seed caught by
+      the oracles it names, a copy of the working tree, the patch, one project built and one class run per oracle;
+      `status` prints the catalogue's worklist. Never part of CI: CodoMetis.TypeKit.Oracles.Tests holds the catalogue
+      there without building anything. Run as its built dll: `dotnet tools/Oracles/bin/Release/net10.0/oracles.dll`.
+      The seed verdict is test/oracles/SeedVerdict.cs, compiled in here and into the oracle tests, which hold the
+      rule, so the two cannot disagree; it is one of the sources the tool's fingerprint covers.
+    -->
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <AssemblyName>oracles</AssemblyName>
+        <RootNamespace>Oracles</RootNamespace>
+        <ToolSourcePatterns>**/*.cs;../../test/oracles/SeedVerdict.cs</ToolSourcePatterns>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <Compile Include="..\..\test\oracles\SeedVerdict.cs" Link="SeedVerdict.cs" />
+    </ItemGroup>
+
+</Project>
diff --git a/tools/Oracles/Program.cs b/tools/Oracles/Program.cs
new file mode 100644
index 00000000..95ceccf1
--- /dev/null
+++ b/tools/Oracles/Program.cs
@@ -0,0 +1,245 @@
+// The oracle kit's local tool (design/adr/0112, test/oracles/README.md). Never part of CI.
+//
+//   dotnet tools/Oracles/bin/Release/net10.0/oracles.dll seeds [name filter]   show that every seed is caught
+//   dotnet tools/Oracles/bin/Release/net10.0/oracles.dll status                the catalogue's worklist
+//
+// `seeds`: first a baseline, a copy of the working tree with no seed (bin/, obj/, .git/ and the agents' worktrees left
+// out, so uncommitted work is included) under the temp directory, each oracle the selected seeds name built in Release
+// and run alone; then, for each test/oracles/seeds/<defect>.patch whose file name holds the filter, another copy, the
+// patch applied, each oracle project its `Oracles:` line names built once and each named class run alone, with the
+// same filter. An oracle catches a seed when it passes without it and fails with it in a test of its own: a test
+// that fails with a row that is not a known candidate, never one xunit could not set up, a test host that crashed or
+// a run that wrote no results, which are ERROR (SeedVerdict, design/adr/0117). One line per baseline and one per
+// (seed, oracle), CAUGHT, MISSED or ERROR.
+//
+// Exit 0 is a pass, 1 a seed not caught (or a status that could not read the catalogue), 2 a usage error, 3 a tool
+// built from other sources than the checkout holds, which names the command that rebuilds it, 4 an oracle that could
+// not be judged: its baseline does not pass, or a run with the seed did not reach the tests' own code.
+using System.Diagnostics;
+using System.Text.Json;
+using System.Text.RegularExpressions;
+using System.Xml.Linq;
+using CodoMetis.TypeKit.Oracles;
+
+Console.Out.NewLine = "\n";
+
+var root = SourceFingerprint.FindRoot();
+var stale = SourceFingerprint.Difference(root);
+if (stale is not null)
+{
+    Console.WriteLine($"TOOL STALE: {SourceFingerprint.Project} was built from other sources than the checkout holds ({stale})");
+    Console.WriteLine($"      rebuild it: {SourceFingerprint.RebuildCommand}");
+    return SourceFingerprint.StaleExitCode;
+}
+
+var oraclesDirectory = Path.Combine(root!, "test", "oracles");
+var json = new JsonSerializerOptions { PropertyNameCaseInsensitive = true, ReadCommentHandling = JsonCommentHandling.Skip, AllowTrailingCommas = true };
+
+return args switch
+{
+    ["seeds"] => Seeds(""),
+    ["seeds", var filter] => Seeds(filter),
+    ["status"] or [] => Status(),
+    _ => Usage(),
+};
+
+int Usage()
+{
+    Console.Error.WriteLine("usage: dotnet tools/Oracles/bin/Release/net10.0/oracles.dll seeds [filter] | status");
+    return 2;
+}
+
+int Seeds(string filter)
+{
+    var oracles = Read<List<Oracle>>("oracles.json").ToDictionary(oracle => oracle.Class, StringComparer.Ordinal);
+    var seeds = Directory.GetFiles(Path.Combine(oraclesDirectory, "seeds"), "*.patch")
+                         .Where(seed => Path.GetFileName(seed).Contains(filter, StringComparison.OrdinalIgnoreCase))
+                         .Order(StringComparer.Ordinal)
+                         .Select(seed => (Path: seed, Name: Path.GetFileName(seed), Named: Header(File.ReadAllText(seed), "Oracles").Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries)))
+                         .ToList();
+    if (seeds.Count == 0)
+    {
+        Console.WriteLine($"no seed matches '{filter}' in test/oracles/seeds");
+        return 1;
+    }
+
+    // The baseline: every registered oracle a seed names, run once on a copy with no seed, built and filtered as the
+    // seeded runs are. A seed is judged against it (SeedVerdict.Judge), so an oracle that cannot pass here, a dead
+    // fixture or a failing test, makes its pairs ERROR instead of crediting every seed with its failures.
+    var started = Stopwatch.StartNew();
+    var baselines = RunOracles(seed: null, [.. seeds.SelectMany(seed => seed.Named).Distinct(StringComparer.Ordinal).Where(oracles.ContainsKey).Select(oracle => oracles[oracle])]);
+    foreach (var (oracle, run) in baselines.OrderBy(pair => pair.Key, StringComparer.Ordinal))
+    {
+        Console.WriteLine(run.Error is null && run.Caught == 0
+            ? $"BASELINE {oracle}: passes without a seed, {run.Executed} tests ({started.Elapsed.TotalSeconds:F0} s)"
+            : $"BASELINE {oracle}: DOES NOT PASS without a seed, {run.Error ?? $"{run.Caught} of {run.Executed} tests fail, e.g. {run.Example}"}");
+    }
+
+    var notRun = new SeedVerdict.Run(0, 0, 0, "", "not run, since it does not pass without the seed");
+    var missed = false;
+    var errors = false;
+    foreach (var (seed, name, named) in seeds)
+    {
+        started.Restart();
+        try
+        {
+            var registered = named.Select(oracle => oracles.TryGetValue(oracle, out var found) ? found : throw new SeedError($"'{oracle}' is not in oracles.json")).ToList();
+            var seeded = RunOracles(seed, [.. registered.Where(oracle => baselines[oracle.Class] is { Error: null, Caught: 0 })]);
+            foreach (var oracle in registered)
+            {
+                var verdict = SeedVerdict.Judge(baselines[oracle.Class], seeded.GetValueOrDefault(oracle.Class) ?? notRun);
+                missed |= verdict.StartsWith("MISSED", StringComparison.Ordinal);
+                errors |= verdict.StartsWith("ERROR", StringComparison.Ordinal);
+                Console.WriteLine($"{verdict[..8]}{name} -> {oracle.Class}: {verdict[8..]} ({started.Elapsed.TotalSeconds:F0} s)");
+            }
+        }
+        catch (SeedError error)
+        {
+            errors = true;
+            Console.WriteLine($"ERROR   {name}: {error.Message}");
+        }
+    }
+
+    if (missed) Console.WriteLine("A SEED IS NOT CAUGHT: the oracle it names cannot fail for that defect");
+    if (errors) Console.WriteLine("AN ORACLE COULD NOT BE JUDGED: its baseline or its run did not reach the tests' own code; fix that and run again");
+    if (!missed && !errors) Console.WriteLine("every seed is caught");
+    return errors ? 4 : missed ? 1 : 0;
+}
+
+// A copy of the working tree with the seed applied, or none, each oracle's project built once in Release and each
+// class run alone. A project that does not build is an error run for each of its oracles.
+Dictionary<string, SeedVerdict.Run> RunOracles(string? seed, IReadOnlyList<Oracle> selected)
+{
+    var runs = new Dictionary<string, SeedVerdict.Run>(StringComparer.Ordinal);
+    if (selected.Count == 0) return runs;
+
+    var scratch = Path.Combine(Path.GetTempPath(), $"typekit-seed-{Guid.NewGuid():N}");
+    try
+    {
+        CopyTree(root!, scratch);
+        if (seed is not null) Require(RunProcess(scratch, "git", null, ["apply", "--whitespace=nowarn", seed]), "apply the patch");
+
+        foreach (var group in selected.GroupBy(oracle => oracle.Project))
+        {
+            var project = Path.Combine("test", group.Key);
+            if (Failure(RunDotnet(scratch, "build", project, "-c", "Release", "-nologo", "-v", "q"), $"build {group.Key}") is { } failure)
+            {
+                foreach (var oracle in group) runs[oracle.Class] = new SeedVerdict.Run(0, 0, 0, "", failure);
+                continue;
+            }
+
+            foreach (var oracle in group)
+            {
+                var results = Path.Combine(scratch, "SeedResults", oracle.Class);
+                var (exit, _) = RunDotnet(scratch, "test", "--project", project, "-c", "Release", "--no-build",
+                                          "--filter-class", $"*.{oracle.Class}", "--report-xunit-trx", "--report-xunit-trx-filename", $"{oracle.Class}.trx",
+                                          "--results-directory", results);
+                var trx = Path.Combine(results, $"{oracle.Class}.trx");
+                runs[oracle.Class] = SeedVerdict.Read(exit, File.Exists(trx) ? XDocument.Load(trx) : null, oracle.Class);
+            }
+        }
+
+        return runs;
+    }
+    finally
+    {
+        try { Directory.Delete(scratch, recursive: true); } catch (IOException) { } catch (UnauthorizedAccessException) { }
+    }
+}
+
+int Status()
+{
+    var claims = Read<List<Claim>>("claims.json");
+    var oracles = Read<List<Oracle>>("oracles.json");
+    var waivers = Read<Dictionary<string, string>>("surface-waivers.json");
+    var candidates = Read<List<Candidate>>("candidates.json");
+    var seeds = Directory.GetFiles(Path.Combine(oraclesDirectory, "seeds"), "*.patch")
+                         .Select(seed => Header(File.ReadAllText(seed), "Oracles").Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries))
+                         .ToList();
+
+    var unheld = claims.Where(claim => claim.HeldBy is not { Count: > 0 }).ToList();
+    Console.WriteLine($"claims: {claims.Count}, held by a test: {claims.Count - unheld.Count}, unheld (the worklist): {unheld.Count}");
+    foreach (var claim in unheld) Console.WriteLine($"  UNHELD   {claim.Id,-40} {claim.Source}");
+
+    var unread = waivers.Where(waiver => waiver.Value.StartsWith("unread:", StringComparison.Ordinal)).ToList();
+    Console.WriteLine($"surface waivers: {waivers.Count}, unread (members whose document has no claims yet): {unread.Count}");
+    foreach (var waiver in unread) Console.WriteLine($"  UNREAD   {waiver.Key}");
+
+    var seeded = seeds.SelectMany(names => names).ToHashSet(StringComparer.Ordinal);
+    Console.WriteLine($"oracles: {oracles.Count}, seeds: {seeds.Count}, oracles without a seed: {oracles.Count(oracle => !seeded.Contains(oracle.Class))}");
+    foreach (var oracle in oracles.Where(oracle => !seeded.Contains(oracle.Class))) Console.WriteLine($"  UNSEEDED {oracle.Class}");
+
+    Console.WriteLine($"candidates: {candidates.Count} ({candidates.Count(candidate => candidate.Issue.Length == 0)} without an issue)");
+    foreach (var candidate in candidates) Console.WriteLine($"  {candidate.Oracle}: '{candidate.Row}' [{candidate.Family}] {(candidate.Issue.Length == 0 ? "NOT FILED" : candidate.Issue)}");
+
+    return 0;
+}
+
+T Read<T>(string file)
+{
+    using var stream = File.OpenRead(Path.Combine(oraclesDirectory, file));
+    return JsonSerializer.Deserialize<T>(stream, json) ?? throw new InvalidOperationException($"test/oracles/{file} is empty.");
+}
+
+static string Header(string text, string key) =>
+    Regex.Match(text, $@"^{key}:\s*(?<value>.+?)\s*$", RegexOptions.Multiline) is { Success: true } match ? match.Groups["value"].Value : "";
+
+static void CopyTree(string from, string to)
+{
+    string[] skipped = ["bin", "obj", ".git", "SeedResults", "TestResults", "dist", ".codebase-memory"];
+    foreach (var directory in Directory.EnumerateDirectories(from, "*", SearchOption.TopDirectoryOnly))
+    {
+        var name = Path.GetFileName(directory);
+        if (skipped.Contains(name, StringComparer.Ordinal)) continue;
+        if (name == ".claude") { CopyClaude(directory, Path.Combine(to, name)); continue; }
+        CopyTree(directory, Path.Combine(to, name));
+    }
+
+    Directory.CreateDirectory(to);
+    foreach (var file in Directory.EnumerateFiles(from, "*", SearchOption.TopDirectoryOnly))
+        File.Copy(file, Path.Combine(to, Path.GetFileName(file)));
+}
+
+// The agents' worktrees under .claude/worktrees are whole checkouts; nothing a seed builds reads them.
+static void CopyClaude(string from, string to)
+{
+    Directory.CreateDirectory(to);
+    foreach (var file in Directory.EnumerateFiles(from)) File.Copy(file, Path.Combine(to, Path.GetFileName(file)));
+    foreach (var directory in Directory.EnumerateDirectories(from).Where(directory => Path.GetFileName(directory) != "worktrees"))
+        CopyTree(directory, Path.Combine(to, Path.GetFileName(directory)));
+}
+
+static (int Exit, string Output) RunDotnet(string directory, params string[] arguments)
+{
+    var (dotnet, home) = Dotnet.For(directory);
+    return RunProcess(directory, dotnet, home, arguments);
+}
+
+static (int Exit, string Output) RunProcess(string directory, string file, string? dotnetHome, string[] arguments)
+{
+    var start = new ProcessStartInfo(file) { WorkingDirectory = directory, RedirectStandardOutput = true, RedirectStandardError = true, UseShellExecute = false };
+    foreach (var argument in arguments) start.ArgumentList.Add(argument);
+    Dotnet.Apply(dotnetHome, start.Environment);
+
+    using var process = Process.Start(start) ?? throw new SeedError($"{file} could not be started");
+    var error = process.StandardError.ReadToEndAsync();
+    var output = process.StandardOutput.ReadToEnd();
+    process.WaitForExit();
+    return (process.ExitCode, output + error.Result);
+}
+
+static void Require((int Exit, string Output) result, string step)
+{
+    if (Failure(result, step) is { } failure) throw new SeedError(failure);
+}
+
+static string? Failure((int Exit, string Output) result, string step) =>
+    result.Exit == 0 ? null : $"{step} failed (exit {result.Exit}): {string.Join(" | ", result.Output.Split('\n').Where(line => line.Contains("error", StringComparison.OrdinalIgnoreCase)).Take(3).Select(line => line.Trim()))}";
+
+internal sealed record Claim(string Id, string Source, IReadOnlyList<string>? HeldBy);
+
+internal sealed record Oracle(string Class, string Project, string Kind, string Against);
+
+internal sealed record Candidate(string Oracle, string Row, string Family, string Issue);
+
+internal sealed class SeedError(string message) : Exception(message);
diff --git a/tools/PrHygiene/PrHygiene.csproj b/tools/PrHygiene/PrHygiene.csproj
new file mode 100644
index 00000000..bf50b846
--- /dev/null
+++ b/tools/PrHygiene/PrHygiene.csproj
@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <!--
+      Checks a pull request's labels, milestone, branch and closing reference against CONTRIBUTING's
+      "Issues and labels" (Program.cs). Run as its built dll, on the event payload GitHub writes:
+      `dotnet tools/PrHygiene/bin/Release/net10.0/pr-hygiene.dll <event.json>`. .github/workflows/pr-hygiene.yml
+      runs it on every pull request into main or a release branch.
+    -->
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <AssemblyName>pr-hygiene</AssemblyName>
+        <RootNamespace>PrHygiene</RootNamespace>
+    </PropertyGroup>
+
+</Project>
diff --git a/tools/PrHygiene/Program.cs b/tools/PrHygiene/Program.cs
new file mode 100644
index 00000000..fa0f74a3
--- /dev/null
+++ b/tools/PrHygiene/Program.cs
@@ -0,0 +1,157 @@
+// Checks a pull_request event payload against CONTRIBUTING's "Issues and labels"
+// (design/adr/0109-work-is-tracked-as-labelled-issues-and-ci-checks-each-pull-request.md):
+//   - exactly one type label: bug, enhancement, documentation, tests or chore;
+//   - a bug carries exactly one severity/* label, and `silent` is only ever a bug;
+//   - the description closes its issue with one of GitHub's closing keywords ("Closes #12");
+//   - the head branch is named <type>/<slug> (decision 94), and its type agrees with the type label;
+//   - a pull request into release/<version>, or of release/<version> into main, has the milestone <version>;
+//   - a `breaking` pull request goes into a major (x.0.0): ApiCompat holds every other version to the
+//     surface of the one before.
+// It reads the payload alone: no token, no network, nothing of the pull request's code run. Dependabot's
+// pull requests carry their own labels and close no issue, so they are not checked.
+//
+// Usage:
+//   dotnet tools/PrHygiene/bin/Release/net10.0/pr-hygiene.dll <event.json>
+//
+// Each problem is printed as a GitHub annotation (::error::), so the run's page lists them. Exit 0 is a
+// pass, 1 a pull request with a problem, 2 a usage error or a payload without a pull request, 3 a tool built
+// from other sources than the checkout holds, which names the command that rebuilds it.
+using System.Text.Json;
+using System.Text.RegularExpressions;
+
+Console.Out.NewLine = "\n";
+Console.Error.NewLine = "\n";
+
+var stale = SourceFingerprint.Difference(SourceFingerprint.FindRoot());
+if (stale is not null)
+{
+    Console.WriteLine($"TOOL STALE: {SourceFingerprint.Project} was built from other sources than the checkout holds ({stale})");
+    Console.WriteLine($"      rebuild it: {SourceFingerprint.RebuildCommand}");
+    return SourceFingerprint.StaleExitCode;
+}
+
+if (args.Length != 1)
+{
+    Console.Error.WriteLine("Usage: dotnet tools/PrHygiene/bin/Release/net10.0/pr-hygiene.dll <event.json>");
+    return 2;
+}
+
+PullRequest pr;
+try
+{
+    using var document = JsonDocument.Parse(File.ReadAllText(args[0]));
+    if (!document.RootElement.TryGetProperty("pull_request", out var element) || element.ValueKind != JsonValueKind.Object)
+    {
+        Console.Error.WriteLine($"{args[0]} is no pull_request event: it has no pull_request object.");
+        return 2;
+    }
+    pr = PullRequest.Read(element);
+}
+catch (Exception e) when (e is IOException or UnauthorizedAccessException or JsonException)
+{
+    Console.Error.WriteLine($"{args[0]} cannot be read as an event payload: {e.Message}");
+    return 2;
+}
+
+if (pr.Author == "dependabot[bot]")
+{
+    Console.WriteLine("Dependabot pull request, not checked.");
+    return 0;
+}
+
+var problems = Hygiene.Problems(pr);
+if (problems.Count == 0)
+{
+    Console.WriteLine("Labels, milestone, branch and issue link are in order.");
+    return 0;
+}
+foreach (var problem in problems) Console.WriteLine($"::error::{problem}");
+Console.WriteLine("See CONTRIBUTING.md, \"Issues and labels\".");
+return 1;
+
+sealed record PullRequest(string Author, IReadOnlyList<string> Labels, string Body, string Head, string Base, string? Milestone)
+{
+    public static PullRequest Read(JsonElement pr) => new(
+        Author: Text(pr, "user", "login") ?? "",
+        Labels: pr.TryGetProperty("labels", out var labels) && labels.ValueKind == JsonValueKind.Array
+            ? [.. labels.EnumerateArray().Select(label => Text(label, "name")).OfType<string>()]
+            : [],
+        Body: Text(pr, "body") ?? "",
+        Head: Text(pr, "head", "ref") ?? "",
+        Base: Text(pr, "base", "ref") ?? "",
+        Milestone: Text(pr, "milestone", "title"));
+
+    // The string at the path, or null where a step is missing or null (GitHub writes "body": null for an empty description).
+    static string? Text(JsonElement element, params string[] path)
+    {
+        foreach (var name in path)
+        {
+            if (element.ValueKind != JsonValueKind.Object || !element.TryGetProperty(name, out element)) return null;
+        }
+        return element.ValueKind == JsonValueKind.String ? element.GetString() : null;
+    }
+}
+
+static partial class Hygiene
+{
+    static readonly string[] Types = ["bug", "enhancement", "documentation", "tests", "chore"];
+
+    // A branch's <type>, as decision 94 names it after the main commit's conventional type, and the type label that goes with it.
+    static readonly Dictionary<string, string> TypeOfBranch = new(StringComparer.Ordinal)
+    {
+        ["feat"] = "enhancement",
+        ["fix"] = "bug",
+        ["docs"] = "documentation",
+        ["test"] = "tests",
+        ["build"] = "chore",
+        ["refactor"] = "chore",
+        ["spike"] = "chore",
+        ["release"] = "chore",
+    };
+
+    // GitHub's closing keywords, before #n or owner/repo#n. Only these link a pull request to the issue it closes.
+    [GeneratedRegex(@"\b(close[sd]?|fix(e[sd])?|resolve[sd]?):? +([A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+)?#[0-9]+\b", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
+    private static partial Regex Closing();
+
+    [GeneratedRegex(@"^release/(?<version>(?<major>[0-9]+)\.(?<minor>[0-9]+)\.(?<patch>[0-9]+))$", RegexOptions.CultureInvariant)]
+    private static partial Regex ReleaseBranch();
+
+    public static List<string> Problems(PullRequest pr)
+    {
+        var problems = new List<string>();
+        var labels = pr.Labels.ToHashSet(StringComparer.Ordinal);
+
+        var types = Types.Where(labels.Contains).ToList();
+        if (types.Count != 1)
+            problems.Add($"Needs exactly one type label ({string.Join(", ", Types)}); it has {types.Count}{(types.Count > 1 ? $": {string.Join(", ", types)}" : "")}.");
+
+        var severities = pr.Labels.Count(label => label.StartsWith("severity/", StringComparison.Ordinal));
+        if (labels.Contains("bug") && severities != 1)
+            problems.Add($"A bug needs exactly one severity/* label (critical, high, medium, low); it has {severities}.");
+        if (labels.Contains("silent") && !labels.Contains("bug"))
+            problems.Add("Only a bug is silent: label it bug, or take silent off.");
+
+        if (!Closing().IsMatch(pr.Body))
+            problems.Add("The description needs a closing reference to its issue, such as 'Closes #12'.");
+
+        var slash = pr.Head.IndexOf('/', StringComparison.Ordinal);
+        var branchType = slash > 0 ? pr.Head[..slash] : null;
+        if (branchType is null || slash == pr.Head.Length - 1 || !TypeOfBranch.TryGetValue(branchType, out var expected))
+            problems.Add($"The branch '{pr.Head}' is not named <type>/<slug>, where the type is one of {string.Join(", ", TypeOfBranch.Keys)} (decision 94).");
+        else if (types.Count == 1 && types[0] != expected)
+            problems.Add($"The branch '{pr.Head}' is a {branchType} branch, which is labelled {expected}, not {types[0]}.");
+
+        var release = ReleaseBranch().Match(pr.Base);
+        if (!release.Success && pr.Base == "main") release = ReleaseBranch().Match(pr.Head);
+        if (release.Success)
+        {
+            var version = release.Groups["version"].Value;
+            if (pr.Milestone != version)
+                problems.Add($"A pull request into {version} has the milestone {version}; it has {(pr.Milestone is null ? "none" : $"'{pr.Milestone}'")}.");
+            if (labels.Contains("breaking") && (release.Groups["minor"].Value != "0" || release.Groups["patch"].Value != "0"))
+                problems.Add($"A breaking change needs a major, and {version} is not one: it waits for the next x.0.0.");
+        }
+
+        return problems;
+    }
+}
diff --git a/tools/Prober/Axes.cs b/tools/Prober/Axes.cs
deleted file mode 100644
index e37f6a46..00000000
--- a/tools/Prober/Axes.cs
+++ /dev/null
@@ -1,386 +0,0 @@
-using System.Text.Json.Nodes;
-using System.Text.RegularExpressions;
-
-namespace Prober;
-
-/// <summary>Two settings of one row, "axis=value" each, held in ordinal order so a pair has one form.</summary>
-internal readonly record struct Pair
-{
-    public string A { get; }
-    public string B { get; }
-
-    public Pair(string x, string y)
-    {
-        if (string.CompareOrdinal(x, y) <= 0) { A = x; B = y; } else { A = y; B = x; }
-    }
-
-    public override string ToString() => $"{A} {B}";
-}
-
-/// <summary>Pairs a claim excludes, and the one sentence that says why no row can hold them or the documents do not promise them.</summary>
-internal sealed record Exclusion(string Reason, IReadOnlyList<Pair> Pairs);
-
-/// <summary>One thing a claim promises, checkable on its own: a sentence quoted from the claim's source, under an id a seed names (decision 104).</summary>
-internal sealed record Obligation(string Id, string Sentence, IReadOnlyDictionary<string, List<string>> Axes)
-{
-    /// <summary>Where the obligation does not apply, each declaration with its citation; the harness's <c>Row.Check</c> reads the same ones.</summary>
-    public IReadOnlyList<Inapplicability> Inapplicable { get; init; } = [];
-}
-
-/// <summary>
-/// Where an obligation does not apply: every axis of the declaration at one of the values it lists, and the citation
-/// that says why (<c>not-promised:id</c>, <c>docs:file#anchor</c>, <c>fact:KB-NNN</c>, <c>record:NNNN</c>). A row
-/// matches when it holds each axis at a listed value; a pair matches when every row holding it does, so when each
-/// axis of the declaration is one of the pair's two at a listed value.
-/// </summary>
-internal sealed record Inapplicability(IReadOnlyDictionary<string, List<string>> Axes, string Cite)
-{
-    public bool Matches(Pair pair) => Axes.All(axis => Holds(pair.A, axis) || Holds(pair.B, axis));
-
-    private static bool Holds(string setting, KeyValuePair<string, List<string>> axis)
-    {
-        var at = setting.IndexOf('=', StringComparison.Ordinal);
-        return at > 0 && string.Equals(setting[..at], axis.Key, StringComparison.Ordinal) && axis.Value.Contains(setting[(at + 1)..]);
-    }
-
-    public JsonObject ToJson() => new()
-    {
-        ["axes"] = new JsonObject(Axes.Select(kv => KeyValuePair.Create(kv.Key, (JsonNode?)new JsonArray([.. kv.Value.Select(v => (JsonNode)v)])))),
-        ["cite"] = Cite,
-    };
-}
-
-/// <summary>One thing a claim does not promise: the sentence of the document or record that makes the difference intended, and what it concerns.</summary>
-internal sealed record NotPromised(string Id, string Source, string Sentence, IReadOnlyDictionary<string, List<string>> Axes);
-
-/// <summary>One claim of the universe: its axes and values, its watched paths, and the pairs it excludes.</summary>
-internal sealed class Claim
-{
-    public required string Id { get; init; }
-    public required string Source { get; init; }
-    public required IReadOnlyList<string> Surfaces { get; init; }
-    public required IReadOnlyList<string> Watched { get; init; }
-    public required SortedDictionary<string, List<string>> Axes { get; init; }
-    public required HashSet<Pair> Excluded { get; init; }
-
-    /// <summary>The claim's exclusions with their reasons, as claims.json holds them; universe.json keeps only <see cref="Excluded"/>.</summary>
-    public IReadOnlyList<Exclusion> Exclusions { get; init; } = [];
-
-    /// <summary>Each axis the claim drops, with the document sentence that limits it; universe.json does not keep these.</summary>
-    public IReadOnlyDictionary<string, string> Narrowed { get; init; } = new SortedDictionary<string, string>(StringComparer.Ordinal);
-
-    /// <summary>What the claim promises, each checkable on its own, as claims.json lists them (empty: one implicit obligation, the claim); universe.json does not keep these.</summary>
-    public IReadOnlyList<Obligation> Obligations { get; init; } = [];
-
-    /// <summary>What the claim does not promise, each with the sentence that makes it intended; universe.json does not keep these.</summary>
-    public IReadOnlyList<NotPromised> NotPromised { get; init; } = [];
-
-    /// <summary>The id of a claim's one obligation where claims.json lists none: the claim itself.</summary>
-    public const string ImplicitObligation = "claim";
-
-    /// <summary>The obligation ids of a claim as claims.json holds it: the listed ones, or the implicit one.</summary>
-    public static List<string> ObligationIds(JsonObject claim)
-    {
-        var ids = (claim["obligations"] as JsonArray ?? []).OfType<JsonObject>().Select(o => Files.Str(o["id"])).Where(id => id.Length > 0).ToList();
-        return ids.Count > 0 ? ids : [ImplicitObligation];
-    }
-
-    /// <summary>The ids of the claim's obligations as built: the listed ones, or the implicit one.</summary>
-    public IEnumerable<string> ObligationIdsBuilt => Obligations.Count > 0 ? Obligations.Select(o => o.Id) : [ImplicitObligation];
-
-    /// <summary>
-    /// The pairs <paramref name="obligation"/> wants: the claim's pairs less those a declaration of that obligation
-    /// matches on either side. An obligation that declares nothing, the implicit one among them, wants them all.
-    /// </summary>
-    public HashSet<Pair> PairsWantedBy(string obligation)
-    {
-        var declared = Obligations.FirstOrDefault(o => o.Id == obligation)?.Inapplicable ?? [];
-        var result = Pairs();
-        if (declared.Count > 0) result.RemoveWhere(p => declared.Any(d => d.Matches(p)));
-        return result;
-    }
-
-    /// <summary>The pairs at least one obligation wants: the union of <see cref="PairsWantedBy"/>, each pair once.</summary>
-    public HashSet<Pair> PairsWanted()
-    {
-        if (!Obligations.Any(o => o.Inapplicable.Count > 0)) return Pairs();
-        var result = new HashSet<Pair>();
-        foreach (var id in ObligationIdsBuilt) result.UnionWith(PairsWantedBy(id));
-        return result;
-    }
-
-    /// <summary>
-    /// The pairs no obligation wants, each with the citations of the declarations that match it: declared
-    /// inapplicable, so no row is generated for them and the gate leaves them out as it leaves out an exclusion.
-    /// </summary>
-    public Dictionary<Pair, SortedSet<string>> DeclaredInapplicable()
-    {
-        var result = new Dictionary<Pair, SortedSet<string>>();
-        var wanted = PairsWanted();
-        foreach (var pair in Pairs())
-            if (!wanted.Contains(pair))
-                result[pair] = new SortedSet<string>(Obligations.SelectMany(o => o.Inapplicable).Where(d => d.Matches(pair)).Select(d => d.Cite), StringComparer.Ordinal);
-        return result;
-    }
-
-    public HashSet<Pair> Pairs()
-    {
-        var result = new HashSet<Pair>();
-        var names = Axes.Keys.ToList();
-        for (var i = 0; i < names.Count; i++)
-            for (var j = i + 1; j < names.Count; j++)
-                foreach (var va in Axes[names[i]])
-                    foreach (var vb in Axes[names[j]])
-                    {
-                        var pair = new Pair($"{names[i]}={va}", $"{names[j]}={vb}");
-                        if (!Excluded.Contains(pair)) result.Add(pair);
-                    }
-        return result;
-    }
-
-    /// <summary>The pairs one row sets, restricted to the claim's axes and values (an applied value the claim does not list earns nothing).</summary>
-    public HashSet<Pair> PairsOfRow(IReadOnlyDictionary<string, string> row)
-    {
-        var items = row.Where(kv => Axes.TryGetValue(kv.Key, out var values) && values.Contains(kv.Value))
-                       .OrderBy(kv => kv.Key, StringComparer.Ordinal).ToList();
-        var result = new HashSet<Pair>();
-        for (var i = 0; i < items.Count; i++)
-            for (var j = i + 1; j < items.Count; j++)
-                result.Add(new Pair($"{items[i].Key}={items[i].Value}", $"{items[j].Key}={items[j].Value}"));
-        return result;
-    }
-
-    public JsonObject ToJson()
-    {
-        var o = new JsonObject
-        {
-            ["id"] = Id, ["source"] = Source, ["surfaces"] = new JsonArray([.. Surfaces.Select(s => (JsonNode)s)]),
-            ["watched"] = new JsonArray([.. Watched.Select(s => (JsonNode)s)]),
-            ["axes"] = new JsonObject(Axes.Select(kv => KeyValuePair.Create(kv.Key, (JsonNode?)new JsonArray([.. kv.Value.Select(v => (JsonNode)v)])))),
-        };
-        if (Excluded.Count > 0) o["exclude"] = new JsonArray([.. Excluded.Select(p => (JsonNode)new JsonArray(p.A, p.B))]);
-        // Every obligation's id with its declarations, written only where one declares something, so the covering
-        // generator and the gate, which read universe.json, know which pairs each wants.
-        if (Obligations.Any(ob => ob.Inapplicable.Count > 0))
-            o["obligations"] = new JsonArray([.. Obligations.Select(ob =>
-            {
-                var item = new JsonObject { ["id"] = ob.Id };
-                if (ob.Inapplicable.Count > 0) item["inapplicable"] = new JsonArray([.. ob.Inapplicable.Select(d => (JsonNode)d.ToJson())]);
-                return (JsonNode)item;
-            })]);
-        return o;
-    }
-
-    public static Claim FromJson(JsonObject o) => new()
-    {
-        Id = Files.Str(o["id"]), Source = Files.Str(o["source"]), Surfaces = [.. Files.Strings(o["surfaces"])],
-        Watched = [.. Files.Strings(o["watched"])],
-        Axes = new((o["axes"] as JsonObject ?? []).ToDictionary(kv => kv.Key, kv => Files.Strings(kv.Value).ToList(), StringComparer.Ordinal), StringComparer.Ordinal),
-        Excluded = [.. (o["exclude"] as JsonArray ?? []).OfType<JsonArray>().Where(p => p.Count == 2).Select(p => new Pair(Files.Str(p[0]), Files.Str(p[1])))],
-        Obligations = [.. (o["obligations"] as JsonArray ?? []).OfType<JsonObject>().Select(ob => new Obligation(Files.Str(ob["id"]), "", new SortedDictionary<string, List<string>>(StringComparer.Ordinal))
-        {
-            Inapplicable = [.. (ob["inapplicable"] as JsonArray ?? []).OfType<JsonObject>().Select(Prober.Axes.Declaration)],
-        })],
-    };
-}
-
-internal sealed class Universe
-{
-    public required string Base { get; init; }
-    public required string Commit { get; init; }
-    public required JsonObject GeneratedVersions { get; init; }
-    public required List<Claim> Claims { get; init; }
-    public Dictionary<string, Claim> ById => field ??= Claims.ToDictionary(c => c.Id, StringComparer.Ordinal);
-
-    public JsonObject ToJson() => new()
-    {
-        ["schemaVersion"] = Files.SchemaVersion, ["base"] = Base, ["commit"] = Commit,
-        ["generated_versions"] = GeneratedVersions.DeepClone(), ["claims"] = new JsonArray([.. Claims.Select(c => (JsonNode)c.ToJson())]),
-    };
-
-    public static Universe? Load(string path) => Files.ReadJson(path) is JsonObject o ? new Universe
-    {
-        Base = Files.Str(o["base"]), Commit = Files.Str(o["commit"]), GeneratedVersions = o["generated_versions"] as JsonObject is { } g ? (JsonObject)g.DeepClone() : [],
-        Claims = [.. (o["claims"] as JsonArray ?? []).OfType<JsonObject>().Select(Claim.FromJson)],
-    } : null;
-}
-
-internal static class Axes
-{
-    /// <summary>The fenced <c>```json probe-axes</c> block of the axes file: hand, ignored, refused, axes, surfaces, replay.</summary>
-    public static JsonObject Block(string path)
-    {
-        if (!File.Exists(path)) throw new Refusal($"no axes file at {path}");
-        var text = File.ReadAllText(path);
-        const string marker = "```json probe-axes";
-        var at = text.IndexOf(marker, StringComparison.Ordinal);
-        if (at < 0) throw new Refusal($"{path} has no {marker} block");
-        var body = text[(at + marker.Length)..];
-        body = body[..body.IndexOf("```", StringComparison.Ordinal)];
-        return JsonNode.Parse(body) as JsonObject ?? throw new Refusal($"the {marker} block of {path} is not a JSON object");
-    }
-
-    /// <summary>fnmatch's "*" (any run of characters), the only wildcard the axes file uses.</summary>
-    public static bool Matches(string pattern, string name) =>
-        Regex.IsMatch(name, "^" + Regex.Escape(pattern).Replace("\\*", ".*", StringComparison.Ordinal) + "$", RegexOptions.CultureInvariant);
-
-    private static string Collapse(string s) => Regex.Replace(s, @"\s+", " ");
-
-    /// <summary>An axis-to-values object of claims.json (an obligation's or a not-promised entry's `axes`), or none.</summary>
-    private static SortedDictionary<string, List<string>> AxesOf(JsonNode? node)
-    {
-        var result = new SortedDictionary<string, List<string>>(StringComparer.Ordinal);
-        foreach (var (name, values) in node as JsonObject ?? []) result[name] = [.. Files.Strings(values)];
-        return result;
-    }
-
-    /// <summary>A declaration of where an obligation does not apply, as claims.json and universe.json hold it.</summary>
-    internal static Inapplicability Declaration(JsonObject d) => new(AxesOf(d["axes"]), Files.Str(d["cite"]));
-
-    private static readonly Regex CiteId = new("^[a-z0-9][a-z0-9-]*$");
-    private static readonly Regex CiteSource = new(@"^(?!/)(?!.*(^|/)\.\.?(/|#|$))[A-Za-z0-9_./-]+\.[A-Za-z0-9]+(#[A-Za-z0-9][A-Za-z0-9._-]*)?$");
-    private static readonly Regex CiteFact = new(@"^KB-\d{3}$");
-    private static readonly Regex CiteRecord = new(@"^\d{4}$");
-
-    /// <summary>
-    /// What is wrong with a citation's form, or null: the forms the harness's <c>Cite</c> (harness/Row.cs) accepts, so
-    /// every declaration the universe reads, the harness can cite (<c>CiteFormTests</c> holds the two alike).
-    /// </summary>
-    internal static string? CiteProblem(string cite)
-    {
-        var at = cite.IndexOf(':', StringComparison.Ordinal);
-        var (kind, value) = at < 0 ? ("", cite) : (cite[..at], cite[(at + 1)..]);
-        return kind switch
-        {
-            "not-promised" => CiteId.IsMatch(value) ? null : "is not a not-promised id (not-promised:closed-set-has-no-text)",
-            "docs" => CiteSource.IsMatch(value) ? null : "is not a docs source (docs:docs/json.md#decimals-in-one-spelling)",
-            "fact" => CiteFact.IsMatch(value) ? null : "is not a knowledge entry's id (fact:KB-031)",
-            "record" => CiteRecord.IsMatch(value) ? null : "is not a decision record's number (record:0094)",
-            _ => "is not a citation (not-promised:id, docs:file#anchor, fact:KB-NNN or record:NNNN)",
-        };
-    }
-
-    /// <summary>Builds the universe: each claim takes every axis of its surfaces, minus quoted narrowings, plus its own axes.</summary>
-    public static (Universe Universe, List<string> Problems) Build(Ledger ledger, string baseRef, List<JsonObject>? claimsOverride = null, JsonObject? generatedOverride = null)
-    {
-        var block = ledger.AxesBlock();
-        var generated = generatedOverride ?? Files.ReadJson(Path.Combine(ledger.Memory, "axes-generated.json")) as JsonObject
-                        ?? throw new Refusal("no axes-generated.json; run `prober replay --all`, which derives the axes");
-        var claims = claimsOverride ?? ledger.Claims();
-        if (claims.Count == 0) throw new Refusal("no claims (tools/probe/corpus/claims.json, or the branch's staging)");
-
-        var ignored = block["ignored"] as JsonObject ?? [];
-        var hand = block["hand"] as JsonObject ?? [];
-        var axes = new SortedDictionary<string, List<string>>(StringComparer.Ordinal);
-        foreach (var (name, values) in generated["axes"] as JsonObject ?? [])
-            if (!ignored.ContainsKey(name)) axes[name] = [.. Files.Strings(values)];
-        var problems = new List<string>();
-        foreach (var name in Files.Strings(generated["needsValues"]))
-        {
-            if (ignored.ContainsKey(name)) continue;
-            if (hand[name] is JsonArray h) axes[name] = ["default", .. Files.Strings(h)];
-            else problems.Add($"needs values: {name} (no hand values and not ignored)");
-        }
-        foreach (var (name, values) in hand)
-            if (!axes.ContainsKey(name) && !ignored.ContainsKey(name)) axes[name] = ["default", .. Files.Strings(values)];
-        foreach (var (name, values) in block["axes"] as JsonObject ?? []) axes[name] = [.. Files.Strings(values)];
-        foreach (var (name, refused) in block["refused"] as JsonObject ?? [])
-            if (axes.TryGetValue(name, out var list) && refused is JsonObject r) axes[name] = [.. list.Where(v => !r.ContainsKey(v))];
-
-        var surfaces = block["surfaces"] as JsonObject ?? throw new Refusal("the axes block has no surfaces");
-        var reached = new HashSet<string>(StringComparer.Ordinal);
-        foreach (var (_, surface) in surfaces)
-            foreach (var pattern in Files.Strings(surface?["axes"]))
-                reached.UnionWith(axes.Keys.Where(k => Matches(pattern, k)));
-        var allGenerated = (generated["axes"] as JsonObject ?? []).Select(kv => kv.Key).Concat(Files.Strings(generated["needsValues"]));
-        foreach (var name in allGenerated.Distinct(StringComparer.Ordinal).Order(StringComparer.Ordinal))
-            if (!ignored.ContainsKey(name) && axes.ContainsKey(name) && !reached.Contains(name))
-                problems.Add($"unassigned: {name} (no surface reaches it and it is not ignored)");
-
-        var built = new List<Claim>();
-        foreach (var c in claims)
-        {
-            var id = Files.Str(c["id"]); var source = Files.Str(c["source"]); var sourceFile = source.Split('#')[0];
-            var mine = new SortedDictionary<string, List<string>>(StringComparer.Ordinal);
-            var watched = new List<string>();
-            foreach (var surfaceName in Files.Strings(c["surfaces"]))
-            {
-                if (surfaces[surfaceName] is not JsonObject surface) throw new Refusal($"claim {id} names unknown surface {surfaceName}");
-                foreach (var pattern in Files.Strings(surface["axes"]))
-                    foreach (var name in axes.Keys.Where(k => Matches(pattern, k))) mine[name] = axes[name];
-                watched.AddRange(Files.Strings(surface["watched"]));
-            }
-            var sourcePath = Path.Combine(ledger.Top, sourceFile);
-            var sourceText = File.Exists(sourcePath) ? Collapse(File.ReadAllText(sourcePath)) : "";
-            var narrowed = new SortedDictionary<string, string>(StringComparer.Ordinal);
-            foreach (var (name, quote) in c["narrow"] as JsonObject ?? [])
-            {
-                if (!sourceText.Contains(Collapse(Files.Str(quote)), StringComparison.Ordinal))
-                    throw new Refusal($"claim {id} narrows {name} by a quote not found in {sourceFile}");
-                mine.Remove(name);
-                narrowed[name] = Files.Str(quote);
-            }
-            foreach (var (name, values) in c["axes"] as JsonObject ?? []) mine[name] = [.. Files.Strings(values)];
-            // What the claim promises and what it does not, each a sentence quoted from its document, checked as a
-            // narrowing is: a sentence the document no longer holds is a refusal, never a stale promise (decision 104).
-            var obligations = new List<Obligation>();
-            var notPromisedIds = (c["not-promised"] as JsonArray ?? []).OfType<JsonObject>().Select(n => Files.Str(n["id"])).ToHashSet(StringComparer.Ordinal);
-            foreach (var o in (c["obligations"] as JsonArray ?? []).OfType<JsonObject>())
-            {
-                var oid = Files.Str(o["id"]);
-                if (obligations.Any(x => x.Id == oid)) throw new Refusal($"claim {id}: obligation {oid} is listed twice");
-                if (!sourceText.Contains(Collapse(Files.Str(o["sentence"])), StringComparison.Ordinal))
-                    throw new Refusal($"claim {id}: obligation {oid} quotes a sentence not found in {sourceFile}");
-                // Where the obligation does not apply, said by the claim's own axes and values and cited: the covering
-                // generator, the gate and the harness read the same declarations, so they never disagree.
-                var declared = new List<Inapplicability>();
-                foreach (var (d, i) in (o["inapplicable"] as JsonArray ?? []).OfType<JsonObject>().Select((d, i) => (d, i)))
-                {
-                    var at = $"claim {id}: obligation {oid}: inapplicable[{i}]";
-                    var declaration = Declaration(d);
-                    if (declaration.Axes.Count == 0) throw new Refusal($"{at} names no axis");
-                    foreach (var (name, values) in declaration.Axes)
-                    {
-                        if (!mine.TryGetValue(name, out var listed)) throw new Refusal($"{at} names axis {name}, which the claim does not have");
-                        if (values.Count == 0) throw new Refusal($"{at} names no value of {name}");
-                        foreach (var value in values.Where(v => !listed.Contains(v)))
-                            throw new Refusal($"{at} names {name}={value}, a value the claim does not list for {name}");
-                    }
-                    if (CiteProblem(declaration.Cite) is { } problem) throw new Refusal($"{at}: cite {declaration.Cite} {problem}");
-                    if (declaration.Cite.StartsWith("not-promised:", StringComparison.Ordinal) && !notPromisedIds.Contains(declaration.Cite["not-promised:".Length..]))
-                        throw new Refusal($"{at} cites {declaration.Cite}, which the claim's not-promised list does not hold");
-                    declared.Add(declaration);
-                }
-                obligations.Add(new Obligation(oid, Files.Str(o["sentence"]), AxesOf(o["axes"])) { Inapplicable = declared });
-            }
-            var notPromised = new List<NotPromised>();
-            foreach (var n in (c["not-promised"] as JsonArray ?? []).OfType<JsonObject>())
-            {
-                var nid = Files.Str(n["id"]); var nsource = Files.Str(n["source"]); var nfile = nsource.Split('#')[0];
-                if (notPromised.Any(x => x.Id == nid)) throw new Refusal($"claim {id}: not-promised {nid} is listed twice");
-                var npath = Path.Combine(ledger.Top, nfile);
-                var ntext = File.Exists(npath) ? Collapse(File.ReadAllText(npath)) : "";
-                if (!ntext.Contains(Collapse(Files.Str(n["sentence"])), StringComparison.Ordinal))
-                    throw new Refusal($"claim {id}: not-promised {nid} quotes a sentence not found in {nfile}");
-                notPromised.Add(new NotPromised(nid, nsource, Files.Str(n["sentence"]), AxesOf(n["axes"])));
-            }
-            // The claims file's schema holds the form (Ledger.ReadClaims): each entry a reason and its pairs.
-            List<Exclusion> exclusions = [.. (c["exclude"] as JsonArray ?? []).OfType<JsonObject>().Select(e => new Exclusion(Files.Str(e["reason"]),
-                [.. (e["pairs"] as JsonArray ?? []).OfType<JsonArray>().Select(p => new Pair(Files.Str(p[0]), Files.Str(p[1])))]))];
-            built.Add(new Claim
-            {
-                Id = id, Source = source, Surfaces = [.. Files.Strings(c["surfaces"])],
-                Watched = [.. watched.Append(sourceFile).Distinct(StringComparer.Ordinal).Order(StringComparer.Ordinal)], Axes = mine,
-                Excluded = [.. exclusions.SelectMany(e => e.Pairs)], Exclusions = exclusions, Narrowed = narrowed,
-                Obligations = obligations, NotPromised = notPromised,
-            });
-        }
-        var universe = new Universe
-        {
-            Base = Git.Out(ledger.Top, "merge-base", "HEAD", baseRef), Commit = ledger.Head,
-            GeneratedVersions = generated["versions"] as JsonObject is { } v ? (JsonObject)v.DeepClone() : [], Claims = built,
-        };
-        Files.WriteJson(ledger.P("universe.json"), universe.ToJson());
-        return (universe, problems);
-    }
-}
diff --git a/tools/Prober/Commands.cs b/tools/Prober/Commands.cs
deleted file mode 100644
index 91cc7df3..00000000
--- a/tools/Prober/Commands.cs
+++ /dev/null
@@ -1,747 +0,0 @@
-using System.Globalization;
-using System.Text.Json;
-using System.Text.Json.Nodes;
-using System.Xml.Linq;
-
-namespace Prober;
-
-/// <summary>The command line: a command, then <c>--name value</c> options and <c>--flag</c> switches.</summary>
-internal sealed class Args
-{
-    private readonly Dictionary<string, List<string>> options = new(StringComparer.Ordinal);
-    public List<string> Positional { get; } = [];
-
-    public Args(IEnumerable<string> argv, IReadOnlySet<string> flags)
-    {
-        var list = argv.ToList();
-        for (var i = 0; i < list.Count; i++)
-        {
-            var a = list[i];
-            if (!a.StartsWith("--", StringComparison.Ordinal)) { Positional.Add(a); continue; }
-            var name = a[2..];
-            if (flags.Contains(name)) { Add(name, "true"); continue; }
-            // A multi-value option takes values until the next option.
-            var any = false;
-            while (i + 1 < list.Count && !list[i + 1].StartsWith("--", StringComparison.Ordinal)) { Add(name, list[++i]); any = true; if (!Multi.Contains(name)) break; }
-            if (!any) Add(name, "");
-        }
-    }
-
-    private static readonly HashSet<string> Multi = new(StringComparer.Ordinal) { "cobertura", "include", "compile-time", "from", "seed-env" };
-    private void Add(string name, string value) { if (!options.TryGetValue(name, out var l)) options[name] = l = []; l.Add(value); }
-    public string? Get(string name) => options.TryGetValue(name, out var l) ? l[^1] : null;
-    public string Need(string name) => Get(name) is { Length: > 0 } v ? v : throw new Refusal($"--{name} is required", 2);
-    public bool Flag(string name) => options.ContainsKey(name);
-    public List<string> All(string name) => options.TryGetValue(name, out var l) ? l : [];
-}
-
-internal static class Commands
-{
-    private static readonly JsonSerializerOptions Pretty = new() { WriteIndented = true };
-    private static string Today => DateTime.Now.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
-
-    public static int Rows(Ledger l, Args a)
-    {
-        if (a.Get("probe") is not { Length: > 0 } probe)
-        {
-            l.Ctx.Out.WriteLine(CoveringRows(l, a.Need("claim"), a.Flag("full"), a.Get("max"), a.Get("seed")).ToJsonString(Pretty));
-            return 0;
-        }
-        if (!l.Registry().TryGetValue(probe, out var entry)) throw new Refusal($"no probe {probe} in the registry, tracked or staged; `prober new` stages one", 2);
-        var claimId = Files.Str(entry["claim"]);
-        if (a.Get("claim") is { Length: > 0 } named && named != claimId) throw new Refusal($"{probe} is a probe of {claimId}, not of {named}", 2);
-        var (rows, uncovered) = StageRows(l, probe, claimId, a.Flag("full"), a.Get("max"), a.Get("seed"));
-        l.Ctx.Out.WriteLine($"rows/{probe}.json: {rows} rows for claim {claimId} over its pairs{(a.Flag("full") ? "" : " its other probes have not covered")}" +
-                            $"{(uncovered > 0 ? $", {uncovered} left uncovered" : "")}; staged in {l.StagingDir}, the file written whole. " +
-                            "`prober publish` moves it into the corpus");
-        return 0;
-    }
-
-    /// <summary>
-    /// Writes a probe's rows file in the staging, whole, never appended: a covering array over its claim's pairs (all of
-    /// them with <paramref name="full"/>) less those the claim's other probes have credited. The probe's own credit is
-    /// not subtracted, since it came from the rows this file replaces and ends with them. The stored rows are
-    /// definitions; the evidence is in the state.
-    /// </summary>
-    internal static (int Rows, int Uncovered) StageRows(Ledger l, string probe, string claimId, bool full, string? max = null, string? seed = null)
-    {
-        var covering = CoveringRows(l, claimId, full, max, seed, except: probe);
-        var rows = new JsonArray([.. (covering["rows"] as JsonArray ?? []).Select(r => (JsonNode)new JsonObject { ["row"] = r?["row"]?.DeepClone() })]);
-        Files.WriteJson(Path.Combine(l.StagingDir, "rows", probe + ".json"), new JsonObject { ["claim"] = claimId, ["rows"] = rows });
-        return (rows.Count, (int)Files.Num(covering["uncovered_after"]));
-    }
-
-    /// <summary>
-    /// What `rows` prints: a pairwise covering array over the claim's pairs not yet covered (all of them with
-    /// <paramref name="full"/>), each row with the pairs it covers. Inside a capped round the claim counts toward
-    /// the round's cap, and past the deadline or the cap this refuses.
-    /// </summary>
-    public static JsonObject CoveringRows(Ledger l, string claimId, bool full, string? max = null, string? seed = null, string? except = null)
-    {
-        var universe = Universe.Load(l.P("universe.json")) ?? throw new Refusal("no universe.json for this branch yet; run `universe` first");
-        if (!universe.ById.TryGetValue(claimId, out var claim)) throw new Refusal($"no claim {claimId} in the universe");
-        if (!full && ActiveRound(l) is { } round)
-        {
-            if (RoundLock.Now() > Files.Num(round["deadline"]))
-                throw new Refusal("the round's time is spent; start no new work. Record what ran, hand the corpus off, and report.");
-            var started = round["claims"] as JsonArray ?? [];
-            if (!Files.Strings(started).Contains(claimId))
-            {
-                if (round["max_claims"] is JsonValue m && m.TryGetValue<int>(out var cap) && started.Count >= cap)
-                    throw new Refusal($"the round's cap of {cap} claim(s) is reached ({string.Join(", ", Files.Strings(started))}); finish those and report.");
-                started.Add(claimId);
-                round["claims"] = started.DeepClone();
-                Files.WriteJson(l.P("round.json"), round);
-            }
-        }
-        var covered = full ? [] : l.Covered(universe, claimId, except);
-        // The pairs some obligation wants: a pair declared inapplicable for every obligation is asked for by no row.
-        var todo = claim.PairsWanted().Where(p => !covered.Contains((claimId, p))).ToHashSet();
-        var rows = Covering.Rows(claim, todo, int.Parse(max ?? "2000", CultureInfo.InvariantCulture), int.Parse(seed ?? "1", CultureInfo.InvariantCulture));
-        return new JsonObject
-        {
-            ["claim"] = claimId,
-            ["rows"] = new JsonArray([.. rows.Select(r => (JsonNode)new JsonObject
-            {
-                ["row"] = new JsonObject(r.Row.Select(kv => KeyValuePair.Create(kv.Key, (JsonNode?)kv.Value))),
-                ["pairs"] = new JsonArray([.. r.Pairs.Select(p => (JsonNode)new JsonArray(p.A, p.B))]),
-            })]),
-            ["uncovered_after"] = todo.Count - rows.Sum(r => r.Pairs.Count),
-        };
-    }
-
-    public static int UniverseCommand(Ledger l, Args a)
-    {
-        var claims = a.Get("claims") is { } cp ? Ledger.ReadClaims(cp, cp) : null;
-        var generated = a.Get("generated") is { } gp ? Files.ReadJson(gp) as JsonObject : null;
-        var (universe, problems) = Axes.Build(l, a.Get("base") ?? "origin/main", claims, generated);
-        var total = 0;
-        foreach (var c in universe.Claims)
-        {
-            var n = c.Pairs().Count; total += n;
-            l.Ctx.Out.WriteLine($"{c.Id}: {c.Axes.Count} axes, {n} pairs");
-            // What the claim leaves out and why: a narrowing's quote is checked against its document, an exclusion's reason by a reviewer only.
-            foreach (var (axis, quote) in c.Narrowed) l.Ctx.Out.WriteLine($"  narrow {axis}: \"{quote}\"");
-            foreach (var e in c.Exclusions)
-                l.Ctx.Out.WriteLine($"  exclude {e.Pairs.Count} pair(s), first {e.Pairs[0]}: {e.Reason}");
-            if (Inapplicable(c) is { } line) l.Ctx.Out.WriteLine($"  {line}");
-        }
-        l.Ctx.Out.WriteLine($"universe: {universe.Claims.Count} claims, {total} pairs");
-        foreach (var p in problems) l.Ctx.Out.WriteLine($"  {p}");
-        return 0;
-    }
-
-    /// <summary>
-    /// The pairs of a claim no obligation wants, as one line: their count, the first, and the citations of the
-    /// declarations that leave them out; null where there are none.
-    /// </summary>
-    private static string? Inapplicable(Claim c)
-    {
-        var dead = c.DeclaredInapplicable();
-        if (dead.Count == 0) return null;
-        var first = dead.Keys.OrderBy(p => p.A, StringComparer.Ordinal).ThenBy(p => p.B, StringComparer.Ordinal).First();
-        var cites = new SortedSet<string>(dead.Values.SelectMany(x => x), StringComparer.Ordinal);
-        return $"inapplicable {dead.Count} pair(s), wanted by no obligation, first {first}: {string.Join(", ", cites)}";
-    }
-
-    public static JsonObject ComputeStatus(Ledger l)
-    {
-        var universe = Universe.Load(l.P("universe.json"));
-        if (universe is null) return new JsonObject { ["branch"] = l.Branch, ["done"] = false, ["reason"] = "no universe.json: run `universe` (no round has run here)" };
-        var credits = l.Credits(universe);
-        var done = credits.Select(x => (x.Claim, x.Pair)).ToHashSet();
-        // How the rows and the checks of each claim's probes ended at their last replay: only a passing check earns
-        // pairs, so the rest is what the claim's coverage loses, and a skip for a finding is an open finding the corpus
-        // records. A row without checks counts as its one check.
-        var outcomes = new Dictionary<string, SortedDictionary<string, int>>(StringComparer.Ordinal);
-        var checkOutcomes = new Dictionary<string, SortedDictionary<string, int>>(StringComparer.Ordinal);
-        var passed = new Dictionary<string, HashSet<string>>(StringComparer.Ordinal);
-        var skips = new SortedDictionary<string, int>(StringComparer.Ordinal);
-        foreach (var (probe, entry) in l.Registry())
-        {
-            var evidence = Files.ReadJson(l.EvidencePath(probe)) as JsonObject;
-            var claim = Files.Str(entry["claim"]);
-            var sum = outcomes.TryGetValue(claim, out var o) ? o : outcomes[claim] = new(StringComparer.Ordinal);
-            foreach (var (category, n) in Ledger.Outcomes(evidence)) sum[category] = sum.GetValueOrDefault(category) + n;
-            var checkSum = checkOutcomes.TryGetValue(claim, out var co) ? co : checkOutcomes[claim] = new(StringComparer.Ordinal);
-            if (evidence is not null) foreach (var (category, n) in Ledger.CheckOutcomes(evidence)) checkSum[category] = checkSum.GetValueOrDefault(category) + n;
-            (passed.TryGetValue(claim, out var p) ? p : passed[claim] = new(StringComparer.Ordinal)).UnionWith(Ledger.PassedObligations(evidence));
-            foreach (var (finding, n) in Ledger.FindingSkips(evidence)) skips[finding] = skips.GetValueOrDefault(finding) + n;
-        }
-        // Each claim's obligations (decision 104), the probes registered for the claim, and the probes whose seeds
-        // break each obligation: the claim's promise is checked only where a probe can be shown to fail on it.
-        var listed = l.Claims().ToDictionary(c => Files.Str(c["id"]), Claim.ObligationIds, StringComparer.Ordinal);
-        var registry = l.Registry();
-        var claims = new JsonObject(); var total = 0; var current = 0; var inapplicableTotal = 0; var wantedTotal = 0; var wantedCurrent = 0;
-        foreach (var c in universe.Claims)
-        {
-            var pairs = c.Pairs(); var hit = pairs.Count(p => done.Contains((c.Id, p)));
-            // The pairs no obligation wants are declared inapplicable: left out of what is still to cover, as the gate leaves them out.
-            var wanted = c.PairsWanted(); var inapplicable = pairs.Count - wanted.Count;
-            inapplicableTotal += inapplicable; wantedTotal += wanted.Count; wantedCurrent += wanted.Count(p => done.Contains((c.Id, p)));
-            var probes = registry.Where(kv => Files.Str(kv.Value["claim"]) == c.Id).ToList();
-            var ids = listed.GetValueOrDefault(c.Id) ?? [Claim.ImplicitObligation];
-            var obligations = new JsonArray();
-            foreach (var id in ids)
-            {
-                var seededBy = probes.Where(kv => Seeds.SeedsOf(kv.Value).Any(s => (s.Obligation ?? (ids is [Claim.ImplicitObligation] ? Claim.ImplicitObligation : null)) == id))
-                                     .Select(kv => (JsonNode)kv.Key).ToList();
-                // current: the claim's pairs credited by current checks naming this obligation; passed: whether any check
-                // named it and passed at the last replay, current or not (status's "K uncredited" counts those that did not).
-                obligations.Add(new JsonObject
-                {
-                    ["id"] = id, ["seeded_by"] = new JsonArray([.. seededBy]),
-                    ["current"] = pairs.Count(p => credits.Contains((c.Id, id, p))),
-                    ["passed"] = passed.GetValueOrDefault(c.Id)?.Contains(id) ?? false,
-                });
-            }
-            claims[c.Id] = new JsonObject
-            {
-                ["pairs"] = pairs.Count, ["current"] = hit, ["inapplicable_pairs"] = inapplicable,
-                ["outcomes"] = new JsonObject((outcomes.GetValueOrDefault(c.Id) ?? []).Select(kv => KeyValuePair.Create(kv.Key, (JsonNode?)kv.Value))),
-                ["check_outcomes"] = new JsonObject((checkOutcomes.GetValueOrDefault(c.Id) ?? []).Select(kv => KeyValuePair.Create(kv.Key, (JsonNode?)kv.Value))),
-                ["probes"] = new JsonArray([.. probes.Select(kv => (JsonNode)kv.Key)]), ["obligations"] = obligations,
-            };
-            total += pairs.Count; current += hit;
-        }
-        var open = l.OpenFindings();
-        return new JsonObject
-        {
-            ["branch"] = l.Branch, ["head"] = l.Head, ["universe_commit"] = universe.Commit, ["pairs"] = total, ["current"] = current,
-            ["inapplicable_pairs"] = inapplicableTotal,
-            ["share"] = total > 0 ? Math.Round((double)current / total, 4) : 1.0,
-            ["open_findings"] = new JsonArray([.. open.Select(f => (JsonNode)f)]),
-            ["skipped_for_findings"] = new JsonObject(skips.Select(kv => KeyValuePair.Create(kv.Key, (JsonNode?)kv.Value))), ["claims"] = claims,
-            ["done"] = total > 0 && wantedCurrent == wantedTotal && open.Count == 0,
-        };
-    }
-
-    public static int Status(Ledger l, Args a)
-    {
-        var s = ComputeStatus(l);
-        if (a.Flag("json")) { l.Ctx.Out.WriteLine(s.ToJsonString(Pretty)); return 0; }
-        if (s["reason"] is { } reason) { l.Ctx.Out.WriteLine($"{l.Branch}: not done ({Files.Str(reason)})"); return 0; }
-        var open = Files.Strings(s["open_findings"]).ToList();
-        l.Ctx.Out.WriteLine($"{l.Branch} at {Files.Str(s["head"])[..7]}: {Files.Num(s["current"])} of {Files.Num(s["pairs"])} pairs current " +
-                            $"({(Files.Num(s["share"]) * 100).ToString("F1", CultureInfo.InvariantCulture)}%), {open.Count} open finding(s)" +
-                            (open.Count > 0 ? ": " + string.Join(", ", open) : "") + $" -> {(s["done"]!.GetValue<bool>() ? "DONE" : "not done")}");
-        foreach (var (finding, rows) in (s["skipped_for_findings"] as JsonObject)!)
-            l.Ctx.Out.WriteLine($"  {rows} row(s) skip for finding {finding}");
-        foreach (var (id, c) in (s["claims"] as JsonObject)!.OrderBy(kv => kv.Key, StringComparer.Ordinal))
-        {
-            var rows = (c!["outcomes"] as JsonObject)!.Select(kv => $"{kv.Key} {Files.Num(kv.Value)}").ToList();
-            var checks = (c["check_outcomes"] as JsonObject ?? []).Select(kv => $"{kv.Key} {Files.Num(kv.Value)}").ToList();
-            var obligations = (c["obligations"] as JsonArray ?? []).OfType<JsonObject>().ToList();
-            var unseeded = obligations.Where(o => (o["seeded_by"] as JsonArray ?? []).Count == 0).Select(o => Files.Str(o["id"])).ToList();
-            // K uncredited: the obligations no passing check named at the last replay.
-            var uncredited = obligations.Count(o => o["passed"] is not JsonValue v || !v.GetValue<bool>());
-            var promise = obligations.Count == 0 ? "" : $"  obligations {obligations.Count}" + (unseeded.Count > 0 ? $" ({unseeded.Count} without a seed: {string.Join(", ", unseeded)})" : ", each seeded")
-                                                        + $", {uncredited} uncredited";
-            var inapplicable = Files.Num(c["inapplicable_pairs"]) is var n and > 0 ? $", {n} inapplicable" : "";
-            l.Ctx.Out.WriteLine($"  {id}: {Files.Num(c["current"])}/{Files.Num(c["pairs"])}{inapplicable}" + (rows.Count > 0 ? $"  (rows: {string.Join(", ", rows)}; checks: {string.Join(", ", checks)})" : "") + promise);
-        }
-        return 0;
-    }
-
-    /// <summary>
-    /// What the corpus leaves out, each with its recorded reason, from the tracked corpus and the generated axes
-    /// alone: the settings no surface reaches and nothing ignores, the settings without values, the declarations
-    /// the generators refuse, the values the frameworks refuse on their own, what the claims say they do not
-    /// promise (their not-promised entries and narrowings), and the surfaces the axes file declares out of reach.
-    /// A report for the release checklist and a feature-research round; it decides nothing (decision 104).
-    /// </summary>
-    public static int Gaps(Ledger l, Args a)
-    {
-        var (universe, problems) = Axes.Build(l, a.Get("base") ?? "origin/main");
-        var block = l.AxesBlock();
-        var generated = Files.ReadJson(Path.Combine(l.Memory, "axes-generated.json")) as JsonObject ?? [];
-        var versions = string.Join(", ", (generated["versions"] as JsonObject ?? []).Select(kv => $"{kv.Key} {Files.Str(kv.Value)}"));
-        l.Ctx.Out.WriteLine($"prober gaps: {l.Branch} at {l.Head[..7]}: what the corpus leaves out, each with its recorded reason; a report, no decision");
-        Section("settings no surface reaches and nothing ignores" + (versions.Length > 0 ? $" (enumerated at {versions})" : ""),
-                problems.Where(p => p.StartsWith("unassigned: ", StringComparison.Ordinal)).Select(p => p["unassigned: ".Length..]));
-        Section("settings without values", problems.Where(p => p.StartsWith("needs values: ", StringComparison.Ordinal)).Select(p => p["needs values: ".Length..]));
-        Section("declarations the generators refuse (shape.refused-kind)", Files.Strings(block["axes"]?["shape.refused-kind"]));
-        Section("values the frameworks refuse on their own",
-                (block["refused"] as JsonObject ?? []).SelectMany(axis => (axis.Value as JsonObject ?? []).Select(v => $"{axis.Key}={v.Key}: {Files.Str(v.Value)}")));
-        Section("not promised, by what it concerns",
-                universe.Claims.SelectMany(c => c.NotPromised.Select(n => (Key: Concerns(n.Axes), Line: $"{Concerns(n.Axes)}: {c.Id}/{n.Id} \"{n.Sentence}\" ({n.Source})"))
-                                                 .Concat(c.Narrowed.Select(kv => (Key: kv.Key, Line: $"{kv.Key}: {c.Id} narrows it, \"{kv.Value}\" ({c.Source})"))))
-                        .OrderBy(x => x.Key, StringComparer.Ordinal).ThenBy(x => x.Line, StringComparer.Ordinal).Select(x => x.Line));
-        Section("pairs no obligation wants (declared inapplicable)",
-                universe.Claims.Select(c => Inapplicable(c) is { } line ? $"{c.Id}: {line}" : null).OfType<string>());
-        Section("pairs no passing check read both axes of (the last replay's evidence)", Unread(l, universe));
-        Section("out of reach", (block["out-of-reach"] as JsonObject ?? []).Select(kv => $"{kv.Key}: {Files.Str(kv.Value)}"));
-        return 0;
-
-        void Section(string title, IEnumerable<string> items)
-        {
-            var list = items.ToList();
-            l.Ctx.Out.WriteLine($"{title}: {(list.Count == 0 ? "none" : list.Count.ToString(CultureInfo.InvariantCulture))}");
-            foreach (var item in list) l.Ctx.Out.WriteLine($"  {item}");
-        }
-
-        static string Concerns(IReadOnlyDictionary<string, List<string>> axes) =>
-            axes.Count == 0 ? "the whole claim" : string.Join(" ", axes.Select(kv => $"{kv.Key}={string.Join("|", kv.Value)}"));
-    }
-
-    /// <summary>
-    /// The wanted pairs of each claim with evidence that no passing check could earn: no obligation that wants the pair
-    /// has a passing check, in its probes' last replay, that read both of the pair's axes. More rows cannot cover such a
-    /// pair; a check that reads both axes, an exclusion or a declaration can (#54's four C11 pairs, wanted by obligations
-    /// whose checks never read shape.wrapped). A claim whose probes have no evidence is left out.
-    /// </summary>
-    private static IEnumerable<string> Unread(Ledger l, Universe universe)
-    {
-        var registry = l.Registry();
-        foreach (var claim in universe.Claims.OrderBy(c => c.Id, StringComparer.Ordinal))
-        {
-            // The axes each obligation's passing checks read together, as "a\nb" with a before b.
-            var read = new Dictionary<string, HashSet<string>>(StringComparer.Ordinal);
-            var any = false;
-            foreach (var (probe, entry) in registry)
-            {
-                if (Files.Str(entry["claim"]) != claim.Id || Files.ReadJson(l.EvidencePath(probe)) is not JsonObject evidence) continue;
-                any = true;
-                foreach (var (_, row) in evidence["rows"] as JsonObject ?? [])
-                    if (row is JsonObject r)
-                        foreach (var check in Ledger.ChecksOf(r).Where(c => c.Category == "pass"))
-                        {
-                            if (!read.TryGetValue(check.Obligation, out var axes)) read[check.Obligation] = axes = new(StringComparer.Ordinal);
-                            var names = check.Applied.Keys.Order(StringComparer.Ordinal).ToList();
-                            for (var i = 0; i < names.Count; i++)
-                                for (var j = i + 1; j < names.Count; j++) axes.Add(names[i] + "\n" + names[j]);
-                        }
-            }
-            if (!any) continue;
-            var wantedBy = claim.ObligationIdsBuilt.Concat(read.Keys).Distinct(StringComparer.Ordinal).ToDictionary(o => o, claim.PairsWantedBy, StringComparer.Ordinal);
-            foreach (var pair in claim.PairsWanted().OrderBy(p => p.A, StringComparer.Ordinal).ThenBy(p => p.B, StringComparer.Ordinal))
-            {
-                var (a, b) = (Axis(pair.A), Axis(pair.B));
-                var both = string.CompareOrdinal(a, b) <= 0 ? a + "\n" + b : b + "\n" + a;
-                if (!wantedBy.Any(o => o.Value.Contains(pair) && read.TryGetValue(o.Key, out var axes) && axes.Contains(both)))
-                    yield return $"{claim.Id}: {pair.A} {pair.B}";
-            }
-        }
-
-        static string Axis(string setting) => setting[..setting.IndexOf('=', StringComparison.Ordinal)];
-    }
-
-    public static int Gate(Ledger l, Args a) => ReleaseGate.Run(l, a.Get("since"), a.Flag("json"));
-
-    public static int Footprint(Ledger l, Args a)
-    {
-        var worktree = Path.GetFullPath(a.Need("root"));
-        var include = a.All("include") is { Count: > 0 } inc ? inc : ["src"];
-        var hit = new SortedSet<string>(StringComparer.Ordinal);
-        foreach (var report in a.All("cobertura"))
-        {
-            var doc = XDocument.Load(report);
-            var sources = doc.Descendants("source").Select(s => Path.GetFullPath(s.Value)).ToList();
-            foreach (var cls in doc.Descendants("class"))
-            {
-                if (!cls.Descendants("line").Any(line => int.TryParse((string?)line.Attribute("hits"), out var h) && h > 0)) continue;
-                var name = (string?)cls.Attribute("filename") ?? "";
-                var candidates = Path.IsPathRooted(name) ? [name] : sources.Count > 0 ? sources.Select(s => Path.Combine(s, name)).ToList() : [name];
-                foreach (var candidate in candidates)
-                {
-                    var full = Path.GetFullPath(candidate);
-                    if (!full.StartsWith(worktree + Path.DirectorySeparatorChar, StringComparison.Ordinal)) continue;
-                    var rel = Path.GetRelativePath(worktree, full).Replace('\\', '/');
-                    if (include.Any(p => rel == p || rel.StartsWith(p.TrimEnd('/') + "/", StringComparison.Ordinal))) hit.Add(rel);
-                    break;
-                }
-            }
-        }
-        // A probe whose own process runs nothing under the include paths (one that builds a consumer in a child process, as C22
-        // does) is recorded by what its registry entry watches; with nothing watched either, the footprint would never go stale.
-        var watchedPaths = l.Watched(a.Need("probe"));
-        if (hit.Count == 0 && watchedPaths.Count == 0)
-            throw new Refusal("the coverage report shows no executed file under " + string.Join(", ", include) +
-                              " and the registry entry watches nothing; refusing to record an empty footprint (it would never go stale): name what the probe depends on in its entry's watched");
-        var rev = Git.Out(worktree, "rev-parse", "HEAD");
-        var footprint = new JsonObject(hit.Select(p => KeyValuePair.Create(p, (JsonNode?)Git.ObjectId(worktree, p))));
-        var compileTime = new JsonObject(a.All("compile-time").Select(p => KeyValuePair.Create(p, (JsonNode?)Git.ObjectId(worktree, p))));
-        // What the probe's registry entry watches beyond what ran: recorded with the ids it ran at, so a change stales it.
-        var watched = new JsonObject(watchedPaths.Select(p => KeyValuePair.Create(p, (JsonNode?)Git.ObjectId(worktree, p))));
-        Files.AppendLine(l.P("footprints.jsonl"), new JsonObject
-        {
-            ["schemaVersion"] = Files.SchemaVersion, ["probe"] = a.Need("probe"), ["commit"] = rev, ["footprint"] = footprint,
-            ["compileTime"] = compileTime, ["watched"] = watched, ["toolchain"] = l.Toolchain().DeepClone(), ["date"] = a.Get("date") ?? Today,
-        });
-        l.Ctx.Out.WriteLine($"{a.Need("probe")}: {footprint.Count} src files, {compileTime.Count} compile-time paths" +
-                            $"{(watched.Count > 0 ? $", {watched.Count} watched" : "")} at {rev[..Math.Min(7, rev.Length)]}");
-        return 0;
-    }
-
-    public static int Stale(Ledger l, Args a)
-    {
-        var states = l.ProbeStates(a.Flag("include-retired"));
-        if (a.Flag("json"))
-        {
-            l.Ctx.Out.WriteLine(new JsonArray([.. states.Select(s => (JsonNode)new JsonObject
-            {
-                ["probe"] = s.Probe, ["claim"] = s.Claim, ["filter"] = s.Filter, ["variants"] = s.Variants.DeepClone(), ["stale"] = s.Stale,
-                ["retired"] = s.Retired, ["passes"] = s.Passes, ["replay"] = s.Replay,
-            })]).ToJsonString(Pretty));
-            return 0;
-        }
-        var todo = states.Where(s => s.Replay).ToList();
-        l.Ctx.Out.WriteLine($"{todo.Count} of {states.Count} probes to replay{(a.Flag("include-retired") ? " (retired included)" : "")}");
-        foreach (var s in todo) l.Ctx.Out.WriteLine($"  {s.Probe}  {s.Filter}");
-        return 0;
-    }
-
-    public static int RecordRun(Ledger l, Args a)
-    {
-        var probe = a.Need("probe"); var result = a.Need("result");
-        if (result is not ("pass" or "fail")) throw new Refusal("--result is pass or fail", 2);
-        var rev = l.Head; var identity = l.Identity(probe);
-        // A regression is a probe that passed with this very identity and fails now; after any change to its
-        // corpus, axes, environment or this tool, a failure is the probe's to triage, not the product's.
-        var passes = Files.ReadLines(l.P("runs.jsonl")).Where(x => Files.Str(x["probe"]) == probe && Files.Str(x["result"]) == "pass").ToList();
-        var passedBefore = passes.Any(x => Files.Str(x["identity"]) == identity);
-        Files.AppendLine(l.P("runs.jsonl"), new JsonObject
-        {
-            ["schemaVersion"] = Files.SchemaVersion, ["probe"] = probe, ["result"] = result, ["commit"] = rev, ["date"] = a.Get("date") ?? Today,
-            ["seconds"] = a.Get("seconds") is { } s ? double.Parse(s, CultureInfo.InvariantCulture) : null, ["identity"] = identity,
-        });
-        if (a.Get("evidence") is { } evidencePath)
-        {
-            var evidence = Files.ReadJson(evidencePath) as JsonObject ?? [];
-            evidence["schemaVersion"] = Files.EvidenceSchemaVersion; evidence["probe"] = probe; evidence["identity"] = identity;
-            evidence["commit"] = rev; evidence["result"] = result; evidence["date"] = a.Get("date") ?? Today;
-            Files.WriteJson(l.EvidencePath(probe), evidence);
-        }
-        if (result == "fail" && passes.Count > 0 && !passedBefore)
-            l.Ctx.Out.WriteLine($"{probe}: fails after a change to its corpus, axes, environment or this tool; triage the probe, not the product");
-        if (result == "fail" && passedBefore)
-            Files.AppendLine(l.P("findings.jsonl"), new JsonObject
-            {
-                ["schemaVersion"] = Files.SchemaVersion, ["id"] = $"R-{probe}-{rev[..7]}", ["claim"] = Files.Str(l.Registry().GetValueOrDefault(probe)?["claim"]),
-                ["status"] = "open", ["commit"] = rev, ["probe"] = probe, ["reason"] = "replay: a probe that passed with this identity fails at this commit",
-            });
-        return 0;
-    }
-
-    public static int IdentityCommand(Ledger l, Args a) { l.Ctx.Out.WriteLine(l.Identity(a.Need("probe"))); return 0; }
-
-    public static int Register(Ledger l, Args a)
-    {
-        // A note or a skip built from text fails at run time after a build and a replay; the staged sources are read first.
-        SourceLint.Refuse(l, "register");
-        var path = Path.Combine(l.StagingDir, "registry.json");
-        var staged = Files.ReadJson(path) as JsonObject ?? new JsonObject { ["probes"] = new JsonObject() };
-        var probes = staged["probes"] as JsonObject ?? [];
-        var entry = l.Registry().GetValueOrDefault(a.Need("probe")) ?? [];
-        entry["claim"] = a.Need("claim"); entry["filter"] = a.Need("filter");
-        if (a.Get("variants") is { Length: > 0 } v) entry["variants"] = JsonNode.Parse(v);
-        // The defect `seeds` applies to prove the probe can fail (decision 100): a patch under the corpus, an
-        // environment toggle, or both, and what it breaks.
-        var seed = new JsonObject();
-        if (a.Get("seed") is { Length: > 0 } patch) seed["patch"] = patch;
-        if (a.All("seed-env") is { Count: > 0 } toggles) seed["env"] = SeedEnv(toggles);
-        if (a.Get("obligation") is { } obligation)
-        {
-            // A seed per obligation (decision 104): into `seeds`, in place of any seed that names the same obligation.
-            if (obligation.Length == 0) throw new Refusal("--obligation needs the id of one of the claim's obligations", 2);
-            if (seed.Count == 0) throw new Refusal("--obligation names the obligation of a seed: give the seed with --seed PATCH or --seed-env NAME=VALUE", 2);
-            var claim = l.Claims().FirstOrDefault(c => Files.Str(c["id"]) == a.Need("claim"))
-                        ?? throw new Refusal($"no claim {a.Need("claim")} in claims.json (tracked or staged), so obligation {obligation} cannot be checked");
-            var ids = Claim.ObligationIds(claim);
-            if (!ids.Contains(obligation))
-                throw new Refusal($"claim {a.Need("claim")} lists no obligation {obligation} (it lists {string.Join(", ", ids)})", 2);
-            var named = new JsonObject { ["obligation"] = obligation };
-            foreach (var (key, value) in seed) named[key] = value?.DeepClone();
-            named["defect"] = a.Need("defect");
-            var kept = (entry["seeds"] as JsonArray ?? []).Where(s => Files.Str(s?["obligation"]) != obligation).Select(s => s?.DeepClone()).ToList();
-            var replaced = (entry["seeds"] as JsonArray ?? []).Count - kept.Count;
-            entry["seeds"] = new JsonArray([.. kept, named]);
-            if (entry["seed"] is JsonObject one && Files.Str(one["obligation"]) == obligation) { entry.Remove("seed"); replaced++; }
-            l.Ctx.Out.WriteLine($"seed for obligation {obligation} of {a.Need("probe")}" + (replaced > 0 ? $", in place of the {replaced} it had" : ""));
-        }
-        else if (seed.Count > 0) { seed["defect"] = a.Need("defect"); entry["seed"] = seed; }
-        probes[a.Need("probe")] = entry;
-        staged["probes"] = probes.DeepClone();
-        Files.WriteJson(path, staged);
-        l.Ctx.Out.WriteLine($"registered {a.Need("probe")} (staged; `publish` moves it into the corpus)");
-        return 0;
-    }
-
-    /// <summary>A seed's environment toggle from <c>--seed-env NAME=VALUE ...</c>; a toggle without a name or an <c>=</c> is refused.</summary>
-    private static JsonObject SeedEnv(List<string> toggles)
-    {
-        var env = new JsonObject();
-        foreach (var toggle in toggles)
-        {
-            var eq = toggle.IndexOf('=', StringComparison.Ordinal);
-            if (eq <= 0) throw new Refusal($"--seed-env {toggle}: a toggle is NAME=VALUE", 2);
-            env[toggle[..eq]] = toggle[(eq + 1)..];
-        }
-        return env;
-    }
-
-    public static int Publish(Ledger l, Args a)
-    {
-        if (!Directory.Exists(l.StagingDir)) { l.Ctx.Out.WriteLine("nothing staged"); return 0; }
-        SourceLint.Refuse(l, "publish");
-        var moved = new List<string>();
-        foreach (var src in Directory.EnumerateFiles(l.StagingDir, "*", SearchOption.AllDirectories).Order(StringComparer.Ordinal))
-        {
-            var rel = Path.GetRelativePath(l.StagingDir, src).Replace('\\', '/');
-            var dst = Path.Combine(l.CorpusDir, rel);
-            if (rel == "registry.json")
-            {
-                var tracked = Files.ReadJson(dst) as JsonObject ?? new JsonObject { ["probes"] = new JsonObject() };
-                var probes = tracked["probes"] as JsonObject ?? [];
-                foreach (var (name, e) in Files.ReadJson(src)?["probes"] as JsonObject ?? []) probes[name] = e?.DeepClone();
-                tracked["probes"] = new JsonObject(probes.OrderBy(kv => kv.Key, StringComparer.Ordinal).Select(kv => KeyValuePair.Create(kv.Key, kv.Value?.DeepClone())));
-                Files.WriteJson(dst, tracked);
-            }
-            else if (rel == "claims.json")
-            {
-                var merged = new SortedDictionary<string, JsonNode>(StringComparer.Ordinal);
-                foreach (var c in Ledger.ReadClaims(dst, "the corpus's claims.json").Concat(Ledger.ReadClaims(src, "the staged claims.json")))
-                    merged[Files.Str(c["id"])] = c.DeepClone();
-                Files.WriteJson(dst, new JsonArray([.. merged.Values]));
-            }
-            else if (rel.StartsWith("rows/", StringComparison.Ordinal) && rel.EndsWith(".json", StringComparison.Ordinal))
-            {
-                // A probe's rows, by probe: the file keeps the claim it names, else its probe's registry entry's.
-                var probe = Path.GetFileNameWithoutExtension(rel);
-                var claim = Files.Str(Files.ReadJson(src)?["claim"]) is { Length: > 0 } named ? named
-                            : l.Registry().GetValueOrDefault(probe)?["claim"] is { } registered ? Files.Str(registered)
-                            : throw new Refusal($"the staged {rel} names no claim and {probe} is no registered probe; a rows file is a probe's, its claim inside");
-                Files.WriteRowsGzipped(dst + ".gz", claim, Files.ReadRows(src).OfType<JsonObject>().Select(r => r["row"] as JsonObject ?? r));
-                rel += ".gz";
-            }
-            else if (rel.EndsWith(".jsonl", StringComparison.Ordinal))
-            {
-                Directory.CreateDirectory(Path.GetDirectoryName(dst)!);
-                Files.WriteAtomically(dst, (File.Exists(dst) ? SharedFile.ReadAllText(dst) : "") + SharedFile.ReadAllText(src));
-            }
-            else
-            {
-                Directory.CreateDirectory(Path.GetDirectoryName(dst)!);
-                File.Copy(src, dst, overwrite: true);
-            }
-            moved.Add(rel);
-        }
-        Directory.Delete(l.StagingDir, recursive: true);
-        l.Ctx.Out.WriteLine($"published {moved.Count} file(s) into {Path.GetRelativePath(l.Top, l.CorpusDir).Replace('\\', '/')}:");
-        foreach (var rel in moved) l.Ctx.Out.WriteLine($"  {rel}");
-        return 0;
-    }
-
-    public static int Mark(Ledger l, Args a)
-    {
-        if (a.Positional.FirstOrDefault() != "retired") throw new Refusal("mark takes `retired`", 2);
-        var probe = a.Need("probe");
-        if (!l.Registry().TryGetValue(probe, out var entry)) throw new Refusal($"no probe {probe} in the registry");
-        var path = Path.Combine(l.StagingDir, "registry.json");
-        var staged = Files.ReadJson(path) as JsonObject ?? new JsonObject { ["probes"] = new JsonObject() };
-        entry["retired"] = true;
-        (staged["probes"] as JsonObject)![probe] = entry;
-        Files.WriteJson(path, staged);
-        l.Ctx.Out.WriteLine($"{probe} retired (staged)");
-        return 0;
-    }
-
-    public static int Dismiss(Ledger l, Args a)
-    {
-        Files.AppendLine(Path.Combine(l.StagingDir, "dismissed.jsonl"),
-            new JsonObject { ["schemaVersion"] = Files.SchemaVersion, ["id"] = a.Need("id"), ["reason"] = a.Need("reason"), ["date"] = a.Get("date") ?? Today });
-        l.Ctx.Out.WriteLine($"{a.Need("id")} dismissed (staged; `publish` puts it in the corpus)");
-        return 0;
-    }
-
-    /// <summary>
-    /// Records an open finding fixed at a commit: the fixed line of findings.jsonl (finding-line.schema.json), with the
-    /// open line's claim and probe and the commit's full id. It refuses an id this ledger does not hold open and a
-    /// commit the repository does not have; a commit outside HEAD's history is recorded and counts once it is in it.
-    /// </summary>
-    public static int Fix(Ledger l, Args a)
-    {
-        var id = a.Positional is [var only] ? only : throw new Refusal("fix takes one finding id: fix F<n> --commit <sha>", 2);
-        var given = a.Need("commit");
-        var resolved = Git.Run(l.Top, "rev-parse", "-q", "--verify", given + "^{commit}");
-        if (resolved.ExitCode != 0) throw new Refusal($"--commit {given} is no commit of this repository");
-        var commit = resolved.Stdout.Trim();
-        if (!l.Findings().TryGetValue(id, out var open)) throw new Refusal($"{id} is no finding of this ledger");
-        if (Files.Str(open["status"]) is var status and not "open") throw new Refusal($"{id} is {status}, not open");
-        var line = new JsonObject
-        {
-            ["schemaVersion"] = Files.SchemaVersion, ["id"] = id, ["claim"] = open["claim"]?.DeepClone(), ["status"] = "fixed", ["commit"] = commit,
-        };
-        if (Files.Str(open["probe"]) is { Length: > 0 } probe) line["probe"] = probe;
-        if (a.Get("reason") is { Length: > 0 } reason) line["reason"] = reason;
-        Files.AppendLine(l.P("findings.jsonl"), line);
-        var inHistory = Git.Run(l.Top, "merge-base", "--is-ancestor", commit, "HEAD").ExitCode == 0;
-        l.Ctx.Out.WriteLine($"{id} fixed at {commit[..7]}" + (inHistory ? "" : "; it counts once that commit is in HEAD's history"));
-        return 0;
-    }
-
-    public static int Lock(Ledger l, Args a)
-    {
-        var holder = a.Need("holder"); var mode = a.Need("mode");
-        if (mode is not ("replay" or "explore" or "full")) throw new Refusal("--mode is replay, explore or full", 2);
-        var pid = a.Get("pid") is { Length: > 0 } p ? long.Parse(p, CultureInfo.InvariantCulture) : (long?)null;
-        var (taken, previous) = RoundLock.Take(l, holder, mode, pid);
-        if (!taken)
-        {
-            var since = DateTimeOffset.FromUnixTimeMilliseconds((long)(Files.Num(previous!["since"]) * 1000)).ToLocalTime().ToString("HH:mm", CultureInfo.InvariantCulture);
-            l.Ctx.Error.WriteLine($"prober: locked by {Files.Str(previous["holder"])} ({Files.Str(previous["mode"])}) since {since}");
-            return 1;
-        }
-        var over = previous is not null && Files.Str(previous["holder"]) != holder ? $" (took over from {Files.Str(previous["holder"])}, whose heartbeat stopped)" : "";
-        l.Ctx.Out.WriteLine($"locked for {mode} by {holder}{over}");
-        return 0;
-    }
-
-    public static int Unlock(Ledger l, Args a)
-    {
-        var owed = RoundLock.Release(l, a.Need("holder"));
-        l.Ctx.Out.WriteLine(owed ? "unlocked; a replay was skipped while locked: run `prober replay` now" : "unlocked");
-        return 0;
-    }
-
-    public static int HeartbeatCommand(Ledger l, Args a) { RoundLock.Beat(l, a.Need("holder")); return 0; }
-
-    public static int OweReplay(Ledger l, Args a) { RoundLock.OweReplay(l); return 0; }
-
-    public static JsonObject? ActiveRound(Ledger l)
-    {
-        var round = Files.ReadJson(l.P("round.json")) as JsonObject;
-        var held = RoundLock.Holder(l);
-        return round is not null && held is not null && Files.Str(held["holder"]) == Files.Str(round["holder"]) ? round : null;
-    }
-
-    public static int RoundStart(Ledger l, Args a)
-    {
-        var holder = a.Need("holder");
-        if (RoundLock.Holder(l) is not { } held || Files.Str(held["holder"]) != holder)
-            throw new Refusal("take the lock first; round-start records the caps of the lock's holder");
-        var minutes = double.Parse(a.Need("minutes"), CultureInfo.InvariantCulture);
-        var claims = a.Get("claims") is { Length: > 0 } c ? int.Parse(c, CultureInfo.InvariantCulture) : (int?)null;
-        Files.WriteJson(l.P("round.json"), new JsonObject
-        {
-            ["schemaVersion"] = Files.SchemaVersion, ["holder"] = holder, ["started"] = RoundLock.Now(),
-            ["deadline"] = RoundLock.Now() + minutes * 60, ["max_claims"] = claims, ["claims"] = new JsonArray(),
-        });
-        l.Ctx.Out.WriteLine($"round capped at {minutes.ToString(CultureInfo.InvariantCulture)} min" + (claims is { } n ? $" and {n} claim(s)" : ""));
-        return 0;
-    }
-
-    public static int RoundEnd(Ledger l, Args a)
-    {
-        if (Files.ReadJson(l.P("round.json")) is JsonObject round && Files.Str(round["holder"]) == a.Need("holder"))
-        {
-            File.Delete(l.P("round.json"));
-            l.Ctx.Out.WriteLine($"round ended: claims {(Files.Strings(round["claims"]).Any() ? string.Join(", ", Files.Strings(round["claims"])) : "none")}");
-        }
-        return 0;
-    }
-
-    public static int Repair(Ledger l, Args a)
-    {
-        var fixedCount = 0;
-        if (Directory.Exists(l.Dir))
-            foreach (var path in Directory.EnumerateFiles(l.Dir, "*.jsonl", SearchOption.AllDirectories))
-            {
-                var data = File.ReadAllText(path);
-                if (data.Length > 0 && !data.EndsWith('\n'))
-                {
-                    Files.WriteAtomically(path, data[..(data.LastIndexOf('\n') + 1)]);
-                    fixedCount++;
-                    l.Ctx.Out.WriteLine($"  removed a partial last line from {Path.GetRelativePath(l.Dir, path)}");
-                }
-            }
-        l.Ctx.Out.WriteLine($"repair: {fixedCount} file(s) fixed");
-        return 0;
-    }
-
-    public static int Abandon(Ledger l, Args a)
-    {
-        Repair(l, a);
-        if (Files.ReadJson(l.P("round.json")) is JsonObject round)
-        {
-            File.Delete(l.P("round.json"));
-            l.Ctx.Out.WriteLine($"round caps cleared ({Files.Str(round["holder"])})");
-        }
-        var held = RoundLock.Abandon(l);
-        l.Ctx.Out.WriteLine(held is null ? "no lock was held" : $"lock of {Files.Str(held["holder"])} ({Files.Str(held["mode"])}) released");
-        return 0;
-    }
-
-    /// <summary>
-    /// Joins the states of a replay split by family (<c>replay --family F</c>, one state directory per leg) into
-    /// this branch's state: each leg's evidence files are copied in, its run, footprint, finding and ledger lines
-    /// are added where this state lacks them (a line a leg carried over from a restored state is not added
-    /// twice), and one replay-last.json sums the legs. It refuses while a probe the registry lists was neither
-    /// replayed nor skipped by any leg, which is how a matrix that leaves a family out fails instead of passing
-    /// on what it ran, and it fails (exit 1) when any leg failed, so the job that merges fails as the legs did.
-    /// </summary>
-    public static int Merge(Ledger l, Args a)
-    {
-        var sources = a.All("from").Where(x => x.Length > 0).ToList();
-        if (sources.Count == 0) throw new Refusal("--from DIR... is required: the state directories of the legs to join into this one", 2);
-        var branchDir = Path.GetFileName(l.Dir);
-        Directory.CreateDirectory(Path.Combine(l.Dir, "evidence"));
-        var legs = new List<JsonObject>();
-        var seen = new SortedSet<string>(StringComparer.Ordinal);
-        foreach (var from in sources)
-        {
-            var root = Path.GetFullPath(from);
-            var dir = Path.Combine(root, "branches", branchDir);
-            var last = Files.ReadJson(Path.Combine(dir, "replay-last.json")) as JsonObject
-                       ?? throw new Refusal($"{from} holds no replay of {l.Branch}: no branches/{branchDir}/replay-last.json");
-            if (legs.Count > 0 && Files.Str(last["commit"]) != Files.Str(legs[0]["commit"]))
-                throw new Refusal($"{from} replayed {Files.Str(last["commit"])[..7]}, another leg {Files.Str(legs[0]["commit"])[..7]}; the legs of one replay share a commit");
-            legs.Add(last);
-            foreach (var name in new[] { "runs.jsonl", "footprints.jsonl", "findings.jsonl", "ledger.jsonl" }) UnionLines(Path.Combine(dir, name), l.P(name));
-            foreach (var sub in new[] { "evidence", "logs" })
-            {
-                var source = Path.Combine(dir, sub);
-                if (!Directory.Exists(source)) continue;
-                Directory.CreateDirectory(l.P(sub));
-                foreach (var file in Directory.EnumerateFiles(source)) File.Copy(file, l.P(Path.Combine(sub, Path.GetFileName(file))), overwrite: true);
-            }
-            foreach (var name in new[] { "universe.json" })
-                if (File.Exists(Path.Combine(dir, name)) && !File.Exists(l.P(name))) File.Copy(Path.Combine(dir, name), l.P(name));
-            var axes = Path.Combine(root, "axes-generated.json");
-            if (File.Exists(axes) && !File.Exists(Path.Combine(l.Memory, "axes-generated.json"))) File.Copy(axes, Path.Combine(l.Memory, "axes-generated.json"));
-            foreach (var probe in Files.Strings(last["selected"]).Concat(Files.Strings(last["skipped"]))) seen.Add(probe);
-        }
-
-        var all = legs.Any(x => x["all"] is JsonValue v && v.TryGetValue<bool>(out var b) && b);
-        var selected = new SortedSet<string>(legs.SelectMany(x => Files.Strings(x["selected"])), StringComparer.Ordinal);
-        var skipped = new SortedSet<string>(legs.SelectMany(x => Files.Strings(x["skipped"])).Where(p => !selected.Contains(p)), StringComparer.Ordinal);
-        var failed = new SortedSet<string>(legs.SelectMany(x => Files.Strings(x["failed"])), StringComparer.Ordinal);
-        static JsonArray Names(IEnumerable<string> names) => new([.. names.Select(x => (JsonNode)x)]);
-        Files.WriteJson(l.P("replay-last.json"), new JsonObject
-        {
-            ["branch"] = l.Branch, ["commit"] = Files.Str(legs[0]["commit"]), ["replayed"] = selected.Count, ["failed"] = Names(failed),
-            ["seconds"] = Math.Round(legs.Max(x => Files.Num(x["seconds"])), 1), ["build_seconds"] = Math.Round(legs.Max(x => Files.Num(x["build_seconds"])), 1),
-            ["all"] = all, ["legs"] = Names(legs.Select(x => Files.Str(x["family"], "all"))), ["footprint"] = legs.All(x => x["footprint"] is not JsonValue f || !f.TryGetValue<bool>(out var ft) || ft),
-            ["selected"] = Names(selected), ["skipped"] = Names(skipped),
-        });
-        l.Ctx.Out.WriteLine($"prober merge: {legs.Count} leg(s) into {l.Dir}: {selected.Count} replayed, {failed.Count} failed, {skipped.Count} current");
-
-        var missing = l.Registry().Where(kv => all || kv.Value["retired"] is not JsonValue r || !r.TryGetValue<bool>(out var retired) || !retired)
-                                  .Select(kv => kv.Key).Where(p => !seen.Contains(p)).ToList();
-        if (missing.Count > 0)
-            throw new Refusal($"no leg replayed or skipped {string.Join(", ", missing)}: every probe's family is a leg of the matrix, or the merged state is short");
-        if (failed.Count > 0) { l.Ctx.Out.WriteLine($"  failed: {string.Join(", ", failed)}"); return 1; }
-        return 0;
-    }
-
-    /// <summary>Adds to <paramref name="target"/> every line of <paramref name="source"/> it does not already hold, in order.</summary>
-    private static void UnionLines(string source, string target)
-    {
-        if (!File.Exists(source)) return;
-        var have = File.Exists(target) ? SharedFile.ReadAllLines(target).Where(x => x.Trim().Length > 0).ToList() : [];
-        var known = new HashSet<string>(have, StringComparer.Ordinal);
-        var added = SharedFile.ReadAllLines(source).Where(x => x.Trim().Length > 0 && known.Add(x)).ToList();
-        if (added.Count == 0 && File.Exists(target)) return;
-        Files.WriteAtomically(target, string.Join('\n', have.Concat(added)) + (have.Count + added.Count > 0 ? "\n" : ""));
-    }
-}
diff --git a/tools/Prober/Context.cs b/tools/Prober/Context.cs
deleted file mode 100644
index 605654a5..00000000
--- a/tools/Prober/Context.cs
+++ /dev/null
@@ -1,80 +0,0 @@
-using System.Diagnostics;
-using System.Text;
-
-namespace Prober;
-
-/// <summary>
-/// Everything a command reads from its surroundings: the directory it runs in, the environment and where
-/// it writes. Commands never touch the process's own current directory or environment, so tests run
-/// them in-process, side by side, each in a checkout of its own.
-/// </summary>
-internal sealed class Context(string workingDirectory, IReadOnlyDictionary<string, string?> environment, TextWriter output, TextWriter error)
-{
-    public string WorkingDirectory { get; } = workingDirectory;
-    public TextWriter Out { get; } = output;
-    public TextWriter Error { get; } = error;
-
-    public string? Env(string name) => environment.TryGetValue(name, out var value) && !string.IsNullOrEmpty(value) ? value : null;
-
-    public static Context FromProcess() =>
-        new(Directory.GetCurrentDirectory(),
-            System.Environment.GetEnvironmentVariables().Cast<System.Collections.DictionaryEntry>()
-                       .ToDictionary(e => (string)e.Key, e => (string?)e.Value, StringComparer.Ordinal),
-            Console.Out, Console.Error);
-
-    public IReadOnlyDictionary<string, string?> Environment => environment;
-}
-
-/// <summary>A child process's result.</summary>
-internal sealed record Ran(int ExitCode, string Stdout, string Stderr);
-
-internal static class Proc
-{
-    /// <summary>
-    /// Runs a program to completion, capturing its output. Never through a shell. `dotnet` is the one that
-    /// satisfies the directory's global.json, the installer's when the one on PATH cannot (Dotnet).
-    /// </summary>
-    public static Ran Run(string fileName, IEnumerable<string> arguments, string workingDirectory,
-                          IReadOnlyDictionary<string, string?>? environment = null, TimeSpan? timeout = null)
-    {
-        string? dotnetDirectory = null;
-        if (fileName == "dotnet") (fileName, dotnetDirectory) = Dotnet.For(workingDirectory);
-        var start = new ProcessStartInfo(fileName)
-        {
-            WorkingDirectory = workingDirectory, RedirectStandardOutput = true, RedirectStandardError = true, UseShellExecute = false,
-            StandardOutputEncoding = Encoding.UTF8, StandardErrorEncoding = Encoding.UTF8,
-        };
-        foreach (var argument in arguments) start.ArgumentList.Add(argument);
-        if (environment is not null)
-            foreach (var (name, value) in environment)
-                if (value is null) start.Environment.Remove(name); else start.Environment[name] = value;
-        Dotnet.Apply(dotnetDirectory, start.Environment);
-
-        using var process = Process.Start(start) ?? throw new InvalidOperationException($"could not start {fileName}");
-        var stdout = process.StandardOutput.ReadToEndAsync();
-        var stderr = process.StandardError.ReadToEndAsync();
-        if (timeout is { } limit && !process.WaitForExit(limit))
-        {
-            // The whole tree: a test host or a headless agent starts children of its own. Portable, no signals.
-            try { process.Kill(entireProcessTree: true); } catch (InvalidOperationException) { }
-            process.WaitForExit();
-            return new Ran(-1, stdout.Result, stderr.Result + "\n(stopped at the time limit)");
-        }
-        process.WaitForExit();
-        return new Ran(process.ExitCode, stdout.Result, stderr.Result);
-    }
-}
-
-internal static class Git
-{
-    public static Ran Run(string workingDirectory, params string[] arguments) => Proc.Run("git", arguments, workingDirectory);
-
-    public static string Out(string workingDirectory, params string[] arguments) => Run(workingDirectory, arguments).Stdout.Trim();
-
-    /// <summary>The object id of a file (blob) or a directory (tree) at a revision, or null when it does not exist there.</summary>
-    public static string? ObjectId(string workingDirectory, string path, string revision = "HEAD")
-    {
-        var ran = Run(workingDirectory, "rev-parse", "-q", "--verify", $"{revision}:{path}");
-        return ran.ExitCode == 0 ? ran.Stdout.Trim() : null;
-    }
-}
diff --git a/tools/Prober/Covering.cs b/tools/Prober/Covering.cs
deleted file mode 100644
index d4cfd13c..00000000
--- a/tools/Prober/Covering.cs
+++ /dev/null
@@ -1,93 +0,0 @@
-namespace Prober;
-
-/// <summary>
-/// A greedy pairwise covering array: each row is the best of a few randomized greedy candidates, and the
-/// rows together cover every pair asked for that at least one of the claim's obligations wants. A pair no
-/// obligation wants (declared inapplicable) is never asked for, and neither it nor an excluded pair is ever put
-/// in a row, not even to fill an axis: every check of such a row would be inapplicable, and an excluded pair is
-/// one the claim says no row can run. An axis none of whose values can join a row without one is left out of
-/// that row: shape.containing beside shape.position=root, and shape.refused-kind wherever the claim excludes each of
-/// its pairs. Deterministic for a seed.
-/// </summary>
-internal static class Covering
-{
-    public static List<(SortedDictionary<string, string> Row, List<Pair> Pairs)> Rows(Claim claim, IReadOnlySet<Pair> wanted, int max, int seed)
-    {
-        var dead = claim.DeclaredInapplicable();
-        bool Blocked(Pair pair) => claim.Excluded.Contains(pair) || dead.ContainsKey(pair);
-        // The pairs asked for, each once however many obligations want it, so a row's gain counts it once.
-        var todo = new HashSet<Pair>(wanted);
-        todo.RemoveWhere(Blocked);
-        var names = claim.Axes.Keys.ToList();
-        var random = new Random(seed);
-        var rows = new List<(SortedDictionary<string, string>, List<Pair>)>();
-        while (todo.Count > 0 && rows.Count < max)
-        {
-            SortedDictionary<string, string>? best = null; var bestGain = -1;
-            for (var attempt = 0; attempt < 30; attempt++)
-            {
-                var order = names.OrderBy(_ => random.Next()).ToList();
-                var row = new SortedDictionary<string, string>(StringComparer.Ordinal);
-                foreach (var name in order)
-                {
-                    var options = claim.Axes[name].OrderBy(_ => random.Next()).ToList();
-                    string? pick = null; var pickGain = -1;
-                    foreach (var v in options)
-                    {
-                        var gain = 0;
-                        foreach (var (n, w) in row)
-                        {
-                            var pair = new Pair($"{name}={v}", $"{n}={w}");
-                            if (Blocked(pair)) { gain = -1; break; }
-                            if (todo.Contains(pair)) gain++;
-                        }
-                        if (gain > pickGain) { pick = v; pickGain = gain; }
-                    }
-                    // Every value of this axis puts a blocked pair in the row: the axis is left out of it.
-                    if (pick is not null) row[name] = pick;
-                }
-                var g = Gained(row, todo).Count;
-                if (g > bestGain) { best = row; bestGain = g; }
-            }
-            if (bestGain <= 0)
-            {
-                // Seed a row from one uncovered pair so progress never stalls.
-                best = Seeded(claim, todo.OrderBy(p => p.A, StringComparer.Ordinal).ThenBy(p => p.B, StringComparer.Ordinal).First(), dead);
-            }
-            var newly = Gained(best!, todo);
-            todo.ExceptWith(newly);
-            rows.Add((best!, newly));
-        }
-        return rows;
-    }
-
-    static string Axis(string setting) => setting[..setting.IndexOf('=', StringComparison.Ordinal)];
-
-    /// <summary>
-    /// A row seeded from one pair: the pair's two settings, and each other axis at its first value that puts neither an excluded pair
-    /// nor a pair no obligation wants (<paramref name="dead"/>) in the row, or left out where none does.
-    /// </summary>
-    internal static SortedDictionary<string, string> Seeded(Claim claim, Pair pair, IReadOnlyDictionary<Pair, SortedSet<string>> dead)
-    {
-        bool Blocked(Pair p) => claim.Excluded.Contains(p) || dead.ContainsKey(p);
-        var row = new SortedDictionary<string, string>(StringComparer.Ordinal);
-        foreach (var item in new[] { pair.A, pair.B }) row[Axis(item)] = item[(item.IndexOf('=', StringComparison.Ordinal) + 1)..];
-        foreach (var name in claim.Axes.Keys.Where(n => !row.ContainsKey(n)).ToList())
-            if (claim.Axes[name].FirstOrDefault(v => !row.Any(kv => Blocked(new Pair($"{name}={v}", $"{kv.Key}={kv.Value}")))) is { } value)
-                row[name] = value;
-        return row;
-    }
-
-    private static List<Pair> Gained(SortedDictionary<string, string> row, HashSet<Pair> todo)
-    {
-        var result = new List<Pair>();
-        var items = row.ToList();
-        for (var i = 0; i < items.Count; i++)
-            for (var j = i + 1; j < items.Count; j++)
-            {
-                var pair = new Pair($"{items[i].Key}={items[i].Value}", $"{items[j].Key}={items[j].Value}");
-                if (todo.Contains(pair)) result.Add(pair);
-            }
-        return result;
-    }
-}
diff --git a/tools/Prober/Files.cs b/tools/Prober/Files.cs
deleted file mode 100644
index 51f83769..00000000
--- a/tools/Prober/Files.cs
+++ /dev/null
@@ -1,142 +0,0 @@
-using System.IO.Compression;
-using System.Text;
-using System.Text.Encodings.Web;
-using System.Text.Json;
-using System.Text.Json.Nodes;
-
-namespace Prober;
-
-/// <summary>
-/// Reading and writing the ledger's files. Every write goes to a temp file renamed over the target, so a
-/// reader sees the file before or after a change, never half of it, on every OS; reads and the rename go
-/// through SharedFile, which Windows needs while another process reads the target. A partial or unreadable
-/// line in a JSON-lines file is skipped, never fatal (a writer killed mid-write in an older version).
-/// </summary>
-internal static class Files
-{
-    /// <summary>The schema version this tool writes. A file or line without one is version 1.</summary>
-    public const int SchemaVersion = 1;
-
-    /// <summary>
-    /// The version of evidence/&lt;probe&gt;.json this tool writes: 2 records each row's checks, one entry per check
-    /// with its own obligation, baseline, outcome and settings. A version-1 file reads as rows without checks, each one
-    /// check of the obligation <c>claim</c>.
-    /// </summary>
-    public const int EvidenceSchemaVersion = 2;
-
-    /// <summary>
-    /// Indented, and with only what JSON itself requires escaped: the tracked corpus is read in a diff, where
-    /// the default encoder's six-character escapes for <c>+</c>, a backtick and <c>&lt;</c> made every publish a
-    /// rewrite (decision 102). No reader here or in the harness parses these files as
-    /// anything but JSON, and an identity hashes <see cref="Canonical"/>, not the file's text.
-    /// </summary>
-    private static readonly JsonSerializerOptions Indented = new() { WriteIndented = true, NewLine = "\n", Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping };
-
-    public static JsonNode? ReadJson(string path)
-    {
-        if (!File.Exists(path)) return null;
-        try { return JsonNode.Parse(SharedFile.ReadAllText(path)); }
-        catch (JsonException) { return null; }   // a file another process is creating this instant: not there yet
-        catch (IOException) { return null; }
-        catch (UnauthorizedAccessException) { return null; }   // Windows: a file being replaced this instant
-    }
-
-    public static void WriteJson(string path, JsonNode value) => WriteAtomically(path, Format(value));
-
-    /// <summary>The text <see cref="WriteJson"/> writes: a tracked file in this form is unchanged by a publish that changes nothing in it.</summary>
-    public static string Format(JsonNode value) => value.ToJsonString(Indented) + "\n";
-
-    public static List<JsonObject> ReadLines(string path)
-    {
-        var result = new List<JsonObject>();
-        if (!File.Exists(path)) return result;
-        foreach (var line in SharedFile.ReadAllLines(path))
-        {
-            if (line.Trim().Length == 0) continue;
-            try { if (JsonNode.Parse(line) is JsonObject o) result.Add(o); }
-            catch (JsonException) { }
-        }
-        return result;
-    }
-
-    /// <summary>Appends one line by writing the whole file anew and renaming it over the old one.</summary>
-    public static void AppendLine(string path, JsonObject value)
-    {
-        var old = File.Exists(path) ? SharedFile.ReadAllText(path) : "";
-        if (old.Length > 0 && !old.EndsWith('\n')) old = old[..(old.LastIndexOf('\n') + 1)];
-        WriteAtomically(path, old + value.ToJsonString() + "\n");
-    }
-
-    public static void WriteAtomically(string path, string text)
-    {
-        Directory.CreateDirectory(Path.GetDirectoryName(path)!);
-        var tmp = $"{path}.{Environment.ProcessId}.{Guid.NewGuid():N}.tmp";
-        File.WriteAllText(tmp, text, new UTF8Encoding(false));
-        SharedFile.Replace(tmp, path);
-    }
-
-    /// <summary>A rows file, plain (staging) or gzipped (the corpus).</summary>
-    public static JsonArray ReadRows(string path)
-    {
-        if (File.Exists(path)) return ReadJson(path)?["rows"] as JsonArray ?? [];
-        if (File.Exists(path + ".gz"))
-        {
-            using var gz = new GZipStream(SharedFile.OpenRead(path + ".gz"), CompressionMode.Decompress);
-            using var reader = new StreamReader(gz, Encoding.UTF8);
-            return JsonNode.Parse(reader.ReadToEnd())?["rows"] as JsonArray ?? [];
-        }
-        return [];
-    }
-
-    public static byte[] Gunzip(string path)
-    {
-        using var gz = new GZipStream(SharedFile.OpenRead(path), CompressionMode.Decompress);
-        using var memory = new MemoryStream();
-        gz.CopyTo(memory);
-        return memory.ToArray();
-    }
-
-    /// <summary>Writes rows gzipped and reproducibly: one row per line, keys sorted, no timestamp in the header.</summary>
-    public static void WriteRowsGzipped(string path, string claim, IEnumerable<JsonObject> rows)
-    {
-        var body = new StringBuilder();
-        body.Append("{\"claim\": ").Append(JsonSerializer.Serialize(claim)).Append(", \"rows\": [\n");
-        body.Append(string.Join(",\n", rows.Select(r => "{\"row\":" + Canonical(r) + "}")));
-        body.Append("\n]}\n");
-        var tmp = $"{path}.{Environment.ProcessId}.tmp";
-        Directory.CreateDirectory(Path.GetDirectoryName(path)!);
-        using (var file = File.Create(tmp))
-        using (var gz = new GZipStream(file, CompressionLevel.SmallestSize))
-            gz.Write(Encoding.UTF8.GetBytes(body.ToString()));
-        SharedFile.Replace(tmp, path);
-    }
-
-    /// <summary>A JSON object with its keys in ordinal order, recursively: the form hashed for an identity.</summary>
-    public static string Canonical(JsonNode? node) => node switch
-    {
-        JsonObject o => "{" + string.Join(",", o.OrderBy(kv => kv.Key, StringComparer.Ordinal)
-                                               .Select(kv => JsonSerializer.Serialize(kv.Key) + ":" + Canonical(kv.Value))) + "}",
-        JsonArray a => "[" + string.Join(",", a.Select(Canonical)) + "]",
-        null => "null",
-        _ => node.ToJsonString(),
-    };
-
-    public static string Str(JsonNode? node, string fallback = "") => node is JsonValue v && v.TryGetValue<string>(out var s) ? s : fallback;
-
-    /// <summary>A number, whether parsed from text or built in memory from any numeric type.</summary>
-    public static double Num(JsonNode? node, double fallback = 0)
-    {
-        if (node is not JsonValue v) return fallback;
-        if (v.TryGetValue<double>(out var d)) return d;
-        if (v.TryGetValue<long>(out var l)) return l;
-        if (v.TryGetValue<int>(out var i)) return i;
-        if (v.TryGetValue<decimal>(out var m)) return (double)m;
-        return double.TryParse(v.ToJsonString(), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var p) ? p : fallback;
-    }
-
-    public static IEnumerable<string> Strings(JsonNode? node) => node is JsonArray a ? a.Select(x => Str(x)) : [];
-
-    public static Dictionary<string, string> StringMap(JsonNode? node) =>
-        node is JsonObject o ? o.Where(kv => kv.Value is JsonValue).ToDictionary(kv => kv.Key, kv => Str(kv.Value, kv.Value!.ToJsonString()), StringComparer.Ordinal)
-                             : new(StringComparer.Ordinal);
-}
diff --git a/tools/Prober/Ledger.cs b/tools/Prober/Ledger.cs
deleted file mode 100644
index 50673244..00000000
--- a/tools/Prober/Ledger.cs
+++ /dev/null
@@ -1,431 +0,0 @@
-using System.Security.Cryptography;
-using System.Text;
-using System.Text.Json.Nodes;
-
-namespace Prober;
-
-/// <summary>
-/// One branch's ledger. Tracked, in the repository: the corpus under tools/probe/corpus (claims, registry,
-/// harness and probe sources, rows, waivers, dismissed findings) and the axes file. Local, under the state
-/// directory: the universe, evidence, footprints, runs, findings, the round's caps and the lock. A pair is
-/// covered only by evidence a replay recorded under an identity that still holds.
-/// </summary>
-internal sealed class Ledger
-{
-    public Context Ctx { get; }
-    public string Root { get; }          // the main checkout, also from a linked worktree
-    public string Top { get; }           // this checkout
-    public bool Linked { get; }          // a linked worktree (git worktree add), not the main checkout
-    public string Branch { get; }
-    public string Memory { get; }        // PROBE_STATE_DIR, else the main checkout's prober memory
-    public string Dir { get; }           // the branch's directory under Memory
-    public string CorpusDir => Path.Combine(Top, "tools", "probe", "corpus");
-    public string AxesFile => Path.Combine(Top, ".claude", "probe-axes.md");
-    public string StagingDir => Path.Combine(Dir, "staging");
-
-    public Ledger(Context ctx, string? branch)
-    {
-        Ctx = ctx;
-        var dirs = Git.Run(ctx.WorkingDirectory, "rev-parse", "--path-format=absolute", "--git-common-dir", "--git-dir");
-        if (dirs.ExitCode != 0) throw new Refusal("not inside a git repository");
-        var lines = dirs.Stdout.Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries).Select(d => d.TrimEnd('/', '\\')).ToArray();
-        if (lines is not [var common, var own]) throw new Refusal("git rev-parse named no git directory");
-        Root = Path.GetDirectoryName(common)!;
-        Linked = own != common;
-        Top = Git.Out(ctx.WorkingDirectory, "rev-parse", "--show-toplevel");
-        Branch = branch ?? Git.Out(ctx.WorkingDirectory, "rev-parse", "--abbrev-ref", "HEAD");
-        Memory = ctx.Env("PROBE_STATE_DIR") ?? Path.Combine(Root, ".claude", "agent-memory-local", "prober");
-        Dir = Path.Combine(Memory, "branches", Branch.Replace('/', '-'));
-    }
-
-    public string Head => Git.Out(Top, "rev-parse", "HEAD");
-    public string P(string name) => Path.Combine(Dir, name);
-
-    // ---- the corpus, tracked, overlaid by the branch's unpublished staging ------------------------------
-
-    public string CorpusPath(string relative)
-    {
-        var staged = Path.Combine(StagingDir, relative);
-        return File.Exists(staged) ? staged : Path.Combine(CorpusDir, relative);
-    }
-
-    public SortedDictionary<string, JsonObject> Registry()
-    {
-        var merged = new SortedDictionary<string, JsonObject>(StringComparer.Ordinal);
-        foreach (var path in new[] { Path.Combine(CorpusDir, "registry.json"), Path.Combine(StagingDir, "registry.json") })
-            if (Files.ReadJson(path)?["probes"] is JsonObject probes)
-                foreach (var (name, entry) in probes)
-                    if (entry is JsonObject e) merged[name] = (JsonObject)e.DeepClone();
-        return merged;
-    }
-
-    public List<JsonObject> Claims()
-    {
-        var merged = new SortedDictionary<string, JsonObject>(StringComparer.Ordinal);
-        foreach (var path in new[] { Path.Combine(CorpusDir, "claims.json"), Path.Combine(StagingDir, "claims.json") })
-            foreach (var c in ReadClaims(path, Path.GetRelativePath(Top, path).Replace('\\', '/')))
-                merged[Files.Str(c["id"])] = (JsonObject)c.DeepClone();
-        return [.. merged.Values];
-    }
-
-    /// <summary>
-    /// A claims file, refused unless it matches Schemas/claims.schema.json, each problem named by its claim and
-    /// field (decision 102). No file is no claims.
-    /// </summary>
-    public static List<JsonObject> ReadClaims(string path, string shown)
-    {
-        if (!File.Exists(path)) return [];
-        if (Files.ReadJson(path) is not JsonArray claims) throw new Refusal($"{shown} is not a JSON list of claims");
-        var schema = SchemaCheck.Load("claims.schema.json")["items"] as JsonObject ?? throw new InvalidOperationException("claims.schema.json has no items");
-        var problems = new List<string>();
-        for (var i = 0; i < claims.Count; i++)
-        {
-            var id = claims[i] is JsonObject o && Files.Str(o["id"]) is { Length: > 0 } s ? s : $"#{i}";
-            problems.AddRange(SchemaCheck.Problems(claims[i], schema).Select(p => $"claim {id}: {p}"));
-        }
-        if (problems.Count > 0)
-            throw new Refusal($"{shown} does not match tools/Prober/Schemas/claims.schema.json:\n  " + string.Join("\n  ", problems));
-        return [.. claims.OfType<JsonObject>()];
-    }
-
-    /// <summary>
-    /// A probe's own rows (rows/P.json, staged, else the corpus's rows/P.json.gz). Each probe has a file of its own, its claim
-    /// inside, so the rows of one probe of a claim never move another's identity.
-    /// </summary>
-    public JsonArray RowsOf(string probe)
-    {
-        var relative = Path.Combine("rows", probe + ".json");
-        var staged = Path.Combine(StagingDir, relative);
-        return File.Exists(staged) ? Files.ReadRows(staged) : Files.ReadRows(Path.Combine(CorpusDir, relative));
-    }
-
-    /// <summary>
-    /// The paths a probe's registry entry watches: what its result depends on that the footprint cannot see, such as a
-    /// variant catalogue under test/ compiled into the probes or a build input a child process reads. They stale its
-    /// footprint like the paths it ran.
-    /// </summary>
-    public IReadOnlyList<string> Watched(string probe) => [.. Files.Strings(Registry().GetValueOrDefault(probe)?["watched"])];
-
-    public JsonObject AxesBlock() => Axes.Block(AxesFile);
-
-    // ---- identity --------------------------------------------------------------------------------------
-
-    /// <summary>
-    /// What a probe's result depends on besides the product footprint: its registry entry (not its seed), every source
-    /// compiled with it (the harness and all probes), its own rows (not a sibling's), the axes file, the build environment
-    /// (SDK, central package versions, build props, global.json), this tool's version and the schema version, and
-    /// where its claim declares where an obligation does not apply, those declarations, which the harness reads.
-    /// A result counts only while this is unchanged.
-    /// </summary>
-    public string Identity(string probe)
-    {
-        using var sha = IncrementalHash.CreateHash(HashAlgorithmName.SHA256);
-        void Add(string s) => sha.AppendData(Encoding.UTF8.GetBytes(s + "\0"));
-        var entry = Registry().GetValueOrDefault(probe) ?? [];
-        // The seeds prove the probe; a result of the probe depends on none of them (decisions 100 and 104).
-        var registered = (JsonObject)entry.DeepClone();
-        registered.Remove("seed");
-        registered.Remove("seeds");
-        Add(Files.Canonical(registered));
-        var sources = new SortedDictionary<string, string>(StringComparer.Ordinal);
-        foreach (var baseDir in new[] { CorpusDir, StagingDir })
-            foreach (var sub in new[] { "harness", "probes" })
-            {
-                var folder = Path.Combine(baseDir, sub);
-                if (Directory.Exists(folder))
-                    foreach (var file in Directory.EnumerateFiles(folder, "*.cs")) sources[Path.GetFileName(file)] = file;
-            }
-        foreach (var (name, file) in sources) { Add(name); sha.AppendData(File.ReadAllBytes(file)); }
-        Add(Files.Canonical(RowsOf(probe)));
-        // The declarations Row.Check applies before a check's body runs: a change to one changes what the probe's rows
-        // check. Added only where the claim declares something, so a claim without declarations leaves the identity as it was.
-        if (Declarations(Files.Str(entry["claim"])) is { } declared) Add("inapplicable:" + Files.Canonical(declared));
-        try { Add(Files.Canonical(AxesBlock())); } catch (Refusal) { Add("no axes file"); }
-        foreach (var path in new[] { "Directory.Packages.props", "Directory.Build.props", "global.json" })
-            Add(path + (Git.ObjectId(Top, path) ?? "-"));
-        Add(Files.Canonical(Toolchain()));
-        Add("tool:" + SourceFingerprint.ToolVersion[..16]);
-        Add("schema:" + Files.SchemaVersion);
-        return Convert.ToHexStringLower(sha.GetHashAndReset())[..16];
-    }
-
-    private Dictionary<string, JsonArray>? declarations;
-
-    /// <summary>A claim's declarations of where its obligations do not apply, as claims.json holds them, by obligation; null where it declares none.</summary>
-    private JsonArray? Declarations(string claim)
-    {
-        declarations ??= Claims().ToDictionary(c => Files.Str(c["id"]), c => new JsonArray([.. (c["obligations"] as JsonArray ?? []).OfType<JsonObject>()
-            .Where(o => o["inapplicable"] is JsonArray { Count: > 0 })
-            .Select(o => (JsonNode)new JsonObject { ["obligation"] = Files.Str(o["id"]), ["inapplicable"] = o["inapplicable"]!.DeepClone() })]), StringComparer.Ordinal);
-        return declarations.TryGetValue(claim, out var declared) && declared.Count > 0 ? declared : null;
-    }
-
-    private JsonObject? toolchain;
-
-    /// <summary>
-    /// What no file in the repository records: the SDK a global.json roll-forward picked, say. A command that cannot
-    /// say it (it does not start, exits non-zero or prints nothing) is a refusal: its error text in every identity
-    /// would read as a toolchain change, and every result as stale, without a word why.
-    /// </summary>
-    public JsonObject Toolchain()
-    {
-        if (toolchain is not null) return toolchain;
-        JsonObject? commands;
-        try { commands = AxesBlock()["replay"]?["toolchain"] as JsonObject; } catch (Refusal) { commands = null; }
-        var result = new JsonObject();
-        foreach (var (name, argv) in (commands ?? []).OrderBy(kv => kv.Key, StringComparer.Ordinal))
-        {
-            var parts = Files.Strings(argv).ToArray();
-            var shown = $"the toolchain command {name} (`{string.Join(' ', parts)}`)";
-            if (parts.Length == 0) throw new Refusal($"{shown} is empty");
-            Ran ran;
-            try { ran = Proc.Run(parts[0], parts[1..], Top); }
-            catch (System.ComponentModel.Win32Exception e) { throw new Refusal($"{shown} did not start: {e.Message}"); }
-            static string FirstLine(string s) => s.Trim().Split('\n')[0].Trim();
-            // A failing `dotnet --version` lists the installed SDKs on stdout ("10.0.401 [path]", a version to look at)
-            // and says why on stderr.
-            if (ran.ExitCode != 0)
-            {
-                var why = FirstLine(ran.Stderr) is { Length: > 0 } err ? err : FirstLine(ran.Stdout);
-                throw new Refusal($"{shown} exited {ran.ExitCode}: {(why.Length > 0 ? why : "no output")}. A result is bound to what it prints, " +
-                                  "so none could be current; put the toolchain global.json asks for first on PATH, or install it where " +
-                                  $"the SDK installer puts it ({Dotnet.InstallerDirectory}), which `dotnet` falls back to");
-            }
-            var first = FirstLine(ran.Stdout.Trim().Length > 0 ? ran.Stdout : ran.Stderr);
-            if (first.Length == 0) throw new Refusal($"{shown} printed nothing, so a result could be bound to no toolchain");
-            result[name] = first;
-        }
-        return toolchain = result;
-    }
-
-    // ---- footprints, evidence, coverage ------------------------------------------------------------------
-
-    public Dictionary<string, JsonObject> Footprints() =>
-        Files.ReadLines(P("footprints.jsonl")).GroupBy(l => Files.Str(l["probe"]), StringComparer.Ordinal)
-             .ToDictionary(g => g.Key, g => g.Last(), StringComparer.Ordinal);
-
-    private readonly Dictionary<string, bool> currentCache = new(StringComparer.Ordinal);
-
-    /// <summary>
-    /// A probe's footprint is current when every path it ran, every compile-time path, every path its registry entry
-    /// watches and the toolchain are unchanged at HEAD. A watched path the footprint did not record (one added to the
-    /// entry since) is not current. A footprint that ran nothing under <c>src/</c> is current only by watched paths it recorded.
-    /// </summary>
-    public bool FootprintCurrent(string probe, Dictionary<string, JsonObject> footprints)
-    {
-        if (currentCache.TryGetValue(probe, out var cached)) return cached;
-        var ok = false;
-        if (footprints.TryGetValue(probe, out var r) && r["footprint"] is JsonObject fp && (fp.Count > 0 || r["watched"] is JsonObject { Count: > 0 }))
-        {
-            var watched = r["watched"] as JsonObject ?? [];
-            ok = Watched(probe).All(watched.ContainsKey)
-                 && fp.Concat(r["compileTime"] as JsonObject ?? []).Concat(watched).All(kv => Git.ObjectId(Top, kv.Key) == Files.Str(kv.Value, null!));
-            if (ok)
-            {
-                var now = Toolchain();
-                ok = (r["toolchain"] as JsonObject ?? []).All(kv => Files.Str(now[kv.Key]) == Files.Str(kv.Value));
-            }
-        }
-        return currentCache[probe] = ok;
-    }
-
-    public bool FootprintChangedSince(string probe, string since, Dictionary<string, JsonObject> footprints)
-    {
-        if (!footprints.TryGetValue(probe, out var r)) return true;
-        var paths = (r["footprint"] as JsonObject ?? []).Select(kv => kv.Key).Concat((r["compileTime"] as JsonObject ?? []).Select(kv => kv.Key))
-                                                         .Concat((r["watched"] as JsonObject ?? []).Select(kv => kv.Key)).Concat(Watched(probe))
-                                                         .Distinct(StringComparer.Ordinal).ToArray();
-        if (paths.Length == 0) return true;
-        return Git.Run(Top, ["diff", "--quiet", since, "HEAD", "--", .. paths]).ExitCode != 0;
-    }
-
-    public string EvidencePath(string probe) => P(Path.Combine("evidence", probe + ".json"));
-
-    /// <summary>A check that earned credit: the obligation it named and the settings it ran under.</summary>
-    public sealed record Credit(string Obligation, Dictionary<string, string> Applied);
-
-    /// <summary>
-    /// The checks of one probe's evidence that earn credit, each with its obligation and settings: only while the
-    /// probe's identity and product footprint are current, and only checks that ended as a pass in rows that were
-    /// expected and executed. A check's settings are the row's (read outside any check, so every check ran under them)
-    /// with its own laid over them; a row without checks is one check of the obligation <c>claim</c>, credited when
-    /// the row passed.
-    /// </summary>
-    public List<Credit> CreditedChecks(string probe, JsonObject? evidence, Dictionary<string, JsonObject>? footprints)
-    {
-        var result = new List<Credit>();
-        if (evidence is null || Files.Str(evidence["identity"]) != Identity(probe)) return result;
-        if (footprints is not null && !FootprintCurrent(probe, footprints)) return result;
-        var expected = new HashSet<int>(); var executed = new HashSet<int>();
-        foreach (var v in (evidence["variants"] as JsonArray ?? []).OfType<JsonObject>())
-        {
-            foreach (var i in v["expected"] as JsonArray ?? []) expected.Add((int)Files.Num(i));
-            foreach (var i in v["executed"] as JsonArray ?? []) executed.Add((int)Files.Num(i));
-        }
-        foreach (var (key, row) in evidence["rows"] as JsonObject ?? [])
-        {
-            var i = int.Parse(key, System.Globalization.CultureInfo.InvariantCulture);
-            if (row is not JsonObject r || !expected.Contains(i) || !executed.Contains(i)) continue;
-            foreach (var check in ChecksOf(r))
-                if (check.Category == "pass" && check.Applied.Count > 0) result.Add(new Credit(check.Obligation, check.Applied));
-        }
-        return result;
-    }
-
-    /// <summary>One check of an evidence row as the ledger reads it.</summary>
-    public sealed record CheckRead(string Obligation, string Category, Dictionary<string, string> Applied, string? Baseline);
-
-    /// <summary>
-    /// The checks of one evidence row: each with its obligation, category and settings (the row's, the check's laid
-    /// over them). A row without checks, every row of a version-1 file among them, is one check of the implicit
-    /// obligation <c>claim</c> with the row's category and settings and no baseline.
-    /// </summary>
-    public static List<CheckRead> ChecksOf(JsonObject row)
-    {
-        var applied = row["applied"] is JsonObject a ? Files.StringMap(a) : new Dictionary<string, string>(StringComparer.Ordinal);
-        if (row["checks"] is not JsonArray { Count: > 0 } checks)
-            return [new CheckRead(Claim.ImplicitObligation, Files.Str(row["category"], "violation"), applied, null)];
-        var result = new List<CheckRead>();
-        foreach (var c in checks.OfType<JsonObject>())
-        {
-            var own = new Dictionary<string, string>(applied, StringComparer.Ordinal);
-            if (c["applied"] is JsonObject ca) foreach (var (axis, value) in Files.StringMap(ca)) own[axis] = value;
-            result.Add(new CheckRead(Files.Str(c["obligation"]), Files.Str(c["category"], "violation"), own, c["baseline"] is JsonValue b ? Files.Str(b) : null));
-        }
-        return result;
-    }
-
-    /// <summary>
-    /// (claim, obligation, pair) for every pair a current check earned, leaving out the probe <paramref name="except"/>
-    /// names. Each check's settings alone make its pairs: a pair is never put together from two checks' settings.
-    /// </summary>
-    public HashSet<(string Claim, string Obligation, Pair Pair)> Credits(Universe universe, string? claimId = null, string? except = null)
-    {
-        var footprints = Footprints();
-        var done = new HashSet<(string, string, Pair)>();
-        foreach (var (name, entry) in Registry())
-        {
-            var cid = Files.Str(entry["claim"]);
-            if (name == except || (claimId is not null && cid != claimId) || !universe.ById.TryGetValue(cid, out var claim)) continue;
-            var evidence = Files.ReadJson(EvidencePath(name)) as JsonObject;
-            foreach (var credit in CreditedChecks(name, evidence, footprints))
-                foreach (var pair in claim.PairsOfRow(credit.Applied)) done.Add((cid, credit.Obligation, pair));
-        }
-        return done;
-    }
-
-    /// <summary>
-    /// (claim, pair) for every pair current evidence earned, leaving out the probe <paramref name="except"/> names. A round's
-    /// own ledger lines earn nothing.
-    /// </summary>
-    public HashSet<(string Claim, Pair Pair)> Covered(Universe universe, string? claimId = null, string? except = null) =>
-        [.. Credits(universe, claimId, except).Select(x => (x.Claim, x.Pair))];
-
-    /// <summary>The last event per finding; a fixed line counts once its commit is in HEAD's history, a dismissal in the corpus everywhere.</summary>
-    public Dictionary<string, JsonObject> Findings()
-    {
-        var last = new Dictionary<string, JsonObject>(StringComparer.Ordinal);
-        foreach (var f in Files.ReadLines(P("findings.jsonl")))
-        {
-            if (Files.Str(f["status"]) == "fixed" && Files.Str(f["commit"]) is { Length: > 0 } c
-                && Git.Run(Top, "merge-base", "--is-ancestor", c, "HEAD").ExitCode != 0) continue;
-            last[Files.Str(f["id"])] = f;
-        }
-        foreach (var f in Files.ReadLines(CorpusPath("dismissed.jsonl")))
-        {
-            var d = (JsonObject)f.DeepClone(); d["status"] = "dismissed";
-            last[Files.Str(f["id"])] = d;
-        }
-        return last;
-    }
-
-    /// <summary>The findings one probe's evidence steps around, with the number of rows that skip for each.</summary>
-    public static SortedDictionary<string, int> FindingSkips(JsonObject? evidence)
-    {
-        var skips = new SortedDictionary<string, int>(StringComparer.Ordinal);
-        foreach (var (_, row) in evidence?["rows"] as JsonObject ?? [])
-            foreach (var f in Files.Strings(row?["findings"])) skips[f] = skips.GetValueOrDefault(f) + 1;
-        return skips;
-    }
-
-    /// <summary>
-    /// The skips of one probe's evidence that no longer stand: a finding this ledger has fixed (in HEAD's history)
-    /// or the corpus has dismissed. Such a skip would hide the defect coming back, so the replay fails the probe.
-    /// A finding this ledger has never seen (a fresh state, as in CI) is left to the gate, which refuses any skip.
-    /// </summary>
-    public List<string> StaleSkips(JsonObject? evidence)
-    {
-        var findings = Findings();
-        var stale = new List<string>();
-        foreach (var (id, rows) in FindingSkips(evidence))
-        {
-            if (!findings.TryGetValue(id, out var f)) continue;
-            var status = Files.Str(f["status"]);
-            if (status == "fixed" && Files.Str(f["commit"]) is { Length: >= 7 } commit) status += " at " + commit[..7];
-            if (status != "open") stale.Add($"{rows} row(s) skip for {id}, which is {status}: remove the skip");
-        }
-        return stale;
-    }
-
-    /// <summary>How the rows of one probe's evidence ended, by category.</summary>
-    public static SortedDictionary<string, int> Outcomes(JsonObject? evidence)
-    {
-        var outcomes = new SortedDictionary<string, int>(StringComparer.Ordinal);
-        foreach (var (_, row) in evidence?["rows"] as JsonObject ?? [])
-        {
-            var category = Files.Str(row?["category"], "violation");
-            outcomes[category] = outcomes.GetValueOrDefault(category) + 1;
-        }
-        return outcomes;
-    }
-
-    /// <summary>How the checks of one probe's evidence ended, by category; a row without checks counts as its one check <c>claim</c>.</summary>
-    public static SortedDictionary<string, int> CheckOutcomes(JsonObject? evidence)
-    {
-        var outcomes = new SortedDictionary<string, int>(StringComparer.Ordinal);
-        foreach (var (_, row) in evidence?["rows"] as JsonObject ?? [])
-            if (row is JsonObject r)
-                foreach (var check in ChecksOf(r)) outcomes[check.Category] = outcomes.GetValueOrDefault(check.Category) + 1;
-        return outcomes;
-    }
-
-    /// <summary>The obligations a check of one probe's evidence passed for at its last replay, current or not.</summary>
-    public static HashSet<string> PassedObligations(JsonObject? evidence)
-    {
-        var passed = new HashSet<string>(StringComparer.Ordinal);
-        foreach (var (_, row) in evidence?["rows"] as JsonObject ?? [])
-            if (row is JsonObject r)
-                foreach (var check in ChecksOf(r).Where(c => c.Category == "pass")) passed.Add(check.Obligation);
-        return passed;
-    }
-
-    public List<string> OpenFindings() => [.. Findings().Where(kv => Files.Str(kv.Value["status"]) == "open").Select(kv => kv.Key).Order(StringComparer.Ordinal)];
-
-    public sealed record ProbeState(string Probe, string Claim, string Filter, JsonArray Variants, bool Stale, bool Retired, int Passes, bool Replay);
-
-    /// <summary>A registry entry's process variants: its own, or one that sets nothing.</summary>
-    public static JsonArray VariantsOf(JsonObject entry) => entry["variants"] is JsonArray va && va.Count > 0 ? (JsonArray)va.DeepClone() : [new JsonObject()];
-
-    public List<ProbeState> ProbeStates(bool includeRetired)
-    {
-        var footprints = Footprints();
-        var runs = Files.ReadLines(P("runs.jsonl"));
-        var states = new List<ProbeState>();
-        foreach (var (probe, r) in Registry())
-        {
-            var passes = runs.Count(x => Files.Str(x["probe"]) == probe && Files.Str(x["result"]) == "pass");
-            var retired = r["retired"] is JsonValue rv && rv.TryGetValue<bool>(out var b) && b;
-            var evidence = Files.ReadJson(EvidencePath(probe));
-            var stale = !FootprintCurrent(probe, footprints) || evidence is null || Files.Str(evidence["identity"]) != Identity(probe);
-            var variants = VariantsOf(r);
-            states.Add(new ProbeState(probe, Files.Str(r["claim"]), Files.Str(r["filter"]), variants, stale, retired, passes, stale && (includeRetired || !retired)));
-        }
-        return states;
-    }
-}
-
-/// <summary>A refusal the user acts on: printed as "prober: ...", exit 1. Never a stack trace.</summary>
-internal sealed class Refusal(string message, int exitCode = 1) : Exception(message)
-{
-    public int ExitCode { get; } = exitCode;
-}
diff --git a/tools/Prober/NewProbe.cs b/tools/Prober/NewProbe.cs
deleted file mode 100644
index 97047dcd..00000000
--- a/tools/Prober/NewProbe.cs
+++ /dev/null
@@ -1,166 +0,0 @@
-using System.Text;
-using System.Text.Json;
-using System.Text.Json.Nodes;
-using System.Text.RegularExpressions;
-
-namespace Prober;
-
-/// <summary>
-/// <c>new</c>: the mechanical half of writing a probe, done the same way every time, into the branch's staging.
-/// It writes the probe's skeleton in the harness's form (<c>probes/P.cs</c>), headed by the claim's source and
-/// every obligation's id and sentence, with one check per obligation that throws until it is written; stages the
-/// probe's own rows (a covering array over its claim's pairs the claim's other probes have not covered, as
-/// <c>rows --probe P</c> writes);
-/// and registers the probe with an empty <c>seeds</c>, so <c>seeds</c> and <c>Seeds.Problems</c> name each
-/// obligation's seed as owed. The skeleton builds, so the other probes keep building beside it, and every row of
-/// it ends as a harness error, which fails the row, earns nothing and is never a seed's catch (decision 103).
-/// It refuses, writing nothing, a claim that is not in the claims, a name a probe has already, and a claim
-/// whose first surface is in no family of the replay configuration (or not in the one <c>--family</c> names).
-/// </summary>
-internal static partial class NewProbe
-{
-    [GeneratedRegex("^[A-Za-z_][A-Za-z0-9_]*Probe$")]
-    private static partial Regex ProbeName();
-
-    [GeneratedRegex("^([A-Za-z]+[0-9]+)(?:-(.*))?$")]
-    private static partial Regex ClaimPrefix();
-
-    [GeneratedRegex("[^A-Za-z0-9]+")]
-    private static partial Regex NotAlphanumeric();
-
-    public static int Run(Ledger l, Args a)
-    {
-        var claimId = a.Need("claim");
-        var claim = l.Claims().FirstOrDefault(c => Files.Str(c["id"]) == claimId)
-                    ?? throw new Refusal($"no claim {claimId} in claims.json (tracked or staged)");
-        var probe = a.Get("probe") is { Length: > 0 } named ? named : DefaultName(claimId);
-        if (!ProbeName().IsMatch(probe)) throw new Refusal($"{probe} is not a probe's name: a C# class name ending in Probe", 2);
-        if (Taken(l, probe) is { } where) throw new Refusal($"a probe {probe} exists already ({where}); name another with --probe");
-        var family = Family(l, claim, a.Get("family"));
-        var obligations = Obligations(claim);
-
-        var source = Path.Combine(l.StagingDir, "probes", probe + ".cs");
-        Files.WriteAtomically(source, Skeleton(claim, probe, family, obligations));
-        // The probe's own rows, its claim's other probes' untouched: a covering array over the pairs they have not covered.
-        var (rows, _) = Commands.StageRows(l, probe, claimId, full: false);
-        var registry = Path.Combine(l.StagingDir, "registry.json");
-        var staged = Files.ReadJson(registry) as JsonObject ?? new JsonObject { ["probes"] = new JsonObject() };
-        var probes = staged["probes"] as JsonObject ?? [];
-        probes[probe] = new JsonObject { ["claim"] = claimId, ["filter"] = "*" + probe, ["seeds"] = new JsonArray() };
-        staged["probes"] = probes.DeepClone();
-        Files.WriteJson(registry, staged);
-
-        var o = l.Ctx.Out;
-        o.WriteLine($"prober new: {probe} for claim {claimId}{(family is null ? "" : $" (family {family})")}, staged in {l.StagingDir}");
-        o.WriteLine($"  probes/{probe}.cs: the skeleton; it builds, and every row ends as a harness error until each obligation's check is written");
-        o.WriteLine($"  rows/{probe}.json: {rows} rows over the claim's pairs its other probes have not covered" +
-                    (rows == 0 ? "; with no row the probe has no test to run" : ""));
-        o.WriteLine($"  registry.json: {probe}, claim {claimId}, filter *{probe}, no seed yet");
-        o.WriteLine("still owed, per obligation:");
-        foreach (var (id, sentence, method) in obligations)
-            o.WriteLine($"  {id}: the check {method} ({(sentence is null ? "the claim as a whole" : $"\"{sentence}\"")}), and a seed that breaks it " +
-                        (id == Claim.ImplicitObligation && sentence is null
-                             ? $"(`prober register --probe {probe} --claim {claimId} --filter \"*{probe}\" --seed seeds/{claimId}.patch --defect \"...\"`)"
-                             : $"(`prober register --probe {probe} --claim {claimId} --filter \"*{probe}\" --obligation {id} --seed seeds/{claimId}-{id}.patch --defect \"...\"`)"));
-        o.WriteLine($"then: `prober try --probe {probe}` until each row ends as it should, `prober seeds --probe {probe}`, `prober register` (it lints the staged sources), `prober publish`");
-        return 0;
-    }
-
-    /// <summary>The claim id's letter-digit prefix, then its words run together, then <c>Probe</c>: C20-testing-shouldhold is C20TestingShouldholdProbe.</summary>
-    internal static string DefaultName(string claimId)
-    {
-        var m = ClaimPrefix().Match(claimId);
-        var (prefix, rest) = m.Success ? (m.Groups[1].Value, m.Groups[2].Value) : ("", claimId);
-        return Pascal(prefix) + Pascal(rest) + "Probe";
-    }
-
-    private static string Pascal(string text) =>
-        string.Concat(NotAlphanumeric().Split(text).Where(w => w.Length > 0).Select(w => char.ToUpperInvariant(w[0]) + w[1..]));
-
-    /// <summary>Where a probe of that name is already: the registry, a source file of that name, or a class of that name in any corpus source.</summary>
-    private static string? Taken(Ledger l, string probe)
-    {
-        if (l.Registry().ContainsKey(probe)) return "in the registry";
-        var declares = new Regex($@"\b(class|record|struct)\s+{probe}\b");
-        foreach (var dir in new[] { l.CorpusDir, l.StagingDir })
-            foreach (var sub in new[] { "harness", "probes" })
-            {
-                var folder = Path.Combine(dir, sub);
-                if (!Directory.Exists(folder)) continue;
-                foreach (var file in Directory.EnumerateFiles(folder, "*.cs"))
-                    if (Path.GetFileNameWithoutExtension(file) == probe || declares.IsMatch(File.ReadAllText(file))) return file;
-            }
-        return null;
-    }
-
-    /// <summary>
-    /// The family the replay runs the probe in, its claim's first surface's (decision 101), checked against
-    /// <c>--family</c>. Null where the replay configuration names no families and none was asked for.
-    /// </summary>
-    private static string? Family(Ledger l, JsonObject claim, string? asked)
-    {
-        var families = (l.AxesBlock()["replay"] as JsonObject)?["families"] as JsonObject;
-        if (families is null)
-            return asked is null ? null : throw new Refusal($"--family {asked}: the replay configuration names no families", 2);
-        var surface = Files.Strings(claim["surfaces"]).FirstOrDefault() ?? "";
-        var family = families.FirstOrDefault(kv => Files.Strings(kv.Value).Contains(surface)).Key
-                     ?? throw new Refusal($"the first surface of claim {Files.Str(claim["id"])} ({surface}) is in no family of the replay configuration, so a replay by family would never run its probe");
-        if (asked is not null && asked != family)
-            throw new Refusal($"claim {Files.Str(claim["id"])} is of family {family} (its first surface, {surface}), not {asked}", 2);
-        return family;
-    }
-
-    /// <summary>Each obligation of the claim with its sentence and the check method the skeleton gives it; a claim without obligations has one, the claim itself, with no sentence.</summary>
-    internal static List<(string Id, string? Sentence, string Method)> Obligations(JsonObject claim)
-    {
-        var listed = (claim["obligations"] as JsonArray ?? []).OfType<JsonObject>()
-                                                              .Select(o => (Id: Files.Str(o["id"]), Sentence: (string?)OneLine(Files.Str(o["sentence"])))).ToList();
-        if (listed.Count == 0) listed = [(Claim.ImplicitObligation, null)];
-        var methods = new HashSet<string>(StringComparer.Ordinal);
-        var result = new List<(string, string?, string)>();
-        foreach (var (id, sentence) in listed)
-        {
-            var method = "Check" + Pascal(id);
-            for (var n = 2; !methods.Add(method); n++) method = "Check" + Pascal(id) + n;
-            result.Add((id, sentence, method));
-        }
-        return result;
-    }
-
-    /// <summary>The probe's source: the form of the corpus's probes (<c>Rows.Data</c>, <c>[Theory, MemberData(nameof(Data))]</c>, <c>Rec.Run</c>), one throwing check per obligation.</summary>
-    internal static string Skeleton(JsonObject claim, string probe, string? family, List<(string Id, string? Sentence, string Method)> obligations)
-    {
-        var id = Files.Str(claim["id"]);
-        var literal = JsonSerializer.Serialize(probe);
-        var b = new StringBuilder();
-        void Line(string text = "") => b.Append(text).Append('\n');
-        Line($"// Claim {id} ({Files.Str(claim["source"])}), surfaces {string.Join(", ", Files.Strings(claim["surfaces"]))}{(family is null ? "" : $", family {family}")}.");
-        Line("// Obligations (claims.json), each with a check below and a seed of its own in the registry entry (decision 104):");
-        foreach (var (oid, sentence, _) in obligations)
-            Line($"//   {oid}: {(sentence is null ? "the claim as a whole (claims.json lists no obligations for it)" : $"\"{sentence}\"")}");
-        Line("// Oracle: TODO: what each row is compared against, and the result it expects.");
-        Line("// Written by `prober new`: it builds, and every row ends as a harness error until each obligation's check is written.");
-        Line("using Probes.Shapes;");
-        Line("namespace Probes;");
-        Line($"public sealed class {probe}");
-        Line("{");
-        Line($"    public static TheoryData<string, int> Data() => Rows.Data({literal});");
-        Line("    [Theory, MemberData(nameof(Data))]");
-        Line("    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);");
-        Line();
-        Line("    static async Task<string?> Check(Row r) =>");
-        for (var i = 0; i < obligations.Count; i++)
-            Line($"        {(i == 0 ? "" : "?? ")}await {obligations[i].Method}(r){(i == obligations.Count - 1 ? ";" : "")}");
-        foreach (var (oid, sentence, method) in obligations)
-        {
-            Line();
-            Line($"    // TODO {oid}: {(sentence is null ? "the claim as a whole" : $"\"{sentence}\"")}");
-            Line("    // Return the failure text, or null where the row holds it; say how it was compared with r.Note(NoteKeys.Compared, detail).");
-            Line($"    static Task<string?> {method}(Row r) => throw new NotImplementedException({JsonSerializer.Serialize($"{id}/{oid}: its check is not written yet")});");
-        }
-        Line("}");
-        return b.ToString();
-    }
-
-    private static string OneLine(string text) => string.Join(" ", text.Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries));
-}
diff --git a/tools/Prober/ProbeAdapter.cs b/tools/Prober/ProbeAdapter.cs
deleted file mode 100644
index fc993e87..00000000
--- a/tools/Prober/ProbeAdapter.cs
+++ /dev/null
@@ -1,116 +0,0 @@
-using System.Text.Json.Nodes;
-using System.Text.RegularExpressions;
-
-namespace Prober;
-
-/// <summary>
-/// What the core needs from a repository's toolchain, and nothing more: build the probes, run one probe in
-/// one process with an environment (writing its rows' outcomes and a coverage report), and derive the
-/// generated axes. The core holds nothing of .NET's; a repository on another stack plugs in its own.
-/// </summary>
-internal interface IProbeAdapter
-{
-    /// <summary>Builds what the probes need in the worktree. The first line of the output is shown.</summary>
-    Ran Build(string worktree, IReadOnlyDictionary<string, string?> environment);
-
-    /// <summary>Runs one probe (by its filter) with the environment given; the coverage report goes to <paramref name="coverageFile"/> under <paramref name="results"/>.</summary>
-    Ran RunProbe(string worktree, string filter, string results, string coverageFile, IReadOnlyDictionary<string, string?> environment);
-
-    /// <summary>The generated axes (settings of the option types the features read), or null with a reason.</summary>
-    (JsonObject? Axes, string? Error) DeriveAxes(string checkout, string workDirectory);
-
-    /// <summary>The environment every build and run of the probes needs (for .NET: the coverage extension).</summary>
-    IReadOnlyDictionary<string, string?> Environment(string cacheDirectory);
-}
-
-/// <summary>
-/// The .NET adapter, configured by the "replay" object of the axes file: argv templates for the build and
-/// the test run (through the repository's verdict tool), the commands that prepare the worktree first (building
-/// that tool), the coverage extension referenced from a targets file outside the worktree, and the reflection
-/// enumerator run with the repository's package versions.
-/// </summary>
-internal sealed class DotNetAdapter(JsonObject config) : IProbeAdapter
-{
-    private string Project => Files.Str(config["project"]);
-
-    private static string[] Expand(JsonNode? template, Dictionary<string, string> values) =>
-        [.. Files.Strings(template).Select(arg => Regex.Replace(arg, @"\{(\w+)\}", m => values.TryGetValue(m.Groups[1].Value, out var v) ? v : m.Value))];
-
-    /// <summary>
-    /// The program a template starts: a bare name (no path separator, <c>dotnet</c>) is found on PATH; a path is
-    /// relative to the replay worktree and must exist there, so a template naming a file the repository no longer
-    /// has fails by name, never as a puzzling exit code.
-    /// </summary>
-    internal static string Executable(string worktree, string program)
-    {
-        if (program.IndexOfAny(['/', '\\']) < 0) return program;
-        var path = Path.Combine(worktree, program);
-        return File.Exists(path) ? path : throw new Refusal($"the replay template names {program}, which the worktree does not have");
-    }
-
-    private static Ran Start(string worktree, string[] argv, IReadOnlyDictionary<string, string?> environment) =>
-        Proc.Run(Executable(worktree, argv[0]), argv[1..], worktree, environment);
-
-    /// <summary>Prepares the worktree (the "prepare" commands: building the verdict tool, which a fresh or moved worktree lacks or holds stale), then builds the probes.</summary>
-    public Ran Build(string worktree, IReadOnlyDictionary<string, string?> environment)
-    {
-        foreach (var command in (config["prepare"] as JsonArray ?? []).OfType<JsonArray>())
-        {
-            var prepared = Start(worktree, Expand(command, new() { ["project"] = Project }), environment);
-            if (prepared.ExitCode != 0)
-                return prepared with { Stdout = $"PREPARE FAILED: {string.Join(' ', Files.Strings(command))}\n" + prepared.Stdout + prepared.Stderr };
-        }
-        return Start(worktree, Expand(config["build"], new() { ["project"] = Project }), environment);
-    }
-
-    /// <summary>
-    /// The "test" template, then the "coverage" arguments when a coverage file is asked for. A replay without a
-    /// footprint asks for none, so a template that carries the coverage arguments itself is refused rather than
-    /// run with an empty file name.
-    /// </summary>
-    public Ran RunProbe(string worktree, string filter, string results, string coverageFile, IReadOnlyDictionary<string, string?> environment)
-    {
-        var values = new Dictionary<string, string> { ["project"] = Project, ["filter"] = filter, ["results"] = results, ["cobertura"] = coverageFile };
-        if (coverageFile.Length == 0 && Files.Strings(config["test"]).Any(arg => arg.Contains("{cobertura}", StringComparison.Ordinal)))
-            throw new Refusal("the replay's test template carries the coverage arguments itself; move them to a \"coverage\" array of the replay configuration, so a run without a footprint can leave them out");
-        string[] argv = coverageFile.Length > 0 ? [.. Expand(config["test"], values), .. Expand(config["coverage"], values)] : Expand(config["test"], values);
-        // The template runs the verdict tool, which keeps its full log where BUILD_VERDICT_LOG_DIR says: the
-        // directory the replay offers as PROBE_LOG_DIR, whose files it keeps for a failed run.
-        if (environment.TryGetValue("PROBE_LOG_DIR", out var logDir) && logDir is { Length: > 0 })
-            environment = new Dictionary<string, string?>(environment, StringComparer.Ordinal) { ["BUILD_VERDICT_LOG_DIR"] = logDir };
-        return Start(worktree, argv, environment);
-    }
-
-    public IReadOnlyDictionary<string, string?> Environment(string cacheDirectory)
-    {
-        var result = new Dictionary<string, string?>(StringComparer.Ordinal);
-        if (Files.Str(config["coverageTargets"]) is { Length: > 0 } targets)
-        {
-            var path = Path.Combine(cacheDirectory, "coverage.targets");
-            if (!File.Exists(path) || SharedFile.ReadAllText(path) != targets) Files.WriteAtomically(path, targets);
-            result["CustomAfterMicrosoftCommonTargets"] = path;
-        }
-        return result;
-    }
-
-    public (JsonObject? Axes, string? Error) DeriveAxes(string checkout, string workDirectory)
-    {
-        if (config["enumerate"] is not JsonObject enumerate) return (null, "no enumerator configured");
-        // The enumerator pins its packages in #:package directives; each version comes from the repository's
-        // central package versions, so the axes follow a dependency update without anyone editing the script.
-        var script = File.ReadAllText(Path.Combine(checkout, Files.Str(enumerate["script"])));
-        var props = Path.Combine(checkout, "Directory.Packages.props");
-        var versions = File.Exists(props)
-            ? Regex.Matches(File.ReadAllText(props), "<PackageVersion\\s+Include=\"([^\"]+)\"\\s+Version=\"([^\"]+)\"")
-                   .ToDictionary(m => m.Groups[1].Value, m => m.Groups[2].Value, StringComparer.Ordinal)
-            : new Dictionary<string, string>(StringComparer.Ordinal);
-        script = Regex.Replace(script, @"^#:package ([^@\s]+)@(\S+)", m => $"#:package {m.Groups[1].Value}@{(versions.TryGetValue(m.Groups[1].Value, out var v) ? v : m.Groups[2].Value)}", RegexOptions.Multiline);
-        Directory.CreateDirectory(workDirectory);
-        var file = Path.Combine(workDirectory, Path.GetFileName(Files.Str(enumerate["script"])));
-        Files.WriteAtomically(file, script);
-        var ran = Proc.Run("dotnet", ["run", file], workDirectory);
-        if (ran.ExitCode != 0) return (null, "the enumerator failed: " + ran.Stderr.Trim().Split('\n')[^1]);
-        var json = ran.Stdout[ran.Stdout.IndexOf('{')..];
-        return (JsonNode.Parse(json) as JsonObject, null);
-    }
-}
diff --git a/tools/Prober/ProbeRun.cs b/tools/Prober/ProbeRun.cs
deleted file mode 100644
index 484fc507..00000000
--- a/tools/Prober/ProbeRun.cs
+++ /dev/null
@@ -1,107 +0,0 @@
-using System.Text.Json.Nodes;
-
-namespace Prober;
-
-/// <summary>
-/// What <c>replay</c>, <c>seeds</c> and <c>try</c> share to run a probe: the worktree moved to HEAD, the
-/// environment every build and run gets, one run of a probe in one process, and how each row of it ended, read
-/// from the jsonl the harness writes under <c>PROBE_OUT</c>.
-/// </summary>
-internal static class ProbeRun
-{
-    /// <summary>
-    /// A row's outcome under one run: its category, the first reason given, whether any reason of the row or of a check
-    /// of it was a harness error, and its checks. A row that ran no check is one check of the obligation <c>claim</c>.
-    /// </summary>
-    internal sealed record RowOutcome(string Category, string Reason, bool HarnessError, IReadOnlyList<CheckOutcome> Checks);
-
-    /// <summary>
-    /// One check of a row under one run: its obligation, category and first reason, and whether a harness error broke it
-    /// or its row outside any check. Only a clean violation, one with no harness error, says the check fired (decision 103).
-    /// </summary>
-    internal sealed record CheckOutcome(string Obligation, string Category, string Reason, bool HarnessError)
-    {
-        public bool CleanViolation => Category == "violation" && !HarnessError;
-    }
-
-    /// <summary>
-    /// Adds the worktree at <paramref name="head"/> ("cold"), or moves it there without force ("warm"): files the
-    /// commits did not change keep their mtimes, so the build stays incremental.
-    /// </summary>
-    public static string Ready(Ledger ledger, string worktree, string head)
-    {
-        if (!Directory.Exists(worktree))
-        {
-            var added = Git.Run(ledger.Root, "worktree", "add", "--detach", worktree, head);
-            if (added.ExitCode != 0) throw new Refusal("could not add the worktree: " + added.Stderr.Trim(), 2);
-            return "cold";
-        }
-        if (Git.Run(worktree, "checkout", "--detach", head).ExitCode != 0) Git.Run(worktree, "reset", "--hard", head);
-        return "warm";
-    }
-
-    /// <summary>The process's environment with what the adapter adds for every build and run of the probes.</summary>
-    public static Dictionary<string, string?> Environment(Context ctx, IProbeAdapter adapter, string home)
-    {
-        var environment = new Dictionary<string, string?>(ctx.Environment, StringComparer.Ordinal);
-        foreach (var (k, v) in adapter.Environment(home)) environment[k] = v;
-        return environment;
-    }
-
-    /// <summary>The environment of one variant: the base, then the variant's own settings, then the extra ones (a seed's toggle).</summary>
-    public static Dictionary<string, string?> Variant(IReadOnlyDictionary<string, string?> environment, JsonObject variant, JsonObject? extra = null)
-    {
-        var env = new Dictionary<string, string?>(environment, StringComparer.Ordinal);
-        foreach (var (k, v) in variant) env[k] = Files.Str(v);
-        foreach (var (k, v) in extra ?? []) env[k] = Files.Str(v);
-        return env;
-    }
-
-    /// <summary>
-    /// Runs the probe the filter selects once, with its rows written to <c>{results}/{name}-rows</c>, and reads how
-    /// each row ended. <paramref name="coverageFile"/> empty asks for no coverage.
-    /// </summary>
-    public static (Ran Ran, Dictionary<int, RowOutcome> Rows) Once(IProbeAdapter adapter, string worktree, string filter, string results, string name,
-                                                                     string coverageFile, Dictionary<string, string?> env)
-    {
-        var outDir = Path.Combine(results, name + "-rows");
-        env["PROBE_OUT"] = outDir;
-        var ran = adapter.RunProbe(worktree, filter, results, coverageFile, env);
-        return (ran, Outcomes(outDir));
-    }
-
-    /// <summary>How each row ended, from every jsonl under <paramref name="outDir"/>; a line without a category is a violation.</summary>
-    public static Dictionary<int, RowOutcome> Outcomes(string outDir)
-    {
-        var rows = new Dictionary<int, RowOutcome>();
-        if (!Directory.Exists(outDir)) return rows;
-        foreach (var file in Directory.EnumerateFiles(outDir, "*.jsonl"))
-            foreach (var line in Files.ReadLines(file))
-            {
-                var category = Files.Str(line["category"], "violation");
-                var reasons = Files.Strings(line["reasons"]).ToList();
-                var reason = reasons.FirstOrDefault(r => r.StartsWith(category + ":", StringComparison.Ordinal)) ?? Files.Str(line["note"]);
-                static bool Broken(IEnumerable<string> reasons) => reasons.Any(r => r.StartsWith("harness-error:", StringComparison.Ordinal));
-                var checks = new List<CheckOutcome>();
-                if (line["checks"] is JsonArray { Count: > 0 } ran)
-                {
-                    // The row's own harness error (outside any check) breaks every check of it; a check's breaks that check.
-                    var rowBroken = Broken(reasons);
-                    foreach (var c in ran.OfType<JsonObject>())
-                    {
-                        var cc = Files.Str(c["category"], "violation");
-                        var cr = Files.Strings(c["reasons"]).ToList();
-                        checks.Add(new CheckOutcome(Files.Str(c["obligation"]), cc, cr.FirstOrDefault(r => r.StartsWith(cc + ":", StringComparison.Ordinal)) ?? Files.Str(c["notes"]),
-                                                    rowBroken || cc == "harness-error" || Broken(cr)));
-                    }
-                }
-                else checks.Add(new CheckOutcome(Claim.ImplicitObligation, category, reason, category == "harness-error" || Broken(reasons)));
-                var harnessError = Broken(reasons) || checks.Any(c => c.HarnessError);
-                rows[(int)Files.Num(line["idx"])] = new RowOutcome(category, reason, harnessError, checks);
-            }
-        return rows;
-    }
-
-    /// <summary>The first line of a run's output (the verdict's), or its exit code where it printed nothing.</summary>
-    public static string FirstLine(Ran ran) => ran.Stdout.Split('\n')[0].Trim() is { Length: > 0 } line ? line : $"exit {ran.ExitCode}";
-}
diff --git a/tools/Prober/Prober.csproj b/tools/Prober/Prober.csproj
deleted file mode 100644
index ba12505a..00000000
--- a/tools/Prober/Prober.csproj
+++ /dev/null
@@ -1,37 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-    <!--
-      prober: the probing workflow's core. It keeps the ledger (claims, universe, covering arrays,
-      evidence, coverage, the release gate, the round lock), replays the probe corpus with no model in
-      the loop, and runs a capped exploration round. Repository tooling, not a package: BCL only, never
-      packed. It is in the solution so `dotnet build` builds it, and it is started as its built dll:
-
-          dotnet tools/Prober/bin/Release/net10.0/prober.dll help
-
-      The file formats are the contract (Schemas/, versioned); this code is one reader of them. Building
-      and running probes goes through an adapter (ProbeAdapter.cs), so the core holds nothing of .NET's.
-      The README beside this file has the commands.
-    -->
-    <PropertyGroup>
-        <OutputType>Exe</OutputType>
-        <AssemblyName>prober</AssemblyName>
-        <RootNamespace>Prober</RootNamespace>
-        <!-- Never packed: release.yml publishes whatever `dotnet pack` of the solution writes (PackabilityTests). -->
-        <IsPackable>false</IsPackable>
-        <ToolSourcePatterns>$(ToolSourcePatterns);Schemas/*.json</ToolSourcePatterns>
-    </PropertyGroup>
-
-    <ItemGroup>
-        <InternalsVisibleTo Include="CodoMetis.TypeKit.Prober.Tests" />
-        <None Include="Schemas/*.json" CopyToOutputDirectory="PreserveNewest" />
-        <!-- The schemas SchemaCheck reads where a file is read (decision 102), by file name. -->
-        <EmbeddedResource Include="Schemas/claims.schema.json" LogicalName="%(Filename)%(Extension)" />
-    </ItemGroup>
-
-    <!--
-      The dll's own freshness is every tool's: tools/Directory.Build.targets stamps its sources, the
-      schemas among them, and at startup tools/Shared/SourceFingerprint.cs refuses to answer from other
-      sources (exit 3).
-    -->
-
-</Project>
diff --git a/tools/Prober/Program.cs b/tools/Prober/Program.cs
deleted file mode 100644
index 7b62b3ae..00000000
--- a/tools/Prober/Program.cs
+++ /dev/null
@@ -1,135 +0,0 @@
-namespace Prober;
-
-internal static class Program
-{
-    private const string Usage =
-        """
-        prober: the probing workflow's core. No command starts a model; only `round` does, locally.
-
-        Ledger (any checkout of the repository; --branch B, default the checked-out branch):
-          universe [--base REF]             each claim's axes, from the claims, the axes file and the generated axes
-          rows --claim C [--full]           a pairwise covering array over the claim's pairs not yet covered;
-                                            inside a capped round it refuses past the deadline or the claim cap
-          rows --probe P [--full]           writes P's rows file whole into the staging: a covering array over its
-                                            claim's pairs less those the claim's other probes have credited
-          status [--json]                   coverage from current evidence, open findings, done or not; per claim
-                                            its obligations and which have a seed
-          gaps [--base REF]                 what the corpus leaves out, each with its reason: unassigned settings,
-                                            refused shapes and values, what claims do not promise, out of reach, and
-                                            the wanted pairs no passing check of the last replay read both axes of
-          gate [--since REF] [--json]       the release gate (needs only the tracked corpus and a replay)
-          stale [--json] [--include-retired]   the probes a replay would run
-          identity --probe P                what a result of P is bound to
-          record-run --probe P --result pass|fail [--evidence F] [--seconds S]
-          footprint --probe P --cobertura F... --root WT [--include src] [--compile-time PATH...]
-          register --probe P --claim C --filter F [--variants JSON] [--seed PATCH] [--seed-env NAME=VALUE...] [--defect TEXT]
-                                            [--obligation O]: the seed (a patch, a toggle or both) into `seed`, or with
-                                            --obligation into `seeds`, in place of a seed naming O; refuses an O that
-                                            claim C does not list
-          publish | dismiss --id F --reason TEXT | mark retired --probe P
-          fix F --commit SHA [--reason TEXT]   records open finding F fixed at the commit (findings.jsonl); refuses
-                                            an id this ledger does not hold open and a commit the repository lacks
-          lock --holder H --mode replay|explore|full [--pid N] | unlock --holder H | heartbeat --holder H
-          round-start --holder H --minutes M [--claims N] | round-end --holder H | repair | abandon
-          merge --from DIR...               joins the states of a replay split by family (one DIR per leg) into
-                                            this one; refuses while a registered probe was in no leg
-
-        Writing a probe (into the branch's staging):
-          new --claim C [--probe P] [--family F]   stages P's skeleton (the claim's source and obligations quoted, one
-                                            check per obligation that throws until written), the claim's rows and P's
-                                            registry entry with no seed yet; P defaults to the claim's prefix and words
-                                            (C20-testing-shouldhold: C20TestingShouldholdProbe); refuses a claim not in
-                                            the claims, a name taken, a family that is not the claim's
-          try --probe P [--rows i,j,...] [--no-build]   builds once in the replay's worktree and runs P alone, every
-                                            variant or the rows given, printing how each row ended; records nothing,
-                                            holds the worktree from a replay, exits with the probe's exit code
-
-        Running probes:
-          replay [--all] [--family F] [--parallel N] [--no-footprint] [--holder H] [--dry-run] [--where]
-                                            replays the corpus with no model: the stale probes, or all; one family
-                                            of the replay configuration; N probe processes at a time (default:
-                                            the cores); without coverage or footprint, for a state nobody keeps
-          round explore|full [--minutes M] [--claims N] [--usd X]   a capped exploration round (local only)
-          seeds [--all] [--probe P] [--dry-run]   applies each probe's seeded defect in a scratch worktree, replays the
-                                            probe there and requires a violation it causes (local only, a build per
-                                            seed): the probes whose identity or footprint changed since every seed of
-                                            theirs was caught, or all of them, as a release runs it
-
-        State goes under PROBE_STATE_DIR when set (CI), else the main checkout's prober memory.
-        Exit codes: 0 done, 1 refused or failed, 2 usage, 3 this dll is stale; `try` exits with the probe's own.
-        """;
-
-    private static readonly HashSet<string> Flags = new(StringComparer.Ordinal)
-        { "json", "full", "all", "include-retired", "dry-run", "where", "no-footprint", "no-build" };
-
-    private static int Main(string[] args)
-    {
-        Console.OutputEncoding = new System.Text.UTF8Encoding(false);
-        if (args.Length == 0 || args[0] is "help" or "-h" or "--help") { Console.Write(Usage); return args.Length == 0 ? 2 : 0; }
-        var home = FindRoot(AppContext.BaseDirectory);
-        if (home is not null && SourceFingerprint.Difference(home) is { } stale)
-        {
-            Console.Error.WriteLine($"prober: this dll was built from other sources than the checkout holds ({stale}). Run `{SourceFingerprint.RebuildCommand}`.");
-            return SourceFingerprint.StaleExitCode;
-        }
-        return Run(Context.FromProcess(), args);
-    }
-
-    /// <summary>Runs one command against a context: the process's, or a test's.</summary>
-    public static int Run(Context ctx, string[] args)
-    {
-        try
-        {
-            var command = args[0];
-            var a = new Args(args[1..], Flags);
-            if (command == "replay") return Replay.Run(ctx, a);
-            if (command == "round") return Round.Run(ctx, a);
-            if (command == "seeds") return Seeds.Run(ctx, a);
-            if (command == "try") return TryProbe.Run(ctx, a);
-            var ledger = new Ledger(ctx, a.Get("branch"));
-            // Commands run under a round keep its lock alive.
-            if (command is not ("lock" or "unlock" or "abandon" or "heartbeat") && ctx.Env("PROBE_HOLDER") is { } holder)
-                RoundLock.Beat(ledger, holder);
-            return command switch
-            {
-                "universe" => Commands.UniverseCommand(ledger, a),
-                "rows" => Commands.Rows(ledger, a),
-                "status" => Commands.Status(ledger, a),
-                "gate" => Commands.Gate(ledger, a),
-                "stale" => Commands.Stale(ledger, a),
-                "identity" => Commands.IdentityCommand(ledger, a),
-                "record-run" => Commands.RecordRun(ledger, a),
-                "footprint" => Commands.Footprint(ledger, a),
-                "new" => NewProbe.Run(ledger, a),
-                "register" => Commands.Register(ledger, a),
-                "publish" => Commands.Publish(ledger, a),
-                "dismiss" => Commands.Dismiss(ledger, a),
-                "fix" => Commands.Fix(ledger, a),
-                "mark" => Commands.Mark(ledger, a),
-                "lock" => Commands.Lock(ledger, a),
-                "unlock" => Commands.Unlock(ledger, a),
-                "heartbeat" => Commands.HeartbeatCommand(ledger, a),
-                "owe-replay" => Commands.OweReplay(ledger, a),
-                "round-start" => Commands.RoundStart(ledger, a),
-                "round-end" => Commands.RoundEnd(ledger, a),
-                "repair" => Commands.Repair(ledger, a),
-                "abandon" => Commands.Abandon(ledger, a),
-                "merge" => Commands.Merge(ledger, a),
-                "gaps" => Commands.Gaps(ledger, a),
-                _ => throw new Refusal($"unknown command {command}; see `prober help`", 2),
-            };
-        }
-        catch (Refusal refusal)
-        {
-            ctx.Error.WriteLine("prober: " + refusal.Message);
-            return refusal.ExitCode;
-        }
-    }
-
-    private static string? FindRoot(string start)
-    {
-        for (var dir = new DirectoryInfo(start); dir is not null; dir = dir.Parent)
-            if (File.Exists(Path.Combine(dir.FullName, "CodoMetis.TypeKit.slnx"))) return dir.FullName;
-        return null;
-    }
-}
diff --git a/tools/Prober/README.md b/tools/Prober/README.md
deleted file mode 100644
index 3abf10f2..00000000
--- a/tools/Prober/README.md
+++ /dev/null
@@ -1,181 +0,0 @@
-# prober
-
-The probing workflow's core: the ledger of what the documents claim and what the probes have shown, the
-replay of the probe corpus, the release gate, and the capped exploration round. Repository tooling, not
-a package. It references the base class library only and is built with the solution.
-
-```text
-dotnet tools/Prober/bin/Release/net10.0/prober.dll help
-```
-
-## What runs where
-
-| Command | Model | Where |
-|---|---|---|
-| `replay [--all] [--family F] [--parallel N] [--no-footprint]` | none | anywhere, CI included: the probes whose identity or footprint changed, or all of them; one family of the replay configuration; N probe processes at a time (the cores by default); without coverage or a footprint, for a state nobody keeps (decision 101) |
-| `merge --from DIR...` | none | anywhere, CI included: joins the states of a replay split by family, and refuses while a registered probe was in no leg |
-| `gate [--since REF]` | none | anywhere, CI included: needs only the tracked corpus and a replay |
-| `status`, `stale`, `universe`, `rows [--claim C \| --probe P]`, … | none | anywhere |
-| `gaps [--base REF]` | none | anywhere: what the corpus leaves out, each with its recorded reason, and, from the last replay's evidence, each wanted pair no obligation wanting it has a passing check that read both its axes of (more rows cannot cover it); a report that decides nothing (decision 104) |
-| `fix F --commit SHA [--reason TEXT]` | none | anywhere: records an open finding fixed at a commit, the fixed line of the state's `findings.jsonl` as `finding-line.schema.json` wants it; it counts once the commit is in HEAD's history |
-| `new --claim C [--probe P] [--family F]` | none | anywhere: stages a probe's skeleton, its own rows and its registry entry with no seed yet, and prints what the writer still owes |
-| `try --probe P [--rows i,j,...] [--no-build]` | none | locally: builds once in the replay's worktree and runs that one probe, every row or the rows given; records nothing, and holds the worktree from a replay while it runs |
-| `round explore\|full` | the `prober` agent | locally only, under caps it cannot overrun |
-| `seeds [--all] [--probe P]` | none | locally only: one build per seed, in a scratch worktree (decision 100); the probes whose seeds identity or product footprint changed since every seed was caught, or all of them, as a release runs it (decision 107) |
-
-No command in the gate's path needs a login, an API key or a Claude executable. A gate obligation is met
-by a probe in the corpus, written by hand or by a round, or by a reviewed waiver in
-`tools/probe/corpus/waivers.json`.
-
-## Files
-
-The corpus is tracked under `tools/probe/corpus/`: claims, the probe registry, harness and probe sources,
-rows (gzipped), waivers and dismissed findings. State goes under `PROBE_STATE_DIR` when set (CI sets it),
-else the main checkout's `.claude/agent-memory-local/prober/`. Every file's shape is in `Schemas/`, versioned;
-a file or line without `schemaVersion` is version 1. `claims.json` is checked against its schema wherever it is
-read, and a field the schema does not have is refused with the claim and the field named; each `exclude` entry
-is a reason and its pairs, which `universe` prints beside the claim's narrowings. The JSON files the prober
-writes keep `+`, backticks and `<` literal, so a `publish` that changes nothing in a tracked file leaves it as
-it is (decision 102). The harness's generated declarations, `harness/*.g.cs`, are written by the file-based
-apps of `tools/probe/generators/` from the rows and the axes file, and `GeneratedHarnessTests` in the
-conventions tests holds each to its app's output (that directory's README).
-
-Rows are per probe: `rows/<probe>.json.gz`, one file for each registered probe, its claim inside (`claim`), so
-two probes of one claim (C07's `BaseProbe` and `C07BlanketMappingProbe`) each run rows of their own, and a
-probe's identity reads its own file only: a sibling's rows changing leaves it as it was. The probe's
-`Rows.Data("P")` names the file, and the replay, `try` and the identity read it. `rows --probe P` writes P's file
-whole into the staging, never appended: a covering array over its claim's pairs less those the claim's other
-probes have credited (P's own credit is not subtracted, since it came from the rows the file replaces), and
-`publish` moves it into the corpus by probe; `rows --claim C` only prints such an array. The stored rows are
-definitions, the evidence is in the state. `ProbeRowsTests` in the conventions tests refuses two rows of one
-file with the same axis map, a file whose `claim` is not in `claims.json` or is not its probe's, a file that
-names no registered probe, and a registered probe without a file.
-
-A registry entry may list `watched`: paths, files or directories, that the probe's result depends on and its
-footprint cannot see, since the footprint is what ran in the probe's own process under `src/` beside the
-`compileTimeFootprint` paths. A variant catalogue under `test/` compiled into the probes is one (C19 builds
-over the analyzer tests' `TypeArgumentSites` and `TypeArgumentKinds`), a build input a child process reads is
-another (C18's consumer build compiles against the base package and evaluates `src/Directory.Build.*`). The
-replay records each with its object id in the footprint line, a change to one stales the footprint like a path
-the probe ran, and the gate counts it as touching the probe's claim. A probe whose own process runs nothing under `src/`
-(C22 builds its consumer in a child process) is recorded by what its entry watches alone; where nothing ran and nothing
-is watched, `footprint` refuses to record an empty footprint, which would never go stale.
-
-The round lock, `round.lock` and its mutex, sits in the branch's directory (`branches/<branch>/`), beside
-everything a round or a replay writes, so rounds and replays of two branches run at once and two of one branch
-never do. The scratch worktrees, `wt` (the replay's), `seeds`, `explore` (the `prober` agent's) and `enumerate`,
-are per checkout: under `PROBE_CACHE_DIR` when set, else `~/.cache/probe-replay/<checkout>-<hash of its path>`,
-and `replay --where` prints them. So a linked worktree (`git worktree add`, as each session under
-`.claude/worktrees/` is) builds a warm copy of its own, about a gigabyte of disk, and two sessions never reset
-each other's copy; the main checkout keeps the directory it had before. Since the lock is per branch and the
-worktree per checkout, a replay also holds `replay.lock` beside them (an OS lock, gone with its process), and a
-replay of another branch in the same checkout, after a branch switch, is skipped while one runs. Removing a
-linked worktree leaves its cache behind: before you remove it, run there the `remove:` line that `replay --where`
-prints, which removes the cache's worktrees (`git worktree remove`) and then its directory, every path written out.
-
-A claim lists what it promises in `obligations`, each an id and a sentence quoted verbatim from the claim's
-source, and what it does not promise in `not-promised`, each an id and the sentence of the document or record
-that makes the difference intended, quoted from that source. `universe` checks every quote as it checks a
-narrowing's and refuses a sentence its document does not hold, or an id listed twice. A claim without
-`obligations` has one, the claim itself, under the id `claim`. `status` shows per claim its obligations and the
-ones no seed names, and `gaps` prints every not-promised entry and narrowing beside the settings no surface
-reaches, the refused shapes and values, and the axes file's `out-of-reach` surfaces (decision 104).
-
-An obligation may declare where it does not apply: `inapplicable`, each entry the claim's own axis values
-(`axes`) and a citation (`cite`: `not-promised:id` of the claim's list, `docs:file#anchor`, `fact:KB-NNN` or
-`record:NNNN`). A row holding every axis of a declaration at one of its values runs no check of that
-obligation: `Row.Check` records the check inapplicable with the cite before its body runs, for that check only.
-The replay stages the claims beside the rows (`claims.json` in the probe directory) for the harness's
-`Rows.Claim`, and a probe's identity takes its claim's declarations. A pair a declaration matches is not wanted
-by that obligation (`Claim.PairsWantedBy`); a pair no obligation wants is declared inapplicable: `universe`
-prints each claim's count with the citations, `gaps` lists them under a heading of their own, `status --json`
-gives `inapplicable_pairs` per claim, the covering generator never puts one in a row, and the gate leaves them
-out as it leaves out an exclusion. A claim's pairs stay its pairs. `universe` refuses a declaration whose axis
-or value the claim does not list, whose cite is malformed, or whose not-promised id the claim lacks.
-
-A pair of a claim's axes counts as covered only by evidence a replay recorded: a check that ended as a pass, in a
-row that was expected and executed, for the settings that actually applied, while the result's identity holds
-(the probe, every compiled corpus source, the rows, the axes file, the build environment, this tool's
-version and the schema version) and the product files the probe ran are unchanged. A row's checks
-(`Row.Check` in the harness) each name an obligation and a baseline and record the axes they read; a check is
-credited with those and the row's own (read outside any check), and a pair is never put together from two
-checks' axes. A row without checks is one check of the obligation `claim` with the row's category. Evidence is
-version 2 (`Schemas/evidence.schema.json`): the replay copies each row's `checks` beside its `applied` and
-`reasons`. `status --json` gives each obligation `current`, the pairs current checks naming it earned, and
-`passed`; the text line counts rows and checks by outcome and ends with the obligations no passing check named
-at the last replay (`K uncredited`).
-
-## Seeds
-
-Each probe's registry entry names a seeded product defect: a patch under `seeds/` against the product
-files (the replay's `include`), an environment toggle, or both, and the sentence `defect`. Where its claim
-lists obligations, the entry's `seeds` holds one such seed per obligation the probe checks, each naming it in
-`obligation`, and every listed obligation of a claim with probes has a seed in one of them (decision 104).
-`seeds` applies each seed on its own in the `seeds` worktree beside the replay's, builds, runs the probe
-and counts the seed caught only for a check that ends as a violation, with no harness error in it or in its
-row outside its checks (decision 103), in a row whose unseeded run had no violation of the same obligation; a
-seed naming an obligation is caught only by a check naming it, so a probe whose rows run no checks (each the
-one check `claim`) catches only seeds that name none. The unseeded rows come from the ledger where the probe's
-evidence is current, else from an unseeded run first. Nothing it runs is evidence; it
-writes `seeds-last.json` (`Schemas/seeds-run.schema.json`), one outcome per seed, reported as
-`P/<obligation>` where the seed names one. `register --obligation O --seed PATCH --defect TEXT` (or
-`--seed-env NAME=VALUE...` for a toggle) writes a seed into `seeds`, in place of any seed of the entry that
-names O, `seed` included, and refuses an O that the claim's entry in `claims.json` does not list; without
-`--obligation`, `--seed` and `--seed-env` set the one `seed`. No seed is written into the registry by hand.
-Without `--all`, `seeds` runs only the probes that changed since the run that caught every one of their seeds
-(design/adr/0107), as `replay` runs only the stale ones: a probe runs when its seeds identity (the probe's identity,
-its seeds and the content of their patches) differs from the one recorded, when the product footprint its last
-replay recorded or a file its seeds patch changed since the recorded commit, when no footprint is recorded, and when
-no run caught all its seeds. It prints each probe it runs or skips with the reason. `seeds-last.json` keeps, per probe,
-the identity and the commit of the run that caught them all, carried forward for the probes a run skips; a missed seed
-drops the probe's record, so it is never skipped next time. `--all` runs every probe whatever the record says, and a
-release runs it before the tag; `--probe P` runs P.
-A seed is not part of a probe's identity, neither `seed` nor `seeds`. Without a build,
-`Seeds.Problems`, which the prober tests run over the repository, refuses a probe without a seed, a seed that
-does not apply, a seed naming an obligation its claim does not list, and a listed obligation no seed names.
-
-## Writing a probe
-
-`new --claim C` starts one in the branch's staging, whose path it prints. It writes `probes/P.cs` in the form
-the corpus's probes have (`Rows.Data`, `[Theory, MemberData(nameof(Data))]`, `Rec.Run`), headed by the claim's
-source and each obligation's id and sentence, with one check per obligation that throws until it is written:
-the probe builds beside the others, and every row of it ends as a harness error, which fails the row, earns
-nothing and is never a seed's catch. It stages the probe's own rows, a covering array over its claim's pairs the
-claim's other probes have not covered, as `rows --probe P` writes them, and the registry entry with an empty
-`seeds`, so `seeds` and `Seeds.Problems` name the seed each obligation owes. P defaults to the claim id's
-prefix and words (`C20-testing-shouldhold` is `C20TestingShouldholdProbe`); it refuses a claim that is not in
-the claims, a name a probe has, and a claim whose first surface is in no family, or not in `--family`'s.
-
-Then fill each check and run `try --probe P` until each row ends as it should. It moves the replay's worktree
-to HEAD, overlays the corpus and the staging as the replay does, builds once through the adapter (not with
-`--no-build`), and runs P alone in each of its registry variants, or only the rows `--rows` names, through the
-harness's `PROBE_ROWS`, within the rows each variant's `PROBE_ONLY` selects. It prints each run's verdict line
-and how each row ended, and exits with the probe's code (1 when the build fails). It records no evidence,
-footprint or run and takes no round lock, but holds the replay's worktree (`replay.lock`) while it runs, so a try
-refuses while a replay of the checkout runs, and a replay skips while a try does. Then write a seed per
-obligation and register it with the command `new` printed for that obligation (`register --obligation O`,
-under "Seeds"), show each caught with `seeds --probe P`, and `publish`. `register` lints the staged sources
-first (below). A writer needs no build or sync script of their own.
-
-## Register and publish
-
-`register` and `publish` read the staged harness and probe sources first and refuse, by file and line, a
-`Note` whose first argument is not a `NoteKeys` member the corpus declares, a harness `Skip` whose finding
-is not a string literal naming a finding this ledger holds open (decision 103), and a check's `Inapplicable` or
-`Refused` whose first argument is not a `Cite` factory with a string literal, or names what does not exist: a
-not-promised entry the probe's claim does not list (any claim's, for a harness source no one probe owns), a docs
-file, a knowledge entry under `design/knowledge/`, a record under `design/adr/`. `ProbeCiteTests` in the
-conventions tests holds the same over the tracked corpus. The scan blanks out comments
-and string literals and reads text, since this tool references the base class library only.
-
-## The adapter
-
-Building the probes, running one probe in one process, and deriving the generated axes go through
-`IProbeAdapter` (`ProbeAdapter.cs`), configured by the `replay` object of `.claude/probe-axes.md`. The .NET
-adapter is the only one; the core holds nothing of .NET's, so another stack can plug in its own.
-
-## Freshness
-
-The dll hashes its own sources, the schemas among them, at build time and checks them at startup, as every
-tool does (`tools/Directory.Build.targets`): a changed, added or removed source makes it refuse with exit 3
-and name the command that rebuilds it, `dotnet build tools/Prober -c Release`. Content hashes, never times.
diff --git a/tools/Prober/ReleaseGate.cs b/tools/Prober/ReleaseGate.cs
deleted file mode 100644
index 42caea16..00000000
--- a/tools/Prober/ReleaseGate.cs
+++ /dev/null
@@ -1,100 +0,0 @@
-using System.Text.Json;
-using System.Text.Json.Nodes;
-
-namespace Prober;
-
-/// <summary>
-/// The release gate. It needs nothing but the tracked corpus and a replay: no model, no login, no local
-/// memory of a developer's machine. It refuses while the staging is unpublished, a finding is open or a row
-/// skips for one, a probe has not passed at its current identity and footprint, an expected row did not run, or a claim touched
-/// since the release has pairs no probe covers and no reviewed waiver. Touched is chosen conservatively: the
-/// claim's source document, its surfaces' source areas, the paths its probes watch or the build inputs changed; footprints only add.
-/// </summary>
-internal static class ReleaseGate
-{
-    private static readonly string[] BuildInputs = ["Directory.Packages.props", "Directory.Build.props", "global.json"];
-
-    public static int Run(Ledger l, string? sinceArg, bool json)
-    {
-        var since = sinceArg ?? Git.Out(l.Top, "describe", "--tags", "--abbrev=0");
-        var (universe, _) = Axes.Build(l, since);
-        var footprints = l.Footprints();
-        var reasons = new List<string>();
-        if (Directory.Exists(l.StagingDir) && Directory.EnumerateFiles(l.StagingDir, "*", SearchOption.AllDirectories).Any())
-            reasons.Add("the staging corpus is not published (run `publish` and commit tools/probe/corpus)");
-        var open = l.OpenFindings();
-        if (open.Count > 0) reasons.Add($"open findings: {string.Join(", ", open)}");
-
-        var runs = Files.ReadLines(l.P("runs.jsonl")).GroupBy(r => Files.Str(r["probe"]), StringComparer.Ordinal).ToDictionary(g => g.Key, g => g.Last(), StringComparer.Ordinal);
-        foreach (var s in l.ProbeStates(includeRetired: true))
-        {
-            if (s.Stale) { reasons.Add($"{s.Probe}: not replayed at its current identity and footprint (run `prober replay --all`)"); continue; }
-            if (Files.Str(runs.GetValueOrDefault(s.Probe)?["result"]) != "pass") { reasons.Add($"{s.Probe}: its last replay failed"); continue; }
-            var evidence = Files.ReadJson(l.EvidencePath(s.Probe)) as JsonObject;
-            var expected = new HashSet<int>(); var executed = new HashSet<int>();
-            foreach (var v in (evidence?["variants"] as JsonArray ?? []).OfType<JsonObject>())
-            {
-                foreach (var i in v["expected"] as JsonArray ?? []) expected.Add((int)Files.Num(i));
-                foreach (var i in v["executed"] as JsonArray ?? []) executed.Add((int)Files.Num(i));
-            }
-            expected.ExceptWith(executed);
-            if (expected.Count > 0) reasons.Add($"{s.Probe}: {expected.Count} expected row(s) did not run");
-            // A skip is an open finding the corpus itself records, so it binds where the ledger has none (CI).
-            foreach (var (finding, rows) in Ledger.FindingSkips(evidence))
-                reasons.Add($"{s.Probe}: {rows} row(s) skip for finding {finding}; fix it and remove the skip, or dismiss it");
-        }
-
-        var done = l.Covered(universe);
-        var byClaim = l.Registry().GroupBy(kv => Files.Str(kv.Value["claim"]), StringComparer.Ordinal).ToDictionary(g => g.Key, g => g.Select(kv => kv.Key).ToList(), StringComparer.Ordinal);
-        var changed = Git.Out(l.Top, "diff", "--name-only", since, "HEAD").Split('\n', StringSplitOptions.RemoveEmptyEntries);
-        bool Under(IEnumerable<string> paths) => paths.Any(w => changed.Any(f => f == w || f.StartsWith(w.TrimEnd('/') + "/", StringComparison.Ordinal)));
-
-        // A reviewed waiver meets an obligation without a probe; one without a reason or a reviewer meets nothing.
-        var waivers = (Files.ReadJson(l.CorpusPath("waivers.json")) as JsonArray ?? []).OfType<JsonObject>()
-            .Where(w => Files.Str(w["claim"]).Length > 0 && Files.Str(w["reason"]).Length > 0 && Files.Str(w["reviewed_by"]).Length > 0)
-            .Select(w => Files.Str(w["claim"])).ToHashSet(StringComparer.Ordinal);
-
-        var required = new List<string>(); var waived = new List<string>(); var missedByFootprint = new List<string>(); var footprintOnly = new List<string>();
-        var missingTotal = 0; var inapplicableTotal = 0;
-        foreach (var claim in universe.Claims)
-        {
-            var probes = byClaim.GetValueOrDefault(claim.Id) ?? [];
-            // What the claim's surfaces watch, and what its probes' registry entries watch beyond their footprints.
-            var conservative = Under([claim.Source.Split('#')[0]]) || Under(claim.Watched) || Under(probes.SelectMany(l.Watched)) || Under(BuildInputs);
-            var footprint = probes.Count > 0 && probes.Any(p => l.FootprintChangedSince(p, since, footprints));
-            if (probes.Count > 0 && conservative && !footprint) missedByFootprint.Add(claim.Id);
-            if (footprint && !conservative) footprintOnly.Add(claim.Id);
-            if (!(conservative || footprint)) continue;
-            if (waivers.Contains(claim.Id)) { waived.Add(claim.Id); continue; }
-            // The pairs some obligation wants; one no obligation wants is declared inapplicable and left out, as an exclusion is.
-            var pairs = claim.PairsWanted();
-            inapplicableTotal += claim.Pairs().Count - pairs.Count;
-            var missing = pairs.Count(p => !done.Contains((claim.Id, p)));
-            required.Add(claim.Id); missingTotal += missing;
-            if (missing > 0) reasons.Add($"{claim.Id}: {missing} of {pairs.Count} pairs uncovered (touched since {since})");
-        }
-
-        if (json)
-        {
-            l.Ctx.Out.WriteLine(new JsonObject
-            {
-                ["since"] = since, ["touched"] = new JsonArray([.. required.Select(x => (JsonNode)x)]), ["uncovered_pairs"] = missingTotal, ["inapplicable_pairs"] = inapplicableTotal,
-                ["reasons"] = new JsonArray([.. reasons.Select(x => (JsonNode)x)]),
-                ["selected_by_footprint_only"] = new JsonArray([.. footprintOnly.Select(x => (JsonNode)x)]),
-                ["waived"] = new JsonArray([.. waived.Select(x => (JsonNode)x)]),
-                ["missed_by_footprint_alone"] = new JsonArray([.. missedByFootprint.Select(x => (JsonNode)x)]), ["passes"] = reasons.Count == 0,
-            }.ToJsonString(new JsonSerializerOptions { WriteIndented = true }));
-            return reasons.Count == 0 ? 0 : 1;
-        }
-        if (reasons.Count > 0)
-        {
-            l.Ctx.Error.WriteLine($"probe gate: refused for {l.Branch} since {since} ({required.Count} claim(s) touched, {missingTotal} pair(s) uncovered):");
-            foreach (var r in reasons) l.Ctx.Error.WriteLine($"  {r}");
-            return 1;
-        }
-        l.Ctx.Out.WriteLine($"probe gate: {l.Branch} passes since {since}: {required.Count} claim(s) touched and fully covered" +
-                            (waived.Count > 0 ? $", {waived.Count} waived ({string.Join(", ", waived)})" : "") +
-                            ", every probe replayed and passing, no open finding.");
-        return 0;
-    }
-}
diff --git a/tools/Prober/Replay.cs b/tools/Prober/Replay.cs
deleted file mode 100644
index eba97a0f..00000000
--- a/tools/Prober/Replay.cs
+++ /dev/null
@@ -1,440 +0,0 @@
-using System.Diagnostics;
-using System.Globalization;
-using System.Security.Cryptography;
-using System.Text;
-using System.Text.Json.Nodes;
-
-namespace Prober;
-
-/// <summary>
-/// Replays the written probes with no model in the loop. Per commit it runs only the probes whose identity or
-/// footprint changed; <c>--all</c> runs every probe, retired ones included (the release run). Each probe runs
-/// once per process variant, and the replay records each probe in registry order whatever order the runs
-/// finished in: per-row evidence (rows expected, rows executed, each row's outcome and applied settings), the
-/// result, and the fresh footprint. <c>--no-footprint</c> runs without coverage and records no footprint, for a
-/// state nobody keeps (a pull request's); only then do the variants of every selected probe run
-/// <c>--parallel N</c> at a time (the machine's cores by default), since the coverage collector rewrites the
-/// assemblies on disk and two hosts from one output directory corrupt each other (KB-025).
-/// <c>--family F</c> replays the probes whose claim's first surface the
-/// replay configuration's <c>families</c> puts under F, so a matrix of jobs can split the corpus and
-/// <c>merge</c> join their states; it refuses while any probe's surface is in no family, so a matrix cannot
-/// quietly leave a probe out. It works in one warm worktree kept between runs and moved to HEAD without force,
-/// so only what changed is rebuilt. A dependency input that changed stales every probe, and the axes are
-/// derived again. Only one round runs at a time.
-/// </summary>
-internal static class Replay
-{
-    /// <summary>How this replay was asked to run, recorded in replay-last.json for <c>merge</c> to read.</summary>
-    internal sealed record Options(bool All, string? Family, int Parallel, bool Footprint);
-
-    public static int Run(Context ctx, Args a, IProbeAdapter? adapter = null)
-    {
-        var ledger = new Ledger(ctx, a.Get("branch"));
-        var config = ledger.AxesBlock()["replay"] as JsonObject ?? throw new Refusal("the axes file's block has no \"replay\" configuration");
-        adapter ??= new DotNetAdapter(config);
-        var home = Home(ctx, ledger);
-        if (a.Flag("where"))
-        {
-            ctx.Out.WriteLine($"replay:  {Path.Combine(home, "wt")}\nexplore: {Path.Combine(home, "explore")}\nseeds:   {Path.Combine(home, "seeds")}");
-            ctx.Out.WriteLine($"remove:  {RemoveCommand(home)}");
-            return 0;
-        }
-
-        // With a footprint the coverage collector instruments the assemblies on disk, so two hosts from one
-        // output directory corrupt each other (KB-025): one at a time, whatever --parallel says.
-        var footprint = !a.Flag("no-footprint");
-        var asked = Parallelism(a.Get("parallel"));
-        var options = new Options(a.Flag("all"), a.Get("family"), footprint ? 1 : asked, footprint);
-        var states = ledger.ProbeStates(options.All);
-        var scope = options.Family is null ? states : OfFamily(config, ledger, states, options.Family);
-        var todo = options.All ? scope : [.. scope.Where(s => s.Replay)];
-        var skipped = scope.Where(s => !todo.Contains(s)).Select(s => s.Probe).ToList();
-        var head = ledger.Head;
-        ctx.Out.WriteLine($"prober replay: {ledger.Branch} at {head[..7]}: {todo.Count} of {scope.Count} probes to replay" +
-                          $"{(options.Family is null ? "" : $" (family {options.Family})")}, " +
-                          (footprint ? "one at a time (the coverage collector rewrites the assemblies on disk)" : $"{options.Parallel} at a time, no footprint"));
-        if (a.Flag("dry-run")) { foreach (var s in todo) ctx.Out.WriteLine($"  {s.Probe}"); return 0; }
-
-        Directory.CreateDirectory(home);
-        var holder = a.Get("holder") ?? $"replay-{System.Environment.ProcessId}";
-        // Under a round's lock (--holder) the replay takes nothing: re-locking would tie the round's liveness to
-        // this shorter-lived process. On its own it locks with its own process as the owner.
-        if (a.Get("holder") is null && !RoundLock.Take(ledger, holder, "replay", System.Environment.ProcessId).Taken)
-        {
-            RoundLock.OweReplay(ledger);
-            ctx.Out.WriteLine($"prober replay: skipped, the ledger is locked by another round; its unlock will say a replay is owed");
-            return 0;
-        }
-        try
-        {
-            using var beat = new RoundLock.Heartbeat(ledger, holder);
-            using var held = HoldWorktree(home);
-            if (held is null)
-            {
-                ctx.Out.WriteLine($"prober replay: skipped, another branch's replay in this checkout is using {home}; run `prober replay` when it ends");
-                return 0;
-            }
-            var axes = Rederive(ledger, adapter, config, Path.Combine(home, "enumerate"), force: options.All);
-            if (axes is not null)
-            {
-                if (axes["error"] is { } error) ctx.Out.WriteLine($"  axes: {Files.Str(error)}");
-                else
-                {
-                    ctx.Out.WriteLine($"  axes: re-derived ({(axes["added"] as JsonArray)!.Count} added, {(axes["removed"] as JsonArray)!.Count} removed)");
-                    foreach (var x in Files.Strings(axes["added"])) ctx.Out.WriteLine($"    + {x}");
-                    foreach (var x in Files.Strings(axes["removed"])) ctx.Out.WriteLine($"    - {x}");
-                }
-            }
-            if (todo.Count == 0)
-            {
-                Summary(ledger, head, warmth: null, buildSeconds: 0, todo, skipped, failed: [], seconds: 0, axes, options);
-                return 0;
-            }
-            return Probes(ctx, ledger, adapter, config, home, Path.GetFullPath(a.Get("worktree") ?? Path.Combine(home, "wt")), head, todo, skipped, axes, options);
-        }
-        finally
-        {
-            if (a.Get("holder") is null) RoundLock.Release(ledger, holder);
-        }
-    }
-
-    /// <summary>How many probe processes run at once: <c>--parallel N</c>, else one per core.</summary>
-    internal static int Parallelism(string? given)
-    {
-        if (given is null) return Math.Max(1, System.Environment.ProcessorCount);
-        if (!int.TryParse(given, NumberStyles.Integer, CultureInfo.InvariantCulture, out var n) || n < 1) throw new Refusal("--parallel takes a whole number of 1 or more", 2);
-        return n;
-    }
-
-    /// <summary>
-    /// The probes of one family: those whose claim's first surface the replay configuration's <c>families</c>
-    /// (name to surfaces) puts under it. Every probe of the registry must have a family, or a matrix of jobs by
-    /// family would never run the one that has none; so this refuses for the whole registry, not only the family
-    /// asked for.
-    /// </summary>
-    internal static List<Ledger.ProbeState> OfFamily(JsonObject config, Ledger ledger, List<Ledger.ProbeState> states, string family)
-    {
-        var families = config["families"] as JsonObject ?? throw new Refusal("the replay configuration names no families; add \"families\" (a name to the surfaces it holds) to the axes file's replay block", 2);
-        if (families[family] is not JsonArray) throw new Refusal($"no family {family}; the replay configuration has {string.Join(", ", families.Select(kv => kv.Key))}", 2);
-        var bySurface = new Dictionary<string, string>(StringComparer.Ordinal);
-        foreach (var (name, surfaces) in families)
-            foreach (var surface in Files.Strings(surfaces))
-            {
-                if (bySurface.TryGetValue(surface, out var other) && other != name) throw new Refusal($"the surface {surface} is in two families, {other} and {name}", 2);
-                bySurface[surface] = name;
-            }
-        var firstSurface = ledger.Claims().ToDictionary(c => Files.Str(c["id"]), c => Files.Strings(c["surfaces"]).FirstOrDefault() ?? "", StringComparer.Ordinal);
-        var result = new List<Ledger.ProbeState>();
-        foreach (var s in states)
-        {
-            var surface = firstSurface.GetValueOrDefault(s.Claim) ?? "";
-            if (!bySurface.TryGetValue(surface, out var f))
-                throw new Refusal($"{s.Probe}: the first surface of its claim {s.Claim} ({(surface.Length > 0 ? surface : "none")}) is in no family of the replay configuration, so a replay by family would never run it");
-            if (f == family) result.Add(s);
-        }
-        return result;
-    }
-
-    /// <summary>Derives the generated axes again when a dependency input or the toolchain changed, or always when forced.</summary>
-    private static JsonObject? Rederive(Ledger ledger, IProbeAdapter adapter, JsonObject config, string work, bool force)
-    {
-        if (config["enumerate"] is not JsonObject enumerate) return null;
-        var stampInput = Files.Canonical(new JsonArray(
-            new JsonArray([.. Files.Strings(enumerate["inputs"]).Select(p => (JsonNode?)(Git.ObjectId(ledger.Top, p) ?? ""))]),
-            ledger.Toolchain().DeepClone()));
-        var stamp = Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(stampInput)));
-        var path = Path.Combine(ledger.Memory, "axes-generated.json");
-        var old = Files.ReadJson(path) as JsonObject ?? [];
-        if (!force && Files.Str(old["inputsStamp"]) == stamp) return null;
-        var (generated, error) = adapter.DeriveAxes(ledger.Top, work);
-        if (generated is null) return new JsonObject { ["error"] = error };
-        generated["inputsStamp"] = stamp;
-        static SortedSet<string> Settings(JsonObject o) =>
-            new((o["axes"] as JsonObject ?? []).SelectMany(kv => Files.Strings(kv.Value).Select(v => $"{kv.Key}={v}")).Concat(Files.Strings(o["needsValues"])), StringComparer.Ordinal);
-        var before = Settings(old); var after = Settings(generated);
-        Files.WriteJson(path, generated);
-        return new JsonObject
-        {
-            ["added"] = new JsonArray([.. after.Except(before, StringComparer.Ordinal).Select(x => (JsonNode)x)]),
-            ["removed"] = new JsonArray([.. before.Except(after, StringComparer.Ordinal).Select(x => (JsonNode)x)]),
-            ["versions"] = generated["versions"]?.DeepClone(),
-        };
-    }
-
-    /// <summary>One process variant of a probe, run: what it was asked, what it answered, and where its rows, coverage and logs went.</summary>
-    private sealed record VariantRun(JsonObject Variant, int Index, Ran Ran, double Seconds, string OutDir, string Coverage, string LogDir);
-
-    /// <summary>
-    /// Starts every variant of a probe, each on a thread of its own that waits its turn at the gate, so the
-    /// variants of all selected probes share the <c>--parallel</c> slots in the order they were started.
-    /// </summary>
-    private static List<Task<VariantRun>> Start(IProbeAdapter adapter, string worktree, string results, IReadOnlyDictionary<string, string?> environment,
-                                                Ledger.ProbeState s, SemaphoreSlim gate, bool coverage)
-    {
-        var pending = new List<Task<VariantRun>>();
-        var index = 0;
-        foreach (var variant in s.Variants.OfType<JsonObject>())
-        {
-            var i = index++;
-            var coverageFile = coverage ? $"{s.Probe}-{i}.cobertura.xml" : "";
-            var outDir = Path.Combine(results, $"{s.Probe}-{i}-rows");
-            // PROBE_LOG_DIR: where the run may leave its full logs; a failed run's are kept in the state.
-            var logDir = Path.Combine(results, $"{s.Probe}-{i}-log");
-            var env = new Dictionary<string, string?>(environment, StringComparer.Ordinal) { ["PROBE_OUT"] = outDir, ["PROBE_LOG_DIR"] = logDir };
-            foreach (var (k, v) in variant) env[k] = Files.Str(v);
-            pending.Add(Task.Factory.StartNew(() =>
-            {
-                gate.Wait();
-                try
-                {
-                    var clock = Stopwatch.StartNew();
-                    var ran = adapter.RunProbe(worktree, s.Filter, results, coverageFile, env);
-                    return new VariantRun(variant, i, ran, clock.Elapsed.TotalSeconds, outDir, coverageFile, logDir);
-                }
-                finally { gate.Release(); }
-            }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default));
-        }
-        return pending;
-    }
-
-    private static int Probes(Context ctx, Ledger ledger, IProbeAdapter adapter, JsonObject config, string home, string worktree, string head,
-                              List<Ledger.ProbeState> todo, List<string> skipped, JsonObject? axes, Options options)
-    {
-        var clock = Stopwatch.StartNew();
-        var warmth = ProbeRun.Ready(ledger, worktree, head);
-        var probeDir = Overlay(ledger, config, worktree);
-        var environment = ProbeRun.Environment(ctx, adapter, home);
-        var results = Directory.CreateTempSubdirectory("prober-replay-").FullName;
-
-        var buildClock = Stopwatch.StartNew();
-        var build = adapter.Build(worktree, environment);
-        var buildSeconds = buildClock.Elapsed.TotalSeconds;
-        ctx.Out.WriteLine($"  build ({warmth}): {buildSeconds.ToString("F1", CultureInfo.InvariantCulture)} s, {FirstLine(build)}");
-        if (build.ExitCode != 0) { ctx.Out.WriteLine(build.Stdout); return 2; }
-
-        // Every variant of every probe is started now and runs when a slot frees; the probes are then read,
-        // reported and recorded one by one in registry order, each once all its variants have ended.
-        using var gate = new SemaphoreSlim(options.Parallel);
-        var started = todo.Select(s => Start(adapter, worktree, results, environment, s, gate, options.Footprint)).ToList();
-
-        var failed = new List<string>();
-        foreach (var (s, pending) in todo.Zip(started))
-        {
-            var variants = pending.Select(t => t.GetAwaiter().GetResult()).OrderBy(v => v.Index).ToList();
-            var probeRows = Files.ReadRows(Path.Combine(probeDir, "rows", s.Probe + ".json"));
-            var evidence = new JsonObject { ["variants"] = new JsonArray(), ["rows"] = new JsonObject() };
-            var result = "pass"; var seconds = 0.0; var reports = new List<string>();
-            foreach (var v in variants)
-            {
-                seconds += v.Seconds;
-                var label = v.Variant.Count > 0 ? " [" + string.Join(", ", v.Variant.Select(kv => $"{kv.Key}={Files.Str(kv.Value)}")) + "]" : "";
-                ctx.Out.WriteLine($"  {s.Probe}{label}: {FirstLine(v.Ran)} ({v.Seconds.ToString("F1", CultureInfo.InvariantCulture)} s)");
-                if (v.Ran.ExitCode != 0) { result = "fail"; ctx.Out.WriteLine(string.Join('\n', v.Ran.Stdout.Split('\n').Skip(1).Take(11))); }
-                // A failed run's full logs, kept under the state's logs/ for triage: in CI the state is the artifact.
-                if (v.Ran.ExitCode != 0 && Directory.Exists(v.LogDir))
-                    foreach (var file in Directory.EnumerateFiles(v.LogDir))
-                    {
-                        var kept = ledger.P(Path.Combine("logs", $"{s.Probe}-{v.Index}-{Path.GetFileName(file)}"));
-                        Directory.CreateDirectory(Path.GetDirectoryName(kept)!);
-                        File.Copy(file, kept, overwrite: true);
-                        ctx.Out.WriteLine($"    log: {kept}");
-                    }
-                if (v.Coverage.Length > 0) reports.AddRange(Directory.EnumerateFiles(results, v.Coverage, SearchOption.AllDirectories));
-
-                // Execution evidence: the rows this variant should run, the rows it did, how each ended and the
-                // settings that applied. A row missing here, or recorded without its settings, earns nothing.
-                var only = Files.Str(v.Variant["PROBE_ONLY"]);
-                var expected = new JsonArray(); var executed = new SortedSet<int>();
-                for (var i = 0; i < probeRows.Count; i++)
-                    if (Selected(Files.StringMap(probeRows[i]?["row"] ?? probeRows[i]), only)) expected.Add(i);
-                if (Directory.Exists(v.OutDir))
-                    foreach (var file in Directory.EnumerateFiles(v.OutDir, "*.jsonl"))
-                        foreach (var line in Files.ReadLines(file))
-                        {
-                            var idx = (int)Files.Num(line["idx"]);
-                            executed.Add(idx);
-                            (evidence["rows"] as JsonObject)![idx.ToString(CultureInfo.InvariantCulture)] = EvidenceRow(line);
-                        }
-                (evidence["variants"] as JsonArray)!.Add(new JsonObject
-                {
-                    ["env"] = v.Variant.DeepClone(), ["expected"] = expected, ["executed"] = new JsonArray([.. executed.Select(x => (JsonNode)x)]),
-                });
-                var missing = expected.Select(x => (int)Files.Num(x)).Where(x => !executed.Contains(x)).ToList();
-                if (missing.Count > 0) ctx.Out.WriteLine($"    {missing.Count} expected row(s) did not run: [{string.Join(", ", missing.Take(10))}]");
-            }
-            foreach (var stale in ledger.StaleSkips(evidence)) { result = "fail"; ctx.Out.WriteLine($"    {stale}"); }
-            if (result == "fail") failed.Add(s.Probe);
-            var evidencePath = Path.Combine(results, $"{s.Probe}-evidence.json");
-            Files.WriteJson(evidencePath, evidence);
-            var categories = (evidence["rows"] as JsonObject)!.GroupBy(kv => Files.Str(kv.Value!["category"]), StringComparer.Ordinal)
-                                                               .OrderBy(g => g.Key, StringComparer.Ordinal).Select(g => $"{g.Key} {g.Count()}");
-            // Checks beside rows, once a row of the probe ran any: until then every row is its one check and the line says nothing more.
-            var checks = (evidence["rows"] as JsonObject)!.Any(kv => kv.Value?["checks"] is JsonArray { Count: > 0 })
-                ? "; checks: " + string.Join(", ", Ledger.CheckOutcomes(evidence).Select(kv => $"{kv.Key} {kv.Value}")) : "";
-            ctx.Out.WriteLine("    outcomes: " + string.Join(", ", categories) + checks);
-            var record = new StringWriter();
-            Program.Run(new Context(ledger.Top, ctx.Environment, record, ctx.Error),
-                ["record-run", "--branch", ledger.Branch, "--probe", s.Probe, "--result", result,
-                 "--seconds", seconds.ToString("F1", CultureInfo.InvariantCulture), "--evidence", evidencePath]);
-            if (record.ToString().Trim() is { Length: > 0 } said) ctx.Out.WriteLine("    " + said);
-            // The footprint is what ran, pass or fail: a probe failing for an open finding is skipped like any
-            // other until its footprint changes (a fix touches it). Without one the probe stays stale, which is
-            // right for a state nobody keeps.
-            if (!options.Footprint) ctx.Out.WriteLine("    footprint: not recorded (--no-footprint)");
-            else if (reports.Count > 0)
-            {
-                var fp = new StringWriter(); var fpError = new StringWriter();
-                Program.Run(new Context(ledger.Top, ctx.Environment, fp, fpError),
-                    ["footprint", "--branch", ledger.Branch, "--probe", s.Probe, "--root", worktree, "--cobertura", .. reports,
-                     "--include", .. (Files.Strings(config["include"]).ToArray() is { Length: > 0 } inc ? inc : ["src"]),
-                     "--compile-time", .. Files.Strings(config["compileTimeFootprint"])]);
-                ctx.Out.WriteLine($"    footprint: {(fp.ToString() + fpError.ToString()).Trim()}");
-            }
-            else ctx.Error.WriteLine("    footprint: no coverage report found; the probe stays stale");
-        }
-
-        Summary(ledger, head, warmth, buildSeconds, todo, skipped, failed, clock.Elapsed.TotalSeconds, axes, options);
-        ctx.Out.WriteLine($"prober replay: {todo.Count - failed.Count} passed, {failed.Count} failed, {clock.Elapsed.TotalSeconds.ToString("F1", CultureInfo.InvariantCulture)} s in all");
-        try { Directory.Delete(results, recursive: true); } catch (IOException) { }
-        return failed.Count > 0 ? 1 : 0;
-    }
-
-    /// <summary>
-    /// replay-last.json: what this replay did, and how it was asked to run. <c>selected</c> and <c>skipped</c>
-    /// together are the probes in its scope (its family, or all), so <c>merge</c> can tell a probe no leg saw.
-    /// </summary>
-    private static void Summary(Ledger ledger, string head, string? warmth, double buildSeconds, List<Ledger.ProbeState> todo, List<string> skipped,
-                                List<string> failed, double seconds, JsonObject? axes, Options options)
-    {
-        static JsonArray Names(IEnumerable<string> names) => new([.. names.Select(x => (JsonNode)x)]);
-        Files.WriteJson(ledger.P("replay-last.json"), new JsonObject
-        {
-            ["branch"] = ledger.Branch, ["commit"] = head, ["build"] = warmth, ["build_seconds"] = Math.Round(buildSeconds, 1),
-            ["replayed"] = todo.Count, ["failed"] = Names(failed), ["seconds"] = Math.Round(seconds, 1), ["axes"] = axes?.DeepClone(),
-            ["all"] = options.All, ["family"] = options.Family, ["parallel"] = options.Parallel, ["footprint"] = options.Footprint,
-            ["selected"] = Names(todo.Select(s => s.Probe)), ["skipped"] = Names(skipped),
-        });
-    }
-
-    /// <summary>
-    /// The cache directory of this checkout's scratch worktrees (<c>wt</c>, <c>seeds</c>, <c>explore</c>, <c>enumerate</c>) under
-    /// PROBE_CACHE_DIR, else ~/.cache/probe-replay: the checkout's directory name and a hash of its path. A linked worktree
-    /// has one of its own, so sessions in two checkouts never reset each other's copy; the main checkout is keyed on
-    /// <see cref="Ledger.Root"/>, as it was before, so its warm copy stays where it is.
-    /// </summary>
-    internal static string Home(Context ctx, Ledger ledger)
-    {
-        var checkout = ledger.Linked ? ledger.Top : ledger.Root;
-        var key = Convert.ToHexStringLower(SHA1.HashData(Encoding.UTF8.GetBytes(checkout)))[..8];
-        return Path.Combine(ctx.Env("PROBE_CACHE_DIR") ?? Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.UserProfile), ".cache", "probe-replay"),
-                            $"{Path.GetFileName(checkout)}-{key}");
-    }
-
-    /// <summary>
-    /// The command that removes this checkout's cache, its worktrees first (for <c>git worktree list</c>) and then the
-    /// directory, every path literal: removing a linked worktree leaves its cache behind.
-    /// </summary>
-    internal static string RemoveCommand(string home)
-    {
-        // Forward slashes on Windows, which git and the sh of Git for Windows both read.
-        static string Quoted(string path) => "'" + (Path.DirectorySeparatorChar == '\\' ? path.Replace('\\', '/') : path).Replace("'", "'\\''") + "'";
-        var worktrees = new[] { "wt", "seeds", "explore" }.Select(w => Path.Combine(home, w)).Where(w => File.Exists(Path.Combine(w, ".git")));
-        return string.Join("; ", worktrees.Select(w => $"git worktree remove --force {Quoted(w)}").Append($"rm -rf {Quoted(home)}"));
-    }
-
-    /// <summary>
-    /// Holds this checkout's replay worktree for one replay: the lock is per branch, the worktree per checkout, so two
-    /// branches' replays in one checkout (a branch switched while the post-commit replay runs) would otherwise share it.
-    /// An OS lock on <c>replay.lock</c> beside it, released by the OS when its process ends; null when another holds it.
-    /// </summary>
-    internal static FileStream? HoldWorktree(string home)
-    {
-        Directory.CreateDirectory(home);
-        try { return new FileStream(Path.Combine(home, "replay.lock"), FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None); }
-        catch (IOException) { return null; }
-    }
-
-    /// <summary>
-    /// Copies the corpus into the worktree's probe directory: tracked, overlaid by the branch's unpublished staging; rows
-    /// unpacked, one file per probe, and a rows file the corpus no longer has removed; and the claims as claims.json,
-    /// whose declarations of where an obligation does not apply the harness reads.
-    /// </summary>
-    internal static string Overlay(Ledger ledger, JsonObject config, string worktree)
-    {
-        var probeDir = Path.Combine(worktree, Files.Str(config["probeDir"]));
-        Directory.CreateDirectory(Path.Combine(probeDir, "rows"));
-        var wanted = new SortedDictionary<string, string>(StringComparer.Ordinal);
-        var rows = new SortedDictionary<string, string>(StringComparer.Ordinal);
-        foreach (var source in new[] { ledger.CorpusDir, ledger.StagingDir })
-        {
-            foreach (var sub in new[] { "harness", "probes" })
-                if (Directory.Exists(Path.Combine(source, sub)))
-                    foreach (var f in Directory.EnumerateFiles(Path.Combine(source, sub), "*.cs")) wanted[Path.GetFileName(f)] = f;
-            if (Directory.Exists(Path.Combine(source, "rows")))
-                foreach (var f in Directory.EnumerateFiles(Path.Combine(source, "rows")).Where(f => f.EndsWith(".json", StringComparison.Ordinal) || f.EndsWith(".json.gz", StringComparison.Ordinal)))
-                    rows[Path.GetFileName(f).Replace(".gz", "", StringComparison.Ordinal)] = f;
-        }
-        foreach (var existing in Directory.EnumerateFiles(probeDir)) if (!wanted.ContainsKey(Path.GetFileName(existing)) && Path.GetFileName(existing) != "claims.json") File.Delete(existing);
-        foreach (var existing in Directory.EnumerateFiles(Path.Combine(probeDir, "rows"))) if (!rows.ContainsKey(Path.GetFileName(existing))) File.Delete(existing);
-        foreach (var (name, src) in wanted)
-        {
-            var dst = Path.Combine(probeDir, name);
-            if (!File.Exists(dst) || !File.ReadAllBytes(dst).AsSpan().SequenceEqual(File.ReadAllBytes(src))) File.Copy(src, dst, overwrite: true);
-        }
-        foreach (var (name, src) in rows)
-        {
-            var data = src.EndsWith(".gz", StringComparison.Ordinal) ? Files.Gunzip(src) : File.ReadAllBytes(src);
-            var dst = Path.Combine(probeDir, "rows", name);
-            if (!File.Exists(dst) || !File.ReadAllBytes(dst).AsSpan().SequenceEqual(data)) File.WriteAllBytes(dst, data);
-        }
-        // The claims beside the rows, the corpus's with the staging's over them: the harness's Rows.Claim reads each
-        // obligation's declarations from here, so Row.Check skips a check where its claim declares it inapplicable.
-        var claims = Path.Combine(probeDir, "claims.json");
-        var text = new JsonArray([.. ledger.Claims().Select(c => (JsonNode)c)]).ToJsonString();
-        if (!File.Exists(claims) || File.ReadAllText(claims) != text) File.WriteAllText(claims, text);
-        return probeDir;
-    }
-
-    /// <summary>
-    /// One row of the harness's jsonl as evidence keeps it: its category, the settings that applied, six reasons, the
-    /// findings it skipped for, and each check it ran with the same fields (obligation, baseline, category, its own
-    /// settings, six reasons, notes). A row that ran no check keeps no <c>checks</c>.
-    /// </summary>
-    internal static JsonObject EvidenceRow(JsonObject line)
-    {
-        static JsonArray Six(JsonNode? reasons) => new([.. Files.Strings(reasons).Take(6).Select(x => (JsonNode)x)]);
-        var row = new JsonObject
-        {
-            ["category"] = Files.Str(line["category"], "violation"), ["applied"] = line["applied"]?.DeepClone() ?? new JsonObject(),
-            ["reasons"] = Six(line["reasons"]),
-            ["findings"] = new JsonArray([.. Files.Strings(line["findings"]).Select(x => (JsonNode)x)]),
-        };
-        if (line["checks"] is JsonArray checks && checks.Count > 0)
-            row["checks"] = new JsonArray([.. checks.OfType<JsonObject>().Select(c => (JsonNode)new JsonObject
-            {
-                ["obligation"] = Files.Str(c["obligation"]), ["baseline"] = c["baseline"] is JsonValue b ? Files.Str(b) : null,
-                ["category"] = Files.Str(c["category"], "violation"), ["applied"] = c["applied"]?.DeepClone() ?? new JsonObject(),
-                ["reasons"] = Six(c["reasons"]), ["notes"] = Files.Str(c["notes"]),
-            })]);
-        return row;
-    }
-
-    /// <summary>The harness's PROBE_ONLY filter, replicated: the rows a variant is expected to run.</summary>
-    internal static bool Selected(IReadOnlyDictionary<string, string> row, string only)
-    {
-        if (only.Length == 0) return true;
-        foreach (var condition in only.Split(','))
-        {
-            var neq = condition.IndexOf("!=", StringComparison.Ordinal);
-            if (neq >= 0) { if (row.TryGetValue(condition[..neq], out var v) && v == condition[(neq + 2)..]) return false; }
-            else
-            {
-                var eq = condition.IndexOf('=');
-                if (!row.TryGetValue(condition[..eq], out var v) || v != condition[(eq + 1)..]) return false;
-            }
-        }
-        return true;
-    }
-
-    private static string FirstLine(Ran ran) => ProbeRun.FirstLine(ran);
-}
diff --git a/tools/Prober/Round.cs b/tools/Prober/Round.cs
deleted file mode 100644
index 9bbf4057..00000000
--- a/tools/Prober/Round.cs
+++ /dev/null
@@ -1,123 +0,0 @@
-using System.Diagnostics;
-using System.Globalization;
-using System.Text.Json;
-using System.Text.Json.Nodes;
-
-namespace Prober;
-
-/// <summary>
-/// One exploration round (explore or full) under caps the model cannot overrun, run locally only: never in
-/// CI, which needs no model. The wall clock is enforced here (the process tree is stopped at the deadline
-/// plus a grace), the claim cap and the deadline by `rows`, which refuses new work, and the spend by
-/// `--max-budget-usd`. The round always ends cleanly: partial lines repaired, caps cleared, lock released.
-/// </summary>
-internal static class Round
-{
-    public static int Run(Context ctx, Args a)
-    {
-        var mode = a.Positional.FirstOrDefault() ?? throw new Refusal("round takes explore or full", 2);
-        if (mode is not ("explore" or "full")) throw new Refusal("round takes explore or full", 2);
-        var minutes = a.Get("minutes") is { Length: > 0 } m ? double.Parse(m, CultureInfo.InvariantCulture) : mode == "explore" ? 10 : 30;
-        int? claims = a.Get("claims") is { Length: > 0 } c ? int.Parse(c, CultureInfo.InvariantCulture) : mode == "explore" ? 2 : null;
-        var grace = double.Parse(ctx.Env("PROBE_GRACE") ?? "60", CultureInfo.InvariantCulture);
-        var ledger = new Ledger(ctx, a.Get("branch"));
-        var holder = $"round-{mode}-{System.Environment.ProcessId}";
-
-        if (!RoundLock.Take(ledger, holder, mode, System.Environment.ProcessId).Taken)
-        {
-            ctx.Out.WriteLine("prober round: the ledger is locked by another round");
-            return 1;
-        }
-        var clock = Stopwatch.StartNew();
-        string outcome = "completed"; int? exit = null; JsonObject usage = []; var report = "";
-        string roundEnded = "", repaired = "", unlocked;
-        try
-        {
-            Program.Run(new Context(ledger.Top, ctx.Environment, TextWriter.Null, ctx.Error),
-                ["round-start", "--branch", ledger.Branch, "--holder", holder, "--minutes", minutes.ToString(CultureInfo.InvariantCulture),
-                 .. (claims is { } n ? new[] { "--claims", n.ToString(CultureInfo.InvariantCulture) } : [])]);
-            var caps = $"{minutes.ToString(CultureInfo.InvariantCulture)} minutes" + (claims is { } k ? $" and {k} claim(s)" : "");
-            var prompt =
-                $"Mode: {mode}. Repository {ledger.Top}, branch {ledger.Branch}, base {a.Get("base") ?? "main"}.\n" +
-                $"This round runs under caps enforced outside you ({caps}). The round runner holds the lock as `{holder}`: do not lock, " +
-                $"unlock or start a round yourself, and pass `--holder {holder}` to `prober replay`. `prober rows` refuses new work once " +
-                "the time is spent or the claim cap is reached; when it refuses, start nothing new: record what ran, hand the corpus off " +
-                "to staging, and report. The process is stopped at the deadline whatever you are doing, so record each claim's results " +
-                "as soon as its rows have run.";
-            var argv = new List<string> { "-p", prompt, "--agent", "prober", "--permission-mode", "auto", "--output-format", "json" };
-            if (a.Get("usd") is { Length: > 0 } usd) argv.AddRange(["--max-budget-usd", usd]);
-            var env = new Dictionary<string, string?>(ctx.Environment, StringComparer.Ordinal) { ["PROBE_HOLDER"] = holder };
-
-            using (new RoundLock.Heartbeat(ledger, holder))
-            {
-                var ran = Proc.Run(FindClaude(ctx), argv, ledger.Top, env, TimeSpan.FromSeconds(minutes * 60 + grace));
-                exit = ran.ExitCode;
-                if (ran.ExitCode == -1) outcome = "stopped at the cap";
-                else
-                {
-                    try
-                    {
-                        if (JsonNode.Parse(ran.Stdout) is JsonObject result)
-                        {
-                            foreach (var key in new[] { "total_cost_usd", "num_turns", "duration_ms", "usage", "subtype" }) usage[key] = result[key]?.DeepClone();
-                            report = Files.Str(result["result"]);
-                        }
-                    }
-                    catch (JsonException) { report = ran.Stdout.Length > 4000 ? ran.Stdout[^4000..] : ran.Stdout; }
-                    if (ran.ExitCode != 0) outcome = "failed";
-                    if ((ran.Stdout + ran.Stderr).Contains("Not logged in", StringComparison.Ordinal))
-                    {
-                        outcome = "not logged in";
-                        report = "The headless claude CLI is not authenticated. Log it in once (`claude`, then /login, or ANTHROPIC_API_KEY), or start the round from a Claude session with the /probe skill, which caps it with `prober round-start` and stops it at the deadline.";
-                    }
-                }
-            }
-        }
-        catch (System.ComponentModel.Win32Exception)
-        {
-            outcome = "no claude executable"; report = "No claude executable was found; set CLAUDE_BIN. Exploration needs a model and runs locally only.";
-        }
-        finally
-        {
-            var w = new StringWriter();
-            Program.Run(new Context(ledger.Top, ctx.Environment, w, ctx.Error), ["repair", "--branch", ledger.Branch]); repaired = w.ToString().Trim();
-            w = new StringWriter();
-            Program.Run(new Context(ledger.Top, ctx.Environment, w, ctx.Error), ["round-end", "--branch", ledger.Branch, "--holder", holder]); roundEnded = w.ToString().Trim();
-            w = new StringWriter();
-            Program.Run(new Context(ledger.Top, ctx.Environment, w, ctx.Error), ["unlock", "--branch", ledger.Branch, "--holder", holder]); unlocked = w.ToString().Trim();
-        }
-        if (unlocked.Contains("replay was skipped", StringComparison.Ordinal))
-            Replay.Run(new Context(ledger.Top, ctx.Environment, TextWriter.Null, ctx.Error), new Args(["--branch", ledger.Branch], new HashSet<string>(StringComparer.Ordinal)));
-        var status = new StringWriter();
-        Program.Run(new Context(ledger.Top, ctx.Environment, status, ctx.Error), ["status", "--branch", ledger.Branch]);
-        var summary = new JsonObject
-        {
-            ["mode"] = mode, ["branch"] = ledger.Branch,
-            ["caps"] = new JsonObject { ["minutes"] = minutes, ["claims"] = claims, ["usd"] = a.Get("usd") },
-            ["outcome"] = outcome, ["exit"] = exit, ["seconds"] = Math.Round(clock.Elapsed.TotalSeconds, 1), ["usage"] = usage,
-            ["round"] = roundEnded, ["repair"] = repaired, ["status"] = status.ToString().Split('\n')[0].Trim(),
-        };
-        var full = (JsonObject)summary.DeepClone(); full["report"] = report;
-        Files.WriteJson(ledger.P("round-last.json"), full);
-        ctx.Out.WriteLine(summary.ToJsonString(new JsonSerializerOptions { WriteIndented = true }));
-        if (report.Length > 0) ctx.Out.WriteLine("\n" + report);
-        return outcome == "completed" ? 0 : 1;
-    }
-
-    /// <summary>$CLAUDE_BIN, else claude on PATH, else the desktop app's bundled copy.</summary>
-    private static string FindClaude(Context ctx)
-    {
-        if (ctx.Env("CLAUDE_BIN") is { } bin) return bin;
-        foreach (var dir in (ctx.Env("PATH") ?? "").Split(Path.PathSeparator))
-            foreach (var name in new[] { "claude", "claude.exe" })
-                if (dir.Length > 0 && File.Exists(Path.Combine(dir, name))) return Path.Combine(dir, name);
-        var bundled = Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.UserProfile), "Library", "Application Support", "Claude", "claude-code");
-        if (Directory.Exists(bundled))
-        {
-            var found = Directory.EnumerateFiles(bundled, "claude", SearchOption.AllDirectories)
-                                 .Where(p => p.Contains("Contents/MacOS", StringComparison.Ordinal)).Order(StringComparer.Ordinal).LastOrDefault();
-            if (found is not null) return found;
-        }
-        throw new System.ComponentModel.Win32Exception("no claude executable");
-    }
-}
diff --git a/tools/Prober/RoundLock.cs b/tools/Prober/RoundLock.cs
deleted file mode 100644
index e3e16831..00000000
--- a/tools/Prober/RoundLock.cs
+++ /dev/null
@@ -1,133 +0,0 @@
-using System.Text.Json.Nodes;
-
-namespace Prober;
-
-/// <summary>
-/// One round at a time per branch. The lock file sits in the branch's directory (<c>branches/&lt;branch&gt;/round.lock</c>),
-/// beside everything a round or a replay writes, so two branches' rounds may run at once and two of one branch never do.
-/// It is created exclusively, with its holder's owner and a heartbeat inside; a holder is alive while its heartbeat is
-/// younger than <see cref="HeartbeatMinutes"/>. Liveness is the heartbeat alone (no process is probed, no signal sent),
-/// which is the same on every OS. Every read-judge-write of the lock runs under an exclusive file create (the mutex), so
-/// two takers can never both see it free, or both take over a holder whose heartbeat stopped.
-/// </summary>
-internal static class RoundLock
-{
-    public const int HeartbeatMinutes = 20;
-    public static readonly TimeSpan BeatEvery = TimeSpan.FromSeconds(30);
-    private const int MutexStaleSeconds = 60;
-
-    public static string LockPath(Ledger l) => Path.Combine(l.Dir, "round.lock");
-
-    public static double Now() => DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() / 1000.0;
-
-    public static bool Alive(JsonObject held) =>
-        Now() - Files.Num(held["heartbeat"], Files.Num(held["since"])) < HeartbeatMinutes * 60;
-
-    public static JsonObject? Holder(Ledger l) => Files.ReadJson(LockPath(l)) is JsonObject held && Alive(held) ? held : null;
-
-    /// <summary>
-    /// The mutex: a file created with <see cref="FileMode.CreateNew"/>, which fails when it exists, atomically
-    /// on every OS. A crashed writer's mutex goes stale after a minute and is removed.
-    /// </summary>
-    public static T WithMutex<T>(Ledger l, Func<T> body)
-    {
-        Directory.CreateDirectory(l.Dir);
-        var path = LockPath(l) + ".mutex";
-        var deadline = DateTime.UtcNow.AddSeconds(10);
-        while (true)
-        {
-            try
-            {
-                using (new FileStream(path, FileMode.CreateNew, FileAccess.Write, FileShare.None)) { }
-                break;
-            }
-            catch (Exception busy) when (busy is IOException or UnauthorizedAccessException)
-            {
-                // It exists (or vanished an instant ago, when its holder released it): either way, look again.
-                // Windows says UnauthorizedAccess, not IOException, for a name whose file is being deleted.
-                try
-                {
-                    if (File.Exists(path) && (DateTime.UtcNow - File.GetLastWriteTimeUtc(path)).TotalSeconds > MutexStaleSeconds) File.Delete(path);
-                }
-                catch (Exception gone) when (gone is IOException or UnauthorizedAccessException) { }
-                if (DateTime.UtcNow > deadline) throw new Refusal("the lock's mutex is held for over 10 s; another command is stuck");
-                Thread.Sleep(Random.Shared.Next(5, 25));
-            }
-        }
-        try { return body(); }
-        finally { try { File.Delete(path); } catch (Exception e) when (e is IOException or UnauthorizedAccessException) { } }
-    }
-
-    public static void WithMutex(Ledger l, Action body) => WithMutex(l, () => { body(); return 0; });
-
-    public static (bool Taken, JsonObject? Previous) Take(Ledger l, string holder, string mode, long? pid)
-    {
-        var now = Now();
-        var record = new JsonObject
-        {
-            ["schemaVersion"] = Files.SchemaVersion, ["holder"] = holder, ["mode"] = mode,
-            ["owner"] = new JsonObject { ["pid"] = pid ?? Environment.ProcessId, ["host"] = Environment.MachineName },
-            ["since"] = now, ["heartbeat"] = now, ["pending_replay"] = false,
-        };
-        return WithMutex(l, () =>
-        {
-            var held = Files.ReadJson(LockPath(l)) as JsonObject;
-            if (held is not null && Files.Str(held["holder"]) != holder && Alive(held)) return (false, held);
-            if (held is not null)
-            {
-                record["pending_replay"] = held["pending_replay"] is JsonValue p && p.TryGetValue<bool>(out var b) && b;
-                Files.WriteJson(LockPath(l), record);   // a holder taking it again, or one whose heartbeat stopped
-            }
-            else
-            {
-                // No lock: an exclusive create, so even a writer that bypasses the mutex cannot overwrite one.
-                using var stream = new FileStream(LockPath(l), FileMode.CreateNew, FileAccess.Write, FileShare.None);
-                using var writer = new StreamWriter(stream);
-                writer.Write(record.ToJsonString());
-            }
-            return (true, held);
-        });
-    }
-
-    public static void Beat(Ledger l, string holder) => WithMutex(l, () =>
-    {
-        if (Files.ReadJson(LockPath(l)) is JsonObject held && Files.Str(held["holder"]) == holder)
-        {
-            held["heartbeat"] = Now();
-            Files.WriteJson(LockPath(l), held);
-        }
-    });
-
-    public static void OweReplay(Ledger l) => WithMutex(l, () =>
-    {
-        if (Files.ReadJson(LockPath(l)) is JsonObject held)
-        {
-            held["pending_replay"] = true;
-            Files.WriteJson(LockPath(l), held);
-        }
-    });
-
-    /// <summary>Releases the lock; returns whether a replay was owed. Refuses another holder's lock.</summary>
-    public static bool Release(Ledger l, string holder) => WithMutex(l, () =>
-    {
-        var held = Files.ReadJson(LockPath(l)) as JsonObject;
-        if (held is not null && Files.Str(held["holder"]) != holder)
-            throw new Refusal($"the lock is {Files.Str(held["holder"])}'s, not {holder}'s");
-        if (held is not null) File.Delete(LockPath(l));
-        return held?["pending_replay"] is JsonValue p && p.TryGetValue<bool>(out var b) && b;
-    });
-
-    public static JsonObject? Abandon(Ledger l) => WithMutex(l, () =>
-    {
-        var held = Files.ReadJson(LockPath(l)) as JsonObject;
-        if (held is not null) File.Delete(LockPath(l));
-        return held;
-    });
-
-    /// <summary>Keeps a lock alive while a long step runs: a timer beats every 30 s.</summary>
-    public sealed class Heartbeat(Ledger ledger, string holder) : IDisposable
-    {
-        private readonly Timer timer = new(_ => { try { Beat(ledger, holder); } catch (Exception) { } }, null, BeatEvery, BeatEvery);
-        public void Dispose() => timer.Dispose();
-    }
-}
diff --git a/tools/Prober/SchemaCheck.cs b/tools/Prober/SchemaCheck.cs
deleted file mode 100644
index 56725a7d..00000000
--- a/tools/Prober/SchemaCheck.cs
+++ /dev/null
@@ -1,88 +0,0 @@
-using System.Text.Json.Nodes;
-using System.Text.RegularExpressions;
-
-namespace Prober;
-
-/// <summary>
-/// The part of JSON Schema the tracked files' schemas use, checked where a file is read, so a field nobody
-/// reads is refused instead of kept (decision 102: three invented fields for an exclusion's reason sat in
-/// claims.json unread). A keyword outside this part throws: a schema that says more than is checked would be
-/// a check that silently does less than it reads.
-/// </summary>
-internal static class SchemaCheck
-{
-    private static readonly HashSet<string> Annotations = ["$schema", "$id", "title", "description"];
-
-    /// <summary>The schema of <c>Schemas/{name}</c>, embedded in the dll, so it is the one the dll's fingerprint covers.</summary>
-    public static JsonObject Load(string name)
-    {
-        using var stream = typeof(SchemaCheck).Assembly.GetManifestResourceStream(name)
-                           ?? throw new InvalidOperationException($"no embedded schema {name}");
-        return JsonNode.Parse(stream) as JsonObject ?? throw new InvalidOperationException($"the schema {name} is not a JSON object");
-    }
-
-    /// <summary>What in <paramref name="node"/> the schema refuses, each at its path (<c>exclude[0].reason</c>).</summary>
-    public static List<string> Problems(JsonNode? node, JsonObject schema, string path = "")
-    {
-        var problems = new List<string>();
-        Check(node, schema, path, problems);
-        return problems;
-    }
-
-    private static void Check(JsonNode? node, JsonObject schema, string path, List<string> problems)
-    {
-        var at = path.Length == 0 ? "the value" : path;
-        foreach (var (keyword, _) in schema)
-            if (!Annotations.Contains(keyword) && keyword is not ("type" or "const" or "required" or "properties" or "additionalProperties"
-                    or "items" or "minItems" or "maxItems" or "minLength" or "pattern"))
-                throw new InvalidOperationException($"a schema uses {keyword}, which SchemaCheck does not check");
-
-        if (schema["type"] is JsonValue type && !IsType(node, Files.Str(type)))
-        {
-            problems.Add($"{at} is not {Article(Files.Str(type))}");
-            return;
-        }
-        if (schema["const"] is { } constant && !JsonNode.DeepEquals(node, constant)) problems.Add($"{at} is not {constant.ToJsonString()}");
-
-        if (node is JsonObject o)
-        {
-            foreach (var name in Files.Strings(schema["required"]))
-                if (!o.ContainsKey(name)) problems.Add($"{Join(path, name)} is required");
-            var properties = schema["properties"] as JsonObject ?? [];
-            foreach (var (name, value) in o)
-            {
-                if (properties[name] is JsonObject property) Check(value, property, Join(path, name), problems);
-                else if (schema["additionalProperties"] is JsonObject rest) Check(value, rest, Join(path, name), problems);
-                else if (schema["additionalProperties"] is JsonValue allowed && allowed.TryGetValue<bool>(out var b) && !b)
-                    problems.Add($"{Join(path, name)} is not a field the schema has");
-            }
-        }
-        if (node is JsonArray a)
-        {
-            if (schema["minItems"] is { } min && a.Count < Files.Num(min)) problems.Add($"{at} has {a.Count} item(s), fewer than {Files.Num(min)}");
-            if (schema["maxItems"] is { } max && a.Count > Files.Num(max)) problems.Add($"{at} has {a.Count} item(s), more than {Files.Num(max)}");
-            if (schema["items"] is JsonObject items)
-                for (var i = 0; i < a.Count; i++) Check(a[i], items, $"{path}[{i}]", problems);
-        }
-        if (node is JsonValue v && v.TryGetValue<string>(out var s))
-        {
-            if (schema["minLength"] is { } length && s.Length < Files.Num(length)) problems.Add($"{at} is shorter than {Files.Num(length)}");
-            if (schema["pattern"] is JsonValue pattern && !Regex.IsMatch(s, Files.Str(pattern), RegexOptions.CultureInvariant))
-                problems.Add($"{at} does not match {Files.Str(pattern)}");
-        }
-    }
-
-    private static string Join(string path, string name) => path.Length == 0 ? name : $"{path}.{name}";
-
-    private static string Article(string type) => type is "object" or "array" or "integer" ? $"an {type}" : $"a {type}";
-
-    private static bool IsType(JsonNode? node, string type) => type switch
-    {
-        "object" => node is JsonObject,
-        "array" => node is JsonArray,
-        "string" => node is JsonValue v && v.TryGetValue<string>(out _),
-        "integer" => node is JsonValue v && v.TryGetValue<long>(out _),
-        "boolean" => node is JsonValue v && v.TryGetValue<bool>(out _),
-        _ => throw new InvalidOperationException($"a schema names type {type}, which SchemaCheck does not check"),
-    };
-}
diff --git a/tools/Prober/Schemas/claims.schema.json b/tools/Prober/Schemas/claims.schema.json
deleted file mode 100644
index 3c944f19..00000000
--- a/tools/Prober/Schemas/claims.schema.json
+++ /dev/null
@@ -1,189 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://codometis.typekit/probe/schemas/claims.schema.json",
-  "title": "Claims",
-  "description": "Tracked (corpus/claims.json): the claims the documents make, each naming the surfaces whose axes it takes. The prober refuses a file that does not match this schema when it reads one (decision 102).",
-  "type": "array",
-  "items": {
-    "type": "object",
-    "required": [
-      "id",
-      "source",
-      "surfaces"
-    ],
-    "properties": {
-      "schemaVersion": {
-        "type": "integer",
-        "const": 1,
-        "description": "The schema version. A file or line without it is version 1 (the Python baseline)."
-      },
-      "id": {
-        "type": "string",
-        "minLength": 1
-      },
-      "source": {
-        "type": "string",
-        "description": "file#heading of the document that states it"
-      },
-      "surfaces": {
-        "type": "array",
-        "items": {
-          "type": "string"
-        },
-        "minItems": 1
-      },
-      "axes": {
-        "type": "object",
-        "additionalProperties": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        },
-        "description": "claim-local axes"
-      },
-      "narrow": {
-        "type": "object",
-        "additionalProperties": {
-          "type": "string"
-        },
-        "description": "axis dropped, with the source sentence that limits it (checked verbatim)"
-      },
-      "obligations": {
-        "type": "array",
-        "minItems": 1,
-        "description": "what the claim promises, each checkable on its own: a sentence quoted verbatim from the claim's source document (checked as a narrowing is), under an id a probe's seed names (decision 104); a claim without the field has one obligation, the claim itself, under the id `claim`",
-        "items": {
-          "type": "object",
-          "required": [
-            "id",
-            "sentence"
-          ],
-          "properties": {
-            "id": {
-              "type": "string",
-              "pattern": "^[a-z0-9][a-z0-9-]*$"
-            },
-            "sentence": {
-              "type": "string",
-              "pattern": "\\S"
-            },
-            "axes": {
-              "type": "object",
-              "additionalProperties": {
-                "type": "array",
-                "items": {
-                  "type": "string"
-                }
-              },
-              "description": "the axis values the obligation concerns, where it is not the whole claim"
-            },
-            "inapplicable": {
-              "type": "array",
-              "minItems": 1,
-              "description": "where the obligation does not apply: a row holding every axis of a declaration at one of its values runs no check of the obligation (Row.Check records it inapplicable with the cite), a pair matched by a declaration is not wanted by the obligation, and a pair no obligation wants is declared inapplicable, never put in a generated row and left out of the gate's count as an exclusion is. `Axes.Build` refuses an axis or value the claim does not list, a malformed cite, and a not-promised id the claim lacks",
-              "items": {
-                "type": "object",
-                "required": [
-                  "axes",
-                  "cite"
-                ],
-                "properties": {
-                  "axes": {
-                    "type": "object",
-                    "additionalProperties": {
-                      "type": "array",
-                      "minItems": 1,
-                      "items": {
-                        "type": "string"
-                      }
-                    },
-                    "description": "axis to the values where the obligation does not apply; every axis must hold at one of its values"
-                  },
-                  "cite": {
-                    "type": "string",
-                    "pattern": "^(not-promised|docs|fact|record):",
-                    "description": "why: not-promised:<id of the claim's not-promised list>, docs:<file#anchor>, fact:KB-NNN or record:NNNN, in the forms the harness's Cite accepts"
-                  }
-                },
-                "additionalProperties": false
-              }
-            }
-          },
-          "additionalProperties": false
-        }
-      },
-      "not-promised": {
-        "type": "array",
-        "minItems": 1,
-        "description": "what the claim does not promise, one entry per intended difference: the sentence of the document or record that makes it intended, quoted verbatim from `source` (checked as a narrowing is), and the axis values it concerns; a note key of outcome expected-refusal, a narrowing or an applicability condition cites an entry by its id (decision 104)",
-        "items": {
-          "type": "object",
-          "required": [
-            "id",
-            "source",
-            "sentence"
-          ],
-          "properties": {
-            "id": {
-              "type": "string",
-              "pattern": "^[a-z0-9][a-z0-9-]*$"
-            },
-            "source": {
-              "type": "string",
-              "description": "file#heading of the document or record that states it"
-            },
-            "sentence": {
-              "type": "string",
-              "pattern": "\\S"
-            },
-            "axes": {
-              "type": "object",
-              "additionalProperties": {
-                "type": "array",
-                "items": {
-                  "type": "string"
-                }
-              },
-              "description": "the axis values or shapes the difference concerns"
-            }
-          },
-          "additionalProperties": false
-        }
-      },
-      "exclude": {
-        "type": "array",
-        "description": "pairs no row can hold, each group with the reason why; `prober universe` prints the reasons, since nothing checks them mechanically",
-        "items": {
-          "type": "object",
-          "required": [
-            "reason",
-            "pairs"
-          ],
-          "properties": {
-            "reason": {
-              "type": "string",
-              "pattern": "\\S",
-              "description": "one sentence saying why the pairs cannot exist or are not promised, citing a docs sentence, a record or a KB fact where one applies"
-            },
-            "pairs": {
-              "type": "array",
-              "minItems": 1,
-              "items": {
-                "type": "array",
-                "items": {
-                  "type": "string",
-                  "pattern": "^[^=]+=.*$"
-                },
-                "minItems": 2,
-                "maxItems": 2
-              }
-            }
-          },
-          "additionalProperties": false
-        }
-      }
-    },
-    "additionalProperties": false
-  }
-}
diff --git a/tools/Prober/Schemas/dismissed-line.schema.json b/tools/Prober/Schemas/dismissed-line.schema.json
deleted file mode 100644
index 1556681b..00000000
--- a/tools/Prober/Schemas/dismissed-line.schema.json
+++ /dev/null
@@ -1,27 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://codometis.typekit/probe/schemas/dismissed-line.schema.json",
-  "title": "Dismissed finding (one line)",
-  "description": "Tracked (corpus/dismissed.jsonl): a finding the maintainers dismissed.",
-  "type": "object",
-  "required": [
-    "id",
-    "reason"
-  ],
-  "properties": {
-    "schemaVersion": {
-      "type": "integer",
-      "const": 1,
-      "description": "The schema version. A file or line without it is version 1 (the Python baseline)."
-    },
-    "id": {
-      "type": "string"
-    },
-    "reason": {
-      "type": "string"
-    },
-    "date": {
-      "type": "string"
-    }
-  }
-}
diff --git a/tools/Prober/Schemas/evidence.schema.json b/tools/Prober/Schemas/evidence.schema.json
deleted file mode 100644
index 7d86b9db..00000000
--- a/tools/Prober/Schemas/evidence.schema.json
+++ /dev/null
@@ -1,170 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://codometis.typekit/probe/schemas/evidence.schema.json",
-  "title": "Evidence",
-  "description": "State (branches/<branch>/evidence/<probe>.json): what one replay of a probe did. Only checks that ended as a pass, in rows expected and executed, earn credit, for the settings that applied (the row's, the check's laid over them), while the identity holds. A row without checks is one check of the obligation `claim` with the row's category.",
-  "type": "object",
-  "required": [
-    "identity",
-    "variants",
-    "rows"
-  ],
-  "properties": {
-    "schemaVersion": {
-      "type": "integer",
-      "enum": [
-        1,
-        2
-      ],
-      "description": "The schema version: 2 records each row's checks. A file without it is version 1, whose rows have no checks."
-    },
-    "probe": {
-      "type": "string"
-    },
-    "identity": {
-      "type": "string"
-    },
-    "commit": {
-      "type": "string"
-    },
-    "result": {
-      "enum": [
-        "pass",
-        "fail"
-      ]
-    },
-    "date": {
-      "type": "string"
-    },
-    "variants": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "required": [
-          "expected",
-          "executed"
-        ],
-        "properties": {
-          "env": {
-            "type": "object",
-            "additionalProperties": {
-              "type": "string"
-            },
-            "description": "Axis name to value, both compared ordinally."
-          },
-          "expected": {
-            "type": "array",
-            "items": {
-              "type": "integer"
-            }
-          },
-          "executed": {
-            "type": "array",
-            "items": {
-              "type": "integer"
-            }
-          }
-        }
-      }
-    },
-    "rows": {
-      "type": "object",
-      "additionalProperties": {
-        "type": "object",
-        "required": [
-          "category",
-          "applied"
-        ],
-        "properties": {
-          "category": {
-            "enum": [
-              "pass",
-              "violation",
-              "expected-refusal",
-              "inapplicable",
-              "harness-error",
-              "inconclusive",
-              "known-finding"
-            ],
-            "description": "The highest of the row's own outcome and its checks'."
-          },
-          "applied": {
-            "type": "object",
-            "additionalProperties": {
-              "type": "string"
-            },
-            "description": "Axis name to value, both compared ordinally: the axes the row read outside any check, which every check of it ran under."
-          },
-          "reasons": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "findings": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            },
-            "description": "The open findings the row stepped around (Row.Skip in the harness); the row ends as known-finding."
-          },
-          "checks": {
-            "type": "array",
-            "description": "Version 2: one entry per check the row ran (Row.Check in the harness), in the order they ended. Absent for a row that ran none.",
-            "items": {
-              "type": "object",
-              "required": [
-                "obligation",
-                "category",
-                "applied"
-              ],
-              "properties": {
-                "obligation": {
-                  "type": "string",
-                  "description": "An id of the claim's obligations, or `claim` for a claim without them."
-                },
-                "baseline": {
-                  "type": [
-                    "string",
-                    "null"
-                  ],
-                  "description": "What the check compared against: twin, framework, round-trip, model, refusal, cost, fact:KB-NNN or docs:file#anchor. A pass always has one."
-                },
-                "category": {
-                  "enum": [
-                    "pass",
-                    "violation",
-                    "expected-refusal",
-                    "inapplicable",
-                    "harness-error",
-                    "inconclusive",
-                    "known-finding"
-                  ]
-                },
-                "applied": {
-                  "type": "object",
-                  "additionalProperties": {
-                    "type": "string"
-                  },
-                  "description": "The axes this check read, at the value that applied, and none another check read."
-                },
-                "reasons": {
-                  "type": "array",
-                  "items": {
-                    "type": "string"
-                  },
-                  "description": "Six at most, as the row's."
-                },
-                "notes": {
-                  "type": "string",
-                  "description": "How the check was compared, and the citations of what did not apply or was refused, separated by ;."
-                }
-              },
-              "additionalProperties": false
-            }
-          }
-        }
-      }
-    }
-  }
-}
diff --git a/tools/Prober/Schemas/finding-line.schema.json b/tools/Prober/Schemas/finding-line.schema.json
deleted file mode 100644
index 317c24f6..00000000
--- a/tools/Prober/Schemas/finding-line.schema.json
+++ /dev/null
@@ -1,44 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://codometis.typekit/probe/schemas/finding-line.schema.json",
-  "title": "Finding event (one line)",
-  "description": "State (findings.jsonl): open, fixed or withdrawn. The last line per id wins; a fixed line counts once its commit is in HEAD's history.",
-  "type": "object",
-  "required": [
-    "id",
-    "status"
-  ],
-  "properties": {
-    "schemaVersion": {
-      "type": "integer",
-      "const": 1,
-      "description": "The schema version. A file or line without it is version 1 (the Python baseline)."
-    },
-    "id": {
-      "type": "string"
-    },
-    "claim": {
-      "type": [
-        "string",
-        "null"
-      ]
-    },
-    "status": {
-      "enum": [
-        "open",
-        "fixed",
-        "withdrawn",
-        "dismissed"
-      ]
-    },
-    "commit": {
-      "type": "string"
-    },
-    "probe": {
-      "type": "string"
-    },
-    "reason": {
-      "type": "string"
-    }
-  }
-}
diff --git a/tools/Prober/Schemas/footprint-line.schema.json b/tools/Prober/Schemas/footprint-line.schema.json
deleted file mode 100644
index f5e41f2e..00000000
--- a/tools/Prober/Schemas/footprint-line.schema.json
+++ /dev/null
@@ -1,60 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://codometis.typekit/probe/schemas/footprint-line.schema.json",
-  "title": "Footprint (one line)",
-  "description": "State (footprints.jsonl): the source files a run of a probe executed, the compile-time paths and the toolchain, each with its id. The last line per probe wins.",
-  "type": "object",
-  "required": [
-    "probe",
-    "footprint"
-  ],
-  "properties": {
-    "schemaVersion": {
-      "type": "integer",
-      "const": 1,
-      "description": "The schema version. A file or line without it is version 1 (the Python baseline)."
-    },
-    "probe": {
-      "type": "string"
-    },
-    "commit": {
-      "type": "string"
-    },
-    "footprint": {
-      "type": "object",
-      "additionalProperties": {
-        "type": "string"
-      },
-      "description": "Axis name to value, both compared ordinally."
-    },
-    "compileTime": {
-      "type": "object",
-      "additionalProperties": {
-        "type": [
-          "string",
-          "null"
-        ]
-      }
-    },
-    "watched": {
-      "type": "object",
-      "additionalProperties": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "description": "The paths the probe's registry entry watches, each with its object id at the commit the run built (null where it does not exist). A footprint line without one of the entry's watched paths is not current."
-    },
-    "toolchain": {
-      "type": "object",
-      "additionalProperties": {
-        "type": "string"
-      },
-      "description": "Axis name to value, both compared ordinally."
-    },
-    "date": {
-      "type": "string"
-    }
-  }
-}
diff --git a/tools/Prober/Schemas/ledger-line.schema.json b/tools/Prober/Schemas/ledger-line.schema.json
deleted file mode 100644
index 188d2a8f..00000000
--- a/tools/Prober/Schemas/ledger-line.schema.json
+++ /dev/null
@@ -1,44 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://codometis.typekit/probe/schemas/ledger-line.schema.json",
-  "title": "Ledger line (legacy, one line)",
-  "description": "State (ledger.jsonl): what a round recorded per pair. Informational: it earns no credit; only evidence does.",
-  "type": "object",
-  "required": [
-    "claim",
-    "pair",
-    "commit",
-    "result"
-  ],
-  "properties": {
-    "schemaVersion": {
-      "type": "integer",
-      "const": 1,
-      "description": "The schema version. A file or line without it is version 1 (the Python baseline)."
-    },
-    "claim": {
-      "type": "string"
-    },
-    "pair": {
-      "type": "array",
-      "items": {
-        "type": "string",
-        "pattern": "^[^=]+=.*$"
-      },
-      "minItems": 2,
-      "maxItems": 2
-    },
-    "commit": {
-      "type": "string"
-    },
-    "result": {
-      "type": "string"
-    },
-    "probe": {
-      "type": "string"
-    },
-    "date": {
-      "type": "string"
-    }
-  }
-}
diff --git a/tools/Prober/Schemas/lock.schema.json b/tools/Prober/Schemas/lock.schema.json
deleted file mode 100644
index 5e9e290d..00000000
--- a/tools/Prober/Schemas/lock.schema.json
+++ /dev/null
@@ -1,53 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://codometis.typekit/probe/schemas/lock.schema.json",
-  "title": "Round lock",
-  "description": "State (branches/<branch>/round.lock): one round at a time per branch. Created exclusively; alive while its heartbeat is recent.",
-  "type": "object",
-  "required": [
-    "holder",
-    "mode",
-    "since",
-    "heartbeat"
-  ],
-  "properties": {
-    "schemaVersion": {
-      "type": "integer",
-      "const": 1,
-      "description": "The schema version. A file or line without it is version 1 (the Python baseline)."
-    },
-    "holder": {
-      "type": "string"
-    },
-    "mode": {
-      "enum": [
-        "replay",
-        "explore",
-        "full"
-      ]
-    },
-    "owner": {
-      "type": "object",
-      "properties": {
-        "pid": {
-          "type": [
-            "integer",
-            "null"
-          ]
-        },
-        "host": {
-          "type": "string"
-        }
-      }
-    },
-    "since": {
-      "type": "number"
-    },
-    "heartbeat": {
-      "type": "number"
-    },
-    "pending_replay": {
-      "type": "boolean"
-    }
-  }
-}
diff --git a/tools/Prober/Schemas/registry.schema.json b/tools/Prober/Schemas/registry.schema.json
deleted file mode 100644
index 3be5eb0a..00000000
--- a/tools/Prober/Schemas/registry.schema.json
+++ /dev/null
@@ -1,143 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://codometis.typekit/probe/schemas/registry.schema.json",
-  "title": "Probe registry",
-  "description": "Tracked (corpus/registry.json): every probe, the claim it covers, how to select it, and the process variants it runs in.",
-  "type": "object",
-  "required": [
-    "probes"
-  ],
-  "properties": {
-    "schemaVersion": {
-      "type": "integer",
-      "const": 1,
-      "description": "The schema version. A file or line without it is version 1 (the Python baseline)."
-    },
-    "probes": {
-      "type": "object",
-      "additionalProperties": {
-        "type": "object",
-        "required": [
-          "claim",
-          "filter"
-        ],
-        "properties": {
-          "claim": {
-            "type": "string"
-          },
-          "filter": {
-            "type": "string"
-          },
-          "variants": {
-            "type": "array",
-            "items": {
-              "type": "object",
-              "additionalProperties": {
-                "type": "string"
-              },
-              "description": "Axis name to value, both compared ordinally."
-            },
-            "description": "one process per environment map"
-          },
-          "retired": {
-            "type": "boolean"
-          },
-          "watched": {
-            "type": "array",
-            "items": {
-              "type": "string",
-              "minLength": 1
-            },
-            "description": "Paths, files or directories relative to the repository root, that the probe's result depends on and its footprint cannot see: a variant catalogue under test/ compiled into the probes, a build input a child process reads. The replay records each with its object id in the probe's footprint line; a change to one stales the footprint (Ledger.FootprintCurrent, FootprintChangedSince), and the release gate counts a change to one as touching the probe's claim. Part of the probe's identity, as the whole entry but its seeds is."
-          },
-          "seeds": {
-            "type": "array",
-            "description": "One seeded defect per obligation of the probe's claim that this probe checks (decision 104): each as `seed` below, naming the obligation it breaks. A probe may carry `seed` and `seeds` both. Empty in the entry `prober new` stages, until the writer registers each with `prober register --obligation O`, which replaces a seed naming O; `seeds` and Seeds.Problems refuse a probe with none. Not part of the probe's identity.",
-            "items": {
-              "type": "object",
-              "required": [
-                "obligation",
-                "defect"
-              ],
-              "anyOf": [
-                {
-                  "required": [
-                    "patch"
-                  ]
-                },
-                {
-                  "required": [
-                    "env"
-                  ]
-                }
-              ],
-              "properties": {
-                "obligation": {
-                  "type": "string",
-                  "description": "The id of the claim's obligation this seed breaks (claims.json `obligations[].id`, or `claim` for a claim without the field)."
-                },
-                "patch": {
-                  "type": "string"
-                },
-                "env": {
-                  "type": "object",
-                  "additionalProperties": {
-                    "type": "string"
-                  }
-                },
-                "defect": {
-                  "type": "string",
-                  "minLength": 1
-                }
-              },
-              "additionalProperties": false
-            }
-          },
-          "seed": {
-            "type": "object",
-            "required": [
-              "defect"
-            ],
-            "anyOf": [
-              {
-                "required": [
-                  "patch"
-                ]
-              },
-              {
-                "required": [
-                  "env"
-                ]
-              }
-            ],
-            "properties": {
-              "patch": {
-                "type": "string",
-                "description": "A unified diff against the product files (the replay's \"include\"), relative to the corpus directory: seeds/<claim>.patch."
-              },
-              "env": {
-                "type": "object",
-                "additionalProperties": {
-                  "type": "string"
-                },
-                "description": "Environment variables set for the seeded build and every variant's run."
-              },
-              "defect": {
-                "type": "string",
-                "minLength": 1,
-                "description": "What the seed breaks, in one sentence."
-              },
-              "obligation": {
-                "type": "string",
-                "description": "The id of the claim's obligation this seed breaks (decision 104); absent, the seed proves the probe and counts for the claim's one implicit obligation only where the claim lists none."
-              }
-            },
-            "additionalProperties": false,
-            "description": "The product defect `prober seeds` applies in a scratch worktree to prove the probe can fail (decision 100). Not part of the probe's identity."
-          }
-        },
-        "additionalProperties": false
-      }
-    }
-  }
-}
diff --git a/tools/Prober/Schemas/round.schema.json b/tools/Prober/Schemas/round.schema.json
deleted file mode 100644
index dda984fe..00000000
--- a/tools/Prober/Schemas/round.schema.json
+++ /dev/null
@@ -1,40 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://codometis.typekit/probe/schemas/round.schema.json",
-  "title": "Round caps",
-  "description": "State (branches/<branch>/round.json): the caps `rows` enforces for the round that holds the lock.",
-  "type": "object",
-  "required": [
-    "holder",
-    "deadline",
-    "claims"
-  ],
-  "properties": {
-    "schemaVersion": {
-      "type": "integer",
-      "const": 1,
-      "description": "The schema version. A file or line without it is version 1 (the Python baseline)."
-    },
-    "holder": {
-      "type": "string"
-    },
-    "started": {
-      "type": "number"
-    },
-    "deadline": {
-      "type": "number"
-    },
-    "max_claims": {
-      "type": [
-        "integer",
-        "null"
-      ]
-    },
-    "claims": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      }
-    }
-  }
-}
diff --git a/tools/Prober/Schemas/rows.schema.json b/tools/Prober/Schemas/rows.schema.json
deleted file mode 100644
index 290f9a7b..00000000
--- a/tools/Prober/Schemas/rows.schema.json
+++ /dev/null
@@ -1,52 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://codometis.typekit/probe/schemas/rows.schema.json",
-  "title": "Rows",
-  "description": "Tracked (corpus/rows/<probe>.json.gz, gzipped; rows/<probe>.json in the staging): the rows one probe runs, a pairwise covering array over its claim's axes. One file per registered probe, written whole by `prober rows --probe P`, never appended; no two rows of a file have the same axis map (ProbeRowsTests).",
-  "type": "object",
-  "required": [
-    "claim",
-    "rows"
-  ],
-  "properties": {
-    "schemaVersion": {
-      "type": "integer",
-      "const": 1,
-      "description": "The schema version. A file or line without it is version 1 (the Python baseline)."
-    },
-    "claim": {
-      "type": "string",
-      "description": "The id of the probe's claim in claims.json; the file is named for the probe, so the claim is kept inside."
-    },
-    "rows": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "required": [
-          "row"
-        ],
-        "properties": {
-          "row": {
-            "type": "object",
-            "additionalProperties": {
-              "type": "string"
-            },
-            "description": "Axis name to value, both compared ordinally."
-          },
-          "pairs": {
-            "type": "array",
-            "items": {
-              "type": "array",
-              "items": {
-                "type": "string",
-                "pattern": "^[^=]+=.*$"
-              },
-              "minItems": 2,
-              "maxItems": 2
-            }
-          }
-        }
-      }
-    }
-  }
-}
diff --git a/tools/Prober/Schemas/run-line.schema.json b/tools/Prober/Schemas/run-line.schema.json
deleted file mode 100644
index 5aca7f82..00000000
--- a/tools/Prober/Schemas/run-line.schema.json
+++ /dev/null
@@ -1,43 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://codometis.typekit/probe/schemas/run-line.schema.json",
-  "title": "Run (one line)",
-  "description": "State (runs.jsonl): one replay result of one probe, with the identity it ran under.",
-  "type": "object",
-  "required": [
-    "probe",
-    "result",
-    "commit"
-  ],
-  "properties": {
-    "schemaVersion": {
-      "type": "integer",
-      "const": 1,
-      "description": "The schema version. A file or line without it is version 1 (the Python baseline)."
-    },
-    "probe": {
-      "type": "string"
-    },
-    "result": {
-      "enum": [
-        "pass",
-        "fail"
-      ]
-    },
-    "commit": {
-      "type": "string"
-    },
-    "date": {
-      "type": "string"
-    },
-    "seconds": {
-      "type": [
-        "number",
-        "null"
-      ]
-    },
-    "identity": {
-      "type": "string"
-    }
-  }
-}
diff --git a/tools/Prober/Schemas/seeds-run.schema.json b/tools/Prober/Schemas/seeds-run.schema.json
deleted file mode 100644
index 824b9919..00000000
--- a/tools/Prober/Schemas/seeds-run.schema.json
+++ /dev/null
@@ -1,131 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://codometis.typekit/probe/schemas/seeds-run.schema.json",
-  "title": "Seeds run",
-  "description": "State (seeds-last.json): the last `prober seeds` run on the branch, one outcome per seed it ran (a probe without one has a single outcome, `no seed`), the probes it skipped and why, and per probe the run that last caught every one of its seeds, which decides what the next run without --all skips (design/adr/0107). Never evidence: a seeded run proves the probe, not the product.",
-  "type": "object",
-  "required": [
-    "branch",
-    "commit",
-    "seeds"
-  ],
-  "properties": {
-    "schemaVersion": {
-      "type": "integer",
-      "const": 1,
-      "description": "The schema version. A file or line without it is version 1 (the Python baseline)."
-    },
-    "branch": {
-      "type": "string"
-    },
-    "commit": {
-      "type": "string"
-    },
-    "seconds": {
-      "type": "number"
-    },
-    "all": {
-      "type": "boolean",
-      "description": "Whether the run was `--all`, every probe whatever its record says, as a release runs it. Absent in a file written before footprint selection."
-    },
-    "probes": {
-      "type": "object",
-      "description": "Per probe, the run that last caught every seed it owes; a probe with a seed missed, or that never ran, has no entry, so it runs next time. Carried forward for the probes a run skipped.",
-      "additionalProperties": {
-        "type": "object",
-        "required": [
-          "identity",
-          "commit"
-        ],
-        "properties": {
-          "identity": {
-            "type": "string",
-            "description": "The seeds identity it was caught under: the probe's identity, its seeds and the content of their patches."
-          },
-          "commit": {
-            "type": "string",
-            "description": "HEAD of the run that caught them; the product footprint and the patched files are compared with it."
-          },
-          "seeds": {
-            "type": "integer",
-            "description": "How many seeds were caught."
-          }
-        },
-        "additionalProperties": false
-      }
-    },
-    "skipped": {
-      "type": "array",
-      "description": "The probes this run skipped, unchanged since every seed of theirs was caught, each with the reason printed.",
-      "items": {
-        "type": "object",
-        "required": [
-          "probe",
-          "reason"
-        ],
-        "properties": {
-          "probe": {
-            "type": "string"
-          },
-          "reason": {
-            "type": "string"
-          }
-        },
-        "additionalProperties": false
-      }
-    },
-    "seeds": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "required": [
-          "probe",
-          "claim",
-          "result"
-        ],
-        "properties": {
-          "probe": {
-            "type": "string"
-          },
-          "claim": {
-            "type": "string"
-          },
-          "obligation": {
-            "type": [
-              "string",
-              "null"
-            ],
-            "description": "The claim's obligation the seed breaks (decision 104), or null for a seed that names none."
-          },
-          "seed": {
-            "type": "string",
-            "description": "The patch and the environment toggle applied, or (none)."
-          },
-          "result": {
-            "enum": [
-              "caught",
-              "missed",
-              "no seed",
-              "does not apply",
-              "build failed"
-            ]
-          },
-          "violations": {
-            "type": "integer",
-            "description": "Rows the seed made violations that the unseeded probe does not have."
-          },
-          "rows": {
-            "type": "integer",
-            "description": "Rows that ran under the seed."
-          },
-          "detail": {
-            "type": "string"
-          }
-        },
-        "additionalProperties": false
-      },
-      "description": "One outcome per seed this run ran; the probes it skipped have none."
-    }
-  },
-  "additionalProperties": false
-}
diff --git a/tools/Prober/Schemas/universe.schema.json b/tools/Prober/Schemas/universe.schema.json
deleted file mode 100644
index 776635f3..00000000
--- a/tools/Prober/Schemas/universe.schema.json
+++ /dev/null
@@ -1,120 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://codometis.typekit/probe/schemas/universe.schema.json",
-  "title": "Universe",
-  "description": "State (branches/<branch>/universe.json): each claim's axes and values, derived from the claims, the axes file and the generated axes.",
-  "type": "object",
-  "required": [
-    "claims"
-  ],
-  "properties": {
-    "schemaVersion": {
-      "type": "integer",
-      "const": 1,
-      "description": "The schema version. A file or line without it is version 1 (the Python baseline)."
-    },
-    "base": {
-      "type": "string"
-    },
-    "commit": {
-      "type": "string"
-    },
-    "generated_versions": {
-      "type": "object",
-      "additionalProperties": {
-        "type": "string"
-      },
-      "description": "Axis name to value, both compared ordinally."
-    },
-    "claims": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "required": [
-          "id",
-          "axes"
-        ],
-        "properties": {
-          "id": {
-            "type": "string"
-          },
-          "source": {
-            "type": "string"
-          },
-          "surfaces": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "watched": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "axes": {
-            "type": "object",
-            "additionalProperties": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            }
-          },
-          "exclude": {
-            "type": "array",
-            "items": {
-              "type": "array",
-              "items": {
-                "type": "string",
-                "pattern": "^[^=]+=.*$"
-              },
-              "minItems": 2,
-              "maxItems": 2
-            }
-          },
-          "obligations": {
-            "type": "array",
-            "description": "written only where an obligation of the claim declares where it does not apply: every obligation's id with its declarations, as claims.json holds them, so the covering generator, status and the gate know the pairs each wants",
-            "items": {
-              "type": "object",
-              "required": [
-                "id"
-              ],
-              "properties": {
-                "id": {
-                  "type": "string"
-                },
-                "inapplicable": {
-                  "type": "array",
-                  "items": {
-                    "type": "object",
-                    "required": [
-                      "axes",
-                      "cite"
-                    ],
-                    "properties": {
-                      "axes": {
-                        "type": "object",
-                        "additionalProperties": {
-                          "type": "array",
-                          "items": {
-                            "type": "string"
-                          }
-                        }
-                      },
-                      "cite": {
-                        "type": "string"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}
diff --git a/tools/Prober/Schemas/waivers.schema.json b/tools/Prober/Schemas/waivers.schema.json
deleted file mode 100644
index 1b0d99c1..00000000
--- a/tools/Prober/Schemas/waivers.schema.json
+++ /dev/null
@@ -1,36 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://codometis.typekit/probe/schemas/waivers.schema.json",
-  "title": "Waivers",
-  "description": "Tracked (corpus/waivers.json): a claim's gate obligation met without a probe. Counts only with a reason and a reviewer.",
-  "type": "array",
-  "items": {
-    "type": "object",
-    "required": [
-      "claim",
-      "reason",
-      "reviewed_by"
-    ],
-    "properties": {
-      "schemaVersion": {
-        "type": "integer",
-        "const": 1,
-        "description": "The schema version. A file or line without it is version 1 (the Python baseline)."
-      },
-      "claim": {
-        "type": "string"
-      },
-      "reason": {
-        "type": "string",
-        "minLength": 1
-      },
-      "reviewed_by": {
-        "type": "string",
-        "minLength": 1
-      },
-      "date": {
-        "type": "string"
-      }
-    }
-  }
-}
diff --git a/tools/Prober/Seeds.cs b/tools/Prober/Seeds.cs
deleted file mode 100644
index 92e5fe86..00000000
--- a/tools/Prober/Seeds.cs
+++ /dev/null
@@ -1,396 +0,0 @@
-using System.Diagnostics;
-using System.Globalization;
-using System.Text.Json.Nodes;
-
-namespace Prober;
-
-/// <summary>
-/// Proves that each probe can fail (decision 100). A probe's registry entry names a seeded product defect:
-/// a patch against the product files (the replay's <c>include</c>, <c>src</c> here), an environment toggle,
-/// or both, and a sentence saying what it breaks. This applies each seed in a scratch worktree of its own,
-/// builds, replays that probe there, and counts the seed caught only where a check ends as a violation that the
-/// unseeded probe does not have in the same row for the same obligation and that no harness error raised, and, for a
-/// seed naming an obligation, only a check naming that obligation (a row without checks is one check, <c>claim</c>).
-/// Nothing it runs is recorded as evidence: a seeded run proves the probe,
-/// not the product. Never in the checkout and never in the replay's worktree; one build per seed, so it runs
-/// locally, not in CI. A missed seed, a probe without one, a seed that no longer applies and a seeded build
-/// that fails all fail the command. Without <c>--all</c> it runs only the probes whose seeds identity or product
-/// footprint changed since the run that last caught every seed of the probe (design/adr/0107), and says why it skips
-/// each of the others; the release runs <c>--all</c>.
-/// </summary>
-internal static class Seeds
-{
-    /// <summary>How one seed ended; <paramref name="Obligation"/> is the claim's obligation it breaks, or null for a seed that proves the probe alone.</summary>
-    internal sealed record Outcome(string Probe, string Claim, string? Obligation, string Seed, string Result, int Violations, int Rows, string Detail);
-
-    /// <summary>
-    /// Every seed of a registry entry, each with the obligation it names: the one `seed` (its `obligation`, if
-    /// any) and each of `seeds` (decision 104). An entry without either has none.
-    /// </summary>
-    internal static List<(string? Obligation, JsonObject Seed)> SeedsOf(JsonObject entry)
-    {
-        var result = new List<(string?, JsonObject)>();
-        if (entry["seed"] is JsonObject one) result.Add((Files.Str(one["obligation"]) is { Length: > 0 } o ? o : null, one));
-        foreach (var seed in (entry["seeds"] as JsonArray ?? []).OfType<JsonObject>())
-            result.Add((Files.Str(seed["obligation"]) is { Length: > 0 } o ? o : null, seed));
-        return result;
-    }
-
-    private static string Named(string probe, string? obligation) => obligation is null ? probe : $"{probe}/{obligation}";
-
-    public static int Run(Context ctx, Args a, IProbeAdapter? adapter = null)
-    {
-        var ledger = new Ledger(ctx, a.Get("branch"));
-        var config = ledger.AxesBlock()["replay"] as JsonObject ?? throw new Refusal("the axes file's block has no \"replay\" configuration");
-        adapter ??= new DotNetAdapter(config);
-        var registry = ledger.Registry();
-        var states = ledger.ProbeStates(includeRetired: false).Where(s => !s.Retired).ToList();
-        if (a.Get("probe") is { } only)
-        {
-            states = [.. states.Where(s => s.Probe == only)];
-            if (states.Count == 0) throw new Refusal($"no registered probe {only} that is not retired", 2);
-        }
-        var head = ledger.Head;
-        var home = Replay.Home(ctx, ledger);
-        var worktree = Path.Combine(home, "seeds");
-        var include = Files.Strings(config["include"]).ToArray() is { Length: > 0 } inc ? inc : ["src"];
-        // The probes whose every seed the last runs caught, each at the commit and the identity it was caught at; a probe
-        // named by --probe, and every probe under --all, runs whatever its record says.
-        var last = Files.ReadJson(ledger.P(LastFile)) as JsonObject;
-        var record = (last?["probes"] as JsonObject ?? []).Where(kv => kv.Value is JsonObject).ToDictionary(kv => kv.Key, kv => (JsonObject)kv.Value!.DeepClone(), StringComparer.Ordinal);
-        var identities = states.ToDictionary(s => s.Probe, s => SeedsIdentity(ledger, s.Probe), StringComparer.Ordinal);
-        var skipped = new List<(string Probe, string Why)>();
-        if (!a.Flag("all") && a.Get("probe") is null)
-        {
-            var footprints = ledger.Footprints();
-            var runs = new List<Ledger.ProbeState>();
-            foreach (var s in states)
-            {
-                var why = Stale(ledger, s.Probe, registry[s.Probe], record.GetValueOrDefault(s.Probe), identities[s.Probe], footprints);
-                if (why.Run) runs.Add(s);
-                else skipped.Add((s.Probe, why.Reason));
-                ctx.Out.WriteLine($"  {(why.Run ? "runs" : "skips")} {s.Probe}: {why.Reason}");
-            }
-            states = runs;
-        }
-        var seedsOf = states.ToDictionary(s => s.Probe, s => SeedsOf(registry[s.Probe]), StringComparer.Ordinal);
-        // A probe without a seed owes one per obligation its claim lists (decision 104), each an outcome of its own;
-        // under a claim without obligations, one.
-        var listed = ledger.Claims().ToDictionary(c => Files.Str(c["id"]), Claim.ObligationIds, StringComparer.Ordinal);
-        List<(string? Obligation, JsonNode? Seed)> Owed(Ledger.ProbeState s) =>
-            seedsOf[s.Probe].Count > 0 ? [.. seedsOf[s.Probe].Select(x => (x.Obligation, (JsonNode?)x.Seed))]
-            : listed.GetValueOrDefault(s.Claim) is { } ids && ids is not [Claim.ImplicitObligation] ? [.. ids.Select(id => ((string?)id, (JsonNode?)null))]
-            : [(null, null)];
-        ctx.Out.WriteLine($"prober seeds: {ledger.Branch} at {head[..7]}: {seedsOf.Values.Sum(x => x.Count)} seeds of {states.Count} probes, in {worktree}" +
-                          (skipped.Count > 0 ? $"; {skipped.Count} probes skipped, unchanged since every seed of theirs was caught (--all runs them)" : ""));
-        if (a.Flag("dry-run"))
-        {
-            foreach (var s in states)
-            {
-                foreach (var (obligation, seed) in Owed(s)) ctx.Out.WriteLine($"  {Named(s.Probe, obligation)}: {Describe(seed)}");
-            }
-            return 0;
-        }
-
-        var clock = Stopwatch.StartNew();
-        var outcomes = new List<Outcome>();
-        // Nothing to run: no worktree and no build, only the record carried forward.
-        if (states.Count > 0)
-        {
-            Directory.CreateDirectory(home);
-            if (!Directory.Exists(worktree))
-            {
-                var added = Git.Run(ledger.Root, "worktree", "add", "--detach", worktree, head);
-                if (added.ExitCode != 0) throw new Refusal("could not add the scratch worktree: " + added.Stderr.Trim());
-            }
-            var environment = ProbeRun.Environment(ctx, adapter, home);
-            var results = Directory.CreateTempSubdirectory("prober-seeds-").FullName;
-            try
-            {
-                // The baseline: the checks each probe already fails without a seed, by row and obligation. From the ledger
-                // where its evidence is current, else from an unseeded run here, so a seed is credited only with violations
-                // of its own.
-                var baseline = new Dictionary<string, HashSet<(int Row, string Obligation)>>(StringComparer.Ordinal);
-                var unseeded = new List<Ledger.ProbeState>();
-                foreach (var s in states)
-                {
-                    if (!s.Stale && Files.ReadJson(ledger.EvidencePath(s.Probe)) is JsonObject evidence)
-                        baseline[s.Probe] = [.. (evidence["rows"] as JsonObject ?? []).Where(kv => kv.Value is JsonObject)
-                            .SelectMany(kv => Ledger.ChecksOf((JsonObject)kv.Value!).Where(c => c.Category == "violation")
-                                                    .Select(c => (int.Parse(kv.Key, CultureInfo.InvariantCulture), c.Obligation)))];
-                    else unseeded.Add(s);
-                }
-                ctx.Out.WriteLine($"  baseline: {states.Count - unseeded.Count} from the ledger, {unseeded.Count} to run unseeded");
-                if (unseeded.Count > 0)
-                {
-                    Reset(worktree, head);
-                    Replay.Overlay(ledger, config, worktree);
-                    var build = Timed(() => adapter.Build(worktree, environment), out var seconds);
-                    ctx.Out.WriteLine($"  unseeded build: {Seconds(seconds)}, {FirstLine(build)}");
-                    if (build.ExitCode != 0) { ctx.Out.WriteLine(build.Stdout); throw new Refusal("the unseeded build failed; no seed can be judged"); }
-                    foreach (var s in unseeded)
-                    {
-                        var rows = RunProbe(adapter, worktree, s, environment, null, results, "base");
-                        baseline[s.Probe] = Violating(rows);
-                        ctx.Out.WriteLine($"    {s.Probe}: {rows.Count} rows, {baseline[s.Probe].Select(x => x.Row).Distinct().Count()} violations unseeded");
-                    }
-                }
-
-                foreach (var s in states)
-                {
-                    // A seed missing is an outcome "no seed"; a probe with several runs each under its obligation.
-                    foreach (var (obligation, seed) in Owed(s))
-                    {
-                        var outcome = One(ledger, config, adapter, worktree, head, include, environment, results, s, obligation, seed, baseline[s.Probe]);
-                        outcomes.Add(outcome);
-                        ctx.Out.WriteLine($"  {Named(s.Probe, obligation)} ({s.Claim}): {outcome.Result}{(outcome.Detail.Length > 0 ? ", " + outcome.Detail : "")}");
-                    }
-                }
-            }
-            finally
-            {
-                // The worktree is left at HEAD, every seed undone, for the next run to build incrementally.
-                Reset(worktree, head);
-                try { Directory.Delete(results, recursive: true); } catch (IOException) { }
-            }
-        }
-
-        // A probe is recorded only where every seed it owes was caught, so a missed one runs again next time, whatever changed.
-        foreach (var s in states)
-        {
-            var own = outcomes.Where(o => o.Probe == s.Probe).ToList();
-            if (own.Count > 0 && own.All(o => o.Result == "caught"))
-                record[s.Probe] = new JsonObject { ["identity"] = identities[s.Probe], ["commit"] = head, ["seeds"] = own.Count };
-            else record.Remove(s.Probe);
-        }
-        foreach (var gone in record.Keys.Where(probe => !registry.ContainsKey(probe)).ToList()) record.Remove(gone);
-
-        Files.WriteJson(ledger.P(LastFile), new JsonObject
-        {
-            ["schemaVersion"] = Files.SchemaVersion, ["branch"] = ledger.Branch, ["commit"] = head,
-            ["seconds"] = Math.Round(clock.Elapsed.TotalSeconds, 1),
-            ["all"] = a.Flag("all"),
-            ["probes"] = new JsonObject(record.OrderBy(kv => kv.Key, StringComparer.Ordinal).Select(kv => KeyValuePair.Create(kv.Key, (JsonNode?)kv.Value))),
-            ["skipped"] = new JsonArray([.. skipped.Select(x => (JsonNode)new JsonObject { ["probe"] = x.Probe, ["reason"] = x.Why })]),
-            ["seeds"] = new JsonArray([.. outcomes.Select(o => (JsonNode)new JsonObject
-            {
-                ["probe"] = o.Probe, ["claim"] = o.Claim, ["obligation"] = o.Obligation, ["seed"] = o.Seed, ["result"] = o.Result,
-                ["violations"] = o.Violations, ["rows"] = o.Rows, ["detail"] = o.Detail,
-            })]),
-        });
-        var caught = outcomes.Count(o => o.Result == "caught");
-        var counts = outcomes.GroupBy(o => o.Result, StringComparer.Ordinal).OrderBy(g => g.Key, StringComparer.Ordinal).Select(g => $"{g.Count()} {g.Key}");
-        ctx.Out.WriteLine($"prober seeds: {string.Join(", ", counts)}, {Seconds(clock.Elapsed.TotalSeconds)} in all");
-        return caught == outcomes.Count ? 0 : 1;
-    }
-
-    public const string LastFile = "seeds-last.json";
-
-    /// <summary>
-    /// What a probe's seeded runs depend on besides the product: the probe's identity (<see cref="Ledger.Identity"/>:
-    /// its registry entry, the harness and probe sources, its rows, the axes file, the build environment, the tool),
-    /// its seeds, which that identity leaves out, and the content of each patch they apply.
-    /// </summary>
-    internal static string SeedsIdentity(Ledger ledger, string probe)
-    {
-        using var sha = System.Security.Cryptography.IncrementalHash.CreateHash(System.Security.Cryptography.HashAlgorithmName.SHA256);
-        void Add(string text) => sha.AppendData(System.Text.Encoding.UTF8.GetBytes(text + "\0"));
-        Add(ledger.Identity(probe));
-        foreach (var (obligation, seed) in SeedsOf(ledger.Registry().GetValueOrDefault(probe) ?? []))
-        {
-            Add(obligation ?? "-");
-            Add(Files.Canonical(seed));
-            var patch = Files.Str(seed["patch"]);
-            if (patch.Length > 0 && File.Exists(ledger.CorpusPath(patch))) sha.AppendData(File.ReadAllBytes(ledger.CorpusPath(patch)));
-        }
-        return Convert.ToHexStringLower(sha.GetHashAndReset())[..16];
-    }
-
-    /// <summary>
-    /// Whether a probe's seeds run without <c>--all</c>, and why: they run unless every seed was caught at a recorded
-    /// commit, under the seeds identity the probe has now, and neither the product footprint the last replay recorded for
-    /// it nor a file its seeds patch changed since that commit. A probe without a recorded footprint runs.
-    /// </summary>
-    internal static (bool Run, string Reason) Stale(Ledger ledger, string probe, JsonObject entry, JsonObject? caught, string identity, Dictionary<string, JsonObject> footprints)
-    {
-        if (caught is null) return (true, "no run caught every seed of it yet");
-        var commit = Files.Str(caught["commit"]);
-        var at = commit.Length >= 7 ? commit[..7] : commit;
-        if (Files.Str(caught["identity"]) != identity) return (true, $"its identity or its seeds changed since they were caught at {at}");
-        if (!footprints.ContainsKey(probe)) return (true, "no product footprint recorded for it (a replay records one)");
-        if (ledger.FootprintChangedSince(probe, commit, footprints)) return (true, $"its product footprint changed since {at}");
-        var patched = SeedsOf(entry).Select(x => Files.Str(x.Seed["patch"])).Where(p => p.Length > 0 && File.Exists(ledger.CorpusPath(p)))
-                                    .SelectMany(p => Patched(File.ReadAllText(ledger.CorpusPath(p)))).Distinct(StringComparer.Ordinal).ToArray();
-        if (patched.Length > 0 && Git.Run(ledger.Top, ["diff", "--quiet", commit, "HEAD", "--", .. patched]).ExitCode != 0)
-            return (true, $"a file its seeds patch changed since {at}");
-        return (false, $"every seed caught at {at}, and neither its identity nor its product footprint changed since");
-    }
-
-    /// <summary>The files a patch changes, as its <c>+++ b/</c> lines name them.</summary>
-    private static IEnumerable<string> Patched(string patch) =>
-        patch.Split('\n').Where(line => line.StartsWith("+++ b/", StringComparison.Ordinal)).Select(line => line["+++ b/".Length..].TrimEnd('\r'));
-
-    /// <summary>Applies one probe's seed, builds, runs the probe, and undoes the seed.</summary>
-    private static Outcome One(Ledger ledger, JsonObject config, IProbeAdapter adapter, string worktree, string head, string[] include,
-                               Dictionary<string, string?> environment, string results, Ledger.ProbeState s, string? obligation, JsonNode? seed,
-                               HashSet<(int Row, string Obligation)> baseline)
-    {
-        Outcome End(string result, string detail, int violations = 0, int rows = 0) => new(s.Probe, s.Claim, obligation, Describe(seed), result, violations, rows, detail);
-
-        Reset(worktree, head);
-        Replay.Overlay(ledger, config, worktree);
-        var (refused, detail, patch, env) = Validate(ledger, include, seed, worktree);
-        if (refused is not null) return End(refused, detail);
-        if (patch is not null)
-        {
-            var ran = Git.Run(worktree, "apply", "--whitespace=nowarn", patch);
-            if (ran.ExitCode != 0) return End("does not apply", FirstLine(ran.Stderr));
-        }
-        try
-        {
-            var seeded = new Dictionary<string, string?>(environment, StringComparer.Ordinal);
-            foreach (var (k, v) in env ?? []) seeded[k] = Files.Str(v);
-            var build = Timed(() => adapter.Build(worktree, seeded), out var buildSeconds);
-            if (build.ExitCode != 0) return End("build failed", $"the seeded build: {FirstLine(build)}");
-            var rows = RunProbe(adapter, worktree, s, environment, env, results, "seed");
-            // A check that broke the harness says nothing about the claim, even where it also returned a failure; a
-            // seed naming an obligation is caught only by a check naming it (decision 104), a seed naming none by any.
-            var fresh = rows.SelectMany(kv => kv.Value.Checks.Select(c => (Row: kv.Key, Check: c)))
-                            .Where(x => x.Check.CleanViolation && !baseline.Contains((x.Row, x.Check.Obligation))).OrderBy(x => x.Row).ToList();
-            var own = fresh.Where(x => obligation is null || x.Check.Obligation == obligation).ToList();
-            var caughtRows = own.Select(x => x.Row).Distinct().Count();
-            var tally = string.Join(", ", rows.Values.GroupBy(r => r.Category, StringComparer.Ordinal).OrderBy(g => g.Key, StringComparer.Ordinal).Select(g => $"{g.Key} {g.Count()}"));
-            var broken = rows.Values.Count(r => r.HarnessError);
-            var harness = broken > 0 ? $"; {broken} ended in a harness error, which is no catch" : "";
-            // Violations by checks of other obligations are no catch of this one; say whose they were, a row without checks being `claim`'s.
-            var others = fresh.Count > own.Count
-                ? $"; {fresh.Select(x => x.Row).Distinct().Count()} violate by a check naming {string.Join(", ", fresh.Select(x => x.Check.Obligation).Distinct().Order(StringComparer.Ordinal))}, not {obligation}"
-                : "";
-            if (own.Count == 0) return End("missed", $"no row violates that did not already ({rows.Count} rows: {(tally.Length > 0 ? tally : "none ran")}{harness}{others}; build {Seconds(buildSeconds)})", 0, rows.Count);
-            var example = own[0];
-            var named = example.Check.Obligation == Claim.ImplicitObligation && rows[example.Row].Checks.Count == 1 ? "" : " " + example.Check.Obligation;
-            return End("caught", $"{caughtRows} of {rows.Count} rows violate; e.g. #{example.Row}{named}: {Cut(example.Check.Reason)}", caughtRows, rows.Count);
-        }
-        finally
-        {
-            if (patch is not null) Git.Run(worktree, "apply", "-R", "--whitespace=nowarn", patch);
-        }
-    }
-
-    /// <summary>
-    /// Why a seed cannot be applied in <paramref name="worktree"/> (a result and a detail), or a null result with
-    /// the patch's full path and the environment toggle to apply. A seed names its defect and a patch, an
-    /// environment toggle or both; a patch exists in the corpus, touches only the product files and applies.
-    /// </summary>
-    private static (string? Refused, string Detail, string? Patch, JsonObject? Env) Validate(Ledger ledger, string[] include, JsonNode? seed, string worktree)
-    {
-        if (seed is not JsonObject entry) return ("no seed", "its registry entry names none", null, null);
-        var patch = Files.Str(entry["patch"]);
-        var env = entry["env"] as JsonObject;
-        if (Files.Str(entry["defect"]).Length == 0 || (patch.Length == 0 && env is not { Count: > 0 }))
-            return ("no seed", "a seed names its defect and a patch or an environment toggle", null, null);
-        if (patch.Length == 0) return (null, "", null, env);
-
-        var file = Path.GetFullPath(ledger.CorpusPath(patch));
-        if (!File.Exists(file)) return ("does not apply", $"{patch} is not in the corpus", null, null);
-        var touched = Git.Run(worktree, "apply", "--numstat", file);
-        if (touched.ExitCode != 0) return ("does not apply", FirstLine(touched.Stderr), null, null);
-        var outside = touched.Stdout.Split('\n', StringSplitOptions.RemoveEmptyEntries).Select(line => line.Split('\t')[^1].Trim())
-                             .Where(path => !include.Any(p => path.StartsWith(p.TrimEnd('/') + "/", StringComparison.Ordinal))).ToList();
-        if (outside.Count > 0) return ("does not apply", $"it patches {string.Join(", ", outside)}, outside the product files ({string.Join(", ", include)})", null, null);
-        var check = Git.Run(worktree, "apply", "--check", file);
-        return check.ExitCode != 0 ? ("does not apply", FirstLine(check.Stderr), null, null) : (null, "", file, env);
-    }
-
-    /// <summary>
-    /// What `seeds` would refuse before building anything, against this checkout: a probe without a seed, or a
-    /// seed that does not apply. No build, so the tests run it on every build and a probe registered without a
-    /// seed, or a product change that leaves a seed behind, fails there and not only at the next local run.
-    /// </summary>
-    internal static List<string> Problems(Ledger ledger)
-    {
-        var config = ledger.AxesBlock()["replay"] as JsonObject ?? [];
-        var include = Files.Strings(config["include"]).ToArray() is { Length: > 0 } inc ? inc : ["src"];
-        var problems = new List<string>();
-        // The obligations each claim lists (or its one implicit obligation), and the seeds that name each.
-        var obligations = ledger.Claims().ToDictionary(c => Files.Str(c["id"]), Claim.ObligationIds, StringComparer.Ordinal);
-        var seeded = new Dictionary<string, HashSet<string>>(StringComparer.Ordinal);
-        foreach (var (probe, entry) in ledger.Registry())
-        {
-            if (entry["retired"] is JsonValue retired && retired.TryGetValue<bool>(out var r) && r) continue;
-            var claim = Files.Str(entry["claim"]);
-            var seeds = SeedsOf(entry);
-            if (seeds.Count == 0) { problems.Add($"{probe}: no seed, its registry entry names none"); continue; }
-            foreach (var (obligation, seed) in seeds)
-            {
-                if (Validate(ledger, include, seed, ledger.Top) is { Refused: { } refused, Detail: var detail })
-                    problems.Add($"{Named(probe, obligation)}: {refused}, {detail}");
-                var ids = obligations.GetValueOrDefault(claim) ?? [Claim.ImplicitObligation];
-                // A seed naming no obligation proves the probe; it counts for the claim's one implicit obligation only.
-                var counts = obligation ?? (ids is [Claim.ImplicitObligation] ? Claim.ImplicitObligation : null);
-                if (counts is null) continue;
-                if (!ids.Contains(counts)) { problems.Add($"{Named(probe, obligation)}: names obligation {counts}, which claim {claim} does not list"); continue; }
-                (seeded.TryGetValue(claim, out var set) ? set : seeded[claim] = new(StringComparer.Ordinal)).Add(counts);
-            }
-        }
-        // Every listed obligation of a claim that has a probe is seeded by some probe of that claim (decision 104);
-        // the implicit obligation is covered by the rule above that every probe has a seed.
-        var claimed = ledger.Registry().Values.Select(e => Files.Str(e["claim"])).ToHashSet(StringComparer.Ordinal);
-        foreach (var (claim, ids) in obligations.OrderBy(kv => kv.Key, StringComparer.Ordinal))
-        {
-            if (ids is [Claim.ImplicitObligation] || !claimed.Contains(claim)) continue;
-            foreach (var id in ids.Where(id => !(seeded.GetValueOrDefault(claim)?.Contains(id) ?? false)))
-                problems.Add($"{claim}: obligation {id} has no seed in any of its probes");
-        }
-        return problems;
-    }
-
-    /// <summary>The (row, obligation) of every check that ended as a violation, clean or not: what a seed's violations are measured against.</summary>
-    private static HashSet<(int Row, string Obligation)> Violating(Dictionary<int, ProbeRun.RowOutcome> rows) =>
-        [.. rows.SelectMany(kv => kv.Value.Checks.Where(c => c.Category == "violation").Select(c => (kv.Key, c.Obligation)))];
-
-    /// <summary>Runs one probe in every one of its variants and reads how each row ended.</summary>
-    private static Dictionary<int, ProbeRun.RowOutcome> RunProbe(IProbeAdapter adapter, string worktree, Ledger.ProbeState s, Dictionary<string, string?> environment,
-                                                                 JsonObject? seedEnv, string results, string tag)
-    {
-        var rows = new Dictionary<int, ProbeRun.RowOutcome>();
-        var index = 0;
-        foreach (var variant in s.Variants.OfType<JsonObject>())
-        {
-            var name = $"{s.Probe}-{tag}-{index}";
-            var (_, outcomes) = ProbeRun.Once(adapter, worktree, s.Filter, results, name, name + ".cobertura.xml", ProbeRun.Variant(environment, variant, seedEnv));
-            foreach (var (idx, outcome) in outcomes) rows[idx] = outcome;
-            index++;
-        }
-        return rows;
-    }
-
-    /// <summary>Puts the scratch worktree's tracked files back at HEAD; the copied corpus, untracked, stays.</summary>
-    private static void Reset(string worktree, string head)
-    {
-        if (Git.Run(worktree, "checkout", "-q", "--detach", head).ExitCode != 0 && Git.Run(worktree, "reset", "-q", "--hard", head).ExitCode != 0)
-            throw new Refusal($"could not move the scratch worktree {worktree} to {head[..7]}");
-        Git.Run(worktree, "reset", "-q", "--hard", head);
-    }
-
-    private static string Describe(JsonNode? seed) =>
-        seed is JsonObject o
-            ? string.Join(" + ", new[] { Files.Str(o["patch"]), o["env"] is JsonObject env ? string.Join(",", env.Select(kv => $"{kv.Key}={Files.Str(kv.Value)}")) : "" }.Where(x => x.Length > 0))
-            : "(none)";
-
-    private static Ran Timed(Func<Ran> run, out double seconds)
-    {
-        var clock = Stopwatch.StartNew();
-        var ran = run();
-        seconds = clock.Elapsed.TotalSeconds;
-        return ran;
-    }
-
-    private static string Seconds(double seconds) => seconds.ToString("F1", CultureInfo.InvariantCulture) + " s";
-
-    private static string Cut(string s) => string.Join(" ", s.Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries)) is var line && line.Length > 160 ? line[..160] + "..." : line;
-
-    private static string FirstLine(Ran ran) => ProbeRun.FirstLine(ran);
-
-    private static string FirstLine(string text) => text.Trim().Split('\n')[0].Trim();
-}
diff --git a/tools/Prober/SourceLint.cs b/tools/Prober/SourceLint.cs
deleted file mode 100644
index 6b34502b..00000000
--- a/tools/Prober/SourceLint.cs
+++ /dev/null
@@ -1,277 +0,0 @@
-using System.Text;
-using System.Text.Json.Nodes;
-using System.Text.RegularExpressions;
-
-namespace Prober;
-
-/// <summary>
-/// What `register` and `publish` refuse in the staged probe sources before anything is built (decision 103):
-/// a <c>Note</c> whose first argument is not a key of the catalogue (<c>NoteKeys.Name</c>, a member the
-/// corpus or the staging declares), and a two-argument <c>Skip</c> (the harness's, not LINQ's) whose first
-/// argument is not a string literal naming a finding this ledger holds open. The compiler refuses a key
-/// outside the catalogue too; this says so by file and line before a build, and holds the finding ids,
-/// which stay strings. A check's <c>Inapplicable</c> and <c>Refused</c> cite their reason by a <c>Cite</c>
-/// factory with a string literal, and what it names exists: a not-promised entry of the probe's claim (of any
-/// claim, for a harness source no one probe owns), a file of the docs, a knowledge entry under design/knowledge/,
-/// a record under design/adr/. It reads code with comments and string literals blanked out, so a call written in
-/// either does not count.
-/// </summary>
-internal static partial class SourceLint
-{
-    /// <summary>The catalogue's members, as <c>harness/Row.cs</c> declares them.</summary>
-    [GeneratedRegex(@"public\s+static\s+readonly\s+NoteKeys\s+(\w+)\s*=")]
-    private static partial Regex CatalogueMember();
-
-    [GeneratedRegex(@"\.\s*(Note|Skip|Inapplicable|Refused)\s*\(")]
-    private static partial Regex Call();
-
-    [GeneratedRegex("^Cite\\s*\\.\\s*(NotPromised|Docs|Fact|Record)\\s*\\(\\s*\"([^\"\\\\]*)\"\\s*\\)$")]
-    private static partial Regex CiteFactory();
-
-    [GeneratedRegex(@"^NoteKeys\s*\.\s*(\w+)$")]
-    private static partial Regex CatalogueKey();
-
-    [GeneratedRegex("^\"([^\"\\\\]*)\"$")]
-    private static partial Regex PlainLiteral();
-
-    /// <summary>Refuses, naming each file and line, while a staged source breaks a rule; does nothing without a staging.</summary>
-    public static void Refuse(Ledger l, string command)
-    {
-        var problems = Problems(l);
-        if (problems.Count > 0)
-            throw new Refusal($"{command}: the staged sources make a note, a skip or a citation that is not written out (decision 103):\n  " + string.Join("\n  ", problems));
-    }
-
-    /// <summary>Every problem in the staged harness and probe sources, with the finding ids checked against this ledger.</summary>
-    public static List<string> Problems(Ledger l)
-    {
-        var staged = Sources(l.StagingDir).ToList();
-        if (staged.Count == 0) return [];
-        var catalogue = new HashSet<string>(StringComparer.Ordinal);
-        foreach (var file in Sources(l.CorpusDir).Concat(staged))
-            foreach (Match m in CatalogueMember().Matches(Mask(File.ReadAllText(file)))) catalogue.Add(m.Groups[1].Value);
-        var findings = l.Findings();
-        // The not-promised ids of each claim, and the claim of each registered probe: a probe's source cites its own
-        // claim's entries, a harness source that no one probe owns any claim's.
-        var notPromised = l.Claims().ToDictionary(c => Files.Str(c["id"]),
-            c => (IReadOnlySet<string>)(c["not-promised"] as JsonArray ?? []).OfType<JsonObject>().Select(n => Files.Str(n["id"])).ToHashSet(StringComparer.Ordinal), StringComparer.Ordinal);
-        // A probe's source is named for it, or for the class its filter selects (*C1Probe).
-        var claimOf = new Dictionary<string, string>(StringComparer.Ordinal);
-        foreach (var (name, entry) in l.Registry())
-        {
-            claimOf[name] = Files.Str(entry["claim"]);
-            if (Files.Str(entry["filter"]).TrimStart('*') is { Length: > 0 } cls) claimOf.TryAdd(cls, Files.Str(entry["claim"]));
-        }
-        var problems = new List<string>();
-        foreach (var file in staged)
-        {
-            // Relative to the checkout where the state lives in it, else in full (PROBE_STATE_DIR elsewhere).
-            var path = Path.GetRelativePath(l.Top, file) is var rel && !rel.StartsWith("..", StringComparison.Ordinal) ? rel.Replace('\\', '/') : file;
-            var cites = new Citations(l.Top, claimOf.TryGetValue(Path.GetFileNameWithoutExtension(file), out var claim) ? claim : null, notPromised);
-            foreach (var (line, problem, finding) in Scan(File.ReadAllText(file), catalogue, cites.Problem))
-            {
-                if (problem is not null) problems.Add($"{path}:{line}: {problem}");
-                else if (finding is not null && Status(findings, finding) is { } status)
-                    problems.Add($"{path}:{line}: Skip(\"{finding}\", ...) names {status}; a skip steps around an open finding only");
-            }
-        }
-        return problems;
-    }
-
-    private static string? Status(Dictionary<string, System.Text.Json.Nodes.JsonObject> findings, string id) =>
-        !findings.TryGetValue(id, out var f) ? "no finding this ledger has"
-        : Files.Str(f["status"]) is var status && status != "open" ? $"finding {id}, which is {status}"
-        : null;
-
-    private static IEnumerable<string> Sources(string root) =>
-        new[] { "harness", "probes" }.Select(sub => Path.Combine(root, sub)).Where(Directory.Exists)
-                                     .SelectMany(dir => Directory.EnumerateFiles(dir, "*.cs")).Order(StringComparer.Ordinal);
-
-    /// <summary>
-    /// What a citation of one source may name, and why one does not: <see cref="Problem"/> takes the factory and its
-    /// literal and says what is missing, or null. <paramref name="Claim"/> is the claim of the probe the source is, or
-    /// null for a source that no one probe owns, which may cite any claim's not-promised entry.
-    /// </summary>
-    internal sealed record Citations(string Top, string? Claim, IReadOnlyDictionary<string, IReadOnlySet<string>> NotPromised)
-    {
-        public string? Problem(string factory, string value)
-        {
-            switch (factory)
-            {
-                case "NotPromised" when Claim is not null:
-                    return NotPromised.GetValueOrDefault(Claim)?.Contains(value) ?? false ? null : $"names no not-promised entry of its claim {Claim}";
-                case "NotPromised":
-                    return NotPromised.Values.Any(ids => ids.Contains(value)) ? null : "names no not-promised entry of any claim";
-                case "Docs":
-                    var file = value.Split('#')[0];
-                    return file.Length > 0 && !file.Contains("..", StringComparison.Ordinal) && File.Exists(Path.Combine(Top, file)) ? null : $"names no file {file} in the repository";
-                case "Fact":
-                    return Named(Path.Combine(Top, "design", "knowledge"), value) ? null : "names no entry under design/knowledge/";
-                default:
-                    return Named(Path.Combine(Top, "design", "adr"), value) ? null : "names no record under design/adr/";
-            }
-        }
-
-        /// <summary>A file of the directory named for the id: <c>KB-031-...md</c>, <c>0094-...md</c>.</summary>
-        private static bool Named(string directory, string id) =>
-            id.Length > 0 && Directory.Exists(directory)
-            && Directory.EnumerateFiles(directory, "*.md").Any(f => Path.GetFileName(f).StartsWith(id + "-", StringComparison.Ordinal) || Path.GetFileName(f) == id + ".md");
-    }
-
-    /// <summary>
-    /// Each <c>Note</c>, two-argument <c>Skip</c>, and <c>Inapplicable</c> or <c>Refused</c> with an argument, of one
-    /// source: its line, the rule it breaks (or null), and for a skip written out, the finding it names.
-    /// <paramref name="cite"/> says what a citation's factory and literal fail to name; without it only the form is held.
-    /// </summary>
-    internal static IEnumerable<(int Line, string? Problem, string? Finding)> Scan(string source, IReadOnlySet<string> catalogue, Func<string, string, string?>? cite = null)
-    {
-        var masked = Mask(source);
-        foreach (Match m in Call().Matches(masked))
-        {
-            var open = m.Index + m.Length - 1;
-            var arguments = Arguments(masked, source, open);
-            if (arguments is null) continue;
-            var line = 1 + masked.AsSpan(0, m.Index).Count('\n');
-            var first = arguments.Count > 0 ? arguments[0] : "";
-            if (m.Groups[1].Value is "Inapplicable" or "Refused")
-            {
-                if (arguments.Count == 0) continue;   // an entry's own Refused() of the harness, not a check's
-                var call = m.Groups[1].Value;
-                var factory = CiteFactory().Match(first);
-                if (!factory.Success) yield return (line, $"{call}({Shown(first)}, ...) does not cite by a Cite factory with a string literal", null);
-                else if (cite?.Invoke(factory.Groups[1].Value, factory.Groups[2].Value) is { } missing)
-                    yield return (line, $"{call}({Shown(first)}, ...) {missing}", null);
-            }
-            else if (m.Groups[1].Value == "Note")
-            {
-                var key = CatalogueKey().Match(first);
-                if (!key.Success) yield return (line, $"Note({Shown(first)}, ...) does not name a key of NoteKeys", null);
-                else if (!catalogue.Contains(key.Groups[1].Value)) yield return (line, $"Note({Shown(first)}, ...) names no key of NoteKeys", null);
-            }
-            else if (arguments.Count == 2)
-            {
-                var id = PlainLiteral().Match(first);
-                yield return id.Success ? (line, null, id.Groups[1].Value) : (line, $"Skip({Shown(first)}, ...) does not name its finding as a string literal", null);
-            }
-        }
-    }
-
-    private static string Shown(string argument) => Regex.Replace(argument, @"\s+", " ") is var s && s.Length > 60 ? s[..60] + "..." : s;
-
-    /// <summary>The top-level arguments of the call whose parenthesis opens at <paramref name="open"/>, from the original text; null if it never closes.</summary>
-    private static List<string>? Arguments(string masked, string source, int open)
-    {
-        var arguments = new List<string>();
-        var depth = 0; var start = open + 1;
-        for (var i = open + 1; i < masked.Length; i++)
-        {
-            switch (masked[i])
-            {
-                case '(' or '[' or '{': depth++; break;
-                case ')' or ']' or '}' when depth > 0: depth--; break;
-                case ',' when depth == 0: arguments.Add(source[start..i].Trim()); start = i + 1; break;
-                case ')':
-                    var last = source[start..i].Trim();
-                    if (last.Length > 0 || arguments.Count > 0) arguments.Add(last);
-                    return arguments;
-            }
-        }
-        return null;
-    }
-
-    /// <summary>
-    /// The source with every comment and the content of every string and character literal blanked out (line
-    /// breaks kept, so lines still count), and the code of an interpolation hole kept as code.
-    /// </summary>
-    internal static string Mask(string s)
-    {
-        var m = new StringBuilder(s);
-        Code(s, m, 0, hole: false);
-        return m.ToString();
-    }
-
-    private static void Blank(StringBuilder m, int from, int to)
-    {
-        for (var i = from; i < to && i < m.Length; i++) if (m[i] != '\n') m[i] = ' ';
-    }
-
-    /// <summary>Scans code from <paramref name="i"/>; in a hole, returns the index after its closing brace.</summary>
-    private static int Code(string s, StringBuilder m, int i, bool hole)
-    {
-        var depth = 0;
-        while (i < s.Length)
-        {
-            var c = s[i];
-            if (c == '/' && i + 1 < s.Length && s[i + 1] == '/')
-            {
-                var end = s.IndexOf('\n', i); end = end < 0 ? s.Length : end;
-                Blank(m, i, end); i = end;
-            }
-            else if (c == '/' && i + 1 < s.Length && s[i + 1] == '*')
-            {
-                var end = s.IndexOf("*/", i + 2, StringComparison.Ordinal); end = end < 0 ? s.Length : end + 2;
-                Blank(m, i, end); i = end;
-            }
-            else if (c == '\'')
-            {
-                var j = i + 1;
-                while (j < s.Length && s[j] != '\'' && s[j] != '\n') j += s[j] == '\\' ? 2 : 1;
-                Blank(m, i + 1, j); i = j + 1;
-            }
-            else if (c is '"' or '$' or '@' && StringStart(s, i) is { } literal) i = String(s, m, i, literal);
-            else if (hole && c == '{') { depth++; i++; }
-            else if (hole && c == '}') { if (depth-- == 0) return i + 1; i++; }
-            else i++;
-        }
-        return i;
-    }
-
-    private sealed record Literal(int Dollars, bool Verbatim, int Quotes, int QuoteAt);
-
-    /// <summary>The literal that starts at <paramref name="i"/>: its <c>$</c> count, <c>@</c>, and run of quotes.</summary>
-    private static Literal? StringStart(string s, int i)
-    {
-        if (i > 0 && (char.IsLetterOrDigit(s[i - 1]) || s[i - 1] == '_') && s[i] != '"') return null;
-        var j = i; var dollars = 0; var verbatim = false;
-        while (j < s.Length && (s[j] == '$' || s[j] == '@')) { if (s[j] == '$') dollars++; else verbatim = true; j++; }
-        if (j >= s.Length || s[j] != '"') return null;
-        var quotes = 0;
-        while (j + quotes < s.Length && s[j + quotes] == '"') quotes++;
-        return new Literal(dollars, verbatim, quotes >= 3 ? quotes : 1, j);
-    }
-
-    /// <summary>Blanks one literal's content, keeping its holes as code; returns the index after it.</summary>
-    private static int String(string s, StringBuilder m, int i, Literal literal)
-    {
-        var j = literal.QuoteAt + literal.Quotes;
-        if (literal.Quotes >= 3)
-        {
-            // A raw literal ends at a run of as many quotes as it opened with. Holes in it hold no note or skip
-            // (both return nothing), so it is blanked whole.
-            var close = new string('"', literal.Quotes);
-            var end = s.IndexOf(close, j, StringComparison.Ordinal); end = end < 0 ? s.Length : end;
-            Blank(m, j, end);
-            return end + literal.Quotes;
-        }
-        var from = j;
-        while (j < s.Length)
-        {
-            var c = s[j];
-            if (literal.Verbatim && c == '"' && j + 1 < s.Length && s[j + 1] == '"') { j += 2; continue; }
-            if (!literal.Verbatim && c == '\\') { j += 2; continue; }
-            if (c == '"') { Blank(m, from, j); return j + 1; }
-            if (literal.Dollars > 0 && c == '{')
-            {
-                if (j + 1 < s.Length && s[j + 1] == '{') { j += 2; continue; }
-                Blank(m, from, j + 1);
-                j = Code(s, m, j + 1, hole: true);
-                from = j - 1;
-                continue;
-            }
-            if (!literal.Verbatim && c == '\n') break;
-            j++;
-        }
-        Blank(m, from, j);
-        return j;
-    }
-}
diff --git a/tools/Prober/TryProbe.cs b/tools/Prober/TryProbe.cs
deleted file mode 100644
index ba6e36cc..00000000
--- a/tools/Prober/TryProbe.cs
+++ /dev/null
@@ -1,151 +0,0 @@
-using System.Diagnostics;
-using System.Globalization;
-using System.Text.Json.Nodes;
-
-namespace Prober;
-
-/// <summary>
-/// <c>try</c>: the writer's loop for one probe. It moves the replay's worktree to HEAD, overlays the corpus and
-/// the branch's staging there as the replay does, builds once through the adapter (not with <c>--no-build</c>),
-/// and runs the one probe in each of its registry variants; <c>--rows</c> keeps the rows given, run through the
-/// harness's <c>PROBE_ROWS</c> one stretch of consecutive rows at a time, within the rows each variant's
-/// <c>PROBE_ONLY</c> selects. It prints each run's first line (the verdict's) and how each row ended, from the
-/// jsonl the harness writes. It records nothing, no evidence, footprint or run, so nothing under the state
-/// directory changes, and takes no round lock, but it holds the replay's worktree (<see cref="Replay.HoldWorktree"/>)
-/// while it runs: a try and a replay of the same checkout never build in it at once, and a try refuses while a
-/// replay holds it. Its exit code is the probe's: the first run's that failed, else 0; 1 when the build fails.
-/// </summary>
-internal static class TryProbe
-{
-    public static int Run(Context ctx, Args a, IProbeAdapter? adapter = null)
-    {
-        var ledger = new Ledger(ctx, a.Get("branch"));
-        var config = ledger.AxesBlock()["replay"] as JsonObject ?? throw new Refusal("the axes file's block has no \"replay\" configuration");
-        adapter ??= new DotNetAdapter(config);
-        var probe = a.Need("probe");
-        if (!ledger.Registry().TryGetValue(probe, out var entry))
-            throw new Refusal($"no probe {probe} in the registry, tracked or staged; `prober new` stages one", 2);
-        var claim = Files.Str(entry["claim"]);
-        var filter = Files.Str(entry["filter"]);
-
-        // What each variant runs: the rows its PROBE_ONLY selects, those of --rows among them, in stretches.
-        var probeRows = ledger.RowsOf(probe);
-        var asked = Indices(a.Get("rows"), probeRows.Count);
-        var plan = new List<(JsonObject Variant, List<int> Rows, List<string?> Stretches)>();
-        foreach (var variant in Ledger.VariantsOf(entry).OfType<JsonObject>())
-        {
-            var only = Files.Str(variant["PROBE_ONLY"]);
-            var selected = Enumerable.Range(0, probeRows.Count).Where(i => Replay.Selected(Files.StringMap(probeRows[i]?["row"] ?? probeRows[i]), only)).ToList();
-            if (asked is null) { plan.Add((variant, selected, [null])); continue; }
-            var rows = selected.Where(asked.Contains).ToList();
-            if (rows.Count > 0) plan.Add((variant, rows, Stretches(rows)));
-        }
-        if (asked is not null && asked.Except(plan.SelectMany(p => p.Rows)).ToList() is { Count: > 0 } unrun)
-            throw new Refusal($"no variant of {probe} runs row(s) {string.Join(", ", unrun)}: each variant's PROBE_ONLY leaves them out", 2);
-
-        var home = Replay.Home(ctx, ledger);
-        var worktree = Path.Combine(home, "wt");
-        var noBuild = a.Flag("no-build");
-        if (noBuild && !Directory.Exists(worktree)) throw new Refusal($"--no-build: the replay worktree {worktree} does not exist yet, so nothing is built; run without it", 2);
-        // The worktree is the replay's: held for the whole try, so neither moves it or builds in it under the other.
-        using var held = Replay.HoldWorktree(home)
-                         ?? throw new Refusal($"a replay in this checkout is using {worktree}; run `prober try` when it ends");
-        var head = ledger.Head;
-        var warmth = ProbeRun.Ready(ledger, worktree, head);
-        Replay.Overlay(ledger, config, worktree);
-        var environment = ProbeRun.Environment(ctx, adapter, home);
-        ctx.Out.WriteLine($"prober try: {probe} ({claim}) at {head[..7]} in {worktree}; nothing is recorded");
-        if (!noBuild)
-        {
-            var clock = Stopwatch.StartNew();
-            var build = adapter.Build(worktree, environment);
-            ctx.Out.WriteLine($"  build ({warmth}): {Seconds(clock.Elapsed.TotalSeconds)}, {ProbeRun.FirstLine(build)}");
-            if (build.ExitCode != 0) { ctx.Out.WriteLine(build.Stdout); return 1; }
-        }
-
-        // The full logs of each run, kept until the next try; the results and the rows' jsonl are thrown away.
-        var logs = Path.Combine(home, "try-logs");
-        try { if (Directory.Exists(logs)) Directory.Delete(logs, recursive: true); } catch (IOException) { }
-        var results = Directory.CreateTempSubdirectory("prober-try-").FullName;
-        var exit = 0;
-        var tally = new SortedDictionary<string, int>(StringComparer.Ordinal);
-        try
-        {
-            var index = 0;
-            foreach (var (variant, rows, stretches) in plan)
-            {
-                var label = variant.Count > 0 ? " [" + string.Join(", ", variant.Select(kv => $"{kv.Key}={Files.Str(kv.Value)}")) + "]" : "";
-                foreach (var stretch in stretches)
-                {
-                    var name = $"{probe}-try-{index++}";
-                    var env = ProbeRun.Variant(environment, variant);
-                    if (stretch is not null) env["PROBE_ROWS"] = stretch;
-                    env["PROBE_LOG_DIR"] = Path.Combine(logs, name);
-                    var clock = Stopwatch.StartNew();
-                    var (ran, outcomes) = ProbeRun.Once(adapter, worktree, filter, results, name, "", env);
-                    ctx.Out.WriteLine($"  {probe}{label}{(stretch is null ? "" : $" rows {stretch}")}: {ProbeRun.FirstLine(ran)} (exit {ran.ExitCode}, {Seconds(clock.Elapsed.TotalSeconds)})");
-                    foreach (var i in rows.Where(i => stretch is null || Within(i, stretch)))
-                    {
-                        var outcome = outcomes.GetValueOrDefault(i);
-                        var category = outcome?.Category ?? "did not run";
-                        tally[category] = tally.GetValueOrDefault(category) + 1;
-                        ctx.Out.WriteLine($"    #{i} {category}{(outcome is { Category: not "pass", Reason.Length: > 0 } ? ": " + Cut(Unprefixed(outcome.Reason, category)) : "")}");
-                    }
-                    if (ran.ExitCode != 0 && Directory.Exists(env["PROBE_LOG_DIR"])) ctx.Out.WriteLine($"    log: {env["PROBE_LOG_DIR"]}");
-                    if (ran.ExitCode != 0 && exit == 0) exit = ran.ExitCode;
-                }
-            }
-        }
-        finally
-        {
-            try { Directory.Delete(results, recursive: true); } catch (IOException) { }
-        }
-        ctx.Out.WriteLine($"prober try: {probe}: {(tally.Count == 0 ? "no rows" : string.Join(", ", tally.Select(kv => $"{kv.Key} {kv.Value}")))}; exit {exit}");
-        return exit;
-    }
-
-    /// <summary>The row indices of <c>--rows</c> (<c>i,j,...</c>, <c>a-b</c> for a stretch), or null for every row; refuses one the claim does not have.</summary>
-    internal static SortedSet<int>? Indices(string? given, int count)
-    {
-        if (given is null) return null;
-        var result = new SortedSet<int>();
-        foreach (var part in given.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
-        {
-            var bounds = part.Split('-');
-            if (bounds.Length > 2 || !bounds.All(x => int.TryParse(x, NumberStyles.None, CultureInfo.InvariantCulture, out _)))
-                throw new Refusal($"--rows takes row indices, i,j,... or a-b: not {part}", 2);
-            var lo = int.Parse(bounds[0], CultureInfo.InvariantCulture); var hi = int.Parse(bounds[^1], CultureInfo.InvariantCulture);
-            for (var i = lo; i <= hi; i++) result.Add(i);
-        }
-        if (result.Count == 0) throw new Refusal("--rows takes row indices, i,j,... or a-b", 2);
-        if (result.Max >= count) throw new Refusal($"--rows {result.Max}: the claim has {count} row(s), 0 to {count - 1}", 2);
-        return result;
-    }
-
-    /// <summary>The consecutive stretches of sorted rows, as the harness's PROBE_ROWS spells one: <c>lo-hi</c>.</summary>
-    internal static List<string?> Stretches(List<int> rows)
-    {
-        var result = new List<string?>();
-        for (var i = 0; i < rows.Count;)
-        {
-            var j = i;
-            while (j + 1 < rows.Count && rows[j + 1] == rows[j] + 1) j++;
-            result.Add(string.Create(CultureInfo.InvariantCulture, $"{rows[i]}-{rows[j]}"));
-            i = j + 1;
-        }
-        return result;
-    }
-
-    private static bool Within(int row, string stretch)
-    {
-        var bounds = stretch.Split('-');
-        return row >= int.Parse(bounds[0], CultureInfo.InvariantCulture) && row <= int.Parse(bounds[1], CultureInfo.InvariantCulture);
-    }
-
-    /// <summary>A reason without the category the harness puts in front of it (<c>violation:...</c>), which the line already names.</summary>
-    private static string Unprefixed(string reason, string category) => reason.StartsWith(category + ":", StringComparison.Ordinal) ? reason[(category.Length + 1)..] : reason;
-
-    private static string Seconds(double seconds) => seconds.ToString("F1", CultureInfo.InvariantCulture) + " s";
-
-    private static string Cut(string s) => string.Join(" ", s.Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries)) is var line && line.Length > 160 ? line[..160] + "..." : line;
-}
diff --git a/tools/probe/corpus/claims.json b/tools/probe/corpus/claims.json
deleted file mode 100644
index 301b96a8..00000000
--- a/tools/probe/corpus/claims.json
+++ /dev/null
@@ -1,16178 +0,0 @@
-[
-  {
-    "id": "C01-decimal-spelling",
-    "source": "docs/json.md#decimals-in-one-spelling",
-    "surfaces": [
-      "json"
-    ],
-    "axes": {
-      "converter": [
-        "number",
-        "string"
-      ],
-      "input": [
-        "7.80",
-        "7.8000",
-        "0.00",
-        "100",
-        "1E+2",
-        "max28digits",
-        "1e-28"
-      ]
-    },
-    "narrow": {
-      "shape.wrapped": "Register either one once, and it covers every decimal: nullable ones, dictionary keys, and every value object over a decimal, since its JSON is the underlying type's.",
-      "input.json": "Both read a number, or a string holding one, and keep the scale they read."
-    },
-    "obligations": [
-      {
-        "id": "smallest-scale",
-        "sentence": "Two converters write the smallest scale instead:"
-      },
-      {
-        "id": "number-is-a-number",
-        "sentence": "**`DecimalNumberJsonConverter`** writes it as a number.",
-        "axes": {
-          "converter": [
-            "number"
-          ]
-        }
-      },
-      {
-        "id": "string-is-a-string",
-        "sentence": "**`DecimalStringJsonConverter`** writes it as a string.",
-        "axes": {
-          "converter": [
-            "string"
-          ]
-        }
-      },
-      {
-        "id": "reads-a-number-or-a-string",
-        "sentence": "Both read a number, or a string holding one, and keep the scale they read."
-      },
-      {
-        "id": "keeps-the-scale-it-reads",
-        "sentence": "Both read a number, or a string holding one, and keep the scale they read."
-      },
-      {
-        "id": "covers-every-decimal",
-        "sentence": "Register either one once, and it covers every decimal: nullable ones, dictionary keys, and every value object over a decimal, since its JSON is the underlying type's."
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "A closed set wraps nothing, so it holds no decimal for a decimal converter to write (docs/json.md#decimals-in-one-spelling covers decimals, nullable ones, dictionary keys and value objects over a decimal).",
-        "pairs": [
-          [
-            "converter=number",
-            "shape.kind=closed-set"
-          ],
-          [
-            "converter=string",
-            "shape.kind=closed-set"
-          ],
-          [
-            "input=0.00",
-            "shape.kind=closed-set"
-          ],
-          [
-            "input=100",
-            "shape.kind=closed-set"
-          ],
-          [
-            "input=1E+2",
-            "shape.kind=closed-set"
-          ],
-          [
-            "input=1e-28",
-            "shape.kind=closed-set"
-          ],
-          [
-            "input=7.80",
-            "shape.kind=closed-set"
-          ],
-          [
-            "input=7.8000",
-            "shape.kind=closed-set"
-          ],
-          [
-            "input=max28digits",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.AllowDuplicateProperties=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.AllowDuplicateProperties=false",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.AllowOutOfOrderMetadataProperties=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.AllowOutOfOrderMetadataProperties=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.AllowTrailingCommas=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.AllowTrailingCommas=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.Converters=JsonStringEnumConverter",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.Converters=StoredJsonConverterFactory",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.Converters=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.Converters=own-for-value-object",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.Converters=own-for-wrapped",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DefaultIgnoreCondition=WhenReading",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DefaultIgnoreCondition=WhenWriting",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DefaultIgnoreCondition=WhenWritingDefault",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DefaultIgnoreCondition=WhenWritingNull",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DefaultIgnoreCondition=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DictionaryKeyPolicy=CamelCase",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DictionaryKeyPolicy=KebabCaseUpper",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DictionaryKeyPolicy=SnakeCaseLower",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DictionaryKeyPolicy=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DictionaryKeyPolicy=own-upper-case",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.Encoder=UnsafeRelaxedJsonEscaping",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.Encoder=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.IgnoreReadOnlyFields=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.IgnoreReadOnlyFields=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.IgnoreReadOnlyProperties=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.IgnoreReadOnlyProperties=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.IncludeFields=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.IncludeFields=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.MaxDepth=3",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.MaxDepth=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.NumberHandling=AllowNamedFloatingPointLiterals",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.NumberHandling=AllowReadingFromString",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.NumberHandling=WriteAsString",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.NumberHandling=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PropertyNameCaseInsensitive=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PropertyNameCaseInsensitive=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PropertyNamingPolicy=CamelCase",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PropertyNamingPolicy=KebabCaseLower",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PropertyNamingPolicy=KebabCaseUpper",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PropertyNamingPolicy=SnakeCaseLower",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PropertyNamingPolicy=SnakeCaseUpper",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PropertyNamingPolicy=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PropertyNamingPolicy=own-upper-case",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.ReadCommentHandling=Skip",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.ReadCommentHandling=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.ReferenceHandler=IgnoreCycles",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.ReferenceHandler=Preserve",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.ReferenceHandler=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.RespectNullableAnnotations=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.RespectNullableAnnotations=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.RespectRequiredConstructorParameters=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.RespectRequiredConstructorParameters=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.TypeInfoResolver=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.TypeInfoResolver=default-with-renaming-modifier",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.TypeInfoResolver=source-generated-context",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.TypeInfoResolverChain=context-then-default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.TypeInfoResolverChain=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.UnknownTypeHandling=JsonNode",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.UnknownTypeHandling=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.UnmappedMemberHandling=Disallow",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.UnmappedMemberHandling=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.containing=class",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=array-element"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=dictionary-key"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=dictionary-value"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=field"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=immutable-array-element"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=in-patch"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=list-element"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=nullable-property"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=polymorphic-derived-property"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=property"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=read-only-list-element"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=record-ctor-parameter"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=required-init"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=root"
-          ]
-        ]
-      },
-      {
-        "reason": "A value at the root is not held by a containing type, so shape.containing has nothing to apply to.",
-        "pairs": [
-          [
-            "shape.containing=class",
-            "shape.position=root"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.position=root"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.position=root"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.position=root"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.position=root"
-          ]
-        ]
-      },
-      {
-        "reason": "System.Text.Json serializes a field only under IncludeFields (or [JsonInclude]), so without it the member is in no document and no converter runs in either direction, for the plain type alike.",
-        "pairs": [
-          [
-            "json.IncludeFields=default",
-            "shape.position=field"
-          ]
-        ]
-      },
-      {
-        "reason": "System.Text.Json refuses JsonObjectCreationHandling.Populate together with a reference handler (InvalidOperationException when the options are used; harness/JsonRow.cs runs such a row without Populate), so no row can set both.",
-        "pairs": [
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C02-optional-text",
-    "source": "docs/text.md#required-and-optional",
-    "surfaces": [
-      "text"
-    ],
-    "axes": {
-      "entry": [
-        "AsOptionalText",
-        "AsOptionalIdentifier",
-        "AsText",
-        "AsIdentifier"
-      ],
-      "input": [
-        "null",
-        "empty",
-        "spaces",
-        "tab-newline",
-        "word",
-        "word+ZWSP",
-        "nbsp-only",
-        "ZWSP-only"
-      ]
-    },
-    "narrow": {
-      "shape.kind": "`AsOptionalText()` and `AsOptionalIdentifier()` return a `Result<Option<string>, TextFault>`",
-      "shape.wrapped": "`AsOptionalText()` and `AsOptionalIdentifier()` return a `Result<Option<string>, TextFault>`",
-      "text.entry": "`AsOptionalText()` and `AsOptionalIdentifier()` return a `Result<Option<string>, TextFault>`"
-    },
-    "obligations": [
-      {
-        "id": "required-blank-is-an-error",
-        "sentence": "For a required field, `Blank` is an error.",
-        "axes": {
-          "entry": [
-            "AsText",
-            "AsIdentifier"
-          ],
-          "input": [
-            "null",
-            "empty",
-            "spaces",
-            "tab-newline",
-            "nbsp-only"
-          ]
-        }
-      },
-      {
-        "id": "optional-blank-is-no-value",
-        "sentence": "For an optional one, a blank means \"no value\", and `AsOptionalText()` and `AsOptionalIdentifier()` return a `Result<Option<string>, TextFault>`.",
-        "axes": {
-          "entry": [
-            "AsOptionalText",
-            "AsOptionalIdentifier"
-          ],
-          "input": [
-            "null",
-            "empty",
-            "spaces",
-            "tab-newline",
-            "nbsp-only"
-          ]
-        }
-      },
-      {
-        "id": "hidden-is-an-error-in-both",
-        "sentence": "`Hidden` is an error in both cases.",
-        "axes": {
-          "input": [
-            "word+ZWSP",
-            "ZWSP-only"
-          ]
-        }
-      },
-      {
-        "id": "null-is-blank",
-        "sentence": "A null string is `Blank`.",
-        "axes": {
-          "input": [
-            "null"
-          ]
-        }
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "as-text-refused-in-globalization-invariant-mode",
-        "source": "docs/text.md#globalization-invariant-mode",
-        "sentence": "So `AsText()` throws `PlatformNotSupportedException` there, on its first call, whatever the string.",
-        "axes": {
-          "text.culture": [
-            "globalization-invariant"
-          ],
-          "entry": [
-            "AsText",
-            "AsOptionalText"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "Not promised (as-text-refused-in-globalization-invariant-mode): `AsText()` throws `PlatformNotSupportedException` in globalization-invariant mode (docs/text.md#globalization-invariant-mode), and `AsOptionalText()`, which calls it, throws with it, so C02OptionalTextProbe checks that refusal without credit and runs the row on the identifier counterpart; no row holds the pair.",
-        "pairs": [
-          [
-            "entry=AsText",
-            "text.culture=globalization-invariant"
-          ],
-          [
-            "entry=AsOptionalText",
-            "text.culture=globalization-invariant"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C03-composed-faults",
-    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#faults-of-several-types",
-    "surfaces": [
-      "http"
-    ],
-    "axes": {
-      "arity": [
-        "2",
-        "3"
-      ],
-      "error": [
-        "first-set",
-        "last-set",
-        "with-detail",
-        "with-rule"
-      ]
-    },
-    "obligations": [
-      {
-        "id": "each-error-own-set",
-        "sentence": "Each error is answered as its own set maps it."
-      },
-      {
-        "id": "detail-and-rule-intact",
-        "sentence": "`Fault<AccountFault, EditFault>` (from CodoMetis.TypeKit) holds one error of either set, with its detail and rule intact.",
-        "axes": {
-          "error": [
-            "with-detail",
-            "with-rule"
-          ]
-        }
-      },
-      {
-        "id": "statuses-ascending",
-        "sentence": "So its operation lists the statuses of both sets, in ascending order, with the problem types of both where they share a status."
-      },
-      {
-        "id": "shared-status-types",
-        "sentence": "So its operation lists the statuses of both sets, in ascending order, with the problem types of both where they share a status."
-      },
-      {
-        "id": "unmapped-set-stops-start",
-        "sentence": "The host doesn't start while either set is unmapped."
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "System.Text.Json refuses PreferredObjectCreationHandling.Populate together with a ReferenceHandler on the options object; JsonRow substitutes the default, so the pair never applies.",
-        "pairs": [
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C04-without-faults",
-    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#leaving-out-what-a-route-cannot-answer",
-    "surfaces": [
-      "http"
-    ],
-    "axes": {
-      "scope": [
-        "endpoint",
-        "group",
-        "controller"
-      ],
-      "combined": [
-        "alone",
-        "with-WithFaultStatus-on-group"
-      ]
-    },
-    "obligations": [
-      {
-        "id": "doc-omits-left-out",
-        "sentence": "The operation then lists no status and no problem type for a member left out."
-      },
-      {
-        "id": "reporting-left-out-throws",
-        "sentence": "Reporting a member left out anyway throws an `InvalidOperationException` naming the endpoint and the member, rather than answering with a status the document doesn't list."
-      },
-      {
-        "id": "narrows-wider-status",
-        "sentence": "If a group gives `NotFound` a status and one endpoint inside leaves `NotFound` out, that endpoint drops it, and the group's other endpoints keep the status.",
-        "axes": {
-          "scope": [
-            "endpoint",
-            "controller"
-          ],
-          "combined": [
-            "with-WithFaultStatus-on-group"
-          ]
-        }
-      },
-      {
-        "id": "left-out-everywhere-stops-start",
-        "sentence": "**These stop the host from starting**, as for a status: a value or a name no member has, a status that every endpoint it's set on leaves out (on the endpoint itself, or on a group whose endpoints all leave the member out), and a group or a controller none of whose endpoints answers with the type.",
-        "axes": {
-          "scope": [
-            "group"
-          ],
-          "combined": [
-            "with-WithFaultStatus-on-group"
-          ]
-        }
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "controller-scope-is-mvc",
-        "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#leaving-out-what-a-route-cannot-answer",
-        "sentence": "**In MVC**, an action or a controller says it with `[WithoutFaults<AccountFault>(nameof(AccountFault.NotFound))]`.",
-        "axes": {
-          "scope": [
-            "controller"
-          ],
-          "http.host": [
-            "minimal",
-            "route-group"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "A minimal-API host has no controller to leave a member out on: the controller scope is MVC's (not-promised controller-scope-is-mvc).",
-        "pairs": [
-          [
-            "scope=controller",
-            "http.host=minimal"
-          ],
-          [
-            "scope=controller",
-            "http.host=route-group"
-          ]
-        ]
-      },
-      {
-        "reason": "System.Text.Json refuses PreferredObjectCreationHandling.Populate together with a ReferenceHandler on the options object; JsonRow substitutes the default, so the pair never applies.",
-        "pairs": [
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C05-with-rule",
-    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#the-rule-that-refused",
-    "surfaces": [
-      "http"
-    ],
-    "axes": {
-      "ruletype": [
-        "enum",
-        "closed-set",
-        "nested-enum",
-        "flags-combination",
-        "undefined-cast"
-      ],
-      "qualified": [
-        "bare",
-        "QualifiedFaultNames"
-      ]
-    },
-    "obligations": [
-      {
-        "id": "rule-qualified",
-        "sentence": "The problem carries it as `rule`, qualified with its type's name, so two types' `Blank` can be told apart:",
-        "axes": {
-          "ruletype": [
-            "enum",
-            "closed-set"
-          ]
-        }
-      },
-      {
-        "id": "nested-chain",
-        "sentence": "A rule of a nested type is named after its nesting chain, whatever `QualifiedFaultNames` says.",
-        "axes": {
-          "ruletype": [
-            "nested-enum"
-          ]
-        }
-      },
-      {
-        "id": "stays-the-errors",
-        "sentence": "The status, the mapping and the document stay the error's.",
-        "axes": {
-          "ruletype": [
-            "enum",
-            "closed-set",
-            "nested-enum"
-          ]
-        }
-      },
-      {
-        "id": "unnamed-value-throws",
-        "sentence": "A value no member names, such as a combination of flags or a cast number, throws where it's given.",
-        "axes": {
-          "ruletype": [
-            "flags-combination",
-            "undefined-cast"
-          ]
-        }
-      },
-      {
-        "id": "no-namespace",
-        "sentence": "**The name carries no namespace**, which would publish your application's structure to every client.",
-        "axes": {
-          "ruletype": [
-            "enum",
-            "closed-set",
-            "nested-enum"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "System.Text.Json refuses PreferredObjectCreationHandling.Populate together with a ReferenceHandler on the options object; JsonRow substitutes the default, so the pair never applies.",
-        "pairs": [
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C06-fault-kinds",
-    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#a-closed-set-as-the-fault-type",
-    "surfaces": [
-      "http"
-    ],
-    "axes": {
-      "kind": [
-        "PreconditionFailed",
-        "Malformed",
-        "Invalid",
-        "Unavailable"
-      ]
-    },
-    "obligations": [
-      {
-        "id": "kind-gives-status",
-        "sentence": "The kind gives the status:"
-      },
-      {
-        "id": "description-as-detail",
-        "sentence": "The description becomes the problem's `detail`, so a client can show it."
-      },
-      {
-        "id": "no-description-no-detail",
-        "sentence": "A member without one has no `detail`."
-      },
-      {
-        "id": "member-must-have-kind",
-        "sentence": "**A member must have a kind.** A member whose kind is `default`, which is no kind, fails this call."
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "System.Text.Json refuses PreferredObjectCreationHandling.Populate together with a ReferenceHandler on the options object; JsonRow substitutes the default, so the pair never applies.",
-        "pairs": [
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C07-fault-responses-blanket",
-    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#every-fault-set-at-once",
-    "surfaces": [
-      "http"
-    ],
-    "axes": {
-      "mapping": [
-        "by-kind",
-        "own-IFault-mapping"
-      ],
-      "set": [
-        "fault-set",
-        "own-mapped-set",
-        "enum-unmapped",
-        "member-without-kind",
-        "mapping-throws",
-        "status-not-error"
-      ]
-    },
-    "obligations": [
-      {
-        "id": "by-kind",
-        "sentence": "every fault set an endpoint answers with, by its kind",
-        "axes": {
-          "mapping": [
-            "by-kind"
-          ]
-        }
-      },
-      {
-        "id": "own-mapping",
-        "sentence": "The mapping can be your own. It reads each member's kind and description through `IFault`:",
-        "axes": {
-          "mapping": [
-            "own-IFault-mapping"
-          ]
-        }
-      },
-      {
-        "id": "own-set-keeps-mapping",
-        "sentence": "A set mapped on its own keeps its mapping.",
-        "axes": {
-          "set": [
-            "own-mapped-set"
-          ]
-        }
-      },
-      {
-        "id": "enum-needs-own-mapping",
-        "sentence": "Neither has a kind, and the host doesn't start while an endpoint answers with one that's unmapped.",
-        "axes": {
-          "set": [
-            "enum-unmapped"
-          ]
-        }
-      },
-      {
-        "id": "member-without-kind-stops-start",
-        "sentence": "A member with no kind stops the start, and so does one the mapping throws for or gives a status that isn't an error.",
-        "axes": {
-          "set": [
-            "member-without-kind"
-          ]
-        }
-      },
-      {
-        "id": "mapping-refusal-stops-start",
-        "sentence": "A member with no kind stops the start, and so does one the mapping throws for or gives a status that isn't an error.",
-        "axes": {
-          "set": [
-            "mapping-throws",
-            "status-not-error"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "System.Text.Json refuses PreferredObjectCreationHandling.Populate together with a ReferenceHandler on the options object; JsonRow substitutes the default, so the pair never applies.",
-        "pairs": [
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C08-same-name-warning",
-    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#faults-of-several-types",
-    "surfaces": [
-      "http"
-    ],
-    "axes": {
-      "naming": [
-        "bare",
-        "qualified"
-      ],
-      "arity": [
-        "2",
-        "3"
-      ],
-      "leave-out": [
-        "none",
-        "WithoutFaults-one"
-      ]
-    },
-    "obligations": [
-      {
-        "id": "bare-names-warn",
-        "sentence": "With bare names, the default, that's `AccountFault.NotFound` beside an `EditFault.NotFound`.",
-        "axes": {
-          "naming": [
-            "bare"
-          ]
-        }
-      },
-      {
-        "id": "qualified-chain-warns",
-        "sentence": "With qualified names, it's two sets with one nesting chain in two namespaces, since the name carries no namespace.",
-        "axes": {
-          "naming": [
-            "qualified"
-          ]
-        }
-      },
-      {
-        "id": "warning-names-both",
-        "sentence": "A client reads the two errors as one, so the host logs a warning at startup naming both.",
-        "axes": {
-          "leave-out": [
-            "none"
-          ]
-        }
-      },
-      {
-        "id": "qualified-names-fix",
-        "sentence": "Fix it with `QualifiedFaultNames`, a rename, or by leaving one out of the route",
-        "axes": {
-          "naming": [
-            "qualified"
-          ]
-        }
-      },
-      {
-        "id": "leave-one-out-fixes",
-        "sentence": "Fix it with `QualifiedFaultNames`, a rename, or by leaving one out of the route",
-        "axes": {
-          "leave-out": [
-            "WithoutFaults-one"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "System.Text.Json refuses PreferredObjectCreationHandling.Populate together with a ReferenceHandler on the options object; JsonRow substitutes the default, so the pair never applies.",
-        "pairs": [
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C09-base-record-equality",
-    "source": "CHANGELOG.md#2.1.0-fixed",
-    "surfaces": [
-      "generation"
-    ],
-    "axes": {
-      "base-equality": [
-        "none",
-        "override-Equals",
-        "override-GetHashCode",
-        "explicit-IEquatable"
-      ],
-      "collection": [
-        "HashSet",
-        "Dictionary-key",
-        "Distinct"
-      ]
-    },
-    "narrow": {
-      "shape.position": "Over a base record, a value object's equality is its wrapped value's, in a collection of the base too, whatever equality the base declares.",
-      "shape.containing": "Over a base record, a value object's equality is its wrapped value's, in a collection of the base too, whatever equality the base declares."
-    },
-    "obligations": [
-      {
-        "id": "equal-by-the-wrapped-value",
-        "sentence": "Over a base record, a value object's equality is its wrapped value's"
-      },
-      {
-        "id": "in-a-collection-of-the-base",
-        "sentence": "in a collection of the base too, whatever equality the base declares."
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "A record struct or a closed set has no base record: C# gives a struct no base type, and a closed set is a sealed class that is never a record (CMTK1020).",
-        "pairs": [
-          [
-            "base-equality=explicit-IEquatable",
-            "shape.kind=closed-set"
-          ],
-          [
-            "base-equality=explicit-IEquatable",
-            "shape.kind=record-struct"
-          ],
-          [
-            "base-equality=explicit-IEquatable",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "base-equality=none",
-            "shape.kind=closed-set"
-          ],
-          [
-            "base-equality=none",
-            "shape.kind=record-struct"
-          ],
-          [
-            "base-equality=none",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "base-equality=override-Equals",
-            "shape.kind=closed-set"
-          ],
-          [
-            "base-equality=override-Equals",
-            "shape.kind=record-struct"
-          ],
-          [
-            "base-equality=override-Equals",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "base-equality=override-GetHashCode",
-            "shape.kind=closed-set"
-          ],
-          [
-            "base-equality=override-GetHashCode",
-            "shape.kind=record-struct"
-          ],
-          [
-            "base-equality=override-GetHashCode",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "collection=Dictionary-key",
-            "shape.kind=closed-set"
-          ],
-          [
-            "collection=Dictionary-key",
-            "shape.kind=record-struct"
-          ],
-          [
-            "collection=Dictionary-key",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "collection=Distinct",
-            "shape.kind=closed-set"
-          ],
-          [
-            "collection=Distinct",
-            "shape.kind=record-struct"
-          ],
-          [
-            "collection=Distinct",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "collection=HashSet",
-            "shape.kind=closed-set"
-          ],
-          [
-            "collection=HashSet",
-            "shape.kind=record-struct"
-          ],
-          [
-            "collection=HashSet",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ]
-        ]
-      },
-      {
-        "reason": "A value object nested in a generic type fails the build with CMTK1005 (Generators README, Build errors), so it has no generated equality or parsing to check.",
-        "pairs": [
-          [
-            "base-equality=explicit-IEquatable",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "base-equality=none",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "base-equality=override-Equals",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "base-equality=override-GetHashCode",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "collection=Dictionary-key",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "collection=Distinct",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "collection=HashSet",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=in-generic-type"
-          ]
-        ]
-      },
-      {
-        "reason": "The claim is about a value object over a base record; with no base record it states nothing.",
-        "pairs": [
-          [
-            "base-equality=explicit-IEquatable",
-            "shape.inheritance=none"
-          ],
-          [
-            "base-equality=none",
-            "shape.inheritance=none"
-          ],
-          [
-            "base-equality=override-Equals",
-            "shape.inheritance=none"
-          ],
-          [
-            "base-equality=override-GetHashCode",
-            "shape.inheritance=none"
-          ],
-          [
-            "collection=Dictionary-key",
-            "shape.inheritance=none"
-          ],
-          [
-            "collection=Distinct",
-            "shape.inheritance=none"
-          ],
-          [
-            "collection=HashSet",
-            "shape.inheritance=none"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.kind=sealed-record-class"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.kind=validated-class"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ]
-        ]
-      },
-      {
-        "reason": "A declaration of a refused kind fails the build (CMTK1005, CMTK1006), so it is generated into nothing; .claude/probe-axes.md: shape.refused-kind is taken only where the refusal is the claim.",
-        "pairs": [
-          [
-            "base-equality=explicit-IEquatable",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "base-equality=explicit-IEquatable",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "base-equality=explicit-IEquatable",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "base-equality=explicit-IEquatable",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "base-equality=none",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "base-equality=none",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "base-equality=none",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "base-equality=none",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "base-equality=override-Equals",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "base-equality=override-Equals",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "base-equality=override-Equals",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "base-equality=override-Equals",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "base-equality=override-GetHashCode",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "base-equality=override-GetHashCode",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "base-equality=override-GetHashCode",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "base-equality=override-GetHashCode",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "collection=Dictionary-key",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "collection=Dictionary-key",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "collection=Dictionary-key",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "collection=Dictionary-key",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "collection=Distinct",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "collection=Distinct",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "collection=Distinct",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "collection=Distinct",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "collection=HashSet",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "collection=HashSet",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "collection=HashSet",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "collection=HashSet",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "base-equality=explicit-IEquatable",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "base-equality=explicit-IEquatable",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "base-equality=explicit-IEquatable",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "base-equality=explicit-IEquatable",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "base-equality=explicit-IEquatable",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "base-equality=none",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "base-equality=none",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "base-equality=none",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "base-equality=none",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "base-equality=none",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "base-equality=override-Equals",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "base-equality=override-Equals",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "base-equality=override-Equals",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "base-equality=override-Equals",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "base-equality=override-Equals",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "base-equality=override-GetHashCode",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "base-equality=override-GetHashCode",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "base-equality=override-GetHashCode",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "base-equality=override-GetHashCode",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "base-equality=override-GetHashCode",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "collection=Dictionary-key",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "collection=Dictionary-key",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "collection=Dictionary-key",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "collection=Dictionary-key",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "collection=Dictionary-key",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "collection=Distinct",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "collection=Distinct",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "collection=Distinct",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "collection=Distinct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "collection=Distinct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "collection=HashSet",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "collection=HashSet",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "collection=HashSet",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "collection=HashSet",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "collection=HashSet",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=ulong"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C10-preserve-guard",
-    "source": "src/CodoMetis.TypeKit.Generators/README.md#json",
-    "surfaces": [
-      "json"
-    ],
-    "axes": {
-      "handler": [
-        "Preserve",
-        "IgnoreCycles",
-        "none"
-      ]
-    },
-    "obligations": [
-      {
-        "id": "refused-where-references-could-be-written",
-        "sentence": "**Preserved references** (`ReferenceHandler.Preserve`) throw a `NotSupportedException` where the serializer could write `$id` or `$ref` inside the underlying value.",
-        "axes": {
-          "handler": [
-            "Preserve"
-          ],
-          "shape.wrapped": [
-            "own-record-class"
-          ]
-        }
-      },
-      {
-        "id": "value-converters-unaffected",
-        "sentence": "These are unaffected: a value the serializer writes with a value converter (a number, a string, a `Guid`, a `Uri`)",
-        "axes": {
-          "handler": [
-            "Preserve"
-          ]
-        }
-      },
-      {
-        "id": "own-converters-unaffected",
-        "sentence": "anything a converter of your own writes, on the options or on one property",
-        "axes": {
-          "json.Converters": [
-            "own-for-wrapped",
-            "own-for-value-object"
-          ]
-        }
-      },
-      {
-        "id": "ignore-cycles-unaffected",
-        "sentence": "a struct of such values, and `ReferenceHandler.IgnoreCycles`.",
-        "axes": {
-          "handler": [
-            "IgnoreCycles"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "handler is this claim's name for JsonSerializerOptions.ReferenceHandler (Preserve, IgnoreCycles, none = default), the same setting as json.ReferenceHandler; one setting cannot hold two values in one row.",
-        "pairs": [
-          [
-            "handler=IgnoreCycles",
-            "json.ReferenceHandler=Preserve"
-          ],
-          [
-            "handler=IgnoreCycles",
-            "json.ReferenceHandler=default"
-          ],
-          [
-            "handler=Preserve",
-            "json.ReferenceHandler=IgnoreCycles"
-          ],
-          [
-            "handler=Preserve",
-            "json.ReferenceHandler=default"
-          ],
-          [
-            "handler=none",
-            "json.ReferenceHandler=IgnoreCycles"
-          ],
-          [
-            "handler=none",
-            "json.ReferenceHandler=Preserve"
-          ]
-        ]
-      },
-      {
-        "reason": "A closed set wraps nothing (Generators README#closed-sets: a sealed class whose instances are its members), so it has no shape.wrapped.",
-        "pairs": [
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=ulong"
-          ]
-        ]
-      },
-      {
-        "reason": "A value at the root is not held by a containing type, so shape.containing has nothing to apply to.",
-        "pairs": [
-          [
-            "shape.containing=class",
-            "shape.position=root"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.position=root"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.position=root"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.position=root"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.position=root"
-          ]
-        ]
-      },
-      {
-        "reason": "System.Text.Json refuses JsonObjectCreationHandling.Populate together with a reference handler (InvalidOperationException when the options are used; harness/JsonRow.cs runs such a row without Populate), so no row can set both.",
-        "pairs": [
-          [
-            "handler=IgnoreCycles",
-            "json.PreferredObjectCreationHandling=Populate"
-          ],
-          [
-            "handler=Preserve",
-            "json.PreferredObjectCreationHandling=Populate"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C11-parse-shapes-build",
-    "source": "CHANGELOG.md#2.1.0-fixed",
-    "surfaces": [
-      "text",
-      "generation"
-    ],
-    "axes": {
-      "parse-shape": [
-        "implicit-result",
-        "ref-text",
-        "abstract-string-ctor",
-        "ordinary"
-      ]
-    },
-    "narrow": {
-      "shape.position": "A wrapped type's `Parse` whose result can't be assigned to it, or that takes its text by `ref`, or an abstract class's string constructor, no longer breaks the build; the value object has no parsing.",
-      "shape.containing": "A wrapped type's `Parse` whose result can't be assigned to it, or that takes its text by `ref`, or an abstract class's string constructor, no longer breaks the build; the value object has no parsing."
-    },
-    "obligations": [
-      {
-        "id": "implicit-result",
-        "sentence": "A wrapped type's `Parse` whose result can't be assigned to it",
-        "axes": {
-          "parse-shape": [
-            "implicit-result"
-          ]
-        }
-      },
-      {
-        "id": "ref-text",
-        "sentence": "or that takes its text by `ref`",
-        "axes": {
-          "parse-shape": [
-            "ref-text"
-          ]
-        }
-      },
-      {
-        "id": "abstract-string-constructor",
-        "sentence": "or an abstract class's string constructor, no longer breaks the build; the value object has no parsing.",
-        "axes": {
-          "parse-shape": [
-            "abstract-string-ctor"
-          ]
-        }
-      },
-      {
-        "id": "parsing-where-it-can-be-parsed",
-        "sentence": "`IParsable`/`ISpanParsable`/`IUtf8SpanParsable`, formatting in the invariant culture",
-        "axes": {
-          "parse-shape": [
-            "ordinary"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "shape.wrapped": [
-                "Uri",
-                "enum",
-                "flags-enum",
-                "NodaTime.Instant"
-              ],
-              "text.entry": [
-                "ISpanParsable"
-              ]
-            },
-            "cite": "not-promised:no-span-parsing-without-the-underlying-types"
-          }
-        ]
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "no-span-parsing-without-the-underlying-types",
-        "source": "src/CodoMetis.TypeKit.Generators/README.md#what-is-generated",
-        "sentence": "A `Uri`, an enum and a NodaTime type have neither.",
-        "axes": {
-          "shape.wrapped": [
-            "Uri",
-            "enum",
-            "flags-enum",
-            "NodaTime.Instant"
-          ],
-          "text.entry": [
-            "ISpanParsable"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "A closed set wraps no type, so it has no wrapped type's Parse to take for its parser.",
-        "pairs": [
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.kind=closed-set"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.kind=closed-set"
-          ],
-          [
-            "parse-shape=ordinary",
-            "shape.kind=closed-set"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.kind=closed-set"
-          ],
-          [
-            "process.converter-lookup=none",
-            "shape.kind=closed-set"
-          ],
-          [
-            "process.converter-lookup=wrapped-type-converter-looked-up-first",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.kind=closed-set",
-            "text.culture=ar-SA"
-          ],
-          [
-            "shape.kind=closed-set",
-            "text.culture=de-DE"
-          ],
-          [
-            "shape.kind=closed-set",
-            "text.culture=globalization-invariant"
-          ],
-          [
-            "shape.kind=closed-set",
-            "text.culture=invariant"
-          ],
-          [
-            "shape.kind=closed-set",
-            "text.culture=tr-TR"
-          ],
-          [
-            "shape.kind=closed-set",
-            "text.entry=IParsable"
-          ],
-          [
-            "shape.kind=closed-set",
-            "text.entry=ISpanParsable"
-          ],
-          [
-            "shape.kind=closed-set",
-            "text.entry=Parse"
-          ],
-          [
-            "shape.kind=closed-set",
-            "text.entry=ToString-format"
-          ],
-          [
-            "shape.kind=closed-set",
-            "text.entry=TryFormat-short-span"
-          ],
-          [
-            "shape.kind=closed-set",
-            "text.entry=TryFrom"
-          ],
-          [
-            "shape.kind=closed-set",
-            "text.entry=TryParse"
-          ],
-          [
-            "shape.kind=closed-set",
-            "text.entry=type-converter"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ]
-        ]
-      },
-      {
-        "reason": "A value object nested in a generic type fails the build with CMTK1005 (Generators README, Build errors), so it has no generated equality or parsing to check.",
-        "pairs": [
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "parse-shape=ordinary",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "process.converter-lookup=none",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "process.converter-lookup=wrapped-type-converter-looked-up-first",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "text.culture=ar-SA"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "text.culture=de-DE"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "text.culture=globalization-invariant"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "text.culture=invariant"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "text.culture=tr-TR"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "text.entry=IParsable"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "text.entry=ISpanParsable"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "text.entry=Parse"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "text.entry=ToString-format"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "text.entry=TryFormat-short-span"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "text.entry=TryFrom"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "text.entry=TryParse"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "text.entry=type-converter"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=in-generic-type"
-          ]
-        ]
-      },
-      {
-        "reason": "A record struct has no base type, so it cannot derive from a base record or inherit a base's explicit IEquatable.",
-        "pairs": [
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.kind=validated-struct"
-          ]
-        ]
-      },
-      {
-        "reason": "The parse shape is the wrapped type itself, a class of its own; a value object over one of the catalogue's wrapped types is the ordinary shape.",
-        "pairs": [
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=bool"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=byte"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=char"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=double"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=enum"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=int"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=long"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=string"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=bool"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=byte"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=char"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=double"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=enum"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=int"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=long"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=string"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=bool"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=byte"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=char"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=double"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=enum"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=int"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=long"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=string"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.wrapped=ulong"
-          ]
-        ]
-      },
-      {
-        "reason": "A declaration of a refused kind fails the build (CMTK1005, CMTK1006), so it is generated into nothing; .claude/probe-axes.md: shape.refused-kind is taken only where the refusal is the claim.",
-        "pairs": [
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "parse-shape=ordinary",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "parse-shape=ordinary",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "parse-shape=ordinary",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "parse-shape=ordinary",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "process.converter-lookup=none",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "process.converter-lookup=none",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "process.converter-lookup=none",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "process.converter-lookup=none",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "process.converter-lookup=wrapped-type-converter-looked-up-first",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "process.converter-lookup=wrapped-type-converter-looked-up-first",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "process.converter-lookup=wrapped-type-converter-looked-up-first",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "process.converter-lookup=wrapped-type-converter-looked-up-first",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "text.culture=ar-SA"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "text.culture=de-DE"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "text.culture=globalization-invariant"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "text.culture=invariant"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "text.culture=tr-TR"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "text.entry=IParsable"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "text.entry=ISpanParsable"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "text.entry=Parse"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "text.entry=ToString-format"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "text.entry=TryFormat-short-span"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "text.entry=TryFrom"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "text.entry=TryParse"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "text.entry=type-converter"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "text.culture=ar-SA"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "text.culture=de-DE"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "text.culture=globalization-invariant"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "text.culture=invariant"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "text.culture=tr-TR"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "text.entry=IParsable"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "text.entry=ISpanParsable"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "text.entry=Parse"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "text.entry=ToString-format"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "text.entry=TryFormat-short-span"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "text.entry=TryFrom"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "text.entry=TryParse"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "text.entry=type-converter"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "text.culture=ar-SA"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "text.culture=de-DE"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "text.culture=globalization-invariant"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "text.culture=invariant"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "text.culture=tr-TR"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "text.entry=IParsable"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "text.entry=ISpanParsable"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "text.entry=Parse"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "text.entry=ToString-format"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "text.entry=TryFormat-short-span"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "text.entry=TryFrom"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "text.entry=TryParse"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "text.entry=type-converter"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "text.culture=ar-SA"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "text.culture=de-DE"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "text.culture=globalization-invariant"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "text.culture=invariant"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "text.culture=tr-TR"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "text.entry=IParsable"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "text.entry=ISpanParsable"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "text.entry=Parse"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "text.entry=ToString-format"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "text.entry=TryFormat-short-span"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "text.entry=TryFrom"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "text.entry=TryParse"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "text.entry=type-converter"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "parse-shape=abstract-string-ctor",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "parse-shape=implicit-result",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "parse-shape=ordinary",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "parse-shape=ordinary",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "parse-shape=ordinary",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "parse-shape=ordinary",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "parse-shape=ordinary",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "parse-shape=ref-text",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "process.converter-lookup=none",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "process.converter-lookup=none",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "process.converter-lookup=none",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "process.converter-lookup=none",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "process.converter-lookup=none",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "process.converter-lookup=wrapped-type-converter-looked-up-first",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "process.converter-lookup=wrapped-type-converter-looked-up-first",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "process.converter-lookup=wrapped-type-converter-looked-up-first",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "process.converter-lookup=wrapped-type-converter-looked-up-first",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "process.converter-lookup=wrapped-type-converter-looked-up-first",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "text.culture=ar-SA"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "text.culture=ar-SA"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "text.culture=ar-SA"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "text.culture=ar-SA"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "text.culture=ar-SA"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "text.culture=de-DE"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "text.culture=de-DE"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "text.culture=de-DE"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "text.culture=de-DE"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "text.culture=de-DE"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "text.culture=globalization-invariant"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "text.culture=globalization-invariant"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "text.culture=globalization-invariant"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "text.culture=globalization-invariant"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "text.culture=globalization-invariant"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "text.culture=invariant"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "text.culture=invariant"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "text.culture=invariant"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "text.culture=invariant"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "text.culture=invariant"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "text.culture=tr-TR"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "text.culture=tr-TR"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "text.culture=tr-TR"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "text.culture=tr-TR"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "text.culture=tr-TR"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "text.entry=IParsable"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "text.entry=IParsable"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "text.entry=IParsable"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "text.entry=IParsable"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "text.entry=IParsable"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "text.entry=ISpanParsable"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "text.entry=ISpanParsable"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "text.entry=ISpanParsable"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "text.entry=ISpanParsable"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "text.entry=ISpanParsable"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "text.entry=Parse"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "text.entry=Parse"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "text.entry=Parse"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "text.entry=Parse"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "text.entry=Parse"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "text.entry=ToString-format"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "text.entry=ToString-format"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "text.entry=ToString-format"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "text.entry=ToString-format"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "text.entry=ToString-format"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "text.entry=TryFormat-short-span"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "text.entry=TryFormat-short-span"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "text.entry=TryFormat-short-span"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "text.entry=TryFormat-short-span"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "text.entry=TryFormat-short-span"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "text.entry=TryFrom"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "text.entry=TryFrom"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "text.entry=TryFrom"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "text.entry=TryFrom"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "text.entry=TryFrom"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "text.entry=TryParse"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "text.entry=TryParse"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "text.entry=TryParse"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "text.entry=TryParse"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "text.entry=TryParse"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "text.entry=type-converter"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "text.entry=type-converter"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "text.entry=type-converter"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "text.entry=type-converter"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "text.entry=type-converter"
-          ]
-        ]
-      },
-      {
-        "reason": "A `Uri`, an enum and a NodaTime type have neither (Generators README, What is generated: no ISpanParsable or IUtf8SpanParsable where the underlying type has none, not-promised no-span-parsing-without-the-underlying-types), so parsing-where-it-can-be-parsed is inapplicable there and no check that reads shape.wrapped can credit them.",
-        "pairs": [
-          [
-            "shape.wrapped=NodaTime.Instant",
-            "text.entry=ISpanParsable"
-          ],
-          [
-            "shape.wrapped=Uri",
-            "text.entry=ISpanParsable"
-          ],
-          [
-            "shape.wrapped=enum",
-            "text.entry=ISpanParsable"
-          ],
-          [
-            "shape.wrapped=flags-enum",
-            "text.entry=ISpanParsable"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C12-described-converter",
-    "source": "docs/json.md#describing-what-a-converter-writes",
-    "surfaces": [
-      "http"
-    ],
-    "axes": {
-      "source": [
-        "IDescribedJsonConverter",
-        "JsonSchemaDescriptions",
-        "decimal-converter"
-      ],
-      "http.host": [
-        "minimal",
-        "mvc",
-        "both",
-        "route-group",
-        "controller-without-ApiController-visible"
-      ]
-    },
-    "obligations": [
-      {
-        "id": "own-converter-describes-itself",
-        "sentence": "**Your own converter** implements `IDescribedJsonConverter` and describes itself, as both decimal converters do.",
-        "axes": {
-          "source": [
-            "IDescribedJsonConverter",
-            "decimal-converter"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "json.ReferenceHandler": [
-                "Preserve"
-              ]
-            },
-            "cite": "record:0099"
-          },
-          {
-            "axes": {
-              "json.MaxDepth": [
-                "3"
-              ],
-              "source": [
-                "IDescribedJsonConverter",
-                "JsonSchemaDescriptions"
-              ]
-            },
-            "cite": "record:0099"
-          }
-        ]
-      },
-      {
-        "id": "options-describe",
-        "sentence": "**A converter someone else wrote**, or the serializer's own enum converter, is described in the options by `JsonSchemaDescriptions`.",
-        "axes": {
-          "source": [
-            "JsonSchemaDescriptions"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "json.ReferenceHandler": [
-                "Preserve"
-              ]
-            },
-            "cite": "record:0099"
-          },
-          {
-            "axes": {
-              "json.MaxDepth": [
-                "3"
-              ],
-              "source": [
-                "IDescribedJsonConverter",
-                "JsonSchemaDescriptions"
-              ]
-            },
-            "cite": "record:0099"
-          }
-        ]
-      },
-      {
-        "id": "every-position",
-        "sentence": "With CodoMetis.TypeKit.AspNetCore, `AddTypeKit()` writes the same descriptions into the OpenAPI document, in every position, a list's elements and a dictionary's values included.",
-        "inapplicable": [
-          {
-            "axes": {
-              "json.ReferenceHandler": [
-                "Preserve"
-              ]
-            },
-            "cite": "record:0099"
-          },
-          {
-            "axes": {
-              "json.MaxDepth": [
-                "3"
-              ],
-              "source": [
-                "IDescribedJsonConverter",
-                "JsonSchemaDescriptions"
-              ]
-            },
-            "cite": "record:0099"
-          }
-        ]
-      },
-      {
-        "id": "parameter-keeps-aspnet",
-        "sentence": "So it keeps the description ASP.NET gives the type without your converters",
-        "axes": {
-          "source": [
-            "decimal-converter"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "json.ReferenceHandler": [
-                "Preserve"
-              ]
-            },
-            "cite": "record:0099"
-          },
-          {
-            "axes": {
-              "json.MaxDepth": [
-                "3"
-              ],
-              "source": [
-                "IDescribedJsonConverter",
-                "JsonSchemaDescriptions"
-              ]
-            },
-            "cite": "record:0099"
-          }
-        ]
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "System.Text.Json refuses PreferredObjectCreationHandling.Populate together with a ReferenceHandler on the options object; JsonRow substitutes the default, so the pair never applies.",
-        "pairs": [
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C13-patch-required",
-    "source": "docs/merge-patches.md#required-constructor-parameters",
-    "surfaces": [
-      "http"
-    ],
-    "axes": {
-      "declared": [
-        "init",
-        "ctor-parameter"
-      ],
-      "http.host": [
-        "minimal",
-        "mvc",
-        "both",
-        "route-group",
-        "controller-without-ApiController-visible"
-      ]
-    },
-    "obligations": [
-      {
-        "id": "doc-required-where-rejected",
-        "sentence": "So the document never calls a field optional when the endpoint rejects a request without it.",
-        "axes": {
-          "declared": [
-            "ctor-parameter"
-          ],
-          "json.RespectRequiredConstructorParameters": [
-            "true"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "json.ReferenceHandler": [
-                "Preserve"
-              ]
-            },
-            "cite": "record:0099"
-          }
-        ]
-      },
-      {
-        "id": "doc-optional-where-absent",
-        "sentence": "`AddTypeKit()` leaves a patch out of `required` where the serializer lets it be absent, and keeps it there where the options reject a body without it.",
-        "inapplicable": [
-          {
-            "axes": {
-              "json.ReferenceHandler": [
-                "Preserve"
-              ]
-            },
-            "cite": "record:0099"
-          }
-        ]
-      },
-      {
-        "id": "absent-is-default",
-        "sentence": "a property the request leaves out keeps its default, which is `Absent`."
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "System.Text.Json refuses PreferredObjectCreationHandling.Populate together with a ReferenceHandler on the options object; JsonRow substitutes the default, so the pair never applies.",
-        "pairs": [
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C14-declared-problem",
-    "source": "CHANGELOG.md#2.1.0-fixed",
-    "surfaces": [
-      "http"
-    ],
-    "axes": {
-      "declared": [
-        "ProducesProblem",
-        "ProducesResponseType",
-        "none"
-      ],
-      "http.host": [
-        "minimal",
-        "mvc",
-        "both",
-        "route-group",
-        "controller-without-ApiController-visible"
-      ]
-    },
-    "obligations": [
-      {
-        "id": "declared-describes-fault",
-        "sentence": "OpenAPI: a problem response an endpoint declares itself (`ProducesProblem`, `[ProducesResponseType]`) describes `fault`, and names its problem types.",
-        "axes": {
-          "declared": [
-            "ProducesProblem",
-            "ProducesResponseType"
-          ]
-        }
-      },
-      {
-        "id": "declared-names-types",
-        "sentence": "OpenAPI: a problem response an endpoint declares itself (`ProducesProblem`, `[ProducesResponseType]`) describes `fault`, and names its problem types.",
-        "axes": {
-          "declared": [
-            "ProducesProblem",
-            "ProducesResponseType"
-          ]
-        }
-      },
-      {
-        "id": "ascending-with-declared",
-        "sentence": "OpenAPI: an operation with fault responses lists every status ascending, the ones its endpoint declares itself among them",
-        "axes": {
-          "declared": [
-            "ProducesProblem",
-            "ProducesResponseType"
-          ]
-        }
-      },
-      {
-        "id": "application-json-declared",
-        "sentence": "OpenAPI: a problem response an endpoint declares as `application/json`, such as `Produces<ProblemDetails>(404)` or `[ProducesResponseType<ProblemDetails>(404)]`, describes `fault` and `rule` and names its problem types, and keeps its media type",
-        "axes": {
-          "declared": [
-            "ProducesResponseType"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "System.Text.Json refuses PreferredObjectCreationHandling.Populate together with a ReferenceHandler on the options object; JsonRow substitutes the default, so the pair never applies.",
-        "pairs": [
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C15-mvc-fault-status-doc",
-    "source": "CHANGELOG.md#2.1.0-fixed",
-    "surfaces": [
-      "http"
-    ],
-    "axes": {
-      "setter": [
-        "MapControllers().WithFaultStatus",
-        "action-attribute",
-        "controller-attribute"
-      ],
-      "kind": [
-        "status-only",
-        "WithoutFaults"
-      ],
-      "http.host": [
-        "minimal",
-        "mvc",
-        "both",
-        "route-group",
-        "controller-without-ApiController-visible"
-      ]
-    },
-    "obligations": [
-      {
-        "id": "builder-reaches-doc",
-        "sentence": "OpenAPI: a `WithFaultStatus` on the builder `MapControllers()` returns reaches the document, as it reached the response."
-      },
-      {
-        "id": "without-faults-leaves-doc",
-        "sentence": "**`WithoutFaults`** and `[WithoutFaults<T>]`: a route leaves out of its document the members it never answers with, and reporting one throws"
-      },
-      {
-        "id": "status-per-scope",
-        "sentence": "`WithFaultStatus`/`[FaultStatus<T>]` per endpoint, group or controller"
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "System.Text.Json refuses PreferredObjectCreationHandling.Populate together with a ReferenceHandler on the options object; JsonRow substitutes the default, so the pair never applies.",
-        "pairs": [
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C16-options-agreement",
-    "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says",
-    "surfaces": [
-      "http"
-    ],
-    "axes": {
-      "difference": [
-        "converter-only-http",
-        "naming-policy",
-        "number-handling"
-      ],
-      "http.host": [
-        "minimal",
-        "mvc",
-        "both",
-        "route-group",
-        "controller-without-ApiController-visible"
-      ]
-    },
-    "obligations": [
-      {
-        "id": "differing-refused",
-        "sentence": "Otherwise building the document fails rather than describe JSON the controllers don't write.",
-        "axes": {
-          "difference": [
-            "converter-only-http"
-          ],
-          "http.host": [
-            "mvc",
-            "both",
-            "controller-without-ApiController-visible"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "json.ReferenceHandler": [
-                "Preserve"
-              ]
-            },
-            "cite": "record:0099"
-          }
-        ]
-      },
-      {
-        "id": "error-names-type-and-descriptions",
-        "sentence": "The error names the type and what each set of options says of it, also for a type held only inside a patch.",
-        "axes": {
-          "difference": [
-            "converter-only-http"
-          ],
-          "http.host": [
-            "mvc",
-            "both",
-            "controller-without-ApiController-visible"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "json.ReferenceHandler": [
-                "Preserve"
-              ]
-            },
-            "cite": "record:0099"
-          }
-        ]
-      },
-      {
-        "id": "patch-held-refused",
-        "sentence": "The error names the type and what each set of options says of it, also for a type held only inside a patch.",
-        "axes": {
-          "difference": [
-            "converter-only-http"
-          ],
-          "http.host": [
-            "mvc",
-            "both",
-            "controller-without-ApiController-visible"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "json.ReferenceHandler": [
-                "Preserve"
-              ]
-            },
-            "cite": "record:0099"
-          }
-        ]
-      },
-      {
-        "id": "same-converters-build",
-        "sentence": "A host with controllers registers the same converters and descriptions on both, in the same order.",
-        "axes": {
-          "difference": [
-            "naming-policy",
-            "number-handling"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "json.ReferenceHandler": [
-                "Preserve"
-              ]
-            },
-            "cite": "record:0099"
-          }
-        ]
-      },
-      {
-        "id": "minimal-host-not-compared",
-        "sentence": "A host with controllers registers the same converters and descriptions on both, in the same order.",
-        "axes": {
-          "difference": [
-            "converter-only-http"
-          ],
-          "http.host": [
-            "minimal",
-            "route-group"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "json.ReferenceHandler": [
-                "Preserve"
-              ]
-            },
-            "cite": "record:0099"
-          }
-        ]
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "only-converters-and-descriptions-compared",
-        "source": "design/adr/0071-converters-say-what-they-write.md#0071-json-converters-say-what-they-write-decimals-get-one-spelling",
-        "sentence": "Where the host has a controller, building the document fails when the two option sets do not carry the same described converters and description sets, by type, naming each that differs; a host of minimal APIs alone is never compared.",
-        "axes": {
-          "difference": [
-            "naming-policy",
-            "number-handling"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "System.Text.Json refuses PreferredObjectCreationHandling.Populate together with a ReferenceHandler on the options object; JsonRow substitutes the default, so the pair never applies.",
-        "pairs": [
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C17-cmtk0014",
-    "source": "src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0014",
-    "surfaces": [
-      "analyzers"
-    ],
-    "axes": {
-      "value": [
-        "(FaultKind)9",
-        "default",
-        "valid"
-      ],
-      "site": [
-        "attribute-argument",
-        "cast",
-        "default-literal"
-      ]
-    },
-    "obligations": [
-      {
-        "id": "a-cast-naming-no-member",
-        "sentence": "A `FaultKind` or a `ConstructorAccessibility` that names no member: a cast",
-        "axes": {
-          "value": [
-            "(FaultKind)9"
-          ]
-        }
-      },
-      {
-        "id": "default-and-zero",
-        "sentence": "`default(FaultKind)`, a zero",
-        "axes": {
-          "value": [
-            "default"
-          ]
-        }
-      },
-      {
-        "id": "constructor-accessibility-too",
-        "sentence": "[RequireParameterlessConstructor((ConstructorAccessibility)7)]   // CMTK0014: no member, read as public",
-        "axes": {
-          "site": [
-            "attribute-argument"
-          ],
-          "value": [
-            "(FaultKind)9"
-          ]
-        }
-      },
-      {
-        "id": "reported-where-written",
-        "sentence": "Both are reported where the value is written:",
-        "axes": {
-          "value": [
-            "(FaultKind)9",
-            "default"
-          ]
-        }
-      },
-      {
-        "id": "a-member-is-silent",
-        "sentence": "public static readonly ImportFault Duplicate = new(FaultKind.Conflict);",
-        "axes": {
-          "value": [
-            "valid"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "A default literal is the value 0, so it cannot spell (FaultKind)9 or a member: FaultKind's members start at 1.",
-        "pairs": [
-          [
-            "site=default-literal",
-            "value=(FaultKind)9"
-          ],
-          [
-            "site=default-literal",
-            "value=valid"
-          ]
-        ]
-      },
-      {
-        "reason": "A record struct has no base type, so it cannot derive from a base record or inherit a base's explicit IEquatable.",
-        "pairs": [
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.kind=validated-struct"
-          ]
-        ]
-      },
-      {
-        "reason": "A closed set wraps no type, so a closed set over a wrapped type cannot be declared.",
-        "pairs": [
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=ulong"
-          ]
-        ]
-      },
-      {
-        "reason": "Declared as .claude/probe-axes.md says (as C22's harness, BuildRefusals.cs, declares it), a closed set named as one of its generated members leaves their writing to the generators, so in this compilation without them it does not implement IClosedSet's members: the compiler's own CS0535, and no row can hold it beside the analyzer's places.",
-        "pairs": [
-          [
-            "shape.containing=class",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=array-element",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=dictionary-key",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=dictionary-value",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=field",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=immutable-array-element",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=in-patch",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=list-element",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=nullable-property",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=polymorphic-derived-property",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=property",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=read-only-list-element",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=record-ctor-parameter",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=required-init",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=root",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "site=attribute-argument"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "site=cast"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "site=default-literal"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "value=(FaultKind)9"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "value=default"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "value=valid"
-          ]
-        ]
-      },
-      {
-        "reason": "A value object with a hand-written operator == and != between two of the type is C#'s own CS0111 without the generators (Generators README, Build errors: CMTK1011, 'which C# also reports as CS0111'), since a record already declares both, so this compilation without the generators cannot hold it.",
-        "pairs": [
-          [
-            "shape.containing=class",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=array-element",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=dictionary-key",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=dictionary-value",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=field",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=immutable-array-element",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=in-patch",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=list-element",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=nullable-property",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=polymorphic-derived-property",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=property",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=read-only-list-element",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=record-ctor-parameter",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=required-init",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=root",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "site=attribute-argument"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "site=cast"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "site=default-literal"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "value=(FaultKind)9"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "value=default"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "value=valid"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C18-cmtk1023",
-    "source": "src/CodoMetis.TypeKit.Generators/README.md#build-errors",
-    "surfaces": [
-      "generation"
-    ],
-    "axes": {
-      "base-member": [
-        "Equals",
-        "GetHashCode",
-        "IEquatable"
-      ]
-    },
-    "obligations": [
-      {
-        "id": "names-each-base-member",
-        "sentence": "So a hand-written `Equals(TBase)`, `GetHashCode()` or `IEquatable<TBase>.Equals` on a base record isn't used, and a warning names it (CMTK1023)."
-      },
-      {
-        "id": "a-warning-and-generated",
-        "sentence": "A warning, and the value object is generated."
-      },
-      {
-        "id": "generated-equality-never-calls-the-base",
-        "sentence": "Over a base record, the generated `Equals(TSelf)` and `GetHashCode()` compare the underlying value alone, and never call the base's."
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "A record struct or a closed set has no base record: C# gives a struct no base type, and a closed set is a sealed class that is never a record (CMTK1020). CMTK1023 is about a base record's equality.",
-        "pairs": [
-          [
-            "base-member=Equals",
-            "shape.kind=closed-set"
-          ],
-          [
-            "base-member=Equals",
-            "shape.kind=record-struct"
-          ],
-          [
-            "base-member=Equals",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "base-member=GetHashCode",
-            "shape.kind=closed-set"
-          ],
-          [
-            "base-member=GetHashCode",
-            "shape.kind=record-struct"
-          ],
-          [
-            "base-member=GetHashCode",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "base-member=IEquatable",
-            "shape.kind=closed-set"
-          ],
-          [
-            "base-member=IEquatable",
-            "shape.kind=record-struct"
-          ],
-          [
-            "base-member=IEquatable",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.containing=class",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.containing=class",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.containing=class",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=array-element"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=dictionary-key"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=dictionary-value"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=field"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=immutable-array-element"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=in-patch"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=list-element"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=nullable-property"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=polymorphic-derived-property"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=property"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=read-only-list-element"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=record-ctor-parameter"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=required-init"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=root"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.position=array-element"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.position=dictionary-key"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.position=dictionary-value"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.position=field"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.position=immutable-array-element"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.position=in-patch"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.position=list-element"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.position=nullable-property"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.position=polymorphic-derived-property"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.position=property"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.position=read-only-list-element"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.position=record-ctor-parameter"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.position=required-init"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.position=root"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.position=array-element"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.position=dictionary-key"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.position=dictionary-value"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.position=field"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.position=immutable-array-element"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.position=in-patch"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.position=list-element"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.position=nullable-property"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.position=polymorphic-derived-property"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.position=property"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.position=read-only-list-element"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.position=record-ctor-parameter"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.position=required-init"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.position=root"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ]
-        ]
-      },
-      {
-        "reason": "A value object nested in a generic type fails the build with CMTK1005 (Generators README, Build errors), so it has no generated equality or parsing to check.",
-        "pairs": [
-          [
-            "base-member=Equals",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "base-member=GetHashCode",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "base-member=IEquatable",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.containing=class",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=array-element",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=dictionary-key",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=dictionary-value",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=field",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=immutable-array-element",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=in-patch",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=list-element",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=nullable-property",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=polymorphic-derived-property",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=property",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=read-only-list-element",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=record-ctor-parameter",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=required-init",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=root",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=in-generic-type"
-          ]
-        ]
-      },
-      {
-        "reason": "Without a base record there is no base to declare Equals, GetHashCode or IEquatable on.",
-        "pairs": [
-          [
-            "base-member=Equals",
-            "shape.inheritance=none"
-          ],
-          [
-            "base-member=GetHashCode",
-            "shape.inheritance=none"
-          ],
-          [
-            "base-member=IEquatable",
-            "shape.inheritance=none"
-          ],
-          [
-            "shape.containing=class",
-            "shape.inheritance=none"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.inheritance=none"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.inheritance=none"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.inheritance=none"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.inheritance=none"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.kind=sealed-record-class"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.kind=validated-class"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.position=array-element"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.position=dictionary-key"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.position=dictionary-value"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.position=field"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.position=immutable-array-element"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.position=in-patch"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.position=list-element"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.position=nullable-property"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.position=polymorphic-derived-property"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.position=property"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.position=read-only-list-element"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.position=record-ctor-parameter"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.position=required-init"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.position=root"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ]
-        ]
-      },
-      {
-        "reason": "CMTK1023 is 'A warning, and the value object is generated' (Generators README, Build errors); a refused declaration is not generated. A declaration of a refused kind fails the build (CMTK1005, CMTK1006), so it is generated into nothing; .claude/probe-axes.md: shape.refused-kind is taken only where the refusal is the claim.",
-        "pairs": [
-          [
-            "base-member=Equals",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "base-member=Equals",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "base-member=Equals",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "base-member=Equals",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "base-member=GetHashCode",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "base-member=GetHashCode",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "base-member=GetHashCode",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "base-member=GetHashCode",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "base-member=IEquatable",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "base-member=IEquatable",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "base-member=IEquatable",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "base-member=IEquatable",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.containing=class",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.containing=class",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.containing=class",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.containing=class",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.position=array-element",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.position=array-element",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.position=array-element",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.position=array-element",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.position=dictionary-key",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.position=dictionary-key",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.position=dictionary-key",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.position=dictionary-key",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.position=dictionary-value",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.position=dictionary-value",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.position=dictionary-value",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.position=dictionary-value",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.position=field",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.position=field",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.position=field",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.position=field",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.position=immutable-array-element",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.position=immutable-array-element",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.position=immutable-array-element",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.position=immutable-array-element",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.position=in-patch",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.position=in-patch",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.position=in-patch",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.position=in-patch",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.position=list-element",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.position=list-element",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.position=list-element",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.position=list-element",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.position=nullable-property",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.position=nullable-property",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.position=nullable-property",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.position=nullable-property",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.position=polymorphic-derived-property",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.position=polymorphic-derived-property",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.position=polymorphic-derived-property",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.position=polymorphic-derived-property",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.position=property",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.position=property",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.position=property",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.position=property",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.position=read-only-list-element",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.position=read-only-list-element",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.position=read-only-list-element",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.position=read-only-list-element",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.position=record-ctor-parameter",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.position=record-ctor-parameter",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.position=record-ctor-parameter",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.position=record-ctor-parameter",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.position=required-init",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.position=required-init",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.position=required-init",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.position=required-init",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.position=root",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.position=root",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.position=root",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ],
-          [
-            "shape.position=root",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "base-member=Equals",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "base-member=Equals",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "base-member=Equals",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "base-member=Equals",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "base-member=Equals",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "base-member=GetHashCode",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "base-member=GetHashCode",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "base-member=GetHashCode",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "base-member=GetHashCode",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "base-member=GetHashCode",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "base-member=IEquatable",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "base-member=IEquatable",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "base-member=IEquatable",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "base-member=IEquatable",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "base-member=IEquatable",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.containing=class",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.containing=class",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.containing=class",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.containing=class",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.containing=class",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=array-element",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.position=array-element",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.position=array-element",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.position=array-element",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=array-element",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=dictionary-key",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.position=dictionary-key",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.position=dictionary-key",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.position=dictionary-key",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=dictionary-key",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=dictionary-value",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.position=dictionary-value",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.position=dictionary-value",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.position=dictionary-value",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=dictionary-value",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=field",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.position=field",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.position=field",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.position=field",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=field",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=immutable-array-element",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.position=immutable-array-element",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.position=immutable-array-element",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.position=immutable-array-element",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=immutable-array-element",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=in-patch",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.position=in-patch",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.position=in-patch",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.position=in-patch",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=in-patch",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=list-element",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.position=list-element",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.position=list-element",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.position=list-element",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=list-element",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=nullable-property",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.position=nullable-property",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.position=nullable-property",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.position=nullable-property",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=nullable-property",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=polymorphic-derived-property",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.position=polymorphic-derived-property",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.position=polymorphic-derived-property",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.position=polymorphic-derived-property",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=polymorphic-derived-property",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=property",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.position=property",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.position=property",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.position=property",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=property",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=read-only-list-element",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.position=read-only-list-element",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.position=read-only-list-element",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.position=read-only-list-element",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=read-only-list-element",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=record-ctor-parameter",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.position=record-ctor-parameter",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.position=record-ctor-parameter",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.position=record-ctor-parameter",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=record-ctor-parameter",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=required-init",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.position=required-init",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.position=required-init",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.position=required-init",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=required-init",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=root",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.position=root",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.position=root",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.position=root",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=root",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=ulong"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C19-cmtk0010-kinds",
-    "source": "docs/type-constraints.md#the-kind-of-a-type-argument",
-    "surfaces": [
-      "analyzers"
-    ],
-    "axes": {
-      "attribute": [
-        "Interface",
-        "Unsealed",
-        "ValueObject",
-        "ClosedSet",
-        "FlagsEnum",
-        "ReadOnlyStruct",
-        "Distinct",
-        "Unrelated"
-      ],
-      "site": [
-        "call",
-        "foreach",
-        "await",
-        "Deconstruct",
-        "collection-expression"
-      ]
-    },
-    "obligations": [
-      {
-        "id": "interface-and-unsealed",
-        "sentence": "**`[Interface]` and `[Unsealed]`** are what a proxy needs: a contract to implement, or a class to derive from.",
-        "axes": {
-          "attribute": [
-            "Interface",
-            "Unsealed"
-          ]
-        }
-      },
-      {
-        "id": "value-object-and-closed-set",
-        "sentence": "**`[ValueObject]` and `[ClosedSet]`** accept their marker interface with any type argument.",
-        "axes": {
-          "attribute": [
-            "ValueObject",
-            "ClosedSet"
-          ]
-        }
-      },
-      {
-        "id": "flags-enum-and-read-only-struct",
-        "sentence": "**`[FlagsEnum]` and `[ReadOnlyStruct]`** narrow what `where T : Enum` and `where T : struct` admit.",
-        "axes": {
-          "attribute": [
-            "FlagsEnum",
-            "ReadOnlyStruct"
-          ]
-        }
-      },
-      {
-        "id": "a-pair-once-at-the-later-argument",
-        "sentence": "A breach is reported once, at the later argument.",
-        "axes": {
-          "attribute": [
-            "Distinct",
-            "Unrelated"
-          ]
-        }
-      },
-      {
-        "id": "methods-the-compiler-calls",
-        "sentence": "**Methods the compiler calls for you:** a `foreach`'s `GetEnumerator`, an `await`'s `GetAwaiter`, a `Deconstruct` (in `var (a, b) = x`, a `foreach`, or a pattern like `x is (1, 2)`), and a collection expression's `Add` or builder method.",
-        "axes": {
-          "site": [
-            "foreach",
-            "await",
-            "Deconstruct",
-            "collection-expression"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "A record struct has no base type, so it cannot derive from a base record or inherit a base's explicit IEquatable.",
-        "pairs": [
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.kind=validated-struct"
-          ]
-        ]
-      },
-      {
-        "reason": "A closed set wraps no type, so a closed set over a wrapped type cannot be declared.",
-        "pairs": [
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=ulong"
-          ]
-        ]
-      },
-      {
-        "reason": "Declared as .claude/probe-axes.md says (as C22's harness, BuildRefusals.cs, declares it), a closed set named as one of its generated members leaves their writing to the generators, so in this compilation without them it does not implement IClosedSet's members: the compiler's own CS0535, and no row can hold it beside the analyzer's places.",
-        "pairs": [
-          [
-            "attribute=ClosedSet",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "attribute=Distinct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "attribute=FlagsEnum",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "attribute=Interface",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "attribute=ReadOnlyStruct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "attribute=Unrelated",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "attribute=Unsealed",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "attribute=ValueObject",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.containing=class",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=array-element",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=dictionary-key",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=dictionary-value",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=field",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=immutable-array-element",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=in-patch",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=list-element",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=nullable-property",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=polymorphic-derived-property",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=property",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=read-only-list-element",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=record-ctor-parameter",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=required-init",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.position=root",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "site=Deconstruct"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "site=await"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "site=call"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "site=collection-expression"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "site=foreach"
-          ]
-        ]
-      },
-      {
-        "reason": "A value object with a hand-written operator == and != between two of the type is C#'s own CS0111 without the generators (Generators README, Build errors: CMTK1011, 'which C# also reports as CS0111'), since a record already declares both, so this compilation without the generators cannot hold it.",
-        "pairs": [
-          [
-            "attribute=ClosedSet",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "attribute=Distinct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "attribute=FlagsEnum",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "attribute=Interface",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "attribute=ReadOnlyStruct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "attribute=Unrelated",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "attribute=Unsealed",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "attribute=ValueObject",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.containing=class",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=array-element",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=dictionary-key",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=dictionary-value",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=field",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=immutable-array-element",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=in-patch",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=list-element",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=nullable-property",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=polymorphic-derived-property",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=property",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=read-only-list-element",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=record-ctor-parameter",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=required-init",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.position=root",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=nested-in-class"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=nested-in-struct"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=nested-two-levels"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=top-level"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "site=Deconstruct"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "site=await"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "site=call"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "site=collection-expression"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "site=foreach"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C20-testing-shouldhold",
-    "source": "src/CodoMetis.TypeKit.Testing/README.md",
-    "surfaces": [
-      "option-result"
-    ],
-    "axes": {
-      "arity": [
-        "2",
-        "3"
-      ],
-      "set": [
-        "first",
-        "last"
-      ],
-      "wrong-reason": [
-        "no",
-        "yes"
-      ]
-    },
-    "obligations": [
-      {
-        "id": "fails-unless-it-holds-that-reason",
-        "sentence": "`ShouldHold(reason)` fails unless the fault holds that reason, whichever of its types the reason belongs to."
-      },
-      {
-        "id": "whichever-of-its-types",
-        "sentence": "whichever of its types the reason belongs to",
-        "axes": {
-          "set": [
-            "first",
-            "last"
-          ],
-          "arity": [
-            "2",
-            "3"
-          ]
-        }
-      },
-      {
-        "id": "hands-back-detail-and-rule",
-        "sentence": "It hands back the `Fault<TFault>` with its detail and rule intact.",
-        "axes": {
-          "wrong-reason": [
-            "no"
-          ]
-        }
-      },
-      {
-        "id": "uninitialized-fails",
-        "sentence": "**An uninitialized result fails every assertion.**",
-        "axes": {
-          "or.operation": [
-            "default-instance"
-          ]
-        }
-      },
-      {
-        "id": "a-failure-says-the-outcome",
-        "sentence": "**A failure says what the outcome was**",
-        "axes": {
-          "wrong-reason": [
-            "yes"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "Result.Catch turns an exception into a Result, never an Option (src/CodoMetis.TypeKit/ResultExtensions.cs), so no row can catch into an Option.",
-        "pairs": [
-          [
-            "or.operation=Result.Catch",
-            "or.shape=Option"
-          ]
-        ]
-      },
-      {
-        "reason": "Result<TError> has no Select or SelectMany, so no query expression produces one, and FirstOrNone returns an Option<T>, never a Result<TError> (src/CodoMetis.TypeKit/ResultExtensions.cs and OptionExtensions.cs).",
-        "pairs": [
-          [
-            "or.operation=FirstOrNone",
-            "or.shape=Result-E"
-          ],
-          [
-            "or.operation=query-syntax",
-            "or.shape=Result-E"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C21-openapi-schema-parity",
-    "source": "README.md#what-you-get",
-    "surfaces": [
-      "http",
-      "json"
-    ],
-    "axes": {
-      "http.host": [
-        "minimal",
-        "mvc",
-        "both",
-        "route-group",
-        "controller-without-ApiController-visible"
-      ]
-    },
-    "obligations": [
-      {
-        "id": "the-underlying-types-schema",
-        "sentence": "The JSON, the database column and the OpenAPI schema are the same as the underlying type's.",
-        "inapplicable": [
-          {
-            "axes": {
-              "json.Converters": [
-                "own-for-value-object"
-              ]
-            },
-            "cite": "not-promised:own-converter-for-the-value-object"
-          },
-          {
-            "axes": {
-              "json.Converters": [
-                "own-for-wrapped"
-              ]
-            },
-            "cite": "not-promised:own-converter-for-the-wrapped-type"
-          },
-          {
-            "axes": {
-              "json.ReferenceHandler": [
-                "Preserve"
-              ]
-            },
-            "cite": "record:0099"
-          },
-          {
-            "axes": {
-              "json.NumberHandling": [
-                "WriteAsString"
-              ],
-              "shape.wrapped": [
-                "char"
-              ]
-            },
-            "cite": "fact:KB-042"
-          },
-          {
-            "axes": {
-              "json.MaxDepth": [
-                "3"
-              ],
-              "shape.wrapped": [
-                "own-record-class"
-              ]
-            },
-            "cite": "record:0099"
-          }
-        ]
-      },
-      {
-        "id": "nullable-admits-null-as-the-wrapped-does",
-        "sentence": "Its OpenAPI schema is the one ASP.NET Core publishes for the underlying type.",
-        "axes": {
-          "http.nullability": [
-            "nullable"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "json.Converters": [
-                "own-for-value-object"
-              ]
-            },
-            "cite": "not-promised:own-converter-for-the-value-object"
-          },
-          {
-            "axes": {
-              "json.Converters": [
-                "own-for-wrapped"
-              ]
-            },
-            "cite": "not-promised:own-converter-for-the-wrapped-type"
-          },
-          {
-            "axes": {
-              "json.ReferenceHandler": [
-                "Preserve"
-              ]
-            },
-            "cite": "record:0099"
-          },
-          {
-            "axes": {
-              "json.NumberHandling": [
-                "WriteAsString"
-              ],
-              "shape.wrapped": [
-                "char"
-              ]
-            },
-            "cite": "fact:KB-042"
-          },
-          {
-            "axes": {
-              "json.MaxDepth": [
-                "3"
-              ],
-              "shape.wrapped": [
-                "own-record-class"
-              ]
-            },
-            "cite": "record:0099"
-          }
-        ]
-      },
-      {
-        "id": "container-elements",
-        "sentence": "Its OpenAPI schema is the one ASP.NET Core publishes for the underlying type.",
-        "axes": {
-          "shape.position": [
-            "list-element",
-            "array-element",
-            "immutable-array-element",
-            "read-only-list-element",
-            "dictionary-value"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "json.Converters": [
-                "own-for-value-object"
-              ]
-            },
-            "cite": "not-promised:own-converter-for-the-value-object"
-          },
-          {
-            "axes": {
-              "json.Converters": [
-                "own-for-wrapped"
-              ]
-            },
-            "cite": "not-promised:own-converter-for-the-wrapped-type"
-          },
-          {
-            "axes": {
-              "json.ReferenceHandler": [
-                "Preserve"
-              ]
-            },
-            "cite": "record:0099"
-          },
-          {
-            "axes": {
-              "json.NumberHandling": [
-                "WriteAsString"
-              ],
-              "shape.wrapped": [
-                "char"
-              ]
-            },
-            "cite": "fact:KB-042"
-          },
-          {
-            "axes": {
-              "json.MaxDepth": [
-                "3"
-              ],
-              "shape.wrapped": [
-                "own-record-class"
-              ]
-            },
-            "cite": "record:0099"
-          }
-        ]
-      },
-      {
-        "id": "dictionary-key",
-        "sentence": "Its OpenAPI schema is the one ASP.NET Core publishes for the underlying type.",
-        "axes": {
-          "shape.position": [
-            "dictionary-key"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "json.Converters": [
-                "own-for-value-object"
-              ]
-            },
-            "cite": "not-promised:own-converter-for-the-value-object"
-          },
-          {
-            "axes": {
-              "json.Converters": [
-                "own-for-wrapped"
-              ]
-            },
-            "cite": "not-promised:own-converter-for-the-wrapped-type"
-          },
-          {
-            "axes": {
-              "json.ReferenceHandler": [
-                "Preserve"
-              ]
-            },
-            "cite": "record:0099"
-          },
-          {
-            "axes": {
-              "json.NumberHandling": [
-                "WriteAsString"
-              ],
-              "shape.wrapped": [
-                "char"
-              ]
-            },
-            "cite": "fact:KB-042"
-          },
-          {
-            "axes": {
-              "json.MaxDepth": [
-                "3"
-              ],
-              "shape.wrapped": [
-                "own-record-class"
-              ]
-            },
-            "cite": "record:0099"
-          }
-        ]
-      },
-      {
-        "id": "every-document-version",
-        "sentence": "Its OpenAPI schema is the one ASP.NET Core publishes for the underlying type.",
-        "axes": {
-          "openapi.OpenApiVersion": [
-            "OpenApi2_0",
-            "OpenApi3_0"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "json.Converters": [
-                "own-for-value-object"
-              ]
-            },
-            "cite": "not-promised:own-converter-for-the-value-object"
-          },
-          {
-            "axes": {
-              "json.Converters": [
-                "own-for-wrapped"
-              ]
-            },
-            "cite": "not-promised:own-converter-for-the-wrapped-type"
-          },
-          {
-            "axes": {
-              "json.ReferenceHandler": [
-                "Preserve"
-              ]
-            },
-            "cite": "record:0099"
-          },
-          {
-            "axes": {
-              "json.NumberHandling": [
-                "WriteAsString"
-              ],
-              "shape.wrapped": [
-                "char"
-              ]
-            },
-            "cite": "fact:KB-042"
-          },
-          {
-            "axes": {
-              "json.MaxDepth": [
-                "3"
-              ],
-              "shape.wrapped": [
-                "own-record-class"
-              ]
-            },
-            "cite": "record:0099"
-          }
-        ]
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "a-closed-set-is-a-string-enum",
-        "source": "README.md#what-you-get",
-        "sentence": "One line per member gives you parsing by name, JSON as the name, an OpenAPI string enum and a text column.",
-        "axes": {
-          "shape.kind": [
-            "closed-set"
-          ]
-        }
-      },
-      {
-        "id": "own-converter-for-the-value-object",
-        "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says",
-        "sentence": "That converter then writes it instead of the generated one, so it's described as that converter says (see \"A described type\" below).",
-        "axes": {
-          "json.Converters": [
-            "own-for-value-object"
-          ]
-        }
-      },
-      {
-        "id": "own-converter-for-the-wrapped-type",
-        "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says",
-        "sentence": "ASP.NET can't see through a JSON converter you write yourself. It writes the type as `{}`, or with only the `format` its CLR type maps to. It also drops a list's `items` and a dictionary's `additionalProperties` of that type.",
-        "axes": {
-          "json.Converters": [
-            "own-for-wrapped"
-          ]
-        }
-      },
-      {
-        "id": "a-class-value-object-admits-null",
-        "source": "design/adr/0036-nullable-value-object-admits-null-openapi.md#0036-a-nullable-value-object-admits-null-in-the-openapi-document-wherever-it-appears",
-        "sentence": "A nullable value object admits null in the OpenAPI document wherever it appears",
-        "axes": {
-          "shape.kind": [
-            "sealed-record-class",
-            "validated-class"
-          ]
-        }
-      },
-      {
-        "id": "a-nullable-value-object-admits-null",
-        "source": "design/adr/0036-nullable-value-object-admits-null-openapi.md#0036-a-nullable-value-object-admits-null-in-the-openapi-document-wherever-it-appears",
-        "sentence": "A nullable value object admits null in the OpenAPI document wherever it appears",
-        "axes": {
-          "http.nullability": [
-            "nullable"
-          ]
-        }
-      },
-      {
-        "id": "openapi-2-nullable-component-loses-its-type",
-        "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says",
-        "sentence": "So under 2.0 a nullable value-object property loses its type, where the underlying type's nullable property keeps it.",
-        "axes": {
-          "openapi.OpenApiVersion": [
-            "OpenApi2_0"
-          ],
-          "openapi.CreateSchemaReferenceId": [
-            "default",
-            "own-prefixing"
-          ]
-        }
-      },
-      {
-        "id": "enum-component-is-its-first-use",
-        "source": "design/knowledge/KB-027-an-enum-component-is-its-first-use.md#kb-027-the-component-aspnet-makes-for-an-enum-written-by-name-is-the-schema-of-the-first-use-it-meets",
-        "sentence": "So whether a parameter of the wrapped `E?` admits null in a document with components depends on the endpoints and their order, not on the parameter.",
-        "axes": {
-          "json.Converters": [
-            "JsonStringEnumConverter"
-          ],
-          "http.nullability": [
-            "nullable"
-          ],
-          "shape.wrapped": [
-            "enum"
-          ]
-        }
-      },
-      {
-        "id": "openapi-2-nullable-body-keeps-only-its-null",
-        "source": "design/knowledge/KB-001-openapi-2-nullable-body-drops-pattern.md#kb-001-under-openapi-20-aspnet-writes-a-nullable-request-body-as-allof-x-nullable-true-and-drops-its-pattern",
-        "sentence": "A minimal API writes it the same, and a nullable enum body, which has no `format`, keeps nothing but the null:",
-        "axes": {
-          "openapi.OpenApiVersion": [
-            "OpenApi2_0"
-          ],
-          "http.binding": [
-            "body"
-          ],
-          "http.nullability": [
-            "nullable"
-          ],
-          "shape.kind": [
-            "sealed-record-class",
-            "validated-class"
-          ]
-        }
-      },
-      {
-        "id": "enum-component-lists-the-null-of-its-first-use",
-        "source": "design/knowledge/KB-027-an-enum-component-is-its-first-use.md#kb-027-the-component-aspnet-makes-for-an-enum-written-by-name-is-the-schema-of-the-first-use-it-meets",
-        "sentence": "What the component says is whatever schema ASP.NET built for the first use it met: met first as a nullable parameter, the component lists null among its values, for its non-nullable uses too; met first as itself, it does not, for its nullable uses too.",
-        "axes": {
-          "json.Converters": [
-            "JsonStringEnumConverter"
-          ],
-          "shape.wrapped": [
-            "enum"
-          ]
-        }
-      },
-      {
-        "id": "openapi-2-nullable-element-loses-its-type",
-        "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says",
-        "sentence": "A nullable element of a list or a dictionary loses its type the same way, since it's the component or null too.",
-        "axes": {
-          "openapi.OpenApiVersion": [
-            "OpenApi2_0"
-          ],
-          "openapi.CreateSchemaReferenceId": [
-            "default",
-            "own-prefixing"
-          ],
-          "shape.position": [
-            "list-element",
-            "array-element",
-            "immutable-array-element",
-            "read-only-list-element",
-            "dictionary-value"
-          ]
-        }
-      },
-      {
-        "id": "a-librarys-converter-for-the-wrapped-type",
-        "source": "src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says",
-        "sentence": "The same goes for a converter a library registers for its own type, such as NodaTime's for `Instant`.",
-        "axes": {
-          "shape.wrapped": [
-            "NodaTime.Instant"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "System.Text.Json refuses PreferredObjectCreationHandling.Populate together with a ReferenceHandler on the options object; JsonRow substitutes the default, so the pair never applies.",
-        "pairs": [
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ]
-        ]
-      },
-      {
-        "reason": "Not promised (a-closed-set-is-a-string-enum): a closed set wraps nothing and is described as the string enum of its names, so it has no underlying type's schema to equal.",
-        "pairs": [
-          [
-            "http.binding=route",
-            "shape.kind=closed-set"
-          ],
-          [
-            "http.binding=query",
-            "shape.kind=closed-set"
-          ],
-          [
-            "http.binding=header",
-            "shape.kind=closed-set"
-          ],
-          [
-            "http.binding=body",
-            "shape.kind=closed-set"
-          ],
-          [
-            "http.binding=form",
-            "shape.kind=closed-set"
-          ],
-          [
-            "http.binding=as-parameters",
-            "shape.kind=closed-set"
-          ],
-          [
-            "http.host=minimal",
-            "shape.kind=closed-set"
-          ],
-          [
-            "http.host=mvc",
-            "shape.kind=closed-set"
-          ],
-          [
-            "http.host=both",
-            "shape.kind=closed-set"
-          ],
-          [
-            "http.host=route-group",
-            "shape.kind=closed-set"
-          ],
-          [
-            "http.host=controller-without-ApiController-visible",
-            "shape.kind=closed-set"
-          ],
-          [
-            "http.nullability=as-declared",
-            "shape.kind=closed-set"
-          ],
-          [
-            "http.nullability=nullable",
-            "shape.kind=closed-set"
-          ],
-          [
-            "http.response=result-to-http-result",
-            "shape.kind=closed-set"
-          ],
-          [
-            "http.response=composed-fault",
-            "shape.kind=closed-set"
-          ],
-          [
-            "http.response=two-faults-same-name",
-            "shape.kind=closed-set"
-          ],
-          [
-            "http.response=group-with-fault-status",
-            "shape.kind=closed-set"
-          ],
-          [
-            "http.response=endpoint-without-faults",
-            "shape.kind=closed-set"
-          ],
-          [
-            "http.response=declared-produces-problem",
-            "shape.kind=closed-set"
-          ],
-          [
-            "input.json=valid",
-            "shape.kind=closed-set"
-          ],
-          [
-            "input.json=refused-by-create",
-            "shape.kind=closed-set"
-          ],
-          [
-            "input.json=wrong-token",
-            "shape.kind=closed-set"
-          ],
-          [
-            "input.json=null",
-            "shape.kind=closed-set"
-          ],
-          [
-            "input.json=empty-string",
-            "shape.kind=closed-set"
-          ],
-          [
-            "input.json=at-type-limit",
-            "shape.kind=closed-set"
-          ],
-          [
-            "input.json=quoted-number",
-            "shape.kind=closed-set"
-          ],
-          [
-            "input.json=escape-sequence",
-            "shape.kind=closed-set"
-          ],
-          [
-            "input.json=duplicate-property",
-            "shape.kind=closed-set"
-          ],
-          [
-            "input.json=metadata-property",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.AllowDuplicateProperties=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.AllowDuplicateProperties=false",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.AllowOutOfOrderMetadataProperties=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.AllowOutOfOrderMetadataProperties=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.AllowTrailingCommas=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.AllowTrailingCommas=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.Converters=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.Converters=JsonStringEnumConverter",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.Converters=StoredJsonConverterFactory",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DefaultIgnoreCondition=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DefaultIgnoreCondition=WhenWritingDefault",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DefaultIgnoreCondition=WhenWritingNull",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DefaultIgnoreCondition=WhenWriting",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DefaultIgnoreCondition=WhenReading",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DictionaryKeyPolicy=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DictionaryKeyPolicy=CamelCase",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DictionaryKeyPolicy=SnakeCaseLower",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DictionaryKeyPolicy=KebabCaseUpper",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.DictionaryKeyPolicy=own-upper-case",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.Encoder=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.Encoder=UnsafeRelaxedJsonEscaping",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.IgnoreReadOnlyFields=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.IgnoreReadOnlyFields=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.IgnoreReadOnlyProperties=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.IgnoreReadOnlyProperties=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.IncludeFields=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.IncludeFields=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.MaxDepth=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.MaxDepth=3",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.NumberHandling=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.NumberHandling=AllowReadingFromString",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.NumberHandling=WriteAsString",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.NumberHandling=AllowNamedFloatingPointLiterals",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PropertyNameCaseInsensitive=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PropertyNameCaseInsensitive=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PropertyNamingPolicy=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PropertyNamingPolicy=CamelCase",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PropertyNamingPolicy=SnakeCaseLower",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PropertyNamingPolicy=SnakeCaseUpper",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PropertyNamingPolicy=KebabCaseLower",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PropertyNamingPolicy=KebabCaseUpper",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.PropertyNamingPolicy=own-upper-case",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.ReadCommentHandling=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.ReadCommentHandling=Skip",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.ReferenceHandler=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.ReferenceHandler=Preserve",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.ReferenceHandler=IgnoreCycles",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.RespectNullableAnnotations=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.RespectNullableAnnotations=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.RespectRequiredConstructorParameters=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.RespectRequiredConstructorParameters=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.TypeInfoResolver=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.TypeInfoResolver=source-generated-context",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.TypeInfoResolver=default-with-renaming-modifier",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.TypeInfoResolverChain=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.TypeInfoResolverChain=context-then-default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.UnknownTypeHandling=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.UnknownTypeHandling=JsonNode",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.UnmappedMemberHandling=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "json.UnmappedMemberHandling=Disallow",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.AllowEmptyInputInBodyModelBinding=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.AllowEmptyInputInBodyModelBinding=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.Conventions=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.Conventions=own-route-prefix",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.InputFormatters=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.InputFormatters=xml-added",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.MaxModelBindingCollectionSize=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.MaxModelBindingCollectionSize=2",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.MaxModelValidationErrors=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.MaxModelValidationErrors=1",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.MaxValidationDepth=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.MaxValidationDepth=1",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.ModelBinderProviders=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.ModelBinderProviders=own-provider-first",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.OutputFormatters=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.OutputFormatters=xml-added",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.RespectBrowserAcceptHeader=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.RespectBrowserAcceptHeader=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.ReturnHttpNotAcceptable=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.ReturnHttpNotAcceptable=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.SuppressImplicitRequiredAttributeForNonNullableReferenceTypes=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.SuppressImplicitRequiredAttributeForNonNullableReferenceTypes=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.ValidateComplexTypesIfChildValidationFails=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "mvc.ValidateComplexTypesIfChildValidationFails=true",
-            "shape.kind=closed-set"
-          ],
-          [
-            "openapi.CreateSchemaReferenceId=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "openapi.CreateSchemaReferenceId=own-prefixing",
-            "shape.kind=closed-set"
-          ],
-          [
-            "openapi.CreateSchemaReferenceId=null-inlines-all",
-            "shape.kind=closed-set"
-          ],
-          [
-            "openapi.OpenApiVersion=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "openapi.OpenApiVersion=OpenApi2_0",
-            "shape.kind=closed-set"
-          ],
-          [
-            "openapi.OpenApiVersion=OpenApi3_0",
-            "shape.kind=closed-set"
-          ],
-          [
-            "openapi.transformers=default",
-            "shape.kind=closed-set"
-          ],
-          [
-            "openapi.transformers=own-schema-transformer",
-            "shape.kind=closed-set"
-          ],
-          [
-            "openapi.transformers=own-operation-transformer",
-            "shape.kind=closed-set"
-          ],
-          [
-            "openapi.transformers=own-document-transformer",
-            "shape.kind=closed-set"
-          ],
-          [
-            "process.converter-lookup=none",
-            "shape.kind=closed-set"
-          ],
-          [
-            "process.converter-lookup=wrapped-type-converter-looked-up-first",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.containing=class",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=root"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=property"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=nullable-property"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=field"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=list-element"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=array-element"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=immutable-array-element"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=read-only-list-element"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=dictionary-key"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=dictionary-value"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=record-ctor-parameter"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=required-init"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=in-patch"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.position=polymorphic-derived-property"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=own-record-class"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "E01-column-parity",
-    "source": "docs/ef-core.md#the-model",
-    "surfaces": [
-      "ef"
-    ],
-    "axes": {
-      "ef.mapping": [
-        "property",
-        "nullable",
-        "key",
-        "owned",
-        "complex"
-      ],
-      "ef.facet": [
-        "none",
-        "HasMaxLength",
-        "HavePrecision",
-        "HasColumnType"
-      ],
-      "shape.wrapped": [
-        "string",
-        "Guid",
-        "int",
-        "long",
-        "byte",
-        "ulong",
-        "decimal",
-        "double",
-        "bool",
-        "char",
-        "DateTime",
-        "DateTimeOffset",
-        "DateOnly",
-        "TimeOnly",
-        "TimeSpan",
-        "enum",
-        "flags-enum",
-        "Uri"
-      ],
-      "shape.kind": [
-        "record-struct",
-        "sealed-record-class",
-        "validated-struct",
-        "validated-class"
-      ]
-    },
-    "narrow": {
-      "ef.query": "Every property maps as a column of the underlying type, nullable where the property is."
-    },
-    "obligations": [
-      {
-        "id": "column-type",
-        "sentence": "Every property maps as a column of the underlying type, nullable where the property is.",
-        "axes": {
-          "ef.mapping": [
-            "property",
-            "key",
-            "owned",
-            "complex"
-          ]
-        }
-      },
-      {
-        "id": "nullable",
-        "sentence": "nullable where the property is",
-        "axes": {
-          "ef.mapping": [
-            "nullable"
-          ]
-        }
-      },
-      {
-        "id": "facet-kept",
-        "sentence": "A facet you configure on it is kept: a precision, a length, a column type.",
-        "axes": {
-          "ef.facet": [
-            "HasMaxLength",
-            "HavePrecision",
-            "HasColumnType"
-          ]
-        }
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "char-key-not-generated",
-        "source": "docs/ef-core.md#keys",
-        "sentence": "A key over `char` is always yours to assign",
-        "axes": {
-          "ef.mapping": [
-            "key"
-          ],
-          "shape.wrapped": [
-            "char"
-          ]
-        }
-      },
-      {
-        "id": "guid-key-not-generated",
-        "source": "docs/ef-core.md#keys",
-        "sentence": "A key over a `Guid` is yours to assign",
-        "axes": {
-          "ef.mapping": [
-            "key"
-          ],
-          "shape.wrapped": [
-            "Guid"
-          ]
-        }
-      }
-    ]
-  },
-  {
-    "id": "E02-value-translates-to-column",
-    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
-    "surfaces": [
-      "ef"
-    ],
-    "axes": {
-      "ef.query": [
-        "where-equals",
-        "where-value-compare",
-        "order-by",
-        "contains",
-        "select",
-        "group-by"
-      ],
-      "ef.accessor": [
-        "Value",
-        "GetValue",
-        "ValueOrNull"
-      ],
-      "shape.wrapped": [
-        "string",
-        "Guid",
-        "int",
-        "long",
-        "byte",
-        "ulong",
-        "decimal",
-        "double",
-        "bool",
-        "char",
-        "DateTime",
-        "DateTimeOffset",
-        "DateOnly",
-        "TimeOnly",
-        "TimeSpan",
-        "enum",
-        "flags-enum",
-        "Uri"
-      ],
-      "shape.kind": [
-        "record-struct",
-        "sealed-record-class",
-        "validated-struct",
-        "validated-class"
-      ]
-    },
-    "narrow": {
-      "ef.mapping": "`.Value`, `GetValue()` and `ValueOrNull()` translate to the column itself."
-    },
-    "obligations": [
-      {
-        "id": "value",
-        "sentence": "`.Value`, `GetValue()` and `ValueOrNull()` translate to the column itself.",
-        "axes": {
-          "ef.accessor": [
-            "Value"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "shape.wrapped": [
-                "DateTimeOffset",
-                "TimeSpan",
-                "ulong"
-              ],
-              "ef.query": [
-                "where-value-compare",
-                "order-by"
-              ]
-            },
-            "cite": "fact:KB-039"
-          }
-        ]
-      },
-      {
-        "id": "get-value",
-        "sentence": "db.Orders.Where(o => o.Total.GetValue() > 100m);",
-        "axes": {
-          "ef.accessor": [
-            "GetValue"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "shape.wrapped": [
-                "DateTimeOffset",
-                "TimeSpan",
-                "ulong"
-              ],
-              "ef.query": [
-                "where-value-compare",
-                "order-by"
-              ]
-            },
-            "cite": "fact:KB-039"
-          }
-        ]
-      },
-      {
-        "id": "value-or-null",
-        "sentence": "Use `ValueOrNull()` for an optional value object, where `.Value` would first unwrap the `Nullable`.",
-        "axes": {
-          "ef.accessor": [
-            "ValueOrNull"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "shape.wrapped": [
-                "DateTimeOffset",
-                "TimeSpan",
-                "ulong"
-              ],
-              "ef.query": [
-                "where-value-compare",
-                "order-by"
-              ]
-            },
-            "cite": "fact:KB-039"
-          }
-        ]
-      },
-      {
-        "id": "column-not-cast",
-        "sentence": "A table's column is re-typed, not cast, so an index on it still serves the query.",
-        "inapplicable": [
-          {
-            "axes": {
-              "shape.wrapped": [
-                "DateTimeOffset",
-                "TimeSpan",
-                "ulong"
-              ],
-              "ef.query": [
-                "where-value-compare",
-                "order-by"
-              ]
-            },
-            "cite": "fact:KB-039"
-          }
-        ]
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "null-passes-no-comparison",
-        "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
-        "sentence": "A null passes no `<`, `<=`, `>` or `>=` in the database.",
-        "axes": {
-          "ef.accessor": [
-            "ValueOrNull"
-          ],
-          "ef.query": [
-            "where-value-compare"
-          ]
-        }
-      },
-      {
-        "id": "collation-orders",
-        "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
-        "sentence": "Ordering in SQL follows the database's collation",
-        "axes": {
-          "ef.query": [
-            "order-by"
-          ],
-          "shape.wrapped": [
-            "string"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "C# defines no `>=` for a `string`, a `bool` or a `Uri`, so no query compares their `.Value` with it; E02ValueTranslatesProbe writes where-equals in its place there, so no row holds the pair.",
-        "pairs": [
-          [
-            "ef.query=where-value-compare",
-            "shape.wrapped=string"
-          ],
-          [
-            "ef.query=where-value-compare",
-            "shape.wrapped=bool"
-          ],
-          [
-            "ef.query=where-value-compare",
-            "shape.wrapped=Uri"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "E03-column-round-trip",
-    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#what-maps",
-    "surfaces": [
-      "ef"
-    ],
-    "axes": {
-      "ef.mapping": [
-        "property",
-        "nullable",
-        "key",
-        "owned",
-        "complex"
-      ],
-      "shape.wrapped": [
-        "string",
-        "Guid",
-        "int",
-        "long",
-        "byte",
-        "ulong",
-        "decimal",
-        "double",
-        "bool",
-        "char",
-        "DateTime",
-        "DateTimeOffset",
-        "DateOnly",
-        "TimeOnly",
-        "TimeSpan",
-        "enum",
-        "flags-enum",
-        "Uri"
-      ],
-      "shape.kind": [
-        "record-struct",
-        "sealed-record-class",
-        "validated-struct",
-        "validated-class"
-      ]
-    },
-    "narrow": {
-      "ef.query": "Keys, foreign keys, nullable properties, primitive collections and query parameters all map as plain columns of the underlying type."
-    },
-    "obligations": [
-      {
-        "id": "stored-as-underlying",
-        "sentence": "Every value object is stored in a plain column of its underlying type",
-        "axes": {
-          "ef.mapping": [
-            "property",
-            "owned",
-            "complex"
-          ]
-        }
-      },
-      {
-        "id": "keys",
-        "sentence": "Keys, foreign keys, nullable properties, primitive collections and query parameters all map as plain columns of the underlying type.",
-        "axes": {
-          "ef.mapping": [
-            "key"
-          ]
-        }
-      },
-      {
-        "id": "nullable-properties",
-        "sentence": "Keys, foreign keys, nullable properties, primitive collections and query parameters all map as plain columns of the underlying type.",
-        "axes": {
-          "ef.mapping": [
-            "nullable"
-          ]
-        }
-      }
-    ]
-  },
-  {
-    "id": "E04-integer-key-generated",
-    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
-    "surfaces": [
-      "ef"
-    ],
-    "axes": {
-      "shape.wrapped": [
-        "int",
-        "long",
-        "byte",
-        "ulong",
-        "char",
-        "Guid",
-        "string"
-      ],
-      "shape.kind": [
-        "record-struct",
-        "sealed-record-class",
-        "validated-struct",
-        "validated-class"
-      ],
-      "ef.key-config": [
-        "default",
-        "ValueGeneratedOnAdd",
-        "ValueGeneratedNever"
-      ]
-    },
-    "narrow": {
-      "ef.query": "A single-column key over an integer is generated on add, like a key of that integer type.",
-      "ef.mapping": "A single-column key over an integer is generated on add, like a key of that integer type.",
-      "shape.site": "A single-column key over an integer is generated on add, like a key of that integer type."
-    },
-    "obligations": [
-      {
-        "id": "generated-on-add",
-        "sentence": "A single-column key over an integer is generated on add, like a key of that integer type.",
-        "axes": {
-          "shape.wrapped": [
-            "int",
-            "long",
-            "ulong"
-          ]
-        }
-      },
-      {
-        "id": "byte-not-generated",
-        "sentence": "That's EF's own list: `int`, `long`, `short`, `sbyte`, `uint`, `ulong` and `ushort`, and not `byte`.",
-        "axes": {
-          "shape.wrapped": [
-            "byte"
-          ]
-        }
-      },
-      {
-        "id": "char-key-yours",
-        "sentence": "A key over `char` is yours to assign.",
-        "axes": {
-          "shape.wrapped": [
-            "char"
-          ],
-          "ef.key-config": [
-            "default"
-          ]
-        }
-      },
-      {
-        "id": "guid-key-yours",
-        "sentence": "A key over a `Guid` is yours to assign",
-        "axes": {
-          "shape.wrapped": [
-            "Guid"
-          ],
-          "ef.key-config": [
-            "default"
-          ]
-        }
-      },
-      {
-        "id": "not-on-efs-list",
-        "sentence": "That's EF's own list: `int`, `long`, `short`, `sbyte`, `uint`, `ulong` and `ushort`, and not `byte`.",
-        "axes": {
-          "shape.wrapped": [
-            "string"
-          ],
-          "ef.key-config": [
-            "default"
-          ]
-        }
-      },
-      {
-        "id": "own-configuration-wins",
-        "sentence": "A configuration you write yourself always wins over these defaults.",
-        "axes": {
-          "shape.wrapped": [
-            "char",
-            "Guid",
-            "string"
-          ],
-          "ef.key-config": [
-            "ValueGeneratedOnAdd",
-            "ValueGeneratedNever"
-          ]
-        }
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "meaningful-char-key-unchecked",
-        "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
-        "sentence": "TypeKit stops that invented value, but it doesn't check that you set a meaningful one.",
-        "axes": {
-          "shape.wrapped": [
-            "char"
-          ],
-          "ef.key-config": [
-            "default"
-          ]
-        }
-      },
-      {
-        "id": "ulong-key-on-a-decimal-column",
-        "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
-        "sentence": "A default key over `ulong` throws at `Add` where the column is a `decimal`",
-        "axes": {
-          "shape.wrapped": [
-            "ulong"
-          ],
-          "provider": [
-            "SQL Server",
-            "PostgreSQL"
-          ]
-        }
-      }
-    ]
-  },
-  {
-    "id": "E05-own-compareto-rejected",
-    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
-    "surfaces": [
-      "ef"
-    ],
-    "axes": {
-      "ef.op": [
-        "lt",
-        "gt",
-        "le",
-        "ge",
-        "CompareTo",
-        "OrderBy",
-        "OrderByDescending",
-        "ThenBy",
-        "Order",
-        "Min",
-        "Max",
-        "equals",
-        "HasQueryFilter",
-        "named-query-filter",
-        "value-order"
-      ],
-      "ef.vo": [
-        "int-struct",
-        "string-struct",
-        "decimal-struct",
-        "DateTime-struct",
-        "int-class",
-        "string-class"
-      ]
-    },
-    "narrow": {
-      "ef.query": "Your own `CompareTo(TSelf)` can't run in the database.",
-      "ef.mapping": "Your own `CompareTo(TSelf)` can't run in the database.",
-      "shape.kind": "Your own `CompareTo(TSelf)` can't run in the database.",
-      "shape.wrapped": "Your own `CompareTo(TSelf)` can't run in the database.",
-      "shape.site": "Your own `CompareTo(TSelf)` can't run in the database."
-    },
-    "obligations": [
-      {
-        "id": "comparison",
-        "sentence": "a comparison (`<`, `>`, `<=`, `>=`, `CompareTo`);",
-        "axes": {
-          "ef.op": [
-            "lt",
-            "gt",
-            "le",
-            "ge",
-            "CompareTo"
-          ]
-        }
-      },
-      {
-        "id": "ordering",
-        "sentence": "an ordering (`OrderBy`, `ThenBy`, their descending forms, `Order`);",
-        "axes": {
-          "ef.op": [
-            "OrderBy",
-            "OrderByDescending",
-            "ThenBy",
-            "Order"
-          ]
-        }
-      },
-      {
-        "id": "min-max",
-        "sentence": "`Min` or `Max`.",
-        "axes": {
-          "ef.op": [
-            "Min",
-            "Max"
-          ]
-        }
-      },
-      {
-        "id": "equality-allowed",
-        "sentence": "Equality isn't ordering, and stays allowed.",
-        "axes": {
-          "ef.op": [
-            "equals"
-          ]
-        }
-      },
-      {
-        "id": "value-order-allowed",
-        "sentence": "Compare or order by `.Value` where the underlying value's order is what you mean",
-        "axes": {
-          "ef.op": [
-            "value-order"
-          ]
-        }
-      },
-      {
-        "id": "query-filter",
-        "sentence": "A query filter (`HasQueryFilter`, named or not) that does the same fails when the model is built, naming the entity type, since it applies to every query of that type.",
-        "axes": {
-          "ef.op": [
-            "HasQueryFilter",
-            "named-query-filter"
-          ]
-        }
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "collation-orders",
-        "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
-        "sentence": "Ordering in SQL follows the database's collation",
-        "axes": {
-          "ef.op": [
-            "value-order"
-          ],
-          "ef.vo": [
-            "string-struct",
-            "string-class"
-          ]
-        }
-      }
-    ]
-  },
-  {
-    "id": "E06-own-converter-no-value",
-    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
-    "surfaces": [
-      "ef"
-    ],
-    "axes": {
-      "ef.converter": [
-        "HasConversion-lambda",
-        "converter-type",
-        "ConfigureConventions"
-      ],
-      "ef.op": [
-        "value-access",
-        "vo-equality"
-      ],
-      "shape.wrapped": [
-        "string",
-        "int",
-        "Guid",
-        "decimal"
-      ]
-    },
-    "narrow": {
-      "ef.query": "A property your application converts itself",
-      "ef.mapping": "A property your application converts itself",
-      "shape.kind": "A property your application converts itself",
-      "shape.site": "A property your application converts itself"
-    },
-    "obligations": [
-      {
-        "id": "value-not-translated",
-        "sentence": "So a filter, a sort, a grouping or an aggregate that reads `.Value` there fails with EF's \"could not be translated\", rather than comparing against what the column really holds.",
-        "axes": {
-          "ef.op": [
-            "value-access"
-          ]
-        }
-      },
-      {
-        "id": "value-object-comparison",
-        "sentence": "Comparing the value object itself (`o.Code == code`) goes through that converter and still works.",
-        "axes": {
-          "ef.op": [
-            "vo-equality"
-          ]
-        }
-      }
-    ]
-  },
-  {
-    "id": "E07-closed-set-stored-as-name",
-    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#closed-sets",
-    "surfaces": [
-      "ef"
-    ],
-    "axes": {
-      "ef.site": [
-        "table",
-        "primitive-collection",
-        "json-column"
-      ],
-      "ef.event": [
-        "round-trip",
-        "unknown-name-on-read",
-        "non-member-on-write"
-      ]
-    },
-    "narrow": {
-      "ef.query": "A closed set (`IClosedSet<TSelf>`) is stored as a text column of the member's name, and read back as the member itself.",
-      "ef.mapping": "A closed set (`IClosedSet<TSelf>`) is stored as a text column of the member's name, and read back as the member itself.",
-      "shape.kind": "A closed set (`IClosedSet<TSelf>`) is stored as a text column of the member's name, and read back as the member itself.",
-      "shape.wrapped": "A closed set (`IClosedSet<TSelf>`) is stored as a text column of the member's name, and read back as the member itself.",
-      "shape.site": "A closed set (`IClosedSet<TSelf>`) is stored as a text column of the member's name, and read back as the member itself."
-    },
-    "obligations": [
-      {
-        "id": "stored-as-name",
-        "sentence": "A closed set (`IClosedSet<TSelf>`) is stored as a text column of the member's name, and read back as the member itself.",
-        "axes": {
-          "ef.event": [
-            "round-trip"
-          ]
-        }
-      },
-      {
-        "id": "in-collections-and-json",
-        "sentence": "That holds in a table, in a primitive collection of names (`text[]` on PostgreSQL, a JSON array elsewhere) and in a JSON column alike, with nothing registered per set.",
-        "axes": {
-          "ef.site": [
-            "primitive-collection",
-            "json-column"
-          ],
-          "ef.event": [
-            "round-trip"
-          ]
-        }
-      },
-      {
-        "id": "unknown-name-throws",
-        "sentence": "A name the set no longer has throws when it's read, rather than reading as null.",
-        "axes": {
-          "ef.event": [
-            "unknown-name-on-read"
-          ]
-        }
-      },
-      {
-        "id": "non-member-throws",
-        "sentence": "An instance that isn't a member throws when it's written.",
-        "axes": {
-          "ef.event": [
-            "non-member-on-write"
-          ]
-        }
-      }
-    ]
-  },
-  {
-    "id": "E08-option-result-not-columns",
-    "source": "docs/ef-core.md#option-and-result",
-    "surfaces": [
-      "ef"
-    ],
-    "axes": {
-      "ef.type": [
-        "Option-int",
-        "Option-VO",
-        "Result-int-E",
-        "Result-VO-E",
-        "Result-E"
-      ],
-      "ef.position": [
-        "property",
-        "key",
-        "collection",
-        "owned-property"
-      ],
-      "shape.wrapped": [
-        "string",
-        "int",
-        "Guid"
-      ]
-    },
-    "narrow": {
-      "ef.query": "EF can't map an `Option` or a `Result` property, and building the model fails with an error that says so.",
-      "ef.mapping": "EF can't map an `Option` or a `Result` property, and building the model fails with an error that says so.",
-      "shape.kind": "EF can't map an `Option` or a `Result` property, and building the model fails with an error that says so.",
-      "shape.site": "EF can't map an `Option` or a `Result` property, and building the model fails with an error that says so."
-    },
-    "obligations": [
-      {
-        "id": "model-fails",
-        "sentence": "EF can't map an `Option` or a `Result` property"
-      },
-      {
-        "id": "error-says-so",
-        "sentence": "building the model fails with an error that says so"
-      }
-    ]
-  },
-  {
-    "id": "E09-or-none-in-database",
-    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#an-option-for-nothing-found",
-    "surfaces": [
-      "ef"
-    ],
-    "axes": {
-      "ef.operator": [
-        "FirstOrNoneAsync",
-        "FirstOrNone",
-        "SingleOrNoneAsync",
-        "SingleOrNone",
-        "ElementAtOrNone",
-        "FirstOrError"
-      ],
-      "ef.data": [
-        "empty",
-        "one-match",
-        "many-match"
-      ],
-      "ef.condition": [
-        "lambda",
-        "expression-variable"
-      ],
-      "shape.wrapped": [
-        "int",
-        "Guid",
-        "string"
-      ]
-    },
-    "narrow": {
-      "ef.query": "These ask the database for one row and let it run the condition:",
-      "ef.mapping": "These ask the database for one row and let it run the condition:",
-      "shape.kind": "These ask the database for one row and let it run the condition:",
-      "shape.site": "These ask the database for one row and let it run the condition:"
-    },
-    "obligations": [
-      {
-        "id": "first-reads-one-row",
-        "sentence": "read one row: `WHERE ... LIMIT @p`.",
-        "axes": {
-          "ef.operator": [
-            "FirstOrNoneAsync",
-            "FirstOrNone",
-            "FirstOrError"
-          ]
-        }
-      },
-      {
-        "id": "single-asks-for-two",
-        "sentence": "ask for two rows, and throw for more than one.",
-        "axes": {
-          "ef.operator": [
-            "SingleOrNoneAsync",
-            "SingleOrNone"
-          ]
-        }
-      },
-      {
-        "id": "element-at-skips",
-        "sentence": "skips to its row: `OFFSET @p`.",
-        "axes": {
-          "ef.operator": [
-            "ElementAtOrNone"
-          ]
-        }
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "func-condition-runs-in-memory",
-        "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#an-option-for-nothing-found",
-        "sentence": "Then every row is read and the condition runs in memory, without a warning.",
-        "axes": {
-          "ef.condition": [
-            "func-variable",
-            "method-group"
-          ]
-        }
-      },
-      {
-        "id": "last-on-a-query-does-not-compile",
-        "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#an-option-for-nothing-found",
-        "sentence": "`LastOrNone` and `LastOrError` on a query don't compile.",
-        "axes": {
-          "ef.operator": [
-            "LastOrNone",
-            "LastOrError"
-          ]
-        }
-      },
-      {
-        "id": "not-precompiled-under-native-aot",
-        "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#an-option-for-nothing-found",
-        "sentence": "Under Native AOT these throw \"Query wasn't precompiled\"",
-        "axes": {
-          "process": [
-            "native-aot"
-          ]
-        }
-      }
-    ]
-  },
-  {
-    "id": "E10-read-back-skips-validation",
-    "source": "docs/ef-core.md#reading-back-without-validation",
-    "surfaces": [
-      "ef"
-    ],
-    "axes": {
-      "ef.mapping": [
-        "property",
-        "key",
-        "nullable",
-        "owned",
-        "complex"
-      ],
-      "shape.wrapped": [
-        "string",
-        "int",
-        "Guid",
-        "decimal",
-        "DateTime",
-        "Uri"
-      ],
-      "shape.kind": [
-        "validated-struct",
-        "validated-class"
-      ]
-    },
-    "narrow": {
-      "ef.query": "EF reads a column back without validation, through the value object's `Materialize` rather than `Create`.",
-      "shape.site": "EF reads a column back without validation, through the value object's `Materialize` rather than `Create`."
-    },
-    "obligations": [
-      {
-        "id": "reads-without-create",
-        "sentence": "EF reads a column back without validation, through the value object's `Materialize` rather than `Create`."
-      },
-      {
-        "id": "revalidate-finds",
-        "sentence": "`Revalidate()` finds the rows that today's rules reject, as above."
-      }
-    ]
-  },
-  {
-    "id": "E11-usetypekit-order",
-    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#setup",
-    "surfaces": [
-      "ef"
-    ],
-    "axes": {
-      "ef.order": [
-        "before-provider",
-        "after-provider"
-      ],
-      "ef.mapping": [
-        "property",
-        "key",
-        "integer-key",
-        "nullable",
-        "owned",
-        "complex",
-        "closed-set"
-      ]
-    },
-    "narrow": {
-      "ef.query": "it doesn't matter whether you call it before or after `UseNpgsql` or `UseSqlite`",
-      "shape.kind": "it doesn't matter whether you call it before or after `UseNpgsql` or `UseSqlite`",
-      "shape.site": "it doesn't matter whether you call it before or after `UseNpgsql` or `UseSqlite`",
-      "shape.wrapped": "it doesn't matter whether you call it before or after `UseNpgsql` or `UseSqlite`"
-    },
-    "obligations": [
-      {
-        "id": "order-does-not-matter",
-        "sentence": "it doesn't matter whether you call it before or after `UseNpgsql` or `UseSqlite`"
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "in-memory-provider-maps-nothing",
-        "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#setup",
-        "sentence": "EF's in-memory provider has no relational type mapping, so nothing is mapped there.",
-        "axes": {
-          "ef.provider": [
-            "InMemory"
-          ]
-        }
-      }
-    ]
-  },
-  {
-    "id": "E12-convention-by-vo-type",
-    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#model-wide-conventions-follow-the-propertys-type",
-    "surfaces": [
-      "ef"
-    ],
-    "axes": {
-      "ef.convention": [
-        "HaveMaxLength",
-        "HavePrecision",
-        "HaveColumnType"
-      ],
-      "ef.convention-type": [
-        "value-object",
-        "underlying"
-      ],
-      "shape.wrapped": [
-        "string",
-        "decimal",
-        "Uri",
-        "int"
-      ]
-    },
-    "narrow": {
-      "ef.query": "Configure the value object instead:",
-      "ef.mapping": "Configure the value object instead:",
-      "shape.site": "Configure the value object instead:",
-      "shape.kind": "Configure the value object instead:"
-    },
-    "obligations": [
-      {
-        "id": "value-object-type-reaches",
-        "sentence": "Configure the value object instead: `configurationBuilder.Properties<Amount>().HavePrecision(18, 2)`.",
-        "axes": {
-          "ef.convention-type": [
-            "value-object"
-          ]
-        }
-      },
-      {
-        "id": "underlying-type-does-not-reach",
-        "sentence": "So `configurationBuilder.Properties<decimal>().HavePrecision(18, 2)` reaches `decimal` properties, and not an `Amount` that wraps one.",
-        "axes": {
-          "ef.convention-type": [
-            "underlying"
-          ]
-        }
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "underlying-type-convention",
-        "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#model-wide-conventions-follow-the-propertys-type",
-        "sentence": "EF applies `ConfigureConventions` by CLR type.",
-        "axes": {
-          "ef.convention-type": [
-            "underlying"
-          ]
-        }
-      }
-    ]
-  },
-  {
-    "id": "E13-primitive-collections",
-    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
-    "surfaces": [
-      "ef"
-    ],
-    "axes": {
-      "ef.query": [
-        "contains",
-        "any-value-equals"
-      ],
-      "shape.wrapped": [
-        "string",
-        "int",
-        "Guid",
-        "long",
-        "decimal"
-      ]
-    },
-    "narrow": {
-      "ef.mapping": "db.Orders.Where(o => o.Tags.Contains(tag));",
-      "shape.site": "db.Orders.Where(o => o.Tags.Contains(tag));",
-      "shape.kind": "db.Orders.Where(o => o.Tags.Contains(tag));"
-    },
-    "obligations": [
-      {
-        "id": "contains",
-        "sentence": "db.Orders.Where(o => o.Tags.Contains(tag));",
-        "axes": {
-          "ef.query": [
-            "contains"
-          ]
-        }
-      },
-      {
-        "id": "element-value",
-        "sentence": "db.Orders.Where(o => o.Tags.Any(t => t.Value == \"x\"));",
-        "axes": {
-          "ef.query": [
-            "any-value-equals"
-          ]
-        }
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "element-converted-may-cast",
-        "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries",
-        "sentence": "These are converted instead, which works everywhere and may add a cast:",
-        "axes": {
-          "ef.query": [
-            "any-value-equals"
-          ]
-        }
-      }
-    ]
-  },
-  {
-    "id": "E14-inheritance-key-generation",
-    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
-    "surfaces": [
-      "ef"
-    ],
-    "axes": {
-      "ef.inheritance": [
-        "TPH",
-        "TPT",
-        "TPC"
-      ],
-      "shape.wrapped": [
-        "int",
-        "long",
-        "Guid"
-      ]
-    },
-    "narrow": {
-      "ef.query": "The root of an inheritance hierarchy follows the same rules under TPH and TPT.",
-      "ef.mapping": "The root of an inheritance hierarchy follows the same rules under TPH and TPT.",
-      "shape.site": "The root of an inheritance hierarchy follows the same rules under TPH and TPT.",
-      "shape.kind": "The root of an inheritance hierarchy follows the same rules under TPH and TPT."
-    },
-    "obligations": [
-      {
-        "id": "tph-tpt-root",
-        "sentence": "The root of an inheritance hierarchy follows the same rules under TPH and TPT.",
-        "axes": {
-          "ef.inheritance": [
-            "TPH",
-            "TPT"
-          ]
-        }
-      },
-      {
-        "id": "tpc-assign-on-sqlite",
-        "sentence": "SQLite has no such sequence, so there you assign it.",
-        "axes": {
-          "ef.inheritance": [
-            "TPC"
-          ]
-        }
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "guid-key-not-generated",
-        "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
-        "sentence": "A key over a `Guid` is yours to assign",
-        "axes": {
-          "shape.wrapped": [
-            "Guid"
-          ]
-        }
-      }
-    ]
-  },
-  {
-    "id": "E15-composite-key",
-    "source": "docs/ef-core.md#keys",
-    "surfaces": [
-      "ef"
-    ],
-    "axes": {
-      "shape.wrapped": [
-        "int",
-        "Guid",
-        "string",
-        "long"
-      ],
-      "ef.key-position": [
-        "first",
-        "second"
-      ]
-    },
-    "narrow": {
-      "ef.query": "A composite key of value objects is `HasKey(x => new { x.Order, x.Line })`, as for primitives.",
-      "ef.mapping": "A composite key of value objects is `HasKey(x => new { x.Order, x.Line })`, as for primitives.",
-      "shape.site": "A composite key of value objects is `HasKey(x => new { x.Order, x.Line })`, as for primitives.",
-      "shape.kind": "A composite key of value objects is `HasKey(x => new { x.Order, x.Line })`, as for primitives."
-    },
-    "obligations": [
-      {
-        "id": "as-for-primitives",
-        "sentence": "A composite key of value objects is `HasKey(x => new { x.Order, x.Line })`, as for primitives."
-      }
-    ]
-  },
-  {
-    "id": "E16-own-configuration-wins",
-    "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
-    "surfaces": [
-      "ef"
-    ],
-    "axes": {
-      "ef.config": [
-        "ValueGeneratedNever",
-        "ValueGeneratedOnAdd",
-        "HasConversion",
-        "HasColumnType",
-        "IsRequired-false"
-      ],
-      "shape.wrapped": [
-        "int",
-        "long",
-        "char",
-        "Guid",
-        "string"
-      ]
-    },
-    "narrow": {
-      "ef.query": "A configuration you write yourself always wins over these defaults.",
-      "ef.mapping": "A configuration you write yourself always wins over these defaults.",
-      "shape.site": "A configuration you write yourself always wins over these defaults.",
-      "shape.kind": "A configuration you write yourself always wins over these defaults."
-    },
-    "obligations": [
-      {
-        "id": "never",
-        "sentence": "A configuration you write yourself always wins over these defaults.",
-        "axes": {
-          "ef.config": [
-            "ValueGeneratedNever"
-          ]
-        }
-      },
-      {
-        "id": "on-add",
-        "sentence": "A configuration you write yourself always wins over these defaults.",
-        "axes": {
-          "ef.config": [
-            "ValueGeneratedOnAdd"
-          ]
-        }
-      },
-      {
-        "id": "column-type",
-        "sentence": "A facet you configure on the property, such as a maximum length or a column type, is kept.",
-        "axes": {
-          "ef.config": [
-            "HasColumnType"
-          ]
-        }
-      },
-      {
-        "id": "conversion",
-        "sentence": "A configuration you write yourself always wins over these defaults.",
-        "axes": {
-          "ef.config": [
-            "HasConversion"
-          ]
-        }
-      },
-      {
-        "id": "optional",
-        "sentence": "A configuration you write yourself always wins over these defaults.",
-        "axes": {
-          "ef.config": [
-            "IsRequired-false"
-          ]
-        }
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "char-key-not-generated",
-        "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
-        "sentence": "A key over `char` is yours to assign.",
-        "axes": {
-          "ef.config": [
-            "HasColumnType",
-            "HasConversion"
-          ],
-          "shape.wrapped": [
-            "char"
-          ]
-        }
-      },
-      {
-        "id": "guid-key-not-generated",
-        "source": "src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys",
-        "sentence": "A key over a `Guid` is yours to assign",
-        "axes": {
-          "ef.config": [
-            "HasColumnType",
-            "HasConversion"
-          ],
-          "shape.wrapped": [
-            "Guid"
-          ]
-        }
-      }
-    ]
-  },
-  {
-    "id": "L01-json-bytes",
-    "source": "README.md#what-typekit-guarantees",
-    "surfaces": [
-      "json"
-    ],
-    "obligations": [
-      {
-        "id": "the-underlying-types-json",
-        "sentence": "Its JSON is the underlying type's under your options",
-        "inapplicable": [
-          {
-            "axes": {
-              "json.Converters": [
-                "own-for-value-object"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says"
-          },
-          {
-            "axes": {
-              "shape.kind": [
-                "record-struct",
-                "sealed-record-class",
-                "validated-struct",
-                "validated-class"
-              ],
-              "shape.wrapped": [
-                "byte"
-              ],
-              "shape.position": [
-                "array-element"
-              ]
-            },
-            "cite": "not-promised:a-byte-array-is-base64"
-          }
-        ]
-      },
-      {
-        "id": "as-a-dictionary-key-too",
-        "sentence": "Its JSON is the underlying type's under your options",
-        "axes": {
-          "shape.position": [
-            "dictionary-key"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "json.Converters": [
-                "own-for-value-object"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says"
-          },
-          {
-            "axes": {
-              "shape.kind": [
-                "closed-set"
-              ],
-              "shape.position": [
-                "dictionary-key"
-              ],
-              "json.DictionaryKeyPolicy": [
-                "CamelCase",
-                "SnakeCaseLower",
-                "KebabCaseUpper",
-                "own-upper-case"
-              ]
-            },
-            "cite": "not-promised:a-closed-set-key-is-its-name"
-          }
-        ]
-      },
-      {
-        "id": "read-as-the-underlying-type-reads",
-        "sentence": "**Swapping a primitive for a value object keeps the JSON, the column and the schema.**",
-        "inapplicable": [
-          {
-            "axes": {
-              "shape.kind": [
-                "record-struct",
-                "sealed-record-class",
-                "validated-struct",
-                "validated-class"
-              ],
-              "shape.wrapped": [
-                "byte"
-              ],
-              "shape.position": [
-                "array-element"
-              ]
-            },
-            "cite": "not-promised:a-byte-array-is-base64"
-          },
-          {
-            "axes": {
-              "shape.kind": [
-                "closed-set"
-              ],
-              "shape.position": [
-                "dictionary-key"
-              ],
-              "json.DictionaryKeyPolicy": [
-                "CamelCase",
-                "SnakeCaseLower",
-                "KebabCaseUpper",
-                "own-upper-case"
-              ]
-            },
-            "cite": "not-promised:a-closed-set-key-is-its-name"
-          }
-        ]
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "a-datetime-is-written-as-utc",
-        "source": "README.md#what-typekit-guarantees",
-        "sentence": "Its JSON is the underlying type's under your options, with two exceptions: a `DateTime` is written as UTC",
-        "axes": {
-          "shape.wrapped": [
-            "DateTime"
-          ]
-        }
-      },
-      {
-        "id": "number-handling-on-the-containing-type",
-        "source": "README.md#what-typekit-guarantees",
-        "sentence": "and no converter sees number handling set by an attribute on the containing type"
-      },
-      {
-        "id": "a-struct-refuses-a-json-null",
-        "source": "README.md#what-typekit-guarantees",
-        "sentence": "What changes is what the value object rejects, a JSON `null` for a struct value object included.",
-        "axes": {
-          "input.json": [
-            "null"
-          ],
-          "shape.kind": [
-            "record-struct",
-            "validated-struct"
-          ]
-        }
-      },
-      {
-        "id": "a-validated-value-object-refuses-what-create-refuses",
-        "source": "README.md#what-typekit-guarantees",
-        "sentence": "What changes is what the value object rejects",
-        "axes": {
-          "input.json": [
-            "refused-by-create"
-          ],
-          "shape.kind": [
-            "validated-struct",
-            "validated-class"
-          ]
-        }
-      },
-      {
-        "id": "an-enum-under-a-source-generated-context",
-        "source": "README.md#what-typekit-guarantees",
-        "sentence": "And under a source-generated context, a value object over an enum needs its enum listed",
-        "axes": {
-          "json.TypeInfoResolver": [
-            "source-generated-context"
-          ],
-          "shape.wrapped": [
-            "enum",
-            "flags-enum"
-          ]
-        }
-      },
-      {
-        "id": "preserved-references-over-a-walked-class",
-        "source": "src/CodoMetis.TypeKit.Generators/README.md#json",
-        "sentence": "**Preserved references** (`ReferenceHandler.Preserve`) throw a `NotSupportedException` where the serializer could write `$id` or `$ref` inside the underlying value.",
-        "axes": {
-          "json.ReferenceHandler": [
-            "Preserve"
-          ],
-          "shape.wrapped": [
-            "own-record-class"
-          ]
-        }
-      },
-      {
-        "id": "a-closed-set-key-is-its-name",
-        "source": "docs/closed-sets.md#send-it-as-json",
-        "sentence": "No naming policy renames it, because a renamed name wouldn't read back.",
-        "axes": {
-          "shape.kind": [
-            "closed-set"
-          ],
-          "shape.position": [
-            "dictionary-key"
-          ]
-        }
-      },
-      {
-        "id": "a-byte-array-is-base64",
-        "source": "docs/json.md#the-wrapped-types-json",
-        "sentence": "An array of value objects over `byte` is a JSON array of numbers.",
-        "axes": {
-          "shape.wrapped": [
-            "byte"
-          ],
-          "shape.position": [
-            "array-element"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "System.Text.Json refuses PreferredObjectCreationHandling.Populate together with a ReferenceHandler on the options object; JsonRow substitutes the default, so the pair never applies.",
-        "pairs": [
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "L02-no-quote",
-    "source": "README.md#what-typekit-guarantees",
-    "surfaces": [
-      "json",
-      "text",
-      "logging"
-    ],
-    "obligations": [
-      {
-        "id": "parsing-never-repeats",
-        "sentence": "**Rejections never repeat the input.**",
-        "axes": {
-          "text.entry": [
-            "Parse",
-            "TryParse",
-            "IParsable",
-            "ISpanParsable",
-            "type-converter"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "shape.kind": [
-                "record-struct",
-                "sealed-record-class",
-                "validated-struct",
-                "validated-class"
-              ],
-              "shape.wrapped": [
-                "Uri",
-                "enum",
-                "flags-enum",
-                "NodaTime.Instant"
-              ],
-              "text.entry": [
-                "ISpanParsable"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.Generators/README.md#what-is-generated"
-          },
-          {
-            "axes": {
-              "shape.kind": [
-                "closed-set"
-              ],
-              "text.entry": [
-                "ISpanParsable"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.Generators/README.md#closed-sets"
-          },
-          {
-            "axes": {
-              "shape.kind": [
-                "record-struct",
-                "sealed-record-class",
-                "validated-struct",
-                "validated-class"
-              ],
-              "shape.wrapped": [
-                "own-record-class"
-              ],
-              "text.entry": [
-                "Parse",
-                "TryParse",
-                "IParsable",
-                "ISpanParsable",
-                "type-converter"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.Generators/README.md#what-is-generated"
-          },
-          {
-            "axes": {
-              "text.entry": [
-                "TryFrom",
-                "ToString-format",
-                "TryFormat-short-span"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.Generators/README.md#when-text-is-rejected"
-          }
-        ]
-      },
-      {
-        "id": "json-never-repeats",
-        "sentence": "A JSON or parsing rejection names the value object and the rule, or the underlying type it could not read.",
-        "inapplicable": [
-          {
-            "axes": {
-              "json.Converters": [
-                "own-for-wrapped",
-                "own-for-value-object"
-              ]
-            },
-            "cite": "not-promised:the-applications-own-converter"
-          }
-        ]
-      },
-      {
-        "id": "no-inner-that-quotes",
-        "sentence": "It carries no inner exception that quotes the text.",
-        "axes": {
-          "text.entry": [
-            "Parse",
-            "TryParse",
-            "IParsable",
-            "ISpanParsable",
-            "type-converter"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "shape.kind": [
-                "record-struct",
-                "sealed-record-class",
-                "validated-struct",
-                "validated-class"
-              ],
-              "shape.wrapped": [
-                "Uri",
-                "enum",
-                "flags-enum",
-                "NodaTime.Instant"
-              ],
-              "text.entry": [
-                "ISpanParsable"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.Generators/README.md#what-is-generated"
-          },
-          {
-            "axes": {
-              "shape.kind": [
-                "closed-set"
-              ],
-              "text.entry": [
-                "ISpanParsable"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.Generators/README.md#closed-sets"
-          },
-          {
-            "axes": {
-              "shape.kind": [
-                "record-struct",
-                "sealed-record-class",
-                "validated-struct",
-                "validated-class"
-              ],
-              "shape.wrapped": [
-                "own-record-class"
-              ],
-              "text.entry": [
-                "Parse",
-                "TryParse",
-                "IParsable",
-                "ISpanParsable",
-                "type-converter"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.Generators/README.md#what-is-generated"
-          },
-          {
-            "axes": {
-              "text.entry": [
-                "TryFrom",
-                "ToString-format",
-                "TryFormat-short-span"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.Generators/README.md#when-text-is-rejected"
-          }
-        ]
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "a-rejected-dictionary-key-in-the-path",
-        "source": "README.md#what-typekit-guarantees",
-        "sentence": "One exception comes from System.Text.Json: a rejected dictionary key is in the `JsonException`'s `Path`, and so in MVC's 400",
-        "axes": {
-          "shape.position": [
-            "dictionary-key"
-          ]
-        }
-      },
-      {
-        "id": "the-applications-own-converter",
-        "source": "README.md#what-typekit-guarantees",
-        "sentence": "So a secret doesn't end up in a message or a log through this package, as long as your fault type doesn't carry it.",
-        "axes": {
-          "json.Converters": [
-            "own-for-wrapped",
-            "own-for-value-object"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "System.Text.Json refuses PreferredObjectCreationHandling.Populate together with a ReferenceHandler on the options object; JsonRow substitutes the default, so the pair never applies.",
-        "pairs": [
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ]
-        ]
-      },
-      {
-        "reason": "System.Text.Json writes no dictionary key of a record class but through a converter of the application's (NotSupportedException for the wrapped type alike, L01's rows), where the JSON half is not promised (not-promised the-applications-own-converter), and a value object over a record class has no parsing (Generators README#what-is-generated), so no check of the claim can read the pair.",
-        "pairs": [
-          [
-            "shape.position=dictionary-key",
-            "shape.wrapped=own-record-class"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "L03-one-rule",
-    "source": "README.md#what-typekit-guarantees",
-    "surfaces": [
-      "text",
-      "json"
-    ],
-    "narrow": {
-      "input.json": "The generated `TryFrom`, `FromKnownGood`, JSON converter, parsing and type converter all run it, and each reports the fault you return from `Create`"
-    },
-    "obligations": [
-      {
-        "id": "tryfrom-runs-create",
-        "sentence": "The generated `TryFrom`, `FromKnownGood`, JSON converter, parsing and type converter all run it",
-        "axes": {
-          "text.entry": [
-            "TryFrom"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "shape.kind": [
-                "closed-set"
-              ],
-              "text.entry": [
-                "TryFrom"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.Generators/README.md#closed-sets"
-          }
-        ]
-      },
-      {
-        "id": "parsing-runs-create",
-        "sentence": "The generated `TryFrom`, `FromKnownGood`, JSON converter, parsing and type converter all run it",
-        "axes": {
-          "text.entry": [
-            "Parse",
-            "TryParse",
-            "IParsable",
-            "ISpanParsable",
-            "type-converter"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "shape.kind": [
-                "record-struct",
-                "sealed-record-class",
-                "validated-struct",
-                "validated-class"
-              ],
-              "shape.wrapped": [
-                "Uri",
-                "enum",
-                "flags-enum",
-                "NodaTime.Instant"
-              ],
-              "text.entry": [
-                "ISpanParsable"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.Generators/README.md#what-is-generated"
-          },
-          {
-            "axes": {
-              "shape.kind": [
-                "closed-set"
-              ],
-              "text.entry": [
-                "ISpanParsable"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.Generators/README.md#closed-sets"
-          },
-          {
-            "axes": {
-              "shape.kind": [
-                "record-struct",
-                "sealed-record-class",
-                "validated-struct",
-                "validated-class"
-              ],
-              "shape.wrapped": [
-                "own-record-class"
-              ],
-              "text.entry": [
-                "Parse",
-                "TryParse",
-                "IParsable",
-                "ISpanParsable",
-                "type-converter"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.Generators/README.md#what-is-generated"
-          }
-        ]
-      },
-      {
-        "id": "json-runs-create",
-        "sentence": "The generated `TryFrom`, `FromKnownGood`, JSON converter, parsing and type converter all run it"
-      },
-      {
-        "id": "refusals-name-the-fault",
-        "sentence": "the `JsonException`, the `FormatException` and the `FromKnownGood` exception all name your `EmailFault.NoAt`"
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "stored-json-skips-validation",
-        "source": "README.md#what-typekit-guarantees",
-        "sentence": "`StoredJsonConverterFactory` reads JSON the application stored itself.",
-        "axes": {
-          "json.Converters": [
-            "StoredJsonConverterFactory"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "System.Text.Json refuses PreferredObjectCreationHandling.Populate together with a ReferenceHandler on the options object; JsonRow substitutes the default, so the pair never applies.",
-        "pairs": [
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "L04-round-trip",
-    "source": "src/CodoMetis.TypeKit.Generators/README.md#parsing-and-formatting",
-    "surfaces": [
-      "text",
-      "json"
-    ],
-    "obligations": [
-      {
-        "id": "invariant-whatever-the-culture",
-        "sentence": "A null `IFormatProvider` means the invariant culture in every generated `Parse`, `TryParse`, `ToString` and `TryFormat`, so the text doesn't depend on the culture the process runs in."
-      },
-      {
-        "id": "the-type-converter-writes-the-same",
-        "sentence": "`ToString()` is the underlying type's own default text under the invariant culture, and the type converter and `$\"{x}\"` write the same.",
-        "axes": {
-          "text.entry": [
-            "ToString-format",
-            "TryFormat-short-span",
-            "type-converter"
-          ]
-        },
-        "inapplicable": [
-          {
-            "axes": {
-              "shape.kind": [
-                "closed-set"
-              ],
-              "text.entry": [
-                "ToString-format",
-                "TryFormat-short-span"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.Generators/README.md#closed-sets"
-          },
-          {
-            "axes": {
-              "shape.kind": [
-                "record-struct",
-                "sealed-record-class",
-                "validated-struct",
-                "validated-class"
-              ],
-              "shape.wrapped": [
-                "own-record-class"
-              ],
-              "text.entry": [
-                "type-converter"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.Generators/README.md#what-is-generated"
-          }
-        ]
-      },
-      {
-        "id": "text-reads-back",
-        "sentence": "That text reads back as the same value wherever the underlying type's own does",
-        "inapplicable": [
-          {
-            "axes": {
-              "shape.kind": [
-                "closed-set"
-              ],
-              "text.entry": [
-                "TryFrom",
-                "ISpanParsable",
-                "ToString-format",
-                "TryFormat-short-span"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.Generators/README.md#closed-sets"
-          },
-          {
-            "axes": {
-              "shape.kind": [
-                "record-struct",
-                "sealed-record-class",
-                "validated-struct",
-                "validated-class"
-              ],
-              "shape.wrapped": [
-                "own-record-class"
-              ],
-              "text.entry": [
-                "Parse",
-                "TryParse",
-                "IParsable",
-                "ISpanParsable",
-                "type-converter",
-                "ToString-format",
-                "TryFormat-short-span"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.Generators/README.md#what-is-generated"
-          },
-          {
-            "axes": {
-              "shape.kind": [
-                "record-struct",
-                "sealed-record-class",
-                "validated-struct",
-                "validated-class"
-              ],
-              "shape.wrapped": [
-                "Uri",
-                "enum",
-                "flags-enum",
-                "NodaTime.Instant"
-              ],
-              "text.entry": [
-                "ISpanParsable"
-              ]
-            },
-            "cite": "docs:src/CodoMetis.TypeKit.Generators/README.md#what-is-generated"
-          },
-          {
-            "axes": {
-              "shape.kind": [
-                "record-struct",
-                "sealed-record-class",
-                "validated-struct",
-                "validated-class"
-              ],
-              "shape.wrapped": [
-                "TimeOnly",
-                "DateTime",
-                "DateTimeOffset"
-              ],
-              "text.entry": [
-                "type-converter"
-              ]
-            },
-            "cite": "not-promised:dates-and-times-lose-detail-as-text"
-          }
-        ]
-      },
-      {
-        "id": "json-refusal-is-a-json-exception",
-        "sentence": "Input it can't read throws a `JsonException` naming the value object and the underlying type"
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "dates-and-times-lose-detail-as-text",
-        "source": "src/CodoMetis.TypeKit.Generators/README.md#parsing-and-formatting",
-        "sentence": "**`TimeOnly`, `DateTime` and `DateTimeOffset` lose detail as text.**",
-        "axes": {
-          "shape.wrapped": [
-            "TimeOnly",
-            "DateTime",
-            "DateTimeOffset"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "System.Text.Json refuses PreferredObjectCreationHandling.Populate together with a ReferenceHandler on the options object; JsonRow substitutes the default, so the pair never applies.",
-        "pairs": [
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "L05-equality",
-    "source": "src/CodoMetis.TypeKit.Generators/README.md#equality",
-    "surfaces": [
-      "generation"
-    ],
-    "narrow": {
-      "shape.refused-kind": "A declaration that can't be generated fails the build, so no type is left half-generated."
-    },
-    "obligations": [
-      {
-        "id": "equality-is-the-underlying-values",
-        "sentence": "Equality is the underlying value's, like the ordering, the JSON and the column."
-      },
-      {
-        "id": "ordering-follows-the-underlying-type",
-        "sentence": "`CompareTo` and the operators follow the underlying type's ordering, ordinal for a string."
-      },
-      {
-        "id": "through-every-base",
-        "sentence": "The value object implements each base's `IEquatable<TBase>` again (`IReimplementedEquatable<TBase>`), so a collection of the base compares it the way the value object does.",
-        "axes": {
-          "shape.inheritance": [
-            "base-depth-1",
-            "base-depth-2",
-            "base-depth-3",
-            "base-explicit-IEquatable"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "A struct cannot derive from a base type (C# structs inherit only from ValueType), so it has no base record.",
-        "pairs": [
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.kind=validated-struct"
-          ]
-        ]
-      },
-      {
-        "reason": "A closed set wraps nothing (Generators README#closed-sets: a sealed class whose instances are its members), so it has no shape.wrapped.",
-        "pairs": [
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=ulong"
-          ]
-        ]
-      },
-      {
-        "reason": "A value object or closed set nested in a generic type fails the build (CMTK1005, CMTK1018; Generators README#build-errors), so no such type exists to compare.",
-        "pairs": [
-          [
-            "shape.containing=class",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=array-element",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=dictionary-key",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=dictionary-value",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=field",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=immutable-array-element",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=in-patch",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=list-element",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=nullable-property",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=polymorphic-derived-property",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=property",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=read-only-list-element",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=record-ctor-parameter",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=required-init",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.position=root",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=ulong"
-          ]
-        ]
-      },
-      {
-        "reason": "A value at the root is not held by a containing type, so shape.containing has nothing to apply to.",
-        "pairs": [
-          [
-            "shape.containing=class",
-            "shape.position=root"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.position=root"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.position=root"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.position=root"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.position=root"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "L06-off-the-wire",
-    "source": "README.md#what-typekit-guarantees",
-    "surfaces": [
-      "json",
-      "option-result"
-    ],
-    "obligations": [
-      {
-        "id": "never-written",
-        "sentence": "System.Text.Json throws `NotSupportedException` for either, in both directions, instead of writing `{}` that reads back as `None`."
-      },
-      {
-        "id": "never-read",
-        "sentence": "System.Text.Json throws `NotSupportedException` for either, in both directions, instead of writing `{}` that reads back as `None`."
-      }
-    ],
-    "not-promised": [
-      {
-        "id": "a-source-generated-context-refuses-a-nullable",
-        "source": "src/CodoMetis.TypeKit/README.md#not-wire-types",
-        "sentence": "**A source-generated context can't describe an `Option<T>?` or `Result<...>?` property.**",
-        "axes": {
-          "json.TypeInfoResolver": [
-            "source-generated-context"
-          ],
-          "shape.position": [
-            "nullable-property"
-          ]
-        }
-      },
-      {
-        "id": "a-missing-property-reaches-no-converter",
-        "source": "src/CodoMetis.TypeKit/README.md#not-wire-types",
-        "sentence": "**A missing property reaches no converter.**"
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "A closed set wraps nothing (Generators README#closed-sets: a sealed class whose instances are its members), so it has no shape.wrapped.",
-        "pairs": [
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=ulong"
-          ]
-        ]
-      },
-      {
-        "reason": "A value at the root is not held by a containing type, so shape.containing has nothing to apply to.",
-        "pairs": [
-          [
-            "shape.containing=class",
-            "shape.position=root"
-          ],
-          [
-            "shape.containing=generic-type",
-            "shape.position=root"
-          ],
-          [
-            "shape.containing=record-class",
-            "shape.position=root"
-          ],
-          [
-            "shape.containing=record-struct",
-            "shape.position=root"
-          ],
-          [
-            "shape.containing=struct",
-            "shape.position=root"
-          ]
-        ]
-      },
-      {
-        "reason": "Result<TError> has no Select or SelectMany, so no query expression produces one, and FirstOrNone returns an Option<T>, never a Result<TError> (src/CodoMetis.TypeKit/ResultExtensions.cs and OptionExtensions.cs).",
-        "pairs": [
-          [
-            "or.operation=FirstOrNone",
-            "or.shape=Result-E"
-          ],
-          [
-            "or.operation=query-syntax",
-            "or.shape=Result-E"
-          ]
-        ]
-      },
-      {
-        "reason": "System.Text.Json serializes a field only under IncludeFields (or [JsonInclude]), so without it the member is in no document and no converter runs in either direction, for the plain type alike.",
-        "pairs": [
-          [
-            "json.IncludeFields=default",
-            "shape.position=field"
-          ]
-        ]
-      },
-      {
-        "reason": "System.Text.Json refuses JsonObjectCreationHandling.Populate together with a reference handler (InvalidOperationException when the options are used; harness/JsonRow.cs runs such a row without Populate), so no row can set both.",
-        "pairs": [
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=IgnoreCycles"
-          ],
-          [
-            "json.PreferredObjectCreationHandling=Populate",
-            "json.ReferenceHandler=Preserve"
-          ]
-        ]
-      }
-    ]
-  },
-  {
-    "id": "C22-generator-refusals",
-    "source": "src/CodoMetis.TypeKit.Generators/README.md#build-errors",
-    "surfaces": [
-      "generation",
-      "analyzers"
-    ],
-    "axes": {
-      "build-host": [
-        "sdk-build"
-      ]
-    },
-    "narrow": {
-      "shape.position": "A declaration that can't be generated fails the build, so no type is left half-generated.",
-      "shape.containing": "A declaration that can't be generated fails the build, so no type is left half-generated."
-    },
-    "obligations": [
-      {
-        "id": "no-type-half-generated",
-        "sentence": "A declaration that can't be generated fails the build, so no type is left half-generated."
-      },
-      {
-        "id": "every-error-links-the-table",
-        "sentence": "Every error ends with a link to this table."
-      },
-      {
-        "id": "unsealed-record-class",
-        "sentence": "A record class not declared `sealed`.",
-        "axes": {
-          "shape.refused-kind": [
-            "unsealed-record-class (CMTK1006)"
-          ]
-        }
-      },
-      {
-        "id": "over-value-object",
-        "sentence": "or a value object (itself included). Wrap what the other value object wraps instead.",
-        "axes": {
-          "shape.refused-kind": [
-            "over-value-object (CMTK1005)"
-          ]
-        }
-      },
-      {
-        "id": "generic-wrapped",
-        "sentence": "A generic underlying type, a tuple included, fails the build (CMTK1005).",
-        "axes": {
-          "shape.refused-kind": [
-            "generic-wrapped (CMTK1005)"
-          ]
-        }
-      },
-      {
-        "id": "abstract",
-        "sentence": "An abstract type with a value-object marker. It would get no member, and a value held as it, of a type derived from it, would have no `Value` and be written as `{}`.",
-        "axes": {
-          "shape.refused-kind": [
-            "abstract (CMTK1005)"
-          ]
-        }
-      },
-      {
-        "id": "over-object",
-        "sentence": "or wrapping `object`, `System.Enum`, an array, a pointer, a nullable type, a generic type (a tuple included) or a value object (itself included).",
-        "axes": {
-          "shape.refused-kind": [
-            "over-object (CMTK1005)"
-          ]
-        }
-      },
-      {
-        "id": "over-system-enum",
-        "sentence": "or wrapping `object`, `System.Enum`, an array, a pointer, a nullable type, a generic type (a tuple included) or a value object (itself included).",
-        "axes": {
-          "shape.refused-kind": [
-            "over-System.Enum (CMTK1005)"
-          ]
-        }
-      },
-      {
-        "id": "named-as-generated-member",
-        "sentence": "named `Value` or as another member the generators add (`From`, `TryFrom`, `FromKnownGood`, `Revalidate`, `Parse`, `TryParse`, `TryFormat`, `MinValue`, `MaxValue`, `CompareTo`)",
-        "axes": {
-          "shape.refused-kind": [
-            "named-as-generated-member (CMTK1005)"
-          ]
-        }
-      },
-      {
-        "id": "closed-set-named-as-generated-member",
-        "sentence": "a set itself named as one of them (a member can't have the name of its type)",
-        "axes": {
-          "shape.refused-kind": [
-            "closed-set-named-as-generated-member (CMTK1021)"
-          ]
-        }
-      },
-      {
-        "id": "equality-operator",
-        "sentence": "So a hand-written `Equals(TSelf)`, `GetHashCode()`, `IEquatable<TSelf>.Equals`, or `operator ==` or `!=` between two of the type, fails the build (CMTK1011).",
-        "axes": {
-          "shape.refused-kind": [
-            "equality-operator (CMTK1011)"
-          ]
-        }
-      }
-    ],
-    "exclude": [
-      {
-        "reason": "A declaration nested in a generic type is refused for that alone (Generators README, Build errors: CMTK1005, \"Generic or nested in a generic type\"; the axes file's refused list), so it cannot show which refusal of its own the generators report.",
-        "pairs": [
-          [
-            "build-host=sdk-build",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=explicit-interface-member",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.inheritance=none",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=abstract (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=equality-operator (CMTK1011)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=generic-wrapped (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=named-as-generated-member (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=over-value-object (CMTK1005)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.refused-kind=unsealed-record-class (CMTK1006)",
-            "shape.site=in-generic-type"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.site=in-generic-type",
-            "shape.wrapped=ulong"
-          ]
-        ]
-      },
-      {
-        "reason": "C# seals every struct and refuses an abstract one, so a record struct can be neither an unsealed nor an abstract record class; a closed set is never a record (CMTK1020), and an unsealed or abstract one is CMTK1014, a refusal of its own.",
-        "pairs": [
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=abstract (CMTK1005)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=unsealed-record-class (CMTK1006)"
-          ]
-        ]
-      },
-      {
-        "reason": "A closed set wraps no type and has no equality of the underlying value to write by hand (Generators README, Closed sets), so it cannot be declared over a type or with a value object's equality; its own name clash is closed-set-named-as-generated-member (CMTK1021).",
-        "pairs": [
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=equality-operator (CMTK1011)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=generic-wrapped (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=named-as-generated-member (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=over-System.Enum (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=over-object (CMTK1005)"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.refused-kind=over-value-object (CMTK1005)"
-          ]
-        ]
-      },
-      {
-        "reason": "CMTK1021 is a closed set's refusal; a value object named as a generated member is named-as-generated-member (CMTK1005).",
-        "pairs": [
-          [
-            "shape.kind=record-struct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=sealed-record-class",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=validated-class",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.kind=validated-struct",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ]
-        ]
-      },
-      {
-        "reason": "The refused kind fixes what is wrapped: object, System.Enum; and a closed set wraps no type (Generators README, Closed sets), so shape.wrapped has nothing to apply to.",
-        "pairs": [
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.kind=closed-set",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=over-System.Enum (CMTK1005)",
-            "shape.wrapped=ulong"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=DateOnly"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=DateTime"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=DateTimeOffset"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=Guid"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=NodaTime.Instant"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=TimeOnly"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=TimeSpan"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=Uri"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=bool"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=byte"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=char"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=decimal"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=double"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=enum"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=flags-enum"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=int"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=long"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=own-record-class"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=string"
-          ],
-          [
-            "shape.refused-kind=over-object (CMTK1005)",
-            "shape.wrapped=ulong"
-          ]
-        ]
-      },
-      {
-        "reason": "A record struct has no base type, and a closed set is a sealed class that is never a record (CMTK1020), so neither derives from the base records of shape.inheritance; an explicit member of another interface they implement themselves.",
-        "pairs": [
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-1",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-2",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-depth-3",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.kind=closed-set"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.kind=record-struct"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.kind=validated-struct"
-          ],
-          [
-            "shape.inheritance=base-explicit-IEquatable",
-            "shape.refused-kind=closed-set-named-as-generated-member (CMTK1021)"
-          ]
-        ]
-      }
-    ]
-  }
-]
diff --git a/tools/probe/corpus/dismissed.jsonl b/tools/probe/corpus/dismissed.jsonl
deleted file mode 100644
index 4327b389..00000000
--- a/tools/probe/corpus/dismissed.jsonl
+++ /dev/null
@@ -1 +0,0 @@
-{"id": "G1", "reason": "Not a TypeKit bug: the MVC [FromBody] T v of a class is nullable, so ASP.NET makes the body optional, and its OpenAPI 2.0 writer turns any nullable body into allOf:[{x-nullable:true}] without pattern; a plain int? without TypeKit gets the same bytes. The harness compared a nullable class value object with a non-nullable int (fix-f2-g1-openapi, measured at 1ee02fc).", "date": "2026-10-15"}
diff --git a/tools/probe/corpus/harness/BaseProbe.cs b/tools/probe/corpus/harness/BaseProbe.cs
deleted file mode 100644
index 13b5e370..00000000
--- a/tools/probe/corpus/harness/BaseProbe.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-// Calibration of the shared HTTP host (not a claim): runs the baseline's wire half over its own rows of claim C07 to find harness mistakes
-// before the claims use it. The schema half is claim C21's (C21OpenapiSchemaParityProbe). Each comparison is a check of its own (HttpBaseline.Run),
-// of the implicit obligation claim: C07 promises nothing of the wire, and its seed names no obligation.
-using Probes.Shapes;
-namespace Probes;
-public sealed class BaseProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("BaseProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run("BASE", idx, async r => await HttpBaseline.Run(r, Registry.Of(r), schema: false), probe);
-}
diff --git a/tools/probe/corpus/harness/BuildConsumer.cs b/tools/probe/corpus/harness/BuildConsumer.cs
deleted file mode 100644
index 15dddbc5..00000000
--- a/tools/probe/corpus/harness/BuildConsumer.cs
+++ /dev/null
@@ -1,125 +0,0 @@
-// A throwaway consumer of the generators, built once per probe run with every row's declarations in a file of its own, for what
-// only a build can show: the generators' diagnostics (CMTK1xxx). It builds as test/CodoMetis.TypeKit.Generators.Tests' BuildOutcomeTests
-// does: under artifacts/, against the projects this run already built (--no-dependencies), outside the repository's build settings.
-using System.Diagnostics;
-using System.Reflection;
-using System.Reflection.Metadata;
-using System.Reflection.PortableExecutable;
-using System.Text.RegularExpressions;
-namespace Probes.Build;
-
-public sealed record BuildDiagnostic(string File, string Severity, string Id, string Message);
-
-public sealed record ConsumerOutcome(int ExitCode, string Output, IReadOnlyList<BuildDiagnostic> Diagnostics, IReadOnlyDictionary<string, HashSet<string>> Methods)
-{
-    /// <summary>The diagnostics reported in one of the consumer's files.</summary>
-    public IEnumerable<BuildDiagnostic> In(string file) => Diagnostics.Where(d => Path.GetFileName(d.File) == file);
-}
-
-public static partial class Consumer
-{
-    static readonly Dictionary<string, Lazy<Task<ConsumerOutcome>>> Builds = new();
-
-    /// <summary>Builds the consumer of <paramref name="files"/> once per <paramref name="key"/> in this process.</summary>
-    public static Task<ConsumerOutcome> Build(string key, Func<IReadOnlyDictionary<string, string>> files)
-    {
-        lock (Builds)
-        {
-            if (!Builds.TryGetValue(key, out var build)) Builds[key] = build = new(() => Run(files()));
-            return build.Value;
-        }
-    }
-
-    public static string RepositoryRoot()
-    {
-        for (var d = new DirectoryInfo(AppContext.BaseDirectory); d is not null; d = d.Parent)
-            if (File.Exists(Path.Combine(d.FullName, "CodoMetis.TypeKit.slnx"))) return d.FullName;
-        throw new InvalidOperationException($"no CodoMetis.TypeKit.slnx above {AppContext.BaseDirectory}");
-    }
-
-    static string Configuration => typeof(Consumer).Assembly.GetCustomAttribute<AssemblyConfigurationAttribute>()?.Configuration
-                                   ?? throw new InvalidOperationException("the probe assembly carries no AssemblyConfigurationAttribute");
-
-    static async Task<ConsumerOutcome> Run(IReadOnlyDictionary<string, string> files)
-    {
-        var root = RepositoryRoot();
-        var dir = Path.Combine(root, "artifacts", $"probe-consumer-{Guid.NewGuid():N}");
-        Directory.CreateDirectory(dir);
-        try
-        {
-            var src = Path.Combine(root, "src");
-            await File.WriteAllTextAsync(Path.Combine(dir, "Consumer.csproj"), $"""
-                <Project Sdk="Microsoft.NET.Sdk">
-                  <PropertyGroup>
-                    <TargetFramework>net10.0</TargetFramework>
-                    <Nullable>enable</Nullable>
-                    <ImplicitUsings>disable</ImplicitUsings>
-                    <AssemblyName>ProbeConsumer</AssemblyName>
-                  </PropertyGroup>
-                  <ItemGroup>
-                    <ProjectReference Include="{src}/CodoMetis.TypeKit.Generators/CodoMetis.TypeKit.Generators.csproj" />
-                    <Reference Include="NodaTime"><HintPath>{typeof(NodaTime.Instant).Assembly.Location}</HintPath></Reference>
-                  </ItemGroup>
-                </Project>
-                """);
-            await File.WriteAllTextAsync(Path.Combine(dir, "Directory.Build.props"), "<Project />");
-            await File.WriteAllTextAsync(Path.Combine(dir, "Directory.Build.targets"), "<Project />");
-            await File.WriteAllTextAsync(Path.Combine(dir, "Directory.Packages.props"),
-                "<Project><PropertyGroup><ManagePackageVersionsCentrally>false</ManagePackageVersionsCentrally></PropertyGroup></Project>");
-            foreach (var (name, text) in files) await File.WriteAllTextAsync(Path.Combine(dir, name), text);
-
-            var dotnet = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH") is { Length: > 0 } host ? host : "dotnet";
-            var info = new ProcessStartInfo(dotnet, ["build", dir, "-c", Configuration, "--no-dependencies", "-p:RestoreRecursive=false", "-nodeReuse:false", "-clp:NoSummary", "-v:q", "-nologo"])
-            {
-                RedirectStandardOutput = true, RedirectStandardError = true, WorkingDirectory = dir,
-            };
-            // The run's code coverage instruments this process through its environment; the build is not the probe's code.
-            foreach (var k in info.Environment.Keys.ToList())
-                if (k.StartsWith("CORECLR_", StringComparison.OrdinalIgnoreCase) || k.StartsWith("COR_", StringComparison.OrdinalIgnoreCase)
-                    || k.Contains("CODECOVERAGE", StringComparison.OrdinalIgnoreCase) || k.StartsWith("MicrosoftInstrumentationEngine", StringComparison.OrdinalIgnoreCase)
-                    || k.Equals("DOTNET_STARTUP_HOOKS", StringComparison.OrdinalIgnoreCase))
-                    info.Environment.Remove(k);
-            info.Environment["DOTNET_CLI_UI_LANGUAGE"] = "en";
-            using var process = Process.Start(info)!;
-            var stdout = process.StandardOutput.ReadToEndAsync();
-            var stderr = process.StandardError.ReadToEndAsync();
-            using (var timeout = new CancellationTokenSource(TimeSpan.FromMinutes(10))) await process.WaitForExitAsync(timeout.Token);
-            var output = await stdout + await stderr;
-            var diagnostics = Line().Matches(output)
-                .Select(m => new BuildDiagnostic(m.Groups["file"].Value.Trim(), m.Groups["sev"].Value, m.Groups["id"].Value, m.Groups["msg"].Value.Trim()))
-                .Distinct().ToList();
-            var dll = Path.Combine(dir, "bin", Configuration, "net10.0", "ProbeConsumer.dll");
-            return new ConsumerOutcome(process.ExitCode, output, diagnostics, File.Exists(dll) ? Methods(dll) : new Dictionary<string, HashSet<string>>());
-        }
-        finally
-        {
-            try { Directory.Delete(dir, recursive: true); } catch (IOException) { } catch (UnauthorizedAccessException) { }
-        }
-    }
-
-    /// <summary>The methods each type of the built assembly declares, by the type's metadata name (nesting with '+'), read without loading it.</summary>
-    static Dictionary<string, HashSet<string>> Methods(string dll)
-    {
-        using var stream = File.OpenRead(dll);
-        using var pe = new PEReader(stream);
-        var md = pe.GetMetadataReader();
-        string Name(TypeDefinition t)
-        {
-            var name = md.GetString(t.Name);
-            var outer = t.GetDeclaringType();
-            if (!outer.IsNil) return Name(md.GetTypeDefinition(outer)) + "+" + name;
-            var ns = md.GetString(t.Namespace);
-            return ns.Length == 0 ? name : ns + "." + name;
-        }
-        var result = new Dictionary<string, HashSet<string>>();
-        foreach (var h in md.TypeDefinitions)
-        {
-            var t = md.GetTypeDefinition(h);
-            result[Name(t)] = [.. t.GetMethods().Select(m => md.GetString(md.GetMethodDefinition(m).Name))];
-        }
-        return result;
-    }
-
-    [GeneratedRegex(@"^(?<file>[^\r\n(]+)\((?<line>\d+),(?<col>\d+)\): (?<sev>warning|error) (?<id>[A-Z]+\d+): (?<msg>.*?)(?: \[[^\]\r\n]*\])?\r?$", RegexOptions.Multiline)]
-    private static partial Regex Line();
-}
diff --git a/tools/probe/corpus/harness/BuildDecls.cs b/tools/probe/corpus/harness/BuildDecls.cs
deleted file mode 100644
index 7efdb659..00000000
--- a/tools/probe/corpus/harness/BuildDecls.cs
+++ /dev/null
@@ -1,91 +0,0 @@
-// The hand half of C09Shapes.g.cs and C11Shapes.g.cs (generated from the rows, one value object per row): the tables' rows, and the
-// wrapped types of C11's parse shapes.
-namespace Probes.Build;
-
-/// <summary>One C09 row as declared: the effective settings, the value object, its bases from the direct one up, and its factory.</summary>
-public sealed record C09Case(int Index, string Key, string Kind, string Site, string Inheritance, Type Vo, Type[] Bases, Func<object, object> Make, (string Axis, string Value)[] Substituted);
-
-/// <summary>
-/// One C11 row as declared: the effective settings, the value object and the type it wraps, and for a parse shape its control: a value
-/// object of the same kind, site and inheritance over the nearest type that does parse.
-/// </summary>
-public sealed record C11Case(int Index, string Key, string Kind, string Site, string Inheritance, Type Vo, Type Wrapped, Type? Control, Type? ControlWrapped, (string Axis, string Value)[] Substituted);
-
-public static class Decls
-{
-    /// <summary>
-    /// The row's settings as the generator keyed them; a table generated from other rows is a harness error, not a pass. Read from
-    /// the cached copy of the row, so the run's own row marks no axis read.
-    /// </summary>
-    public static string Key(string probe, int index) =>
-        string.Join(";", Probes.Shapes.Rows.Get(probe, index).All.OrderBy(kv => kv.Key, StringComparer.Ordinal).Select(kv => $"{kv.Key}={kv.Value}"));
-}
-
-// C11's parse shapes, each the whole wrapped type (CHANGELOG 2.1.0, Fixed): "A wrapped type's `Parse` whose result can't be assigned
-// to it, or that takes its text by `ref`, or an abstract class's string constructor".
-
-/// <summary>implicit-result: a static Parse whose result, an int, cannot be assigned to the type.</summary>
-public sealed class C11ParsesToInt
-{
-    public static int Parse(string text) => text.Length;
-    public override string ToString() => "parses-to-int";
-}
-
-/// <summary>ref-text: a static Parse that takes its text by ref.</summary>
-public sealed class C11ParsesByRef
-{
-    public static C11ParsesByRef Parse(ref string text) { text = ""; return new(); }
-    public override string ToString() => "parses-by-ref";
-}
-
-/// <summary>ref-text: a string constructor that takes its text by ref.</summary>
-public sealed class C11ConstructedByRef
-{
-    public C11ConstructedByRef(ref string text) => text = "";
-    private C11ConstructedByRef() { }
-    public static C11ConstructedByRef Sample() => new();
-    public override string ToString() => "constructed-by-ref";
-}
-
-/// <summary>abstract-string-ctor: an abstract class with a public string constructor, which only a derived class can call.</summary>
-public abstract class C11AbstractText
-{
-    public C11AbstractText(string text) => Text = text;
-    public string Text { get; }
-    public override string ToString() => Text;
-}
-
-public sealed class C11ConcreteText(string text) : C11AbstractText(text);
-
-// The controls, each the nearest type that can be parsed (Generators README, "What you can wrap": "Parsing where it can be parsed"):
-// a Parse whose result converts to the type by a user-defined implicit operator, so it can be assigned; a Parse taking its text by in,
-// which a call passes as it is; a sealed class's public string constructor.
-
-/// <summary>Control of implicit-result: Parse gives a type that converts to this one implicitly.</summary>
-public sealed class C11ParsedShape
-{
-    public string Text { get; init; } = "";
-    public static C11ParsedCircle Parse(string text) => new() { Text = text };
-    public override string ToString() => Text;
-}
-
-public sealed class C11ParsedCircle
-{
-    public string Text { get; init; } = "";
-    public static implicit operator C11ParsedShape(C11ParsedCircle circle) => new() { Text = circle.Text };
-}
-
-/// <summary>Control of ref-text: Parse takes its text by in.</summary>
-public sealed class C11ParsesFromIn
-{
-    public string Text { get; private init; } = "";
-    public static C11ParsesFromIn Parse(in string text) => new() { Text = text };
-    public override string ToString() => Text;
-}
-
-/// <summary>Control of abstract-string-ctor: a sealed class with a public string constructor.</summary>
-public sealed class C11ConstructedConcrete(string text)
-{
-    public string Text { get; } = text;
-    public override string ToString() => Text;
-}
diff --git a/tools/probe/corpus/harness/BuildRefusals.cs b/tools/probe/corpus/harness/BuildRefusals.cs
deleted file mode 100644
index be3d79da..00000000
--- a/tools/probe/corpus/harness/BuildRefusals.cs
+++ /dev/null
@@ -1,280 +0,0 @@
-// The declarations the generators refuse (shape.refused-kind), written as C# per row, and the consumer build that shows what the
-// generators did with them (C22). The build is BuildConsumer.cs's (a throwaway consumer under artifacts/, against the projects this run
-// already built, outside the repository's build settings) with Metalama's transformed files kept, since a refused declaration fails the
-// build and leaves no assembly to read: the transformed source is where a member the generators added to a refused type would show.
-using System.Diagnostics;
-using System.Reflection;
-using System.Text.RegularExpressions;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-namespace Probes.Build;
-
-/// <summary>A consumer build: its exit code, its output, its diagnostics, and Metalama's transformed source of each file.</summary>
-public sealed record RefusalOutcome(int ExitCode, string Output, IReadOnlyList<BuildDiagnostic> Diagnostics, IReadOnlyDictionary<string, string> Transformed)
-{
-    /// <summary>The diagnostics reported in one of the consumer's files.</summary>
-    public IEnumerable<BuildDiagnostic> In(string file) => Diagnostics.Where(d => Path.GetFileName(d.File) == file);
-}
-
-/// <summary>
-/// One refusal of the Generators README's "Build errors" table, as a row declares it: the id the table gives it, the obligation of C22
-/// that states it, the consumer it is built in, and the compiler errors that may stand beside it in its own file.
-/// </summary>
-/// <remarks>
-/// A compiler error in a consumer hid every LAMA0611 of the other files (e4b751c), so the declarations whose refusal comes with a
-/// compiler error of its own are built apart: a refused closed set leaves its interface's members unimplemented (CS0535, as
-/// BuildOutcomeTests allows it), and a hand-written equality operator of a record is also C#'s CS0111 (the README says so).
-/// </remarks>
-public sealed record Refusal(string Kind, string Id, string Obligation, string Group, IReadOnlyList<string> Companions);
-
-/// <summary>One row's declarations: the refused type, as the diagnostics name it, and a control the generators must generate.</summary>
-public sealed record RefusedDeclaration(int Index, Refusal Refusal, string Name, string Display, string Control, string File, string Source);
-
-public static partial class Refusals
-{
-    /// <summary>The refusals C22 declares, by their shape.refused-kind value; any other value is the harness's mistake, never a pass.</summary>
-    public static readonly IReadOnlyDictionary<string, Refusal> Table = new Refusal[]
-    {
-        new("unsealed-record-class (CMTK1006)", "CMTK1006", "unsealed-record-class", "value-objects", []),
-        new("over-value-object (CMTK1005)", "CMTK1005", "over-value-object", "value-objects", []),
-        new("generic-wrapped (CMTK1005)", "CMTK1005", "generic-wrapped", "value-objects", []),
-        // The label keeps the id it had when C09's and C11's rows were generated; an abstract value object is CMTK1022 since 1ef30be.
-        new("abstract (CMTK1005)", "CMTK1022", "abstract", "value-objects", []),
-        new("over-object (CMTK1005)", "CMTK1005", "over-object", "value-objects", []),
-        new("over-System.Enum (CMTK1005)", "CMTK1005", "over-system-enum", "value-objects", []),
-        new("named-as-generated-member (CMTK1005)", "CMTK1005", "named-as-generated-member", "value-objects", []),
-        new("closed-set-named-as-generated-member (CMTK1021)", "CMTK1021", "closed-set-named-as-generated-member", "closed-sets", ["CS0535"]),
-        new("equality-operator (CMTK1011)", "CMTK1011", "equality-operator", "operators", ["CS0111"]),
-    }.ToDictionary(r => r.Kind);
-
-    /// <summary>
-    /// The value-object names CMTK1005 refuses (the README's list), and the closed-set names CMTK1021 refuses; a row takes one by its
-    /// index. C17's and C19's probes name their named-as-generated-member declaration from the same list.
-    /// </summary>
-    public static readonly string[] ValueObjectNames = ["Value", "From", "TryFrom", "FromKnownGood", "Revalidate", "Parse", "TryParse", "TryFormat", "MinValue", "MaxValue", "CompareTo"];
-    static readonly string[] ClosedSetNames = ["Name", "QualifiedName", "All", "Match", "Parse", "TryParse"];
-
-    /// <summary>The link every generator error ends with (Generators README, Build errors: "Every error ends with a link to this table").</summary>
-    public const string TableLink = "https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.Generators/README.md#build-errors";
-
-    static readonly string[] Structs = ["record-struct", "validated-struct"];
-
-    /// <summary>
-    /// The row's declarations. Reads shape.refused-kind, shape.kind, shape.site, shape.inheritance and build-host, and shape.wrapped where
-    /// the refused kind wraps it. A refused kind the table does not hold, a combination the claim excludes, and a refusal the README's
-    /// Build errors table no longer lists are harness errors: the row would show nothing about a refusal the README states.
-    /// </summary>
-    public static RefusedDeclaration Declare(Probes.Shapes.Row r)
-    {
-        if (r["build-host"] != "sdk-build") throw new InvalidOperationException("build-host " + r["build-host"] + " has no build here");
-        var kindValue = r["shape.refused-kind"];
-        if (!Table.TryGetValue(kindValue, out var refusal)) throw new InvalidOperationException($"shape.refused-kind '{kindValue}' is no refusal this harness declares");
-        if (!ReadmeLists(refusal.Id)) throw new InvalidOperationException($"the Generators README's Build errors table has no row for {refusal.Id}");
-        var kind = r["shape.kind"]; var site = r["shape.site"]; var inheritance = r["shape.inheritance"];
-        var n = r.Index; var id = n.ToString();
-        var closedSet = kind == "closed-set";
-        if (closedSet != (refusal.Group == "closed-sets")) throw new InvalidOperationException($"{kindValue} cannot be declared as a {kind} (excluded in claims.json)");
-        if (Structs.Contains(kind) && refusal.Obligation is "unsealed-record-class" or "abstract") throw new InvalidOperationException($"a {kind} cannot be {refusal.Obligation} (excluded in claims.json)");
-        if ((Structs.Contains(kind) || closedSet) && inheritance is not ("none" or "explicit-interface-member")) throw new InvalidOperationException($"a {kind} has no base record for {inheritance} (excluded in claims.json)");
-        if (site == "in-generic-type") throw new InvalidOperationException("in-generic-type is a refusal of its own (excluded in claims.json)");
-
-        var name = refusal.Obligation switch
-        {
-            "named-as-generated-member" => ValueObjectNames[n % ValueObjectNames.Length],
-            "closed-set-named-as-generated-member" => ClosedSetNames[n % ClosedSetNames.Length],
-            _ => $"V{id}",
-        };
-        var control = closedSet ? $"S{id}" : $"K{id}";
-        var body = new System.Text.StringBuilder();
-        body.AppendLine($"public enum VF{id} {{ No }}");
-        var explicitMember = inheritance == "explicit-interface-member";
-        if (explicitMember) body.AppendLine($"public interface IMark{id} {{ int Mark(); }}");
-
-        // The bases, from the topmost down: plain abstract records, the direct one with an explicit IEquatable of its own or an explicit
-        // member of another interface where shape.inheritance says so. A struct or a closed set implements that interface itself.
-        var depth = inheritance switch { "base-depth-2" => 2, "base-depth-3" => 3, "none" => 0, _ => 1 };
-        if (closedSet || Structs.Contains(kind)) depth = 0;
-        for (var d = depth; d >= 1; d--)
-        {
-            var b = $"B{id}_{d}";
-            var parents = new List<string>();
-            if (d < depth) parents.Add($"B{id}_{d + 1}");
-            var members = "";
-            if (d == 1 && inheritance == "base-explicit-IEquatable") { parents.Add($"IEquatable<{b}>"); members = $"bool IEquatable<{b}>.Equals({b}? other) => ReferenceEquals(this, other);"; }
-            if (d == 1 && explicitMember) { parents.Add($"IMark{id}"); members = $"int IMark{id}.Mark() => 0;"; }
-            body.AppendLine($"public abstract record {b}{(parents.Count > 0 ? " : " + string.Join(", ", parents) : "")} {{ {members} }}");
-        }
-        var baseList = depth > 0 ? $"B{id}_1, " : "";
-        var ownMark = explicitMember && depth == 0;
-        var markList = ownMark ? $", IMark{id}" : "";
-        var markMember = ownMark ? $" int IMark{id}.Mark() => 0;" : "";
-
-        if (closedSet)
-        {
-            body.AppendLine($"public sealed partial class {name} : IClosedSet<{name}>{markList} {{ public static readonly {name} A{id} = new();{markMember} }}");
-            body.AppendLine($"public sealed partial class {control} : IClosedSet<{control}>{markList} {{ public static readonly {control} A{id} = new();{markMember} }}");
-        }
-        else
-        {
-            var w = refusal.Obligation is "over-object" or "over-system-enum" ? null : Src.Wrapped(r["shape.wrapped"], id);
-            var wrapped = refusal.Obligation switch
-            {
-                "over-value-object" => $"I{id}",
-                "generic-wrapped" => $"List<{w}>",
-                "over-object" => "object",
-                "over-system-enum" => "System.Enum",
-                _ => w!,
-            };
-            if (refusal.Obligation == "over-value-object") body.AppendLine($"public readonly partial record struct I{id} : IValue<{w}>;");
-            var modifier = refusal.Obligation switch { "unsealed-record-class" => "", "abstract" => "abstract ", _ => "sealed " };
-            var operators = refusal.Obligation == "equality-operator";
-            body.AppendLine(ValueObject(kind, name, modifier, baseList, wrapped, id, markList, markMember, operators));
-            body.AppendLine(ValueObject(kind, control, "sealed ", baseList, w ?? "int", id, markList, markMember, operators: false));
-        }
-
-        var source = Src.Usings + $"namespace C22R{id};\n" + Src.WrappedDeclarations(id) + Src.AtSite(site, id, body.ToString()) + "\n";
-        return new(n, refusal, name, Nesting(site, id) + name, control, $"R{id}.cs", source);
-    }
-
-    static string ValueObject(string kind, string name, string modifier, string baseList, string wrapped, string id, string markList, string markMember, bool operators)
-    {
-        var validated = kind.StartsWith("validated", StringComparison.Ordinal);
-        var marker = validated ? $"IValidatedValue<{name}, {wrapped}, VF{id}>" : $"IValue<{wrapped}>";
-        var head = Structs.Contains(kind)
-            ? $"public readonly partial record struct {name} : {marker}{markList}"
-            : $"public {modifier}partial record {name} : {baseList}{marker}{markList}";
-        var members = new List<string>();
-        if (validated) members.Add($"public static Result<{name}, VF{id}> Create({wrapped} value) => Result.Error(VF{id}.No);");
-        if (operators)
-        {
-            var t = Structs.Contains(kind) ? name : name + "?";
-            members.Add($"public static bool operator ==({t} left, {t} right) => true;");
-            members.Add($"public static bool operator !=({t} left, {t} right) => false;");
-        }
-        if (markMember.Length > 0) members.Add(markMember.Trim());
-        return members.Count == 0 ? head + ";" : $"{head}\n{{\n    {string.Join("\n    ", members)}\n}}";
-    }
-
-    /// <summary>shape.site's nesting as a diagnostic names a type: its containing types, dotted.</summary>
-    static string Nesting(string site, string id) => site switch
-    {
-        "top-level" => "", "nested-in-class" or "nested-in-struct" => $"O{id}.", "nested-two-levels" => $"O{id}.P{id}.",
-        _ => throw new ArgumentException("shape.site " + site),
-    };
-
-    static readonly Lazy<string> Readme = new(() => File.ReadAllText(Path.Combine(Consumer.RepositoryRoot(), "src", "CodoMetis.TypeKit.Generators", "README.md")));
-
-    /// <summary>Whether the README's Build errors table has a row for <paramref name="id"/>.</summary>
-    public static bool ReadmeLists(string id) =>
-        Readme.Value.IndexOf("\n## Build errors", StringComparison.Ordinal) is var at and >= 0
-        && Readme.Value.IndexOf($"\n| {id} |", at, StringComparison.Ordinal) >= 0;
-
-    /// <summary>Whether the README still has the heading the table link points at.</summary>
-    public static bool ReadmeHasBuildErrorsHeading() => Readme.Value.Split('\n').Any(l => l.TrimEnd('\r') == "## Build errors");
-
-    /// <summary>
-    /// How the generators left a type in Metalama's transformed source: <c>null</c> where its declaration is as it was written (no base
-    /// type and no member added, and no <c>{Name}Extensions</c> companion), else what they added. Throws where the type is not there.
-    /// </summary>
-    public static string? Added(RefusalOutcome build, RefusedDeclaration d, string name)
-    {
-        if (!build.Transformed.TryGetValue(d.File, out var transformed)) throw new InvalidOperationException($"Metalama wrote no transformed {d.File}");
-        var written = One(CSharpSyntaxTree.ParseText(d.Source).GetRoot(), name, "the row's source");
-        var woven = One(CSharpSyntaxTree.ParseText(transformed).GetRoot(), name, "the transformed " + d.File);
-        var added = new List<string>();
-        var bw = written.BaseList?.Types.Count ?? 0; var bt = woven.BaseList?.Types.Count ?? 0;
-        if (bt != bw) added.Add($"{bt - bw} base type(s)");
-        if (woven.Members.Count != written.Members.Count) added.Add($"{woven.Members.Count - written.Members.Count} member(s)");
-        var companion = name + "Extensions";
-        foreach (var (file, text) in build.Transformed)
-            if (text.Contains($"namespace C22R{d.Index}", StringComparison.Ordinal) && text.Contains(companion, StringComparison.Ordinal)
-                && CSharpSyntaxTree.ParseText(text).GetRoot().DescendantNodes().OfType<ClassDeclarationSyntax>().Any(c => c.Identifier.Text == companion))
-                added.Add($"the companion {companion} ({file})");
-        return added.Count == 0 ? null : string.Join(", ", added);
-    }
-
-    static TypeDeclarationSyntax One(Microsoft.CodeAnalysis.SyntaxNode root, string name, string where)
-    {
-        var found = root.DescendantNodes().OfType<TypeDeclarationSyntax>().Where(t => t.Identifier.Text == name).ToList();
-        return found.Count == 1 ? found[0] : throw new InvalidOperationException($"{found.Count} declarations of {name} in {where}");
-    }
-
-    static readonly Dictionary<string, Lazy<Task<RefusalOutcome>>> Builds = new();
-
-    /// <summary>Builds the consumer of <paramref name="files"/> once per <paramref name="key"/> in this process.</summary>
-    public static Task<RefusalOutcome> Build(string key, Func<IReadOnlyDictionary<string, string>> files)
-    {
-        lock (Builds)
-        {
-            if (!Builds.TryGetValue(key, out var build)) Builds[key] = build = new(() => Run(files()));
-            return build.Value;
-        }
-    }
-
-    static string Configuration => typeof(Refusals).Assembly.GetCustomAttribute<AssemblyConfigurationAttribute>()?.Configuration
-                                   ?? throw new InvalidOperationException("the probe assembly carries no AssemblyConfigurationAttribute");
-
-    static async Task<RefusalOutcome> Run(IReadOnlyDictionary<string, string> files)
-    {
-        var root = Consumer.RepositoryRoot();
-        var dir = Path.Combine(root, "artifacts", $"probe-refusals-{Guid.NewGuid():N}");
-        Directory.CreateDirectory(dir);
-        try
-        {
-            var src = Path.Combine(root, "src");
-            await File.WriteAllTextAsync(Path.Combine(dir, "Consumer.csproj"), $"""
-                <Project Sdk="Microsoft.NET.Sdk">
-                  <PropertyGroup>
-                    <TargetFramework>net10.0</TargetFramework>
-                    <Nullable>enable</Nullable>
-                    <ImplicitUsings>disable</ImplicitUsings>
-                    <AssemblyName>ProbeRefusals</AssemblyName>
-                    <MetalamaEmitCompilerTransformedFiles>true</MetalamaEmitCompilerTransformedFiles>
-                  </PropertyGroup>
-                  <ItemGroup>
-                    <ProjectReference Include="{src}/CodoMetis.TypeKit.Generators/CodoMetis.TypeKit.Generators.csproj" />
-                    <Reference Include="NodaTime"><HintPath>{typeof(NodaTime.Instant).Assembly.Location}</HintPath></Reference>
-                  </ItemGroup>
-                </Project>
-                """);
-            await File.WriteAllTextAsync(Path.Combine(dir, "Directory.Build.props"), "<Project />");
-            await File.WriteAllTextAsync(Path.Combine(dir, "Directory.Build.targets"), "<Project />");
-            await File.WriteAllTextAsync(Path.Combine(dir, "Directory.Packages.props"),
-                "<Project><PropertyGroup><ManagePackageVersionsCentrally>false</ManagePackageVersionsCentrally></PropertyGroup></Project>");
-            foreach (var (name, text) in files) await File.WriteAllTextAsync(Path.Combine(dir, name), text);
-
-            var dotnet = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH") is { Length: > 0 } host ? host : "dotnet";
-            var info = new ProcessStartInfo(dotnet, ["build", dir, "-c", Configuration, "--no-dependencies", "-p:RestoreRecursive=false", "-nodeReuse:false", "-clp:NoSummary", "-v:q", "-nologo"])
-            {
-                RedirectStandardOutput = true, RedirectStandardError = true, WorkingDirectory = dir,
-            };
-            // The run's code coverage instruments this process through its environment; the build is not the probe's code.
-            foreach (var k in info.Environment.Keys.ToList())
-                if (k.StartsWith("CORECLR_", StringComparison.OrdinalIgnoreCase) || k.StartsWith("COR_", StringComparison.OrdinalIgnoreCase)
-                    || k.Contains("CODECOVERAGE", StringComparison.OrdinalIgnoreCase) || k.StartsWith("MicrosoftInstrumentationEngine", StringComparison.OrdinalIgnoreCase)
-                    || k.Equals("DOTNET_STARTUP_HOOKS", StringComparison.OrdinalIgnoreCase))
-                    info.Environment.Remove(k);
-            info.Environment["DOTNET_CLI_UI_LANGUAGE"] = "en";
-            using var process = Process.Start(info)!;
-            var stdout = process.StandardOutput.ReadToEndAsync();
-            var stderr = process.StandardError.ReadToEndAsync();
-            using (var timeout = new CancellationTokenSource(TimeSpan.FromMinutes(10))) await process.WaitForExitAsync(timeout.Token);
-            var output = await stdout + await stderr;
-            var diagnostics = Line().Matches(output)
-                .Select(m => new BuildDiagnostic(m.Groups["file"].Value.Trim(), m.Groups["sev"].Value, m.Groups["id"].Value, m.Groups["msg"].Value.Trim()))
-                .Distinct().ToList();
-            var woven = Path.Combine(dir, "obj", Configuration, "net10.0", "metalama");
-            var transformed = Directory.Exists(woven)
-                ? Directory.GetFiles(woven, "*.cs").ToDictionary(f => Path.GetFileName(f), f => File.ReadAllText(f))
-                : new Dictionary<string, string>();
-            return new RefusalOutcome(process.ExitCode, output, diagnostics, transformed);
-        }
-        finally
-        {
-            try { Directory.Delete(dir, recursive: true); } catch (IOException) { } catch (UnauthorizedAccessException) { }
-        }
-    }
-
-    [GeneratedRegex(@"^(?<file>[^\r\n(]+)\((?<line>\d+),(?<col>\d+)\): (?<sev>warning|error) (?<id>[A-Z]+\d+): (?<msg>.*?)(?: \[[^\]\r\n]*\])?\r?$", RegexOptions.Multiline)]
-    private static partial Regex Line();
-}
diff --git a/tools/probe/corpus/harness/BuildRoslyn.cs b/tools/probe/corpus/harness/BuildRoslyn.cs
deleted file mode 100644
index 2f3584d1..00000000
--- a/tools/probe/corpus/harness/BuildRoslyn.cs
+++ /dev/null
@@ -1,167 +0,0 @@
-// The analyzer probes' compiler (C17 CMTK0014, C19 CMTK0010): a CSharpCompilation over the real CodoMetis.TypeKit and the
-// running framework, with the CMTK analyzer that reports the claim's id attached, as test/CodoMetis.TypeKit.Analyzers.Tests
-// runs it. Sources carry markup {|#label:...|}; a marked span is where the probe expects (or forbids) a report.
-using System.Collections.Immutable;
-using System.Reflection;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Text;
-namespace Probes.Build;
-
-/// <summary>One marked span of a source file, by its label.</summary>
-public sealed record Mark(string Label, string File, TextSpan Span, string Text);
-
-/// <summary>A source file whose markup was taken out, with the spans it marked.</summary>
-public sealed record Marked(string File, string Text, IReadOnlyList<Mark> Marks)
-{
-    /// <summary>Strips <c>{|#label:…|}</c> (not nested) and records each span in the stripped text.</summary>
-    public static Marked Parse(string file, string source)
-    {
-        var sb = new System.Text.StringBuilder(); var marks = new List<Mark>(); var i = 0;
-        while (i < source.Length)
-        {
-            var open = source.IndexOf("{|#", i, StringComparison.Ordinal);
-            if (open < 0) { sb.Append(source, i, source.Length - i); break; }
-            sb.Append(source, i, open - i);
-            var colon = source.IndexOf(':', open);
-            var label = source[(open + 3)..colon];
-            var close = source.IndexOf("|}", colon, StringComparison.Ordinal);
-            if (close < 0) throw new InvalidOperationException($"unclosed markup {label} in {file}");
-            var inner = source[(colon + 1)..close];
-            if (inner.Contains("{|", StringComparison.Ordinal)) throw new InvalidOperationException($"nested markup in {label} of {file}");
-            marks.Add(new Mark(label, file, new TextSpan(sb.Length, inner.Length), inner));
-            sb.Append(inner);
-            i = close + 2;
-        }
-        return new Marked(file, sb.ToString(), marks);
-    }
-}
-
-/// <summary>What one compilation reported: compiler errors, the analyzer's diagnostics, analyzer failures.</summary>
-public sealed record Analysis(IReadOnlyList<Diagnostic> Errors, IReadOnlyList<Diagnostic> Reported, IReadOnlyList<Diagnostic> AnalyzerFailures, IReadOnlyList<Marked> Files)
-{
-    public IEnumerable<Mark> Marks => Files.SelectMany(f => f.Marks);
-    public static string Where(Diagnostic d) => $"{d.Location.SourceTree?.FilePath}:{d.Location.SourceSpan} '{d.Location.SourceTree?.GetText().ToString(d.Location.SourceSpan)}'";
-    public string ErrorText() => string.Join("; ", Errors.Take(5).Select(e => $"{e.Id} {Where(e)}: {e.GetMessage()}"));
-}
-
-public static class Rz
-{
-    static readonly Lazy<ImmutableArray<MetadataReference>> Refs = new(() =>
-    {
-        // The running shared framework (implementation assemblies, as the probe's own process binds), plus the real base package and NodaTime.
-        var framework = Path.GetDirectoryName(typeof(object).Assembly.Location)!;
-        var tpa = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator)
-            .Where(p => Path.GetDirectoryName(p) == framework && Path.GetFileName(p) is var n && (n.StartsWith("System.") || n.StartsWith("Microsoft.") || n is "mscorlib.dll" or "netstandard.dll"));
-        return [.. tpa.Concat([typeof(CodoMetis.TypeKit.Option<>).Assembly.Location, typeof(NodaTime.Instant).Assembly.Location])
-                      .Distinct().Select(p => (MetadataReference)MetadataReference.CreateFromFile(p))];
-    });
-
-    /// <summary>The CMTK analyzers that report <paramref name="id"/>, found by the id they declare, never by type name.</summary>
-    public static ImmutableArray<DiagnosticAnalyzer> AnalyzersFor(string id) =>
-    [
-        .. typeof(CodoMetis.TypeKit.Analyzers.TypeArgumentConstraintAnalyzer).Assembly.GetTypes()
-            .Where(t => !t.IsAbstract && typeof(DiagnosticAnalyzer).IsAssignableFrom(t) && t.GetCustomAttribute<DiagnosticAnalyzerAttribute>() is not null)
-            .Select(t => (DiagnosticAnalyzer)Activator.CreateInstance(t)!)
-            .Where(a => a.SupportedDiagnostics.Any(d => d.Id == id)),
-    ];
-
-    public static async Task<Analysis> Analyze(string id, IEnumerable<(string File, string Source)> sources)
-    {
-        var files = sources.Select(s => Marked.Parse(s.File, s.Source)).ToList();
-        var parse = new CSharpParseOptions(LanguageVersion.Latest);
-        var trees = files.Select(f => CSharpSyntaxTree.ParseText(f.Text, parse, path: f.File)).ToList();
-        var compilation = CSharpCompilation.Create("ProbeBuild" + Guid.NewGuid().ToString("N"), trees, Refs.Value,
-            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, nullableContextOptions: NullableContextOptions.Enable));
-        var analyzers = AnalyzersFor(id);
-        if (analyzers.Length == 0) throw new InvalidOperationException($"no CMTK analyzer declares {id}");
-        var failures = new List<Diagnostic>();
-        var options = new CompilationWithAnalyzersOptions(new AnalyzerOptions([]), (ex, analyzer, diagnostic) => { lock (failures) failures.Add(diagnostic); },
-            concurrentAnalysis: false, logAnalyzerExecutionTime: false);
-        var with = compilation.WithAnalyzers(analyzers, options);
-        var analyzerDiagnostics = await with.GetAnalyzerDiagnosticsAsync(CancellationToken.None);
-        var errors = compilation.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error).ToList();
-        failures.AddRange(analyzerDiagnostics.Where(d => d.Id == "AD0001"));
-        return new Analysis(errors, [.. analyzerDiagnostics.Where(d => d.Id == id)], failures, files);
-    }
-
-    /// <summary>
-    /// Compares the reports with the marks: every mark in <paramref name="expected"/> reported exactly once at its span, nothing
-    /// reported anywhere else. Null when they agree, else what differs.
-    /// </summary>
-    public static string? Agree(Analysis a, IReadOnlySet<string> expected, Func<Diagnostic, Mark, string?>? message = null) =>
-        Agree(a, expected, _ => true, outside: true, message);
-
-    /// <summary>
-    /// The same over the marks <paramref name="judged"/> selects, one check's share of a compilation: each of them in
-    /// <paramref name="expected"/> reported exactly once at its span, the others silent, and with <paramref name="outside"/>, nothing
-    /// reported outside every mark. A report at a mark the check does not judge is another check's.
-    /// </summary>
-    public static string? Agree(Analysis a, IReadOnlySet<string> expected, Func<Mark, bool> judged, bool outside, Func<Diagnostic, Mark, string?>? message = null)
-    {
-        var marks = a.Marks.ToList();
-        foreach (var label in expected) if (!marks.Any(m => m.Label == label)) throw new InvalidOperationException($"no mark {label}");
-        var problems = new List<string>();
-        foreach (var m in marks.Where(judged))
-        {
-            var at = At(a, m);
-            if (expected.Contains(m.Label))
-            {
-                if (at.Count != 1) problems.Add($"{m.Label} '{m.Text}': reported {at.Count} times, expected once");
-                else if (message?.Invoke(at[0], m) is { } bad) problems.Add($"{m.Label} '{m.Text}': {bad}");
-            }
-            else if (at.Count != 0) problems.Add($"{m.Label} '{m.Text}': reported, expected silent ({at[0].GetMessage()})");
-        }
-        if (outside) problems.AddRange(Outside(a).Select(d => $"reported outside every mark at {Analysis.Where(d)}: {d.GetMessage()}"));
-        return problems.Count == 0 ? null : string.Join("; ", problems);
-    }
-
-    /// <summary>The reports exactly at a mark's span.</summary>
-    public static List<Diagnostic> At(Analysis a, Mark m) =>
-        [.. a.Reported.Where(d => d.Location.SourceTree?.FilePath == m.File && d.Location.SourceSpan == m.Span)];
-
-    /// <summary>The reports whose span holds a mark's: at it, or at the syntax around it.</summary>
-    public static List<Diagnostic> Around(Analysis a, Mark m) =>
-        [.. a.Reported.Where(d => d.Location.SourceTree?.FilePath == m.File && d.Location.SourceSpan.Contains(m.Span))];
-
-    /// <summary>The reports whose span holds no mark.</summary>
-    public static List<Diagnostic> Outside(Analysis a) =>
-        [.. a.Reported.Where(d => !a.Marks.Any(m => d.Location.SourceTree?.FilePath == m.File && d.Location.SourceSpan.Contains(m.Span)))];
-
-    /// <summary>
-    /// Whether a value is reported, wherever around it: each mark <paramref name="judged"/> names that is in <paramref name="expected"/>
-    /// has exactly one report at or around it, the others none. Where the report sits is <see cref="WhereWritten"/>'s question, so a
-    /// report moved to the syntax around its value still counts here. Null when they agree, else what differs.
-    /// </summary>
-    public static string? Reported(Analysis a, IEnumerable<string> judged, IReadOnlySet<string> expected, Func<Diagnostic, Mark, string?>? message = null)
-    {
-        var problems = new List<string>();
-        foreach (var label in judged)
-        {
-            var m = a.Marks.SingleOrDefault(x => x.Label == label) ?? throw new InvalidOperationException($"no mark {label}");
-            var around = Around(a, m);
-            if (expected.Contains(label))
-            {
-                if (around.Count != 1) problems.Add($"{m.Label} '{m.Text}': reported {around.Count} times, expected once");
-                else if (message?.Invoke(around[0], m) is { } bad) problems.Add($"{m.Label} '{m.Text}': {bad}");
-            }
-            else if (around.Count != 0) problems.Add($"{m.Label} '{m.Text}': reported, expected silent ({around[0].GetMessage()})");
-        }
-        return problems.Count == 0 ? null : string.Join("; ", problems);
-    }
-
-    /// <summary>
-    /// Where the reports sit: every report at or around a mark in <paramref name="expected"/> is at the mark's own span, the value as
-    /// written, and none is outside every mark. Null when so, else what differs.
-    /// </summary>
-    public static string? WhereWritten(Analysis a, IReadOnlySet<string> expected)
-    {
-        var problems = new List<string>();
-        foreach (var m in a.Marks.Where(m => expected.Contains(m.Label)))
-            foreach (var d in Around(a, m).Where(d => d.Location.SourceSpan != m.Span))
-                problems.Add($"{m.Label} '{m.Text}': reported at {Analysis.Where(d)}, not at the value");
-        problems.AddRange(Outside(a).Select(d => $"reported outside every mark at {Analysis.Where(d)}: {d.GetMessage()}"));
-        return problems.Count == 0 ? null : string.Join("; ", problems);
-    }
-}
diff --git a/tools/probe/corpus/harness/BuildSource.cs b/tools/probe/corpus/harness/BuildSource.cs
deleted file mode 100644
index bc37edfc..00000000
--- a/tools/probe/corpus/harness/BuildSource.cs
+++ /dev/null
@@ -1,58 +0,0 @@
-// Source text for the build family's probes (C17, C18, C19): a row's shape.* axes written as C#, for a compilation the probe
-// makes itself (an analyzer run, or the consumer build of C18). Each piece names its types after a suffix, so the pieces of
-// several rows can sit in one compilation.
-namespace Probes.Build;
-
-public static class Src
-{
-    public const string Usings =
-        """
-        #nullable enable
-        using System;
-        using System.Collections.Generic;
-        using System.Collections.Immutable;
-        using System.Threading.Tasks;
-        using CodoMetis.TypeKit;
-        using CodoMetis.TypeKit.ClosedSets;
-        using CodoMetis.TypeKit.ValueObjects;
-
-        """;
-
-    /// <summary>shape.site: <paramref name="inner"/> declared at the top level, nested in a class or a struct, two levels down, or in a generic type.</summary>
-    public static string AtSite(string site, string id, string inner) => site switch
-    {
-        "top-level" => inner,
-        "nested-in-class" => $"public static partial class O{id}\n{{\n{inner}\n}}",
-        "nested-in-struct" => $"public partial struct O{id}\n{{\n{inner}\n}}",
-        "nested-two-levels" => $"public static partial class O{id}\n{{\npublic sealed partial class P{id}\n{{\n{inner}\n}}\n}}",
-        "in-generic-type" => $"public static partial class O{id}<TO>\n{{\n{inner}\n}}",
-        _ => throw new ArgumentException("shape.site " + site),
-    };
-
-    /// <summary>shape.wrapped as a type name; enum, flags-enum and own-record-class are declared by <see cref="WrappedDeclarations"/>.</summary>
-    public static string Wrapped(string wrapped, string id) => wrapped switch
-    {
-        "string" or "int" or "long" or "byte" or "ulong" or "decimal" or "double" or "bool" or "char" => wrapped,
-        "Guid" or "DateTime" or "DateTimeOffset" or "DateOnly" or "TimeOnly" or "TimeSpan" or "Uri" => "System." + wrapped,
-        "enum" => $"WEnum{id}", "flags-enum" => $"WFlags{id}", "NodaTime.Instant" => "global::NodaTime.Instant", "own-record-class" => $"WRec{id}",
-        _ => throw new ArgumentException("shape.wrapped " + wrapped),
-    };
-
-    public static string WrappedDeclarations(string id) =>
-        $"public enum WEnum{id} {{ A, B }}\n[Flags] public enum WFlags{id} {{ None = 0, P = 1, Q = 2 }}\npublic sealed record WRec{id} {{ public int N {{ get; init; }} }}\n";
-
-    public static bool IsStructKind(string kind) => kind is "record-struct" or "validated-struct";
-
-    /// <summary>The type head of shape.containing, and the type as written from inside it (generic-type is closed over int outside).</summary>
-    public static string ContainerHead(string containing, string name, string primary = "") => containing switch
-    {
-        "class" => $"public sealed partial class {name}{primary}",
-        "record-class" => $"public sealed partial record {name}{primary}",
-        "struct" => $"public partial struct {name}{primary}",
-        "record-struct" => $"public partial record struct {name}{primary}",
-        "generic-type" => $"public sealed partial class {name}<TC>{primary}",
-        _ => throw new ArgumentException("shape.containing " + containing),
-    };
-
-    public static string ContainerSelf(string containing, string name) => containing == "generic-type" ? $"{name}<TC>" : name;
-}
diff --git a/tools/probe/corpus/harness/C09Shapes.g.cs b/tools/probe/corpus/harness/C09Shapes.g.cs
deleted file mode 100644
index 2a365946..00000000
--- a/tools/probe/corpus/harness/C09Shapes.g.cs
+++ /dev/null
@@ -1,1031 +0,0 @@
-// <auto-generated/> by tools/probe/generators/decls.cs from rows/C09BaseRecordEqualityProbe.json.gz: one value object per row. Do not edit; regenerate with the rows.
-#nullable enable
-// CMTK1023: the bases' own equality is the point (C09) or beside it (C11); CS8851: a base's Equals without GetHashCode, on purpose.
-#pragma warning disable CMTK1023, CS8851, CS1591
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.ValueObjects;
-namespace Probes.Build.C09;
-
-// row 0
-public static partial class O0
-{
-public sealed partial class P0
-{
-public abstract record B0_1 : System.IEquatable<B0_1> { bool System.IEquatable<B0_1>.Equals(B0_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V0 : B0_1, IValidatedValue<V0, global::Probes.Shapes.PRec, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V0, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PRec value) => new V0(value);
-}
-}
-}
-
-// row 1
-public static partial class O1
-{
-public sealed partial class P1
-{
-public abstract record B1_3 { public virtual bool Equals(B1_3? other) => ReferenceEquals(this, other); }
-public abstract record B1_2 : B1_3 {  }
-public abstract record B1_1 : B1_2 {  }
-public sealed partial record V1 : B1_1, IValue<global::System.DateTimeOffset>;
-}
-}
-
-// row 2
-public partial struct O2
-{
-public abstract record B2_1 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); }
-public sealed partial record V2 : B2_1, IValidatedValue<V2, long, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V2, global::Probes.Shapes.ShapeFault> Create(long value) => new V2(value);
-}
-}
-
-// row 3
-public abstract record B3_1 {  }
-public sealed partial record V3 : B3_1, IValue<global::System.DateOnly>;
-
-// row 4
-public interface IMark4 { int Mark(); }
-public abstract record B4_1 : IMark4 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); int IMark4.Mark() => 1; }
-public sealed partial record V4 : B4_1, IValidatedValue<V4, string, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V4, global::Probes.Shapes.ShapeFault> Create(string value) => new V4(value);
-}
-
-// row 5
-public static partial class O5
-{
-public interface IMark5 { int Mark(); }
-public abstract record B5_1 : System.IEquatable<B5_1>, IMark5 { bool System.IEquatable<B5_1>.Equals(B5_1? other) => ReferenceEquals(this, other); int IMark5.Mark() => 1; }
-public sealed partial record V5 : B5_1, IValue<global::System.Uri>;
-}
-
-// row 6
-public static partial class O6
-{
-public abstract record B6_2 {  }
-public abstract record B6_1 : B6_2 {  }
-public sealed partial record V6 : B6_1, IValidatedValue<V6, global::Probes.Shapes.PFlags, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V6, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PFlags value) => new V6(value);
-}
-}
-
-// row 7
-public partial struct O7
-{
-public abstract record B7_2 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); }
-public abstract record B7_1 : B7_2 {  }
-public sealed partial record V7 : B7_1, IValue<global::System.TimeSpan>;
-}
-
-// row 8
-public partial struct O8
-{
-public abstract record B8_1 : System.IEquatable<B8_1> { bool System.IEquatable<B8_1>.Equals(B8_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V8 : B8_1, IValue<global::System.TimeOnly>;
-}
-
-// row 9
-public static partial class O9
-{
-public sealed partial class P9
-{
-public interface IMark9 { int Mark(); }
-public abstract record B9_1 : IMark9 { int IMark9.Mark() => 1; }
-public sealed partial record V9 : B9_1, IValue<byte>;
-}
-}
-
-// row 10
-public abstract record B10_2 { public virtual bool Equals(B10_2? other) => ReferenceEquals(this, other); }
-public abstract record B10_1 : B10_2 {  }
-public sealed partial record V10 : B10_1, IValidatedValue<V10, global::System.DateOnly, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V10, global::Probes.Shapes.ShapeFault> Create(global::System.DateOnly value) => new V10(value);
-}
-
-// row 11
-public static partial class O11
-{
-public abstract record B11_1 { public virtual bool Equals(B11_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V11 : B11_1, IValidatedValue<V11, global::System.Guid, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V11, global::Probes.Shapes.ShapeFault> Create(global::System.Guid value) => new V11(value);
-}
-}
-
-// row 12
-public partial struct O12
-{
-public abstract record B12_2 : System.IEquatable<B12_2> { bool System.IEquatable<B12_2>.Equals(B12_2? other) => ReferenceEquals(this, other); }
-public abstract record B12_1 : B12_2 {  }
-public sealed partial record V12 : B12_1, IValidatedValue<V12, ulong, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V12, global::Probes.Shapes.ShapeFault> Create(ulong value) => new V12(value);
-}
-}
-
-// row 13
-public partial struct O13
-{
-public abstract record B13_3 { public virtual bool Equals(B13_3? other) => ReferenceEquals(this, other); }
-public abstract record B13_2 : B13_3 {  }
-public abstract record B13_1 : B13_2 {  }
-public sealed partial record V13 : B13_1, IValidatedValue<V13, decimal, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V13, global::Probes.Shapes.ShapeFault> Create(decimal value) => new V13(value);
-}
-}
-
-// row 14
-public static partial class O14
-{
-public abstract record B14_3 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); }
-public abstract record B14_2 : B14_3 {  }
-public abstract record B14_1 : B14_2 {  }
-public sealed partial record V14 : B14_1, IValue<int>;
-}
-
-// row 15
-public partial struct O15
-{
-public interface IMark15 { int Mark(); }
-public abstract record B15_1 : IMark15 { public virtual bool Equals(B15_1? other) => ReferenceEquals(this, other); int IMark15.Mark() => 1; }
-public sealed partial record V15 : B15_1, IValidatedValue<V15, global::NodaTime.Instant, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V15, global::Probes.Shapes.ShapeFault> Create(global::NodaTime.Instant value) => new V15(value);
-}
-}
-
-// row 16
-public abstract record B16_3 : System.IEquatable<B16_3> { bool System.IEquatable<B16_3>.Equals(B16_3? other) => ReferenceEquals(this, other); }
-public abstract record B16_2 : B16_3 {  }
-public abstract record B16_1 : B16_2 {  }
-public sealed partial record V16 : B16_1, IValue<double>;
-
-// row 17
-public static partial class O17
-{
-public abstract record B17_1 : System.IEquatable<B17_1> { public virtual bool Equals(B17_1? other) => ReferenceEquals(this, other); bool System.IEquatable<B17_1>.Equals(B17_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V17 : B17_1, IValue<global::System.TimeSpan>;
-}
-
-// row 18
-public static partial class O18
-{
-public sealed partial class P18
-{
-public abstract record B18_1 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); }
-public sealed partial record V18 : B18_1, IValue<global::Probes.Shapes.PFlags>;
-}
-}
-
-// row 19
-public abstract record B19_1 : System.IEquatable<B19_1> { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); bool System.IEquatable<B19_1>.Equals(B19_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V19 : B19_1, IValidatedValue<V19, char, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V19, global::Probes.Shapes.ShapeFault> Create(char value) => new V19(value);
-}
-
-// row 20
-public abstract record B20_3 {  }
-public abstract record B20_2 : B20_3 {  }
-public abstract record B20_1 : B20_2 {  }
-public sealed partial record V20 : B20_1, IValidatedValue<V20, global::System.DateTime, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V20, global::Probes.Shapes.ShapeFault> Create(global::System.DateTime value) => new V20(value);
-}
-
-// row 21
-public static partial class O21
-{
-public abstract record B21_2 : System.IEquatable<B21_2> { bool System.IEquatable<B21_2>.Equals(B21_2? other) => ReferenceEquals(this, other); }
-public abstract record B21_1 : B21_2 {  }
-public sealed partial record V21 : B21_1, IValue<global::System.DateTime>;
-}
-
-// row 22
-public static partial class O22
-{
-public sealed partial class P22
-{
-public abstract record B22_2 {  }
-public abstract record B22_1 : B22_2 {  }
-public sealed partial record V22 : B22_1, IValue<global::NodaTime.Instant>;
-}
-}
-
-// row 23
-public abstract record B23_1 : System.IEquatable<B23_1> { bool System.IEquatable<B23_1>.Equals(B23_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V23 : B23_1, IValidatedValue<V23, global::System.TimeOnly, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V23, global::Probes.Shapes.ShapeFault> Create(global::System.TimeOnly value) => new V23(value);
-}
-
-// row 24
-public static partial class O24
-{
-public sealed partial class P24
-{
-public abstract record B24_1 {  }
-public sealed partial record V24 : B24_1, IValidatedValue<V24, global::System.Uri, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V24, global::Probes.Shapes.ShapeFault> Create(global::System.Uri value) => new V24(value);
-}
-}
-}
-
-// row 25
-public static partial class O25
-{
-public abstract record B25_1 {  }
-public sealed partial record V25 : B25_1, IValidatedValue<V25, bool, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V25, global::Probes.Shapes.ShapeFault> Create(bool value) => new V25(value);
-}
-}
-
-// row 26
-public static partial class O26
-{
-public sealed partial class P26
-{
-public abstract record B26_3 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); }
-public abstract record B26_2 : B26_3 {  }
-public abstract record B26_1 : B26_2 {  }
-public sealed partial record V26 : B26_1, IValidatedValue<V26, global::Probes.Shapes.PEnum, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V26, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PEnum value) => new V26(value);
-}
-}
-}
-
-// row 27
-public abstract record B27_2 {  }
-public abstract record B27_1 : B27_2 {  }
-public sealed partial record V27 : B27_1, IValue<long>;
-
-// row 28
-public partial struct O28
-{
-public abstract record B28_1 {  }
-public sealed partial record V28 : B28_1, IValue<global::Probes.Shapes.PRec>;
-}
-
-// row 29
-public partial struct O29
-{
-public interface IMark29 { int Mark(); }
-public abstract record B29_1 : System.IEquatable<B29_1>, IMark29 { bool System.IEquatable<B29_1>.Equals(B29_1? other) => ReferenceEquals(this, other); int IMark29.Mark() => 1; }
-public sealed partial record V29 : B29_1, IValue<bool>;
-}
-
-// row 30
-public abstract record B30_2 : System.IEquatable<B30_2> { bool System.IEquatable<B30_2>.Equals(B30_2? other) => ReferenceEquals(this, other); }
-public abstract record B30_1 : B30_2 {  }
-public sealed partial record V30 : B30_1, IValue<int>;
-
-// row 31
-public static partial class O31
-{
-public sealed partial class P31
-{
-public abstract record B31_3 {  }
-public abstract record B31_2 : B31_3 {  }
-public abstract record B31_1 : B31_2 {  }
-public sealed partial record V31 : B31_1, IValue<ulong>;
-}
-}
-
-// row 32
-public partial struct O32
-{
-public abstract record B32_1 : System.IEquatable<B32_1> { bool System.IEquatable<B32_1>.Equals(B32_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V32 : B32_1, IValidatedValue<V32, double, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V32, global::Probes.Shapes.ShapeFault> Create(double value) => new V32(value);
-}
-}
-
-// row 33
-public static partial class O33
-{
-public sealed partial class P33
-{
-public abstract record B33_1 : System.IEquatable<B33_1> { public virtual bool Equals(B33_1? other) => ReferenceEquals(this, other); bool System.IEquatable<B33_1>.Equals(B33_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V33 : B33_1, IValue<string>;
-}
-}
-
-// row 34
-public partial struct O34
-{
-public abstract record B34_1 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); }
-public sealed partial record V34 : B34_1, IValidatedValue<V34, global::System.DateTimeOffset, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V34, global::Probes.Shapes.ShapeFault> Create(global::System.DateTimeOffset value) => new V34(value);
-}
-}
-
-// row 35
-public abstract record B35_3 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); }
-public abstract record B35_2 : B35_3 {  }
-public abstract record B35_1 : B35_2 {  }
-public sealed partial record V35 : B35_1, IValue<global::System.Guid>;
-
-// row 36
-public static partial class O36
-{
-public abstract record B36_3 {  }
-public abstract record B36_2 : B36_3 {  }
-public abstract record B36_1 : B36_2 {  }
-public sealed partial record V36 : B36_1, IValue<char>;
-}
-
-// row 37
-public static partial class O37
-{
-public abstract record B37_1 : System.IEquatable<B37_1> { bool System.IEquatable<B37_1>.Equals(B37_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V37 : B37_1, IValue<decimal>;
-}
-
-// row 38
-public partial struct O38
-{
-public abstract record B38_2 : System.IEquatable<B38_2> { bool System.IEquatable<B38_2>.Equals(B38_2? other) => ReferenceEquals(this, other); }
-public abstract record B38_1 : B38_2 {  }
-public sealed partial record V38 : B38_1, IValue<global::Probes.Shapes.PEnum>;
-}
-
-// row 39
-public abstract record B39_2 { public virtual bool Equals(B39_2? other) => ReferenceEquals(this, other); }
-public abstract record B39_1 : B39_2 {  }
-public sealed partial record V39 : B39_1, IValidatedValue<V39, byte, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V39, global::Probes.Shapes.ShapeFault> Create(byte value) => new V39(value);
-}
-
-// row 40
-public partial struct O40
-{
-public abstract record B40_3 { public virtual bool Equals(B40_3? other) => ReferenceEquals(this, other); }
-public abstract record B40_2 : B40_3 {  }
-public abstract record B40_1 : B40_2 {  }
-public sealed partial record V40 : B40_1, IValidatedValue<V40, global::Probes.Shapes.PFlags, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V40, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PFlags value) => new V40(value);
-}
-}
-
-// row 41
-public abstract record B41_3 {  }
-public abstract record B41_2 : B41_3 {  }
-public abstract record B41_1 : B41_2 {  }
-public sealed partial record V41 : B41_1, IValidatedValue<V41, global::System.TimeSpan, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V41, global::Probes.Shapes.ShapeFault> Create(global::System.TimeSpan value) => new V41(value);
-}
-
-// row 42
-public partial struct O42
-{
-public interface IMark42 { int Mark(); }
-public abstract record B42_1 : IMark42 { public virtual bool Equals(B42_1? other) => ReferenceEquals(this, other); int IMark42.Mark() => 1; }
-public sealed partial record V42 : B42_1, IValue<char>;
-}
-
-// row 43
-public partial struct O43
-{
-public abstract record B43_1 { public virtual bool Equals(B43_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V43 : B43_1, IValue<int>;
-}
-
-// row 44
-public partial struct O44
-{
-public abstract record B44_1 : System.IEquatable<B44_1> { public virtual bool Equals(B44_1? other) => ReferenceEquals(this, other); bool System.IEquatable<B44_1>.Equals(B44_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V44 : B44_1, IValue<global::System.Uri>;
-}
-
-// row 45
-public static partial class O45
-{
-public abstract record B45_1 {  }
-public sealed partial record V45 : B45_1, IValidatedValue<V45, global::Probes.Shapes.PEnum, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V45, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PEnum value) => new V45(value);
-}
-}
-
-// row 46
-public static partial class O46
-{
-public interface IMark46 { int Mark(); }
-public abstract record B46_1 : System.IEquatable<B46_1>, IMark46 { bool System.IEquatable<B46_1>.Equals(B46_1? other) => ReferenceEquals(this, other); int IMark46.Mark() => 1; }
-public sealed partial record V46 : B46_1, IValidatedValue<V46, long, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V46, global::Probes.Shapes.ShapeFault> Create(long value) => new V46(value);
-}
-}
-
-// row 47
-public abstract record B47_3 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); }
-public abstract record B47_2 : B47_3 {  }
-public abstract record B47_1 : B47_2 {  }
-public sealed partial record V47 : B47_1, IValue<global::NodaTime.Instant>;
-
-// row 48
-public partial struct O48
-{
-public abstract record B48_3 {  }
-public abstract record B48_2 : B48_3 {  }
-public abstract record B48_1 : B48_2 {  }
-public sealed partial record V48 : B48_1, IValue<string>;
-}
-
-// row 49
-public interface IMark49 { int Mark(); }
-public abstract record B49_1 : IMark49 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); int IMark49.Mark() => 1; }
-public sealed partial record V49 : B49_1, IValue<global::Probes.Shapes.PRec>;
-
-// row 50
-public static partial class O50
-{
-public sealed partial class P50
-{
-public abstract record B50_3 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); }
-public abstract record B50_2 : B50_3 {  }
-public abstract record B50_1 : B50_2 {  }
-public sealed partial record V50 : B50_1, IValue<global::System.DateOnly>;
-}
-}
-
-// row 51
-public abstract record B51_1 : System.IEquatable<B51_1> { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); bool System.IEquatable<B51_1>.Equals(B51_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V51 : B51_1, IValidatedValue<V51, bool, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V51, global::Probes.Shapes.ShapeFault> Create(bool value) => new V51(value);
-}
-
-// row 52
-public abstract record B52_2 {  }
-public abstract record B52_1 : B52_2 {  }
-public sealed partial record V52 : B52_1, IValue<global::System.DateTimeOffset>;
-
-// row 53
-public partial struct O53
-{
-public interface IMark53 { int Mark(); }
-public abstract record B53_1 : IMark53 { int IMark53.Mark() => 1; }
-public sealed partial record V53 : B53_1, IValue<global::System.Guid>;
-}
-
-// row 54
-public partial struct O54
-{
-public abstract record B54_1 : System.IEquatable<B54_1> { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); bool System.IEquatable<B54_1>.Equals(B54_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V54 : B54_1, IValidatedValue<V54, global::System.DateTime, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V54, global::Probes.Shapes.ShapeFault> Create(global::System.DateTime value) => new V54(value);
-}
-}
-
-// row 55
-public partial struct O55
-{
-public abstract record B55_3 : System.IEquatable<B55_3> { bool System.IEquatable<B55_3>.Equals(B55_3? other) => ReferenceEquals(this, other); }
-public abstract record B55_2 : B55_3 {  }
-public abstract record B55_1 : B55_2 {  }
-public sealed partial record V55 : B55_1, IValue<byte>;
-}
-
-// row 56
-public interface IMark56 { int Mark(); }
-public abstract record B56_1 : IMark56 { int IMark56.Mark() => 1; }
-public sealed partial record V56 : B56_1, IValidatedValue<V56, decimal, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V56, global::Probes.Shapes.ShapeFault> Create(decimal value) => new V56(value);
-}
-
-// row 57
-public static partial class O57
-{
-public abstract record B57_1 { public virtual bool Equals(B57_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V57 : B57_1, IValidatedValue<V57, double, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V57, global::Probes.Shapes.ShapeFault> Create(double value) => new V57(value);
-}
-}
-
-// row 58
-public interface IMark58 { int Mark(); }
-public abstract record B58_1 : IMark58 { public virtual bool Equals(B58_1? other) => ReferenceEquals(this, other); int IMark58.Mark() => 1; }
-public sealed partial record V58 : B58_1, IValidatedValue<V58, global::System.TimeOnly, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V58, global::Probes.Shapes.ShapeFault> Create(global::System.TimeOnly value) => new V58(value);
-}
-
-// row 59
-public partial struct O59
-{
-public abstract record B59_1 : System.IEquatable<B59_1> { bool System.IEquatable<B59_1>.Equals(B59_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V59 : B59_1, IValue<global::System.DateOnly>;
-}
-
-// row 60
-public abstract record B60_1 : System.IEquatable<B60_1> { public virtual bool Equals(B60_1? other) => ReferenceEquals(this, other); bool System.IEquatable<B60_1>.Equals(B60_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V60 : B60_1, IValidatedValue<V60, global::Probes.Shapes.PEnum, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V60, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PEnum value) => new V60(value);
-}
-
-// row 61
-public abstract record B61_1 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); }
-public sealed partial record V61 : B61_1, IValue<ulong>;
-
-// row 62
-public static partial class O62
-{
-public abstract record B62_2 { public virtual bool Equals(B62_2? other) => ReferenceEquals(this, other); }
-public abstract record B62_1 : B62_2 {  }
-public sealed partial record V62 : B62_1, IValue<global::Probes.Shapes.PRec>;
-}
-
-// row 63
-public static partial class O63
-{
-public sealed partial class P63
-{
-public abstract record B63_1 : System.IEquatable<B63_1> { public virtual bool Equals(B63_1? other) => ReferenceEquals(this, other); bool System.IEquatable<B63_1>.Equals(B63_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V63 : B63_1, IValidatedValue<V63, long, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V63, global::Probes.Shapes.ShapeFault> Create(long value) => new V63(value);
-}
-}
-}
-
-// row 64
-public static partial class O64
-{
-public sealed partial class P64
-{
-public abstract record B64_1 : System.IEquatable<B64_1> { bool System.IEquatable<B64_1>.Equals(B64_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V64 : B64_1, IValidatedValue<V64, int, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V64, global::Probes.Shapes.ShapeFault> Create(int value) => new V64(value);
-}
-}
-}
-
-// row 65
-public static partial class O65
-{
-public abstract record B65_1 : System.IEquatable<B65_1> { bool System.IEquatable<B65_1>.Equals(B65_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V65 : B65_1, IValue<string>;
-}
-
-// row 66
-public static partial class O66
-{
-public sealed partial class P66
-{
-public abstract record B66_1 : System.IEquatable<B66_1> { bool System.IEquatable<B66_1>.Equals(B66_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V66 : B66_1, IValidatedValue<V66, global::System.TimeSpan, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V66, global::Probes.Shapes.ShapeFault> Create(global::System.TimeSpan value) => new V66(value);
-}
-}
-}
-
-// row 67
-public static partial class O67
-{
-public sealed partial class P67
-{
-public abstract record B67_1 { public virtual bool Equals(B67_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V67 : B67_1, IValue<global::System.DateTime>;
-}
-}
-
-// row 68
-public static partial class O68
-{
-public abstract record B68_1 { public virtual bool Equals(B68_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V68 : B68_1, IValidatedValue<V68, ulong, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V68, global::Probes.Shapes.ShapeFault> Create(ulong value) => new V68(value);
-}
-}
-
-// row 69
-public static partial class O69
-{
-public sealed partial class P69
-{
-public abstract record B69_2 { public virtual bool Equals(B69_2? other) => ReferenceEquals(this, other); }
-public abstract record B69_1 : B69_2 {  }
-public sealed partial record V69 : B69_1, IValue<bool>;
-}
-}
-
-// row 70
-public abstract record B70_2 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); }
-public abstract record B70_1 : B70_2 {  }
-public sealed partial record V70 : B70_1, IValidatedValue<V70, global::System.Uri, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V70, global::Probes.Shapes.ShapeFault> Create(global::System.Uri value) => new V70(value);
-}
-
-// row 71
-public interface IMark71 { int Mark(); }
-public abstract record B71_1 : System.IEquatable<B71_1>, IMark71 { bool System.IEquatable<B71_1>.Equals(B71_1? other) => ReferenceEquals(this, other); int IMark71.Mark() => 1; }
-public sealed partial record V71 : B71_1, IValidatedValue<V71, global::Probes.Shapes.PFlags, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V71, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PFlags value) => new V71(value);
-}
-
-// row 72
-public static partial class O72
-{
-public abstract record B72_1 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); }
-public sealed partial record V72 : B72_1, IValue<byte>;
-}
-
-// row 73
-public static partial class O73
-{
-public sealed partial class P73
-{
-public abstract record B73_1 : System.IEquatable<B73_1> { bool System.IEquatable<B73_1>.Equals(B73_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V73 : B73_1, IValue<global::System.Guid>;
-}
-}
-
-// row 74
-public static partial class O74
-{
-public sealed partial class P74
-{
-public abstract record B74_2 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); }
-public abstract record B74_1 : B74_2 {  }
-public sealed partial record V74 : B74_1, IValidatedValue<V74, double, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V74, global::Probes.Shapes.ShapeFault> Create(double value) => new V74(value);
-}
-}
-}
-
-// row 75
-public static partial class O75
-{
-public abstract record B75_1 : System.IEquatable<B75_1> { bool System.IEquatable<B75_1>.Equals(B75_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V75 : B75_1, IValue<global::NodaTime.Instant>;
-}
-
-// row 76
-public static partial class O76
-{
-public interface IMark76 { int Mark(); }
-public abstract record B76_1 : System.IEquatable<B76_1>, IMark76 { bool System.IEquatable<B76_1>.Equals(B76_1? other) => ReferenceEquals(this, other); int IMark76.Mark() => 1; }
-public sealed partial record V76 : B76_1, IValidatedValue<V76, global::System.DateTimeOffset, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V76, global::Probes.Shapes.ShapeFault> Create(global::System.DateTimeOffset value) => new V76(value);
-}
-}
-
-// row 77
-public static partial class O77
-{
-public sealed partial class P77
-{
-public abstract record B77_2 : System.IEquatable<B77_2> { bool System.IEquatable<B77_2>.Equals(B77_2? other) => ReferenceEquals(this, other); }
-public abstract record B77_1 : B77_2 {  }
-public sealed partial record V77 : B77_1, IValidatedValue<V77, char, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V77, global::Probes.Shapes.ShapeFault> Create(char value) => new V77(value);
-}
-}
-}
-
-// row 78
-public static partial class O78
-{
-public sealed partial class P78
-{
-public abstract record B78_1 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); }
-public sealed partial record V78 : B78_1, IValue<decimal>;
-}
-}
-
-// row 79
-public static partial class O79
-{
-public abstract record B79_2 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); }
-public abstract record B79_1 : B79_2 {  }
-public sealed partial record V79 : B79_1, IValue<global::System.TimeOnly>;
-}
-
-// row 80
-public static partial class O80
-{
-public sealed partial class P80
-{
-public abstract record B80_3 { public virtual bool Equals(B80_3? other) => ReferenceEquals(this, other); }
-public abstract record B80_2 : B80_3 {  }
-public abstract record B80_1 : B80_2 {  }
-public sealed partial record V80 : B80_1, IValidatedValue<V80, global::System.TimeOnly, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V80, global::Probes.Shapes.ShapeFault> Create(global::System.TimeOnly value) => new V80(value);
-}
-}
-}
-
-// row 81
-public static partial class O81
-{
-public interface IMark81 { int Mark(); }
-public abstract record B81_1 : System.IEquatable<B81_1>, IMark81 { bool System.IEquatable<B81_1>.Equals(B81_1? other) => ReferenceEquals(this, other); int IMark81.Mark() => 1; }
-public sealed partial record V81 : B81_1, IValue<ulong>;
-}
-
-// row 82
-public static partial class O82
-{
-public interface IMark82 { int Mark(); }
-public abstract record B82_1 : IMark82 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); int IMark82.Mark() => 1; }
-public sealed partial record V82 : B82_1, IValue<global::System.DateOnly>;
-}
-
-// row 83
-public abstract record B83_1 : System.IEquatable<B83_1> { bool System.IEquatable<B83_1>.Equals(B83_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V83 : B83_1, IValue<ulong>;
-
-// row 84
-public abstract record B84_1 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); }
-public sealed partial record V84 : B84_1, IValidatedValue<V84, char, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V84, global::Probes.Shapes.ShapeFault> Create(char value) => new V84(value);
-}
-
-// row 85
-public static partial class O85
-{
-public interface IMark85 { int Mark(); }
-public abstract record B85_1 : System.IEquatable<B85_1>, IMark85 { bool System.IEquatable<B85_1>.Equals(B85_1? other) => ReferenceEquals(this, other); int IMark85.Mark() => 1; }
-public sealed partial record V85 : B85_1, IValue<global::System.TimeSpan>;
-}
-
-// row 86
-public partial struct O86
-{
-public abstract record B86_2 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); }
-public abstract record B86_1 : B86_2 {  }
-public sealed partial record V86 : B86_1, IValue<decimal>;
-}
-
-// row 87
-public partial struct O87
-{
-public abstract record B87_1 : System.IEquatable<B87_1> { bool System.IEquatable<B87_1>.Equals(B87_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V87 : B87_1, IValidatedValue<V87, global::System.DateTimeOffset, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V87, global::Probes.Shapes.ShapeFault> Create(global::System.DateTimeOffset value) => new V87(value);
-}
-}
-
-// row 88
-public static partial class O88
-{
-public abstract record B88_2 : System.IEquatable<B88_2> { bool System.IEquatable<B88_2>.Equals(B88_2? other) => ReferenceEquals(this, other); }
-public abstract record B88_1 : B88_2 {  }
-public sealed partial record V88 : B88_1, IValidatedValue<V88, global::System.Guid, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V88, global::Probes.Shapes.ShapeFault> Create(global::System.Guid value) => new V88(value);
-}
-}
-
-// row 89
-public static partial class O89
-{
-public abstract record B89_1 : System.IEquatable<B89_1> { bool System.IEquatable<B89_1>.Equals(B89_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V89 : B89_1, IValue<byte>;
-}
-
-// row 90
-public abstract record B90_3 : System.IEquatable<B90_3> { bool System.IEquatable<B90_3>.Equals(B90_3? other) => ReferenceEquals(this, other); }
-public abstract record B90_2 : B90_3 {  }
-public abstract record B90_1 : B90_2 {  }
-public sealed partial record V90 : B90_1, IValidatedValue<V90, long, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V90, global::Probes.Shapes.ShapeFault> Create(long value) => new V90(value);
-}
-
-// row 91
-public static partial class O91
-{
-public sealed partial class P91
-{
-public abstract record B91_2 : System.IEquatable<B91_2> { bool System.IEquatable<B91_2>.Equals(B91_2? other) => ReferenceEquals(this, other); }
-public abstract record B91_1 : B91_2 {  }
-public sealed partial record V91 : B91_1, IValue<string>;
-}
-}
-
-// row 92
-public abstract record B92_3 : System.IEquatable<B92_3> { bool System.IEquatable<B92_3>.Equals(B92_3? other) => ReferenceEquals(this, other); }
-public abstract record B92_2 : B92_3 {  }
-public abstract record B92_1 : B92_2 {  }
-public sealed partial record V92 : B92_1, IValidatedValue<V92, bool, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V92, global::Probes.Shapes.ShapeFault> Create(bool value) => new V92(value);
-}
-
-// row 93
-public abstract record B93_1 : System.IEquatable<B93_1> { bool System.IEquatable<B93_1>.Equals(B93_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V93 : B93_1, IValidatedValue<V93, global::NodaTime.Instant, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V93, global::Probes.Shapes.ShapeFault> Create(global::NodaTime.Instant value) => new V93(value);
-}
-
-// row 94
-public static partial class O94
-{
-public sealed partial class P94
-{
-public interface IMark94 { int Mark(); }
-public abstract record B94_1 : System.IEquatable<B94_1>, IMark94 { bool System.IEquatable<B94_1>.Equals(B94_1? other) => ReferenceEquals(this, other); int IMark94.Mark() => 1; }
-public sealed partial record V94 : B94_1, IValue<int>;
-}
-}
-
-// row 95
-public static partial class O95
-{
-public abstract record B95_1 : System.IEquatable<B95_1> { bool System.IEquatable<B95_1>.Equals(B95_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V95 : B95_1, IValidatedValue<V95, global::Probes.Shapes.PFlags, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V95, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PFlags value) => new V95(value);
-}
-}
-
-// row 96
-public partial struct O96
-{
-public interface IMark96 { int Mark(); }
-public abstract record B96_1 : IMark96 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); int IMark96.Mark() => 1; }
-public sealed partial record V96 : B96_1, IValue<global::Probes.Shapes.PEnum>;
-}
-
-// row 97
-public static partial class O97
-{
-public sealed partial class P97
-{
-public abstract record B97_3 {  }
-public abstract record B97_2 : B97_3 {  }
-public abstract record B97_1 : B97_2 {  }
-public sealed partial record V97 : B97_1, IValue<global::Probes.Shapes.PRec>;
-}
-}
-
-// row 98
-public static partial class O98
-{
-public interface IMark98 { int Mark(); }
-public abstract record B98_1 : System.IEquatable<B98_1>, IMark98 { bool System.IEquatable<B98_1>.Equals(B98_1? other) => ReferenceEquals(this, other); int IMark98.Mark() => 1; }
-public sealed partial record V98 : B98_1, IValue<global::System.DateTime>;
-}
-
-// row 99
-public static partial class O99
-{
-public interface IMark99 { int Mark(); }
-public abstract record B99_1 : IMark99 { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); int IMark99.Mark() => 1; }
-public sealed partial record V99 : B99_1, IValidatedValue<V99, double, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V99, global::Probes.Shapes.ShapeFault> Create(double value) => new V99(value);
-}
-}
-
-// row 100
-public static partial class O100
-{
-public abstract record B100_3 : System.IEquatable<B100_3> { bool System.IEquatable<B100_3>.Equals(B100_3? other) => ReferenceEquals(this, other); }
-public abstract record B100_2 : B100_3 {  }
-public abstract record B100_1 : B100_2 {  }
-public sealed partial record V100 : B100_1, IValidatedValue<V100, global::System.Uri, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V100, global::Probes.Shapes.ShapeFault> Create(global::System.Uri value) => new V100(value);
-}
-}
-
-public static partial class C09Table
-{
-    public static readonly C09Case[] Cases =
-    [
-        new(0, "base-equality=explicit-IEquatable;collection=HashSet;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=own-record-class", "validated-class", "nested-two-levels", "base-explicit-IEquatable", typeof(O0.P0.V0), [typeof(O0.P0.B0_1)], x => O0.P0.V0.FromKnownGood((global::Probes.Shapes.PRec)x), []),
-        new(1, "base-equality=override-Equals;collection=Distinct;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=DateTimeOffset", "sealed-record-class", "nested-two-levels", "base-depth-3", typeof(O1.P1.V1), [typeof(O1.P1.B1_1), typeof(O1.P1.B1_2), typeof(O1.P1.B1_3)], x => O1.P1.V1.From((global::System.DateTimeOffset)x), []),
-        new(2, "base-equality=override-GetHashCode;collection=Dictionary-key;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=long", "validated-class", "nested-in-struct", "base-depth-1", typeof(O2.V2), [typeof(O2.B2_1)], x => O2.V2.FromKnownGood((long)x), []),
-        new(3, "base-equality=none;collection=HashSet;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=DateOnly", "sealed-record-class", "top-level", "base-depth-1", typeof(V3), [typeof(B3_1)], x => V3.From((global::System.DateOnly)x), []),
-        new(4, "base-equality=override-GetHashCode;collection=Distinct;shape.inheritance=explicit-interface-member;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=string", "validated-class", "top-level", "explicit-interface-member", typeof(V4), [typeof(B4_1)], x => V4.FromKnownGood((string)x), []),
-        new(5, "base-equality=explicit-IEquatable;collection=Dictionary-key;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-class;shape.wrapped=Uri", "sealed-record-class", "nested-in-class", "explicit-interface-member", typeof(O5.V5), [typeof(O5.B5_1)], x => O5.V5.From((global::System.Uri)x), []),
-        new(6, "base-equality=none;collection=HashSet;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=flags-enum", "validated-class", "nested-in-class", "base-depth-2", typeof(O6.V6), [typeof(O6.B6_1), typeof(O6.B6_2)], x => O6.V6.FromKnownGood((global::Probes.Shapes.PFlags)x), []),
-        new(7, "base-equality=override-GetHashCode;collection=HashSet;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=TimeSpan", "sealed-record-class", "nested-in-struct", "base-depth-2", typeof(O7.V7), [typeof(O7.B7_1), typeof(O7.B7_2)], x => O7.V7.From((global::System.TimeSpan)x), []),
-        new(8, "base-equality=none;collection=Distinct;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=TimeOnly", "sealed-record-class", "nested-in-struct", "base-explicit-IEquatable", typeof(O8.V8), [typeof(O8.B8_1)], x => O8.V8.From((global::System.TimeOnly)x), []),
-        new(9, "base-equality=none;collection=Dictionary-key;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=byte", "sealed-record-class", "nested-two-levels", "explicit-interface-member", typeof(O9.P9.V9), [typeof(O9.P9.B9_1)], x => O9.P9.V9.From((byte)x), []),
-        new(10, "base-equality=override-Equals;collection=Dictionary-key;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=top-level;shape.wrapped=DateOnly", "validated-class", "top-level", "base-depth-2", typeof(V10), [typeof(B10_1), typeof(B10_2)], x => V10.FromKnownGood((global::System.DateOnly)x), []),
-        new(11, "base-equality=override-Equals;collection=Distinct;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=Guid", "validated-class", "nested-in-class", "base-depth-1", typeof(O11.V11), [typeof(O11.B11_1)], x => O11.V11.FromKnownGood((global::System.Guid)x), []),
-        new(12, "base-equality=explicit-IEquatable;collection=Distinct;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=ulong", "validated-class", "nested-in-struct", "base-depth-2", typeof(O12.V12), [typeof(O12.B12_1), typeof(O12.B12_2)], x => O12.V12.FromKnownGood((ulong)x), []),
-        new(13, "base-equality=override-Equals;collection=HashSet;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=decimal", "validated-class", "nested-in-struct", "base-depth-3", typeof(O13.V13), [typeof(O13.B13_1), typeof(O13.B13_2), typeof(O13.B13_3)], x => O13.V13.FromKnownGood((decimal)x), []),
-        new(14, "base-equality=override-GetHashCode;collection=Dictionary-key;shape.inheritance=base-depth-3;shape.kind=closed-set;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-class;shape.wrapped=int", "sealed-record-class", "nested-in-class", "base-depth-3", typeof(O14.V14), [typeof(O14.B14_1), typeof(O14.B14_2), typeof(O14.B14_3)], x => O14.V14.From((int)x), [("shape.kind", "sealed-record-class")]),
-        new(15, "base-equality=override-Equals;collection=HashSet;shape.inheritance=explicit-interface-member;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=NodaTime.Instant", "validated-class", "nested-in-struct", "explicit-interface-member", typeof(O15.V15), [typeof(O15.B15_1)], x => O15.V15.FromKnownGood((global::NodaTime.Instant)x), []),
-        new(16, "base-equality=explicit-IEquatable;collection=Distinct;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=double", "sealed-record-class", "top-level", "base-depth-3", typeof(V16), [typeof(B16_1), typeof(B16_2), typeof(B16_3)], x => V16.From((double)x), []),
-        new(17, "base-equality=override-Equals;collection=Dictionary-key;shape.inheritance=base-explicit-IEquatable;shape.kind=record-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-class;shape.wrapped=TimeSpan", "sealed-record-class", "nested-in-class", "base-explicit-IEquatable", typeof(O17.V17), [typeof(O17.B17_1)], x => O17.V17.From((global::System.TimeSpan)x), [("shape.kind", "sealed-record-class")]),
-        new(18, "base-equality=override-GetHashCode;collection=Dictionary-key;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-two-levels;shape.wrapped=flags-enum", "sealed-record-class", "nested-two-levels", "base-depth-1", typeof(O18.P18.V18), [typeof(O18.P18.B18_1)], x => O18.P18.V18.From((global::Probes.Shapes.PFlags)x), []),
-        new(19, "base-equality=override-GetHashCode;collection=Dictionary-key;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=char", "validated-class", "top-level", "base-explicit-IEquatable", typeof(V19), [typeof(B19_1)], x => V19.FromKnownGood((char)x), []),
-        new(20, "base-equality=none;collection=Dictionary-key;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=DateTime", "validated-class", "top-level", "base-depth-3", typeof(V20), [typeof(B20_1), typeof(B20_2), typeof(B20_3)], x => V20.FromKnownGood((global::System.DateTime)x), []),
-        new(21, "base-equality=explicit-IEquatable;collection=HashSet;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=DateTime", "sealed-record-class", "nested-in-class", "base-depth-2", typeof(O21.V21), [typeof(O21.B21_1), typeof(O21.B21_2)], x => O21.V21.From((global::System.DateTime)x), []),
-        new(22, "base-equality=none;collection=Dictionary-key;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-two-levels;shape.wrapped=NodaTime.Instant", "sealed-record-class", "nested-two-levels", "base-depth-2", typeof(O22.P22.V22), [typeof(O22.P22.B22_1), typeof(O22.P22.B22_2)], x => O22.P22.V22.From((global::NodaTime.Instant)x), []),
-        new(23, "base-equality=explicit-IEquatable;collection=Dictionary-key;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=TimeOnly", "validated-class", "top-level", "base-depth-1", typeof(V23), [typeof(B23_1)], x => V23.FromKnownGood((global::System.TimeOnly)x), []),
-        new(24, "base-equality=none;collection=Distinct;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=Uri", "validated-class", "nested-two-levels", "base-depth-1", typeof(O24.P24.V24), [typeof(O24.P24.B24_1)], x => O24.P24.V24.FromKnownGood((global::System.Uri)x), []),
-        new(25, "base-equality=none;collection=Dictionary-key;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-class;shape.wrapped=bool", "validated-class", "nested-in-class", "base-depth-1", typeof(O25.V25), [typeof(O25.B25_1)], x => O25.V25.FromKnownGood((bool)x), []),
-        new(26, "base-equality=override-GetHashCode;collection=Dictionary-key;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=enum", "validated-class", "nested-two-levels", "base-depth-3", typeof(O26.P26.V26), [typeof(O26.P26.B26_1), typeof(O26.P26.B26_2), typeof(O26.P26.B26_3)], x => O26.P26.V26.FromKnownGood((global::Probes.Shapes.PEnum)x), []),
-        new(27, "base-equality=none;collection=Distinct;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=long", "sealed-record-class", "top-level", "base-depth-2", typeof(V27), [typeof(B27_1), typeof(B27_2)], x => V27.From((long)x), []),
-        new(28, "base-equality=none;collection=Distinct;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=own-record-class", "sealed-record-class", "nested-in-struct", "base-depth-1", typeof(O28.V28), [typeof(O28.B28_1)], x => O28.V28.From((global::Probes.Shapes.PRec)x), []),
-        new(29, "base-equality=explicit-IEquatable;collection=Distinct;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-struct;shape.wrapped=bool", "sealed-record-class", "nested-in-struct", "explicit-interface-member", typeof(O29.V29), [typeof(O29.B29_1)], x => O29.V29.From((bool)x), []),
-        new(30, "base-equality=explicit-IEquatable;collection=Distinct;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=int", "sealed-record-class", "top-level", "base-depth-2", typeof(V30), [typeof(B30_1), typeof(B30_2)], x => V30.From((int)x), []),
-        new(31, "base-equality=none;collection=Dictionary-key;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=ulong", "sealed-record-class", "nested-two-levels", "base-depth-3", typeof(O31.P31.V31), [typeof(O31.P31.B31_1), typeof(O31.P31.B31_2), typeof(O31.P31.B31_3)], x => O31.P31.V31.From((ulong)x), []),
-        new(32, "base-equality=none;collection=Dictionary-key;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=double", "validated-class", "nested-in-struct", "base-explicit-IEquatable", typeof(O32.V32), [typeof(O32.B32_1)], x => O32.V32.FromKnownGood((double)x), []),
-        new(33, "base-equality=override-Equals;collection=HashSet;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-two-levels;shape.wrapped=string", "sealed-record-class", "nested-two-levels", "base-explicit-IEquatable", typeof(O33.P33.V33), [typeof(O33.P33.B33_1)], x => O33.P33.V33.From((string)x), []),
-        new(34, "base-equality=override-GetHashCode;collection=HashSet;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-struct;shape.wrapped=DateTimeOffset", "validated-class", "nested-in-struct", "base-depth-1", typeof(O34.V34), [typeof(O34.B34_1)], x => O34.V34.FromKnownGood((global::System.DateTimeOffset)x), []),
-        new(35, "base-equality=override-GetHashCode;collection=Dictionary-key;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=Guid", "sealed-record-class", "top-level", "base-depth-3", typeof(V35), [typeof(B35_1), typeof(B35_2), typeof(B35_3)], x => V35.From((global::System.Guid)x), []),
-        new(36, "base-equality=none;collection=Distinct;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=char", "sealed-record-class", "nested-in-class", "base-depth-3", typeof(O36.V36), [typeof(O36.B36_1), typeof(O36.B36_2), typeof(O36.B36_3)], x => O36.V36.From((char)x), []),
-        new(37, "base-equality=explicit-IEquatable;collection=Dictionary-key;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=decimal", "sealed-record-class", "nested-in-class", "base-explicit-IEquatable", typeof(O37.V37), [typeof(O37.B37_1)], x => O37.V37.From((decimal)x), []),
-        new(38, "base-equality=explicit-IEquatable;collection=Distinct;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=enum", "sealed-record-class", "nested-in-struct", "base-depth-2", typeof(O38.V38), [typeof(O38.B38_1), typeof(O38.B38_2)], x => O38.V38.From((global::Probes.Shapes.PEnum)x), []),
-        new(39, "base-equality=override-Equals;collection=HashSet;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=byte", "validated-class", "top-level", "base-depth-2", typeof(V39), [typeof(B39_1), typeof(B39_2)], x => V39.FromKnownGood((byte)x), []),
-        new(40, "base-equality=override-Equals;collection=Distinct;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=flags-enum", "validated-class", "nested-in-struct", "base-depth-3", typeof(O40.V40), [typeof(O40.B40_1), typeof(O40.B40_2), typeof(O40.B40_3)], x => O40.V40.FromKnownGood((global::Probes.Shapes.PFlags)x), []),
-        new(41, "base-equality=none;collection=Distinct;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=top-level;shape.wrapped=TimeSpan", "validated-class", "top-level", "base-depth-3", typeof(V41), [typeof(B41_1), typeof(B41_2), typeof(B41_3)], x => V41.FromKnownGood((global::System.TimeSpan)x), []),
-        new(42, "base-equality=override-Equals;collection=HashSet;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=char", "sealed-record-class", "nested-in-struct", "explicit-interface-member", typeof(O42.V42), [typeof(O42.B42_1)], x => O42.V42.From((char)x), []),
-        new(43, "base-equality=override-Equals;collection=HashSet;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=int", "sealed-record-class", "nested-in-struct", "base-depth-1", typeof(O43.V43), [typeof(O43.B43_1)], x => O43.V43.From((int)x), []),
-        new(44, "base-equality=override-Equals;collection=HashSet;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=Uri", "sealed-record-class", "nested-in-struct", "base-explicit-IEquatable", typeof(O44.V44), [typeof(O44.B44_1)], x => O44.V44.From((global::System.Uri)x), []),
-        new(45, "base-equality=none;collection=HashSet;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-class;shape.wrapped=enum", "validated-class", "nested-in-class", "base-depth-1", typeof(O45.V45), [typeof(O45.B45_1)], x => O45.V45.FromKnownGood((global::Probes.Shapes.PEnum)x), []),
-        new(46, "base-equality=explicit-IEquatable;collection=HashSet;shape.inheritance=explicit-interface-member;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=long", "validated-class", "nested-in-class", "explicit-interface-member", typeof(O46.V46), [typeof(O46.B46_1)], x => O46.V46.FromKnownGood((long)x), []),
-        new(47, "base-equality=override-GetHashCode;collection=Distinct;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=NodaTime.Instant", "sealed-record-class", "top-level", "base-depth-3", typeof(V47), [typeof(B47_1), typeof(B47_2), typeof(B47_3)], x => V47.From((global::NodaTime.Instant)x), []),
-        new(48, "base-equality=none;collection=Dictionary-key;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=string", "sealed-record-class", "nested-in-struct", "base-depth-3", typeof(O48.V48), [typeof(O48.B48_1), typeof(O48.B48_2), typeof(O48.B48_3)], x => O48.V48.From((string)x), []),
-        new(49, "base-equality=override-GetHashCode;collection=Dictionary-key;shape.inheritance=explicit-interface-member;shape.kind=record-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=own-record-class", "sealed-record-class", "top-level", "explicit-interface-member", typeof(V49), [typeof(B49_1)], x => V49.From((global::Probes.Shapes.PRec)x), [("shape.kind", "sealed-record-class")]),
-        new(50, "base-equality=override-GetHashCode;collection=Distinct;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=DateOnly", "sealed-record-class", "nested-two-levels", "base-depth-3", typeof(O50.P50.V50), [typeof(O50.P50.B50_1), typeof(O50.P50.B50_2), typeof(O50.P50.B50_3)], x => O50.P50.V50.From((global::System.DateOnly)x), []),
-        new(51, "base-equality=override-GetHashCode;collection=HashSet;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=bool", "validated-class", "top-level", "base-explicit-IEquatable", typeof(V51), [typeof(B51_1)], x => V51.FromKnownGood((bool)x), []),
-        new(52, "base-equality=none;collection=Dictionary-key;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=DateTimeOffset", "sealed-record-class", "top-level", "base-depth-2", typeof(V52), [typeof(B52_1), typeof(B52_2)], x => V52.From((global::System.DateTimeOffset)x), []),
-        new(53, "base-equality=none;collection=HashSet;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=Guid", "sealed-record-class", "nested-in-struct", "explicit-interface-member", typeof(O53.V53), [typeof(O53.B53_1)], x => O53.V53.From((global::System.Guid)x), []),
-        new(54, "base-equality=override-GetHashCode;collection=Distinct;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-struct;shape.wrapped=DateTime", "validated-class", "nested-in-struct", "base-explicit-IEquatable", typeof(O54.V54), [typeof(O54.B54_1)], x => O54.V54.FromKnownGood((global::System.DateTime)x), []),
-        new(55, "base-equality=explicit-IEquatable;collection=Distinct;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=byte", "sealed-record-class", "nested-in-struct", "base-depth-3", typeof(O55.V55), [typeof(O55.B55_1), typeof(O55.B55_2), typeof(O55.B55_3)], x => O55.V55.From((byte)x), []),
-        new(56, "base-equality=none;collection=Distinct;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=decimal", "validated-class", "top-level", "explicit-interface-member", typeof(V56), [typeof(B56_1)], x => V56.FromKnownGood((decimal)x), [("shape.kind", "validated-class")]),
-        new(57, "base-equality=override-Equals;collection=HashSet;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=double", "validated-class", "nested-in-class", "base-depth-1", typeof(O57.V57), [typeof(O57.B57_1)], x => O57.V57.FromKnownGood((double)x), []),
-        new(58, "base-equality=override-Equals;collection=HashSet;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=top-level;shape.wrapped=TimeOnly", "validated-class", "top-level", "explicit-interface-member", typeof(V58), [typeof(B58_1)], x => V58.FromKnownGood((global::System.TimeOnly)x), [("shape.kind", "validated-class")]),
-        new(59, "base-equality=explicit-IEquatable;collection=HashSet;shape.inheritance=base-explicit-IEquatable;shape.kind=closed-set;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=DateOnly", "sealed-record-class", "nested-in-struct", "base-explicit-IEquatable", typeof(O59.V59), [typeof(O59.B59_1)], x => O59.V59.From((global::System.DateOnly)x), [("shape.kind", "sealed-record-class")]),
-        new(60, "base-equality=override-Equals;collection=Distinct;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=enum", "validated-class", "top-level", "base-explicit-IEquatable", typeof(V60), [typeof(B60_1)], x => V60.FromKnownGood((global::Probes.Shapes.PEnum)x), []),
-        new(61, "base-equality=override-GetHashCode;collection=HashSet;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=top-level;shape.wrapped=ulong", "sealed-record-class", "top-level", "base-depth-1", typeof(V61), [typeof(B61_1)], x => V61.From((ulong)x), []),
-        new(62, "base-equality=override-Equals;collection=Distinct;shape.inheritance=base-depth-2;shape.kind=closed-set;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=own-record-class", "sealed-record-class", "nested-in-class", "base-depth-2", typeof(O62.V62), [typeof(O62.B62_1), typeof(O62.B62_2)], x => O62.V62.From((global::Probes.Shapes.PRec)x), [("shape.kind", "sealed-record-class")]),
-        new(63, "base-equality=override-Equals;collection=HashSet;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=long", "validated-class", "nested-two-levels", "base-explicit-IEquatable", typeof(O63.P63.V63), [typeof(O63.P63.B63_1)], x => O63.P63.V63.FromKnownGood((long)x), []),
-        new(64, "base-equality=none;collection=Distinct;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=int", "validated-class", "nested-two-levels", "base-explicit-IEquatable", typeof(O64.P64.V64), [typeof(O64.P64.B64_1)], x => O64.P64.V64.FromKnownGood((int)x), []),
-        new(65, "base-equality=explicit-IEquatable;collection=HashSet;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=string", "sealed-record-class", "nested-in-class", "base-depth-1", typeof(O65.V65), [typeof(O65.B65_1)], x => O65.V65.From((string)x), []),
-        new(66, "base-equality=explicit-IEquatable;collection=HashSet;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=TimeSpan", "validated-class", "nested-two-levels", "base-depth-1", typeof(O66.P66.V66), [typeof(O66.P66.B66_1)], x => O66.P66.V66.FromKnownGood((global::System.TimeSpan)x), []),
-        new(67, "base-equality=override-Equals;collection=Distinct;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=DateTime", "sealed-record-class", "nested-two-levels", "base-depth-1", typeof(O67.P67.V67), [typeof(O67.P67.B67_1)], x => O67.P67.V67.From((global::System.DateTime)x), []),
-        new(68, "base-equality=override-Equals;collection=Dictionary-key;shape.inheritance=base-depth-1;shape.kind=validated-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-class;shape.wrapped=ulong", "validated-class", "nested-in-class", "base-depth-1", typeof(O68.V68), [typeof(O68.B68_1)], x => O68.V68.FromKnownGood((ulong)x), [("shape.kind", "validated-class")]),
-        new(69, "base-equality=override-Equals;collection=Dictionary-key;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=bool", "sealed-record-class", "nested-two-levels", "base-depth-2", typeof(O69.P69.V69), [typeof(O69.P69.B69_1), typeof(O69.P69.B69_2)], x => O69.P69.V69.From((bool)x), []),
-        new(70, "base-equality=override-GetHashCode;collection=Dictionary-key;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=Uri", "validated-class", "top-level", "base-depth-2", typeof(V70), [typeof(B70_1), typeof(B70_2)], x => V70.FromKnownGood((global::System.Uri)x), []),
-        new(71, "base-equality=explicit-IEquatable;collection=HashSet;shape.inheritance=explicit-interface-member;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=flags-enum", "validated-class", "top-level", "explicit-interface-member", typeof(V71), [typeof(B71_1)], x => V71.FromKnownGood((global::Probes.Shapes.PFlags)x), []),
-        new(72, "base-equality=override-GetHashCode;collection=HashSet;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=byte", "sealed-record-class", "nested-in-class", "base-depth-1", typeof(O72.V72), [typeof(O72.B72_1)], x => O72.V72.From((byte)x), []),
-        new(73, "base-equality=explicit-IEquatable;collection=Distinct;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=Guid", "sealed-record-class", "nested-two-levels", "base-explicit-IEquatable", typeof(O73.P73.V73), [typeof(O73.P73.B73_1)], x => O73.P73.V73.From((global::System.Guid)x), []),
-        new(74, "base-equality=override-GetHashCode;collection=HashSet;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=double", "validated-class", "nested-two-levels", "base-depth-2", typeof(O74.P74.V74), [typeof(O74.P74.B74_1), typeof(O74.P74.B74_2)], x => O74.P74.V74.FromKnownGood((double)x), []),
-        new(75, "base-equality=explicit-IEquatable;collection=Distinct;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-class;shape.wrapped=NodaTime.Instant", "sealed-record-class", "nested-in-class", "base-explicit-IEquatable", typeof(O75.V75), [typeof(O75.B75_1)], x => O75.V75.From((global::NodaTime.Instant)x), []),
-        new(76, "base-equality=explicit-IEquatable;collection=Dictionary-key;shape.inheritance=explicit-interface-member;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-class;shape.wrapped=DateTimeOffset", "validated-class", "nested-in-class", "explicit-interface-member", typeof(O76.V76), [typeof(O76.B76_1)], x => O76.V76.FromKnownGood((global::System.DateTimeOffset)x), []),
-        new(77, "base-equality=explicit-IEquatable;collection=HashSet;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-two-levels;shape.wrapped=char", "validated-class", "nested-two-levels", "base-depth-2", typeof(O77.P77.V77), [typeof(O77.P77.B77_1), typeof(O77.P77.B77_2)], x => O77.P77.V77.FromKnownGood((char)x), []),
-        new(78, "base-equality=override-GetHashCode;collection=HashSet;shape.inheritance=base-depth-1;shape.kind=record-struct;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=decimal", "sealed-record-class", "nested-two-levels", "base-depth-1", typeof(O78.P78.V78), [typeof(O78.P78.B78_1)], x => O78.P78.V78.From((decimal)x), [("shape.kind", "sealed-record-class")]),
-        new(79, "base-equality=override-GetHashCode;collection=Dictionary-key;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=TimeOnly", "sealed-record-class", "nested-in-class", "base-depth-2", typeof(O79.V79), [typeof(O79.B79_1), typeof(O79.B79_2)], x => O79.V79.From((global::System.TimeOnly)x), []),
-        new(80, "base-equality=override-Equals;collection=Distinct;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=TimeOnly", "validated-class", "nested-two-levels", "base-depth-3", typeof(O80.P80.V80), [typeof(O80.P80.B80_1), typeof(O80.P80.B80_2), typeof(O80.P80.B80_3)], x => O80.P80.V80.FromKnownGood((global::System.TimeOnly)x), []),
-        new(81, "base-equality=explicit-IEquatable;collection=Dictionary-key;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=ulong", "sealed-record-class", "nested-in-class", "explicit-interface-member", typeof(O81.V81), [typeof(O81.B81_1)], x => O81.V81.From((ulong)x), []),
-        new(82, "base-equality=override-GetHashCode;collection=Dictionary-key;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=DateOnly", "sealed-record-class", "nested-in-class", "explicit-interface-member", typeof(O82.V82), [typeof(O82.B82_1)], x => O82.V82.From((global::System.DateOnly)x), []),
-        new(83, "base-equality=explicit-IEquatable;collection=HashSet;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=ulong", "sealed-record-class", "top-level", "base-explicit-IEquatable", typeof(V83), [typeof(B83_1)], x => V83.From((ulong)x), []),
-        new(84, "base-equality=override-GetHashCode;collection=Distinct;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=char", "validated-class", "top-level", "base-depth-1", typeof(V84), [typeof(B84_1)], x => V84.FromKnownGood((char)x), []),
-        new(85, "base-equality=explicit-IEquatable;collection=Dictionary-key;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=TimeSpan", "sealed-record-class", "nested-in-class", "explicit-interface-member", typeof(O85.V85), [typeof(O85.B85_1)], x => O85.V85.From((global::System.TimeSpan)x), []),
-        new(86, "base-equality=override-GetHashCode;collection=Distinct;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=decimal", "sealed-record-class", "nested-in-struct", "base-depth-2", typeof(O86.V86), [typeof(O86.B86_1), typeof(O86.B86_2)], x => O86.V86.From((decimal)x), []),
-        new(87, "base-equality=none;collection=HashSet;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=DateTimeOffset", "validated-class", "nested-in-struct", "base-explicit-IEquatable", typeof(O87.V87), [typeof(O87.B87_1)], x => O87.V87.FromKnownGood((global::System.DateTimeOffset)x), []),
-        new(88, "base-equality=explicit-IEquatable;collection=Distinct;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=Guid", "validated-class", "nested-in-class", "base-depth-2", typeof(O88.V88), [typeof(O88.B88_1), typeof(O88.B88_2)], x => O88.V88.FromKnownGood((global::System.Guid)x), []),
-        new(89, "base-equality=explicit-IEquatable;collection=Distinct;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=in-generic-type;shape.wrapped=byte", "sealed-record-class", "nested-in-class", "base-explicit-IEquatable", typeof(O89.V89), [typeof(O89.B89_1)], x => O89.V89.From((byte)x), [("shape.site", "nested-in-class")]),
-        new(90, "base-equality=explicit-IEquatable;collection=Distinct;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=long", "validated-class", "top-level", "base-depth-3", typeof(V90), [typeof(B90_1), typeof(B90_2), typeof(B90_3)], x => V90.FromKnownGood((long)x), []),
-        new(91, "base-equality=explicit-IEquatable;collection=HashSet;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=string", "sealed-record-class", "nested-two-levels", "base-depth-2", typeof(O91.P91.V91), [typeof(O91.P91.B91_1), typeof(O91.P91.B91_2)], x => O91.P91.V91.From((string)x), []),
-        new(92, "base-equality=explicit-IEquatable;collection=HashSet;shape.inheritance=base-depth-3;shape.kind=validated-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=bool", "validated-class", "top-level", "base-depth-3", typeof(V92), [typeof(B92_1), typeof(B92_2), typeof(B92_3)], x => V92.FromKnownGood((bool)x), [("shape.kind", "validated-class")]),
-        new(93, "base-equality=explicit-IEquatable;collection=Dictionary-key;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=top-level;shape.wrapped=NodaTime.Instant", "validated-class", "top-level", "base-depth-1", typeof(V93), [typeof(B93_1)], x => V93.FromKnownGood((global::NodaTime.Instant)x), []),
-        new(94, "base-equality=explicit-IEquatable;collection=Distinct;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=int", "sealed-record-class", "nested-two-levels", "explicit-interface-member", typeof(O94.P94.V94), [typeof(O94.P94.B94_1)], x => O94.P94.V94.From((int)x), []),
-        new(95, "base-equality=none;collection=Distinct;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=flags-enum", "validated-class", "nested-in-class", "base-explicit-IEquatable", typeof(O95.V95), [typeof(O95.B95_1)], x => O95.V95.FromKnownGood((global::Probes.Shapes.PFlags)x), []),
-        new(96, "base-equality=override-GetHashCode;collection=Dictionary-key;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=enum", "sealed-record-class", "nested-in-struct", "explicit-interface-member", typeof(O96.V96), [typeof(O96.B96_1)], x => O96.V96.From((global::Probes.Shapes.PEnum)x), []),
-        new(97, "base-equality=none;collection=Dictionary-key;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-two-levels;shape.wrapped=own-record-class", "sealed-record-class", "nested-two-levels", "base-depth-3", typeof(O97.P97.V97), [typeof(O97.P97.B97_1), typeof(O97.P97.B97_2), typeof(O97.P97.B97_3)], x => O97.P97.V97.From((global::Probes.Shapes.PRec)x), []),
-        new(98, "base-equality=explicit-IEquatable;collection=HashSet;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=DateTime", "sealed-record-class", "nested-in-class", "explicit-interface-member", typeof(O98.V98), [typeof(O98.B98_1)], x => O98.V98.From((global::System.DateTime)x), []),
-        new(99, "base-equality=override-GetHashCode;collection=Dictionary-key;shape.inheritance=explicit-interface-member;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=in-generic-type;shape.wrapped=double", "validated-class", "nested-in-class", "explicit-interface-member", typeof(O99.V99), [typeof(O99.B99_1)], x => O99.V99.FromKnownGood((double)x), [("shape.site", "nested-in-class")]),
-        new(100, "base-equality=explicit-IEquatable;collection=Dictionary-key;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=in-generic-type;shape.wrapped=Uri", "validated-class", "nested-in-class", "base-depth-3", typeof(O100.V100), [typeof(O100.B100_1), typeof(O100.B100_2), typeof(O100.B100_3)], x => O100.V100.FromKnownGood((global::System.Uri)x), [("shape.site", "nested-in-class")]),
-    ];
-}
diff --git a/tools/probe/corpus/harness/C11Shapes.g.cs b/tools/probe/corpus/harness/C11Shapes.g.cs
deleted file mode 100644
index 992834fa..00000000
--- a/tools/probe/corpus/harness/C11Shapes.g.cs
+++ /dev/null
@@ -1,2596 +0,0 @@
-// <auto-generated/> by tools/probe/generators/decls.cs from rows/C11ParseShapesBuildProbe.json.gz: one value object per row. Do not edit; regenerate with the rows.
-#nullable enable
-// CMTK1023: the bases' own equality is the point (C09) or beside it (C11); CS8851: a base's Equals without GetHashCode, on purpose.
-#pragma warning disable CMTK1023, CS8851, CS1591
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.ValueObjects;
-namespace Probes.Build.C11;
-
-// row 0
-public static partial class O0
-{
-public interface IMark0 { int Mark(); }
-public sealed partial record V0 : IValue<double>, IMark0 { int IMark0.Mark() => 1; }
-}
-
-// row 1
-public sealed partial record V1 : IValidatedValue<V1, global::System.TimeSpan, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V1, global::Probes.Shapes.ShapeFault> Create(global::System.TimeSpan value) => new V1(value);
-}
-
-// row 2
-public partial struct O2
-{
-public abstract record B2_2 {  }
-public abstract record B2_1 : B2_2 {  }
-public sealed partial record V2 : B2_1, IValue<global::Probes.Build.C11ParsesToInt> { }
-public abstract record BC2_2 {  }
-public abstract record BC2_1 : BC2_2 {  }
-public sealed partial record VC2 : BC2_1, IValue<global::Probes.Build.C11ParsedShape> { }
-}
-
-// row 3
-public static partial class O3
-{
-public sealed partial class P3
-{
-public readonly partial record struct V3 : IValidatedValue<V3, global::Probes.Build.C11AbstractText, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V3, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11AbstractText value) => new V3(value);
-}
-public readonly partial record struct VC3 : IValidatedValue<VC3, global::Probes.Build.C11ConstructedConcrete, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC3, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ConstructedConcrete value) => new VC3(value);
-}
-}
-}
-
-// row 4
-public interface IMark4 { int Mark(); }
-public readonly partial record struct V4 : IValue<global::Probes.Build.C11ParsesByRef>, IMark4 { int IMark4.Mark() => 1; }
-public readonly partial record struct VC4 : IValue<global::Probes.Build.C11ParsesFromIn>, IMark4 { int IMark4.Mark() => 1; }
-
-// row 5
-public partial struct O5
-{
-public abstract record B5_1 {  }
-public sealed partial record V5 : B5_1, IValidatedValue<V5, global::Probes.Build.C11AbstractText, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V5, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11AbstractText value) => new V5(value);
-}
-public abstract record BC5_1 {  }
-public sealed partial record VC5 : BC5_1, IValidatedValue<VC5, global::Probes.Build.C11ConstructedConcrete, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC5, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ConstructedConcrete value) => new VC5(value);
-}
-}
-
-// row 6
-public static partial class O6
-{
-public readonly partial record struct V6 : IValue<global::Probes.Build.C11ParsesToInt> { }
-public readonly partial record struct VC6 : IValue<global::Probes.Build.C11ParsedShape> { }
-}
-
-// row 7
-public static partial class O7
-{
-public sealed partial class P7
-{
-public abstract record B7_1 {  }
-public sealed partial record V7 : B7_1, IValue<global::Probes.Build.C11ConstructedByRef> { }
-public abstract record BC7_1 {  }
-public sealed partial record VC7 : BC7_1, IValue<global::Probes.Build.C11ParsesFromIn> { }
-}
-}
-
-// row 8
-public static partial class O8
-{
-public sealed partial class P8
-{
-public abstract record B8_1 : System.IEquatable<B8_1> { bool System.IEquatable<B8_1>.Equals(B8_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V8 : B8_1, IValue<long> { }
-}
-}
-
-// row 9
-public partial struct O9
-{
-public abstract record B9_3 {  }
-public abstract record B9_2 : B9_3 {  }
-public abstract record B9_1 : B9_2 {  }
-public sealed partial record V9 : B9_1, IValidatedValue<V9, global::NodaTime.Instant, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V9, global::Probes.Shapes.ShapeFault> Create(global::NodaTime.Instant value) => new V9(value);
-}
-}
-
-// row 10
-public abstract record B10_1 : System.IEquatable<B10_1> { bool System.IEquatable<B10_1>.Equals(B10_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V10 : B10_1, IValidatedValue<V10, global::Probes.Build.C11ParsesToInt, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V10, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesToInt value) => new V10(value);
-}
-public abstract record BC10_1 : System.IEquatable<BC10_1> { bool System.IEquatable<BC10_1>.Equals(BC10_1? other) => ReferenceEquals(this, other); }
-public sealed partial record VC10 : BC10_1, IValidatedValue<VC10, global::Probes.Build.C11ParsedShape, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC10, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsedShape value) => new VC10(value);
-}
-
-// row 11
-public static partial class O11
-{
-public interface IMark11 { int Mark(); }
-public readonly partial record struct V11 : IValidatedValue<V11, global::Probes.Build.C11ConstructedByRef, global::Probes.Shapes.ShapeFault>, IMark11
-{
-    public static Result<V11, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ConstructedByRef value) => new V11(value); int IMark11.Mark() => 1;
-}
-public readonly partial record struct VC11 : IValidatedValue<VC11, global::Probes.Build.C11ParsesFromIn, global::Probes.Shapes.ShapeFault>, IMark11
-{
-    public static Result<VC11, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesFromIn value) => new VC11(value); int IMark11.Mark() => 1;
-}
-}
-
-// row 12
-public abstract record B12_2 {  }
-public abstract record B12_1 : B12_2 {  }
-public sealed partial record V12 : B12_1, IValue<bool> { }
-
-// row 13
-public static partial class O13
-{
-public abstract record B13_3 {  }
-public abstract record B13_2 : B13_3 {  }
-public abstract record B13_1 : B13_2 {  }
-public sealed partial record V13 : B13_1, IValidatedValue<V13, global::Probes.Build.C11AbstractText, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V13, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11AbstractText value) => new V13(value);
-}
-public abstract record BC13_3 {  }
-public abstract record BC13_2 : BC13_3 {  }
-public abstract record BC13_1 : BC13_2 {  }
-public sealed partial record VC13 : BC13_1, IValidatedValue<VC13, global::Probes.Build.C11ConstructedConcrete, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC13, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ConstructedConcrete value) => new VC13(value);
-}
-}
-
-// row 14
-public partial struct O14
-{
-public readonly partial record struct V14 : IValidatedValue<V14, global::System.DateOnly, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V14, global::Probes.Shapes.ShapeFault> Create(global::System.DateOnly value) => new V14(value);
-}
-}
-
-// row 15
-public partial struct O15
-{
-public readonly partial record struct V15 : IValue<global::Probes.Build.C11ConstructedByRef> { }
-public readonly partial record struct VC15 : IValue<global::Probes.Build.C11ParsesFromIn> { }
-}
-
-// row 16
-public static partial class O16
-{
-public sealed partial class P16
-{
-public interface IMark16 { int Mark(); }
-public readonly partial record struct V16 : IValue<global::Probes.Build.C11AbstractText>, IMark16 { int IMark16.Mark() => 1; }
-public readonly partial record struct VC16 : IValue<global::Probes.Build.C11ConstructedConcrete>, IMark16 { int IMark16.Mark() => 1; }
-}
-}
-
-// row 17
-public readonly partial record struct V17 : IValue<global::System.Uri> { }
-
-// row 18
-public static partial class O18
-{
-public sealed partial class P18
-{
-public abstract record B18_2 {  }
-public abstract record B18_1 : B18_2 {  }
-public sealed partial record V18 : B18_1, IValidatedValue<V18, global::Probes.Build.C11ParsesToInt, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V18, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesToInt value) => new V18(value);
-}
-public abstract record BC18_2 {  }
-public abstract record BC18_1 : BC18_2 {  }
-public sealed partial record VC18 : BC18_1, IValidatedValue<VC18, global::Probes.Build.C11ParsedShape, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC18, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsedShape value) => new VC18(value);
-}
-}
-}
-
-// row 19
-public static partial class O19
-{
-public abstract record B19_1 : System.IEquatable<B19_1> { bool System.IEquatable<B19_1>.Equals(B19_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V19 : B19_1, IValue<global::Probes.Build.C11AbstractText> { }
-public abstract record BC19_1 : System.IEquatable<BC19_1> { bool System.IEquatable<BC19_1>.Equals(BC19_1? other) => ReferenceEquals(this, other); }
-public sealed partial record VC19 : BC19_1, IValue<global::Probes.Build.C11ConstructedConcrete> { }
-}
-
-// row 20
-public partial struct O20
-{
-public interface IMark20 { int Mark(); }
-public readonly partial record struct V20 : IValidatedValue<V20, global::Probes.Build.C11ParsesByRef, global::Probes.Shapes.ShapeFault>, IMark20
-{
-    public static Result<V20, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesByRef value) => new V20(value); int IMark20.Mark() => 1;
-}
-public readonly partial record struct VC20 : IValidatedValue<VC20, global::Probes.Build.C11ParsesFromIn, global::Probes.Shapes.ShapeFault>, IMark20
-{
-    public static Result<VC20, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesFromIn value) => new VC20(value); int IMark20.Mark() => 1;
-}
-}
-
-// row 21
-public static partial class O21
-{
-public readonly partial record struct V21 : IValidatedValue<V21, global::System.DateTimeOffset, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V21, global::Probes.Shapes.ShapeFault> Create(global::System.DateTimeOffset value) => new V21(value);
-}
-}
-
-// row 22
-public static partial class O22
-{
-public sealed partial class P22
-{
-public interface IMark22 { int Mark(); }
-public readonly partial record struct V22 : IValue<global::Probes.Build.C11ParsesToInt>, IMark22 { int IMark22.Mark() => 1; }
-public readonly partial record struct VC22 : IValue<global::Probes.Build.C11ParsedShape>, IMark22 { int IMark22.Mark() => 1; }
-}
-}
-
-// row 23
-public static partial class O23
-{
-public sealed partial class P23
-{
-public abstract record B23_3 {  }
-public abstract record B23_2 : B23_3 {  }
-public abstract record B23_1 : B23_2 {  }
-public sealed partial record V23 : B23_1, IValue<byte> { }
-}
-}
-
-// row 24
-public static partial class O24
-{
-public readonly partial record struct V24 : IValidatedValue<V24, global::Probes.Build.C11ParsesToInt, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V24, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesToInt value) => new V24(value);
-}
-public readonly partial record struct VC24 : IValidatedValue<VC24, global::Probes.Build.C11ParsedShape, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC24, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsedShape value) => new VC24(value);
-}
-}
-
-// row 25
-public interface IMark25 { int Mark(); }
-public readonly partial record struct V25 : IValidatedValue<V25, global::Probes.Build.C11AbstractText, global::Probes.Shapes.ShapeFault>, IMark25
-{
-    public static Result<V25, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11AbstractText value) => new V25(value); int IMark25.Mark() => 1;
-}
-public readonly partial record struct VC25 : IValidatedValue<VC25, global::Probes.Build.C11ConstructedConcrete, global::Probes.Shapes.ShapeFault>, IMark25
-{
-    public static Result<VC25, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ConstructedConcrete value) => new VC25(value); int IMark25.Mark() => 1;
-}
-
-// row 26
-public partial struct O26
-{
-public abstract record B26_1 : System.IEquatable<B26_1> { bool System.IEquatable<B26_1>.Equals(B26_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V26 : B26_1, IValidatedValue<V26, global::Probes.Build.C11ParsesByRef, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V26, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesByRef value) => new V26(value);
-}
-public abstract record BC26_1 : System.IEquatable<BC26_1> { bool System.IEquatable<BC26_1>.Equals(BC26_1? other) => ReferenceEquals(this, other); }
-public sealed partial record VC26 : BC26_1, IValidatedValue<VC26, global::Probes.Build.C11ParsesFromIn, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC26, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesFromIn value) => new VC26(value);
-}
-}
-
-// row 27
-public static partial class O27
-{
-public readonly partial record struct V27 : IValidatedValue<V27, global::Probes.Build.C11ParsesToInt, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V27, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesToInt value) => new V27(value);
-}
-public readonly partial record struct VC27 : IValidatedValue<VC27, global::Probes.Build.C11ParsedShape, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC27, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsedShape value) => new VC27(value);
-}
-}
-
-// row 28
-public readonly partial record struct V28 : IValidatedValue<V28, global::Probes.Build.C11ParsesByRef, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V28, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesByRef value) => new V28(value);
-}
-public readonly partial record struct VC28 : IValidatedValue<VC28, global::Probes.Build.C11ParsesFromIn, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC28, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesFromIn value) => new VC28(value);
-}
-
-// row 29
-public partial struct O29
-{
-public interface IMark29 { int Mark(); }
-public sealed partial record V29 : IValidatedValue<V29, global::Probes.Build.C11ConstructedByRef, global::Probes.Shapes.ShapeFault>, IMark29
-{
-    public static Result<V29, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ConstructedByRef value) => new V29(value); int IMark29.Mark() => 1;
-}
-public sealed partial record VC29 : IValidatedValue<VC29, global::Probes.Build.C11ParsesFromIn, global::Probes.Shapes.ShapeFault>, IMark29
-{
-    public static Result<VC29, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesFromIn value) => new VC29(value); int IMark29.Mark() => 1;
-}
-}
-
-// row 30
-public abstract record B30_2 {  }
-public abstract record B30_1 : B30_2 {  }
-public sealed partial record V30 : B30_1, IValue<global::Probes.Build.C11ParsesByRef> { }
-public abstract record BC30_2 {  }
-public abstract record BC30_1 : BC30_2 {  }
-public sealed partial record VC30 : BC30_1, IValue<global::Probes.Build.C11ParsesFromIn> { }
-
-// row 31
-public static partial class O31
-{
-public readonly partial record struct V31 : IValidatedValue<V31, global::Probes.Build.C11ParsesToInt, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V31, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesToInt value) => new V31(value);
-}
-public readonly partial record struct VC31 : IValidatedValue<VC31, global::Probes.Build.C11ParsedShape, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC31, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsedShape value) => new VC31(value);
-}
-}
-
-// row 32
-public partial struct O32
-{
-public sealed partial record V32 : IValue<global::Probes.Build.C11AbstractText> { }
-public sealed partial record VC32 : IValue<global::Probes.Build.C11ConstructedConcrete> { }
-}
-
-// row 33
-public static partial class O33
-{
-public abstract record B33_1 {  }
-public sealed partial record V33 : B33_1, IValidatedValue<V33, long, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V33, global::Probes.Shapes.ShapeFault> Create(long value) => new V33(value);
-}
-}
-
-// row 34
-public abstract record B34_3 {  }
-public abstract record B34_2 : B34_3 {  }
-public abstract record B34_1 : B34_2 {  }
-public sealed partial record V34 : B34_1, IValue<global::Probes.Build.C11ParsesToInt> { }
-public abstract record BC34_3 {  }
-public abstract record BC34_2 : BC34_3 {  }
-public abstract record BC34_1 : BC34_2 {  }
-public sealed partial record VC34 : BC34_1, IValue<global::Probes.Build.C11ParsedShape> { }
-
-// row 35
-public abstract record B35_2 {  }
-public abstract record B35_1 : B35_2 {  }
-public sealed partial record V35 : B35_1, IValue<int> { }
-
-// row 36
-public partial struct O36
-{
-public abstract record B36_2 {  }
-public abstract record B36_1 : B36_2 {  }
-public sealed partial record V36 : B36_1, IValue<global::Probes.Build.C11AbstractText> { }
-public abstract record BC36_2 {  }
-public abstract record BC36_1 : BC36_2 {  }
-public sealed partial record VC36 : BC36_1, IValue<global::Probes.Build.C11ConstructedConcrete> { }
-}
-
-// row 37
-public static partial class O37
-{
-public sealed partial class P37
-{
-public sealed partial record V37 : IValue<char> { }
-}
-}
-
-// row 38
-public partial struct O38
-{
-public abstract record B38_2 {  }
-public abstract record B38_1 : B38_2 {  }
-public sealed partial record V38 : B38_1, IValidatedValue<V38, global::Probes.Build.C11ParsesByRef, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V38, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesByRef value) => new V38(value);
-}
-public abstract record BC38_2 {  }
-public abstract record BC38_1 : BC38_2 {  }
-public sealed partial record VC38 : BC38_1, IValidatedValue<VC38, global::Probes.Build.C11ParsesFromIn, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC38, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesFromIn value) => new VC38(value);
-}
-}
-
-// row 39
-public partial struct O39
-{
-public abstract record B39_3 {  }
-public abstract record B39_2 : B39_3 {  }
-public abstract record B39_1 : B39_2 {  }
-public sealed partial record V39 : B39_1, IValue<global::Probes.Shapes.PEnum> { }
-}
-
-// row 40
-public partial struct O40
-{
-public readonly partial record struct V40 : IValidatedValue<V40, global::Probes.Build.C11ParsesToInt, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V40, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesToInt value) => new V40(value);
-}
-public readonly partial record struct VC40 : IValidatedValue<VC40, global::Probes.Build.C11ParsedShape, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC40, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsedShape value) => new VC40(value);
-}
-}
-
-// row 41
-public partial struct O41
-{
-public abstract record B41_1 : System.IEquatable<B41_1> { bool System.IEquatable<B41_1>.Equals(B41_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V41 : B41_1, IValue<global::Probes.Shapes.PRec> { }
-}
-
-// row 42
-public static partial class O42
-{
-public sealed partial class P42
-{
-public abstract record B42_1 : System.IEquatable<B42_1> { bool System.IEquatable<B42_1>.Equals(B42_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V42 : B42_1, IValue<global::System.Guid> { }
-}
-}
-
-// row 43
-public partial struct O43
-{
-public readonly partial record struct V43 : IValue<global::Probes.Build.C11AbstractText> { }
-public readonly partial record struct VC43 : IValue<global::Probes.Build.C11ConstructedConcrete> { }
-}
-
-// row 44
-public static partial class O44
-{
-public sealed partial class P44
-{
-public readonly partial record struct V44 : IValue<global::Probes.Build.C11ParsesByRef> { }
-public readonly partial record struct VC44 : IValue<global::Probes.Build.C11ParsesFromIn> { }
-}
-}
-
-// row 45
-public readonly partial record struct V45 : IValidatedValue<V45, global::Probes.Build.C11ConstructedByRef, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V45, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ConstructedByRef value) => new V45(value);
-}
-public readonly partial record struct VC45 : IValidatedValue<VC45, global::Probes.Build.C11ParsesFromIn, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC45, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesFromIn value) => new VC45(value);
-}
-
-// row 46
-public static partial class O46
-{
-public readonly partial record struct V46 : IValidatedValue<V46, global::Probes.Shapes.PFlags, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V46, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PFlags value) => new V46(value);
-}
-}
-
-// row 47
-public static partial class O47
-{
-public readonly partial record struct V47 : IValidatedValue<V47, int, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V47, global::Probes.Shapes.ShapeFault> Create(int value) => new V47(value);
-}
-}
-
-// row 48
-public static partial class O48
-{
-public readonly partial record struct V48 : IValue<global::Probes.Build.C11AbstractText> { }
-public readonly partial record struct VC48 : IValue<global::Probes.Build.C11ConstructedConcrete> { }
-}
-
-// row 49
-public static partial class O49
-{
-public abstract record B49_1 : System.IEquatable<B49_1> { bool System.IEquatable<B49_1>.Equals(B49_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V49 : B49_1, IValidatedValue<V49, bool, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V49, global::Probes.Shapes.ShapeFault> Create(bool value) => new V49(value);
-}
-}
-
-// row 50
-public abstract record B50_1 : System.IEquatable<B50_1> { bool System.IEquatable<B50_1>.Equals(B50_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V50 : B50_1, IValue<global::Probes.Build.C11ParsesByRef> { }
-public abstract record BC50_1 : System.IEquatable<BC50_1> { bool System.IEquatable<BC50_1>.Equals(BC50_1? other) => ReferenceEquals(this, other); }
-public sealed partial record VC50 : BC50_1, IValue<global::Probes.Build.C11ParsesFromIn> { }
-
-// row 51
-public static partial class O51
-{
-public abstract record B51_3 {  }
-public abstract record B51_2 : B51_3 {  }
-public abstract record B51_1 : B51_2 {  }
-public sealed partial record V51 : B51_1, IValidatedValue<V51, global::System.DateOnly, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V51, global::Probes.Shapes.ShapeFault> Create(global::System.DateOnly value) => new V51(value);
-}
-}
-
-// row 52
-public partial struct O52
-{
-public sealed partial record V52 : IValue<ulong> { }
-}
-
-// row 53
-public static partial class O53
-{
-public sealed partial class P53
-{
-public abstract record B53_3 {  }
-public abstract record B53_2 : B53_3 {  }
-public abstract record B53_1 : B53_2 {  }
-public sealed partial record V53 : B53_1, IValidatedValue<V53, string, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V53, global::Probes.Shapes.ShapeFault> Create(string value) => new V53(value);
-}
-}
-}
-
-// row 54
-public static partial class O54
-{
-public sealed partial class P54
-{
-public abstract record B54_3 {  }
-public abstract record B54_2 : B54_3 {  }
-public abstract record B54_1 : B54_2 {  }
-public sealed partial record V54 : B54_1, IValidatedValue<V54, global::Probes.Build.C11AbstractText, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V54, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11AbstractText value) => new V54(value);
-}
-public abstract record BC54_3 {  }
-public abstract record BC54_2 : BC54_3 {  }
-public abstract record BC54_1 : BC54_2 {  }
-public sealed partial record VC54 : BC54_1, IValidatedValue<VC54, global::Probes.Build.C11ConstructedConcrete, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC54, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ConstructedConcrete value) => new VC54(value);
-}
-}
-}
-
-// row 55
-public static partial class O55
-{
-public sealed partial class P55
-{
-public abstract record B55_1 {  }
-public sealed partial record V55 : B55_1, IValue<global::System.TimeSpan> { }
-}
-}
-
-// row 56
-public static partial class O56
-{
-public sealed partial class P56
-{
-public abstract record B56_1 {  }
-public sealed partial record V56 : B56_1, IValidatedValue<V56, decimal, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V56, global::Probes.Shapes.ShapeFault> Create(decimal value) => new V56(value);
-}
-}
-}
-
-// row 57
-public abstract record B57_1 {  }
-public sealed partial record V57 : B57_1, IValidatedValue<V57, global::Probes.Shapes.PEnum, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V57, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PEnum value) => new V57(value);
-}
-
-// row 58
-public readonly partial record struct V58 : IValue<byte> { }
-
-// row 59
-public static partial class O59
-{
-public sealed partial class P59
-{
-public abstract record B59_3 {  }
-public abstract record B59_2 : B59_3 {  }
-public abstract record B59_1 : B59_2 {  }
-public sealed partial record V59 : B59_1, IValidatedValue<V59, double, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V59, global::Probes.Shapes.ShapeFault> Create(double value) => new V59(value);
-}
-}
-}
-
-// row 60
-public static partial class O60
-{
-public interface IMark60 { int Mark(); }
-public sealed partial record V60 : IValue<global::System.TimeOnly>, IMark60 { int IMark60.Mark() => 1; }
-}
-
-// row 61
-public partial struct O61
-{
-public abstract record B61_1 {  }
-public sealed partial record V61 : B61_1, IValue<global::Probes.Build.C11ParsesToInt> { }
-public abstract record BC61_1 {  }
-public sealed partial record VC61 : BC61_1, IValue<global::Probes.Build.C11ParsedShape> { }
-}
-
-// row 62
-public static partial class O62
-{
-public sealed partial class P62
-{
-public readonly partial record struct V62 : IValidatedValue<V62, global::System.DateTime, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V62, global::Probes.Shapes.ShapeFault> Create(global::System.DateTime value) => new V62(value);
-}
-}
-}
-
-// row 63
-public interface IMark63 { int Mark(); }
-public readonly partial record struct V63 : IValue<global::NodaTime.Instant>, IMark63 { int IMark63.Mark() => 1; }
-
-// row 64
-public static partial class O64
-{
-public readonly partial record struct V64 : IValidatedValue<V64, global::Probes.Shapes.PEnum, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V64, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PEnum value) => new V64(value);
-}
-}
-
-// row 65
-public abstract record B65_2 {  }
-public abstract record B65_1 : B65_2 {  }
-public sealed partial record V65 : B65_1, IValidatedValue<V65, global::System.Guid, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V65, global::Probes.Shapes.ShapeFault> Create(global::System.Guid value) => new V65(value);
-}
-
-// row 66
-public abstract record B66_1 : System.IEquatable<B66_1> { bool System.IEquatable<B66_1>.Equals(B66_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V66 : B66_1, IValidatedValue<V66, global::Probes.Shapes.PRec, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V66, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PRec value) => new V66(value);
-}
-
-// row 67
-public static partial class O67
-{
-public sealed partial class P67
-{
-public readonly partial record struct V67 : IValidatedValue<V67, global::Probes.Build.C11AbstractText, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V67, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11AbstractText value) => new V67(value);
-}
-public readonly partial record struct VC67 : IValidatedValue<VC67, global::Probes.Build.C11ConstructedConcrete, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC67, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ConstructedConcrete value) => new VC67(value);
-}
-}
-}
-
-// row 68
-public static partial class O68
-{
-public sealed partial class P68
-{
-public readonly partial record struct V68 : IValue<global::System.DateOnly> { }
-}
-}
-
-// row 69
-public partial struct O69
-{
-public interface IMark69 { int Mark(); }
-public readonly partial record struct V69 : IValidatedValue<V69, long, global::Probes.Shapes.ShapeFault>, IMark69
-{
-    public static Result<V69, global::Probes.Shapes.ShapeFault> Create(long value) => new V69(value); int IMark69.Mark() => 1;
-}
-}
-
-// row 70
-public static partial class O70
-{
-public sealed partial class P70
-{
-public interface IMark70 { int Mark(); }
-public readonly partial record struct V70 : IValue<global::System.DateTimeOffset>, IMark70 { int IMark70.Mark() => 1; }
-}
-}
-
-// row 71
-public static partial class O71
-{
-public sealed partial class P71
-{
-public readonly partial record struct V71 : IValue<global::Probes.Shapes.PFlags> { }
-}
-}
-
-// row 72
-public partial struct O72
-{
-public readonly partial record struct V72 : IValue<double> { }
-}
-
-// row 73
-public static partial class O73
-{
-public interface IMark73 { int Mark(); }
-public readonly partial record struct V73 : IValidatedValue<V73, global::Probes.Build.C11ConstructedByRef, global::Probes.Shapes.ShapeFault>, IMark73
-{
-    public static Result<V73, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ConstructedByRef value) => new V73(value); int IMark73.Mark() => 1;
-}
-public readonly partial record struct VC73 : IValidatedValue<VC73, global::Probes.Build.C11ParsesFromIn, global::Probes.Shapes.ShapeFault>, IMark73
-{
-    public static Result<VC73, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesFromIn value) => new VC73(value); int IMark73.Mark() => 1;
-}
-}
-
-// row 74
-public static partial class O74
-{
-public readonly partial record struct V74 : IValue<char> { }
-}
-
-// row 75
-public partial struct O75
-{
-public abstract record B75_1 {  }
-public sealed partial record V75 : B75_1, IValidatedValue<V75, int, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V75, global::Probes.Shapes.ShapeFault> Create(int value) => new V75(value);
-}
-}
-
-// row 76
-public static partial class O76
-{
-public interface IMark76 { int Mark(); }
-public sealed partial record V76 : IValue<global::System.Uri>, IMark76 { int IMark76.Mark() => 1; }
-}
-
-// row 77
-public readonly partial record struct V77 : IValue<global::Probes.Build.C11AbstractText> { }
-public readonly partial record struct VC77 : IValue<global::Probes.Build.C11ConstructedConcrete> { }
-
-// row 78
-public static partial class O78
-{
-public sealed partial class P78
-{
-public readonly partial record struct V78 : IValue<global::Probes.Build.C11ParsesToInt> { }
-public readonly partial record struct VC78 : IValue<global::Probes.Build.C11ParsedShape> { }
-}
-}
-
-// row 79
-public abstract record B79_1 : System.IEquatable<B79_1> { bool System.IEquatable<B79_1>.Equals(B79_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V79 : B79_1, IValue<global::Probes.Build.C11ParsesToInt> { }
-public abstract record BC79_1 : System.IEquatable<BC79_1> { bool System.IEquatable<BC79_1>.Equals(BC79_1? other) => ReferenceEquals(this, other); }
-public sealed partial record VC79 : BC79_1, IValue<global::Probes.Build.C11ParsedShape> { }
-
-// row 80
-public static partial class O80
-{
-public readonly partial record struct V80 : IValidatedValue<V80, global::NodaTime.Instant, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V80, global::Probes.Shapes.ShapeFault> Create(global::NodaTime.Instant value) => new V80(value);
-}
-}
-
-// row 81
-public static partial class O81
-{
-public abstract record B81_1 : System.IEquatable<B81_1> { bool System.IEquatable<B81_1>.Equals(B81_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V81 : B81_1, IValue<global::Probes.Build.C11AbstractText> { }
-public abstract record BC81_1 : System.IEquatable<BC81_1> { bool System.IEquatable<BC81_1>.Equals(BC81_1? other) => ReferenceEquals(this, other); }
-public sealed partial record VC81 : BC81_1, IValue<global::Probes.Build.C11ConstructedConcrete> { }
-}
-
-// row 82
-public static partial class O82
-{
-public sealed partial class P82
-{
-public interface IMark82 { int Mark(); }
-public readonly partial record struct V82 : IValue<global::System.DateTime>, IMark82 { int IMark82.Mark() => 1; }
-}
-}
-
-// row 83
-public abstract record B83_2 {  }
-public abstract record B83_1 : B83_2 {  }
-public sealed partial record V83 : B83_1, IValidatedValue<V83, string, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V83, global::Probes.Shapes.ShapeFault> Create(string value) => new V83(value);
-}
-
-// row 84
-public static partial class O84
-{
-public abstract record B84_2 {  }
-public abstract record B84_1 : B84_2 {  }
-public sealed partial record V84 : B84_1, IValidatedValue<V84, long, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V84, global::Probes.Shapes.ShapeFault> Create(long value) => new V84(value);
-}
-}
-
-// row 85
-public partial struct O85
-{
-public abstract record B85_1 : System.IEquatable<B85_1> { bool System.IEquatable<B85_1>.Equals(B85_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V85 : B85_1, IValue<global::System.TimeOnly> { }
-}
-
-// row 86
-public static partial class O86
-{
-public sealed partial class P86
-{
-public abstract record B86_2 {  }
-public abstract record B86_1 : B86_2 {  }
-public sealed partial record V86 : B86_1, IValue<global::Probes.Build.C11ParsesToInt> { }
-public abstract record BC86_2 {  }
-public abstract record BC86_1 : BC86_2 {  }
-public sealed partial record VC86 : BC86_1, IValue<global::Probes.Build.C11ParsedShape> { }
-}
-}
-
-// row 87
-public static partial class O87
-{
-public sealed partial class P87
-{
-public sealed partial record V87 : IValue<int> { }
-}
-}
-
-// row 88
-public sealed partial record V88 : IValue<global::Probes.Build.C11AbstractText> { }
-public sealed partial record VC88 : IValue<global::Probes.Build.C11ConstructedConcrete> { }
-
-// row 89
-public abstract record B89_2 {  }
-public abstract record B89_1 : B89_2 {  }
-public sealed partial record V89 : B89_1, IValidatedValue<V89, ulong, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V89, global::Probes.Shapes.ShapeFault> Create(ulong value) => new V89(value);
-}
-
-// row 90
-public readonly partial record struct V90 : IValue<global::NodaTime.Instant> { }
-
-// row 91
-public static partial class O91
-{
-public sealed partial class P91
-{
-public abstract record B91_1 {  }
-public sealed partial record V91 : B91_1, IValue<global::Probes.Build.C11ParsesToInt> { }
-public abstract record BC91_1 {  }
-public sealed partial record VC91 : BC91_1, IValue<global::Probes.Build.C11ParsedShape> { }
-}
-}
-
-// row 92
-public static partial class O92
-{
-public abstract record B92_2 {  }
-public abstract record B92_1 : B92_2 {  }
-public sealed partial record V92 : B92_1, IValidatedValue<V92, global::System.TimeSpan, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V92, global::Probes.Shapes.ShapeFault> Create(global::System.TimeSpan value) => new V92(value);
-}
-}
-
-// row 93
-public abstract record B93_3 {  }
-public abstract record B93_2 : B93_3 {  }
-public abstract record B93_1 : B93_2 {  }
-public sealed partial record V93 : B93_1, IValue<decimal> { }
-
-// row 94
-public partial struct O94
-{
-public abstract record B94_2 {  }
-public abstract record B94_1 : B94_2 {  }
-public sealed partial record V94 : B94_1, IValue<global::System.Uri> { }
-}
-
-// row 95
-public abstract record B95_3 {  }
-public abstract record B95_2 : B95_3 {  }
-public abstract record B95_1 : B95_2 {  }
-public sealed partial record V95 : B95_1, IValidatedValue<V95, char, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V95, global::Probes.Shapes.ShapeFault> Create(char value) => new V95(value);
-}
-
-// row 96
-public partial struct O96
-{
-public abstract record B96_3 {  }
-public abstract record B96_2 : B96_3 {  }
-public abstract record B96_1 : B96_2 {  }
-public sealed partial record V96 : B96_1, IValidatedValue<V96, global::Probes.Shapes.PRec, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V96, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PRec value) => new V96(value);
-}
-}
-
-// row 97
-public abstract record B97_1 {  }
-public sealed partial record V97 : B97_1, IValidatedValue<V97, global::Probes.Shapes.PFlags, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V97, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PFlags value) => new V97(value);
-}
-
-// row 98
-public abstract record B98_2 {  }
-public abstract record B98_1 : B98_2 {  }
-public sealed partial record V98 : B98_1, IValue<global::Probes.Shapes.PEnum> { }
-
-// row 99
-public interface IMark99 { int Mark(); }
-public readonly partial record struct V99 : IValidatedValue<V99, string, global::Probes.Shapes.ShapeFault>, IMark99
-{
-    public static Result<V99, global::Probes.Shapes.ShapeFault> Create(string value) => new V99(value); int IMark99.Mark() => 1;
-}
-
-// row 100
-public abstract record B100_1 {  }
-public sealed partial record V100 : B100_1, IValidatedValue<V100, global::Probes.Build.C11ParsesToInt, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V100, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesToInt value) => new V100(value);
-}
-public abstract record BC100_1 {  }
-public sealed partial record VC100 : BC100_1, IValidatedValue<VC100, global::Probes.Build.C11ParsedShape, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC100, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsedShape value) => new VC100(value);
-}
-
-// row 101
-public static partial class O101
-{
-public interface IMark101 { int Mark(); }
-public readonly partial record struct V101 : IValidatedValue<V101, global::System.DateOnly, global::Probes.Shapes.ShapeFault>, IMark101
-{
-    public static Result<V101, global::Probes.Shapes.ShapeFault> Create(global::System.DateOnly value) => new V101(value); int IMark101.Mark() => 1;
-}
-}
-
-// row 102
-public static partial class O102
-{
-public sealed partial class P102
-{
-public interface IMark102 { int Mark(); }
-public sealed partial record V102 : IValue<bool>, IMark102 { int IMark102.Mark() => 1; }
-}
-}
-
-// row 103
-public readonly partial record struct V103 : IValidatedValue<V103, global::Probes.Build.C11ParsesToInt, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V103, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesToInt value) => new V103(value);
-}
-public readonly partial record struct VC103 : IValidatedValue<VC103, global::Probes.Build.C11ParsedShape, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC103, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsedShape value) => new VC103(value);
-}
-
-// row 104
-public static partial class O104
-{
-public sealed partial class P104
-{
-public readonly partial record struct V104 : IValue<global::System.TimeSpan> { }
-}
-}
-
-// row 105
-public interface IMark105 { int Mark(); }
-public readonly partial record struct V105 : IValue<global::Probes.Shapes.PRec>, IMark105 { int IMark105.Mark() => 1; }
-
-// row 106
-public static partial class O106
-{
-public sealed partial class P106
-{
-public abstract record B106_1 : System.IEquatable<B106_1> { bool System.IEquatable<B106_1>.Equals(B106_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V106 : B106_1, IValue<global::Probes.Build.C11ParsesToInt> { }
-public abstract record BC106_1 : System.IEquatable<BC106_1> { bool System.IEquatable<BC106_1>.Equals(BC106_1? other) => ReferenceEquals(this, other); }
-public sealed partial record VC106 : BC106_1, IValue<global::Probes.Build.C11ParsedShape> { }
-}
-}
-
-// row 107
-public static partial class O107
-{
-public sealed partial class P107
-{
-public readonly partial record struct V107 : IValue<global::Probes.Build.C11ParsesToInt> { }
-public readonly partial record struct VC107 : IValue<global::Probes.Build.C11ParsedShape> { }
-}
-}
-
-// row 108
-public static partial class O108
-{
-public sealed partial class P108
-{
-public readonly partial record struct V108 : IValidatedValue<V108, bool, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V108, global::Probes.Shapes.ShapeFault> Create(bool value) => new V108(value);
-}
-}
-}
-
-// row 109
-public static partial class O109
-{
-public abstract record B109_2 {  }
-public abstract record B109_1 : B109_2 {  }
-public sealed partial record V109 : B109_1, IValidatedValue<V109, global::Probes.Build.C11ConstructedByRef, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V109, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ConstructedByRef value) => new V109(value);
-}
-public abstract record BC109_2 {  }
-public abstract record BC109_1 : BC109_2 {  }
-public sealed partial record VC109 : BC109_1, IValidatedValue<VC109, global::Probes.Build.C11ParsesFromIn, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC109, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesFromIn value) => new VC109(value);
-}
-}
-
-// row 110
-public static partial class O110
-{
-public sealed partial class P110
-{
-public abstract record B110_1 : System.IEquatable<B110_1> { bool System.IEquatable<B110_1>.Equals(B110_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V110 : B110_1, IValue<global::System.Uri> { }
-}
-}
-
-// row 111
-public static partial class O111
-{
-public readonly partial record struct V111 : IValue<global::Probes.Build.C11ParsesToInt> { }
-public readonly partial record struct VC111 : IValue<global::Probes.Build.C11ParsedShape> { }
-}
-
-// row 112
-public partial struct O112
-{
-public interface IMark112 { int Mark(); }
-public readonly partial record struct V112 : IValidatedValue<V112, int, global::Probes.Shapes.ShapeFault>, IMark112
-{
-    public static Result<V112, global::Probes.Shapes.ShapeFault> Create(int value) => new V112(value); int IMark112.Mark() => 1;
-}
-}
-
-// row 113
-public partial struct O113
-{
-public abstract record B113_3 {  }
-public abstract record B113_2 : B113_3 {  }
-public abstract record B113_1 : B113_2 {  }
-public sealed partial record V113 : B113_1, IValue<ulong> { }
-}
-
-// row 114
-public partial struct O114
-{
-public abstract record B114_2 {  }
-public abstract record B114_1 : B114_2 {  }
-public sealed partial record V114 : B114_1, IValidatedValue<V114, double, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V114, global::Probes.Shapes.ShapeFault> Create(double value) => new V114(value);
-}
-}
-
-// row 115
-public static partial class O115
-{
-public readonly partial record struct V115 : IValidatedValue<V115, global::System.DateTime, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V115, global::Probes.Shapes.ShapeFault> Create(global::System.DateTime value) => new V115(value);
-}
-}
-
-// row 116
-public static partial class O116
-{
-public abstract record B116_2 {  }
-public abstract record B116_1 : B116_2 {  }
-public sealed partial record V116 : B116_1, IValue<char> { }
-}
-
-// row 117
-public static partial class O117
-{
-public abstract record B117_1 {  }
-public sealed partial record V117 : B117_1, IValue<global::Probes.Build.C11ParsesToInt> { }
-public abstract record BC117_1 {  }
-public sealed partial record VC117 : BC117_1, IValue<global::Probes.Build.C11ParsedShape> { }
-}
-
-// row 118
-public partial struct O118
-{
-public abstract record B118_1 : System.IEquatable<B118_1> { bool System.IEquatable<B118_1>.Equals(B118_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V118 : B118_1, IValue<char> { }
-}
-
-// row 119
-public static partial class O119
-{
-public sealed partial class P119
-{
-public abstract record B119_1 {  }
-public sealed partial record V119 : B119_1, IValue<global::System.Guid> { }
-}
-}
-
-// row 120
-public partial struct O120
-{
-public abstract record B120_2 {  }
-public abstract record B120_1 : B120_2 {  }
-public sealed partial record V120 : B120_1, IValidatedValue<V120, global::NodaTime.Instant, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V120, global::Probes.Shapes.ShapeFault> Create(global::NodaTime.Instant value) => new V120(value);
-}
-}
-
-// row 121
-public abstract record B121_3 {  }
-public abstract record B121_2 : B121_3 {  }
-public abstract record B121_1 : B121_2 {  }
-public sealed partial record V121 : B121_1, IValue<global::Probes.Build.C11AbstractText> { }
-public abstract record BC121_3 {  }
-public abstract record BC121_2 : BC121_3 {  }
-public abstract record BC121_1 : BC121_2 {  }
-public sealed partial record VC121 : BC121_1, IValue<global::Probes.Build.C11ConstructedConcrete> { }
-
-// row 122
-public static partial class O122
-{
-public readonly partial record struct V122 : IValue<long> { }
-}
-
-// row 123
-public partial struct O123
-{
-public interface IMark123 { int Mark(); }
-public sealed partial record V123 : IValue<global::Probes.Build.C11ConstructedByRef>, IMark123 { int IMark123.Mark() => 1; }
-public sealed partial record VC123 : IValue<global::Probes.Build.C11ParsesFromIn>, IMark123 { int IMark123.Mark() => 1; }
-}
-
-// row 124
-public partial struct O124
-{
-public readonly partial record struct V124 : IValidatedValue<V124, global::Probes.Build.C11ParsesByRef, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V124, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesByRef value) => new V124(value);
-}
-public readonly partial record struct VC124 : IValidatedValue<VC124, global::Probes.Build.C11ParsesFromIn, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC124, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesFromIn value) => new VC124(value);
-}
-}
-
-// row 125
-public static partial class O125
-{
-public interface IMark125 { int Mark(); }
-public readonly partial record struct V125 : IValidatedValue<V125, global::System.Uri, global::Probes.Shapes.ShapeFault>, IMark125
-{
-    public static Result<V125, global::Probes.Shapes.ShapeFault> Create(global::System.Uri value) => new V125(value); int IMark125.Mark() => 1;
-}
-}
-
-// row 126
-public static partial class O126
-{
-public sealed partial class P126
-{
-public abstract record B126_1 : System.IEquatable<B126_1> { bool System.IEquatable<B126_1>.Equals(B126_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V126 : B126_1, IValidatedValue<V126, decimal, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V126, global::Probes.Shapes.ShapeFault> Create(decimal value) => new V126(value);
-}
-}
-}
-
-// row 127
-public static partial class O127
-{
-public abstract record B127_1 : System.IEquatable<B127_1> { bool System.IEquatable<B127_1>.Equals(B127_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V127 : B127_1, IValue<global::NodaTime.Instant> { }
-}
-
-// row 128
-public static partial class O128
-{
-public abstract record B128_1 : System.IEquatable<B128_1> { bool System.IEquatable<B128_1>.Equals(B128_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V128 : B128_1, IValidatedValue<V128, global::System.DateTime, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V128, global::Probes.Shapes.ShapeFault> Create(global::System.DateTime value) => new V128(value);
-}
-}
-
-// row 129
-public readonly partial record struct V129 : IValidatedValue<V129, global::Probes.Build.C11ConstructedByRef, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V129, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ConstructedByRef value) => new V129(value);
-}
-public readonly partial record struct VC129 : IValidatedValue<VC129, global::Probes.Build.C11ParsesFromIn, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC129, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesFromIn value) => new VC129(value);
-}
-
-// row 130
-public static partial class O130
-{
-public interface IMark130 { int Mark(); }
-public readonly partial record struct V130 : IValue<char>, IMark130 { int IMark130.Mark() => 1; }
-}
-
-// row 131
-public partial struct O131
-{
-public interface IMark131 { int Mark(); }
-public readonly partial record struct V131 : IValue<long>, IMark131 { int IMark131.Mark() => 1; }
-}
-
-// row 132
-public interface IMark132 { int Mark(); }
-public readonly partial record struct V132 : IValidatedValue<V132, global::Probes.Build.C11AbstractText, global::Probes.Shapes.ShapeFault>, IMark132
-{
-    public static Result<V132, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11AbstractText value) => new V132(value); int IMark132.Mark() => 1;
-}
-public readonly partial record struct VC132 : IValidatedValue<VC132, global::Probes.Build.C11ConstructedConcrete, global::Probes.Shapes.ShapeFault>, IMark132
-{
-    public static Result<VC132, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ConstructedConcrete value) => new VC132(value); int IMark132.Mark() => 1;
-}
-
-// row 133
-public static partial class O133
-{
-public abstract record B133_2 {  }
-public abstract record B133_1 : B133_2 {  }
-public sealed partial record V133 : B133_1, IValue<global::Probes.Shapes.PRec> { }
-}
-
-// row 134
-public abstract record B134_2 {  }
-public abstract record B134_1 : B134_2 {  }
-public sealed partial record V134 : B134_1, IValidatedValue<V134, global::Probes.Build.C11ParsesByRef, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V134, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesByRef value) => new V134(value);
-}
-public abstract record BC134_2 {  }
-public abstract record BC134_1 : BC134_2 {  }
-public sealed partial record VC134 : BC134_1, IValidatedValue<VC134, global::Probes.Build.C11ParsesFromIn, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC134, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesFromIn value) => new VC134(value);
-}
-
-// row 135
-public partial struct O135
-{
-public abstract record B135_3 {  }
-public abstract record B135_2 : B135_3 {  }
-public abstract record B135_1 : B135_2 {  }
-public sealed partial record V135 : B135_1, IValue<global::System.TimeSpan> { }
-}
-
-// row 136
-public partial struct O136
-{
-public interface IMark136 { int Mark(); }
-public readonly partial record struct V136 : IValue<global::System.TimeOnly>, IMark136 { int IMark136.Mark() => 1; }
-}
-
-// row 137
-public static partial class O137
-{
-public abstract record B137_1 {  }
-public sealed partial record V137 : B137_1, IValue<global::Probes.Build.C11ParsesToInt> { }
-public abstract record BC137_1 {  }
-public sealed partial record VC137 : BC137_1, IValue<global::Probes.Build.C11ParsedShape> { }
-}
-
-// row 138
-public static partial class O138
-{
-public readonly partial record struct V138 : IValue<global::Probes.Build.C11AbstractText> { }
-public readonly partial record struct VC138 : IValue<global::Probes.Build.C11ConstructedConcrete> { }
-}
-
-// row 139
-public static partial class O139
-{
-public sealed partial class P139
-{
-public abstract record B139_1 : System.IEquatable<B139_1> { bool System.IEquatable<B139_1>.Equals(B139_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V139 : B139_1, IValue<global::Probes.Shapes.PFlags> { }
-}
-}
-
-// row 140
-public static partial class O140
-{
-public abstract record B140_2 {  }
-public abstract record B140_1 : B140_2 {  }
-public sealed partial record V140 : B140_1, IValue<bool> { }
-}
-
-// row 141
-public static partial class O141
-{
-public interface IMark141 { int Mark(); }
-public readonly partial record struct V141 : IValue<global::Probes.Build.C11AbstractText>, IMark141 { int IMark141.Mark() => 1; }
-public readonly partial record struct VC141 : IValue<global::Probes.Build.C11ConstructedConcrete>, IMark141 { int IMark141.Mark() => 1; }
-}
-
-// row 142
-public static partial class O142
-{
-public readonly partial record struct V142 : IValidatedValue<V142, global::Probes.Build.C11ParsesToInt, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V142, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesToInt value) => new V142(value);
-}
-public readonly partial record struct VC142 : IValidatedValue<VC142, global::Probes.Build.C11ParsedShape, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC142, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsedShape value) => new VC142(value);
-}
-}
-
-// row 143
-public sealed partial record V143 : IValue<global::Probes.Build.C11ConstructedByRef> { }
-public sealed partial record VC143 : IValue<global::Probes.Build.C11ParsesFromIn> { }
-
-// row 144
-public static partial class O144
-{
-public sealed partial class P144
-{
-public interface IMark144 { int Mark(); }
-public readonly partial record struct V144 : IValue<global::Probes.Build.C11AbstractText>, IMark144 { int IMark144.Mark() => 1; }
-public readonly partial record struct VC144 : IValue<global::Probes.Build.C11ConstructedConcrete>, IMark144 { int IMark144.Mark() => 1; }
-}
-}
-
-// row 145
-public static partial class O145
-{
-public sealed partial class P145
-{
-public readonly partial record struct V145 : IValidatedValue<V145, ulong, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V145, global::Probes.Shapes.ShapeFault> Create(ulong value) => new V145(value);
-}
-}
-}
-
-// row 146
-public static partial class O146
-{
-public readonly partial record struct V146 : IValidatedValue<V146, global::Probes.Build.C11ParsesToInt, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V146, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesToInt value) => new V146(value);
-}
-public readonly partial record struct VC146 : IValidatedValue<VC146, global::Probes.Build.C11ParsedShape, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC146, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsedShape value) => new VC146(value);
-}
-}
-
-// row 147
-public static partial class O147
-{
-public sealed partial class P147
-{
-public interface IMark147 { int Mark(); }
-public readonly partial record struct V147 : IValidatedValue<V147, global::Probes.Build.C11AbstractText, global::Probes.Shapes.ShapeFault>, IMark147
-{
-    public static Result<V147, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11AbstractText value) => new V147(value); int IMark147.Mark() => 1;
-}
-public readonly partial record struct VC147 : IValidatedValue<VC147, global::Probes.Build.C11ConstructedConcrete, global::Probes.Shapes.ShapeFault>, IMark147
-{
-    public static Result<VC147, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ConstructedConcrete value) => new VC147(value); int IMark147.Mark() => 1;
-}
-}
-}
-
-// row 148
-public static partial class O148
-{
-public sealed partial record V148 : IValidatedValue<V148, global::Probes.Shapes.PEnum, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V148, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PEnum value) => new V148(value);
-}
-}
-
-// row 149
-public partial struct O149
-{
-public interface IMark149 { int Mark(); }
-public sealed partial record V149 : IValue<global::Probes.Build.C11ParsesToInt>, IMark149 { int IMark149.Mark() => 1; }
-public sealed partial record VC149 : IValue<global::Probes.Build.C11ParsedShape>, IMark149 { int IMark149.Mark() => 1; }
-}
-
-// row 150
-public static partial class O150
-{
-public sealed partial class P150
-{
-public abstract record B150_3 {  }
-public abstract record B150_2 : B150_3 {  }
-public abstract record B150_1 : B150_2 {  }
-public sealed partial record V150 : B150_1, IValidatedValue<V150, decimal, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V150, global::Probes.Shapes.ShapeFault> Create(decimal value) => new V150(value);
-}
-}
-}
-
-// row 151
-public static partial class O151
-{
-public sealed partial record V151 : IValidatedValue<V151, ulong, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V151, global::Probes.Shapes.ShapeFault> Create(ulong value) => new V151(value);
-}
-}
-
-// row 152
-public static partial class O152
-{
-public interface IMark152 { int Mark(); }
-public sealed partial record V152 : IValue<global::Probes.Build.C11AbstractText>, IMark152 { int IMark152.Mark() => 1; }
-public sealed partial record VC152 : IValue<global::Probes.Build.C11ConstructedConcrete>, IMark152 { int IMark152.Mark() => 1; }
-}
-
-// row 153
-public static partial class O153
-{
-public sealed partial record V153 : IValue<global::Probes.Build.C11ParsesToInt> { }
-public sealed partial record VC153 : IValue<global::Probes.Build.C11ParsedShape> { }
-}
-
-// row 154
-public static partial class O154
-{
-public sealed partial class P154
-{
-public abstract record B154_1 : System.IEquatable<B154_1> { bool System.IEquatable<B154_1>.Equals(B154_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V154 : B154_1, IValue<global::Probes.Build.C11ParsesToInt> { }
-public abstract record BC154_1 : System.IEquatable<BC154_1> { bool System.IEquatable<BC154_1>.Equals(BC154_1? other) => ReferenceEquals(this, other); }
-public sealed partial record VC154 : BC154_1, IValue<global::Probes.Build.C11ParsedShape> { }
-}
-}
-
-// row 155
-public sealed partial record V155 : IValue<global::Probes.Build.C11ConstructedByRef> { }
-public sealed partial record VC155 : IValue<global::Probes.Build.C11ParsesFromIn> { }
-
-// row 156
-public interface IMark156 { int Mark(); }
-public readonly partial record struct V156 : IValidatedValue<V156, global::System.DateTimeOffset, global::Probes.Shapes.ShapeFault>, IMark156
-{
-    public static Result<V156, global::Probes.Shapes.ShapeFault> Create(global::System.DateTimeOffset value) => new V156(value); int IMark156.Mark() => 1;
-}
-
-// row 157
-public static partial class O157
-{
-public sealed partial class P157
-{
-public abstract record B157_1 : System.IEquatable<B157_1> { bool System.IEquatable<B157_1>.Equals(B157_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V157 : B157_1, IValidatedValue<V157, global::Probes.Build.C11ParsesToInt, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V157, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesToInt value) => new V157(value);
-}
-public abstract record BC157_1 : System.IEquatable<BC157_1> { bool System.IEquatable<BC157_1>.Equals(BC157_1? other) => ReferenceEquals(this, other); }
-public sealed partial record VC157 : BC157_1, IValidatedValue<VC157, global::Probes.Build.C11ParsedShape, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC157, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsedShape value) => new VC157(value);
-}
-}
-}
-
-// row 158
-public static partial class O158
-{
-public sealed partial class P158
-{
-public abstract record B158_3 {  }
-public abstract record B158_2 : B158_3 {  }
-public abstract record B158_1 : B158_2 {  }
-public sealed partial record V158 : B158_1, IValidatedValue<V158, string, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V158, global::Probes.Shapes.ShapeFault> Create(string value) => new V158(value);
-}
-}
-}
-
-// row 159
-public static partial class O159
-{
-public sealed partial class P159
-{
-public abstract record B159_2 {  }
-public abstract record B159_1 : B159_2 {  }
-public sealed partial record V159 : B159_1, IValue<global::Probes.Shapes.PFlags> { }
-}
-}
-
-// row 160
-public partial struct O160
-{
-public interface IMark160 { int Mark(); }
-public sealed partial record V160 : IValue<decimal>, IMark160 { int IMark160.Mark() => 1; }
-}
-
-// row 161
-public static partial class O161
-{
-public readonly partial record struct V161 : IValue<global::System.Guid> { }
-}
-
-// row 162
-public partial struct O162
-{
-public abstract record B162_3 {  }
-public abstract record B162_2 : B162_3 {  }
-public abstract record B162_1 : B162_2 {  }
-public sealed partial record V162 : B162_1, IValue<global::System.DateTime> { }
-}
-
-// row 163
-public partial struct O163
-{
-public abstract record B163_1 : System.IEquatable<B163_1> { bool System.IEquatable<B163_1>.Equals(B163_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V163 : B163_1, IValue<global::System.DateTimeOffset> { }
-}
-
-// row 164
-public partial struct O164
-{
-public interface IMark164 { int Mark(); }
-public readonly partial record struct V164 : IValidatedValue<V164, byte, global::Probes.Shapes.ShapeFault>, IMark164
-{
-    public static Result<V164, global::Probes.Shapes.ShapeFault> Create(byte value) => new V164(value); int IMark164.Mark() => 1;
-}
-}
-
-// row 165
-public abstract record B165_1 : System.IEquatable<B165_1> { bool System.IEquatable<B165_1>.Equals(B165_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V165 : B165_1, IValue<global::System.DateOnly> { }
-
-// row 166
-public static partial class O166
-{
-public readonly partial record struct V166 : IValue<decimal> { }
-}
-
-// row 167
-public static partial class O167
-{
-public readonly partial record struct V167 : IValue<string> { }
-}
-
-// row 168
-public static partial class O168
-{
-public readonly partial record struct V168 : IValue<ulong> { }
-}
-
-// row 169
-public partial struct O169
-{
-public interface IMark169 { int Mark(); }
-public readonly partial record struct V169 : IValue<bool>, IMark169 { int IMark169.Mark() => 1; }
-}
-
-// row 170
-public static partial class O170
-{
-public sealed partial class P170
-{
-public readonly partial record struct V170 : IValidatedValue<V170, global::Probes.Shapes.PRec, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V170, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PRec value) => new V170(value);
-}
-}
-}
-
-// row 171
-public static partial class O171
-{
-public sealed partial record V171 : IValidatedValue<V171, byte, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V171, global::Probes.Shapes.ShapeFault> Create(byte value) => new V171(value);
-}
-}
-
-// row 172
-public static partial class O172
-{
-public sealed partial class P172
-{
-public abstract record B172_2 {  }
-public abstract record B172_1 : B172_2 {  }
-public sealed partial record V172 : B172_1, IValue<global::System.TimeOnly> { }
-}
-}
-
-// row 173
-public abstract record B173_3 {  }
-public abstract record B173_2 : B173_3 {  }
-public abstract record B173_1 : B173_2 {  }
-public sealed partial record V173 : B173_1, IValidatedValue<V173, global::System.TimeOnly, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V173, global::Probes.Shapes.ShapeFault> Create(global::System.TimeOnly value) => new V173(value);
-}
-
-// row 174
-public static partial class O174
-{
-public abstract record B174_3 {  }
-public abstract record B174_2 : B174_3 {  }
-public abstract record B174_1 : B174_2 {  }
-public sealed partial record V174 : B174_1, IValidatedValue<V174, global::System.Uri, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V174, global::Probes.Shapes.ShapeFault> Create(global::System.Uri value) => new V174(value);
-}
-}
-
-// row 175
-public partial struct O175
-{
-public readonly partial record struct V175 : IValidatedValue<V175, double, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V175, global::Probes.Shapes.ShapeFault> Create(double value) => new V175(value);
-}
-}
-
-// row 176
-public partial struct O176
-{
-public abstract record B176_1 : System.IEquatable<B176_1> { bool System.IEquatable<B176_1>.Equals(B176_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V176 : B176_1, IValue<string> { }
-}
-
-// row 177
-public static partial class O177
-{
-public abstract record B177_3 {  }
-public abstract record B177_2 : B177_3 {  }
-public abstract record B177_1 : B177_2 {  }
-public sealed partial record V177 : B177_1, IValidatedValue<V177, global::Probes.Build.C11ConstructedByRef, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V177, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ConstructedByRef value) => new V177(value);
-}
-public abstract record BC177_3 {  }
-public abstract record BC177_2 : BC177_3 {  }
-public abstract record BC177_1 : BC177_2 {  }
-public sealed partial record VC177 : BC177_1, IValidatedValue<VC177, global::Probes.Build.C11ParsesFromIn, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<VC177, global::Probes.Shapes.ShapeFault> Create(global::Probes.Build.C11ParsesFromIn value) => new VC177(value);
-}
-}
-
-// row 178
-public partial struct O178
-{
-public interface IMark178 { int Mark(); }
-public readonly partial record struct V178 : IValidatedValue<V178, global::System.Guid, global::Probes.Shapes.ShapeFault>, IMark178
-{
-    public static Result<V178, global::Probes.Shapes.ShapeFault> Create(global::System.Guid value) => new V178(value); int IMark178.Mark() => 1;
-}
-}
-
-// row 179
-public static partial class O179
-{
-public readonly partial record struct V179 : IValidatedValue<V179, global::System.TimeOnly, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V179, global::Probes.Shapes.ShapeFault> Create(global::System.TimeOnly value) => new V179(value);
-}
-}
-
-// row 180
-public static partial class O180
-{
-public sealed partial class P180
-{
-public interface IMark180 { int Mark(); }
-public readonly partial record struct V180 : IValue<global::Probes.Shapes.PEnum>, IMark180 { int IMark180.Mark() => 1; }
-}
-}
-
-// row 181
-public interface IMark181 { int Mark(); }
-public readonly partial record struct V181 : IValidatedValue<V181, global::System.TimeSpan, global::Probes.Shapes.ShapeFault>, IMark181
-{
-    public static Result<V181, global::Probes.Shapes.ShapeFault> Create(global::System.TimeSpan value) => new V181(value); int IMark181.Mark() => 1;
-}
-
-// row 182
-public static partial class O182
-{
-public readonly partial record struct V182 : IValidatedValue<V182, decimal, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V182, global::Probes.Shapes.ShapeFault> Create(decimal value) => new V182(value);
-}
-}
-
-// row 183
-public partial struct O183
-{
-public abstract record B183_3 {  }
-public abstract record B183_2 : B183_3 {  }
-public abstract record B183_1 : B183_2 {  }
-public sealed partial record V183 : B183_1, IValidatedValue<V183, global::Probes.Shapes.PFlags, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V183, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PFlags value) => new V183(value);
-}
-}
-
-// row 184
-public abstract record B184_1 {  }
-public sealed partial record V184 : B184_1, IValidatedValue<V184, global::System.DateTime, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V184, global::Probes.Shapes.ShapeFault> Create(global::System.DateTime value) => new V184(value);
-}
-
-// row 185
-public static partial class O185
-{
-public sealed partial class P185
-{
-public readonly partial record struct V185 : IValue<bool> { }
-}
-}
-
-// row 186
-public abstract record B186_3 {  }
-public abstract record B186_2 : B186_3 {  }
-public abstract record B186_1 : B186_2 {  }
-public sealed partial record V186 : B186_1, IValue<long> { }
-
-// row 187
-public static partial class O187
-{
-public abstract record B187_1 {  }
-public sealed partial record V187 : B187_1, IValidatedValue<V187, global::System.DateOnly, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V187, global::Probes.Shapes.ShapeFault> Create(global::System.DateOnly value) => new V187(value);
-}
-}
-
-// row 188
-public static partial class O188
-{
-public sealed partial class P188
-{
-public interface IMark188 { int Mark(); }
-public readonly partial record struct V188 : IValue<int>, IMark188 { int IMark188.Mark() => 1; }
-}
-}
-
-// row 189
-public static partial class O189
-{
-public sealed partial class P189
-{
-public interface IMark189 { int Mark(); }
-public sealed partial record V189 : IValidatedValue<V189, global::NodaTime.Instant, global::Probes.Shapes.ShapeFault>, IMark189
-{
-    public static Result<V189, global::Probes.Shapes.ShapeFault> Create(global::NodaTime.Instant value) => new V189(value); int IMark189.Mark() => 1;
-}
-}
-}
-
-// row 190
-public partial struct O190
-{
-public abstract record B190_3 {  }
-public abstract record B190_2 : B190_3 {  }
-public abstract record B190_1 : B190_2 {  }
-public sealed partial record V190 : B190_1, IValue<global::System.Guid> { }
-}
-
-// row 191
-public static partial class O191
-{
-public sealed partial class P191
-{
-public interface IMark191 { int Mark(); }
-public sealed partial record V191 : IValue<string>, IMark191 { int IMark191.Mark() => 1; }
-}
-}
-
-// row 192
-public abstract record B192_1 : System.IEquatable<B192_1> { bool System.IEquatable<B192_1>.Equals(B192_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V192 : B192_1, IValidatedValue<V192, ulong, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V192, global::Probes.Shapes.ShapeFault> Create(ulong value) => new V192(value);
-}
-
-// row 193
-public abstract record B193_2 {  }
-public abstract record B193_1 : B193_2 {  }
-public sealed partial record V193 : B193_1, IValue<global::System.DateOnly> { }
-
-// row 194
-public static partial class O194
-{
-public abstract record B194_2 {  }
-public abstract record B194_1 : B194_2 {  }
-public sealed partial record V194 : B194_1, IValidatedValue<V194, byte, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V194, global::Probes.Shapes.ShapeFault> Create(byte value) => new V194(value);
-}
-}
-
-// row 195
-public interface IMark195 { int Mark(); }
-public sealed partial record V195 : IValue<global::Probes.Shapes.PFlags>, IMark195 { int IMark195.Mark() => 1; }
-
-// row 196
-public abstract record B196_1 : System.IEquatable<B196_1> { bool System.IEquatable<B196_1>.Equals(B196_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V196 : B196_1, IValidatedValue<V196, double, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V196, global::Probes.Shapes.ShapeFault> Create(double value) => new V196(value);
-}
-
-// row 197
-public static partial class O197
-{
-public abstract record B197_2 {  }
-public abstract record B197_1 : B197_2 {  }
-public sealed partial record V197 : B197_1, IValue<global::System.DateTime> { }
-}
-
-// row 198
-public partial struct O198
-{
-public readonly partial record struct V198 : IValidatedValue<V198, byte, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V198, global::Probes.Shapes.ShapeFault> Create(byte value) => new V198(value);
-}
-}
-
-// row 199
-public static partial class O199
-{
-public sealed partial class P199
-{
-public interface IMark199 { int Mark(); }
-public readonly partial record struct V199 : IValidatedValue<V199, char, global::Probes.Shapes.ShapeFault>, IMark199
-{
-    public static Result<V199, global::Probes.Shapes.ShapeFault> Create(char value) => new V199(value); int IMark199.Mark() => 1;
-}
-}
-}
-
-// row 200
-public partial struct O200
-{
-public abstract record B200_1 : System.IEquatable<B200_1> { bool System.IEquatable<B200_1>.Equals(B200_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V200 : B200_1, IValue<global::Probes.Shapes.PEnum> { }
-}
-
-// row 201
-public partial struct O201
-{
-public abstract record B201_3 {  }
-public abstract record B201_2 : B201_3 {  }
-public abstract record B201_1 : B201_2 {  }
-public sealed partial record V201 : B201_1, IValue<global::System.Guid> { }
-}
-
-// row 202
-public partial struct O202
-{
-public abstract record B202_2 {  }
-public abstract record B202_1 : B202_2 {  }
-public sealed partial record V202 : B202_1, IValue<global::System.DateTimeOffset> { }
-}
-
-// row 203
-public static partial class O203
-{
-public sealed partial class P203
-{
-public abstract record B203_1 {  }
-public sealed partial record V203 : B203_1, IValue<char> { }
-}
-}
-
-// row 204
-public partial struct O204
-{
-public abstract record B204_1 {  }
-public sealed partial record V204 : B204_1, IValidatedValue<V204, global::System.TimeOnly, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V204, global::Probes.Shapes.ShapeFault> Create(global::System.TimeOnly value) => new V204(value);
-}
-}
-
-// row 205
-public partial struct O205
-{
-public abstract record B205_1 {  }
-public sealed partial record V205 : B205_1, IValue<string> { }
-}
-
-// row 206
-public static partial class O206
-{
-public sealed partial class P206
-{
-public abstract record B206_1 {  }
-public sealed partial record V206 : B206_1, IValidatedValue<V206, global::System.Uri, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V206, global::Probes.Shapes.ShapeFault> Create(global::System.Uri value) => new V206(value);
-}
-}
-}
-
-// row 207
-public abstract record B207_1 {  }
-public sealed partial record V207 : B207_1, IValue<global::System.DateTimeOffset> { }
-
-// row 208
-public abstract record B208_2 {  }
-public abstract record B208_1 : B208_2 {  }
-public sealed partial record V208 : B208_1, IValidatedValue<V208, long, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V208, global::Probes.Shapes.ShapeFault> Create(long value) => new V208(value);
-}
-
-// row 209
-public static partial class O209
-{
-public sealed partial class P209
-{
-public interface IMark209 { int Mark(); }
-public sealed partial record V209 : IValidatedValue<V209, ulong, global::Probes.Shapes.ShapeFault>, IMark209
-{
-    public static Result<V209, global::Probes.Shapes.ShapeFault> Create(ulong value) => new V209(value); int IMark209.Mark() => 1;
-}
-}
-}
-
-// row 210
-public static partial class O210
-{
-public abstract record B210_1 {  }
-public sealed partial record V210 : B210_1, IValidatedValue<V210, bool, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V210, global::Probes.Shapes.ShapeFault> Create(bool value) => new V210(value);
-}
-}
-
-// row 211
-public abstract record B211_1 : System.IEquatable<B211_1> { bool System.IEquatable<B211_1>.Equals(B211_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V211 : B211_1, IValidatedValue<V211, global::System.TimeSpan, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V211, global::Probes.Shapes.ShapeFault> Create(global::System.TimeSpan value) => new V211(value);
-}
-
-// row 212
-public static partial class O212
-{
-public abstract record B212_3 {  }
-public abstract record B212_2 : B212_3 {  }
-public abstract record B212_1 : B212_2 {  }
-public sealed partial record V212 : B212_1, IValidatedValue<V212, int, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V212, global::Probes.Shapes.ShapeFault> Create(int value) => new V212(value);
-}
-}
-
-// row 213
-public static partial class O213
-{
-public abstract record B213_1 : System.IEquatable<B213_1> { bool System.IEquatable<B213_1>.Equals(B213_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V213 : B213_1, IValue<int> { }
-}
-
-// row 214
-public abstract record B214_1 {  }
-public sealed partial record V214 : B214_1, IValidatedValue<V214, decimal, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V214, global::Probes.Shapes.ShapeFault> Create(decimal value) => new V214(value);
-}
-
-// row 215
-public static partial class O215
-{
-public sealed partial class P215
-{
-public abstract record B215_1 : System.IEquatable<B215_1> { bool System.IEquatable<B215_1>.Equals(B215_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V215 : B215_1, IValidatedValue<V215, byte, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V215, global::Probes.Shapes.ShapeFault> Create(byte value) => new V215(value);
-}
-}
-}
-
-// row 216
-public static partial class O216
-{
-public sealed partial class P216
-{
-public abstract record B216_1 {  }
-public sealed partial record V216 : B216_1, IValidatedValue<V216, global::Probes.Shapes.PRec, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V216, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PRec value) => new V216(value);
-}
-}
-}
-
-// row 217
-public partial struct O217
-{
-public readonly partial record struct V217 : IValidatedValue<V217, int, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V217, global::Probes.Shapes.ShapeFault> Create(int value) => new V217(value);
-}
-}
-
-// row 218
-public static partial class O218
-{
-public abstract record B218_1 : System.IEquatable<B218_1> { bool System.IEquatable<B218_1>.Equals(B218_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V218 : B218_1, IValue<string> { }
-}
-
-// row 219
-public static partial class O219
-{
-public sealed partial class P219
-{
-public abstract record B219_2 {  }
-public abstract record B219_1 : B219_2 {  }
-public sealed partial record V219 : B219_1, IValidatedValue<V219, global::System.Guid, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V219, global::Probes.Shapes.ShapeFault> Create(global::System.Guid value) => new V219(value);
-}
-}
-}
-
-// row 220
-public static partial class O220
-{
-public sealed partial class P220
-{
-public abstract record B220_1 {  }
-public sealed partial record V220 : B220_1, IValue<global::Probes.Shapes.PFlags> { }
-}
-}
-
-// row 221
-public partial struct O221
-{
-public sealed partial record V221 : IValue<byte> { }
-}
-
-// row 222
-public partial struct O222
-{
-public abstract record B222_1 {  }
-public sealed partial record V222 : B222_1, IValue<global::System.DateTime> { }
-}
-
-// row 223
-public sealed partial record V223 : IValue<global::Probes.Shapes.PRec> { }
-
-// row 224
-public partial struct O224
-{
-public abstract record B224_1 {  }
-public sealed partial record V224 : B224_1, IValidatedValue<V224, global::NodaTime.Instant, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V224, global::Probes.Shapes.ShapeFault> Create(global::NodaTime.Instant value) => new V224(value);
-}
-}
-
-// row 225
-public static partial class O225
-{
-public sealed partial class P225
-{
-public readonly partial record struct V225 : IValue<global::System.DateOnly> { }
-}
-}
-
-// row 226
-public static partial class O226
-{
-public sealed partial class P226
-{
-public readonly partial record struct V226 : IValidatedValue<V226, global::System.DateTimeOffset, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V226, global::Probes.Shapes.ShapeFault> Create(global::System.DateTimeOffset value) => new V226(value);
-}
-}
-}
-
-// row 227
-public static partial class O227
-{
-public abstract record B227_3 {  }
-public abstract record B227_2 : B227_3 {  }
-public abstract record B227_1 : B227_2 {  }
-public sealed partial record V227 : B227_1, IValue<global::System.TimeOnly> { }
-}
-
-// row 228
-public static partial class O228
-{
-public readonly partial record struct V228 : IValidatedValue<V228, global::System.TimeSpan, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V228, global::Probes.Shapes.ShapeFault> Create(global::System.TimeSpan value) => new V228(value);
-}
-}
-
-// row 229
-public static partial class O229
-{
-public sealed partial class P229
-{
-public abstract record B229_1 : System.IEquatable<B229_1> { bool System.IEquatable<B229_1>.Equals(B229_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V229 : B229_1, IValidatedValue<V229, global::System.DateTime, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V229, global::Probes.Shapes.ShapeFault> Create(global::System.DateTime value) => new V229(value);
-}
-}
-}
-
-// row 230
-public partial struct O230
-{
-public abstract record B230_1 : System.IEquatable<B230_1> { bool System.IEquatable<B230_1>.Equals(B230_1? other) => ReferenceEquals(this, other); }
-public sealed partial record V230 : B230_1, IValidatedValue<V230, double, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V230, global::Probes.Shapes.ShapeFault> Create(double value) => new V230(value);
-}
-}
-
-// row 231
-public static partial class O231
-{
-public interface IMark231 { int Mark(); }
-public readonly partial record struct V231 : IValidatedValue<V231, global::System.Uri, global::Probes.Shapes.ShapeFault>, IMark231
-{
-    public static Result<V231, global::Probes.Shapes.ShapeFault> Create(global::System.Uri value) => new V231(value); int IMark231.Mark() => 1;
-}
-}
-
-// row 232
-public partial struct O232
-{
-public interface IMark232 { int Mark(); }
-public readonly partial record struct V232 : IValue<double>, IMark232 { int IMark232.Mark() => 1; }
-}
-
-// row 233
-public static partial class O233
-{
-public sealed partial class P233
-{
-public readonly partial record struct V233 : IValue<global::System.DateOnly> { }
-}
-}
-
-// row 234
-public readonly partial record struct V234 : IValue<global::Probes.Shapes.PEnum> { }
-
-// row 235
-public abstract record B235_3 {  }
-public abstract record B235_2 : B235_3 {  }
-public abstract record B235_1 : B235_2 {  }
-public sealed partial record V235 : B235_1, IValidatedValue<V235, global::System.DateTimeOffset, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V235, global::Probes.Shapes.ShapeFault> Create(global::System.DateTimeOffset value) => new V235(value);
-}
-
-// row 236
-public abstract record B236_3 {  }
-public abstract record B236_2 : B236_3 {  }
-public abstract record B236_1 : B236_2 {  }
-public sealed partial record V236 : B236_1, IValidatedValue<V236, bool, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V236, global::Probes.Shapes.ShapeFault> Create(bool value) => new V236(value);
-}
-
-// row 237
-public static partial class O237
-{
-public abstract record B237_2 {  }
-public abstract record B237_1 : B237_2 {  }
-public sealed partial record V237 : B237_1, IValue<decimal> { }
-}
-
-// row 238
-public static partial class O238
-{
-public sealed partial class P238
-{
-public abstract record B238_1 {  }
-public sealed partial record V238 : B238_1, IValue<ulong> { }
-}
-}
-
-// row 239
-public abstract record B239_1 {  }
-public sealed partial record V239 : B239_1, IValue<double> { }
-
-// row 240
-public abstract record B240_1 {  }
-public sealed partial record V240 : B240_1, IValue<byte> { }
-
-// row 241
-public static partial class O241
-{
-public sealed partial class P241
-{
-public interface IMark241 { int Mark(); }
-public sealed partial record V241 : IValidatedValue<V241, global::Probes.Shapes.PEnum, global::Probes.Shapes.ShapeFault>, IMark241
-{
-    public static Result<V241, global::Probes.Shapes.ShapeFault> Create(global::Probes.Shapes.PEnum value) => new V241(value); int IMark241.Mark() => 1;
-}
-}
-}
-
-// row 242
-public partial struct O242
-{
-public abstract record B242_3 {  }
-public abstract record B242_2 : B242_3 {  }
-public abstract record B242_1 : B242_2 {  }
-public sealed partial record V242 : B242_1, IValue<global::Probes.Shapes.PFlags> { }
-}
-
-// row 243
-public readonly partial record struct V243 : IValue<global::System.Uri> { }
-
-// row 244
-public static partial class O244
-{
-public sealed partial class P244
-{
-public readonly partial record struct V244 : IValidatedValue<V244, global::NodaTime.Instant, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V244, global::Probes.Shapes.ShapeFault> Create(global::NodaTime.Instant value) => new V244(value);
-}
-}
-}
-
-// row 245
-public partial struct O245
-{
-public interface IMark245 { int Mark(); }
-public readonly partial record struct V245 : IValue<global::System.Uri>, IMark245 { int IMark245.Mark() => 1; }
-}
-
-// row 246
-public static partial class O246
-{
-public sealed partial class P246
-{
-public abstract record B246_3 {  }
-public abstract record B246_2 : B246_3 {  }
-public abstract record B246_1 : B246_2 {  }
-public sealed partial record V246 : B246_1, IValidatedValue<V246, global::System.Uri, global::Probes.Shapes.ShapeFault>
-{
-    public static Result<V246, global::Probes.Shapes.ShapeFault> Create(global::System.Uri value) => new V246(value);
-}
-}
-}
-
-public static partial class C11Table
-{
-    public static readonly C11Case[] Cases =
-    [
-        new(0, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=double;text.culture=invariant;text.entry=TryFrom", "sealed-record-class", "nested-in-class", "explicit-interface-member", typeof(O0.V0), typeof(double), null, null, []),
-        new(1, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=TimeSpan;text.culture=de-DE;text.entry=ISpanParsable", "validated-class", "top-level", "none", typeof(V1), typeof(global::System.TimeSpan), null, null, []),
-        new(2, "parse-shape=implicit-result;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-struct;shape.wrapped=decimal;text.culture=tr-TR;text.entry=TryFormat-short-span", "sealed-record-class", "nested-in-struct", "base-depth-2", typeof(O2.V2), typeof(global::Probes.Build.C11ParsesToInt), typeof(O2.VC2), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(3, "parse-shape=abstract-string-ctor;process.converter-lookup=none;shape.inheritance=none;shape.kind=validated-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=TimeOnly;text.culture=tr-TR;text.entry=Parse", "validated-struct", "nested-two-levels", "none", typeof(O3.P3.V3), typeof(global::Probes.Build.C11AbstractText), typeof(O3.P3.VC3), typeof(global::Probes.Build.C11ConstructedConcrete), []),
-        new(4, "parse-shape=ref-text;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=record-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=decimal;text.culture=ar-SA;text.entry=ToString-format", "record-struct", "top-level", "explicit-interface-member", typeof(V4), typeof(global::Probes.Build.C11ParsesByRef), typeof(VC4), typeof(global::Probes.Build.C11ParsesFromIn), []),
-        new(5, "parse-shape=abstract-string-ctor;process.converter-lookup=none;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=char;text.culture=globalization-invariant;text.entry=IParsable", "validated-class", "nested-in-struct", "base-depth-1", typeof(O5.V5), typeof(global::Probes.Build.C11AbstractText), typeof(O5.VC5), typeof(global::Probes.Build.C11ConstructedConcrete), []),
-        new(6, "parse-shape=implicit-result;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=record-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=string;text.culture=globalization-invariant;text.entry=TryParse", "record-struct", "nested-in-class", "none", typeof(O6.V6), typeof(global::Probes.Build.C11ParsesToInt), typeof(O6.VC6), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(7, "parse-shape=ref-text;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=NodaTime.Instant;text.culture=invariant;text.entry=type-converter", "sealed-record-class", "nested-two-levels", "base-depth-1", typeof(O7.P7.V7), typeof(global::Probes.Build.C11ConstructedByRef), typeof(O7.P7.VC7), typeof(global::Probes.Build.C11ParsesFromIn), []),
-        new(8, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=long;text.culture=ar-SA;text.entry=IParsable", "sealed-record-class", "nested-two-levels", "base-explicit-IEquatable", typeof(O8.P8.V8), typeof(long), null, null, []),
-        new(9, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=NodaTime.Instant;text.culture=de-DE;text.entry=TryParse", "validated-class", "nested-in-struct", "base-depth-3", typeof(O9.V9), typeof(global::NodaTime.Instant), null, null, []),
-        new(10, "parse-shape=implicit-result;process.converter-lookup=none;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=ulong;text.culture=invariant;text.entry=TryFormat-short-span", "validated-class", "top-level", "base-explicit-IEquatable", typeof(V10), typeof(global::Probes.Build.C11ParsesToInt), typeof(VC10), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(11, "parse-shape=ref-text;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=Guid;text.culture=de-DE;text.entry=Parse", "validated-struct", "nested-in-class", "explicit-interface-member", typeof(O11.V11), typeof(global::Probes.Build.C11ConstructedByRef), typeof(O11.VC11), typeof(global::Probes.Build.C11ParsesFromIn), []),
-        new(12, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=bool;text.culture=globalization-invariant;text.entry=type-converter", "sealed-record-class", "top-level", "base-depth-2", typeof(V12), typeof(bool), null, null, []),
-        new(13, "parse-shape=abstract-string-ctor;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=DateTime;text.culture=tr-TR;text.entry=ToString-format", "validated-class", "nested-in-class", "base-depth-3", typeof(O13.V13), typeof(global::Probes.Build.C11AbstractText), typeof(O13.VC13), typeof(global::Probes.Build.C11ConstructedConcrete), []),
-        new(14, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=validated-struct;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=DateOnly;text.culture=ar-SA;text.entry=ISpanParsable", "validated-struct", "nested-in-struct", "none", typeof(O14.V14), typeof(global::System.DateOnly), null, null, [("shape.inheritance", "none")]),
-        new(15, "parse-shape=ref-text;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=record-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=int;text.culture=invariant;text.entry=TryFrom", "record-struct", "nested-in-struct", "none", typeof(O15.V15), typeof(global::Probes.Build.C11ConstructedByRef), typeof(O15.VC15), typeof(global::Probes.Build.C11ParsesFromIn), []),
-        new(16, "parse-shape=abstract-string-ctor;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=record-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=enum;text.culture=globalization-invariant;text.entry=TryFormat-short-span", "record-struct", "nested-two-levels", "explicit-interface-member", typeof(O16.P16.V16), typeof(global::Probes.Build.C11AbstractText), typeof(O16.P16.VC16), typeof(global::Probes.Build.C11ConstructedConcrete), []),
-        new(17, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=record-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=Uri;text.culture=tr-TR;text.entry=Parse", "record-struct", "top-level", "none", typeof(V17), typeof(global::System.Uri), null, null, [("shape.inheritance", "none")]),
-        new(18, "parse-shape=implicit-result;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-two-levels;shape.wrapped=TimeOnly;text.culture=ar-SA;text.entry=TryFrom", "validated-class", "nested-two-levels", "base-depth-2", typeof(O18.P18.V18), typeof(global::Probes.Build.C11ParsesToInt), typeof(O18.P18.VC18), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(19, "parse-shape=abstract-string-ctor;process.converter-lookup=none;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=string;text.culture=de-DE;text.entry=ISpanParsable", "sealed-record-class", "nested-in-class", "base-explicit-IEquatable", typeof(O19.V19), typeof(global::Probes.Build.C11AbstractText), typeof(O19.VC19), typeof(global::Probes.Build.C11ConstructedConcrete), []),
-        new(20, "parse-shape=ref-text;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=TimeSpan;text.culture=tr-TR;text.entry=IParsable", "validated-struct", "nested-in-struct", "explicit-interface-member", typeof(O20.V20), typeof(global::Probes.Build.C11ParsesByRef), typeof(O20.VC20), typeof(global::Probes.Build.C11ParsesFromIn), []),
-        new(21, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=none;shape.kind=validated-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=DateTimeOffset;text.culture=ar-SA;text.entry=TryFormat-short-span", "validated-struct", "nested-in-class", "none", typeof(O21.V21), typeof(global::System.DateTimeOffset), null, null, []),
-        new(22, "parse-shape=implicit-result;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=record-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=ulong;text.culture=de-DE;text.entry=ISpanParsable", "record-struct", "nested-two-levels", "explicit-interface-member", typeof(O22.P22.V22), typeof(global::Probes.Build.C11ParsesToInt), typeof(O22.P22.VC22), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(23, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=byte;text.culture=invariant;text.entry=ToString-format", "sealed-record-class", "nested-two-levels", "base-depth-3", typeof(O23.P23.V23), typeof(byte), null, null, []),
-        new(24, "parse-shape=implicit-result;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-2;shape.kind=validated-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=own-record-class;text.culture=de-DE;text.entry=ToString-format", "validated-struct", "nested-in-class", "none", typeof(O24.V24), typeof(global::Probes.Build.C11ParsesToInt), typeof(O24.VC24), typeof(global::Probes.Build.C11ParsedShape), [("shape.inheritance", "none")]),
-        new(25, "parse-shape=abstract-string-ctor;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=char;text.culture=ar-SA;text.entry=TryParse", "validated-struct", "top-level", "explicit-interface-member", typeof(V25), typeof(global::Probes.Build.C11AbstractText), typeof(VC25), typeof(global::Probes.Build.C11ConstructedConcrete), []),
-        new(26, "parse-shape=ref-text;process.converter-lookup=none;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=byte;text.culture=globalization-invariant;text.entry=Parse", "validated-class", "nested-in-struct", "base-explicit-IEquatable", typeof(O26.V26), typeof(global::Probes.Build.C11ParsesByRef), typeof(O26.VC26), typeof(global::Probes.Build.C11ParsesFromIn), []),
-        new(27, "parse-shape=implicit-result;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=validated-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=ulong;text.culture=ar-SA;text.entry=type-converter", "validated-struct", "nested-in-class", "none", typeof(O27.V27), typeof(global::Probes.Build.C11ParsesToInt), typeof(O27.VC27), typeof(global::Probes.Build.C11ParsedShape), [("shape.inheritance", "none")]),
-        new(28, "parse-shape=ref-text;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=validated-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=TimeOnly;text.culture=globalization-invariant;text.entry=TryFrom", "validated-struct", "top-level", "none", typeof(V28), typeof(global::Probes.Build.C11ParsesByRef), typeof(VC28), typeof(global::Probes.Build.C11ParsesFromIn), [("shape.inheritance", "none")]),
-        new(29, "parse-shape=ref-text;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=flags-enum;text.culture=de-DE;text.entry=type-converter", "validated-class", "nested-in-struct", "explicit-interface-member", typeof(O29.V29), typeof(global::Probes.Build.C11ConstructedByRef), typeof(O29.VC29), typeof(global::Probes.Build.C11ParsesFromIn), []),
-        new(30, "parse-shape=ref-text;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=DateOnly;text.culture=invariant;text.entry=TryParse", "sealed-record-class", "top-level", "base-depth-2", typeof(V30), typeof(global::Probes.Build.C11ParsesByRef), typeof(VC30), typeof(global::Probes.Build.C11ParsesFromIn), []),
-        new(31, "parse-shape=implicit-result;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=validated-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=decimal;text.culture=invariant;text.entry=IParsable", "validated-struct", "nested-in-class", "none", typeof(O31.V31), typeof(global::Probes.Build.C11ParsesToInt), typeof(O31.VC31), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(32, "parse-shape=abstract-string-ctor;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=Guid;text.culture=globalization-invariant;text.entry=ToString-format", "sealed-record-class", "nested-in-struct", "none", typeof(O32.V32), typeof(global::Probes.Build.C11AbstractText), typeof(O32.VC32), typeof(global::Probes.Build.C11ConstructedConcrete), []),
-        new(33, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=long;text.culture=de-DE;text.entry=TryFrom", "validated-class", "nested-in-class", "base-depth-1", typeof(O33.V33), typeof(long), null, null, []),
-        new(34, "parse-shape=implicit-result;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=flags-enum;text.culture=globalization-invariant;text.entry=Parse", "sealed-record-class", "top-level", "base-depth-3", typeof(V34), typeof(global::Probes.Build.C11ParsesToInt), typeof(VC34), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(35, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=top-level;shape.wrapped=int;text.culture=globalization-invariant;text.entry=IParsable", "sealed-record-class", "top-level", "base-depth-2", typeof(V35), typeof(int), null, null, []),
-        new(36, "parse-shape=abstract-string-ctor;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=DateTime;text.culture=invariant;text.entry=Parse", "sealed-record-class", "nested-in-struct", "base-depth-2", typeof(O36.V36), typeof(global::Probes.Build.C11AbstractText), typeof(O36.VC36), typeof(global::Probes.Build.C11ConstructedConcrete), []),
-        new(37, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-two-levels;shape.wrapped=char;text.culture=tr-TR;text.entry=type-converter", "sealed-record-class", "nested-two-levels", "none", typeof(O37.P37.V37), typeof(char), null, null, []),
-        new(38, "parse-shape=ref-text;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-struct;shape.wrapped=DateTimeOffset;text.culture=globalization-invariant;text.entry=ISpanParsable", "validated-class", "nested-in-struct", "base-depth-2", typeof(O38.V38), typeof(global::Probes.Build.C11ParsesByRef), typeof(O38.VC38), typeof(global::Probes.Build.C11ParsesFromIn), []),
-        new(39, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=enum;text.culture=ar-SA;text.entry=Parse", "sealed-record-class", "nested-in-struct", "base-depth-3", typeof(O39.V39), typeof(global::Probes.Shapes.PEnum), null, null, []),
-        new(40, "parse-shape=implicit-result;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=validated-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=Uri;text.culture=invariant;text.entry=ISpanParsable", "validated-struct", "nested-in-struct", "none", typeof(O40.V40), typeof(global::Probes.Build.C11ParsesToInt), typeof(O40.VC40), typeof(global::Probes.Build.C11ParsedShape), [("shape.inheritance", "none")]),
-        new(41, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=own-record-class;text.culture=tr-TR;text.entry=ISpanParsable", "sealed-record-class", "nested-in-struct", "base-explicit-IEquatable", typeof(O41.V41), typeof(global::Probes.Shapes.PRec), null, null, []),
-        new(42, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=Guid;text.culture=tr-TR;text.entry=TryParse", "sealed-record-class", "nested-two-levels", "base-explicit-IEquatable", typeof(O42.P42.V42), typeof(global::System.Guid), null, null, []),
-        new(43, "parse-shape=abstract-string-ctor;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-2;shape.kind=record-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-struct;shape.wrapped=bool;text.culture=de-DE;text.entry=IParsable", "record-struct", "nested-in-struct", "none", typeof(O43.V43), typeof(global::Probes.Build.C11AbstractText), typeof(O43.VC43), typeof(global::Probes.Build.C11ConstructedConcrete), [("shape.inheritance", "none")]),
-        new(44, "parse-shape=ref-text;process.converter-lookup=none;shape.inheritance=base-depth-1;shape.kind=record-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=TimeOnly;text.culture=de-DE;text.entry=TryFormat-short-span", "record-struct", "nested-two-levels", "none", typeof(O44.P44.V44), typeof(global::Probes.Build.C11ParsesByRef), typeof(O44.P44.VC44), typeof(global::Probes.Build.C11ParsesFromIn), [("shape.inheritance", "none")]),
-        new(45, "parse-shape=ref-text;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=validated-struct;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=double;text.culture=ar-SA;text.entry=TryFormat-short-span", "validated-struct", "top-level", "none", typeof(V45), typeof(global::Probes.Build.C11ConstructedByRef), typeof(VC45), typeof(global::Probes.Build.C11ParsesFromIn), []),
-        new(46, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=flags-enum;text.culture=invariant;text.entry=ToString-format", "validated-struct", "nested-in-class", "none", typeof(O46.V46), typeof(global::Probes.Shapes.PFlags), null, null, [("shape.inheritance", "none")]),
-        new(47, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=validated-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=int;text.culture=de-DE;text.entry=type-converter", "validated-struct", "nested-in-class", "none", typeof(O47.V47), typeof(int), null, null, [("shape.inheritance", "none")]),
-        new(48, "parse-shape=abstract-string-ctor;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=record-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=in-generic-type;shape.wrapped=Guid;text.culture=invariant;text.entry=type-converter", "record-struct", "nested-in-class", "none", typeof(O48.V48), typeof(global::Probes.Build.C11AbstractText), typeof(O48.VC48), typeof(global::Probes.Build.C11ConstructedConcrete), [("shape.site", "nested-in-class"), ("shape.inheritance", "none")]),
-        new(49, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=bool;text.culture=tr-TR;text.entry=TryFrom", "validated-class", "nested-in-class", "base-explicit-IEquatable", typeof(O49.V49), typeof(bool), null, null, []),
-        new(50, "parse-shape=ref-text;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=DateTimeOffset;text.culture=invariant;text.entry=type-converter", "sealed-record-class", "top-level", "base-explicit-IEquatable", typeof(V50), typeof(global::Probes.Build.C11ParsesByRef), typeof(VC50), typeof(global::Probes.Build.C11ParsesFromIn), []),
-        new(51, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=DateOnly;text.culture=globalization-invariant;text.entry=IParsable", "validated-class", "nested-in-class", "base-depth-3", typeof(O51.V51), typeof(global::System.DateOnly), null, null, []),
-        new(52, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=none;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=ulong;text.culture=tr-TR;text.entry=TryFrom", "sealed-record-class", "nested-in-struct", "none", typeof(O52.V52), typeof(ulong), null, null, []),
-        new(53, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=string;text.culture=invariant;text.entry=TryFormat-short-span", "validated-class", "nested-two-levels", "base-depth-3", typeof(O53.P53.V53), typeof(string), null, null, []),
-        new(54, "parse-shape=abstract-string-ctor;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=Uri;text.culture=ar-SA;text.entry=TryFrom", "validated-class", "nested-two-levels", "base-depth-3", typeof(O54.P54.V54), typeof(global::Probes.Build.C11AbstractText), typeof(O54.P54.VC54), typeof(global::Probes.Build.C11ConstructedConcrete), []),
-        new(55, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-two-levels;shape.wrapped=TimeSpan;text.culture=ar-SA;text.entry=TryParse", "sealed-record-class", "nested-two-levels", "base-depth-1", typeof(O55.P55.V55), typeof(global::System.TimeSpan), null, null, []),
-        new(56, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=decimal;text.culture=globalization-invariant;text.entry=TryParse", "validated-class", "nested-two-levels", "base-depth-1", typeof(O56.P56.V56), typeof(decimal), null, null, []),
-        new(57, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=enum;text.culture=de-DE;text.entry=ToString-format", "validated-class", "top-level", "base-depth-1", typeof(V57), typeof(global::Probes.Shapes.PEnum), null, null, []),
-        new(58, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=record-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=byte;text.culture=tr-TR;text.entry=TryParse", "record-struct", "top-level", "none", typeof(V58), typeof(byte), null, null, []),
-        new(59, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=double;text.culture=tr-TR;text.entry=TryParse", "validated-class", "nested-two-levels", "base-depth-3", typeof(O59.P59.V59), typeof(double), null, null, []),
-        new(60, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=TimeOnly;text.culture=invariant;text.entry=ToString-format", "sealed-record-class", "nested-in-class", "explicit-interface-member", typeof(O60.V60), typeof(global::System.TimeOnly), null, null, []),
-        new(61, "parse-shape=implicit-result;process.converter-lookup=none;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=string;text.culture=tr-TR;text.entry=Parse", "sealed-record-class", "nested-in-struct", "base-depth-1", typeof(O61.V61), typeof(global::Probes.Build.C11ParsesToInt), typeof(O61.VC61), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(62, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=validated-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=DateTime;text.culture=ar-SA;text.entry=ISpanParsable", "validated-struct", "nested-two-levels", "none", typeof(O62.P62.V62), typeof(global::System.DateTime), null, null, []),
-        new(63, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=record-struct;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=NodaTime.Instant;text.culture=tr-TR;text.entry=TryFrom", "record-struct", "top-level", "explicit-interface-member", typeof(V63), typeof(global::NodaTime.Instant), null, null, []),
-        new(64, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=validated-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-class;shape.wrapped=enum;text.culture=tr-TR;text.entry=type-converter", "validated-struct", "nested-in-class", "none", typeof(O64.V64), typeof(global::Probes.Shapes.PEnum), null, null, []),
-        new(65, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=Guid;text.culture=ar-SA;text.entry=TryFormat-short-span", "validated-class", "top-level", "base-depth-2", typeof(V65), typeof(global::System.Guid), null, null, []),
-        new(66, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=own-record-class;text.culture=ar-SA;text.entry=IParsable", "validated-class", "top-level", "base-explicit-IEquatable", typeof(V66), typeof(global::Probes.Shapes.PRec), null, null, []),
-        new(67, "parse-shape=abstract-string-ctor;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=validated-struct;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=bool;text.culture=ar-SA;text.entry=ISpanParsable", "validated-struct", "nested-two-levels", "none", typeof(O67.P67.V67), typeof(global::Probes.Build.C11AbstractText), typeof(O67.P67.VC67), typeof(global::Probes.Build.C11ConstructedConcrete), [("shape.inheritance", "none")]),
-        new(68, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=record-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-two-levels;shape.wrapped=DateOnly;text.culture=tr-TR;text.entry=ToString-format", "record-struct", "nested-two-levels", "none", typeof(O68.P68.V68), typeof(global::System.DateOnly), null, null, [("shape.inheritance", "none")]),
-        new(69, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=long;text.culture=invariant;text.entry=TryParse", "validated-struct", "nested-in-struct", "explicit-interface-member", typeof(O69.V69), typeof(long), null, null, []),
-        new(70, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=record-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=DateTimeOffset;text.culture=tr-TR;text.entry=Parse", "record-struct", "nested-two-levels", "explicit-interface-member", typeof(O70.P70.V70), typeof(global::System.DateTimeOffset), null, null, []),
-        new(71, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=record-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=flags-enum;text.culture=ar-SA;text.entry=TryFormat-short-span", "record-struct", "nested-two-levels", "none", typeof(O71.P71.V71), typeof(global::Probes.Shapes.PFlags), null, null, []),
-        new(72, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=record-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-struct;shape.wrapped=double;text.culture=globalization-invariant;text.entry=ToString-format", "record-struct", "nested-in-struct", "none", typeof(O72.V72), typeof(double), null, null, [("shape.inheritance", "none")]),
-        new(73, "parse-shape=ref-text;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-class;shape.wrapped=byte;text.culture=de-DE;text.entry=ISpanParsable", "validated-struct", "nested-in-class", "explicit-interface-member", typeof(O73.V73), typeof(global::Probes.Build.C11ConstructedByRef), typeof(O73.VC73), typeof(global::Probes.Build.C11ParsesFromIn), []),
-        new(74, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=none;shape.kind=record-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-class;shape.wrapped=char;text.culture=de-DE;text.entry=TryFormat-short-span", "record-struct", "nested-in-class", "none", typeof(O74.V74), typeof(char), null, null, []),
-        new(75, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=int;text.culture=ar-SA;text.entry=TryFormat-short-span", "validated-class", "nested-in-struct", "base-depth-1", typeof(O75.V75), typeof(int), null, null, []),
-        new(76, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=Uri;text.culture=de-DE;text.entry=TryParse", "sealed-record-class", "nested-in-class", "explicit-interface-member", typeof(O76.V76), typeof(global::System.Uri), null, null, []),
-        new(77, "parse-shape=abstract-string-ctor;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=record-struct;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=long;text.culture=globalization-invariant;text.entry=ToString-format", "record-struct", "top-level", "none", typeof(V77), typeof(global::Probes.Build.C11AbstractText), typeof(VC77), typeof(global::Probes.Build.C11ConstructedConcrete), []),
-        new(78, "parse-shape=implicit-result;process.converter-lookup=none;shape.inheritance=none;shape.kind=record-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=own-record-class;text.culture=invariant;text.entry=TryParse", "record-struct", "nested-two-levels", "none", typeof(O78.P78.V78), typeof(global::Probes.Build.C11ParsesToInt), typeof(O78.P78.VC78), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(79, "parse-shape=implicit-result;process.converter-lookup=none;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=DateTime;text.culture=globalization-invariant;text.entry=TryFrom", "sealed-record-class", "top-level", "base-explicit-IEquatable", typeof(V79), typeof(global::Probes.Build.C11ParsesToInt), typeof(VC79), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(80, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-1;shape.kind=validated-struct;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=NodaTime.Instant;text.culture=globalization-invariant;text.entry=IParsable", "validated-struct", "nested-in-class", "none", typeof(O80.V80), typeof(global::NodaTime.Instant), null, null, [("shape.inheritance", "none")]),
-        new(81, "parse-shape=abstract-string-ctor;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=closed-set;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=TimeSpan;text.culture=ar-SA;text.entry=Parse", "sealed-record-class", "nested-in-class", "base-explicit-IEquatable", typeof(O81.V81), typeof(global::Probes.Build.C11AbstractText), typeof(O81.VC81), typeof(global::Probes.Build.C11ConstructedConcrete), [("shape.kind", "sealed-record-class")]),
-        new(82, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=record-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=DateTime;text.culture=de-DE;text.entry=IParsable", "record-struct", "nested-two-levels", "explicit-interface-member", typeof(O82.P82.V82), typeof(global::System.DateTime), null, null, []),
-        new(83, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=string;text.culture=ar-SA;text.entry=ToString-format", "validated-class", "top-level", "base-depth-2", typeof(V83), typeof(string), null, null, []),
-        new(84, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=long;text.culture=tr-TR;text.entry=ISpanParsable", "validated-class", "nested-in-class", "base-depth-2", typeof(O84.V84), typeof(long), null, null, []),
-        new(85, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=TimeOnly;text.culture=invariant;text.entry=type-converter", "sealed-record-class", "nested-in-struct", "base-explicit-IEquatable", typeof(O85.V85), typeof(global::System.TimeOnly), null, null, []),
-        new(86, "parse-shape=implicit-result;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=byte;text.culture=ar-SA;text.entry=TryFrom", "sealed-record-class", "nested-two-levels", "base-depth-2", typeof(O86.P86.V86), typeof(global::Probes.Build.C11ParsesToInt), typeof(O86.P86.VC86), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(87, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=int;text.culture=tr-TR;text.entry=ToString-format", "sealed-record-class", "nested-two-levels", "none", typeof(O87.P87.V87), typeof(int), null, null, []),
-        new(88, "parse-shape=abstract-string-ctor;process.converter-lookup=none;shape.inheritance=none;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=DateOnly;text.culture=de-DE;text.entry=type-converter", "sealed-record-class", "top-level", "none", typeof(V88), typeof(global::Probes.Build.C11AbstractText), typeof(VC88), typeof(global::Probes.Build.C11ConstructedConcrete), []),
-        new(89, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=top-level;shape.wrapped=ulong;text.culture=globalization-invariant;text.entry=TryParse", "validated-class", "top-level", "base-depth-2", typeof(V89), typeof(ulong), null, null, []),
-        new(90, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=none;shape.kind=record-struct;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=NodaTime.Instant;text.culture=ar-SA;text.entry=TryFormat-short-span", "record-struct", "top-level", "none", typeof(V90), typeof(global::NodaTime.Instant), null, null, []),
-        new(91, "parse-shape=implicit-result;process.converter-lookup=none;shape.inheritance=base-depth-1;shape.kind=closed-set;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=DateTimeOffset;text.culture=de-DE;text.entry=ToString-format", "sealed-record-class", "nested-two-levels", "base-depth-1", typeof(O91.P91.V91), typeof(global::Probes.Build.C11ParsesToInt), typeof(O91.P91.VC91), typeof(global::Probes.Build.C11ParsedShape), [("shape.kind", "sealed-record-class")]),
-        new(92, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=in-generic-type;shape.wrapped=TimeSpan;text.culture=invariant;text.entry=type-converter", "validated-class", "nested-in-class", "base-depth-2", typeof(O92.V92), typeof(global::System.TimeSpan), null, null, [("shape.site", "nested-in-class")]),
-        new(93, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=decimal;text.culture=de-DE;text.entry=ISpanParsable", "sealed-record-class", "top-level", "base-depth-3", typeof(V93), typeof(decimal), null, null, []),
-        new(94, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=Uri;text.culture=globalization-invariant;text.entry=IParsable", "sealed-record-class", "nested-in-struct", "base-depth-2", typeof(O94.V94), typeof(global::System.Uri), null, null, []),
-        new(95, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=char;text.culture=invariant;text.entry=TryFrom", "validated-class", "top-level", "base-depth-3", typeof(V95), typeof(char), null, null, []),
-        new(96, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=own-record-class;text.culture=globalization-invariant;text.entry=type-converter", "validated-class", "nested-in-struct", "base-depth-3", typeof(O96.V96), typeof(global::Probes.Shapes.PRec), null, null, []),
-        new(97, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=top-level;shape.wrapped=flags-enum;text.culture=tr-TR;text.entry=TryFrom", "validated-class", "top-level", "base-depth-1", typeof(V97), typeof(global::Probes.Shapes.PFlags), null, null, []),
-        new(98, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=enum;text.culture=invariant;text.entry=TryParse", "sealed-record-class", "top-level", "base-depth-2", typeof(V98), typeof(global::Probes.Shapes.PEnum), null, null, []),
-        new(99, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=string;text.culture=invariant;text.entry=TryFrom", "validated-struct", "top-level", "explicit-interface-member", typeof(V99), typeof(string), null, null, []),
-        new(100, "parse-shape=implicit-result;process.converter-lookup=none;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=double;text.culture=de-DE;text.entry=ISpanParsable", "validated-class", "top-level", "base-depth-1", typeof(V100), typeof(global::Probes.Build.C11ParsesToInt), typeof(VC100), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(101, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=in-generic-type;shape.wrapped=DateOnly;text.culture=tr-TR;text.entry=Parse", "validated-struct", "nested-in-class", "explicit-interface-member", typeof(O101.V101), typeof(global::System.DateOnly), null, null, [("shape.site", "nested-in-class")]),
-        new(102, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=bool;text.culture=invariant;text.entry=TryParse", "sealed-record-class", "nested-two-levels", "explicit-interface-member", typeof(O102.P102.V102), typeof(bool), null, null, []),
-        new(103, "parse-shape=implicit-result;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=validated-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=top-level;shape.wrapped=bool;text.culture=ar-SA;text.entry=ToString-format", "validated-struct", "top-level", "none", typeof(V103), typeof(global::Probes.Build.C11ParsesToInt), typeof(VC103), typeof(global::Probes.Build.C11ParsedShape), [("shape.inheritance", "none")]),
-        new(104, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=record-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=TimeSpan;text.culture=globalization-invariant;text.entry=TryFormat-short-span", "record-struct", "nested-two-levels", "none", typeof(O104.P104.V104), typeof(global::System.TimeSpan), null, null, []),
-        new(105, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=record-struct;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=own-record-class;text.culture=de-DE;text.entry=TryFormat-short-span", "record-struct", "top-level", "explicit-interface-member", typeof(V105), typeof(global::Probes.Shapes.PRec), null, null, []),
-        new(106, "parse-shape=implicit-result;process.converter-lookup=none;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=enum;text.culture=globalization-invariant;text.entry=ISpanParsable", "sealed-record-class", "nested-two-levels", "base-explicit-IEquatable", typeof(O106.P106.V106), typeof(global::Probes.Build.C11ParsesToInt), typeof(O106.P106.VC106), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(107, "parse-shape=implicit-result;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=record-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=Uri;text.culture=tr-TR;text.entry=ToString-format", "record-struct", "nested-two-levels", "none", typeof(O107.P107.V107), typeof(global::Probes.Build.C11ParsesToInt), typeof(O107.P107.VC107), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(108, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=validated-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=bool;text.culture=tr-TR;text.entry=TryFormat-short-span", "validated-struct", "nested-two-levels", "none", typeof(O108.P108.V108), typeof(bool), null, null, []),
-        new(109, "parse-shape=ref-text;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=flags-enum;text.culture=ar-SA;text.entry=ISpanParsable", "validated-class", "nested-in-class", "base-depth-2", typeof(O109.V109), typeof(global::Probes.Build.C11ConstructedByRef), typeof(O109.VC109), typeof(global::Probes.Build.C11ParsesFromIn), []),
-        new(110, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=Uri;text.culture=ar-SA;text.entry=type-converter", "sealed-record-class", "nested-two-levels", "base-explicit-IEquatable", typeof(O110.P110.V110), typeof(global::System.Uri), null, null, []),
-        new(111, "parse-shape=implicit-result;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=record-struct;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=int;text.culture=de-DE;text.entry=ISpanParsable", "record-struct", "nested-in-class", "none", typeof(O111.V111), typeof(global::Probes.Build.C11ParsesToInt), typeof(O111.VC111), typeof(global::Probes.Build.C11ParsedShape), [("shape.inheritance", "none")]),
-        new(112, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=int;text.culture=ar-SA;text.entry=TryParse", "validated-struct", "nested-in-struct", "explicit-interface-member", typeof(O112.V112), typeof(int), null, null, []),
-        new(113, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-struct;shape.wrapped=ulong;text.culture=globalization-invariant;text.entry=Parse", "sealed-record-class", "nested-in-struct", "base-depth-3", typeof(O113.V113), typeof(ulong), null, null, []),
-        new(114, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=double;text.culture=de-DE;text.entry=IParsable", "validated-class", "nested-in-struct", "base-depth-2", typeof(O114.V114), typeof(double), null, null, []),
-        new(115, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=validated-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=DateTime;text.culture=tr-TR;text.entry=TryParse", "validated-struct", "nested-in-class", "none", typeof(O115.V115), typeof(global::System.DateTime), null, null, [("shape.inheritance", "none")]),
-        new(116, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-2;shape.kind=closed-set;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=in-generic-type;shape.wrapped=char;text.culture=globalization-invariant;text.entry=ISpanParsable", "sealed-record-class", "nested-in-class", "base-depth-2", typeof(O116.V116), typeof(char), null, null, [("shape.kind", "sealed-record-class"), ("shape.site", "nested-in-class")]),
-        new(117, "parse-shape=implicit-result;process.converter-lookup=none;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=byte;text.culture=tr-TR;text.entry=TryFormat-short-span", "sealed-record-class", "nested-in-class", "base-depth-1", typeof(O117.V117), typeof(global::Probes.Build.C11ParsesToInt), typeof(O117.VC117), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(118, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=char;text.culture=ar-SA;text.entry=Parse", "sealed-record-class", "nested-in-struct", "base-explicit-IEquatable", typeof(O118.V118), typeof(char), null, null, []),
-        new(119, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=Guid;text.culture=tr-TR;text.entry=IParsable", "sealed-record-class", "nested-two-levels", "base-depth-1", typeof(O119.P119.V119), typeof(global::System.Guid), null, null, []),
-        new(120, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=NodaTime.Instant;text.culture=invariant;text.entry=ToString-format", "validated-class", "nested-in-struct", "base-depth-2", typeof(O120.V120), typeof(global::NodaTime.Instant), null, null, []),
-        new(121, "parse-shape=abstract-string-ctor;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=closed-set;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=TimeSpan;text.culture=invariant;text.entry=TryFrom", "sealed-record-class", "top-level", "base-depth-3", typeof(V121), typeof(global::Probes.Build.C11AbstractText), typeof(VC121), typeof(global::Probes.Build.C11ConstructedConcrete), [("shape.kind", "sealed-record-class")]),
-        new(122, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=record-struct;shape.refused-kind=abstract (CMTK1005);shape.site=in-generic-type;shape.wrapped=long;text.culture=globalization-invariant;text.entry=type-converter", "record-struct", "nested-in-class", "none", typeof(O122.V122), typeof(long), null, null, [("shape.site", "nested-in-class"), ("shape.inheritance", "none")]),
-        new(123, "parse-shape=ref-text;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=closed-set;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=DateOnly;text.culture=de-DE;text.entry=TryFrom", "sealed-record-class", "nested-in-struct", "explicit-interface-member", typeof(O123.V123), typeof(global::Probes.Build.C11ConstructedByRef), typeof(O123.VC123), typeof(global::Probes.Build.C11ParsesFromIn), [("shape.kind", "sealed-record-class")]),
-        new(124, "parse-shape=ref-text;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=validated-struct;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=DateTimeOffset;text.culture=tr-TR;text.entry=TryFrom", "validated-struct", "nested-in-struct", "none", typeof(O124.V124), typeof(global::Probes.Build.C11ParsesByRef), typeof(O124.VC124), typeof(global::Probes.Build.C11ParsesFromIn), [("shape.inheritance", "none")]),
-        new(125, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=Uri;text.culture=tr-TR;text.entry=TryFormat-short-span", "validated-struct", "nested-in-class", "explicit-interface-member", typeof(O125.V125), typeof(global::System.Uri), null, null, []),
-        new(126, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-two-levels;shape.wrapped=decimal;text.culture=de-DE;text.entry=Parse", "validated-class", "nested-two-levels", "base-explicit-IEquatable", typeof(O126.P126.V126), typeof(decimal), null, null, []),
-        new(127, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-explicit-IEquatable;shape.kind=closed-set;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=NodaTime.Instant;text.culture=ar-SA;text.entry=Parse", "sealed-record-class", "nested-in-class", "base-explicit-IEquatable", typeof(O127.V127), typeof(global::NodaTime.Instant), null, null, [("shape.kind", "sealed-record-class")]),
-        new(128, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=DateTime;text.culture=de-DE;text.entry=type-converter", "validated-class", "nested-in-class", "base-explicit-IEquatable", typeof(O128.V128), typeof(global::System.DateTime), null, null, []),
-        new(129, "parse-shape=ref-text;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=validated-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=own-record-class;text.culture=ar-SA;text.entry=TryFrom", "validated-struct", "top-level", "none", typeof(V129), typeof(global::Probes.Build.C11ConstructedByRef), typeof(VC129), typeof(global::Probes.Build.C11ParsesFromIn), [("shape.inheritance", "none")]),
-        new(130, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=record-struct;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=char;text.culture=globalization-invariant;text.entry=ToString-format", "record-struct", "nested-in-class", "explicit-interface-member", typeof(O130.V130), typeof(char), null, null, []),
-        new(131, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=record-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=long;text.culture=globalization-invariant;text.entry=TryFormat-short-span", "record-struct", "nested-in-struct", "explicit-interface-member", typeof(O131.V131), typeof(long), null, null, []),
-        new(132, "parse-shape=abstract-string-ctor;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=double;text.culture=invariant;text.entry=Parse", "validated-struct", "top-level", "explicit-interface-member", typeof(V132), typeof(global::Probes.Build.C11AbstractText), typeof(VC132), typeof(global::Probes.Build.C11ConstructedConcrete), []),
-        new(133, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=own-record-class;text.culture=de-DE;text.entry=Parse", "sealed-record-class", "nested-in-class", "base-depth-2", typeof(O133.V133), typeof(global::Probes.Shapes.PRec), null, null, []),
-        new(134, "parse-shape=ref-text;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=NodaTime.Instant;text.culture=invariant;text.entry=ISpanParsable", "validated-class", "top-level", "base-depth-2", typeof(V134), typeof(global::Probes.Build.C11ParsesByRef), typeof(VC134), typeof(global::Probes.Build.C11ParsesFromIn), []),
-        new(135, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=closed-set;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=TimeSpan;text.culture=globalization-invariant;text.entry=ToString-format", "sealed-record-class", "nested-in-struct", "base-depth-3", typeof(O135.V135), typeof(global::System.TimeSpan), null, null, [("shape.kind", "sealed-record-class")]),
-        new(136, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=record-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-struct;shape.wrapped=TimeOnly;text.culture=de-DE;text.entry=TryParse", "record-struct", "nested-in-struct", "explicit-interface-member", typeof(O136.V136), typeof(global::System.TimeOnly), null, null, []),
-        new(137, "parse-shape=implicit-result;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=byte;text.culture=ar-SA;text.entry=IParsable", "sealed-record-class", "nested-in-class", "base-depth-1", typeof(O137.V137), typeof(global::Probes.Build.C11ParsesToInt), typeof(O137.VC137), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(138, "parse-shape=abstract-string-ctor;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=record-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=TimeOnly;text.culture=invariant;text.entry=ISpanParsable", "record-struct", "nested-in-class", "none", typeof(O138.V138), typeof(global::Probes.Build.C11AbstractText), typeof(O138.VC138), typeof(global::Probes.Build.C11ConstructedConcrete), []),
-        new(139, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-explicit-IEquatable;shape.kind=closed-set;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=flags-enum;text.culture=de-DE;text.entry=TryParse", "sealed-record-class", "nested-two-levels", "base-explicit-IEquatable", typeof(O139.P139.V139), typeof(global::Probes.Shapes.PFlags), null, null, [("shape.kind", "sealed-record-class")]),
-        new(140, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=bool;text.culture=globalization-invariant;text.entry=Parse", "sealed-record-class", "nested-in-class", "base-depth-2", typeof(O140.V140), typeof(bool), null, null, []),
-        new(141, "parse-shape=abstract-string-ctor;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=record-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=in-generic-type;shape.wrapped=DateTimeOffset;text.culture=de-DE;text.entry=IParsable", "record-struct", "nested-in-class", "explicit-interface-member", typeof(O141.V141), typeof(global::Probes.Build.C11AbstractText), typeof(O141.VC141), typeof(global::Probes.Build.C11ConstructedConcrete), [("shape.site", "nested-in-class")]),
-        new(142, "parse-shape=implicit-result;process.converter-lookup=none;shape.inheritance=none;shape.kind=validated-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=in-generic-type;shape.wrapped=TimeOnly;text.culture=invariant;text.entry=IParsable", "validated-struct", "nested-in-class", "none", typeof(O142.V142), typeof(global::Probes.Build.C11ParsesToInt), typeof(O142.VC142), typeof(global::Probes.Build.C11ParsedShape), [("shape.site", "nested-in-class")]),
-        new(143, "parse-shape=ref-text;process.converter-lookup=none;shape.inheritance=none;shape.kind=closed-set;shape.refused-kind=over-value-object (CMTK1005);shape.site=top-level;shape.wrapped=byte;text.culture=tr-TR;text.entry=type-converter", "sealed-record-class", "top-level", "none", typeof(V143), typeof(global::Probes.Build.C11ConstructedByRef), typeof(VC143), typeof(global::Probes.Build.C11ParsesFromIn), [("shape.kind", "sealed-record-class")]),
-        new(144, "parse-shape=abstract-string-ctor;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=record-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=enum;text.culture=de-DE;text.entry=TryFrom", "record-struct", "nested-two-levels", "explicit-interface-member", typeof(O144.P144.V144), typeof(global::Probes.Build.C11AbstractText), typeof(O144.P144.VC144), typeof(global::Probes.Build.C11ConstructedConcrete), []),
-        new(145, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=none;shape.kind=validated-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=ulong;text.culture=de-DE;text.entry=ToString-format", "validated-struct", "nested-two-levels", "none", typeof(O145.P145.V145), typeof(ulong), null, null, []),
-        new(146, "parse-shape=implicit-result;process.converter-lookup=none;shape.inheritance=none;shape.kind=validated-struct;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=int;text.culture=de-DE;text.entry=Parse", "validated-struct", "nested-in-class", "none", typeof(O146.V146), typeof(global::Probes.Build.C11ParsesToInt), typeof(O146.VC146), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(147, "parse-shape=abstract-string-ctor;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-two-levels;shape.wrapped=Guid;text.culture=ar-SA;text.entry=ISpanParsable", "validated-struct", "nested-two-levels", "explicit-interface-member", typeof(O147.P147.V147), typeof(global::Probes.Build.C11AbstractText), typeof(O147.P147.VC147), typeof(global::Probes.Build.C11ConstructedConcrete), []),
-        new(148, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=in-generic-type;shape.wrapped=enum;text.culture=globalization-invariant;text.entry=IParsable", "validated-class", "nested-in-class", "none", typeof(O148.V148), typeof(global::Probes.Shapes.PEnum), null, null, [("shape.site", "nested-in-class")]),
-        new(149, "parse-shape=implicit-result;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=DateTime;text.culture=invariant;text.entry=TryFormat-short-span", "sealed-record-class", "nested-in-struct", "explicit-interface-member", typeof(O149.V149), typeof(global::Probes.Build.C11ParsesToInt), typeof(O149.VC149), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(150, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=decimal;text.culture=de-DE;text.entry=TryFrom", "validated-class", "nested-two-levels", "base-depth-3", typeof(O150.P150.V150), typeof(decimal), null, null, []),
-        new(151, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=ulong;text.culture=invariant;text.entry=IParsable", "validated-class", "nested-in-class", "none", typeof(O151.V151), typeof(ulong), null, null, []),
-        new(152, "parse-shape=abstract-string-ctor;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=double;text.culture=ar-SA;text.entry=type-converter", "sealed-record-class", "nested-in-class", "explicit-interface-member", typeof(O152.V152), typeof(global::Probes.Build.C11AbstractText), typeof(O152.VC152), typeof(global::Probes.Build.C11ConstructedConcrete), []),
-        new(153, "parse-shape=implicit-result;process.converter-lookup=none;shape.inheritance=none;shape.kind=closed-set;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=in-generic-type;shape.wrapped=Guid;text.culture=ar-SA;text.entry=TryFrom", "sealed-record-class", "nested-in-class", "none", typeof(O153.V153), typeof(global::Probes.Build.C11ParsesToInt), typeof(O153.VC153), typeof(global::Probes.Build.C11ParsedShape), [("shape.kind", "sealed-record-class"), ("shape.site", "nested-in-class")]),
-        new(154, "parse-shape=implicit-result;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=long;text.culture=invariant;text.entry=Parse", "sealed-record-class", "nested-two-levels", "base-explicit-IEquatable", typeof(O154.P154.V154), typeof(global::Probes.Build.C11ParsesToInt), typeof(O154.P154.VC154), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(155, "parse-shape=ref-text;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=closed-set;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=string;text.culture=globalization-invariant;text.entry=type-converter", "sealed-record-class", "top-level", "none", typeof(V155), typeof(global::Probes.Build.C11ConstructedByRef), typeof(VC155), typeof(global::Probes.Build.C11ParsesFromIn), [("shape.kind", "sealed-record-class")]),
-        new(156, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=DateTimeOffset;text.culture=de-DE;text.entry=TryParse", "validated-struct", "top-level", "explicit-interface-member", typeof(V156), typeof(global::System.DateTimeOffset), null, null, []),
-        new(157, "parse-shape=implicit-result;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=DateOnly;text.culture=globalization-invariant;text.entry=TryFormat-short-span", "validated-class", "nested-two-levels", "base-explicit-IEquatable", typeof(O157.P157.V157), typeof(global::Probes.Build.C11ParsesToInt), typeof(O157.P157.VC157), typeof(global::Probes.Build.C11ParsedShape), []),
-        new(158, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=string;text.culture=invariant;text.entry=IParsable", "validated-class", "nested-two-levels", "base-depth-3", typeof(O158.P158.V158), typeof(string), null, null, []),
-        new(159, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=flags-enum;text.culture=globalization-invariant;text.entry=IParsable", "sealed-record-class", "nested-two-levels", "base-depth-2", typeof(O159.P159.V159), typeof(global::Probes.Shapes.PFlags), null, null, []),
-        new(160, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=decimal;text.culture=invariant;text.entry=type-converter", "sealed-record-class", "nested-in-struct", "explicit-interface-member", typeof(O160.V160), typeof(decimal), null, null, []),
-        new(161, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=none;shape.kind=record-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-class;shape.wrapped=Guid;text.culture=invariant;text.entry=type-converter", "record-struct", "nested-in-class", "none", typeof(O161.V161), typeof(global::System.Guid), null, null, []),
-        new(162, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=DateTime;text.culture=invariant;text.entry=TryFormat-short-span", "sealed-record-class", "nested-in-struct", "base-depth-3", typeof(O162.V162), typeof(global::System.DateTime), null, null, []),
-        new(163, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=DateTimeOffset;text.culture=invariant;text.entry=ToString-format", "sealed-record-class", "nested-in-struct", "base-explicit-IEquatable", typeof(O163.V163), typeof(global::System.DateTimeOffset), null, null, []),
-        new(164, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=byte;text.culture=ar-SA;text.entry=IParsable", "validated-struct", "nested-in-struct", "explicit-interface-member", typeof(O164.V164), typeof(byte), null, null, []),
-        new(165, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=DateOnly;text.culture=de-DE;text.entry=ToString-format", "sealed-record-class", "top-level", "base-explicit-IEquatable", typeof(V165), typeof(global::System.DateOnly), null, null, []),
-        new(166, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=none;shape.kind=record-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=decimal;text.culture=ar-SA;text.entry=ToString-format", "record-struct", "nested-in-class", "none", typeof(O166.V166), typeof(decimal), null, null, []),
-        new(167, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=none;shape.kind=record-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=string;text.culture=de-DE;text.entry=Parse", "record-struct", "nested-in-class", "none", typeof(O167.V167), typeof(string), null, null, []),
-        new(168, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=record-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=ulong;text.culture=ar-SA;text.entry=TryFormat-short-span", "record-struct", "nested-in-class", "none", typeof(O168.V168), typeof(ulong), null, null, [("shape.inheritance", "none")]),
-        new(169, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=record-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-struct;shape.wrapped=bool;text.culture=de-DE;text.entry=ISpanParsable", "record-struct", "nested-in-struct", "explicit-interface-member", typeof(O169.V169), typeof(bool), null, null, []),
-        new(170, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=validated-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=own-record-class;text.culture=invariant;text.entry=ToString-format", "validated-struct", "nested-two-levels", "none", typeof(O170.P170.V170), typeof(global::Probes.Shapes.PRec), null, null, []),
-        new(171, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=none;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=byte;text.culture=globalization-invariant;text.entry=ISpanParsable", "validated-class", "nested-in-class", "none", typeof(O171.V171), typeof(byte), null, null, []),
-        new(172, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=TimeOnly;text.culture=ar-SA;text.entry=Parse", "sealed-record-class", "nested-two-levels", "base-depth-2", typeof(O172.P172.V172), typeof(global::System.TimeOnly), null, null, []),
-        new(173, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=TimeOnly;text.culture=tr-TR;text.entry=TryFormat-short-span", "validated-class", "top-level", "base-depth-3", typeof(V173), typeof(global::System.TimeOnly), null, null, []),
-        new(174, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=Uri;text.culture=invariant;text.entry=ISpanParsable", "validated-class", "nested-in-class", "base-depth-3", typeof(O174.V174), typeof(global::System.Uri), null, null, []),
-        new(175, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=validated-struct;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=double;text.culture=ar-SA;text.entry=ISpanParsable", "validated-struct", "nested-in-struct", "none", typeof(O175.V175), typeof(double), null, null, [("shape.inheritance", "none")]),
-        new(176, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=string;text.culture=tr-TR;text.entry=ToString-format", "sealed-record-class", "nested-in-struct", "base-explicit-IEquatable", typeof(O176.V176), typeof(string), null, null, []),
-        new(177, "parse-shape=ref-text;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=DateTimeOffset;text.culture=globalization-invariant;text.entry=TryFrom", "validated-class", "nested-in-class", "base-depth-3", typeof(O177.V177), typeof(global::Probes.Build.C11ConstructedByRef), typeof(O177.VC177), typeof(global::Probes.Build.C11ParsesFromIn), []),
-        new(178, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-struct;shape.wrapped=Guid;text.culture=tr-TR;text.entry=ToString-format", "validated-struct", "nested-in-struct", "explicit-interface-member", typeof(O178.V178), typeof(global::System.Guid), null, null, []),
-        new(179, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=none;shape.kind=validated-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-class;shape.wrapped=TimeOnly;text.culture=globalization-invariant;text.entry=TryFrom", "validated-struct", "nested-in-class", "none", typeof(O179.V179), typeof(global::System.TimeOnly), null, null, []),
-        new(180, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=record-struct;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=enum;text.culture=globalization-invariant;text.entry=ISpanParsable", "record-struct", "nested-two-levels", "explicit-interface-member", typeof(O180.P180.V180), typeof(global::Probes.Shapes.PEnum), null, null, []),
-        new(181, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=TimeSpan;text.culture=tr-TR;text.entry=IParsable", "validated-struct", "top-level", "explicit-interface-member", typeof(V181), typeof(global::System.TimeSpan), null, null, []),
-        new(182, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=validated-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-class;shape.wrapped=decimal;text.culture=tr-TR;text.entry=TryFormat-short-span", "validated-struct", "nested-in-class", "none", typeof(O182.V182), typeof(decimal), null, null, [("shape.inheritance", "none")]),
-        new(183, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-struct;shape.wrapped=flags-enum;text.culture=invariant;text.entry=ISpanParsable", "validated-class", "nested-in-struct", "base-depth-3", typeof(O183.V183), typeof(global::Probes.Shapes.PFlags), null, null, []),
-        new(184, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=DateTime;text.culture=globalization-invariant;text.entry=type-converter", "validated-class", "top-level", "base-depth-1", typeof(V184), typeof(global::System.DateTime), null, null, []),
-        new(185, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=record-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-two-levels;shape.wrapped=bool;text.culture=ar-SA;text.entry=IParsable", "record-struct", "nested-two-levels", "none", typeof(O185.P185.V185), typeof(bool), null, null, [("shape.inheritance", "none")]),
-        new(186, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=top-level;shape.wrapped=long;text.culture=globalization-invariant;text.entry=ToString-format", "sealed-record-class", "top-level", "base-depth-3", typeof(V186), typeof(long), null, null, []),
-        new(187, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=in-generic-type;shape.wrapped=DateOnly;text.culture=invariant;text.entry=TryFrom", "validated-class", "nested-in-class", "base-depth-1", typeof(O187.V187), typeof(global::System.DateOnly), null, null, [("shape.site", "nested-in-class")]),
-        new(188, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=record-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=int;text.culture=invariant;text.entry=Parse", "record-struct", "nested-two-levels", "explicit-interface-member", typeof(O188.P188.V188), typeof(int), null, null, []),
-        new(189, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=NodaTime.Instant;text.culture=invariant;text.entry=ISpanParsable", "validated-class", "nested-two-levels", "explicit-interface-member", typeof(O189.P189.V189), typeof(global::NodaTime.Instant), null, null, []),
-        new(190, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=Guid;text.culture=de-DE;text.entry=TryFrom", "sealed-record-class", "nested-in-struct", "base-depth-3", typeof(O190.V190), typeof(global::System.Guid), null, null, []),
-        new(191, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=string;text.culture=globalization-invariant;text.entry=TryParse", "sealed-record-class", "nested-two-levels", "explicit-interface-member", typeof(O191.P191.V191), typeof(string), null, null, []),
-        new(192, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=ulong;text.culture=globalization-invariant;text.entry=type-converter", "validated-class", "top-level", "base-explicit-IEquatable", typeof(V192), typeof(ulong), null, null, []),
-        new(193, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=DateOnly;text.culture=globalization-invariant;text.entry=TryParse", "sealed-record-class", "top-level", "base-depth-2", typeof(V193), typeof(global::System.DateOnly), null, null, []),
-        new(194, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=byte;text.culture=de-DE;text.entry=TryFrom", "validated-class", "nested-in-class", "base-depth-2", typeof(O194.V194), typeof(byte), null, null, []),
-        new(195, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=flags-enum;text.culture=globalization-invariant;text.entry=Parse", "sealed-record-class", "top-level", "explicit-interface-member", typeof(V195), typeof(global::Probes.Shapes.PFlags), null, null, []),
-        new(196, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=double;text.culture=ar-SA;text.entry=type-converter", "validated-class", "top-level", "base-explicit-IEquatable", typeof(V196), typeof(double), null, null, []),
-        new(197, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=DateTime;text.culture=invariant;text.entry=TryFrom", "sealed-record-class", "nested-in-class", "base-depth-2", typeof(O197.V197), typeof(global::System.DateTime), null, null, []),
-        new(198, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=validated-struct;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=byte;text.culture=invariant;text.entry=type-converter", "validated-struct", "nested-in-struct", "none", typeof(O198.V198), typeof(byte), null, null, [("shape.inheritance", "none")]),
-        new(199, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=char;text.culture=invariant;text.entry=IParsable", "validated-struct", "nested-two-levels", "explicit-interface-member", typeof(O199.P199.V199), typeof(char), null, null, []),
-        new(200, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=enum;text.culture=ar-SA;text.entry=TryFormat-short-span", "sealed-record-class", "nested-in-struct", "base-explicit-IEquatable", typeof(O200.V200), typeof(global::Probes.Shapes.PEnum), null, null, []),
-        new(201, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=Guid;text.culture=globalization-invariant;text.entry=ISpanParsable", "sealed-record-class", "nested-in-struct", "base-depth-3", typeof(O201.V201), typeof(global::System.Guid), null, null, []),
-        new(202, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=DateTimeOffset;text.culture=de-DE;text.entry=IParsable", "sealed-record-class", "nested-in-struct", "base-depth-2", typeof(O202.V202), typeof(global::System.DateTimeOffset), null, null, []),
-        new(203, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=char;text.culture=invariant;text.entry=TryParse", "sealed-record-class", "nested-two-levels", "base-depth-1", typeof(O203.P203.V203), typeof(char), null, null, []),
-        new(204, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=TimeOnly;text.culture=invariant;text.entry=ISpanParsable", "validated-class", "nested-in-struct", "base-depth-1", typeof(O204.V204), typeof(global::System.TimeOnly), null, null, []),
-        new(205, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=string;text.culture=tr-TR;text.entry=ISpanParsable", "sealed-record-class", "nested-in-struct", "base-depth-1", typeof(O205.V205), typeof(string), null, null, []),
-        new(206, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=Uri;text.culture=tr-TR;text.entry=TryFrom", "validated-class", "nested-two-levels", "base-depth-1", typeof(O206.P206.V206), typeof(global::System.Uri), null, null, []),
-        new(207, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=DateTimeOffset;text.culture=ar-SA;text.entry=ISpanParsable", "sealed-record-class", "top-level", "base-depth-1", typeof(V207), typeof(global::System.DateTimeOffset), null, null, []),
-        new(208, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=top-level;shape.wrapped=long;text.culture=ar-SA;text.entry=Parse", "validated-class", "top-level", "base-depth-2", typeof(V208), typeof(long), null, null, []),
-        new(209, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=ulong;text.culture=de-DE;text.entry=ISpanParsable", "validated-class", "nested-two-levels", "explicit-interface-member", typeof(O209.P209.V209), typeof(ulong), null, null, []),
-        new(210, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=bool;text.culture=invariant;text.entry=ToString-format", "validated-class", "nested-in-class", "base-depth-1", typeof(O210.V210), typeof(bool), null, null, []),
-        new(211, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=top-level;shape.wrapped=TimeSpan;text.culture=tr-TR;text.entry=Parse", "validated-class", "top-level", "base-explicit-IEquatable", typeof(V211), typeof(global::System.TimeSpan), null, null, []),
-        new(212, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=int;text.culture=globalization-invariant;text.entry=TryFrom", "validated-class", "nested-in-class", "base-depth-3", typeof(O212.V212), typeof(int), null, null, []),
-        new(213, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=in-generic-type;shape.wrapped=int;text.culture=invariant;text.entry=ToString-format", "sealed-record-class", "nested-in-class", "base-explicit-IEquatable", typeof(O213.V213), typeof(int), null, null, [("shape.site", "nested-in-class")]),
-        new(214, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=top-level;shape.wrapped=decimal;text.culture=tr-TR;text.entry=IParsable", "validated-class", "top-level", "base-depth-1", typeof(V214), typeof(decimal), null, null, []),
-        new(215, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-two-levels;shape.wrapped=byte;text.culture=de-DE;text.entry=TryFormat-short-span", "validated-class", "nested-two-levels", "base-explicit-IEquatable", typeof(O215.P215.V215), typeof(byte), null, null, []),
-        new(216, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-two-levels;shape.wrapped=own-record-class;text.culture=ar-SA;text.entry=TryParse", "validated-class", "nested-two-levels", "base-depth-1", typeof(O216.P216.V216), typeof(global::Probes.Shapes.PRec), null, null, []),
-        new(217, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=none;shape.kind=validated-struct;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=int;text.culture=invariant;text.entry=ISpanParsable", "validated-struct", "nested-in-struct", "none", typeof(O217.V217), typeof(int), null, null, []),
-        new(218, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=in-generic-type;shape.wrapped=string;text.culture=globalization-invariant;text.entry=type-converter", "sealed-record-class", "nested-in-class", "base-explicit-IEquatable", typeof(O218.V218), typeof(string), null, null, [("shape.site", "nested-in-class")]),
-        new(219, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-two-levels;shape.wrapped=Guid;text.culture=invariant;text.entry=Parse", "validated-class", "nested-two-levels", "base-depth-2", typeof(O219.P219.V219), typeof(global::System.Guid), null, null, []),
-        new(220, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-two-levels;shape.wrapped=flags-enum;text.culture=globalization-invariant;text.entry=type-converter", "sealed-record-class", "nested-two-levels", "base-depth-1", typeof(O220.P220.V220), typeof(global::Probes.Shapes.PFlags), null, null, []),
-        new(221, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=sealed-record-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=byte;text.culture=invariant;text.entry=Parse", "sealed-record-class", "nested-in-struct", "none", typeof(O221.V221), typeof(byte), null, null, []),
-        new(222, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=DateTime;text.culture=tr-TR;text.entry=Parse", "sealed-record-class", "nested-in-struct", "base-depth-1", typeof(O222.V222), typeof(global::System.DateTime), null, null, []),
-        new(223, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=none;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=own-record-class;text.culture=tr-TR;text.entry=TryFrom", "sealed-record-class", "top-level", "none", typeof(V223), typeof(global::Probes.Shapes.PRec), null, null, []),
-        new(224, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-struct;shape.wrapped=NodaTime.Instant;text.culture=tr-TR;text.entry=type-converter", "validated-class", "nested-in-struct", "base-depth-1", typeof(O224.V224), typeof(global::NodaTime.Instant), null, null, []),
-        new(225, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-2;shape.kind=record-struct;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=DateOnly;text.culture=de-DE;text.entry=type-converter", "record-struct", "nested-two-levels", "none", typeof(O225.P225.V225), typeof(global::System.DateOnly), null, null, [("shape.inheritance", "none")]),
-        new(226, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=validated-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-two-levels;shape.wrapped=DateTimeOffset;text.culture=invariant;text.entry=type-converter", "validated-struct", "nested-two-levels", "none", typeof(O226.P226.V226), typeof(global::System.DateTimeOffset), null, null, [("shape.inheritance", "none")]),
-        new(227, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-class;shape.wrapped=TimeOnly;text.culture=ar-SA;text.entry=IParsable", "sealed-record-class", "nested-in-class", "base-depth-3", typeof(O227.V227), typeof(global::System.TimeOnly), null, null, []),
-        new(228, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-struct;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-class;shape.wrapped=TimeSpan;text.culture=globalization-invariant;text.entry=TryFrom", "validated-struct", "nested-in-class", "none", typeof(O228.V228), typeof(global::System.TimeSpan), null, null, [("shape.inheritance", "none")]),
-        new(229, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-two-levels;shape.wrapped=DateTime;text.culture=tr-TR;text.entry=ToString-format", "validated-class", "nested-two-levels", "base-explicit-IEquatable", typeof(O229.P229.V229), typeof(global::System.DateTime), null, null, []),
-        new(230, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-explicit-IEquatable;shape.kind=validated-class;shape.refused-kind=generic-wrapped (CMTK1005);shape.site=nested-in-struct;shape.wrapped=double;text.culture=globalization-invariant;text.entry=TryFormat-short-span", "validated-class", "nested-in-struct", "base-explicit-IEquatable", typeof(O230.V230), typeof(double), null, null, []),
-        new(231, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=validated-struct;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-class;shape.wrapped=Uri;text.culture=ar-SA;text.entry=ToString-format", "validated-struct", "nested-in-class", "explicit-interface-member", typeof(O231.V231), typeof(global::System.Uri), null, null, []),
-        new(232, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=record-struct;shape.refused-kind=over-value-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=double;text.culture=ar-SA;text.entry=Parse", "record-struct", "nested-in-struct", "explicit-interface-member", typeof(O232.V232), typeof(double), null, null, []),
-        new(233, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=record-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-two-levels;shape.wrapped=DateOnly;text.culture=tr-TR;text.entry=TryFormat-short-span", "record-struct", "nested-two-levels", "none", typeof(O233.P233.V233), typeof(global::System.DateOnly), null, null, [("shape.inheritance", "none")]),
-        new(234, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=none;shape.kind=record-struct;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=enum;text.culture=invariant;text.entry=TryFrom", "record-struct", "top-level", "none", typeof(V234), typeof(global::Probes.Shapes.PEnum), null, null, []),
-        new(235, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=top-level;shape.wrapped=DateTimeOffset;text.culture=globalization-invariant;text.entry=TryFrom", "validated-class", "top-level", "base-depth-3", typeof(V235), typeof(global::System.DateTimeOffset), null, null, []),
-        new(236, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=bool;text.culture=de-DE;text.entry=Parse", "validated-class", "top-level", "base-depth-3", typeof(V236), typeof(bool), null, null, []),
-        new(237, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-2;shape.kind=sealed-record-class;shape.refused-kind=unsealed-record-class (CMTK1006);shape.site=nested-in-class;shape.wrapped=decimal;text.culture=tr-TR;text.entry=TryFormat-short-span", "sealed-record-class", "nested-in-class", "base-depth-2", typeof(O237.V237), typeof(decimal), null, null, []),
-        new(238, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=ulong;text.culture=de-DE;text.entry=TryFormat-short-span", "sealed-record-class", "nested-two-levels", "base-depth-1", typeof(O238.P238.V238), typeof(ulong), null, null, []),
-        new(239, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=double;text.culture=de-DE;text.entry=IParsable", "sealed-record-class", "top-level", "base-depth-1", typeof(V239), typeof(double), null, null, []),
-        new(240, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-1;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=top-level;shape.wrapped=byte;text.culture=ar-SA;text.entry=TryFrom", "sealed-record-class", "top-level", "base-depth-1", typeof(V240), typeof(byte), null, null, []),
-        new(241, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=validated-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-two-levels;shape.wrapped=enum;text.culture=de-DE;text.entry=IParsable", "validated-class", "nested-two-levels", "explicit-interface-member", typeof(O241.P241.V241), typeof(global::Probes.Shapes.PEnum), null, null, []),
-        new(242, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=sealed-record-class;shape.refused-kind=abstract (CMTK1005);shape.site=nested-in-struct;shape.wrapped=flags-enum;text.culture=ar-SA;text.entry=TryFrom", "sealed-record-class", "nested-in-struct", "base-depth-3", typeof(O242.V242), typeof(global::Probes.Shapes.PFlags), null, null, []),
-        new(243, "parse-shape=ordinary;process.converter-lookup=wrapped-type-converter-looked-up-first;shape.inheritance=base-depth-3;shape.kind=record-struct;shape.refused-kind=closed-set-named-as-generated-member (CMTK1021);shape.site=top-level;shape.wrapped=Uri;text.culture=ar-SA;text.entry=IParsable", "record-struct", "top-level", "none", typeof(V243), typeof(global::System.Uri), null, null, [("shape.inheritance", "none")]),
-        new(244, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=none;shape.kind=validated-struct;shape.refused-kind=equality-operator (CMTK1011);shape.site=nested-two-levels;shape.wrapped=NodaTime.Instant;text.culture=ar-SA;text.entry=TryFormat-short-span", "validated-struct", "nested-two-levels", "none", typeof(O244.P244.V244), typeof(global::NodaTime.Instant), null, null, []),
-        new(245, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=explicit-interface-member;shape.kind=record-struct;shape.refused-kind=over-object (CMTK1005);shape.site=nested-in-struct;shape.wrapped=Uri;text.culture=invariant;text.entry=TryFormat-short-span", "record-struct", "nested-in-struct", "explicit-interface-member", typeof(O245.V245), typeof(global::System.Uri), null, null, []),
-        new(246, "parse-shape=ordinary;process.converter-lookup=none;shape.inheritance=base-depth-3;shape.kind=validated-class;shape.refused-kind=over-System.Enum (CMTK1005);shape.site=nested-two-levels;shape.wrapped=Uri;text.culture=ar-SA;text.entry=TryParse", "validated-class", "nested-two-levels", "base-depth-3", typeof(O246.P246.V246), typeof(global::System.Uri), null, null, []),
-    ];
-}
diff --git a/tools/probe/corpus/harness/Cmp.cs b/tools/probe/corpus/harness/Cmp.cs
deleted file mode 100644
index a435030b..00000000
--- a/tools/probe/corpus/harness/Cmp.cs
+++ /dev/null
@@ -1,128 +0,0 @@
-// Composed-fault errors for C03/C05 (harness). e: 1 first set, 2 last set, 3 last set with detail, 4/5/6 first set with a rule (enum / closed set / nested enum).
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.ClosedSets;
-using CodoMetis.TypeKit.AspNetCore;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Routing;
-namespace Probes;
-
-public sealed partial class KFault : IFaultSet<KFault>
-{
-    public static readonly KFault Clash = new(FaultKind.Conflict, null);
-    public static readonly KFault Lost = new(FaultKind.NotFound, null);
-    private KFault(FaultKind kind, string? description) { Kind = kind; Description = description; }
-    public FaultKind Kind { get; }
-    public string? Description { get; }
-}
-
-public static class Cmp
-{
-    public const string Detail = "It is at version 3, not 2.";
-    static Fault<HFault> Rule(int e) => e switch
-    {
-        4 => Fault.Of(HFault.Clash).WithRule(PRule.A),
-        5 => Fault.Of(HFault.Clash).WithRule(RuleSet.X),
-        6 => Fault.Of(HFault.Clash).WithRule(Holder.NestedRule.N),
-        _ => throw new ArgumentOutOfRangeException(nameof(e)),
-    };
-    public static Result<Fault<HFault, GFault>> Two(int e) => e switch
-    {
-        1 => Fault<HFault, GFault>.Of(HFault.Missing),
-        2 => Fault<HFault, GFault>.Of(GFault.Raced),
-        3 => Fault<HFault, GFault>.Of(Fault.Of(GFault.Old, Detail)),
-        >= 4 and <= 6 => Fault<HFault, GFault>.Of(Rule(e)),
-        _ => Result<Fault<HFault, GFault>>.Success(),
-    };
-    public static Result<Fault<HFault, KFault>> TwoK(int e) => e switch
-    {
-        1 => Fault<HFault, KFault>.Of(HFault.Missing),
-        2 => Fault<HFault, KFault>.Of(KFault.Clash),
-        3 => Fault<HFault, KFault>.Of(Fault.Of(KFault.Lost, Detail)),
-        >= 4 and <= 6 => Fault<HFault, KFault>.Of(Rule(e)),
-        _ => Result<Fault<HFault, KFault>>.Success(),
-    };
-    public static Result<Fault<HFault, GFault, SFault>> Three(int e) => e switch
-    {
-        1 => Fault<HFault, GFault, SFault>.Of(HFault.Missing),
-        2 => Fault<HFault, GFault, SFault>.Of(SFault.First),
-        3 => Fault<HFault, GFault, SFault>.Of(Fault.Of(SFault.Second, Detail)),
-        >= 4 and <= 6 => Fault<HFault, GFault, SFault>.Of(Rule(e)),
-        _ => Result<Fault<HFault, GFault, SFault>>.Success(),
-    };
-    public static Result<Fault<HFault, KFault, SFault>> ThreeK(int e) => e switch
-    {
-        1 => Fault<HFault, KFault, SFault>.Of(HFault.Missing),
-        2 => Fault<HFault, KFault, SFault>.Of(SFault.First),
-        3 => Fault<HFault, KFault, SFault>.Of(Fault.Of(SFault.Second, Detail)),
-        >= 4 and <= 6 => Fault<HFault, KFault, SFault>.Of(Rule(e)),
-        _ => Result<Fault<HFault, KFault, SFault>>.Success(),
-    };
-
-    // ---- expectations
-    /// <summary>(fault type name, member name, status) of the error e answers, by arity and variant; variant group moves HFault.Clash to 422.</summary>
-    public static (string Type, string Member, int Status) Expect(int arity, string variant, int e)
-    {
-        var k = variant == "dup";
-        int clash = variant == "group" ? 422 : 409;
-        return e switch
-        {
-            1 => ("HFault", "Missing", 404),
-            2 => arity == 2 ? (k ? ("KFault", "Clash", 409) : ("GFault", "Raced", 409)) : ("SFault", "First", 409),
-            3 => arity == 2 ? (k ? ("KFault", "Lost", 404) : ("GFault", "Old", 412)) : ("SFault", "Second", 410),
-            _ => ("HFault", "Clash", clash),
-        };
-    }
-    /// <summary>The statuses >= 400 the operation lists: those of every member of every answered type, minus the left-out ones, plus the declared 429.</summary>
-    public static SortedSet<int> DocStatuses(int arity, string variant)
-    {
-        var s = new SortedSet<int>();
-        var h = new (string, int)[] { ("Missing", 404), ("Clash", variant == "group" ? 422 : 409), ("Bad", 422), ("Denied", 403), ("Down", 503), ("Stale", 412), ("Garbled", 400) };
-        foreach (var (m, st) in h) if (!(variant == "wo" && m == "Bad")) s.Add(st);
-        if (variant == "dup") { s.Add(409); s.Add(404); } else { s.Add(404); s.Add(409); s.Add(412); }
-        if (arity == 3) { s.Add(409); s.Add(410); }
-        if (variant == "declared") s.Add(429);
-        return s;
-    }
-
-    static readonly Dictionary<string, string> Kinds = new(StringComparer.Ordinal)
-    {
-        ["HFault.Missing"] = "NotFound", ["HFault.Clash"] = "Conflict", ["HFault.Bad"] = "Invalid", ["HFault.Denied"] = "Forbidden",
-        ["HFault.Down"] = "Unavailable", ["HFault.Stale"] = "PreconditionFailed", ["HFault.Garbled"] = "Malformed",
-        ["GFault.Gone"] = "NotFound", ["GFault.Raced"] = "Conflict", ["GFault.Old"] = "PreconditionFailed",
-        ["KFault.Clash"] = "Conflict", ["KFault.Lost"] = "NotFound",
-    };
-    /// <summary>The kind of a fault-set member, or null for a member of the enum SFault, which has none.</summary>
-    public static string? KindOf(string type, string member) => Kinds.GetValueOrDefault(type + "." + member);
-    /// <summary>The problem types the operation's response for <paramref name="status"/> names: every member answered with it, of every set.</summary>
-    public static HashSet<string> TypesAt(int arity, string variant, int status)
-    {
-        var members = new List<(string Type, string Member, int Status)>
-        {
-            ("HFault", "Missing", 404), ("HFault", "Clash", variant == "group" ? 422 : 409), ("HFault", "Denied", 403), ("HFault", "Down", 503),
-            ("HFault", "Stale", 412), ("HFault", "Garbled", 400),
-        };
-        if (variant != "wo") members.Add(("HFault", "Bad", 422));
-        if (variant == "dup") members.AddRange([("KFault", "Clash", 409), ("KFault", "Lost", 404)]);
-        else members.AddRange([("GFault", "Gone", 404), ("GFault", "Raced", 409), ("GFault", "Old", 412)]);
-        // arity 3 adds SFault, an enum mapped to 409 and 410 with no type
-        return [.. members.Where(m => m.Status == status).Select(m => ComposedClaims.TypeOf(m.Type, KindOf(m.Type, m.Member)!))];
-    }
-
-    public static RouteHandlerBuilder Decorate(RouteHandlerBuilder rb, string variant) => variant switch
-    {
-        "wo" => rb.WithoutFaults(HFault.Bad),
-        "group" => rb.WithFaultStatus(HFault.Clash, 422),
-        "declared" => rb.ProducesProblem(429),
-        _ => rb,
-    };
-    public static void MapMinimal(IEndpointRouteBuilder b)
-    {
-        foreach (var v in new[] { "plain", "wo", "group", "declared", "dup" })
-        {
-            var k = v == "dup";
-            Decorate(k ? b.MapGet($"/m/2/{v}", (int e) => TwoK(e).ToHttpResult()) : b.MapGet($"/m/2/{v}", (int e) => Two(e).ToHttpResult()), v);
-            Decorate(k ? b.MapGet($"/m/3/{v}", (int e) => ThreeK(e).ToHttpResult()) : b.MapGet($"/m/3/{v}", (int e) => Three(e).ToHttpResult()), v);
-        }
-    }
-}
diff --git a/tools/probe/corpus/harness/ComposedProbes.cs b/tools/probe/corpus/harness/ComposedProbes.cs
deleted file mode 100644
index 56532242..00000000
--- a/tools/probe/corpus/harness/ComposedProbes.cs
+++ /dev/null
@@ -1,228 +0,0 @@
-// Claims C03-composed-faults (AspNetCore README#faults-of-several-types) and C05-with-rule (README#the-rule-that-refused).
-// C03: a Fault<T1,T2[,T3]> is "answered as its own set maps it" (status, `fault`, problem type, detail, rule intact); "its operation lists the
-//   statuses of both sets, in ascending order, with the problem types of both where they share a status"; "the host doesn't start while either
-//   set is unmapped". The host maps every fault set with a problem type of its set and kind (TypeOf), so two sets sharing a status name two types.
-// C05: WithRule(member) is written as `rule`, "qualified with its type's name", a nested type after its nesting chain "whatever QualifiedFaultNames
-//   says"; "The status, the mapping and the document stay the error's"; a value no member names "throws where it's given"; the document describes `rule`.
-// Oracle: claim (README text) + differential wire/document. Expected: see Cmp.Expect / Cmp.DocStatuses. Each obligation is a check of its
-// own (ComposedChecks.C03, C05), every check on one host.
-using System.Text.Json.Nodes;
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.AspNetCore;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.Extensions.DependencyInjection;
-using Probes.Faults;
-using Probes.Shapes;
-namespace Probes;
-
-public static class ComposedClaims
-{
-    /// <summary>The application's own string converter (json.Converters=own-for-wrapped) wraps every string it writes: take it off again.</summary>
-    static string? Un(Row r, string? s) => r.Is("json.Converters", "own-for-wrapped") && s is not null && s.StartsWith("own:") ? s[4..].Trim('"') : s;
-    static string Cut(string? s) => s is null ? "(null)" : s.Length > 200 ? s[..200] + "..." : s;
-    public static string Variant(Row r) => r["http.response"] switch
-    {
-        "endpoint-without-faults" => "wo", "group-with-fault-status" => "group", "declared-produces-problem" => "declared", "two-faults-same-name" => "dup", _ => "plain",
-    };
-    static HostCfg Cfg(Row r) => new()
-    {
-        FaultControllers = true, Controllers = Hx.Plain(r) ? [typeof(RulePlainController)] : [typeof(RuleApiController)],
-        Minimal = Cmp.MapMinimal, Qualified = r.Is("qualified", "QualifiedFaultNames"),
-        Mapping = "own-per-set-type",
-        Services = s => s.AddFaultResponses(f => FaultResponse.For(f.Kind).WithType(new Uri(TypeOf(f.GetType().Name, f.Kind.ToString())))),
-    };
-
-    /// <summary>The problem type the host maps a fault-set member to: its set's and its kind's, so two sets sharing a status name two types.</summary>
-    public static string TypeOf(string set, string kind) => $"https://p.example/{set}/{kind}";
-
-    /// <summary>The problem's rule, an aspect of its own beside <see cref="Aspect"/>'s.</summary>
-    public const string Rule = "rule";
-
-    /// <summary>
-    /// The wire and the document of one endpoint family under the row, one check (Row.Check) per obligation <paramref name="of"/> names an
-    /// aspect for (<see cref="Aspect"/>'s and <see cref="Rule"/>), against <paramref name="against"/>; every check runs on the one host, with
-    /// the answers fetched once. e: the error code of Cmp.
-    /// </summary>
-    public static async Task<string?> WireAndDoc(Row r, Entry en, int arity, int e, string rule, Func<string, string[]> of, Baseline against)
-    {
-        var variant = Variant(r);
-        var obligations = Aspect.Answer.Append(Rule).Concat(Aspect.Doc).SelectMany(of).Distinct().ToList();
-        WebApplication? app = null; Exception? down = null;
-        try { app = await Hx.Start(r, en, Cfg(r)); }
-        catch (Exception ex) when (ex is not Sides.InputsNotEquivalent) { down = ex; }
-        await using var _ = app;
-        string? failed = null;
-        if (down is not null)
-        {
-            foreach (var o in obligations) { var f = r.Check(o, against, _ => "host did not start: " + down.GetType().Name + ": " + Cut(down.Message)); failed ??= f; }
-            return failed;
-        }
-        var qualified = r.Is("qualified", "QualifiedFaultNames");
-        var sides = new List<string>();
-        if (Hx.HasMinimal(r)) sides.Add(Hx.M(r, $"/m/{arity}/{variant}"));
-        if (Hx.HasMvc(r)) sides.Add(Hx.C(r, $"/c/{arity}/{variant}"));
-        JsonNode? doc = null; Exception? docFailed = null;
-        try { doc = await Hx.Doc(app!); }
-        catch (Exception ex) { docFailed = ex; }
-        var wires = new Dictionary<string, Hx.Wire>();
-        foreach (var path in sides) wires[path] = await Hx.Get(app!, $"{path}?e={e}");
-        var (type, member, status) = Cmp.Expect(arity, variant, e);
-
-        foreach (var o in obligations)
-        {
-            var f = await r.Check(o, against, async c =>
-            {
-                bool want(string aspect) => of(aspect).Contains(o);
-                if (Aspect.Answer.Any(want) || want(Rule))
-                    foreach (var path in sides)
-                    {
-                        var w = wires[path];
-                        if (w.Thrown is not null) return $"{path} e={e}: request threw {w.Thrown}";
-                        if (want(Aspect.Status) && (int)w.Status != status) return $"{path} e={e}: status {(int)w.Status}, expected {status}: {Cut(w.Body)}";
-                        JsonNode? body; try { body = JsonNode.Parse(w.Body); } catch { return $"{path} e={e}: body is not JSON: {Cut(w.Body)}"; }
-                        var fault = Un(r, body?["fault"]?.GetValue<string>());
-                        var wantFault = qualified ? $"{type}.{member}" : member;
-                        if (want(Aspect.Fault) && fault != wantFault) return $"{path} e={e}: fault {fault}, expected {wantFault}";
-                        if (want(Aspect.Detail) && e == 3 && Un(r, body?["detail"]?.GetValue<string>()) != Cmp.Detail) return $"{path} e={e}: detail {body?["detail"]}, expected the occurrence's";
-                        var gotRule = Un(r, body?["rule"]?.GetValue<string>());
-                        if (want(Rule) && gotRule != (rule == "" ? null : rule)) return $"{path} e={e}: rule {gotRule ?? "(none)"}, expected {(rule == "" ? "(none)" : rule)}";
-                        // an enum (SFault) is mapped to a status alone, and ASP.NET writes its own default type there
-                        if (want(Aspect.Type) && Cmp.KindOf(type, member) is { } kind && Un(r, body?["type"]?.GetValue<string>()) is var gotType && gotType != TypeOf(type, kind))
-                            return $"{path} e={e}: type {gotType ?? "(none)"}, expected {TypeOf(type, kind)}";
-                        if (want(Aspect.Status) && int.Parse(body?["status"]?.ToString() is { } st ? Un(r, st)!.Trim('"') : "0") != status) return $"{path} e={e}: problem status field {body?["status"]}";
-                    }
-                if (!Aspect.Doc.Any(want)) return null;
-                // the document: one ASP.NET alone refuses the same way has nothing to check (noted there)
-                if (docFailed is not null)
-                    return await Hx.DocRefusedByAspNetAlone(r, en, Cfg(r), docFailed, (Aspect.Answer.Any(want) || want(Rule)) && sides.Count > 0) is { } alone
-                        ? alone + " @ " + string.Join(" < ", (docFailed.StackTrace ?? "").Split('\n').Take(4).Select(x => x.Trim().Split('(')[0]))
-                        : null;
-                foreach (var path in sides)
-                {
-                    var ops = doc!["paths"]?[path]?["get"];
-                    if (ops is null && !Hx.InDocument(r) && path.Contains("/c/")) { c.Note(NoteKeys.DocControllerNotInApiExplorer); continue; }
-                    if (ops is null) return $"document has no GET {path}";
-                    var keys = ops["responses"]!.AsObject().Select(kv => kv.Key).Where(k => int.TryParse(k, out var n) && n >= 400).Select(int.Parse).ToList();
-                    var listed = Cmp.DocStatuses(arity, variant);
-                    // A status the endpoint declares itself (the 429) takes its place among the sets' statuses (fixed in 8d1ebd8).
-                    if ((want(Aspect.DocListed) || want(Aspect.DocOrder)) && !keys.SequenceEqual(listed)) return $"{path}: document lists {string.Join(",", keys)}, expected {string.Join(",", listed)} (ascending)";
-                    foreach (var k in keys)
-                    {
-                        if (variant == "declared" && k == 429) continue;   // a declared problem is ASP.NET's, not an answered fault
-                        var txt = Hx.Deep(doc!, ops["responses"]![k.ToString()])?.ToJsonString() ?? "";
-                        if (want(Aspect.DocDescribes) && !txt.Contains("\"fault\"")) return $"{path} {k}: response schema does not describe fault: {Cut(txt)}";
-                        if (want(Aspect.DocDescribes) && !txt.Contains("\"rule\"")) return $"{path} {k}: response schema does not describe rule: {Cut(txt)}";
-                        var desc = ops["responses"]![k.ToString()]?["description"]?.GetValue<string>() ?? "";
-                        const string Lead = "Problem types: ";
-                        var at = desc.IndexOf(Lead, StringComparison.Ordinal);
-                        var types = at < 0 ? [] : desc[(at + Lead.Length)..].Split(", ").ToHashSet();
-                        var wantTypes = Cmp.TypesAt(arity, variant, k);
-                        if (want(Aspect.DocTypes) && !types.SetEquals(wantTypes))
-                            return $"{path} {k}: description \"{desc}\" names problem types {{{string.Join(", ", types)}}}, expected {{{string.Join(", ", wantTypes)}}}";
-                    }
-                }
-                return null;
-            });
-            failed ??= f;
-        }
-        return failed;
-    }
-
-    /// <summary>"The host doesn't start while either set is unmapped."</summary>
-    public static async Task<string?> UnmappedDoesNotStart(Row r, Entry en, int arity, int e)
-    {
-        var cfg = Cfg(r); cfg.MapBlanketMapping = false;
-        var unmapped = e == 1 ? "HFault" : arity == 2 ? "GFault" : "GFault";
-        var variant = Variant(r);
-        if (variant == "dup") unmapped = e == 1 ? "HFault" : "KFault";
-        cfg.Services = s =>
-        {
-            if (unmapped != "HFault") s.AddFaultResponses<HFault>();
-            if (unmapped != "GFault" && variant != "dup") s.AddFaultResponses<GFault>();
-            if (unmapped != "KFault" && variant == "dup") s.AddFaultResponses<KFault>();
-            if (arity == 3) s.AddFaultResponses<SFault>(f => f switch { SFault.First => 409, _ => 410 });
-        };
-        WebApplication? app = null;
-        try { app = await Hx.Start(r, en, cfg); }
-        catch (Exception ex) when (ex is not Sides.InputsNotEquivalent)
-        {
-            return ex.ToString().Contains(unmapped) ? null : $"host refused to start but not naming {unmapped}: {ex.GetType().Name}: {Cut(ex.Message)}";
-        }
-        await using var _ = app;
-        return $"host started with {unmapped} unmapped (arity {arity}, variant {variant}); answered only at request time?";
-    }
-}
-
-public static class ComposedChecks
-{
-    static void Process(Row r, Entry en) { if (r.Is("process.converter-lookup", "wrapped-type-converter-looked-up-first")) _ = System.ComponentModel.TypeDescriptor.GetConverter(Make.Held(en.Plain)); }
-    /// <summary>
-    /// C03, a check per obligation: each-error-own-set (status, fault, problem type, and the rule where the error names none),
-    /// detail-and-rule-intact (error with-detail or with-rule: the detail and the rule), statuses-ascending (the statuses each operation
-    /// lists, in order, and their problem schemas), shared-status-types (the problem types each status's description names), and
-    /// unmapped-set-stops-start (a host with one set unmapped, against the refusal) in every row.
-    /// </summary>
-    public static async Task<string?> C03(Row r)
-    {
-        var en = Registry.Of(r); Process(r, en);
-        var arity = int.Parse(r["arity"]);
-        var e = r["error"] switch { "first-set" => 1, "last-set" => 2, "with-detail" => 3, _ => 4 };
-        var intact = r["error"] is "with-detail" or "with-rule";
-        string[] Of(string aspect) => aspect switch
-        {
-            Aspect.Detail or ComposedClaims.Rule when intact => ["detail-and-rule-intact"],
-            Aspect.DocListed or Aspect.DocOrder or Aspect.DocDescribes => ["statuses-ascending"],
-            Aspect.DocTypes => ["shared-status-types"],
-            _ => ["each-error-own-set"],
-        };
-        var answered = await ComposedClaims.WireAndDoc(r, en, arity, e, e == 4 ? "PRule.A" : "", Of,
-            Baseline.Docs("src/CodoMetis.TypeKit.AspNetCore/README.md#faults-of-several-types"));
-        var unmapped = await r.Check("unmapped-set-stops-start", Baseline.Refusal, _ => ComposedClaims.UnmappedDoesNotStart(r, en, arity, e));
-        return answered ?? unmapped;
-    }
-    /// <summary>
-    /// C05, a check per obligation: unnamed-value-throws (ruletype flags-combination or undefined-cast, against the refusal);
-    /// rule-qualified (enum, closed-set) or nested-chain (nested-enum), and no-namespace, for the rule on the wire; stays-the-errors for
-    /// the status, fault, problem type and the document, and in the rows of an unnamed value for the error answered without a rule.
-    /// </summary>
-    public static async Task<string?> C05(Row r)
-    {
-        var en = Registry.Of(r); Process(r, en);
-        var ruletype = r["ruletype"];
-        // a value no member names throws where it is given (never a rule on the wire)
-        var thrown = ruletype switch
-        {
-            "flags-combination" => r.Check("unnamed-value-throws", Baseline.Refusal, c =>
-            {
-                try { _ = Fault.Of(HFault.Clash).WithRule((FRule)3); return "WithRule(flags combination) did not throw"; } catch (ArgumentException) { return null; }
-            }),
-            "undefined-cast" => r.Check("unnamed-value-throws", Baseline.Refusal, c =>
-            {
-                try { _ = Fault.Of(HFault.Clash).WithRule((PRule)9); return "WithRule(undefined cast) did not throw"; } catch (ArgumentException) { return null; }
-            }),
-            _ => null,
-        };
-        var (e, rule) = ruletype switch { "enum" => (4, "PRule.A"), "closed-set" => (5, "RuleSet.X"), "nested-enum" => (6, "Holder.NestedRule.N"), _ => (1, "") };
-        var named = ruletype switch { "enum" or "closed-set" => "rule-qualified", "nested-enum" => "nested-chain", _ => null };
-        string[] Of(string aspect) => aspect == ComposedClaims.Rule && named is not null ? [named, "no-namespace"] : ["stays-the-errors"];
-        var answered = await ComposedClaims.WireAndDoc(r, en, 3, e, rule, Of, Baseline.Docs("src/CodoMetis.TypeKit.AspNetCore/README.md#the-rule-that-refused"));
-        return thrown ?? answered;
-    }
-}
-public static class ComposedShrinkInit
-{
-    [System.Runtime.CompilerServices.ModuleInitializer]
-    public static void Init() { ShrinkChecks.All["C03"] = ComposedChecks.C03; ShrinkChecks.All["C05"] = ComposedChecks.C05; }
-}
-public sealed class C03ComposedProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("C03ComposedProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run("C03", idx, ComposedChecks.C03, probe);
-}
-public sealed class C05RuleProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("C05RuleProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run("C05", idx, ComposedChecks.C05, probe);
-}
diff --git a/tools/probe/corpus/harness/Containers.g.cs b/tools/probe/corpus/harness/Containers.g.cs
deleted file mode 100644
index d79627ed..00000000
--- a/tools/probe/corpus/harness/Containers.g.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-// <auto-generated/> by tools/probe/generators/containers.cs
-#nullable disable
-#pragma warning disable CS8618, CS1591, CS0649
-using System.Text.Json.Serialization;
-namespace Probes.Shapes;
-public class Cn_class_P<M> { public M P { get; set; } }
-public class Cn_class_F<M> { public M F; }
-public class Cn_class_C<M> { public M P { get; } [JsonConstructor] public Cn_class_C(M p) { P = p; } }
-public class Cn_class_R<M> { public required M P { get; init; } }
-public record class Cn_record_class_P<M> { public M P { get; set; } }
-public record class Cn_record_class_F<M> { public M F; }
-public record class Cn_record_class_C<M>(M P);
-public record class Cn_record_class_R<M> { public required M P { get; init; } }
-public struct Cn_struct_P<M> { public M P { get; set; } }
-public struct Cn_struct_F<M> { public M F; }
-public struct Cn_struct_C<M> { public M P { get; } [JsonConstructor] public Cn_struct_C(M p) { P = p; } }
-public struct Cn_struct_R<M> { public required M P { get; init; } }
-public record struct Cn_record_struct_P<M> { public M P { get; set; } }
-public record struct Cn_record_struct_F<M> { public M F; }
-public record struct Cn_record_struct_C<M> { public M P { get; } [JsonConstructor] public Cn_record_struct_C(M p) { P = p; } }
-public record struct Cn_record_struct_R<M> { public required M P { get; init; } }
-public class Cn_generic_type_P<M, U> { public M P { get; set; } }
-public class Cn_generic_type_F<M, U> { public M F; }
-public class Cn_generic_type_C<M, U> { public M P { get; } [JsonConstructor] public Cn_generic_type_C(M p) { P = p; } }
-public class Cn_generic_type_R<M, U> { public required M P { get; init; } }
diff --git a/tools/probe/corpus/harness/DecimalSpelling.cs b/tools/probe/corpus/harness/DecimalSpelling.cs
deleted file mode 100644
index 11a7c617..00000000
--- a/tools/probe/corpus/harness/DecimalSpelling.cs
+++ /dev/null
@@ -1,230 +0,0 @@
-// Claim C01-decimal-spelling (docs/json.md#decimals-in-one-spelling): DecimalNumberJsonConverter writes the smallest scale as a
-// number, DecimalStringJsonConverter as a string; "Register either one once, and it covers every decimal: nullable ones, dictionary
-// keys, and every value object over a decimal, since its JSON is the underlying type's." "Both read a number, or a string holding one,
-// and keep the scale they read."
-// Oracle: claim (the minimal spelling, computed here independently of the product) plus differential (the value object's document is the
-// plain decimal's under the same options), with the options' own leaving-out shown by a baseline without the converter in the same row.
-using System.Globalization;
-using System.Text.Json;
-using System.Text.Json.Serialization;
-using CodoMetis.TypeKit;
-using Probes.Shapes;
-namespace Probes.Json;
-
-public static class DecimalSpelling
-{
-    static readonly CultureInfo Inv = CultureInfo.InvariantCulture;
-    const char Bs = (char)92;
-
-    /// <summary>The input axis as decimal text: max28digits is 7.8 at scale 28, the largest scale a decimal has.</summary>
-    public static string Text(string input) => input == "max28digits" ? "7.8000000000000000000000000000" : input;
-
-    /// <summary>The minimal spelling, worked out without the product: invariant digits, trailing fractional zeros dropped, a zero written 0.</summary>
-    public static string Canonical(decimal d)
-    {
-        if (d == 0m) return "0";
-        var s = d.ToString(Inv);
-        return s.Contains('.') ? s.TrimEnd('0').TrimEnd('.') : s;
-    }
-
-    static bool IsDecimal(JTok t, decimal d) => t.Type switch
-    {
-        JsonTokenType.Number => decimal.TryParse(t.Raw, NumberStyles.Float, Inv, out var x) && x == d,
-        JsonTokenType.String or JsonTokenType.PropertyName => t.Text is { Length: > 0 } s && s.Trim() == s && decimal.TryParse(s, NumberStyles.Float, Inv, out var y) && y == d,
-        _ => false,
-    };
-
-    /// <summary>The decimals a read value holds, as the serializer writes them by default: with the scale they hold.</summary>
-    static List<decimal> Held(object? v, Type declared, decimal d)
-    {
-        if (v is null) return [];
-        var json = JsonSerializer.Serialize(v, declared, Jx.Plain);
-        return Jx.Tokens(json).Where(t => IsDecimal(t, d)).Select(t => decimal.Parse(t.Type == JsonTokenType.Number ? t.Raw : t.Text!, NumberStyles.Float, Inv)).ToList();
-    }
-    static bool Same(decimal a, decimal b) => decimal.GetBits(a).SequenceEqual(decimal.GetBits(b));
-    static string Show(List<decimal> l) => string.Join(",", l.Select(x => x.ToString(Inv)));
-
-    /// <summary>What one form of the document read as: the decimal's and the value object's refusals and the decimals each holds.</summary>
-    sealed record Form(string Name, string Json, Exception? Ep, Exception? Ev, List<decimal> Cp, List<decimal> Cv, bool BothRefused);
-
-    /// <summary>
-    /// C01's checks, one per obligation, over one write and one read of the row's shape: the converter's spelling of each value
-    /// (smallest-scale; number-is-a-number or string-is-a-string, by the row's converter) against the docs' minimal spelling worked out
-    /// here; every decimal of the document, a key's included, and the value object's document against the plain decimal's
-    /// (covers-every-decimal, the twin); each form of the input read (reads-a-number-or-a-string) with the scale it carries
-    /// (keeps-the-scale-it-reads). The options' own leaving-out is shown by a baseline without the converter in the same row: a
-    /// direction it leaves out has nothing to check. Every check runs; returns the first failure.
-    /// </summary>
-    public static string? Check(Row r)
-    {
-        var kind = r["shape.kind"];
-        if (kind == "closed-set") { r.Outcome("harness-error", "C01 excludes closed-set: a closed set holds no decimal"); return null; }
-        var e = Registry.Get(kind, "decimal");
-        var text = Text(r["input"]);
-        var d = decimal.Parse(text, NumberStyles.Float, Inv);
-        var canon = Canonical(d);
-        var number = r["converter"] == "number";
-        JsonConverter conv = number ? new DecimalNumberJsonConverter() : new DecimalStringJsonConverter();
-        var position = r["shape.position"];
-        var containing = position == "root" ? "class" : r["shape.containing"];
-        var (hp, hv) = Sides.Twins(position, containing, e, d, Make.Vo(e, d));
-        var o = JCtx.Apply(r, e, hp.Declared, hv.Declared);
-        var ob = new JsonSerializerOptions(o);      // the baseline: the same options, the serializer's own decimal
-        foreach (var c in ob.Converters.Where(c => c.CanConvert(typeof(decimal))).ToList()) ob.Converters.Remove(c);
-        o.Converters.Insert(0, conv);               // registered first: an application converter for decimals (own-for-wrapped) comes after it
-        var ownVo = r.Is("json.Converters", "own-for-value-object");
-        var docs = Baseline.Docs("docs/json.md#decimals-in-one-spelling");
-        const string Smallest = "smallest-scale", Covers = "covers-every-decimal", Reads = "reads-a-number-or-a-string", Keeps = "keeps-the-scale-it-reads";
-        var kindOf = number ? "number-is-a-number" : "string-is-a-string";
-
-        // Writing: one spelling, the smallest scale, as a number or a string; the value object's document is the decimal's.
-        var (jp, xp) = Jx.Ser(hp, o); var (jv, xv) = Jx.Ser(hv, o); var (jb, xb) = Jx.Ser(hp, ob);
-        if (xb is not null && xp is not null && (xv is not null || ownVo) && xp.GetType() == xb.GetType())
-        {
-            // the options refuse the shape for the serializer's own decimal too: nothing is written or read to compare. Where the value
-            // object is refused alike, at the same stage with the same exception type, the decimal without TypeKit's converter is side (1)
-            // of the three-sided differential (Sides), and each check is the framework's refusal; otherwise none can tell.
-            var one = new Sides.Answer("write", null, xb); var three = new Sides.Answer("write", null, xv);
-            if (Sides.Alike(one, three))
-            {
-                var framework = Sides.Measured(one, "the serializer's own decimal, without TypeKit's converter");
-                foreach (var o2 in new[] { Smallest, kindOf, Covers, Reads, Keeps }) r.Check(o2, framework.Baseline, c => Sides.Refuses(c, framework, three));
-                return null;
-            }
-            var why = "the options refuse the shape for the serializer's own decimal too: " + Jx.Ex(xb);
-            string? None(Check c) => c.Inconclusive(why);
-            foreach (var ob2 in new[] { Smallest, kindOf }) r.Check(ob2, docs, None);
-            r.Check(Covers, Baseline.Twin, None); r.Check(Reads, docs, None); r.Check(Keeps, docs, None);
-            return null;
-        }
-        var tp = xp is null ? Jx.Tokens(jp!).Where(t => IsDecimal(t, d)).ToList() : [];
-        var tb = xb is null ? Jx.Tokens(jb!).Where(t => IsDecimal(t, d)).ToList() : null;
-        var writeLeftOut = tb is { Count: 0 } && xp is null && tp.Count == 0;
-        string? WriteLeftOut(Check c) { c.Note(NoteKeys.JsonMemberLeftOutByOptions, "write: " + Jx.Cut(jb)); return c.Inconclusive("write: the options leave the member out, for the serializer's own decimal too: " + Jx.Cut(jb)); }
-        var want = number ? JsonTokenType.Number : JsonTokenType.String;
-        var f1 = r.Check(Smallest, docs, c =>
-        {
-            if (xp is not null) return $"write: the decimal with {conv.GetType().Name} threw {Jx.Ex(xp)}; without it the serializer wrote {Jx.Cut(jb)}";
-            if (tb is { Count: 0 } && tp.Count != 0) return $"write: the options leave the member out without the converter ({Jx.Cut(jb)}) but it wrote {Jx.Cut(jp)}";
-            if (writeLeftOut) return WriteLeftOut(c);
-            if (tp.Count == 0) return $"write: no decimal in {Jx.Cut(jp)}; the serializer alone wrote {Jx.Cut(jb)}";
-            foreach (var t in tp.Where(t => t.Type != JsonTokenType.PropertyName))
-                if (t.Raw != canon) return $"write: {t.Type} {t.Raw}, expected the smallest scale {canon}, in {Jx.Cut(jp)}";
-            c.Note(NoteKeys.Compared, $"write {text} -> {canon}");
-            return null;
-        });
-        var f2 = r.Check(kindOf, docs, c =>
-        {
-            if (xp is not null) return c.Inconclusive("write: the decimal with the converter threw, judged by smallest-scale");
-            if (writeLeftOut) return WriteLeftOut(c);
-            var values = tp.Where(t => t.Type != JsonTokenType.PropertyName).ToList();
-            if (values.Count == 0) return c.Inconclusive($"write: no decimal value in {Jx.Cut(jp)}, only keys, which are names");
-            foreach (var t in values)
-                if (t.Type != want) return $"write: {t.Type} {t.Raw}, expected the {want} {canon}, in {Jx.Cut(jp)}";
-            c.Note(NoteKeys.Compared, $"write as a {want}");
-            return null;
-        });
-
-        // Reading: a number, a string holding one, and an escaped string all read, the scale they carry kept, on both sides alike.
-        var full = Jx.Full(o);
-        var (jf, xf) = Jx.Ser(hp, full);
-        if (xf is not null) { r.Outcome("harness-error", "the document with every member written threw " + Jx.Ex(xf)); return f1 ?? f2; }
-        var at = Jx.Tokens(jf!).Where(t => IsDecimal(t, d)).ToList();
-        string? readNothing = null;
-        var forms = new List<Form>();
-        var leftOut = false;
-        if (at.Count == 0)
-        {
-            // Nothing to read either: the options leave the member out of every document (a field without IncludeFields).
-            var (jfb, _) = Jx.Ser(hp, Jx.Full(ob));
-            if (jfb is null || Jx.Tokens(jfb).Any(t => IsDecimal(t, d))) { r.Outcome("harness-error", "no decimal in the document with every member written: " + jf); return f1 ?? f2; }
-            readNothing = "read: the options leave the member out of every document, for the serializer's own decimal too: " + Jx.Cut(jf);
-        }
-        else
-        {
-            var key = at.Any(t => t.Type == JsonTokenType.PropertyName);
-            var texts = new List<(string Name, string Json)>();
-            if (!key) texts.Add(("number", Jx.Rewrite(jf!, at, _ => text)));
-            texts.Add(("string", Jx.Rewrite(jf!, at, _ => "\"" + text + "\"")));
-            texts.Add(("escaped string", Jx.Rewrite(jf!, at, _ => "\"" + Bs + "u00" + ((int)text[0]).ToString("x2") + text[1..] + "\"")));
-            // The baseline reads the first form with the serializer's own decimal: it shows whether these options read the member at all.
-            var (vb, eb) = Jx.De(texts[0].Json, hp.Declared, ob);
-            leftOut = eb is null && Held(vb, hp.Declared, d).Count == 0;
-            foreach (var (name, json) in texts)
-            {
-                var (vp, ep) = Jx.De(json, hp.Declared, o);
-                var (vv, ev) = ownVo ? (null, null) : Jx.De(json, hv.Declared, o);
-                var both = ep is not null && eb is not null && (ownVo || ev is not null) && ep.GetType() == eb.GetType();
-                var cp = ep is null ? Held(vp, hp.Declared, d) : []; var cv = ownVo ? cp : ev is null ? Held(vv, hv.Declared, d) : [];
-                forms.Add(new(name, json, ep, ev, cp, cv, both));
-            }
-            if (leftOut && forms.All(f => f.Ep is null && f.Ev is null && f.Cp.Count == 0 && f.Cv.Count == 0))
-                readNothing = "read: the options read no member, for the serializer's own decimal too";
-        }
-        string? ReadLeftOut(Check c) { c.Note(NoteKeys.JsonMemberLeftOutByOptions, "read"); return c.Inconclusive(readNothing!); }
-        // The forms both sides refuse alike under these options (the serializer's own decimal too) have nothing to compare.
-        var compared = forms.Where(f => !f.BothRefused).ToList();
-        string? AllRefused(Check c)
-        {
-            foreach (var f in forms.Where(f => f.BothRefused)) c.Log.AppendLine($"read {f.Name}: both refuse: {Jx.Ex(f.Ep!)}");
-            return c.Inconclusive("read: every form is refused for the serializer's own decimal too: " + Jx.Ex(forms[0].Ep!));
-        }
-        var f4 = r.Check(Reads, docs, c =>
-        {
-            if (readNothing is not null) return ReadLeftOut(c);
-            foreach (var f in forms)
-            {
-                if (f.BothRefused) continue;
-                if (f.Ep is not null) return $"read {f.Name}: the decimal with {conv.GetType().Name} threw {Jx.Ex(f.Ep)}\n  text={Jx.Cut(f.Json)}";
-                if (leftOut) { if (f.Cp.Count != 0) return $"read {f.Name}: the options read no member for the serializer's own decimal, yet it read {Show(f.Cp)}"; continue; }
-                if (f.Cp.Count == 0) return $"read {f.Name}: the decimal read nothing\n  text={Jx.Cut(f.Json)}";
-            }
-            if (compared.Count == 0) return AllRefused(c);
-            c.Note(NoteKeys.Compared, "read " + string.Join(", ", compared.Select(f => f.Name)));
-            return null;
-        });
-        var f5 = r.Check(Keeps, docs, c =>
-        {
-            if (readNothing is not null) return ReadLeftOut(c);
-            if (compared.Count == 0) return AllRefused(c);
-            var kept = 0;
-            foreach (var f in compared)
-            {
-                if (f.Cp.Count == 0) continue;   // read nothing, or refused: reads-a-number-or-a-string judges it
-                if (f.Cp.Any(x => !Same(x, d))) return $"read {f.Name}: read {Show(f.Cp)}, expected {d.ToString(Inv)} with its scale\n  text={Jx.Cut(f.Json)}";
-                kept++;
-            }
-            if (kept == 0) return c.Inconclusive("read: no form read a decimal to hold its scale to");
-            c.Note(NoteKeys.Compared, $"read with the scale of {text}");
-            return null;
-        });
-        var f3 = r.Check(Covers, ownVo ? Baseline.RoundTrip : Baseline.Twin, c =>
-        {
-            if (xv is not null && !ownVo) return $"write: the value object threw {Jx.Ex(xv)} where the decimal wrote {Jx.Cut(jp)}";
-            if (xp is not null) return c.Inconclusive("write: the decimal with the converter threw, judged by smallest-scale");
-            if (tb is not null && tb.Count != 0 && tp.Count != tb.Count) return $"write: {tp.Count} decimals in {Jx.Cut(jp)}, {tb.Count} in {Jx.Cut(jb)}";
-            foreach (var t in tp.Where(t => t.Type == JsonTokenType.PropertyName))
-                if (t.Raw != canon) return $"write: key {t.Raw}, expected {canon}, in {Jx.Cut(jp)}";
-            if (ownVo)
-            {
-                // "Your own converter wins" (AspNetCore README#what-the-document-says): the application's converter writes the value object,
-                // so the decimal's document is none of its; its own document reads back under the same options
-                c.Note(NoteKeys.OwnVo);
-                var (_, xr) = Jx.De(jv!, hv.Declared, o);
-                if (xr is not null) return "own converter for the value object: its document does not read back: " + Jx.Ex(xr);
-                return null;
-            }
-            if (jv != jp) return $"write: the value object wrote {Jx.Cut(jv)}, the decimal {Jx.Cut(jp)}";
-            foreach (var f in compared)
-            {
-                if (f.Ep is not null) continue;   // the decimal refused it: reads-a-number-or-a-string judges it
-                if (f.Ev is not null) return $"read {f.Name}: the value object threw {Jx.Ex(f.Ev)} where the decimal read it\n  text={Jx.Cut(f.Json)}";
-                if (f.Cp.Count != f.Cv.Count || f.Cp.Zip(f.Cv).Any(z => !Same(z.First, z.Second))) return $"read {f.Name}: the value object read {Show(f.Cv)}, the decimal {Show(f.Cp)}\n  text={Jx.Cut(f.Json)}";
-            }
-            if (writeLeftOut && (readNothing is not null || compared.Count == 0)) return WriteLeftOut(c);
-            c.Note(NoteKeys.Compared, $"{(number ? "number" : "string")} {text} -> {canon}, the value object's document the decimal's");
-            return null;
-        });
-        return f1 ?? f2 ?? f3 ?? f4 ?? f5;
-    }
-}
diff --git a/tools/probe/corpus/harness/EfExtra.cs b/tools/probe/corpus/harness/EfExtra.cs
deleted file mode 100644
index 26ef7def..00000000
--- a/tools/probe/corpus/harness/EfExtra.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-// Entity shapes and helpers for the EF claims E07, E13, E14, E15 (reuse EfHarness.cs: EfDb, EfModel, Q, EfRegistry, KeyRegistry).
-#nullable enable
-using System.Linq.Expressions;
-using System.Reflection;
-using Microsoft.EntityFrameworkCore;
-using Probes.Shapes;
-namespace Probes.Ef;
-
-public class EntL<T> where T : notnull { public int Id { get; set; } public List<T> Items { get; set; } = []; }
-public class EntComp<TA, TB> where TA : notnull where TB : notnull { public TA A { get; set; } = default!; public TB B { get; set; } = default!; public string Tag { get; set; } = ""; }
-public abstract class RootE<T> where T : notnull { public T Id { get; set; } = default!; public string Name { get; set; } = ""; }
-public class LeafA<T> : RootE<T> where T : notnull { public int X { get; set; } }
-public class LeafB<T> : RootE<T> where T : notnull { public int Y { get; set; } }
-
-public static class EfX
-{
-    /// <summary>The i-th distinct plain value of a wrapped type.</summary>
-    public static object Sample(string wrapped, int i) => wrapped switch
-    {
-        "string" => "val-" + (char)('a' + i),
-        "int" => 10 + i,
-        "long" => 4_000_000_000L + i,
-        "Guid" => new Guid(i + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11),
-        "decimal" => 1.5m + i,
-        _ => throw new ArgumentException(wrapped),
-    };
-    public static EfEntry Top(string kind, string wrapped) => EfRegistry.All.FirstOrDefault(x => x.Kind == kind && x.Wrapped == wrapped && x.Site == "top-level")
-        ?? EfRegistry.All.First(x => (x.Kind is "record-struct" or "sealed-record-class") && x.Wrapped == wrapped && x.Site == "top-level");
-    public static readonly string[] Kinds = ["record-struct", "sealed-record-class", "validated-class", "validated-struct"];
-    public static object New(Type t) => Activator.CreateInstance(t)!;
-    public static void Set(object o, string prop, object? v) => o.GetType().GetProperty(prop)!.SetValue(o, v);
-    public static object? Get(object o, string prop) => o.GetType().GetProperty(prop)!.GetValue(o);
-    public static string Plainify(object? k)
-    {
-        if (k is not null && k.GetType().Namespace == "Probes.Ef") k = k.GetType().GetProperty("Value")!.GetValue(k);
-        return Convert.ToString(k, System.Globalization.CultureInfo.InvariantCulture) ?? "null";
-    }
-    public static IEnumerable<object> Enumerate(IQueryable q) { foreach (var o in q) yield return o!; }
-    public static async Task<string?> RawScalar(EfDb db, string sql)
-    {
-        await using var cmd = db.Connection.CreateCommand(); cmd.CommandText = sql;
-        return Convert.ToString(await cmd.ExecuteScalarAsync(), System.Globalization.CultureInfo.InvariantCulture);
-    }
-    public static async Task Raw(EfDb db, string sql)
-    {
-        await using var cmd = db.Connection.CreateCommand(); cmd.CommandText = sql; await cmd.ExecuteNonQueryAsync();
-    }
-}
diff --git a/tools/probe/corpus/harness/EfExtra2.cs b/tools/probe/corpus/harness/EfExtra2.cs
deleted file mode 100644
index 2cffd4cf..00000000
--- a/tools/probe/corpus/harness/EfExtra2.cs
+++ /dev/null
@@ -1,82 +0,0 @@
-// Shared by the EF claims E06, E11, E12, E16 (after EfHarness.cs / EfExtra.cs): a context with ConventionS and the order of UseTypeKit,
-// and an application-owned converter ("C:" + the plain value as text) for any type.
-#nullable enable
-using System.Globalization;
-using Microsoft.Data.Sqlite;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using Probes.Shapes;
-namespace Probes.Ef;
-
-public sealed class DynCtx2(DbContextOptions options, Action<ModelBuilder> configure, Action<ModelConfigurationBuilder>? conventions) : DbContext(options)
-{
-    protected override void OnModelCreating(ModelBuilder modelBuilder) => configure(modelBuilder);
-    protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder) => conventions?.Invoke(configurationBuilder);
-}
-
-public sealed class EfDb2 : IAsyncDisposable
-{
-    public SqliteConnection Connection { get; }
-    public DynCtx2 Context { get; }
-    // order: "none" (no UseTypeKit), "before-provider" or "after-provider".
-    public EfDb2(Action<ModelBuilder> configure, string order, Action<ModelConfigurationBuilder>? conventions = null)
-    {
-        Connection = new SqliteConnection("Data Source=:memory:");
-        Connection.Open();
-        var b = new DbContextOptionsBuilder<DynCtx2>();
-        if (order == "before-provider") b.UseTypeKit();
-        b.UseSqlite(Connection);
-        if (order == "after-provider") b.UseTypeKit();
-        b.ReplaceService<IModelCacheKeyFactory, UniqueModelKey>();
-        Context = new DynCtx2(b.Options, configure, conventions);
-    }
-    public async ValueTask DisposeAsync() { await Context.DisposeAsync(); await Connection.DisposeAsync(); }
-}
-
-/// <summary>An application-owned conversion of T to text: "C:" + the plain value. T is the value object or its wrapped type.</summary>
-public static class OwnConv<T>
-{
-    public static Func<T, string> ToF = _ => throw new InvalidOperationException("OwnConv not set up");
-    public static Func<string, T> FromF = _ => throw new InvalidOperationException("OwnConv not set up");
-    public static string To(T v) => ToF(v);
-    public static T From(string s) => FromF(s);
-    public static void Setup(string wrapped, Func<object, object> make, Func<object, object> plain)
-    {
-        ToF = v => "C:" + Fmt(plain(v!));
-        FromF = s => (T)make(Parse(wrapped, s[2..]));
-    }
-    public static string Fmt(object p) => Convert.ToString(p, CultureInfo.InvariantCulture)!;
-    public static object Parse(string wrapped, string s) => wrapped switch
-    {
-        "string" => s, "int" => int.Parse(s, CultureInfo.InvariantCulture), "long" => long.Parse(s, CultureInfo.InvariantCulture),
-        "Guid" => Guid.Parse(s), "decimal" => decimal.Parse(s, CultureInfo.InvariantCulture), "char" => s[0],
-        _ => throw new ArgumentException(wrapped),
-    };
-}
-
-public sealed class OwnConverter<T>() : ValueConverter<T, string>(v => OwnConv<T>.To(v), s => OwnConv<T>.From(s));
-
-public static class OwnConvs
-{
-    /// <summary>Sets OwnConv up for the value object (voSide) or for its wrapped type, returns the converter type.</summary>
-    public static Type Setup(EfEntry e, bool vo)
-    {
-        if (vo)
-        {
-            typeof(OwnConv<>).MakeGenericType(e.Vo).GetMethod("Setup")!.Invoke(null, [e.Wrapped, (Func<object, object>)e.MakeVo, (Func<object, object>)(v => v.GetType().GetProperty("Value")!.GetValue(v)!)]);
-            return typeof(OwnConverter<>).MakeGenericType(e.Vo);
-        }
-        typeof(OwnConv<>).MakeGenericType(e.Plain).GetMethod("Setup")!.Invoke(null, [e.Wrapped, (Func<object, object>)(p => p), (Func<object, object>)(p => p)]);
-        return typeof(OwnConverter<>).MakeGenericType(e.Plain);
-    }
-}
-
-public static class EfX2
-{
-    public static async Task<string?> RawScalar(SqliteConnection c, string sql)
-    {
-        await using var cmd = c.CreateCommand(); cmd.CommandText = sql;
-        return Convert.ToString(await cmd.ExecuteScalarAsync(), CultureInfo.InvariantCulture);
-    }
-}
diff --git a/tools/probe/corpus/harness/EfHarness.cs b/tools/probe/corpus/harness/EfHarness.cs
deleted file mode 100644
index c6de75a1..00000000
--- a/tools/probe/corpus/harness/EfHarness.cs
+++ /dev/null
@@ -1,191 +0,0 @@
-// Shared EF row-applying code for the EF satellite claims (surface ef): the entity shapes, a DbContext built from a
-// configuration delegate, the model descriptor and the query helpers. Written once; later EF claims reuse it.
-#nullable enable
-using System.Linq.Expressions;
-using System.Reflection;
-using Microsoft.Data.Sqlite;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Metadata;
-using Microsoft.EntityFrameworkCore.Metadata.Builders;
-using Probes.Shapes;
-namespace Probes.Ef;
-
-public sealed record EfEntry(string Kind, string Wrapped, string Site, Type Vo, Type Plain, Func<object> Valid)
-{
-    /// <summary>The value object around a plain value, by its public seams: From, else FromKnownGood.</summary>
-    public object MakeVo(object plain)
-    {
-        var from = Vo.GetMethod("From", BindingFlags.Public | BindingFlags.Static, [Plain]);
-        if (from is not null) return from.Invoke(null, [plain])!;
-        var known = Vo.GetMethod("FromKnownGood", BindingFlags.Public | BindingFlags.Static, [Plain, typeof(string)]);
-        return known is null ? throw new InvalidOperationException($"{Vo} has neither From nor FromKnownGood") : known.Invoke(null, [plain, null])!;
-    }
-
-    /// <summary>The generated companion extension GetValue / ValueOrNull of this value object (a static class in its namespace; the first parameter is the value object, or its Nullable for ValueOrNull).</summary>
-    public MethodInfo? Companion(string name)
-    {
-        var first = name == "ValueOrNull" && Vo.IsValueType ? typeof(Nullable<>).MakeGenericType(Vo) : Vo;
-        return Vo.Assembly.GetTypes().Where(t => t.IsAbstract && t.IsSealed && t.Namespace == Vo.Namespace)
-            .SelectMany(t => t.GetMethods(BindingFlags.Public | BindingFlags.Static))
-            .FirstOrDefault(m => m.Name == name && m.GetParameters() is [var p] && p.ParameterType == first);
-    }
-}
-
-public static partial class EfRegistry
-{
-    public static readonly List<EfEntry> All = Build();
-    static List<EfEntry> Build() { var e = new List<EfEntry>(); Fill(e); return e; }
-    static partial void Fill(List<EfEntry> e);
-    public static EfEntry Of(Row r) { var k = r["shape.kind"]; var w = r["shape.wrapped"]; var s = r["shape.site"]; return All.First(x => x.Kind == k && x.Wrapped == w && x.Site == s); }
-}
-
-public class EntP<T> where T : notnull { public int Id { get; set; } public T P { get; set; } = default!; }
-public class EntNC<T> where T : class { public int Id { get; set; } public T? P { get; set; } }
-public class EntK<T> where T : notnull { public T Id { get; set; } = default!; public string Tag { get; set; } = ""; }
-public class Own<T> where T : notnull { public T P { get; set; } = default!; }
-public class EntO<T> where T : notnull { public int Id { get; set; } public Own<T> O { get; set; } = new(); }
-public class EntC<T> where T : notnull { public int Id { get; set; } public Own<T> C { get; set; } = new(); }
-public sealed class Box<T> { public T Value = default!; }
-
-public sealed class UniqueModelKey : Microsoft.EntityFrameworkCore.Infrastructure.IModelCacheKeyFactory
-{
-    public object Create(DbContext context, bool designTime) => new object();
-}
-
-public sealed class DynCtx(DbContextOptions options, Action<ModelBuilder> configure) : DbContext(options)
-{
-    protected override void OnModelCreating(ModelBuilder modelBuilder) => configure(modelBuilder);
-}
-
-public sealed class EfDb : IAsyncDisposable
-{
-    public SqliteConnection Connection { get; }
-    public DynCtx Context { get; }
-    public EfDb(Action<ModelBuilder> configure, bool typeKit, Action<DbContextOptionsBuilder>? extra = null)
-    {
-        Connection = new SqliteConnection("Data Source=:memory:");
-        Connection.Open();
-        var b = new DbContextOptionsBuilder<DynCtx>().UseSqlite(Connection).ReplaceService<IModelCacheKeyFactory, UniqueModelKey>();
-        if (typeKit) b.UseTypeKit();
-        extra?.Invoke(b);
-        Context = new DynCtx(b.Options, configure);
-    }
-    public async ValueTask DisposeAsync() { await Context.DisposeAsync(); await Connection.DisposeAsync(); }
-}
-
-public static class EfModel
-{
-    public static Type Entity(string mapping, Type t) => mapping switch
-    {
-        "property" => typeof(EntP<>).MakeGenericType(t),
-        "nullable" => t.IsValueType ? typeof(EntP<>).MakeGenericType(typeof(Nullable<>).MakeGenericType(t)) : typeof(EntNC<>).MakeGenericType(t),
-        "key" => typeof(EntK<>).MakeGenericType(t),
-        "owned" => typeof(EntO<>).MakeGenericType(t),
-        "complex" => typeof(EntC<>).MakeGenericType(t),
-        _ => throw new ArgumentException("mapping " + mapping),
-    };
-
-    public static readonly Dictionary<string, string> ColumnTypes = new()
-    {
-        ["string"] = "VARCHAR(40)", ["Uri"] = "VARCHAR(40)", ["Guid"] = "UNIQUEIDENTIFIER", ["int"] = "BIGINT", ["long"] = "BIGINT", ["byte"] = "TINYINT",
-        ["ulong"] = "BIGINT", ["decimal"] = "NUMERIC(10,2)", ["double"] = "FLOAT", ["bool"] = "BIT", ["char"] = "CHAR(1)", ["DateTime"] = "DATETIME",
-        ["DateTimeOffset"] = "DATETIMEOFFSET", ["DateOnly"] = "DATE", ["TimeOnly"] = "TIME", ["TimeSpan"] = "TIME", ["enum"] = "SMALLINT", ["flags-enum"] = "SMALLINT",
-    };
-
-    /// <summary>Maps the entity of a mapping in table "t", applying a facet to the column property (and UseAutoincrement to an integer key when asked).</summary>
-    public static Action<ModelBuilder> Configure(string mapping, Type entity, Action<IMutableProperty>? facet, bool autoincrement) => mb =>
-    {
-        var eb = mb.Entity(entity);
-        eb.ToTable("t");
-        var t = entity.GetGenericArguments()[0];
-        switch (mapping)
-        {
-            case "property" or "nullable": eb.HasKey("Id"); if (facet is not null) facet(eb.Property("P").Metadata); break;
-            case "key":
-                eb.HasKey("Id");
-                var pb = eb.Property("Id");
-                facet?.Invoke(pb.Metadata);
-                if (autoincrement) Microsoft.EntityFrameworkCore.SqlitePropertyBuilderExtensions.UseAutoincrement(pb);
-                break;
-            case "owned":
-                eb.HasKey("Id");
-                eb.OwnsOne(typeof(Own<>).MakeGenericType(t), "O", ob => { if (facet is not null) facet(ob.Property("P").Metadata); });
-                break;
-            case "complex":
-                eb.HasKey("Id");
-                eb.ComplexProperty("C", cb => { if (facet is not null) facet(cb.Property("P").Metadata); });
-                break;
-        }
-    };
-
-    /// <summary>What the model says about every mapped column: store type, nullability, facets, key and generation.</summary>
-    public static string Describe(DbContext db)
-    {
-        var model = db.GetService<IDesignTimeModel>().Model;
-        var lines = new List<string>();
-        string Line(string table, string prefix, IProperty p)
-        {
-            string col = "?"; try { col = ((IReadOnlyProperty)p).GetColumnType() ?? "?"; } catch { try { col = Microsoft.EntityFrameworkCore.RelationalPropertyExtensions.GetRelationalTypeMapping(p).StoreType; } catch { col = "?"; } }
-            string nul; try { nul = p.IsColumnNullable().ToString(); } catch { nul = p.IsNullable.ToString(); }
-            return $"{table}.{prefix}{p.Name}: type={col} nullable={nul} max={p.GetMaxLength()} prec={p.GetPrecision()} scale={p.GetScale()} unicode={p.IsUnicode()} pk={p.IsPrimaryKey()} gen={p.ValueGenerated}";
-        }
-        foreach (var et in model.GetEntityTypes())
-        {
-            var table = et.GetTableName() ?? "(none)";
-            foreach (var p in et.GetProperties()) lines.Add(Line(table, "", p));
-            foreach (var cp in et.GetComplexProperties()) foreach (var p in cp.ComplexType.GetProperties()) lines.Add(Line(table, cp.Name + ".", p));
-        }
-        lines.Sort(StringComparer.Ordinal);
-        return string.Join("\n", lines);
-    }
-
-    public static string FirstDiff(string a, string b)
-    {
-        var x = a.Split('\n'); var y = b.Split('\n');
-        for (var i = 0; i < Math.Max(x.Length, y.Length); i++)
-            if ((i < x.Length ? x[i] : "<none>") != (i < y.Length ? y[i] : "<none>")) return $"VO: {(i < x.Length ? x[i] : "<none>")} | plain: {(i < y.Length ? y[i] : "<none>")}";
-        return "";
-    }
-}
-
-/// <summary>
-/// How a check of a two-sided EF row ends where a side threw: the value object's context under <c>UseTypeKit()</c> and the
-/// wrapped twin's under plain EF ran the same step, named by <c>what</c>. Neither threw: false, compare on. The value object
-/// alone: its violation. Both, with exceptions of one type: nothing to compare, inconclusive, since no fact or sentence says why
-/// the framework refuses it. Both, otherwise: a violation, since the value object did not fail as its twin does. The twin alone:
-/// inconclusive, no twin to compare with.
-/// </summary>
-public static class EfSides
-{
-    public static bool Threw(Check c, Exception? vo, Exception? plain, string what, out string? failure)
-    {
-        failure = null;
-        if (vo is null && plain is null) return false;
-        if (vo is not null && plain is not null)
-            failure = vo.GetType() == plain.GetType()
-                ? c.Inconclusive($"both sides refuse {what} alike: {vo.GetType().Name}: {Short(vo.Message)}")
-                : $"{what}: the value object's side threw {vo.GetType().Name}: {Short(vo.Message)}; the wrapped type's {plain.GetType().Name}: {Short(plain.Message)}";
-        else if (plain is not null) failure = c.Inconclusive($"the wrapped type's side refuses {what}, so there is no twin to compare with: {plain.GetType().Name}: {Short(plain.Message)}");
-        else failure = $"{what} with the value object threw {vo!.GetType().Name}: {Short(vo.Message)}; the wrapped type's did not";
-        return true;
-    }
-
-    static string Short(string s) { s = s.Split('\n')[0]; return s.Length > 300 ? s[..300] : s; }
-}
-
-public static class Q
-{
-    public static IQueryable Call(string name, Type[] typeArgs, IQueryable src, params Expression[] args)
-    {
-        static bool OneParamLambda(ParameterInfo p) =>
-            p.ParameterType.IsGenericType && p.ParameterType.GetGenericTypeDefinition() == typeof(Expression<>) && p.ParameterType.GetGenericArguments()[0].GetGenericArguments().Length == 2;
-        var m = typeof(Queryable).GetMethods().First(x => x.Name == name && x.IsGenericMethodDefinition && x.GetGenericArguments().Length == typeArgs.Length
-            && x.GetParameters().Length == args.Length + 1 && x.GetParameters().Skip(1).All(OneParamLambda));
-        return (IQueryable)m.MakeGenericMethod(typeArgs).Invoke(null, [src, .. args.Select(a => (object)a)])!;
-    }
-    public static IQueryable SetOf(DbContext db, Type entity) =>
-        (IQueryable)typeof(DbContext).GetMethods().First(m => m.Name == "Set" && m.GetParameters().Length == 0).MakeGenericMethod(entity).Invoke(db, null)!;
-    public static object NewBox(Type t, object? value) { var b = Activator.CreateInstance(typeof(Box<>).MakeGenericType(t))!; typeof(Box<>).MakeGenericType(t).GetField("Value")!.SetValue(b, value); return b; }
-    public static string Sql(IQueryable q) => q.ToQueryString();
-}
diff --git a/tools/probe/corpus/harness/EfShapes.g.cs b/tools/probe/corpus/harness/EfShapes.g.cs
deleted file mode 100644
index 95fa592f..00000000
--- a/tools/probe/corpus/harness/EfShapes.g.cs
+++ /dev/null
@@ -1,962 +0,0 @@
-// <auto-generated/> by tools/probe/generators/ef.cs catalogue; the EF probes' shape catalogue (shape.kind x shape.wrapped x shape.site). Do not edit.
-#nullable enable
-#pragma warning disable CMTK0014, CS8618, CS1591, CMTK0005, CMTK1000, CMTK0003, CMTK0006, CA1000
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.ValueObjects;
-using Probes.Shapes;
-namespace Probes.Ef;
-public struct S_E_record_struct_DateOnly
-{
-public readonly partial record struct V : IValue<DateOnly>;
-}
-public static class C2_E_record_struct_DateOnly
-{
- public static class Inner
- {
-public readonly partial record struct V : IValue<DateOnly>;
- }
-}
-public readonly partial record struct E_record_struct_DateOnly : IValue<DateOnly>;
-public static class C_E_record_struct_DateTime
-{
-public readonly partial record struct V : IValue<DateTime>;
-}
-public static class C2_E_record_struct_DateTime
-{
- public static class Inner
- {
-public readonly partial record struct V : IValue<DateTime>;
- }
-}
-public readonly partial record struct E_record_struct_DateTime : IValue<DateTime>;
-public readonly partial record struct E_record_struct_DateTimeOffset : IValue<DateTimeOffset>;
-public static class C_E_record_struct_Guid
-{
-public readonly partial record struct V : IValue<Guid>;
-}
-public static class C2_E_record_struct_Guid
-{
- public static class Inner
- {
-public readonly partial record struct V : IValue<Guid>;
- }
-}
-public readonly partial record struct E_record_struct_Guid : IValue<Guid>;
-public static class C2_E_record_struct_TimeOnly
-{
- public static class Inner
- {
-public readonly partial record struct V : IValue<TimeOnly>;
- }
-}
-public static class C_E_record_struct_TimeSpan
-{
-public readonly partial record struct V : IValue<TimeSpan>;
-}
-public struct S_E_record_struct_TimeSpan
-{
-public readonly partial record struct V : IValue<TimeSpan>;
-}
-public static class C_E_record_struct_Uri
-{
-public readonly partial record struct V : IValue<Uri>;
-}
-public static class C2_E_record_struct_Uri
-{
- public static class Inner
- {
-public readonly partial record struct V : IValue<Uri>;
- }
-}
-public readonly partial record struct E_record_struct_Uri : IValue<Uri>;
-public struct S_E_record_struct_bool
-{
-public readonly partial record struct V : IValue<bool>;
-}
-public readonly partial record struct E_record_struct_bool : IValue<bool>;
-public static class C2_E_record_struct_byte
-{
- public static class Inner
- {
-public readonly partial record struct V : IValue<byte>;
- }
-}
-public readonly partial record struct E_record_struct_byte : IValue<byte>;
-public static class C_E_record_struct_char
-{
-public readonly partial record struct V : IValue<char>;
-}
-public struct S_E_record_struct_char
-{
-public readonly partial record struct V : IValue<char>;
-}
-public readonly partial record struct E_record_struct_char : IValue<char>;
-public struct S_E_record_struct_decimal
-{
-public readonly partial record struct V : IValue<decimal>;
-}
-public static class C2_E_record_struct_decimal
-{
- public static class Inner
- {
-public readonly partial record struct V : IValue<decimal>;
- }
-}
-public readonly partial record struct E_record_struct_decimal : IValue<decimal>;
-public struct S_E_record_struct_double
-{
-public readonly partial record struct V : IValue<double>;
-}
-public static class C2_E_record_struct_enum
-{
- public static class Inner
- {
-public readonly partial record struct V : IValue<PEnum>;
- }
-}
-public readonly partial record struct E_record_struct_enum : IValue<PEnum>;
-public static class C2_E_record_struct_flags_enum
-{
- public static class Inner
- {
-public readonly partial record struct V : IValue<PFlags>;
- }
-}
-public readonly partial record struct E_record_struct_flags_enum : IValue<PFlags>;
-public static class C2_E_record_struct_int
-{
- public static class Inner
- {
-public readonly partial record struct V : IValue<int>;
- }
-}
-public readonly partial record struct E_record_struct_int : IValue<int>;
-public static class C2_E_record_struct_long
-{
- public static class Inner
- {
-public readonly partial record struct V : IValue<long>;
- }
-}
-public readonly partial record struct E_record_struct_long : IValue<long>;
-public static class C_E_record_struct_string
-{
-public readonly partial record struct V : IValue<string>;
-}
-public struct S_E_record_struct_ulong
-{
-public readonly partial record struct V : IValue<ulong>;
-}
-public struct S_E_sealed_record_class_DateOnly
-{
-public sealed partial record class V : IValue<DateOnly>;
-}
-public static class C2_E_sealed_record_class_DateOnly
-{
- public static class Inner
- {
-public sealed partial record class V : IValue<DateOnly>;
- }
-}
-public struct S_E_sealed_record_class_DateTime
-{
-public sealed partial record class V : IValue<DateTime>;
-}
-public static class C2_E_sealed_record_class_DateTime
-{
- public static class Inner
- {
-public sealed partial record class V : IValue<DateTime>;
- }
-}
-public static class C_E_sealed_record_class_DateTimeOffset
-{
-public sealed partial record class V : IValue<DateTimeOffset>;
-}
-public struct S_E_sealed_record_class_DateTimeOffset
-{
-public sealed partial record class V : IValue<DateTimeOffset>;
-}
-public static class C2_E_sealed_record_class_DateTimeOffset
-{
- public static class Inner
- {
-public sealed partial record class V : IValue<DateTimeOffset>;
- }
-}
-public static class C2_E_sealed_record_class_Guid
-{
- public static class Inner
- {
-public sealed partial record class V : IValue<Guid>;
- }
-}
-public static class C_E_sealed_record_class_TimeOnly
-{
-public sealed partial record class V : IValue<TimeOnly>;
-}
-public struct S_E_sealed_record_class_TimeOnly
-{
-public sealed partial record class V : IValue<TimeOnly>;
-}
-public static class C2_E_sealed_record_class_TimeOnly
-{
- public static class Inner
- {
-public sealed partial record class V : IValue<TimeOnly>;
- }
-}
-public sealed partial record class E_sealed_record_class_TimeSpan : IValue<TimeSpan>;
-public static class C_E_sealed_record_class_Uri
-{
-public sealed partial record class V : IValue<Uri>;
-}
-public struct S_E_sealed_record_class_Uri
-{
-public sealed partial record class V : IValue<Uri>;
-}
-public static class C2_E_sealed_record_class_Uri
-{
- public static class Inner
- {
-public sealed partial record class V : IValue<Uri>;
- }
-}
-public static class C2_E_sealed_record_class_bool
-{
- public static class Inner
- {
-public sealed partial record class V : IValue<bool>;
- }
-}
-public static class C_E_sealed_record_class_byte
-{
-public sealed partial record class V : IValue<byte>;
-}
-public struct S_E_sealed_record_class_byte
-{
-public sealed partial record class V : IValue<byte>;
-}
-public struct S_E_sealed_record_class_char
-{
-public sealed partial record class V : IValue<char>;
-}
-public sealed partial record class E_sealed_record_class_char : IValue<char>;
-public static class C_E_sealed_record_class_decimal
-{
-public sealed partial record class V : IValue<decimal>;
-}
-public static class C2_E_sealed_record_class_decimal
-{
- public static class Inner
- {
-public sealed partial record class V : IValue<decimal>;
- }
-}
-public static class C2_E_sealed_record_class_double
-{
- public static class Inner
- {
-public sealed partial record class V : IValue<double>;
- }
-}
-public sealed partial record class E_sealed_record_class_double : IValue<double>;
-public sealed partial record class E_sealed_record_class_enum : IValue<PEnum>;
-public static class C_E_sealed_record_class_flags_enum
-{
-public sealed partial record class V : IValue<PFlags>;
-}
-public sealed partial record class E_sealed_record_class_flags_enum : IValue<PFlags>;
-public static class C_E_sealed_record_class_int
-{
-public sealed partial record class V : IValue<int>;
-}
-public struct S_E_sealed_record_class_int
-{
-public sealed partial record class V : IValue<int>;
-}
-public static class C_E_sealed_record_class_long
-{
-public sealed partial record class V : IValue<long>;
-}
-public static class C_E_sealed_record_class_string
-{
-public sealed partial record class V : IValue<string>;
-}
-public struct S_E_sealed_record_class_string
-{
-public sealed partial record class V : IValue<string>;
-}
-public sealed partial record class E_sealed_record_class_string : IValue<string>;
-public static class C_E_sealed_record_class_ulong
-{
-public sealed partial record class V : IValue<ulong>;
-}
-public struct S_E_validated_class_DateOnly
-{
-public sealed partial record class V : IValidatedValue<V, DateOnly, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(DateOnly value) =>
-        EqualityComparer<DateOnly>.Default.Equals(value, DateOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public struct S_E_validated_class_DateTimeOffset
-{
-public sealed partial record class V : IValidatedValue<V, DateTimeOffset, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(DateTimeOffset value) =>
-        EqualityComparer<DateTimeOffset>.Default.Equals(value, DateTimeOffset.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public static class C_E_validated_class_Guid
-{
-public sealed partial record class V : IValidatedValue<V, Guid, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(Guid value) =>
-        EqualityComparer<Guid>.Default.Equals(value, Guid.Empty) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public struct S_E_validated_class_Guid
-{
-public sealed partial record class V : IValidatedValue<V, Guid, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(Guid value) =>
-        EqualityComparer<Guid>.Default.Equals(value, Guid.Empty) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public sealed partial record class E_validated_class_Guid : IValidatedValue<E_validated_class_Guid, Guid, ShapeFault>
-{
-    public static Result<E_validated_class_Guid, ShapeFault> Create(Guid value) =>
-        EqualityComparer<Guid>.Default.Equals(value, Guid.Empty) ? Result.Error(ShapeFault.Refused) : new E_validated_class_Guid(value);
-}
-public static class C_E_validated_class_TimeOnly
-{
-public sealed partial record class V : IValidatedValue<V, TimeOnly, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(TimeOnly value) =>
-        EqualityComparer<TimeOnly>.Default.Equals(value, TimeOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public sealed partial record class E_validated_class_TimeOnly : IValidatedValue<E_validated_class_TimeOnly, TimeOnly, ShapeFault>
-{
-    public static Result<E_validated_class_TimeOnly, ShapeFault> Create(TimeOnly value) =>
-        EqualityComparer<TimeOnly>.Default.Equals(value, TimeOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new E_validated_class_TimeOnly(value);
-}
-public static class C2_E_validated_class_TimeSpan
-{
- public static class Inner
- {
-public sealed partial record class V : IValidatedValue<V, TimeSpan, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(TimeSpan value) =>
-        EqualityComparer<TimeSpan>.Default.Equals(value, TimeSpan.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
- }
-}
-public struct S_E_validated_class_Uri
-{
-public sealed partial record class V : IValidatedValue<V, Uri, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(Uri value) =>
-        EqualityComparer<Uri>.Default.Equals(value, new Uri("https://example.com/refused")) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public static class C_E_validated_class_bool
-{
-public sealed partial record class V : IValidatedValue<V, bool, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(bool value) =>
-        EqualityComparer<bool>.Default.Equals(value, false) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public struct S_E_validated_class_bool
-{
-public sealed partial record class V : IValidatedValue<V, bool, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(bool value) =>
-        EqualityComparer<bool>.Default.Equals(value, false) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public sealed partial record class E_validated_class_bool : IValidatedValue<E_validated_class_bool, bool, ShapeFault>
-{
-    public static Result<E_validated_class_bool, ShapeFault> Create(bool value) =>
-        EqualityComparer<bool>.Default.Equals(value, false) ? Result.Error(ShapeFault.Refused) : new E_validated_class_bool(value);
-}
-public static class C_E_validated_class_byte
-{
-public sealed partial record class V : IValidatedValue<V, byte, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(byte value) =>
-        EqualityComparer<byte>.Default.Equals(value, (byte)255) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public sealed partial record class E_validated_class_byte : IValidatedValue<E_validated_class_byte, byte, ShapeFault>
-{
-    public static Result<E_validated_class_byte, ShapeFault> Create(byte value) =>
-        EqualityComparer<byte>.Default.Equals(value, (byte)255) ? Result.Error(ShapeFault.Refused) : new E_validated_class_byte(value);
-}
-public static class C_E_validated_class_char
-{
-public sealed partial record class V : IValidatedValue<V, char, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(char value) =>
-        EqualityComparer<char>.Default.Equals(value, 'x') ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public static class C2_E_validated_class_char
-{
- public static class Inner
- {
-public sealed partial record class V : IValidatedValue<V, char, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(char value) =>
-        EqualityComparer<char>.Default.Equals(value, 'x') ? Result.Error(ShapeFault.Refused) : new V(value);
-}
- }
-}
-public static class C_E_validated_class_double
-{
-public sealed partial record class V : IValidatedValue<V, double, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(double value) =>
-        EqualityComparer<double>.Default.Equals(value, -1.0) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public static class C2_E_validated_class_double
-{
- public static class Inner
- {
-public sealed partial record class V : IValidatedValue<V, double, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(double value) =>
-        EqualityComparer<double>.Default.Equals(value, -1.0) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
- }
-}
-public struct S_E_validated_class_enum
-{
-public sealed partial record class V : IValidatedValue<V, PEnum, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(PEnum value) =>
-        EqualityComparer<PEnum>.Default.Equals(value, (PEnum)99) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public static class C2_E_validated_class_enum
-{
- public static class Inner
- {
-public sealed partial record class V : IValidatedValue<V, PEnum, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(PEnum value) =>
-        EqualityComparer<PEnum>.Default.Equals(value, (PEnum)99) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
- }
-}
-public static class C_E_validated_class_flags_enum
-{
-public sealed partial record class V : IValidatedValue<V, PFlags, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(PFlags value) =>
-        EqualityComparer<PFlags>.Default.Equals(value, (PFlags)0) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public struct S_E_validated_class_flags_enum
-{
-public sealed partial record class V : IValidatedValue<V, PFlags, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(PFlags value) =>
-        EqualityComparer<PFlags>.Default.Equals(value, (PFlags)0) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public static class C2_E_validated_class_flags_enum
-{
- public static class Inner
- {
-public sealed partial record class V : IValidatedValue<V, PFlags, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(PFlags value) =>
-        EqualityComparer<PFlags>.Default.Equals(value, (PFlags)0) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
- }
-}
-public static class C2_E_validated_class_int
-{
- public static class Inner
- {
-public sealed partial record class V : IValidatedValue<V, int, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(int value) =>
-        EqualityComparer<int>.Default.Equals(value, -1) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
- }
-}
-public sealed partial record class E_validated_class_int : IValidatedValue<E_validated_class_int, int, ShapeFault>
-{
-    public static Result<E_validated_class_int, ShapeFault> Create(int value) =>
-        EqualityComparer<int>.Default.Equals(value, -1) ? Result.Error(ShapeFault.Refused) : new E_validated_class_int(value);
-}
-public struct S_E_validated_class_long
-{
-public sealed partial record class V : IValidatedValue<V, long, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(long value) =>
-        EqualityComparer<long>.Default.Equals(value, -1L) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public static class C2_E_validated_class_long
-{
- public static class Inner
- {
-public sealed partial record class V : IValidatedValue<V, long, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(long value) =>
-        EqualityComparer<long>.Default.Equals(value, -1L) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
- }
-}
-public struct S_E_validated_class_string
-{
-public sealed partial record class V : IValidatedValue<V, string, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(string value) =>
-        EqualityComparer<string>.Default.Equals(value, "SECRET-7f3a") ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public static class C2_E_validated_class_string
-{
- public static class Inner
- {
-public sealed partial record class V : IValidatedValue<V, string, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(string value) =>
-        EqualityComparer<string>.Default.Equals(value, "SECRET-7f3a") ? Result.Error(ShapeFault.Refused) : new V(value);
-}
- }
-}
-public struct S_E_validated_class_ulong
-{
-public sealed partial record class V : IValidatedValue<V, ulong, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(ulong value) =>
-        EqualityComparer<ulong>.Default.Equals(value, 0UL) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public sealed partial record class E_validated_class_ulong : IValidatedValue<E_validated_class_ulong, ulong, ShapeFault>
-{
-    public static Result<E_validated_class_ulong, ShapeFault> Create(ulong value) =>
-        EqualityComparer<ulong>.Default.Equals(value, 0UL) ? Result.Error(ShapeFault.Refused) : new E_validated_class_ulong(value);
-}
-public static class C_E_validated_struct_DateOnly
-{
-public readonly partial record struct V : IValidatedValue<V, DateOnly, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(DateOnly value) =>
-        EqualityComparer<DateOnly>.Default.Equals(value, DateOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public readonly partial record struct E_validated_struct_DateOnly : IValidatedValue<E_validated_struct_DateOnly, DateOnly, ShapeFault>
-{
-    public static Result<E_validated_struct_DateOnly, ShapeFault> Create(DateOnly value) =>
-        EqualityComparer<DateOnly>.Default.Equals(value, DateOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new E_validated_struct_DateOnly(value);
-}
-public static class C_E_validated_struct_DateTime
-{
-public readonly partial record struct V : IValidatedValue<V, DateTime, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(DateTime value) =>
-        EqualityComparer<DateTime>.Default.Equals(value, DateTime.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public struct S_E_validated_struct_DateTime
-{
-public readonly partial record struct V : IValidatedValue<V, DateTime, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(DateTime value) =>
-        EqualityComparer<DateTime>.Default.Equals(value, DateTime.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public static class C_E_validated_struct_DateTimeOffset
-{
-public readonly partial record struct V : IValidatedValue<V, DateTimeOffset, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(DateTimeOffset value) =>
-        EqualityComparer<DateTimeOffset>.Default.Equals(value, DateTimeOffset.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public static class C2_E_validated_struct_DateTimeOffset
-{
- public static class Inner
- {
-public readonly partial record struct V : IValidatedValue<V, DateTimeOffset, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(DateTimeOffset value) =>
-        EqualityComparer<DateTimeOffset>.Default.Equals(value, DateTimeOffset.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
- }
-}
-public static class C_E_validated_struct_Guid
-{
-public readonly partial record struct V : IValidatedValue<V, Guid, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(Guid value) =>
-        EqualityComparer<Guid>.Default.Equals(value, Guid.Empty) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public struct S_E_validated_struct_Guid
-{
-public readonly partial record struct V : IValidatedValue<V, Guid, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(Guid value) =>
-        EqualityComparer<Guid>.Default.Equals(value, Guid.Empty) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public struct S_E_validated_struct_TimeOnly
-{
-public readonly partial record struct V : IValidatedValue<V, TimeOnly, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(TimeOnly value) =>
-        EqualityComparer<TimeOnly>.Default.Equals(value, TimeOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public readonly partial record struct E_validated_struct_TimeOnly : IValidatedValue<E_validated_struct_TimeOnly, TimeOnly, ShapeFault>
-{
-    public static Result<E_validated_struct_TimeOnly, ShapeFault> Create(TimeOnly value) =>
-        EqualityComparer<TimeOnly>.Default.Equals(value, TimeOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new E_validated_struct_TimeOnly(value);
-}
-public static class C_E_validated_struct_TimeSpan
-{
-public readonly partial record struct V : IValidatedValue<V, TimeSpan, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(TimeSpan value) =>
-        EqualityComparer<TimeSpan>.Default.Equals(value, TimeSpan.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public readonly partial record struct E_validated_struct_Uri : IValidatedValue<E_validated_struct_Uri, Uri, ShapeFault>
-{
-    public static Result<E_validated_struct_Uri, ShapeFault> Create(Uri value) =>
-        EqualityComparer<Uri>.Default.Equals(value, new Uri("https://example.com/refused")) ? Result.Error(ShapeFault.Refused) : new E_validated_struct_Uri(value);
-}
-public static class C_E_validated_struct_bool
-{
-public readonly partial record struct V : IValidatedValue<V, bool, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(bool value) =>
-        EqualityComparer<bool>.Default.Equals(value, false) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public struct S_E_validated_struct_bool
-{
-public readonly partial record struct V : IValidatedValue<V, bool, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(bool value) =>
-        EqualityComparer<bool>.Default.Equals(value, false) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public static class C2_E_validated_struct_bool
-{
- public static class Inner
- {
-public readonly partial record struct V : IValidatedValue<V, bool, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(bool value) =>
-        EqualityComparer<bool>.Default.Equals(value, false) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
- }
-}
-public struct S_E_validated_struct_byte
-{
-public readonly partial record struct V : IValidatedValue<V, byte, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(byte value) =>
-        EqualityComparer<byte>.Default.Equals(value, (byte)255) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public static class C2_E_validated_struct_byte
-{
- public static class Inner
- {
-public readonly partial record struct V : IValidatedValue<V, byte, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(byte value) =>
-        EqualityComparer<byte>.Default.Equals(value, (byte)255) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
- }
-}
-public static class C2_E_validated_struct_char
-{
- public static class Inner
- {
-public readonly partial record struct V : IValidatedValue<V, char, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(char value) =>
-        EqualityComparer<char>.Default.Equals(value, 'x') ? Result.Error(ShapeFault.Refused) : new V(value);
-}
- }
-}
-public readonly partial record struct E_validated_struct_char : IValidatedValue<E_validated_struct_char, char, ShapeFault>
-{
-    public static Result<E_validated_struct_char, ShapeFault> Create(char value) =>
-        EqualityComparer<char>.Default.Equals(value, 'x') ? Result.Error(ShapeFault.Refused) : new E_validated_struct_char(value);
-}
-public static class C_E_validated_struct_decimal
-{
-public readonly partial record struct V : IValidatedValue<V, decimal, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(decimal value) =>
-        EqualityComparer<decimal>.Default.Equals(value, -1m) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public struct S_E_validated_struct_decimal
-{
-public readonly partial record struct V : IValidatedValue<V, decimal, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(decimal value) =>
-        EqualityComparer<decimal>.Default.Equals(value, -1m) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public static class C2_E_validated_struct_decimal
-{
- public static class Inner
- {
-public readonly partial record struct V : IValidatedValue<V, decimal, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(decimal value) =>
-        EqualityComparer<decimal>.Default.Equals(value, -1m) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
- }
-}
-public readonly partial record struct E_validated_struct_decimal : IValidatedValue<E_validated_struct_decimal, decimal, ShapeFault>
-{
-    public static Result<E_validated_struct_decimal, ShapeFault> Create(decimal value) =>
-        EqualityComparer<decimal>.Default.Equals(value, -1m) ? Result.Error(ShapeFault.Refused) : new E_validated_struct_decimal(value);
-}
-public static class C_E_validated_struct_double
-{
-public readonly partial record struct V : IValidatedValue<V, double, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(double value) =>
-        EqualityComparer<double>.Default.Equals(value, -1.0) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public readonly partial record struct E_validated_struct_double : IValidatedValue<E_validated_struct_double, double, ShapeFault>
-{
-    public static Result<E_validated_struct_double, ShapeFault> Create(double value) =>
-        EqualityComparer<double>.Default.Equals(value, -1.0) ? Result.Error(ShapeFault.Refused) : new E_validated_struct_double(value);
-}
-public static class C_E_validated_struct_enum
-{
-public readonly partial record struct V : IValidatedValue<V, PEnum, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(PEnum value) =>
-        EqualityComparer<PEnum>.Default.Equals(value, (PEnum)99) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public struct S_E_validated_struct_flags_enum
-{
-public readonly partial record struct V : IValidatedValue<V, PFlags, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(PFlags value) =>
-        EqualityComparer<PFlags>.Default.Equals(value, (PFlags)0) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public static class C_E_validated_struct_int
-{
-public readonly partial record struct V : IValidatedValue<V, int, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(int value) =>
-        EqualityComparer<int>.Default.Equals(value, -1) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public struct S_E_validated_struct_int
-{
-public readonly partial record struct V : IValidatedValue<V, int, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(int value) =>
-        EqualityComparer<int>.Default.Equals(value, -1) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
-}
-public static class C2_E_validated_struct_long
-{
- public static class Inner
- {
-public readonly partial record struct V : IValidatedValue<V, long, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(long value) =>
-        EqualityComparer<long>.Default.Equals(value, -1L) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
- }
-}
-public readonly partial record struct E_validated_struct_long : IValidatedValue<E_validated_struct_long, long, ShapeFault>
-{
-    public static Result<E_validated_struct_long, ShapeFault> Create(long value) =>
-        EqualityComparer<long>.Default.Equals(value, -1L) ? Result.Error(ShapeFault.Refused) : new E_validated_struct_long(value);
-}
-public static class C2_E_validated_struct_string
-{
- public static class Inner
- {
-public readonly partial record struct V : IValidatedValue<V, string, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(string value) =>
-        EqualityComparer<string>.Default.Equals(value, "SECRET-7f3a") ? Result.Error(ShapeFault.Refused) : new V(value);
-}
- }
-}
-public readonly partial record struct E_validated_struct_string : IValidatedValue<E_validated_struct_string, string, ShapeFault>
-{
-    public static Result<E_validated_struct_string, ShapeFault> Create(string value) =>
-        EqualityComparer<string>.Default.Equals(value, "SECRET-7f3a") ? Result.Error(ShapeFault.Refused) : new E_validated_struct_string(value);
-}
-public static class C2_E_validated_struct_ulong
-{
- public static class Inner
- {
-public readonly partial record struct V : IValidatedValue<V, ulong, ShapeFault>
-{
-    public static Result<V, ShapeFault> Create(ulong value) =>
-        EqualityComparer<ulong>.Default.Equals(value, 0UL) ? Result.Error(ShapeFault.Refused) : new V(value);
-}
- }
-}
-public static partial class EfRegistry
-{
-    static partial void Fill(List<EfEntry> e)
-    {
-        e.Add(new EfEntry("record-struct", "DateOnly", "nested-in-struct", typeof(S_E_record_struct_DateOnly.V), typeof(DateOnly), () => new DateOnly(2026,10,15)));
-        e.Add(new EfEntry("record-struct", "DateOnly", "nested-two-levels", typeof(C2_E_record_struct_DateOnly.Inner.V), typeof(DateOnly), () => new DateOnly(2026,10,15)));
-        e.Add(new EfEntry("record-struct", "DateOnly", "top-level", typeof(E_record_struct_DateOnly), typeof(DateOnly), () => new DateOnly(2026,10,15)));
-        e.Add(new EfEntry("record-struct", "DateTime", "nested-in-class", typeof(C_E_record_struct_DateTime.V), typeof(DateTime), () => new DateTime(2026,10,15,8,30,0,DateTimeKind.Utc)));
-        e.Add(new EfEntry("record-struct", "DateTime", "nested-two-levels", typeof(C2_E_record_struct_DateTime.Inner.V), typeof(DateTime), () => new DateTime(2026,10,15,8,30,0,DateTimeKind.Utc)));
-        e.Add(new EfEntry("record-struct", "DateTime", "top-level", typeof(E_record_struct_DateTime), typeof(DateTime), () => new DateTime(2026,10,15,8,30,0,DateTimeKind.Utc)));
-        e.Add(new EfEntry("record-struct", "DateTimeOffset", "top-level", typeof(E_record_struct_DateTimeOffset), typeof(DateTimeOffset), () => new DateTimeOffset(2026,10,15,8,30,0,TimeSpan.Zero)));
-        e.Add(new EfEntry("record-struct", "Guid", "nested-in-class", typeof(C_E_record_struct_Guid.V), typeof(Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111")));
-        e.Add(new EfEntry("record-struct", "Guid", "nested-two-levels", typeof(C2_E_record_struct_Guid.Inner.V), typeof(Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111")));
-        e.Add(new EfEntry("record-struct", "Guid", "top-level", typeof(E_record_struct_Guid), typeof(Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111")));
-        e.Add(new EfEntry("record-struct", "TimeOnly", "nested-two-levels", typeof(C2_E_record_struct_TimeOnly.Inner.V), typeof(TimeOnly), () => new TimeOnly(8,30,15)));
-        e.Add(new EfEntry("record-struct", "TimeSpan", "nested-in-class", typeof(C_E_record_struct_TimeSpan.V), typeof(TimeSpan), () => TimeSpan.FromMinutes(90)));
-        e.Add(new EfEntry("record-struct", "TimeSpan", "nested-in-struct", typeof(S_E_record_struct_TimeSpan.V), typeof(TimeSpan), () => TimeSpan.FromMinutes(90)));
-        e.Add(new EfEntry("record-struct", "Uri", "nested-in-class", typeof(C_E_record_struct_Uri.V), typeof(Uri), () => new Uri("https://example.com/a")));
-        e.Add(new EfEntry("record-struct", "Uri", "nested-two-levels", typeof(C2_E_record_struct_Uri.Inner.V), typeof(Uri), () => new Uri("https://example.com/a")));
-        e.Add(new EfEntry("record-struct", "Uri", "top-level", typeof(E_record_struct_Uri), typeof(Uri), () => new Uri("https://example.com/a")));
-        e.Add(new EfEntry("record-struct", "bool", "nested-in-struct", typeof(S_E_record_struct_bool.V), typeof(bool), () => true));
-        e.Add(new EfEntry("record-struct", "bool", "top-level", typeof(E_record_struct_bool), typeof(bool), () => true));
-        e.Add(new EfEntry("record-struct", "byte", "nested-two-levels", typeof(C2_E_record_struct_byte.Inner.V), typeof(byte), () => (byte)7));
-        e.Add(new EfEntry("record-struct", "byte", "top-level", typeof(E_record_struct_byte), typeof(byte), () => (byte)7));
-        e.Add(new EfEntry("record-struct", "char", "nested-in-class", typeof(C_E_record_struct_char.V), typeof(char), () => 'a'));
-        e.Add(new EfEntry("record-struct", "char", "nested-in-struct", typeof(S_E_record_struct_char.V), typeof(char), () => 'a'));
-        e.Add(new EfEntry("record-struct", "char", "top-level", typeof(E_record_struct_char), typeof(char), () => 'a'));
-        e.Add(new EfEntry("record-struct", "decimal", "nested-in-struct", typeof(S_E_record_struct_decimal.V), typeof(decimal), () => 7.80m));
-        e.Add(new EfEntry("record-struct", "decimal", "nested-two-levels", typeof(C2_E_record_struct_decimal.Inner.V), typeof(decimal), () => 7.80m));
-        e.Add(new EfEntry("record-struct", "decimal", "top-level", typeof(E_record_struct_decimal), typeof(decimal), () => 7.80m));
-        e.Add(new EfEntry("record-struct", "double", "nested-in-struct", typeof(S_E_record_struct_double.V), typeof(double), () => 1.5));
-        e.Add(new EfEntry("record-struct", "enum", "nested-two-levels", typeof(C2_E_record_struct_enum.Inner.V), typeof(PEnum), () => PEnum.B));
-        e.Add(new EfEntry("record-struct", "enum", "top-level", typeof(E_record_struct_enum), typeof(PEnum), () => PEnum.B));
-        e.Add(new EfEntry("record-struct", "flags-enum", "nested-two-levels", typeof(C2_E_record_struct_flags_enum.Inner.V), typeof(PFlags), () => PFlags.P | PFlags.Q));
-        e.Add(new EfEntry("record-struct", "flags-enum", "top-level", typeof(E_record_struct_flags_enum), typeof(PFlags), () => PFlags.P | PFlags.Q));
-        e.Add(new EfEntry("record-struct", "int", "nested-two-levels", typeof(C2_E_record_struct_int.Inner.V), typeof(int), () => 42));
-        e.Add(new EfEntry("record-struct", "int", "top-level", typeof(E_record_struct_int), typeof(int), () => 42));
-        e.Add(new EfEntry("record-struct", "long", "nested-two-levels", typeof(C2_E_record_struct_long.Inner.V), typeof(long), () => 4200000000L));
-        e.Add(new EfEntry("record-struct", "long", "top-level", typeof(E_record_struct_long), typeof(long), () => 4200000000L));
-        e.Add(new EfEntry("record-struct", "string", "nested-in-class", typeof(C_E_record_struct_string.V), typeof(string), () => "alpha"));
-        e.Add(new EfEntry("record-struct", "ulong", "nested-in-struct", typeof(S_E_record_struct_ulong.V), typeof(ulong), () => 4200000000UL));
-        e.Add(new EfEntry("sealed-record-class", "DateOnly", "nested-in-struct", typeof(S_E_sealed_record_class_DateOnly.V), typeof(DateOnly), () => new DateOnly(2026,10,15)));
-        e.Add(new EfEntry("sealed-record-class", "DateOnly", "nested-two-levels", typeof(C2_E_sealed_record_class_DateOnly.Inner.V), typeof(DateOnly), () => new DateOnly(2026,10,15)));
-        e.Add(new EfEntry("sealed-record-class", "DateTime", "nested-in-struct", typeof(S_E_sealed_record_class_DateTime.V), typeof(DateTime), () => new DateTime(2026,10,15,8,30,0,DateTimeKind.Utc)));
-        e.Add(new EfEntry("sealed-record-class", "DateTime", "nested-two-levels", typeof(C2_E_sealed_record_class_DateTime.Inner.V), typeof(DateTime), () => new DateTime(2026,10,15,8,30,0,DateTimeKind.Utc)));
-        e.Add(new EfEntry("sealed-record-class", "DateTimeOffset", "nested-in-class", typeof(C_E_sealed_record_class_DateTimeOffset.V), typeof(DateTimeOffset), () => new DateTimeOffset(2026,10,15,8,30,0,TimeSpan.Zero)));
-        e.Add(new EfEntry("sealed-record-class", "DateTimeOffset", "nested-in-struct", typeof(S_E_sealed_record_class_DateTimeOffset.V), typeof(DateTimeOffset), () => new DateTimeOffset(2026,10,15,8,30,0,TimeSpan.Zero)));
-        e.Add(new EfEntry("sealed-record-class", "DateTimeOffset", "nested-two-levels", typeof(C2_E_sealed_record_class_DateTimeOffset.Inner.V), typeof(DateTimeOffset), () => new DateTimeOffset(2026,10,15,8,30,0,TimeSpan.Zero)));
-        e.Add(new EfEntry("sealed-record-class", "Guid", "nested-two-levels", typeof(C2_E_sealed_record_class_Guid.Inner.V), typeof(Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111")));
-        e.Add(new EfEntry("sealed-record-class", "TimeOnly", "nested-in-class", typeof(C_E_sealed_record_class_TimeOnly.V), typeof(TimeOnly), () => new TimeOnly(8,30,15)));
-        e.Add(new EfEntry("sealed-record-class", "TimeOnly", "nested-in-struct", typeof(S_E_sealed_record_class_TimeOnly.V), typeof(TimeOnly), () => new TimeOnly(8,30,15)));
-        e.Add(new EfEntry("sealed-record-class", "TimeOnly", "nested-two-levels", typeof(C2_E_sealed_record_class_TimeOnly.Inner.V), typeof(TimeOnly), () => new TimeOnly(8,30,15)));
-        e.Add(new EfEntry("sealed-record-class", "TimeSpan", "top-level", typeof(E_sealed_record_class_TimeSpan), typeof(TimeSpan), () => TimeSpan.FromMinutes(90)));
-        e.Add(new EfEntry("sealed-record-class", "Uri", "nested-in-class", typeof(C_E_sealed_record_class_Uri.V), typeof(Uri), () => new Uri("https://example.com/a")));
-        e.Add(new EfEntry("sealed-record-class", "Uri", "nested-in-struct", typeof(S_E_sealed_record_class_Uri.V), typeof(Uri), () => new Uri("https://example.com/a")));
-        e.Add(new EfEntry("sealed-record-class", "Uri", "nested-two-levels", typeof(C2_E_sealed_record_class_Uri.Inner.V), typeof(Uri), () => new Uri("https://example.com/a")));
-        e.Add(new EfEntry("sealed-record-class", "bool", "nested-two-levels", typeof(C2_E_sealed_record_class_bool.Inner.V), typeof(bool), () => true));
-        e.Add(new EfEntry("sealed-record-class", "byte", "nested-in-class", typeof(C_E_sealed_record_class_byte.V), typeof(byte), () => (byte)7));
-        e.Add(new EfEntry("sealed-record-class", "byte", "nested-in-struct", typeof(S_E_sealed_record_class_byte.V), typeof(byte), () => (byte)7));
-        e.Add(new EfEntry("sealed-record-class", "char", "nested-in-struct", typeof(S_E_sealed_record_class_char.V), typeof(char), () => 'a'));
-        e.Add(new EfEntry("sealed-record-class", "char", "top-level", typeof(E_sealed_record_class_char), typeof(char), () => 'a'));
-        e.Add(new EfEntry("sealed-record-class", "decimal", "nested-in-class", typeof(C_E_sealed_record_class_decimal.V), typeof(decimal), () => 7.80m));
-        e.Add(new EfEntry("sealed-record-class", "decimal", "nested-two-levels", typeof(C2_E_sealed_record_class_decimal.Inner.V), typeof(decimal), () => 7.80m));
-        e.Add(new EfEntry("sealed-record-class", "double", "nested-two-levels", typeof(C2_E_sealed_record_class_double.Inner.V), typeof(double), () => 1.5));
-        e.Add(new EfEntry("sealed-record-class", "double", "top-level", typeof(E_sealed_record_class_double), typeof(double), () => 1.5));
-        e.Add(new EfEntry("sealed-record-class", "enum", "top-level", typeof(E_sealed_record_class_enum), typeof(PEnum), () => PEnum.B));
-        e.Add(new EfEntry("sealed-record-class", "flags-enum", "nested-in-class", typeof(C_E_sealed_record_class_flags_enum.V), typeof(PFlags), () => PFlags.P | PFlags.Q));
-        e.Add(new EfEntry("sealed-record-class", "flags-enum", "top-level", typeof(E_sealed_record_class_flags_enum), typeof(PFlags), () => PFlags.P | PFlags.Q));
-        e.Add(new EfEntry("sealed-record-class", "int", "nested-in-class", typeof(C_E_sealed_record_class_int.V), typeof(int), () => 42));
-        e.Add(new EfEntry("sealed-record-class", "int", "nested-in-struct", typeof(S_E_sealed_record_class_int.V), typeof(int), () => 42));
-        e.Add(new EfEntry("sealed-record-class", "long", "nested-in-class", typeof(C_E_sealed_record_class_long.V), typeof(long), () => 4200000000L));
-        e.Add(new EfEntry("sealed-record-class", "string", "nested-in-class", typeof(C_E_sealed_record_class_string.V), typeof(string), () => "alpha"));
-        e.Add(new EfEntry("sealed-record-class", "string", "nested-in-struct", typeof(S_E_sealed_record_class_string.V), typeof(string), () => "alpha"));
-        e.Add(new EfEntry("sealed-record-class", "string", "top-level", typeof(E_sealed_record_class_string), typeof(string), () => "alpha"));
-        e.Add(new EfEntry("sealed-record-class", "ulong", "nested-in-class", typeof(C_E_sealed_record_class_ulong.V), typeof(ulong), () => 4200000000UL));
-        e.Add(new EfEntry("validated-class", "DateOnly", "nested-in-struct", typeof(S_E_validated_class_DateOnly.V), typeof(DateOnly), () => new DateOnly(2026,10,15)));
-        e.Add(new EfEntry("validated-class", "DateTimeOffset", "nested-in-struct", typeof(S_E_validated_class_DateTimeOffset.V), typeof(DateTimeOffset), () => new DateTimeOffset(2026,10,15,8,30,0,TimeSpan.Zero)));
-        e.Add(new EfEntry("validated-class", "Guid", "nested-in-class", typeof(C_E_validated_class_Guid.V), typeof(Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111")));
-        e.Add(new EfEntry("validated-class", "Guid", "nested-in-struct", typeof(S_E_validated_class_Guid.V), typeof(Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111")));
-        e.Add(new EfEntry("validated-class", "Guid", "top-level", typeof(E_validated_class_Guid), typeof(Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111")));
-        e.Add(new EfEntry("validated-class", "TimeOnly", "nested-in-class", typeof(C_E_validated_class_TimeOnly.V), typeof(TimeOnly), () => new TimeOnly(8,30,15)));
-        e.Add(new EfEntry("validated-class", "TimeOnly", "top-level", typeof(E_validated_class_TimeOnly), typeof(TimeOnly), () => new TimeOnly(8,30,15)));
-        e.Add(new EfEntry("validated-class", "TimeSpan", "nested-two-levels", typeof(C2_E_validated_class_TimeSpan.Inner.V), typeof(TimeSpan), () => TimeSpan.FromMinutes(90)));
-        e.Add(new EfEntry("validated-class", "Uri", "nested-in-struct", typeof(S_E_validated_class_Uri.V), typeof(Uri), () => new Uri("https://example.com/a")));
-        e.Add(new EfEntry("validated-class", "bool", "nested-in-class", typeof(C_E_validated_class_bool.V), typeof(bool), () => true));
-        e.Add(new EfEntry("validated-class", "bool", "nested-in-struct", typeof(S_E_validated_class_bool.V), typeof(bool), () => true));
-        e.Add(new EfEntry("validated-class", "bool", "top-level", typeof(E_validated_class_bool), typeof(bool), () => true));
-        e.Add(new EfEntry("validated-class", "byte", "nested-in-class", typeof(C_E_validated_class_byte.V), typeof(byte), () => (byte)7));
-        e.Add(new EfEntry("validated-class", "byte", "top-level", typeof(E_validated_class_byte), typeof(byte), () => (byte)7));
-        e.Add(new EfEntry("validated-class", "char", "nested-in-class", typeof(C_E_validated_class_char.V), typeof(char), () => 'a'));
-        e.Add(new EfEntry("validated-class", "char", "nested-two-levels", typeof(C2_E_validated_class_char.Inner.V), typeof(char), () => 'a'));
-        e.Add(new EfEntry("validated-class", "double", "nested-in-class", typeof(C_E_validated_class_double.V), typeof(double), () => 1.5));
-        e.Add(new EfEntry("validated-class", "double", "nested-two-levels", typeof(C2_E_validated_class_double.Inner.V), typeof(double), () => 1.5));
-        e.Add(new EfEntry("validated-class", "enum", "nested-in-struct", typeof(S_E_validated_class_enum.V), typeof(PEnum), () => PEnum.B));
-        e.Add(new EfEntry("validated-class", "enum", "nested-two-levels", typeof(C2_E_validated_class_enum.Inner.V), typeof(PEnum), () => PEnum.B));
-        e.Add(new EfEntry("validated-class", "flags-enum", "nested-in-class", typeof(C_E_validated_class_flags_enum.V), typeof(PFlags), () => PFlags.P | PFlags.Q));
-        e.Add(new EfEntry("validated-class", "flags-enum", "nested-in-struct", typeof(S_E_validated_class_flags_enum.V), typeof(PFlags), () => PFlags.P | PFlags.Q));
-        e.Add(new EfEntry("validated-class", "flags-enum", "nested-two-levels", typeof(C2_E_validated_class_flags_enum.Inner.V), typeof(PFlags), () => PFlags.P | PFlags.Q));
-        e.Add(new EfEntry("validated-class", "int", "nested-two-levels", typeof(C2_E_validated_class_int.Inner.V), typeof(int), () => 42));
-        e.Add(new EfEntry("validated-class", "int", "top-level", typeof(E_validated_class_int), typeof(int), () => 42));
-        e.Add(new EfEntry("validated-class", "long", "nested-in-struct", typeof(S_E_validated_class_long.V), typeof(long), () => 4200000000L));
-        e.Add(new EfEntry("validated-class", "long", "nested-two-levels", typeof(C2_E_validated_class_long.Inner.V), typeof(long), () => 4200000000L));
-        e.Add(new EfEntry("validated-class", "string", "nested-in-struct", typeof(S_E_validated_class_string.V), typeof(string), () => "alpha"));
-        e.Add(new EfEntry("validated-class", "string", "nested-two-levels", typeof(C2_E_validated_class_string.Inner.V), typeof(string), () => "alpha"));
-        e.Add(new EfEntry("validated-class", "ulong", "nested-in-struct", typeof(S_E_validated_class_ulong.V), typeof(ulong), () => 4200000000UL));
-        e.Add(new EfEntry("validated-class", "ulong", "top-level", typeof(E_validated_class_ulong), typeof(ulong), () => 4200000000UL));
-        e.Add(new EfEntry("validated-struct", "DateOnly", "nested-in-class", typeof(C_E_validated_struct_DateOnly.V), typeof(DateOnly), () => new DateOnly(2026,10,15)));
-        e.Add(new EfEntry("validated-struct", "DateOnly", "top-level", typeof(E_validated_struct_DateOnly), typeof(DateOnly), () => new DateOnly(2026,10,15)));
-        e.Add(new EfEntry("validated-struct", "DateTime", "nested-in-class", typeof(C_E_validated_struct_DateTime.V), typeof(DateTime), () => new DateTime(2026,10,15,8,30,0,DateTimeKind.Utc)));
-        e.Add(new EfEntry("validated-struct", "DateTime", "nested-in-struct", typeof(S_E_validated_struct_DateTime.V), typeof(DateTime), () => new DateTime(2026,10,15,8,30,0,DateTimeKind.Utc)));
-        e.Add(new EfEntry("validated-struct", "DateTimeOffset", "nested-in-class", typeof(C_E_validated_struct_DateTimeOffset.V), typeof(DateTimeOffset), () => new DateTimeOffset(2026,10,15,8,30,0,TimeSpan.Zero)));
-        e.Add(new EfEntry("validated-struct", "DateTimeOffset", "nested-two-levels", typeof(C2_E_validated_struct_DateTimeOffset.Inner.V), typeof(DateTimeOffset), () => new DateTimeOffset(2026,10,15,8,30,0,TimeSpan.Zero)));
-        e.Add(new EfEntry("validated-struct", "Guid", "nested-in-class", typeof(C_E_validated_struct_Guid.V), typeof(Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111")));
-        e.Add(new EfEntry("validated-struct", "Guid", "nested-in-struct", typeof(S_E_validated_struct_Guid.V), typeof(Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111")));
-        e.Add(new EfEntry("validated-struct", "TimeOnly", "nested-in-struct", typeof(S_E_validated_struct_TimeOnly.V), typeof(TimeOnly), () => new TimeOnly(8,30,15)));
-        e.Add(new EfEntry("validated-struct", "TimeOnly", "top-level", typeof(E_validated_struct_TimeOnly), typeof(TimeOnly), () => new TimeOnly(8,30,15)));
-        e.Add(new EfEntry("validated-struct", "TimeSpan", "nested-in-class", typeof(C_E_validated_struct_TimeSpan.V), typeof(TimeSpan), () => TimeSpan.FromMinutes(90)));
-        e.Add(new EfEntry("validated-struct", "Uri", "top-level", typeof(E_validated_struct_Uri), typeof(Uri), () => new Uri("https://example.com/a")));
-        e.Add(new EfEntry("validated-struct", "bool", "nested-in-class", typeof(C_E_validated_struct_bool.V), typeof(bool), () => true));
-        e.Add(new EfEntry("validated-struct", "bool", "nested-in-struct", typeof(S_E_validated_struct_bool.V), typeof(bool), () => true));
-        e.Add(new EfEntry("validated-struct", "bool", "nested-two-levels", typeof(C2_E_validated_struct_bool.Inner.V), typeof(bool), () => true));
-        e.Add(new EfEntry("validated-struct", "byte", "nested-in-struct", typeof(S_E_validated_struct_byte.V), typeof(byte), () => (byte)7));
-        e.Add(new EfEntry("validated-struct", "byte", "nested-two-levels", typeof(C2_E_validated_struct_byte.Inner.V), typeof(byte), () => (byte)7));
-        e.Add(new EfEntry("validated-struct", "char", "nested-two-levels", typeof(C2_E_validated_struct_char.Inner.V), typeof(char), () => 'a'));
-        e.Add(new EfEntry("validated-struct", "char", "top-level", typeof(E_validated_struct_char), typeof(char), () => 'a'));
-        e.Add(new EfEntry("validated-struct", "decimal", "nested-in-class", typeof(C_E_validated_struct_decimal.V), typeof(decimal), () => 7.80m));
-        e.Add(new EfEntry("validated-struct", "decimal", "nested-in-struct", typeof(S_E_validated_struct_decimal.V), typeof(decimal), () => 7.80m));
-        e.Add(new EfEntry("validated-struct", "decimal", "nested-two-levels", typeof(C2_E_validated_struct_decimal.Inner.V), typeof(decimal), () => 7.80m));
-        e.Add(new EfEntry("validated-struct", "decimal", "top-level", typeof(E_validated_struct_decimal), typeof(decimal), () => 7.80m));
-        e.Add(new EfEntry("validated-struct", "double", "nested-in-class", typeof(C_E_validated_struct_double.V), typeof(double), () => 1.5));
-        e.Add(new EfEntry("validated-struct", "double", "top-level", typeof(E_validated_struct_double), typeof(double), () => 1.5));
-        e.Add(new EfEntry("validated-struct", "enum", "nested-in-class", typeof(C_E_validated_struct_enum.V), typeof(PEnum), () => PEnum.B));
-        e.Add(new EfEntry("validated-struct", "flags-enum", "nested-in-struct", typeof(S_E_validated_struct_flags_enum.V), typeof(PFlags), () => PFlags.P | PFlags.Q));
-        e.Add(new EfEntry("validated-struct", "int", "nested-in-class", typeof(C_E_validated_struct_int.V), typeof(int), () => 42));
-        e.Add(new EfEntry("validated-struct", "int", "nested-in-struct", typeof(S_E_validated_struct_int.V), typeof(int), () => 42));
-        e.Add(new EfEntry("validated-struct", "long", "nested-two-levels", typeof(C2_E_validated_struct_long.Inner.V), typeof(long), () => 4200000000L));
-        e.Add(new EfEntry("validated-struct", "long", "top-level", typeof(E_validated_struct_long), typeof(long), () => 4200000000L));
-        e.Add(new EfEntry("validated-struct", "string", "nested-two-levels", typeof(C2_E_validated_struct_string.Inner.V), typeof(string), () => "alpha"));
-        e.Add(new EfEntry("validated-struct", "string", "top-level", typeof(E_validated_struct_string), typeof(string), () => "alpha"));
-        e.Add(new EfEntry("validated-struct", "ulong", "nested-two-levels", typeof(C2_E_validated_struct_ulong.Inner.V), typeof(ulong), () => 4200000000UL));
-    }
-}
diff --git a/tools/probe/corpus/harness/EfShapes3.cs b/tools/probe/corpus/harness/EfShapes3.cs
deleted file mode 100644
index b4b846b7..00000000
--- a/tools/probe/corpus/harness/EfShapes3.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Lookup of the top-level shapes of EfShapes3.g.cs as EfEntry (so MakeVo/Companion work): the complete kind x wrapped grid.
-#nullable enable
-namespace Probes.Ef3;
-public static class E3
-{
-    public static Probes.Ef.EfEntry Find(string kind, string wrapped)
-    {
-        var (vo, plain) = Reg3.All[(kind, wrapped)];
-        var src = Probes.Ef.EfRegistry.All.Where(x => x.Wrapped == wrapped && x.Kind == (kind.StartsWith("validated") ? "validated-struct" : "record-struct")).FirstOrDefault()
-            ?? Probes.Ef.EfRegistry.All.First(x => x.Wrapped == wrapped);
-        return new Probes.Ef.EfEntry(kind, wrapped, "top-level", vo, plain, src.Valid);
-    }
-}
-public static class E4
-{
-    /// <summary>The shape at a site; in-generic-type (CMTK1005, refused at build) runs at top-level and says so.</summary>
-    public static Probes.Ef.EfEntry At(Probes.Shapes.Row r, string kind, string wrapped, string site)
-    {
-        if (site == "in-generic-type") { r.Substituted("shape.site", "top-level", "CMTK1005: a value object nested in a generic type does not build"); site = "top-level"; }
-        if (site == "top-level") return E3.Find(kind, wrapped);
-        var (vo, plain) = Probes.Ef4.Reg4.All[(kind, wrapped, site)];
-        var src = Probes.Ef.EfRegistry.All.Where(x => x.Wrapped == wrapped && x.Kind == (kind.StartsWith("validated") ? "validated-struct" : "record-struct")).FirstOrDefault()
-            ?? Probes.Ef.EfRegistry.All.First(x => x.Wrapped == wrapped);
-        return new Probes.Ef.EfEntry(kind, wrapped, site, vo, plain, src.Valid);
-    }
-}
diff --git a/tools/probe/corpus/harness/EfShapes3.g.cs b/tools/probe/corpus/harness/EfShapes3.g.cs
deleted file mode 100644
index ef335f76..00000000
--- a/tools/probe/corpus/harness/EfShapes3.g.cs
+++ /dev/null
@@ -1,155 +0,0 @@
-// <auto-generated/> by tools/probe/generators/ef.cs top-level: top-level shapes for every (kind, wrapped) the E03/E09/E10 probes need. Do not edit.
-#nullable enable
-#pragma warning disable CMTK0014, CS8618, CS1591, CMTK0005, CMTK1000, CMTK0003, CMTK0006, CA1000
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.ValueObjects;
-using Probes.Shapes;
-namespace Probes.Ef3;
-public readonly partial record struct X_rs_DateOnly : IValue<DateOnly>;
-public sealed partial record class X_rc_DateOnly : IValue<DateOnly>;
-public readonly partial record struct X_vs_DateOnly : IValidatedValue<X_vs_DateOnly, DateOnly, ShapeFault> { public static Result<X_vs_DateOnly, ShapeFault> Create(DateOnly value) => EqualityComparer<DateOnly>.Default.Equals(value, DateOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new X_vs_DateOnly(value); }
-public sealed partial record class X_vc_DateOnly : IValidatedValue<X_vc_DateOnly, DateOnly, ShapeFault> { public static Result<X_vc_DateOnly, ShapeFault> Create(DateOnly value) => EqualityComparer<DateOnly>.Default.Equals(value, DateOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new X_vc_DateOnly(value); }
-public readonly partial record struct X_rs_DateTime : IValue<DateTime>;
-public sealed partial record class X_rc_DateTime : IValue<DateTime>;
-public readonly partial record struct X_vs_DateTime : IValidatedValue<X_vs_DateTime, DateTime, ShapeFault> { public static Result<X_vs_DateTime, ShapeFault> Create(DateTime value) => EqualityComparer<DateTime>.Default.Equals(value, DateTime.MinValue) ? Result.Error(ShapeFault.Refused) : new X_vs_DateTime(value); }
-public sealed partial record class X_vc_DateTime : IValidatedValue<X_vc_DateTime, DateTime, ShapeFault> { public static Result<X_vc_DateTime, ShapeFault> Create(DateTime value) => EqualityComparer<DateTime>.Default.Equals(value, DateTime.MinValue) ? Result.Error(ShapeFault.Refused) : new X_vc_DateTime(value); }
-public readonly partial record struct X_rs_DateTimeOffset : IValue<DateTimeOffset>;
-public sealed partial record class X_rc_DateTimeOffset : IValue<DateTimeOffset>;
-public readonly partial record struct X_vs_DateTimeOffset : IValidatedValue<X_vs_DateTimeOffset, DateTimeOffset, ShapeFault> { public static Result<X_vs_DateTimeOffset, ShapeFault> Create(DateTimeOffset value) => EqualityComparer<DateTimeOffset>.Default.Equals(value, DateTimeOffset.MinValue) ? Result.Error(ShapeFault.Refused) : new X_vs_DateTimeOffset(value); }
-public sealed partial record class X_vc_DateTimeOffset : IValidatedValue<X_vc_DateTimeOffset, DateTimeOffset, ShapeFault> { public static Result<X_vc_DateTimeOffset, ShapeFault> Create(DateTimeOffset value) => EqualityComparer<DateTimeOffset>.Default.Equals(value, DateTimeOffset.MinValue) ? Result.Error(ShapeFault.Refused) : new X_vc_DateTimeOffset(value); }
-public readonly partial record struct X_rs_Guid : IValue<Guid>;
-public sealed partial record class X_rc_Guid : IValue<Guid>;
-public readonly partial record struct X_vs_Guid : IValidatedValue<X_vs_Guid, Guid, ShapeFault> { public static Result<X_vs_Guid, ShapeFault> Create(Guid value) => EqualityComparer<Guid>.Default.Equals(value, Guid.Empty) ? Result.Error(ShapeFault.Refused) : new X_vs_Guid(value); }
-public sealed partial record class X_vc_Guid : IValidatedValue<X_vc_Guid, Guid, ShapeFault> { public static Result<X_vc_Guid, ShapeFault> Create(Guid value) => EqualityComparer<Guid>.Default.Equals(value, Guid.Empty) ? Result.Error(ShapeFault.Refused) : new X_vc_Guid(value); }
-public readonly partial record struct X_rs_TimeOnly : IValue<TimeOnly>;
-public sealed partial record class X_rc_TimeOnly : IValue<TimeOnly>;
-public readonly partial record struct X_vs_TimeOnly : IValidatedValue<X_vs_TimeOnly, TimeOnly, ShapeFault> { public static Result<X_vs_TimeOnly, ShapeFault> Create(TimeOnly value) => EqualityComparer<TimeOnly>.Default.Equals(value, TimeOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new X_vs_TimeOnly(value); }
-public sealed partial record class X_vc_TimeOnly : IValidatedValue<X_vc_TimeOnly, TimeOnly, ShapeFault> { public static Result<X_vc_TimeOnly, ShapeFault> Create(TimeOnly value) => EqualityComparer<TimeOnly>.Default.Equals(value, TimeOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new X_vc_TimeOnly(value); }
-public readonly partial record struct X_rs_TimeSpan : IValue<TimeSpan>;
-public sealed partial record class X_rc_TimeSpan : IValue<TimeSpan>;
-public readonly partial record struct X_vs_TimeSpan : IValidatedValue<X_vs_TimeSpan, TimeSpan, ShapeFault> { public static Result<X_vs_TimeSpan, ShapeFault> Create(TimeSpan value) => EqualityComparer<TimeSpan>.Default.Equals(value, TimeSpan.MinValue) ? Result.Error(ShapeFault.Refused) : new X_vs_TimeSpan(value); }
-public sealed partial record class X_vc_TimeSpan : IValidatedValue<X_vc_TimeSpan, TimeSpan, ShapeFault> { public static Result<X_vc_TimeSpan, ShapeFault> Create(TimeSpan value) => EqualityComparer<TimeSpan>.Default.Equals(value, TimeSpan.MinValue) ? Result.Error(ShapeFault.Refused) : new X_vc_TimeSpan(value); }
-public readonly partial record struct X_rs_Uri : IValue<Uri>;
-public sealed partial record class X_rc_Uri : IValue<Uri>;
-public readonly partial record struct X_vs_Uri : IValidatedValue<X_vs_Uri, Uri, ShapeFault> { public static Result<X_vs_Uri, ShapeFault> Create(Uri value) => EqualityComparer<Uri>.Default.Equals(value, new Uri("https://example.com/refused")) ? Result.Error(ShapeFault.Refused) : new X_vs_Uri(value); }
-public sealed partial record class X_vc_Uri : IValidatedValue<X_vc_Uri, Uri, ShapeFault> { public static Result<X_vc_Uri, ShapeFault> Create(Uri value) => EqualityComparer<Uri>.Default.Equals(value, new Uri("https://example.com/refused")) ? Result.Error(ShapeFault.Refused) : new X_vc_Uri(value); }
-public readonly partial record struct X_rs_bool : IValue<bool>;
-public sealed partial record class X_rc_bool : IValue<bool>;
-public readonly partial record struct X_vs_bool : IValidatedValue<X_vs_bool, bool, ShapeFault> { public static Result<X_vs_bool, ShapeFault> Create(bool value) => EqualityComparer<bool>.Default.Equals(value, false) ? Result.Error(ShapeFault.Refused) : new X_vs_bool(value); }
-public sealed partial record class X_vc_bool : IValidatedValue<X_vc_bool, bool, ShapeFault> { public static Result<X_vc_bool, ShapeFault> Create(bool value) => EqualityComparer<bool>.Default.Equals(value, false) ? Result.Error(ShapeFault.Refused) : new X_vc_bool(value); }
-public readonly partial record struct X_rs_byte : IValue<byte>;
-public sealed partial record class X_rc_byte : IValue<byte>;
-public readonly partial record struct X_vs_byte : IValidatedValue<X_vs_byte, byte, ShapeFault> { public static Result<X_vs_byte, ShapeFault> Create(byte value) => EqualityComparer<byte>.Default.Equals(value, (byte)255) ? Result.Error(ShapeFault.Refused) : new X_vs_byte(value); }
-public sealed partial record class X_vc_byte : IValidatedValue<X_vc_byte, byte, ShapeFault> { public static Result<X_vc_byte, ShapeFault> Create(byte value) => EqualityComparer<byte>.Default.Equals(value, (byte)255) ? Result.Error(ShapeFault.Refused) : new X_vc_byte(value); }
-public readonly partial record struct X_rs_char : IValue<char>;
-public sealed partial record class X_rc_char : IValue<char>;
-public readonly partial record struct X_vs_char : IValidatedValue<X_vs_char, char, ShapeFault> { public static Result<X_vs_char, ShapeFault> Create(char value) => EqualityComparer<char>.Default.Equals(value, 'x') ? Result.Error(ShapeFault.Refused) : new X_vs_char(value); }
-public sealed partial record class X_vc_char : IValidatedValue<X_vc_char, char, ShapeFault> { public static Result<X_vc_char, ShapeFault> Create(char value) => EqualityComparer<char>.Default.Equals(value, 'x') ? Result.Error(ShapeFault.Refused) : new X_vc_char(value); }
-public readonly partial record struct X_rs_decimal : IValue<decimal>;
-public sealed partial record class X_rc_decimal : IValue<decimal>;
-public readonly partial record struct X_vs_decimal : IValidatedValue<X_vs_decimal, decimal, ShapeFault> { public static Result<X_vs_decimal, ShapeFault> Create(decimal value) => EqualityComparer<decimal>.Default.Equals(value, -1m) ? Result.Error(ShapeFault.Refused) : new X_vs_decimal(value); }
-public sealed partial record class X_vc_decimal : IValidatedValue<X_vc_decimal, decimal, ShapeFault> { public static Result<X_vc_decimal, ShapeFault> Create(decimal value) => EqualityComparer<decimal>.Default.Equals(value, -1m) ? Result.Error(ShapeFault.Refused) : new X_vc_decimal(value); }
-public readonly partial record struct X_rs_double : IValue<double>;
-public sealed partial record class X_rc_double : IValue<double>;
-public readonly partial record struct X_vs_double : IValidatedValue<X_vs_double, double, ShapeFault> { public static Result<X_vs_double, ShapeFault> Create(double value) => EqualityComparer<double>.Default.Equals(value, -1.0) ? Result.Error(ShapeFault.Refused) : new X_vs_double(value); }
-public sealed partial record class X_vc_double : IValidatedValue<X_vc_double, double, ShapeFault> { public static Result<X_vc_double, ShapeFault> Create(double value) => EqualityComparer<double>.Default.Equals(value, -1.0) ? Result.Error(ShapeFault.Refused) : new X_vc_double(value); }
-public readonly partial record struct X_rs_enum : IValue<PEnum>;
-public sealed partial record class X_rc_enum : IValue<PEnum>;
-public readonly partial record struct X_vs_enum : IValidatedValue<X_vs_enum, PEnum, ShapeFault> { public static Result<X_vs_enum, ShapeFault> Create(PEnum value) => EqualityComparer<PEnum>.Default.Equals(value, (PEnum)99) ? Result.Error(ShapeFault.Refused) : new X_vs_enum(value); }
-public sealed partial record class X_vc_enum : IValidatedValue<X_vc_enum, PEnum, ShapeFault> { public static Result<X_vc_enum, ShapeFault> Create(PEnum value) => EqualityComparer<PEnum>.Default.Equals(value, (PEnum)99) ? Result.Error(ShapeFault.Refused) : new X_vc_enum(value); }
-public readonly partial record struct X_rs_flags_enum : IValue<PFlags>;
-public sealed partial record class X_rc_flags_enum : IValue<PFlags>;
-public readonly partial record struct X_vs_flags_enum : IValidatedValue<X_vs_flags_enum, PFlags, ShapeFault> { public static Result<X_vs_flags_enum, ShapeFault> Create(PFlags value) => EqualityComparer<PFlags>.Default.Equals(value, (PFlags)0) ? Result.Error(ShapeFault.Refused) : new X_vs_flags_enum(value); }
-public sealed partial record class X_vc_flags_enum : IValidatedValue<X_vc_flags_enum, PFlags, ShapeFault> { public static Result<X_vc_flags_enum, ShapeFault> Create(PFlags value) => EqualityComparer<PFlags>.Default.Equals(value, (PFlags)0) ? Result.Error(ShapeFault.Refused) : new X_vc_flags_enum(value); }
-public readonly partial record struct X_rs_int : IValue<int>;
-public sealed partial record class X_rc_int : IValue<int>;
-public readonly partial record struct X_vs_int : IValidatedValue<X_vs_int, int, ShapeFault> { public static Result<X_vs_int, ShapeFault> Create(int value) => EqualityComparer<int>.Default.Equals(value, -1) ? Result.Error(ShapeFault.Refused) : new X_vs_int(value); }
-public sealed partial record class X_vc_int : IValidatedValue<X_vc_int, int, ShapeFault> { public static Result<X_vc_int, ShapeFault> Create(int value) => EqualityComparer<int>.Default.Equals(value, -1) ? Result.Error(ShapeFault.Refused) : new X_vc_int(value); }
-public readonly partial record struct X_rs_long : IValue<long>;
-public sealed partial record class X_rc_long : IValue<long>;
-public readonly partial record struct X_vs_long : IValidatedValue<X_vs_long, long, ShapeFault> { public static Result<X_vs_long, ShapeFault> Create(long value) => EqualityComparer<long>.Default.Equals(value, -1L) ? Result.Error(ShapeFault.Refused) : new X_vs_long(value); }
-public sealed partial record class X_vc_long : IValidatedValue<X_vc_long, long, ShapeFault> { public static Result<X_vc_long, ShapeFault> Create(long value) => EqualityComparer<long>.Default.Equals(value, -1L) ? Result.Error(ShapeFault.Refused) : new X_vc_long(value); }
-public readonly partial record struct X_rs_string : IValue<string>;
-public sealed partial record class X_rc_string : IValue<string>;
-public readonly partial record struct X_vs_string : IValidatedValue<X_vs_string, string, ShapeFault> { public static Result<X_vs_string, ShapeFault> Create(string value) => EqualityComparer<string>.Default.Equals(value, "SECRET-7f3a") ? Result.Error(ShapeFault.Refused) : new X_vs_string(value); }
-public sealed partial record class X_vc_string : IValidatedValue<X_vc_string, string, ShapeFault> { public static Result<X_vc_string, ShapeFault> Create(string value) => EqualityComparer<string>.Default.Equals(value, "SECRET-7f3a") ? Result.Error(ShapeFault.Refused) : new X_vc_string(value); }
-public readonly partial record struct X_rs_ulong : IValue<ulong>;
-public sealed partial record class X_rc_ulong : IValue<ulong>;
-public readonly partial record struct X_vs_ulong : IValidatedValue<X_vs_ulong, ulong, ShapeFault> { public static Result<X_vs_ulong, ShapeFault> Create(ulong value) => EqualityComparer<ulong>.Default.Equals(value, 0UL) ? Result.Error(ShapeFault.Refused) : new X_vs_ulong(value); }
-public sealed partial record class X_vc_ulong : IValidatedValue<X_vc_ulong, ulong, ShapeFault> { public static Result<X_vc_ulong, ShapeFault> Create(ulong value) => EqualityComparer<ulong>.Default.Equals(value, 0UL) ? Result.Error(ShapeFault.Refused) : new X_vc_ulong(value); }
-public static class Reg3 {
- public static readonly Dictionary<(string Kind, string Wrapped), (Type Vo, Type Plain)> All = new() {
-  [("record-struct", "DateOnly")] = (typeof(X_rs_DateOnly), typeof(DateOnly)),
-  [("sealed-record-class", "DateOnly")] = (typeof(X_rc_DateOnly), typeof(DateOnly)),
-  [("validated-struct", "DateOnly")] = (typeof(X_vs_DateOnly), typeof(DateOnly)),
-  [("validated-class", "DateOnly")] = (typeof(X_vc_DateOnly), typeof(DateOnly)),
-  [("record-struct", "DateTime")] = (typeof(X_rs_DateTime), typeof(DateTime)),
-  [("sealed-record-class", "DateTime")] = (typeof(X_rc_DateTime), typeof(DateTime)),
-  [("validated-struct", "DateTime")] = (typeof(X_vs_DateTime), typeof(DateTime)),
-  [("validated-class", "DateTime")] = (typeof(X_vc_DateTime), typeof(DateTime)),
-  [("record-struct", "DateTimeOffset")] = (typeof(X_rs_DateTimeOffset), typeof(DateTimeOffset)),
-  [("sealed-record-class", "DateTimeOffset")] = (typeof(X_rc_DateTimeOffset), typeof(DateTimeOffset)),
-  [("validated-struct", "DateTimeOffset")] = (typeof(X_vs_DateTimeOffset), typeof(DateTimeOffset)),
-  [("validated-class", "DateTimeOffset")] = (typeof(X_vc_DateTimeOffset), typeof(DateTimeOffset)),
-  [("record-struct", "Guid")] = (typeof(X_rs_Guid), typeof(Guid)),
-  [("sealed-record-class", "Guid")] = (typeof(X_rc_Guid), typeof(Guid)),
-  [("validated-struct", "Guid")] = (typeof(X_vs_Guid), typeof(Guid)),
-  [("validated-class", "Guid")] = (typeof(X_vc_Guid), typeof(Guid)),
-  [("record-struct", "TimeOnly")] = (typeof(X_rs_TimeOnly), typeof(TimeOnly)),
-  [("sealed-record-class", "TimeOnly")] = (typeof(X_rc_TimeOnly), typeof(TimeOnly)),
-  [("validated-struct", "TimeOnly")] = (typeof(X_vs_TimeOnly), typeof(TimeOnly)),
-  [("validated-class", "TimeOnly")] = (typeof(X_vc_TimeOnly), typeof(TimeOnly)),
-  [("record-struct", "TimeSpan")] = (typeof(X_rs_TimeSpan), typeof(TimeSpan)),
-  [("sealed-record-class", "TimeSpan")] = (typeof(X_rc_TimeSpan), typeof(TimeSpan)),
-  [("validated-struct", "TimeSpan")] = (typeof(X_vs_TimeSpan), typeof(TimeSpan)),
-  [("validated-class", "TimeSpan")] = (typeof(X_vc_TimeSpan), typeof(TimeSpan)),
-  [("record-struct", "Uri")] = (typeof(X_rs_Uri), typeof(Uri)),
-  [("sealed-record-class", "Uri")] = (typeof(X_rc_Uri), typeof(Uri)),
-  [("validated-struct", "Uri")] = (typeof(X_vs_Uri), typeof(Uri)),
-  [("validated-class", "Uri")] = (typeof(X_vc_Uri), typeof(Uri)),
-  [("record-struct", "bool")] = (typeof(X_rs_bool), typeof(bool)),
-  [("sealed-record-class", "bool")] = (typeof(X_rc_bool), typeof(bool)),
-  [("validated-struct", "bool")] = (typeof(X_vs_bool), typeof(bool)),
-  [("validated-class", "bool")] = (typeof(X_vc_bool), typeof(bool)),
-  [("record-struct", "byte")] = (typeof(X_rs_byte), typeof(byte)),
-  [("sealed-record-class", "byte")] = (typeof(X_rc_byte), typeof(byte)),
-  [("validated-struct", "byte")] = (typeof(X_vs_byte), typeof(byte)),
-  [("validated-class", "byte")] = (typeof(X_vc_byte), typeof(byte)),
-  [("record-struct", "char")] = (typeof(X_rs_char), typeof(char)),
-  [("sealed-record-class", "char")] = (typeof(X_rc_char), typeof(char)),
-  [("validated-struct", "char")] = (typeof(X_vs_char), typeof(char)),
-  [("validated-class", "char")] = (typeof(X_vc_char), typeof(char)),
-  [("record-struct", "decimal")] = (typeof(X_rs_decimal), typeof(decimal)),
-  [("sealed-record-class", "decimal")] = (typeof(X_rc_decimal), typeof(decimal)),
-  [("validated-struct", "decimal")] = (typeof(X_vs_decimal), typeof(decimal)),
-  [("validated-class", "decimal")] = (typeof(X_vc_decimal), typeof(decimal)),
-  [("record-struct", "double")] = (typeof(X_rs_double), typeof(double)),
-  [("sealed-record-class", "double")] = (typeof(X_rc_double), typeof(double)),
-  [("validated-struct", "double")] = (typeof(X_vs_double), typeof(double)),
-  [("validated-class", "double")] = (typeof(X_vc_double), typeof(double)),
-  [("record-struct", "enum")] = (typeof(X_rs_enum), typeof(PEnum)),
-  [("sealed-record-class", "enum")] = (typeof(X_rc_enum), typeof(PEnum)),
-  [("validated-struct", "enum")] = (typeof(X_vs_enum), typeof(PEnum)),
-  [("validated-class", "enum")] = (typeof(X_vc_enum), typeof(PEnum)),
-  [("record-struct", "flags-enum")] = (typeof(X_rs_flags_enum), typeof(PFlags)),
-  [("sealed-record-class", "flags-enum")] = (typeof(X_rc_flags_enum), typeof(PFlags)),
-  [("validated-struct", "flags-enum")] = (typeof(X_vs_flags_enum), typeof(PFlags)),
-  [("validated-class", "flags-enum")] = (typeof(X_vc_flags_enum), typeof(PFlags)),
-  [("record-struct", "int")] = (typeof(X_rs_int), typeof(int)),
-  [("sealed-record-class", "int")] = (typeof(X_rc_int), typeof(int)),
-  [("validated-struct", "int")] = (typeof(X_vs_int), typeof(int)),
-  [("validated-class", "int")] = (typeof(X_vc_int), typeof(int)),
-  [("record-struct", "long")] = (typeof(X_rs_long), typeof(long)),
-  [("sealed-record-class", "long")] = (typeof(X_rc_long), typeof(long)),
-  [("validated-struct", "long")] = (typeof(X_vs_long), typeof(long)),
-  [("validated-class", "long")] = (typeof(X_vc_long), typeof(long)),
-  [("record-struct", "string")] = (typeof(X_rs_string), typeof(string)),
-  [("sealed-record-class", "string")] = (typeof(X_rc_string), typeof(string)),
-  [("validated-struct", "string")] = (typeof(X_vs_string), typeof(string)),
-  [("validated-class", "string")] = (typeof(X_vc_string), typeof(string)),
-  [("record-struct", "ulong")] = (typeof(X_rs_ulong), typeof(ulong)),
-  [("sealed-record-class", "ulong")] = (typeof(X_rc_ulong), typeof(ulong)),
-  [("validated-struct", "ulong")] = (typeof(X_vs_ulong), typeof(ulong)),
-  [("validated-class", "ulong")] = (typeof(X_vc_ulong), typeof(ulong)),
- };
-}
diff --git a/tools/probe/corpus/harness/EfShapes4.g.cs b/tools/probe/corpus/harness/EfShapes4.g.cs
deleted file mode 100644
index 27234211..00000000
--- a/tools/probe/corpus/harness/EfShapes4.g.cs
+++ /dev/null
@@ -1,443 +0,0 @@
-// <auto-generated/> by tools/probe/generators/ef.cs nested: nested-site shapes (nested-in-class, nested-in-struct, nested-two-levels) for every kind x wrapped. Do not edit.
-#nullable enable
-#pragma warning disable CMTK0014, CS8618, CS1591, CMTK0005, CMTK1000, CMTK0003, CMTK0006, CA1000
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.ValueObjects;
-using Probes.Shapes;
-namespace Probes.Ef4;
-public static class NC_rs_DateOnly { public readonly partial record struct V : IValue<DateOnly>; }
-public struct NS_rs_DateOnly { public readonly partial record struct V : IValue<DateOnly>; }
-public static class N2_rs_DateOnly { public static class Inner { public readonly partial record struct V : IValue<DateOnly>; } }
-public static class NC_rc_DateOnly { public sealed partial record class V : IValue<DateOnly>; }
-public struct NS_rc_DateOnly { public sealed partial record class V : IValue<DateOnly>; }
-public static class N2_rc_DateOnly { public static class Inner { public sealed partial record class V : IValue<DateOnly>; } }
-public static class NC_vs_DateOnly { public readonly partial record struct V : IValidatedValue<V, DateOnly, ShapeFault> { public static Result<V, ShapeFault> Create(DateOnly value) => EqualityComparer<DateOnly>.Default.Equals(value, DateOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vs_DateOnly { public readonly partial record struct V : IValidatedValue<V, DateOnly, ShapeFault> { public static Result<V, ShapeFault> Create(DateOnly value) => EqualityComparer<DateOnly>.Default.Equals(value, DateOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vs_DateOnly { public static class Inner { public readonly partial record struct V : IValidatedValue<V, DateOnly, ShapeFault> { public static Result<V, ShapeFault> Create(DateOnly value) => EqualityComparer<DateOnly>.Default.Equals(value, DateOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_vc_DateOnly { public sealed partial record class V : IValidatedValue<V, DateOnly, ShapeFault> { public static Result<V, ShapeFault> Create(DateOnly value) => EqualityComparer<DateOnly>.Default.Equals(value, DateOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vc_DateOnly { public sealed partial record class V : IValidatedValue<V, DateOnly, ShapeFault> { public static Result<V, ShapeFault> Create(DateOnly value) => EqualityComparer<DateOnly>.Default.Equals(value, DateOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vc_DateOnly { public static class Inner { public sealed partial record class V : IValidatedValue<V, DateOnly, ShapeFault> { public static Result<V, ShapeFault> Create(DateOnly value) => EqualityComparer<DateOnly>.Default.Equals(value, DateOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_rs_DateTime { public readonly partial record struct V : IValue<DateTime>; }
-public struct NS_rs_DateTime { public readonly partial record struct V : IValue<DateTime>; }
-public static class N2_rs_DateTime { public static class Inner { public readonly partial record struct V : IValue<DateTime>; } }
-public static class NC_rc_DateTime { public sealed partial record class V : IValue<DateTime>; }
-public struct NS_rc_DateTime { public sealed partial record class V : IValue<DateTime>; }
-public static class N2_rc_DateTime { public static class Inner { public sealed partial record class V : IValue<DateTime>; } }
-public static class NC_vs_DateTime { public readonly partial record struct V : IValidatedValue<V, DateTime, ShapeFault> { public static Result<V, ShapeFault> Create(DateTime value) => EqualityComparer<DateTime>.Default.Equals(value, DateTime.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vs_DateTime { public readonly partial record struct V : IValidatedValue<V, DateTime, ShapeFault> { public static Result<V, ShapeFault> Create(DateTime value) => EqualityComparer<DateTime>.Default.Equals(value, DateTime.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vs_DateTime { public static class Inner { public readonly partial record struct V : IValidatedValue<V, DateTime, ShapeFault> { public static Result<V, ShapeFault> Create(DateTime value) => EqualityComparer<DateTime>.Default.Equals(value, DateTime.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_vc_DateTime { public sealed partial record class V : IValidatedValue<V, DateTime, ShapeFault> { public static Result<V, ShapeFault> Create(DateTime value) => EqualityComparer<DateTime>.Default.Equals(value, DateTime.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vc_DateTime { public sealed partial record class V : IValidatedValue<V, DateTime, ShapeFault> { public static Result<V, ShapeFault> Create(DateTime value) => EqualityComparer<DateTime>.Default.Equals(value, DateTime.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vc_DateTime { public static class Inner { public sealed partial record class V : IValidatedValue<V, DateTime, ShapeFault> { public static Result<V, ShapeFault> Create(DateTime value) => EqualityComparer<DateTime>.Default.Equals(value, DateTime.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_rs_DateTimeOffset { public readonly partial record struct V : IValue<DateTimeOffset>; }
-public struct NS_rs_DateTimeOffset { public readonly partial record struct V : IValue<DateTimeOffset>; }
-public static class N2_rs_DateTimeOffset { public static class Inner { public readonly partial record struct V : IValue<DateTimeOffset>; } }
-public static class NC_rc_DateTimeOffset { public sealed partial record class V : IValue<DateTimeOffset>; }
-public struct NS_rc_DateTimeOffset { public sealed partial record class V : IValue<DateTimeOffset>; }
-public static class N2_rc_DateTimeOffset { public static class Inner { public sealed partial record class V : IValue<DateTimeOffset>; } }
-public static class NC_vs_DateTimeOffset { public readonly partial record struct V : IValidatedValue<V, DateTimeOffset, ShapeFault> { public static Result<V, ShapeFault> Create(DateTimeOffset value) => EqualityComparer<DateTimeOffset>.Default.Equals(value, DateTimeOffset.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vs_DateTimeOffset { public readonly partial record struct V : IValidatedValue<V, DateTimeOffset, ShapeFault> { public static Result<V, ShapeFault> Create(DateTimeOffset value) => EqualityComparer<DateTimeOffset>.Default.Equals(value, DateTimeOffset.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vs_DateTimeOffset { public static class Inner { public readonly partial record struct V : IValidatedValue<V, DateTimeOffset, ShapeFault> { public static Result<V, ShapeFault> Create(DateTimeOffset value) => EqualityComparer<DateTimeOffset>.Default.Equals(value, DateTimeOffset.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_vc_DateTimeOffset { public sealed partial record class V : IValidatedValue<V, DateTimeOffset, ShapeFault> { public static Result<V, ShapeFault> Create(DateTimeOffset value) => EqualityComparer<DateTimeOffset>.Default.Equals(value, DateTimeOffset.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vc_DateTimeOffset { public sealed partial record class V : IValidatedValue<V, DateTimeOffset, ShapeFault> { public static Result<V, ShapeFault> Create(DateTimeOffset value) => EqualityComparer<DateTimeOffset>.Default.Equals(value, DateTimeOffset.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vc_DateTimeOffset { public static class Inner { public sealed partial record class V : IValidatedValue<V, DateTimeOffset, ShapeFault> { public static Result<V, ShapeFault> Create(DateTimeOffset value) => EqualityComparer<DateTimeOffset>.Default.Equals(value, DateTimeOffset.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_rs_Guid { public readonly partial record struct V : IValue<Guid>; }
-public struct NS_rs_Guid { public readonly partial record struct V : IValue<Guid>; }
-public static class N2_rs_Guid { public static class Inner { public readonly partial record struct V : IValue<Guid>; } }
-public static class NC_rc_Guid { public sealed partial record class V : IValue<Guid>; }
-public struct NS_rc_Guid { public sealed partial record class V : IValue<Guid>; }
-public static class N2_rc_Guid { public static class Inner { public sealed partial record class V : IValue<Guid>; } }
-public static class NC_vs_Guid { public readonly partial record struct V : IValidatedValue<V, Guid, ShapeFault> { public static Result<V, ShapeFault> Create(Guid value) => EqualityComparer<Guid>.Default.Equals(value, Guid.Empty) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vs_Guid { public readonly partial record struct V : IValidatedValue<V, Guid, ShapeFault> { public static Result<V, ShapeFault> Create(Guid value) => EqualityComparer<Guid>.Default.Equals(value, Guid.Empty) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vs_Guid { public static class Inner { public readonly partial record struct V : IValidatedValue<V, Guid, ShapeFault> { public static Result<V, ShapeFault> Create(Guid value) => EqualityComparer<Guid>.Default.Equals(value, Guid.Empty) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_vc_Guid { public sealed partial record class V : IValidatedValue<V, Guid, ShapeFault> { public static Result<V, ShapeFault> Create(Guid value) => EqualityComparer<Guid>.Default.Equals(value, Guid.Empty) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vc_Guid { public sealed partial record class V : IValidatedValue<V, Guid, ShapeFault> { public static Result<V, ShapeFault> Create(Guid value) => EqualityComparer<Guid>.Default.Equals(value, Guid.Empty) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vc_Guid { public static class Inner { public sealed partial record class V : IValidatedValue<V, Guid, ShapeFault> { public static Result<V, ShapeFault> Create(Guid value) => EqualityComparer<Guid>.Default.Equals(value, Guid.Empty) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_rs_TimeOnly { public readonly partial record struct V : IValue<TimeOnly>; }
-public struct NS_rs_TimeOnly { public readonly partial record struct V : IValue<TimeOnly>; }
-public static class N2_rs_TimeOnly { public static class Inner { public readonly partial record struct V : IValue<TimeOnly>; } }
-public static class NC_rc_TimeOnly { public sealed partial record class V : IValue<TimeOnly>; }
-public struct NS_rc_TimeOnly { public sealed partial record class V : IValue<TimeOnly>; }
-public static class N2_rc_TimeOnly { public static class Inner { public sealed partial record class V : IValue<TimeOnly>; } }
-public static class NC_vs_TimeOnly { public readonly partial record struct V : IValidatedValue<V, TimeOnly, ShapeFault> { public static Result<V, ShapeFault> Create(TimeOnly value) => EqualityComparer<TimeOnly>.Default.Equals(value, TimeOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vs_TimeOnly { public readonly partial record struct V : IValidatedValue<V, TimeOnly, ShapeFault> { public static Result<V, ShapeFault> Create(TimeOnly value) => EqualityComparer<TimeOnly>.Default.Equals(value, TimeOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vs_TimeOnly { public static class Inner { public readonly partial record struct V : IValidatedValue<V, TimeOnly, ShapeFault> { public static Result<V, ShapeFault> Create(TimeOnly value) => EqualityComparer<TimeOnly>.Default.Equals(value, TimeOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_vc_TimeOnly { public sealed partial record class V : IValidatedValue<V, TimeOnly, ShapeFault> { public static Result<V, ShapeFault> Create(TimeOnly value) => EqualityComparer<TimeOnly>.Default.Equals(value, TimeOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vc_TimeOnly { public sealed partial record class V : IValidatedValue<V, TimeOnly, ShapeFault> { public static Result<V, ShapeFault> Create(TimeOnly value) => EqualityComparer<TimeOnly>.Default.Equals(value, TimeOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vc_TimeOnly { public static class Inner { public sealed partial record class V : IValidatedValue<V, TimeOnly, ShapeFault> { public static Result<V, ShapeFault> Create(TimeOnly value) => EqualityComparer<TimeOnly>.Default.Equals(value, TimeOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_rs_TimeSpan { public readonly partial record struct V : IValue<TimeSpan>; }
-public struct NS_rs_TimeSpan { public readonly partial record struct V : IValue<TimeSpan>; }
-public static class N2_rs_TimeSpan { public static class Inner { public readonly partial record struct V : IValue<TimeSpan>; } }
-public static class NC_rc_TimeSpan { public sealed partial record class V : IValue<TimeSpan>; }
-public struct NS_rc_TimeSpan { public sealed partial record class V : IValue<TimeSpan>; }
-public static class N2_rc_TimeSpan { public static class Inner { public sealed partial record class V : IValue<TimeSpan>; } }
-public static class NC_vs_TimeSpan { public readonly partial record struct V : IValidatedValue<V, TimeSpan, ShapeFault> { public static Result<V, ShapeFault> Create(TimeSpan value) => EqualityComparer<TimeSpan>.Default.Equals(value, TimeSpan.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vs_TimeSpan { public readonly partial record struct V : IValidatedValue<V, TimeSpan, ShapeFault> { public static Result<V, ShapeFault> Create(TimeSpan value) => EqualityComparer<TimeSpan>.Default.Equals(value, TimeSpan.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vs_TimeSpan { public static class Inner { public readonly partial record struct V : IValidatedValue<V, TimeSpan, ShapeFault> { public static Result<V, ShapeFault> Create(TimeSpan value) => EqualityComparer<TimeSpan>.Default.Equals(value, TimeSpan.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_vc_TimeSpan { public sealed partial record class V : IValidatedValue<V, TimeSpan, ShapeFault> { public static Result<V, ShapeFault> Create(TimeSpan value) => EqualityComparer<TimeSpan>.Default.Equals(value, TimeSpan.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vc_TimeSpan { public sealed partial record class V : IValidatedValue<V, TimeSpan, ShapeFault> { public static Result<V, ShapeFault> Create(TimeSpan value) => EqualityComparer<TimeSpan>.Default.Equals(value, TimeSpan.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vc_TimeSpan { public static class Inner { public sealed partial record class V : IValidatedValue<V, TimeSpan, ShapeFault> { public static Result<V, ShapeFault> Create(TimeSpan value) => EqualityComparer<TimeSpan>.Default.Equals(value, TimeSpan.MinValue) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_rs_Uri { public readonly partial record struct V : IValue<Uri>; }
-public struct NS_rs_Uri { public readonly partial record struct V : IValue<Uri>; }
-public static class N2_rs_Uri { public static class Inner { public readonly partial record struct V : IValue<Uri>; } }
-public static class NC_rc_Uri { public sealed partial record class V : IValue<Uri>; }
-public struct NS_rc_Uri { public sealed partial record class V : IValue<Uri>; }
-public static class N2_rc_Uri { public static class Inner { public sealed partial record class V : IValue<Uri>; } }
-public static class NC_vs_Uri { public readonly partial record struct V : IValidatedValue<V, Uri, ShapeFault> { public static Result<V, ShapeFault> Create(Uri value) => EqualityComparer<Uri>.Default.Equals(value, new Uri("https://example.com/refused")) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vs_Uri { public readonly partial record struct V : IValidatedValue<V, Uri, ShapeFault> { public static Result<V, ShapeFault> Create(Uri value) => EqualityComparer<Uri>.Default.Equals(value, new Uri("https://example.com/refused")) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vs_Uri { public static class Inner { public readonly partial record struct V : IValidatedValue<V, Uri, ShapeFault> { public static Result<V, ShapeFault> Create(Uri value) => EqualityComparer<Uri>.Default.Equals(value, new Uri("https://example.com/refused")) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_vc_Uri { public sealed partial record class V : IValidatedValue<V, Uri, ShapeFault> { public static Result<V, ShapeFault> Create(Uri value) => EqualityComparer<Uri>.Default.Equals(value, new Uri("https://example.com/refused")) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vc_Uri { public sealed partial record class V : IValidatedValue<V, Uri, ShapeFault> { public static Result<V, ShapeFault> Create(Uri value) => EqualityComparer<Uri>.Default.Equals(value, new Uri("https://example.com/refused")) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vc_Uri { public static class Inner { public sealed partial record class V : IValidatedValue<V, Uri, ShapeFault> { public static Result<V, ShapeFault> Create(Uri value) => EqualityComparer<Uri>.Default.Equals(value, new Uri("https://example.com/refused")) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_rs_bool { public readonly partial record struct V : IValue<bool>; }
-public struct NS_rs_bool { public readonly partial record struct V : IValue<bool>; }
-public static class N2_rs_bool { public static class Inner { public readonly partial record struct V : IValue<bool>; } }
-public static class NC_rc_bool { public sealed partial record class V : IValue<bool>; }
-public struct NS_rc_bool { public sealed partial record class V : IValue<bool>; }
-public static class N2_rc_bool { public static class Inner { public sealed partial record class V : IValue<bool>; } }
-public static class NC_vs_bool { public readonly partial record struct V : IValidatedValue<V, bool, ShapeFault> { public static Result<V, ShapeFault> Create(bool value) => EqualityComparer<bool>.Default.Equals(value, false) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vs_bool { public readonly partial record struct V : IValidatedValue<V, bool, ShapeFault> { public static Result<V, ShapeFault> Create(bool value) => EqualityComparer<bool>.Default.Equals(value, false) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vs_bool { public static class Inner { public readonly partial record struct V : IValidatedValue<V, bool, ShapeFault> { public static Result<V, ShapeFault> Create(bool value) => EqualityComparer<bool>.Default.Equals(value, false) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_vc_bool { public sealed partial record class V : IValidatedValue<V, bool, ShapeFault> { public static Result<V, ShapeFault> Create(bool value) => EqualityComparer<bool>.Default.Equals(value, false) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vc_bool { public sealed partial record class V : IValidatedValue<V, bool, ShapeFault> { public static Result<V, ShapeFault> Create(bool value) => EqualityComparer<bool>.Default.Equals(value, false) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vc_bool { public static class Inner { public sealed partial record class V : IValidatedValue<V, bool, ShapeFault> { public static Result<V, ShapeFault> Create(bool value) => EqualityComparer<bool>.Default.Equals(value, false) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_rs_byte { public readonly partial record struct V : IValue<byte>; }
-public struct NS_rs_byte { public readonly partial record struct V : IValue<byte>; }
-public static class N2_rs_byte { public static class Inner { public readonly partial record struct V : IValue<byte>; } }
-public static class NC_rc_byte { public sealed partial record class V : IValue<byte>; }
-public struct NS_rc_byte { public sealed partial record class V : IValue<byte>; }
-public static class N2_rc_byte { public static class Inner { public sealed partial record class V : IValue<byte>; } }
-public static class NC_vs_byte { public readonly partial record struct V : IValidatedValue<V, byte, ShapeFault> { public static Result<V, ShapeFault> Create(byte value) => EqualityComparer<byte>.Default.Equals(value, (byte)255) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vs_byte { public readonly partial record struct V : IValidatedValue<V, byte, ShapeFault> { public static Result<V, ShapeFault> Create(byte value) => EqualityComparer<byte>.Default.Equals(value, (byte)255) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vs_byte { public static class Inner { public readonly partial record struct V : IValidatedValue<V, byte, ShapeFault> { public static Result<V, ShapeFault> Create(byte value) => EqualityComparer<byte>.Default.Equals(value, (byte)255) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_vc_byte { public sealed partial record class V : IValidatedValue<V, byte, ShapeFault> { public static Result<V, ShapeFault> Create(byte value) => EqualityComparer<byte>.Default.Equals(value, (byte)255) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vc_byte { public sealed partial record class V : IValidatedValue<V, byte, ShapeFault> { public static Result<V, ShapeFault> Create(byte value) => EqualityComparer<byte>.Default.Equals(value, (byte)255) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vc_byte { public static class Inner { public sealed partial record class V : IValidatedValue<V, byte, ShapeFault> { public static Result<V, ShapeFault> Create(byte value) => EqualityComparer<byte>.Default.Equals(value, (byte)255) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_rs_char { public readonly partial record struct V : IValue<char>; }
-public struct NS_rs_char { public readonly partial record struct V : IValue<char>; }
-public static class N2_rs_char { public static class Inner { public readonly partial record struct V : IValue<char>; } }
-public static class NC_rc_char { public sealed partial record class V : IValue<char>; }
-public struct NS_rc_char { public sealed partial record class V : IValue<char>; }
-public static class N2_rc_char { public static class Inner { public sealed partial record class V : IValue<char>; } }
-public static class NC_vs_char { public readonly partial record struct V : IValidatedValue<V, char, ShapeFault> { public static Result<V, ShapeFault> Create(char value) => EqualityComparer<char>.Default.Equals(value, 'x') ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vs_char { public readonly partial record struct V : IValidatedValue<V, char, ShapeFault> { public static Result<V, ShapeFault> Create(char value) => EqualityComparer<char>.Default.Equals(value, 'x') ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vs_char { public static class Inner { public readonly partial record struct V : IValidatedValue<V, char, ShapeFault> { public static Result<V, ShapeFault> Create(char value) => EqualityComparer<char>.Default.Equals(value, 'x') ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_vc_char { public sealed partial record class V : IValidatedValue<V, char, ShapeFault> { public static Result<V, ShapeFault> Create(char value) => EqualityComparer<char>.Default.Equals(value, 'x') ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vc_char { public sealed partial record class V : IValidatedValue<V, char, ShapeFault> { public static Result<V, ShapeFault> Create(char value) => EqualityComparer<char>.Default.Equals(value, 'x') ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vc_char { public static class Inner { public sealed partial record class V : IValidatedValue<V, char, ShapeFault> { public static Result<V, ShapeFault> Create(char value) => EqualityComparer<char>.Default.Equals(value, 'x') ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_rs_decimal { public readonly partial record struct V : IValue<decimal>; }
-public struct NS_rs_decimal { public readonly partial record struct V : IValue<decimal>; }
-public static class N2_rs_decimal { public static class Inner { public readonly partial record struct V : IValue<decimal>; } }
-public static class NC_rc_decimal { public sealed partial record class V : IValue<decimal>; }
-public struct NS_rc_decimal { public sealed partial record class V : IValue<decimal>; }
-public static class N2_rc_decimal { public static class Inner { public sealed partial record class V : IValue<decimal>; } }
-public static class NC_vs_decimal { public readonly partial record struct V : IValidatedValue<V, decimal, ShapeFault> { public static Result<V, ShapeFault> Create(decimal value) => EqualityComparer<decimal>.Default.Equals(value, -1m) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vs_decimal { public readonly partial record struct V : IValidatedValue<V, decimal, ShapeFault> { public static Result<V, ShapeFault> Create(decimal value) => EqualityComparer<decimal>.Default.Equals(value, -1m) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vs_decimal { public static class Inner { public readonly partial record struct V : IValidatedValue<V, decimal, ShapeFault> { public static Result<V, ShapeFault> Create(decimal value) => EqualityComparer<decimal>.Default.Equals(value, -1m) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_vc_decimal { public sealed partial record class V : IValidatedValue<V, decimal, ShapeFault> { public static Result<V, ShapeFault> Create(decimal value) => EqualityComparer<decimal>.Default.Equals(value, -1m) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vc_decimal { public sealed partial record class V : IValidatedValue<V, decimal, ShapeFault> { public static Result<V, ShapeFault> Create(decimal value) => EqualityComparer<decimal>.Default.Equals(value, -1m) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vc_decimal { public static class Inner { public sealed partial record class V : IValidatedValue<V, decimal, ShapeFault> { public static Result<V, ShapeFault> Create(decimal value) => EqualityComparer<decimal>.Default.Equals(value, -1m) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_rs_double { public readonly partial record struct V : IValue<double>; }
-public struct NS_rs_double { public readonly partial record struct V : IValue<double>; }
-public static class N2_rs_double { public static class Inner { public readonly partial record struct V : IValue<double>; } }
-public static class NC_rc_double { public sealed partial record class V : IValue<double>; }
-public struct NS_rc_double { public sealed partial record class V : IValue<double>; }
-public static class N2_rc_double { public static class Inner { public sealed partial record class V : IValue<double>; } }
-public static class NC_vs_double { public readonly partial record struct V : IValidatedValue<V, double, ShapeFault> { public static Result<V, ShapeFault> Create(double value) => EqualityComparer<double>.Default.Equals(value, -1.0) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vs_double { public readonly partial record struct V : IValidatedValue<V, double, ShapeFault> { public static Result<V, ShapeFault> Create(double value) => EqualityComparer<double>.Default.Equals(value, -1.0) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vs_double { public static class Inner { public readonly partial record struct V : IValidatedValue<V, double, ShapeFault> { public static Result<V, ShapeFault> Create(double value) => EqualityComparer<double>.Default.Equals(value, -1.0) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_vc_double { public sealed partial record class V : IValidatedValue<V, double, ShapeFault> { public static Result<V, ShapeFault> Create(double value) => EqualityComparer<double>.Default.Equals(value, -1.0) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vc_double { public sealed partial record class V : IValidatedValue<V, double, ShapeFault> { public static Result<V, ShapeFault> Create(double value) => EqualityComparer<double>.Default.Equals(value, -1.0) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vc_double { public static class Inner { public sealed partial record class V : IValidatedValue<V, double, ShapeFault> { public static Result<V, ShapeFault> Create(double value) => EqualityComparer<double>.Default.Equals(value, -1.0) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_rs_enum { public readonly partial record struct V : IValue<PEnum>; }
-public struct NS_rs_enum { public readonly partial record struct V : IValue<PEnum>; }
-public static class N2_rs_enum { public static class Inner { public readonly partial record struct V : IValue<PEnum>; } }
-public static class NC_rc_enum { public sealed partial record class V : IValue<PEnum>; }
-public struct NS_rc_enum { public sealed partial record class V : IValue<PEnum>; }
-public static class N2_rc_enum { public static class Inner { public sealed partial record class V : IValue<PEnum>; } }
-public static class NC_vs_enum { public readonly partial record struct V : IValidatedValue<V, PEnum, ShapeFault> { public static Result<V, ShapeFault> Create(PEnum value) => EqualityComparer<PEnum>.Default.Equals(value, (PEnum)99) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vs_enum { public readonly partial record struct V : IValidatedValue<V, PEnum, ShapeFault> { public static Result<V, ShapeFault> Create(PEnum value) => EqualityComparer<PEnum>.Default.Equals(value, (PEnum)99) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vs_enum { public static class Inner { public readonly partial record struct V : IValidatedValue<V, PEnum, ShapeFault> { public static Result<V, ShapeFault> Create(PEnum value) => EqualityComparer<PEnum>.Default.Equals(value, (PEnum)99) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_vc_enum { public sealed partial record class V : IValidatedValue<V, PEnum, ShapeFault> { public static Result<V, ShapeFault> Create(PEnum value) => EqualityComparer<PEnum>.Default.Equals(value, (PEnum)99) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vc_enum { public sealed partial record class V : IValidatedValue<V, PEnum, ShapeFault> { public static Result<V, ShapeFault> Create(PEnum value) => EqualityComparer<PEnum>.Default.Equals(value, (PEnum)99) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vc_enum { public static class Inner { public sealed partial record class V : IValidatedValue<V, PEnum, ShapeFault> { public static Result<V, ShapeFault> Create(PEnum value) => EqualityComparer<PEnum>.Default.Equals(value, (PEnum)99) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_rs_flags_enum { public readonly partial record struct V : IValue<PFlags>; }
-public struct NS_rs_flags_enum { public readonly partial record struct V : IValue<PFlags>; }
-public static class N2_rs_flags_enum { public static class Inner { public readonly partial record struct V : IValue<PFlags>; } }
-public static class NC_rc_flags_enum { public sealed partial record class V : IValue<PFlags>; }
-public struct NS_rc_flags_enum { public sealed partial record class V : IValue<PFlags>; }
-public static class N2_rc_flags_enum { public static class Inner { public sealed partial record class V : IValue<PFlags>; } }
-public static class NC_vs_flags_enum { public readonly partial record struct V : IValidatedValue<V, PFlags, ShapeFault> { public static Result<V, ShapeFault> Create(PFlags value) => EqualityComparer<PFlags>.Default.Equals(value, (PFlags)0) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vs_flags_enum { public readonly partial record struct V : IValidatedValue<V, PFlags, ShapeFault> { public static Result<V, ShapeFault> Create(PFlags value) => EqualityComparer<PFlags>.Default.Equals(value, (PFlags)0) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vs_flags_enum { public static class Inner { public readonly partial record struct V : IValidatedValue<V, PFlags, ShapeFault> { public static Result<V, ShapeFault> Create(PFlags value) => EqualityComparer<PFlags>.Default.Equals(value, (PFlags)0) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_vc_flags_enum { public sealed partial record class V : IValidatedValue<V, PFlags, ShapeFault> { public static Result<V, ShapeFault> Create(PFlags value) => EqualityComparer<PFlags>.Default.Equals(value, (PFlags)0) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vc_flags_enum { public sealed partial record class V : IValidatedValue<V, PFlags, ShapeFault> { public static Result<V, ShapeFault> Create(PFlags value) => EqualityComparer<PFlags>.Default.Equals(value, (PFlags)0) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vc_flags_enum { public static class Inner { public sealed partial record class V : IValidatedValue<V, PFlags, ShapeFault> { public static Result<V, ShapeFault> Create(PFlags value) => EqualityComparer<PFlags>.Default.Equals(value, (PFlags)0) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_rs_int { public readonly partial record struct V : IValue<int>; }
-public struct NS_rs_int { public readonly partial record struct V : IValue<int>; }
-public static class N2_rs_int { public static class Inner { public readonly partial record struct V : IValue<int>; } }
-public static class NC_rc_int { public sealed partial record class V : IValue<int>; }
-public struct NS_rc_int { public sealed partial record class V : IValue<int>; }
-public static class N2_rc_int { public static class Inner { public sealed partial record class V : IValue<int>; } }
-public static class NC_vs_int { public readonly partial record struct V : IValidatedValue<V, int, ShapeFault> { public static Result<V, ShapeFault> Create(int value) => EqualityComparer<int>.Default.Equals(value, -1) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vs_int { public readonly partial record struct V : IValidatedValue<V, int, ShapeFault> { public static Result<V, ShapeFault> Create(int value) => EqualityComparer<int>.Default.Equals(value, -1) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vs_int { public static class Inner { public readonly partial record struct V : IValidatedValue<V, int, ShapeFault> { public static Result<V, ShapeFault> Create(int value) => EqualityComparer<int>.Default.Equals(value, -1) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_vc_int { public sealed partial record class V : IValidatedValue<V, int, ShapeFault> { public static Result<V, ShapeFault> Create(int value) => EqualityComparer<int>.Default.Equals(value, -1) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vc_int { public sealed partial record class V : IValidatedValue<V, int, ShapeFault> { public static Result<V, ShapeFault> Create(int value) => EqualityComparer<int>.Default.Equals(value, -1) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vc_int { public static class Inner { public sealed partial record class V : IValidatedValue<V, int, ShapeFault> { public static Result<V, ShapeFault> Create(int value) => EqualityComparer<int>.Default.Equals(value, -1) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_rs_long { public readonly partial record struct V : IValue<long>; }
-public struct NS_rs_long { public readonly partial record struct V : IValue<long>; }
-public static class N2_rs_long { public static class Inner { public readonly partial record struct V : IValue<long>; } }
-public static class NC_rc_long { public sealed partial record class V : IValue<long>; }
-public struct NS_rc_long { public sealed partial record class V : IValue<long>; }
-public static class N2_rc_long { public static class Inner { public sealed partial record class V : IValue<long>; } }
-public static class NC_vs_long { public readonly partial record struct V : IValidatedValue<V, long, ShapeFault> { public static Result<V, ShapeFault> Create(long value) => EqualityComparer<long>.Default.Equals(value, -1L) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vs_long { public readonly partial record struct V : IValidatedValue<V, long, ShapeFault> { public static Result<V, ShapeFault> Create(long value) => EqualityComparer<long>.Default.Equals(value, -1L) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vs_long { public static class Inner { public readonly partial record struct V : IValidatedValue<V, long, ShapeFault> { public static Result<V, ShapeFault> Create(long value) => EqualityComparer<long>.Default.Equals(value, -1L) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_vc_long { public sealed partial record class V : IValidatedValue<V, long, ShapeFault> { public static Result<V, ShapeFault> Create(long value) => EqualityComparer<long>.Default.Equals(value, -1L) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vc_long { public sealed partial record class V : IValidatedValue<V, long, ShapeFault> { public static Result<V, ShapeFault> Create(long value) => EqualityComparer<long>.Default.Equals(value, -1L) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vc_long { public static class Inner { public sealed partial record class V : IValidatedValue<V, long, ShapeFault> { public static Result<V, ShapeFault> Create(long value) => EqualityComparer<long>.Default.Equals(value, -1L) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_rs_string { public readonly partial record struct V : IValue<string>; }
-public struct NS_rs_string { public readonly partial record struct V : IValue<string>; }
-public static class N2_rs_string { public static class Inner { public readonly partial record struct V : IValue<string>; } }
-public static class NC_rc_string { public sealed partial record class V : IValue<string>; }
-public struct NS_rc_string { public sealed partial record class V : IValue<string>; }
-public static class N2_rc_string { public static class Inner { public sealed partial record class V : IValue<string>; } }
-public static class NC_vs_string { public readonly partial record struct V : IValidatedValue<V, string, ShapeFault> { public static Result<V, ShapeFault> Create(string value) => EqualityComparer<string>.Default.Equals(value, "SECRET-7f3a") ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vs_string { public readonly partial record struct V : IValidatedValue<V, string, ShapeFault> { public static Result<V, ShapeFault> Create(string value) => EqualityComparer<string>.Default.Equals(value, "SECRET-7f3a") ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vs_string { public static class Inner { public readonly partial record struct V : IValidatedValue<V, string, ShapeFault> { public static Result<V, ShapeFault> Create(string value) => EqualityComparer<string>.Default.Equals(value, "SECRET-7f3a") ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_vc_string { public sealed partial record class V : IValidatedValue<V, string, ShapeFault> { public static Result<V, ShapeFault> Create(string value) => EqualityComparer<string>.Default.Equals(value, "SECRET-7f3a") ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vc_string { public sealed partial record class V : IValidatedValue<V, string, ShapeFault> { public static Result<V, ShapeFault> Create(string value) => EqualityComparer<string>.Default.Equals(value, "SECRET-7f3a") ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vc_string { public static class Inner { public sealed partial record class V : IValidatedValue<V, string, ShapeFault> { public static Result<V, ShapeFault> Create(string value) => EqualityComparer<string>.Default.Equals(value, "SECRET-7f3a") ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_rs_ulong { public readonly partial record struct V : IValue<ulong>; }
-public struct NS_rs_ulong { public readonly partial record struct V : IValue<ulong>; }
-public static class N2_rs_ulong { public static class Inner { public readonly partial record struct V : IValue<ulong>; } }
-public static class NC_rc_ulong { public sealed partial record class V : IValue<ulong>; }
-public struct NS_rc_ulong { public sealed partial record class V : IValue<ulong>; }
-public static class N2_rc_ulong { public static class Inner { public sealed partial record class V : IValue<ulong>; } }
-public static class NC_vs_ulong { public readonly partial record struct V : IValidatedValue<V, ulong, ShapeFault> { public static Result<V, ShapeFault> Create(ulong value) => EqualityComparer<ulong>.Default.Equals(value, 0UL) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vs_ulong { public readonly partial record struct V : IValidatedValue<V, ulong, ShapeFault> { public static Result<V, ShapeFault> Create(ulong value) => EqualityComparer<ulong>.Default.Equals(value, 0UL) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vs_ulong { public static class Inner { public readonly partial record struct V : IValidatedValue<V, ulong, ShapeFault> { public static Result<V, ShapeFault> Create(ulong value) => EqualityComparer<ulong>.Default.Equals(value, 0UL) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class NC_vc_ulong { public sealed partial record class V : IValidatedValue<V, ulong, ShapeFault> { public static Result<V, ShapeFault> Create(ulong value) => EqualityComparer<ulong>.Default.Equals(value, 0UL) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public struct NS_vc_ulong { public sealed partial record class V : IValidatedValue<V, ulong, ShapeFault> { public static Result<V, ShapeFault> Create(ulong value) => EqualityComparer<ulong>.Default.Equals(value, 0UL) ? Result.Error(ShapeFault.Refused) : new V(value); } }
-public static class N2_vc_ulong { public static class Inner { public sealed partial record class V : IValidatedValue<V, ulong, ShapeFault> { public static Result<V, ShapeFault> Create(ulong value) => EqualityComparer<ulong>.Default.Equals(value, 0UL) ? Result.Error(ShapeFault.Refused) : new V(value); } } }
-public static class Reg4 {
- public static readonly Dictionary<(string Kind, string Wrapped, string Site), (Type Vo, Type Plain)> All = new() {
-  [("record-struct", "DateOnly", "nested-in-class")] = (typeof(NC_rs_DateOnly.V), typeof(DateOnly)),
-  [("record-struct", "DateOnly", "nested-in-struct")] = (typeof(NS_rs_DateOnly.V), typeof(DateOnly)),
-  [("record-struct", "DateOnly", "nested-two-levels")] = (typeof(N2_rs_DateOnly.Inner.V), typeof(DateOnly)),
-  [("sealed-record-class", "DateOnly", "nested-in-class")] = (typeof(NC_rc_DateOnly.V), typeof(DateOnly)),
-  [("sealed-record-class", "DateOnly", "nested-in-struct")] = (typeof(NS_rc_DateOnly.V), typeof(DateOnly)),
-  [("sealed-record-class", "DateOnly", "nested-two-levels")] = (typeof(N2_rc_DateOnly.Inner.V), typeof(DateOnly)),
-  [("validated-struct", "DateOnly", "nested-in-class")] = (typeof(NC_vs_DateOnly.V), typeof(DateOnly)),
-  [("validated-struct", "DateOnly", "nested-in-struct")] = (typeof(NS_vs_DateOnly.V), typeof(DateOnly)),
-  [("validated-struct", "DateOnly", "nested-two-levels")] = (typeof(N2_vs_DateOnly.Inner.V), typeof(DateOnly)),
-  [("validated-class", "DateOnly", "nested-in-class")] = (typeof(NC_vc_DateOnly.V), typeof(DateOnly)),
-  [("validated-class", "DateOnly", "nested-in-struct")] = (typeof(NS_vc_DateOnly.V), typeof(DateOnly)),
-  [("validated-class", "DateOnly", "nested-two-levels")] = (typeof(N2_vc_DateOnly.Inner.V), typeof(DateOnly)),
-  [("record-struct", "DateTime", "nested-in-class")] = (typeof(NC_rs_DateTime.V), typeof(DateTime)),
-  [("record-struct", "DateTime", "nested-in-struct")] = (typeof(NS_rs_DateTime.V), typeof(DateTime)),
-  [("record-struct", "DateTime", "nested-two-levels")] = (typeof(N2_rs_DateTime.Inner.V), typeof(DateTime)),
-  [("sealed-record-class", "DateTime", "nested-in-class")] = (typeof(NC_rc_DateTime.V), typeof(DateTime)),
-  [("sealed-record-class", "DateTime", "nested-in-struct")] = (typeof(NS_rc_DateTime.V), typeof(DateTime)),
-  [("sealed-record-class", "DateTime", "nested-two-levels")] = (typeof(N2_rc_DateTime.Inner.V), typeof(DateTime)),
-  [("validated-struct", "DateTime", "nested-in-class")] = (typeof(NC_vs_DateTime.V), typeof(DateTime)),
-  [("validated-struct", "DateTime", "nested-in-struct")] = (typeof(NS_vs_DateTime.V), typeof(DateTime)),
-  [("validated-struct", "DateTime", "nested-two-levels")] = (typeof(N2_vs_DateTime.Inner.V), typeof(DateTime)),
-  [("validated-class", "DateTime", "nested-in-class")] = (typeof(NC_vc_DateTime.V), typeof(DateTime)),
-  [("validated-class", "DateTime", "nested-in-struct")] = (typeof(NS_vc_DateTime.V), typeof(DateTime)),
-  [("validated-class", "DateTime", "nested-two-levels")] = (typeof(N2_vc_DateTime.Inner.V), typeof(DateTime)),
-  [("record-struct", "DateTimeOffset", "nested-in-class")] = (typeof(NC_rs_DateTimeOffset.V), typeof(DateTimeOffset)),
-  [("record-struct", "DateTimeOffset", "nested-in-struct")] = (typeof(NS_rs_DateTimeOffset.V), typeof(DateTimeOffset)),
-  [("record-struct", "DateTimeOffset", "nested-two-levels")] = (typeof(N2_rs_DateTimeOffset.Inner.V), typeof(DateTimeOffset)),
-  [("sealed-record-class", "DateTimeOffset", "nested-in-class")] = (typeof(NC_rc_DateTimeOffset.V), typeof(DateTimeOffset)),
-  [("sealed-record-class", "DateTimeOffset", "nested-in-struct")] = (typeof(NS_rc_DateTimeOffset.V), typeof(DateTimeOffset)),
-  [("sealed-record-class", "DateTimeOffset", "nested-two-levels")] = (typeof(N2_rc_DateTimeOffset.Inner.V), typeof(DateTimeOffset)),
-  [("validated-struct", "DateTimeOffset", "nested-in-class")] = (typeof(NC_vs_DateTimeOffset.V), typeof(DateTimeOffset)),
-  [("validated-struct", "DateTimeOffset", "nested-in-struct")] = (typeof(NS_vs_DateTimeOffset.V), typeof(DateTimeOffset)),
-  [("validated-struct", "DateTimeOffset", "nested-two-levels")] = (typeof(N2_vs_DateTimeOffset.Inner.V), typeof(DateTimeOffset)),
-  [("validated-class", "DateTimeOffset", "nested-in-class")] = (typeof(NC_vc_DateTimeOffset.V), typeof(DateTimeOffset)),
-  [("validated-class", "DateTimeOffset", "nested-in-struct")] = (typeof(NS_vc_DateTimeOffset.V), typeof(DateTimeOffset)),
-  [("validated-class", "DateTimeOffset", "nested-two-levels")] = (typeof(N2_vc_DateTimeOffset.Inner.V), typeof(DateTimeOffset)),
-  [("record-struct", "Guid", "nested-in-class")] = (typeof(NC_rs_Guid.V), typeof(Guid)),
-  [("record-struct", "Guid", "nested-in-struct")] = (typeof(NS_rs_Guid.V), typeof(Guid)),
-  [("record-struct", "Guid", "nested-two-levels")] = (typeof(N2_rs_Guid.Inner.V), typeof(Guid)),
-  [("sealed-record-class", "Guid", "nested-in-class")] = (typeof(NC_rc_Guid.V), typeof(Guid)),
-  [("sealed-record-class", "Guid", "nested-in-struct")] = (typeof(NS_rc_Guid.V), typeof(Guid)),
-  [("sealed-record-class", "Guid", "nested-two-levels")] = (typeof(N2_rc_Guid.Inner.V), typeof(Guid)),
-  [("validated-struct", "Guid", "nested-in-class")] = (typeof(NC_vs_Guid.V), typeof(Guid)),
-  [("validated-struct", "Guid", "nested-in-struct")] = (typeof(NS_vs_Guid.V), typeof(Guid)),
-  [("validated-struct", "Guid", "nested-two-levels")] = (typeof(N2_vs_Guid.Inner.V), typeof(Guid)),
-  [("validated-class", "Guid", "nested-in-class")] = (typeof(NC_vc_Guid.V), typeof(Guid)),
-  [("validated-class", "Guid", "nested-in-struct")] = (typeof(NS_vc_Guid.V), typeof(Guid)),
-  [("validated-class", "Guid", "nested-two-levels")] = (typeof(N2_vc_Guid.Inner.V), typeof(Guid)),
-  [("record-struct", "TimeOnly", "nested-in-class")] = (typeof(NC_rs_TimeOnly.V), typeof(TimeOnly)),
-  [("record-struct", "TimeOnly", "nested-in-struct")] = (typeof(NS_rs_TimeOnly.V), typeof(TimeOnly)),
-  [("record-struct", "TimeOnly", "nested-two-levels")] = (typeof(N2_rs_TimeOnly.Inner.V), typeof(TimeOnly)),
-  [("sealed-record-class", "TimeOnly", "nested-in-class")] = (typeof(NC_rc_TimeOnly.V), typeof(TimeOnly)),
-  [("sealed-record-class", "TimeOnly", "nested-in-struct")] = (typeof(NS_rc_TimeOnly.V), typeof(TimeOnly)),
-  [("sealed-record-class", "TimeOnly", "nested-two-levels")] = (typeof(N2_rc_TimeOnly.Inner.V), typeof(TimeOnly)),
-  [("validated-struct", "TimeOnly", "nested-in-class")] = (typeof(NC_vs_TimeOnly.V), typeof(TimeOnly)),
-  [("validated-struct", "TimeOnly", "nested-in-struct")] = (typeof(NS_vs_TimeOnly.V), typeof(TimeOnly)),
-  [("validated-struct", "TimeOnly", "nested-two-levels")] = (typeof(N2_vs_TimeOnly.Inner.V), typeof(TimeOnly)),
-  [("validated-class", "TimeOnly", "nested-in-class")] = (typeof(NC_vc_TimeOnly.V), typeof(TimeOnly)),
-  [("validated-class", "TimeOnly", "nested-in-struct")] = (typeof(NS_vc_TimeOnly.V), typeof(TimeOnly)),
-  [("validated-class", "TimeOnly", "nested-two-levels")] = (typeof(N2_vc_TimeOnly.Inner.V), typeof(TimeOnly)),
-  [("record-struct", "TimeSpan", "nested-in-class")] = (typeof(NC_rs_TimeSpan.V), typeof(TimeSpan)),
-  [("record-struct", "TimeSpan", "nested-in-struct")] = (typeof(NS_rs_TimeSpan.V), typeof(TimeSpan)),
-  [("record-struct", "TimeSpan", "nested-two-levels")] = (typeof(N2_rs_TimeSpan.Inner.V), typeof(TimeSpan)),
-  [("sealed-record-class", "TimeSpan", "nested-in-class")] = (typeof(NC_rc_TimeSpan.V), typeof(TimeSpan)),
-  [("sealed-record-class", "TimeSpan", "nested-in-struct")] = (typeof(NS_rc_TimeSpan.V), typeof(TimeSpan)),
-  [("sealed-record-class", "TimeSpan", "nested-two-levels")] = (typeof(N2_rc_TimeSpan.Inner.V), typeof(TimeSpan)),
-  [("validated-struct", "TimeSpan", "nested-in-class")] = (typeof(NC_vs_TimeSpan.V), typeof(TimeSpan)),
-  [("validated-struct", "TimeSpan", "nested-in-struct")] = (typeof(NS_vs_TimeSpan.V), typeof(TimeSpan)),
-  [("validated-struct", "TimeSpan", "nested-two-levels")] = (typeof(N2_vs_TimeSpan.Inner.V), typeof(TimeSpan)),
-  [("validated-class", "TimeSpan", "nested-in-class")] = (typeof(NC_vc_TimeSpan.V), typeof(TimeSpan)),
-  [("validated-class", "TimeSpan", "nested-in-struct")] = (typeof(NS_vc_TimeSpan.V), typeof(TimeSpan)),
-  [("validated-class", "TimeSpan", "nested-two-levels")] = (typeof(N2_vc_TimeSpan.Inner.V), typeof(TimeSpan)),
-  [("record-struct", "Uri", "nested-in-class")] = (typeof(NC_rs_Uri.V), typeof(Uri)),
-  [("record-struct", "Uri", "nested-in-struct")] = (typeof(NS_rs_Uri.V), typeof(Uri)),
-  [("record-struct", "Uri", "nested-two-levels")] = (typeof(N2_rs_Uri.Inner.V), typeof(Uri)),
-  [("sealed-record-class", "Uri", "nested-in-class")] = (typeof(NC_rc_Uri.V), typeof(Uri)),
-  [("sealed-record-class", "Uri", "nested-in-struct")] = (typeof(NS_rc_Uri.V), typeof(Uri)),
-  [("sealed-record-class", "Uri", "nested-two-levels")] = (typeof(N2_rc_Uri.Inner.V), typeof(Uri)),
-  [("validated-struct", "Uri", "nested-in-class")] = (typeof(NC_vs_Uri.V), typeof(Uri)),
-  [("validated-struct", "Uri", "nested-in-struct")] = (typeof(NS_vs_Uri.V), typeof(Uri)),
-  [("validated-struct", "Uri", "nested-two-levels")] = (typeof(N2_vs_Uri.Inner.V), typeof(Uri)),
-  [("validated-class", "Uri", "nested-in-class")] = (typeof(NC_vc_Uri.V), typeof(Uri)),
-  [("validated-class", "Uri", "nested-in-struct")] = (typeof(NS_vc_Uri.V), typeof(Uri)),
-  [("validated-class", "Uri", "nested-two-levels")] = (typeof(N2_vc_Uri.Inner.V), typeof(Uri)),
-  [("record-struct", "bool", "nested-in-class")] = (typeof(NC_rs_bool.V), typeof(bool)),
-  [("record-struct", "bool", "nested-in-struct")] = (typeof(NS_rs_bool.V), typeof(bool)),
-  [("record-struct", "bool", "nested-two-levels")] = (typeof(N2_rs_bool.Inner.V), typeof(bool)),
-  [("sealed-record-class", "bool", "nested-in-class")] = (typeof(NC_rc_bool.V), typeof(bool)),
-  [("sealed-record-class", "bool", "nested-in-struct")] = (typeof(NS_rc_bool.V), typeof(bool)),
-  [("sealed-record-class", "bool", "nested-two-levels")] = (typeof(N2_rc_bool.Inner.V), typeof(bool)),
-  [("validated-struct", "bool", "nested-in-class")] = (typeof(NC_vs_bool.V), typeof(bool)),
-  [("validated-struct", "bool", "nested-in-struct")] = (typeof(NS_vs_bool.V), typeof(bool)),
-  [("validated-struct", "bool", "nested-two-levels")] = (typeof(N2_vs_bool.Inner.V), typeof(bool)),
-  [("validated-class", "bool", "nested-in-class")] = (typeof(NC_vc_bool.V), typeof(bool)),
-  [("validated-class", "bool", "nested-in-struct")] = (typeof(NS_vc_bool.V), typeof(bool)),
-  [("validated-class", "bool", "nested-two-levels")] = (typeof(N2_vc_bool.Inner.V), typeof(bool)),
-  [("record-struct", "byte", "nested-in-class")] = (typeof(NC_rs_byte.V), typeof(byte)),
-  [("record-struct", "byte", "nested-in-struct")] = (typeof(NS_rs_byte.V), typeof(byte)),
-  [("record-struct", "byte", "nested-two-levels")] = (typeof(N2_rs_byte.Inner.V), typeof(byte)),
-  [("sealed-record-class", "byte", "nested-in-class")] = (typeof(NC_rc_byte.V), typeof(byte)),
-  [("sealed-record-class", "byte", "nested-in-struct")] = (typeof(NS_rc_byte.V), typeof(byte)),
-  [("sealed-record-class", "byte", "nested-two-levels")] = (typeof(N2_rc_byte.Inner.V), typeof(byte)),
-  [("validated-struct", "byte", "nested-in-class")] = (typeof(NC_vs_byte.V), typeof(byte)),
-  [("validated-struct", "byte", "nested-in-struct")] = (typeof(NS_vs_byte.V), typeof(byte)),
-  [("validated-struct", "byte", "nested-two-levels")] = (typeof(N2_vs_byte.Inner.V), typeof(byte)),
-  [("validated-class", "byte", "nested-in-class")] = (typeof(NC_vc_byte.V), typeof(byte)),
-  [("validated-class", "byte", "nested-in-struct")] = (typeof(NS_vc_byte.V), typeof(byte)),
-  [("validated-class", "byte", "nested-two-levels")] = (typeof(N2_vc_byte.Inner.V), typeof(byte)),
-  [("record-struct", "char", "nested-in-class")] = (typeof(NC_rs_char.V), typeof(char)),
-  [("record-struct", "char", "nested-in-struct")] = (typeof(NS_rs_char.V), typeof(char)),
-  [("record-struct", "char", "nested-two-levels")] = (typeof(N2_rs_char.Inner.V), typeof(char)),
-  [("sealed-record-class", "char", "nested-in-class")] = (typeof(NC_rc_char.V), typeof(char)),
-  [("sealed-record-class", "char", "nested-in-struct")] = (typeof(NS_rc_char.V), typeof(char)),
-  [("sealed-record-class", "char", "nested-two-levels")] = (typeof(N2_rc_char.Inner.V), typeof(char)),
-  [("validated-struct", "char", "nested-in-class")] = (typeof(NC_vs_char.V), typeof(char)),
-  [("validated-struct", "char", "nested-in-struct")] = (typeof(NS_vs_char.V), typeof(char)),
-  [("validated-struct", "char", "nested-two-levels")] = (typeof(N2_vs_char.Inner.V), typeof(char)),
-  [("validated-class", "char", "nested-in-class")] = (typeof(NC_vc_char.V), typeof(char)),
-  [("validated-class", "char", "nested-in-struct")] = (typeof(NS_vc_char.V), typeof(char)),
-  [("validated-class", "char", "nested-two-levels")] = (typeof(N2_vc_char.Inner.V), typeof(char)),
-  [("record-struct", "decimal", "nested-in-class")] = (typeof(NC_rs_decimal.V), typeof(decimal)),
-  [("record-struct", "decimal", "nested-in-struct")] = (typeof(NS_rs_decimal.V), typeof(decimal)),
-  [("record-struct", "decimal", "nested-two-levels")] = (typeof(N2_rs_decimal.Inner.V), typeof(decimal)),
-  [("sealed-record-class", "decimal", "nested-in-class")] = (typeof(NC_rc_decimal.V), typeof(decimal)),
-  [("sealed-record-class", "decimal", "nested-in-struct")] = (typeof(NS_rc_decimal.V), typeof(decimal)),
-  [("sealed-record-class", "decimal", "nested-two-levels")] = (typeof(N2_rc_decimal.Inner.V), typeof(decimal)),
-  [("validated-struct", "decimal", "nested-in-class")] = (typeof(NC_vs_decimal.V), typeof(decimal)),
-  [("validated-struct", "decimal", "nested-in-struct")] = (typeof(NS_vs_decimal.V), typeof(decimal)),
-  [("validated-struct", "decimal", "nested-two-levels")] = (typeof(N2_vs_decimal.Inner.V), typeof(decimal)),
-  [("validated-class", "decimal", "nested-in-class")] = (typeof(NC_vc_decimal.V), typeof(decimal)),
-  [("validated-class", "decimal", "nested-in-struct")] = (typeof(NS_vc_decimal.V), typeof(decimal)),
-  [("validated-class", "decimal", "nested-two-levels")] = (typeof(N2_vc_decimal.Inner.V), typeof(decimal)),
-  [("record-struct", "double", "nested-in-class")] = (typeof(NC_rs_double.V), typeof(double)),
-  [("record-struct", "double", "nested-in-struct")] = (typeof(NS_rs_double.V), typeof(double)),
-  [("record-struct", "double", "nested-two-levels")] = (typeof(N2_rs_double.Inner.V), typeof(double)),
-  [("sealed-record-class", "double", "nested-in-class")] = (typeof(NC_rc_double.V), typeof(double)),
-  [("sealed-record-class", "double", "nested-in-struct")] = (typeof(NS_rc_double.V), typeof(double)),
-  [("sealed-record-class", "double", "nested-two-levels")] = (typeof(N2_rc_double.Inner.V), typeof(double)),
-  [("validated-struct", "double", "nested-in-class")] = (typeof(NC_vs_double.V), typeof(double)),
-  [("validated-struct", "double", "nested-in-struct")] = (typeof(NS_vs_double.V), typeof(double)),
-  [("validated-struct", "double", "nested-two-levels")] = (typeof(N2_vs_double.Inner.V), typeof(double)),
-  [("validated-class", "double", "nested-in-class")] = (typeof(NC_vc_double.V), typeof(double)),
-  [("validated-class", "double", "nested-in-struct")] = (typeof(NS_vc_double.V), typeof(double)),
-  [("validated-class", "double", "nested-two-levels")] = (typeof(N2_vc_double.Inner.V), typeof(double)),
-  [("record-struct", "enum", "nested-in-class")] = (typeof(NC_rs_enum.V), typeof(PEnum)),
-  [("record-struct", "enum", "nested-in-struct")] = (typeof(NS_rs_enum.V), typeof(PEnum)),
-  [("record-struct", "enum", "nested-two-levels")] = (typeof(N2_rs_enum.Inner.V), typeof(PEnum)),
-  [("sealed-record-class", "enum", "nested-in-class")] = (typeof(NC_rc_enum.V), typeof(PEnum)),
-  [("sealed-record-class", "enum", "nested-in-struct")] = (typeof(NS_rc_enum.V), typeof(PEnum)),
-  [("sealed-record-class", "enum", "nested-two-levels")] = (typeof(N2_rc_enum.Inner.V), typeof(PEnum)),
-  [("validated-struct", "enum", "nested-in-class")] = (typeof(NC_vs_enum.V), typeof(PEnum)),
-  [("validated-struct", "enum", "nested-in-struct")] = (typeof(NS_vs_enum.V), typeof(PEnum)),
-  [("validated-struct", "enum", "nested-two-levels")] = (typeof(N2_vs_enum.Inner.V), typeof(PEnum)),
-  [("validated-class", "enum", "nested-in-class")] = (typeof(NC_vc_enum.V), typeof(PEnum)),
-  [("validated-class", "enum", "nested-in-struct")] = (typeof(NS_vc_enum.V), typeof(PEnum)),
-  [("validated-class", "enum", "nested-two-levels")] = (typeof(N2_vc_enum.Inner.V), typeof(PEnum)),
-  [("record-struct", "flags-enum", "nested-in-class")] = (typeof(NC_rs_flags_enum.V), typeof(PFlags)),
-  [("record-struct", "flags-enum", "nested-in-struct")] = (typeof(NS_rs_flags_enum.V), typeof(PFlags)),
-  [("record-struct", "flags-enum", "nested-two-levels")] = (typeof(N2_rs_flags_enum.Inner.V), typeof(PFlags)),
-  [("sealed-record-class", "flags-enum", "nested-in-class")] = (typeof(NC_rc_flags_enum.V), typeof(PFlags)),
-  [("sealed-record-class", "flags-enum", "nested-in-struct")] = (typeof(NS_rc_flags_enum.V), typeof(PFlags)),
-  [("sealed-record-class", "flags-enum", "nested-two-levels")] = (typeof(N2_rc_flags_enum.Inner.V), typeof(PFlags)),
-  [("validated-struct", "flags-enum", "nested-in-class")] = (typeof(NC_vs_flags_enum.V), typeof(PFlags)),
-  [("validated-struct", "flags-enum", "nested-in-struct")] = (typeof(NS_vs_flags_enum.V), typeof(PFlags)),
-  [("validated-struct", "flags-enum", "nested-two-levels")] = (typeof(N2_vs_flags_enum.Inner.V), typeof(PFlags)),
-  [("validated-class", "flags-enum", "nested-in-class")] = (typeof(NC_vc_flags_enum.V), typeof(PFlags)),
-  [("validated-class", "flags-enum", "nested-in-struct")] = (typeof(NS_vc_flags_enum.V), typeof(PFlags)),
-  [("validated-class", "flags-enum", "nested-two-levels")] = (typeof(N2_vc_flags_enum.Inner.V), typeof(PFlags)),
-  [("record-struct", "int", "nested-in-class")] = (typeof(NC_rs_int.V), typeof(int)),
-  [("record-struct", "int", "nested-in-struct")] = (typeof(NS_rs_int.V), typeof(int)),
-  [("record-struct", "int", "nested-two-levels")] = (typeof(N2_rs_int.Inner.V), typeof(int)),
-  [("sealed-record-class", "int", "nested-in-class")] = (typeof(NC_rc_int.V), typeof(int)),
-  [("sealed-record-class", "int", "nested-in-struct")] = (typeof(NS_rc_int.V), typeof(int)),
-  [("sealed-record-class", "int", "nested-two-levels")] = (typeof(N2_rc_int.Inner.V), typeof(int)),
-  [("validated-struct", "int", "nested-in-class")] = (typeof(NC_vs_int.V), typeof(int)),
-  [("validated-struct", "int", "nested-in-struct")] = (typeof(NS_vs_int.V), typeof(int)),
-  [("validated-struct", "int", "nested-two-levels")] = (typeof(N2_vs_int.Inner.V), typeof(int)),
-  [("validated-class", "int", "nested-in-class")] = (typeof(NC_vc_int.V), typeof(int)),
-  [("validated-class", "int", "nested-in-struct")] = (typeof(NS_vc_int.V), typeof(int)),
-  [("validated-class", "int", "nested-two-levels")] = (typeof(N2_vc_int.Inner.V), typeof(int)),
-  [("record-struct", "long", "nested-in-class")] = (typeof(NC_rs_long.V), typeof(long)),
-  [("record-struct", "long", "nested-in-struct")] = (typeof(NS_rs_long.V), typeof(long)),
-  [("record-struct", "long", "nested-two-levels")] = (typeof(N2_rs_long.Inner.V), typeof(long)),
-  [("sealed-record-class", "long", "nested-in-class")] = (typeof(NC_rc_long.V), typeof(long)),
-  [("sealed-record-class", "long", "nested-in-struct")] = (typeof(NS_rc_long.V), typeof(long)),
-  [("sealed-record-class", "long", "nested-two-levels")] = (typeof(N2_rc_long.Inner.V), typeof(long)),
-  [("validated-struct", "long", "nested-in-class")] = (typeof(NC_vs_long.V), typeof(long)),
-  [("validated-struct", "long", "nested-in-struct")] = (typeof(NS_vs_long.V), typeof(long)),
-  [("validated-struct", "long", "nested-two-levels")] = (typeof(N2_vs_long.Inner.V), typeof(long)),
-  [("validated-class", "long", "nested-in-class")] = (typeof(NC_vc_long.V), typeof(long)),
-  [("validated-class", "long", "nested-in-struct")] = (typeof(NS_vc_long.V), typeof(long)),
-  [("validated-class", "long", "nested-two-levels")] = (typeof(N2_vc_long.Inner.V), typeof(long)),
-  [("record-struct", "string", "nested-in-class")] = (typeof(NC_rs_string.V), typeof(string)),
-  [("record-struct", "string", "nested-in-struct")] = (typeof(NS_rs_string.V), typeof(string)),
-  [("record-struct", "string", "nested-two-levels")] = (typeof(N2_rs_string.Inner.V), typeof(string)),
-  [("sealed-record-class", "string", "nested-in-class")] = (typeof(NC_rc_string.V), typeof(string)),
-  [("sealed-record-class", "string", "nested-in-struct")] = (typeof(NS_rc_string.V), typeof(string)),
-  [("sealed-record-class", "string", "nested-two-levels")] = (typeof(N2_rc_string.Inner.V), typeof(string)),
-  [("validated-struct", "string", "nested-in-class")] = (typeof(NC_vs_string.V), typeof(string)),
-  [("validated-struct", "string", "nested-in-struct")] = (typeof(NS_vs_string.V), typeof(string)),
-  [("validated-struct", "string", "nested-two-levels")] = (typeof(N2_vs_string.Inner.V), typeof(string)),
-  [("validated-class", "string", "nested-in-class")] = (typeof(NC_vc_string.V), typeof(string)),
-  [("validated-class", "string", "nested-in-struct")] = (typeof(NS_vc_string.V), typeof(string)),
-  [("validated-class", "string", "nested-two-levels")] = (typeof(N2_vc_string.Inner.V), typeof(string)),
-  [("record-struct", "ulong", "nested-in-class")] = (typeof(NC_rs_ulong.V), typeof(ulong)),
-  [("record-struct", "ulong", "nested-in-struct")] = (typeof(NS_rs_ulong.V), typeof(ulong)),
-  [("record-struct", "ulong", "nested-two-levels")] = (typeof(N2_rs_ulong.Inner.V), typeof(ulong)),
-  [("sealed-record-class", "ulong", "nested-in-class")] = (typeof(NC_rc_ulong.V), typeof(ulong)),
-  [("sealed-record-class", "ulong", "nested-in-struct")] = (typeof(NS_rc_ulong.V), typeof(ulong)),
-  [("sealed-record-class", "ulong", "nested-two-levels")] = (typeof(N2_rc_ulong.Inner.V), typeof(ulong)),
-  [("validated-struct", "ulong", "nested-in-class")] = (typeof(NC_vs_ulong.V), typeof(ulong)),
-  [("validated-struct", "ulong", "nested-in-struct")] = (typeof(NS_vs_ulong.V), typeof(ulong)),
-  [("validated-struct", "ulong", "nested-two-levels")] = (typeof(N2_vs_ulong.Inner.V), typeof(ulong)),
-  [("validated-class", "ulong", "nested-in-class")] = (typeof(NC_vc_ulong.V), typeof(ulong)),
-  [("validated-class", "ulong", "nested-in-struct")] = (typeof(NS_vc_ulong.V), typeof(ulong)),
-  [("validated-class", "ulong", "nested-two-levels")] = (typeof(N2_vc_ulong.Inner.V), typeof(ulong)),
- };
-}
diff --git a/tools/probe/corpus/harness/Equality.cs b/tools/probe/corpus/harness/Equality.cs
deleted file mode 100644
index 7cabd460..00000000
--- a/tools/probe/corpus/harness/Equality.cs
+++ /dev/null
@@ -1,211 +0,0 @@
-// Claim L05-equality (README.md#what-typekit-guarantees; Generators README "Equality", "Comparison"; oracle "Equality (metamorphic)" in
-// .claude/probe-axes.md): equal value objects have equal hash codes, CompareTo is zero exactly when Equals is true, and both agree with the
-// wrapped type's (ordinal for a string), through every base in the inheritance chain, and wherever the value object is held. A closed set's
-// members are singletons, so its equality is reference equality (docs/closed-sets.md).
-// Oracle: metamorphic. Two value objects over values the wrapped type calls equal in different forms (7.8m and 7.80m, 0.0 and -0.0, one
-// instant at two offsets, two string instances), and one over a value it calls unequal and orders after.
-using System.Collections;
-using System.Reflection;
-using Probes.Shapes;
-namespace Probes.Json;
-
-public sealed record L05Entry(string Kind, string Wrapped, string Inheritance, string Site, Type Type, Func<object> A1, Func<object> A2, Func<object> B);
-
-public abstract record L05PolyBase;
-public sealed record L05PolyDerived<T> : L05PolyBase { public T Value { get; set; } = default!; }
-
-public static partial class L05Registry
-{
-    static readonly List<L05Entry> All = [];
-    static L05Registry() => Fill();
-    static partial void Fill();
-    static void Add(string kind, string wrapped, string inheritance, string site, Type type, Func<object> a1, Func<object> a2, Func<object> b) =>
-        All.Add(new(kind, wrapped, inheritance, site, type, a1, a2, b));
-    public static L05Entry? Get(string kind, string wrapped, string inheritance, string site) =>
-        All.FirstOrDefault(x => x.Kind == kind && x.Wrapped == wrapped && x.Inheritance == inheritance && x.Site == site);
-}
-
-public static class Equality
-{
-    static IEqualityComparer Comparer(Type t) => (IEqualityComparer)typeof(EqualityComparer<>).MakeGenericType(t).GetProperty("Default")!.GetValue(null)!;
-    static int Sign(int x) => Math.Sign(x);
-
-    static object Make(Type v, Type w, object value)
-    {
-        var m = v.GetMethods(BindingFlags.Public | BindingFlags.Static)
-            .First(x => x.Name is "From" or "FromKnownGood" && x.GetParameters() is [var p, ..] && p.ParameterType == w);
-        var args = m.GetParameters().Select((p, i) => i == 0 ? value : Type.Missing).ToArray();
-        return m.Invoke(null, BindingFlags.OptionalParamBinding | BindingFlags.Default, null, args, null)!;
-    }
-
-    static object? Op(Type t, string name, object a, object b) =>
-        t.GetMethod(name, BindingFlags.Public | BindingFlags.Static, [t, t]) is { } m ? m.Invoke(null, [a, b]) : null;
-
-    public static string? Check(Row r)
-    {
-        var kind = r["shape.kind"]; var inh = r["shape.inheritance"]; var site = r["shape.site"];
-        var closed = kind == "closed-set";
-        // claims.json excludes the pairs no type can have; a row the covering array made with one anyway runs the nearest shape that exists
-        if (site == "in-generic-type") { r.Substituted("shape.site", "top-level", "CMTK1005/CMTK1018: nothing nests in a generic type"); site = "top-level"; }
-        if (kind is "record-struct" or "validated-struct" && inh.StartsWith("base-")) { r.Substituted("shape.inheritance", "none", "a struct has no base type"); inh = "none"; }
-        var wrapped = closed ? "-" : r["shape.wrapped"];
-        var en = L05Registry.Get(kind, wrapped, inh, site);
-        if (en is null) { r.Outcome("harness-error", $"no L05 shape for {kind}/{wrapped}/{inh}/{site}: run harness/gen_json_family.py"); return null; }
-        var v = en.Type;
-        object x1, x2, y; bool eq12;
-        Type? w = null; object? a1 = null, b = null;
-        if (closed)
-        {
-            x1 = en.A1(); x2 = en.A2(); y = en.B();
-            if (!ReferenceEquals(x1, x2)) return "closed set: the member found in All is not the member itself";
-            eq12 = true;
-        }
-        else
-        {
-            w = v.GetProperty("Value")!.PropertyType;
-            a1 = en.A1(); var a2 = en.A2(); b = en.B();
-            var cw = Comparer(w);
-            if (!cw.Equals(a1, a2) || cw.Equals(a1, b)) { r.Outcome("harness-error", $"samples of {wrapped}: {a1} and {a2} must be equal, {b} not"); return null; }
-            eq12 = true;
-            x1 = Make(v, w, a1); x2 = Make(v, w, a2); y = Make(v, w, b);
-            if (!cw.Equals(v.GetProperty("Value")!.GetValue(x1), a1)) return $"Value of {v.Name} is not the value it was made from";
-        }
-        // each failure goes to the obligation it breaks: the value object's own equality and wherever it is held, its ordering, its bases
-        List<string> eqF = [], ordF = [], baseF = [];
-        var fails = eqF;
-        void Expect(bool got, bool want, string what) { if (got != want) fails.Add($"{what}: {got}, expected {want}"); }
-
-        // the value object's own equality
-        Expect(x1.Equals(x2), eq12, "Equals(object) of equal values");
-        Expect(x1.Equals(y), false, "Equals(object) of unequal values");
-        Expect(x1.Equals(null), false, "Equals(null)");
-        Expect(Comparer(v).Equals(x1, x2), eq12, "EqualityComparer<V> of equal values");
-        Expect(Comparer(v).Equals(x1, y), false, "EqualityComparer<V> of unequal values");
-        if (x1!.GetHashCode() != x2!.GetHashCode()) fails.Add($"equal values hash apart: {x1.GetHashCode()} and {x2.GetHashCode()}");
-        if (Comparer(v).GetHashCode(x1) != Comparer(v).GetHashCode(x2)) fails.Add("EqualityComparer<V> hashes equal values apart");
-        if (Op(v, "op_Equality", x1, x2) is { } e12) Expect((bool)e12, eq12, "== of equal values"); else if (!closed) fails.Add("no operator ==");
-        if (Op(v, "op_Equality", x1, y) is { } e1b) Expect((bool)e1b, false, "== of unequal values");
-        if (Op(v, "op_Inequality", x1, x2) is { } n12) Expect((bool)n12, !eq12, "!= of equal values");
-
-        // ordering: generated where the wrapped type is comparable, ordinal for a string, zero exactly when equal
-        fails = ordF;
-        var icv = typeof(IComparable<>).MakeGenericType(v);
-        if (!closed)
-        {
-            var comparableW = typeof(IComparable<>).MakeGenericType(w!).IsAssignableFrom(w) || typeof(IComparable).IsAssignableFrom(w);   // an enum is IComparable only
-            if (icv.IsAssignableFrom(v) != comparableW) fails.Add($"IComparable<{v.Name}> is {(icv.IsAssignableFrom(v) ? "" : "not ")}implemented, the wrapped {w!.Name} is {(comparableW ? "" : "not ")}comparable");
-        }
-        if (icv.IsAssignableFrom(v))
-        {
-            var cmp = icv.GetMethod("CompareTo")!;
-            var c12 = (int)cmp.Invoke(x1, [x2])!; var c1b = (int)cmp.Invoke(x1, [y])!; var cb1 = (int)cmp.Invoke(y, [x1])!;
-            Expect(c12 == 0, eq12, "CompareTo of equal values is zero");
-            if (c1b == 0) fails.Add("CompareTo of unequal values is zero");
-            if (Sign(c1b) != -Sign(cb1)) fails.Add($"CompareTo is not antisymmetric: {c1b} and {cb1}");
-            if (!closed)
-            {
-                var want = w == typeof(string) ? string.CompareOrdinal((string)a1!, (string)b!) : ((IComparer)typeof(Comparer<>).MakeGenericType(w!).GetProperty("Default")!.GetValue(null)!).Compare(a1, b);
-                if (Sign(c1b) != Sign(want)) fails.Add($"CompareTo orders {c1b}, the wrapped type {want}");
-            }
-            if (x1 is IComparable nc) { if (Sign(nc.CompareTo(y)) != Sign(c1b) || nc.CompareTo(x2) != 0 == eq12) fails.Add("CompareTo(object) disagrees with CompareTo(TSelf)"); }
-            if (Op(v, "op_LessThan", x1, y) is { } lt) Expect((bool)lt, c1b < 0, "<");
-            if (Op(v, "op_GreaterThan", x1, y) is { } gt) Expect((bool)gt, c1b > 0, ">");
-            if (Op(v, "op_LessThanOrEqual", x1, x2) is { } le) Expect((bool)le, true, "<= of equal values");
-            if (Op(v, "op_GreaterThanOrEqual", x1, x2) is { } ge) Expect((bool)ge, true, ">= of equal values");
-            if (Op(v, "op_LessThan", x1, x2) is { } lt2) Expect((bool)lt2, false, "< of equal values");
-        }
-
-        // through every base, and every IEquatable<TBase> it implements
-        var bases = 0;
-        for (var t = v.BaseType; t is not null; t = t.BaseType)
-        {
-            // object and ValueType are every value object's, a base of none: held as one, it is its own equality
-            var own = t == typeof(object) || t == typeof(ValueType);
-            if (!own) bases++;
-            fails = own ? eqF : baseF;
-            var c = Comparer(t);
-            Expect(c.Equals(x1, x2), eq12, $"EqualityComparer<{t.Name}> of equal values");
-            Expect(c.Equals(x1, y), false, $"EqualityComparer<{t.Name}> of unequal values");
-            if (c.GetHashCode(x1) != c.GetHashCode(x2)) fails.Add($"EqualityComparer<{t.Name}> hashes equal values apart");
-            if (Op(t, "op_Equality", x1, x2) is { } be) Expect((bool)be, eq12, $"{t.Name}'s == of equal values");
-            var set = (IEnumerable)Activator.CreateInstance(typeof(HashSet<>).MakeGenericType(t))!;
-            var add = set.GetType().GetMethod("Add")!; add.Invoke(set, [x1]); add.Invoke(set, [x2]); add.Invoke(set, [y]);
-            var count = set.Cast<object>().Count();
-            if (count != 2) fails.Add($"HashSet<{t.Name}> of two equal values and one other holds {count}");
-        }
-        foreach (var i in v.GetInterfaces().Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEquatable<>)))
-        {
-            fails = i.GetGenericArguments()[0] == v ? eqF : baseF;   // IEquatable<TSelf> is its own equality, IEquatable<TBase> a base's
-            var m = i.GetMethod("Equals")!;
-            Expect((bool)m.Invoke(x1, [x2])!, eq12, $"{Jx.Name(i)}.Equals of equal values");
-            Expect((bool)m.Invoke(x1, [y])!, false, $"{Jx.Name(i)}.Equals of unequal values");
-        }
-
-        // wherever it is held
-        fails = eqF;
-        var position = r["shape.position"];
-        var containing = position == "root" ? "class" : r["shape.containing"];
-        var e = new Entry(kind, wrapped, v, v, () => x1, () => null, typeof(L05PolyBase), typeof(L05PolyDerived<>).MakeGenericType(v), typeof(L05PolyBase), typeof(L05PolyDerived<>).MakeGenericType(v));
-        var h1 = Pos.Build(position, containing, e, true, x1); var h2 = Pos.Build(position, containing, e, true, x2); var h3 = Pos.Build(position, containing, e, true, y);
-        object? Member(Held h) => position == "root" ? h.Value : h.Declared.GetProperty("P") is { } p ? p.GetValue(h.Value) : h.Declared.GetField("F")!.GetValue(h.Value);
-        switch (position)
-        {
-            case "root": break;
-            case "list-element" or "array-element" or "immutable-array-element" or "read-only-list-element":
-            {
-                var l = (IList)Member(h1)!;
-                Expect(l.Contains(x2), eq12, $"{Jx.Name(l.GetType())}.Contains of an equal value");
-                Expect(l.Contains(y), false, $"{Jx.Name(l.GetType())}.Contains of an unequal value");
-                if (l.IndexOf(x2) != 0) fails.Add("IndexOf of an equal value is " + l.IndexOf(x2));
-                break;
-            }
-            case "dictionary-key":
-            {
-                var d = (IDictionary)Member(h1)!;
-                Expect(d.Contains(x2), eq12, "dictionary lookup by an equal key");
-                Expect(d.Contains(y), false, "dictionary lookup by an unequal key");
-                break;
-            }
-            case "dictionary-value":
-            {
-                var d = Member(h1)!; var cv = d.GetType().GetMethod("ContainsValue")!;
-                Expect((bool)cv.Invoke(d, [x2])!, eq12, "ContainsValue of an equal value");
-                Expect((bool)cv.Invoke(d, [y])!, false, "ContainsValue of an unequal value");
-                break;
-            }
-            default:
-            {
-                // a container with value equality compares through the member; one with reference equality is compared by its member
-                var byValue = containing is "record-class" or "record-struct" or "struct";
-                var (p1, p2, p3) = byValue ? (h1.Value, h2.Value, h3.Value) : (Member(h1), Member(h2), Member(h3));
-                var what = byValue ? Jx.Name(h1.Declared) : $"the {position} of {Jx.Name(h1.Declared)}";
-                Expect(Equals(p1, p2), eq12, what + " holding equal values");
-                Expect(Equals(p1, p3), false, what + " holding unequal values");
-                if (p1 is not null && p2 is not null && p1.GetHashCode() != p2.GetHashCode()) fails.Add(what + " holding equal values hashes them apart");
-                break;
-            }
-        }
-        string What(List<string> f) => $"{Jx.Name(v)} ({kind}, {wrapped}, {inh}, {site}, {position} in {containing}): " + string.Join("; ", f);
-        var f1 = r.Check("equality-is-the-underlying-values", Baseline.Twin, c =>
-        {
-            if (eqF.Count > 0) return What(eqF);
-            c.Note(NoteKeys.Compared, $"{v.Name} {position}: equality, against EqualityComparer<{(w is null ? v.Name : w.Name)}>");
-            return null;
-        });
-        var f2 = r.Check("ordering-follows-the-underlying-type", Baseline.Twin, c =>
-        {
-            if (ordF.Count > 0) return What(ordF);
-            c.Note(NoteKeys.Compared, $"{v.Name}: ordering{(icv.IsAssignableFrom(v) ? "" : ", none generated where the wrapped type has none")}");
-            return null;
-        });
-        // a value object with a base record: each base compares it as it does (the chain is shape.inheritance's)
-        var f3 = bases == 0 ? null : r.Check("through-every-base", Baseline.Twin, c =>
-        {
-            _ = c["shape.inheritance"];
-            if (baseF.Count > 0) return What(baseF);
-            c.Note(NoteKeys.Compared, $"{v.Name}: {bases} base type(s)");
-            return null;
-        });
-        return f1 ?? f2 ?? f3;
-    }
-}
diff --git a/tools/probe/corpus/harness/FaultClaim.cs b/tools/probe/corpus/harness/FaultClaim.cs
deleted file mode 100644
index 03018dd1..00000000
--- a/tools/probe/corpus/harness/FaultClaim.cs
+++ /dev/null
@@ -1,412 +0,0 @@
-// The shared runner of the fault claims C04-without-faults, C06-fault-kinds, C14-declared-problem and C15-mvc-fault-status-doc
-// (AspNetCore README "A closed set as the fault type", "A status per endpoint", "Leaving out what a route cannot answer"; CHANGELOG 2.1.0 Fixed).
-// A claim is a Spec: its minimal endpoints as a tree of groups, the MVC controllers of FxCtl (FaultClaimControllers.g.cs), what
-// MapControllers()'s builder adds, and the errors each endpoint reports. Each declaration is listed where it is made, so an endpoint's
-// declarations come in ASP.NET's metadata order: outer group, inner group, endpoint; or controller, action, then MapControllers()'s builder.
-// The oracle is the README's rules applied to those declarations, never the product's own reading of them:
-//  - a member is answered with the last status its endpoint's metadata sets for it, else the mapped one ("When several statuses name one
-//    member, the last in ASP.NET's metadata order wins"); the mapping is by kind (README table), or its own with a problem type per kind;
-//  - a member left out anywhere in that metadata is listed nowhere in the operation, and reporting it throws an InvalidOperationException
-//    naming the endpoint and the member ("Leave out only what the route can't report");
-//  - the operation lists every status of every remaining member of every answered type, the endpoint's own declared ones among them, all its
-//    responses ascending; each fault status's problem schema describes fault and rule, and its description names exactly the problem types
-//    of the members answered with it ("names its problem types", CHANGELOG 2.1.0);
-//  - a status that every endpoint of its scope leaves out stops the host, naming the member and the status.
-// Each comparison is about one Aspect, and a claim's Spec.Of names the obligations it is checked for: the row runs one check (Row.Check) per
-// obligation it reaches, against the README's rules (Spec.Against) or, for a refusal, the documented one (Spec.Refusals), every check on the
-// one host and the answers fetched once.
-// http.response picks what every endpoint of the row answers (one fault type, a composed fault, two types writing one name) and what the
-// outermost scope adds (a status for another member, a member left out, a problem the endpoint declares itself).
-using System.Text.Json.Nodes;
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.AspNetCore;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.AspNetCore.Routing;
-using Microsoft.Extensions.DependencyInjection;
-using Probes.Shapes;
-namespace Probes.Faults;
-
-/// <summary>One declaration about one member: a status (WithFaultStatus, [FaultStatus]) or, with status 0, the member left out.</summary>
-public sealed record Decl(string Type, string Member, int Status)
-{
-    public bool Out => Status == 0;
-    public bool Names(Mem m) => Type == m.Type && Member == m.Name;
-    public override string ToString() => Out ? $"WithoutFaults({Type}.{Member})" : $"WithFaultStatus({Type}.{Member}, {Status})";
-}
-/// <summary>An MVC action of FxCtl: its route (before the result-type segment), what it declares, the problem statuses it declares itself.</summary>
-public sealed record Act(string Route, Decl[] Decls, int[] Declared);
-/// <summary>An MVC controller of FxCtl: the [ApiController] and the plain copy, what the class declares, its actions.</summary>
-public sealed record Ctl(Type Api, Type Plain, Decl[] Decls, Act[] Actions);
-public static partial class FxCtl
-{
-    public static readonly Dictionary<string, Ctl> All = Build();
-    static Dictionary<string, Ctl> Build() { var d = new Dictionary<string, Ctl>(StringComparer.Ordinal); Fill(d); return d; }
-    static partial void Fill(Dictionary<string, Ctl> d);
-}
-
-/// <summary>A minimal endpoint, relative to its group; How: "pp" = ProducesProblem(each Declared), "prt" = [ProducesResponseType&lt;ProblemDetails&gt;(404)].</summary>
-public sealed record MEp(string Route, Decl[] Decls, int[]? Declared = null, string? How = null);
-/// <summary>A route group: its prefix (never empty), what it declares, its inner groups and endpoints.</summary>
-public sealed record MGrp(string Prefix, Decl[] Decls, MGrp[] Groups, MEp[] Eps);
-
-/// <summary>A member of a fault type the endpoints answer with, its kind and the status its kind maps to (README table).</summary>
-public sealed record Mem(string Type, string Name, string Kind, int Status) { public string Q => Type + "." + Name; }
-
-public static class FxErr
-{
-    public static readonly Mem[] H =
-    [
-        new("HFault", "Missing", "NotFound", 404), new("HFault", "Clash", "Conflict", 409), new("HFault", "Bad", "Invalid", 422),
-        new("HFault", "Denied", "Forbidden", 403), new("HFault", "Down", "Unavailable", 503), new("HFault", "Stale", "PreconditionFailed", 412),
-        new("HFault", "Garbled", "Malformed", 400),
-    ];
-    static readonly Mem[] G = [new("GFault", "Gone", "NotFound", 404), new("GFault", "Raced", "Conflict", 409), new("GFault", "Old", "PreconditionFailed", 412)];
-    static readonly Mem[] K = [new("KFault", "Clash", "Conflict", 409), new("KFault", "Lost", "NotFound", 404)];
-    /// <summary>Every member of every type an endpoint answering <paramref name="t"/> answers with.</summary>
-    public static Mem[] Answered(string t) => t == "two" ? [.. H, .. G] : t == "dup" ? [.. H, .. K] : H;
-    /// <summary>e: 1-based index into H; 0 is a success.</summary>
-    static HFault Of(int e) => (HFault)typeof(HFault).GetField(H[e - 1].Name)!.GetValue(null)!;
-    public static Result<Fault<HFault>> One(int e) { if (e == 0) return Result<Fault<HFault>>.Success(); return Fault.Of(Of(e)); }
-    public static Result<Fault<HFault, GFault>> Two(int e) => e == 0 ? Result<Fault<HFault, GFault>>.Success() : Fault<HFault, GFault>.Of(Of(e));
-    public static Result<Fault<HFault, KFault>> Dup(int e) => e == 0 ? Result<Fault<HFault, KFault>>.Success() : Fault<HFault, KFault>.Of(Of(e));
-    public static int E(string member) => Array.FindIndex(H, m => m.Name == member) + 1;
-}
-
-/// <summary>One endpoint as the oracle sees it: its URL in this host, the result it answers, its declarations in metadata order.</summary>
-public sealed record Ep(bool Mvc, string Url, string T, Decl[] Decls, int[] Declared, Func<Mem, (int Status, string? Type)> Map)
-{
-    public bool LeftOut(Mem m) => Decls.Any(d => d.Out && d.Names(m));
-    public int StatusOf(Mem m) => Decls.LastOrDefault(d => !d.Out && d.Names(m))?.Status ?? Map(m).Status;
-    public SortedSet<int> FaultStatuses() => new(FxErr.Answered(T).Where(m => !LeftOut(m)).Select(StatusOf));
-    public SortedSet<int> DocStatuses() { var s = FaultStatuses(); foreach (var d in Declared) s.Add(d); return s; }
-    public HashSet<string> TypesAt(int status) =>
-        [.. FxErr.Answered(T).Where(m => !LeftOut(m) && StatusOf(m) == status).Select(m => Map(m).Type).OfType<string>()];
-}
-
-/// <summary>What one comparison of <see cref="FaultClaim.Run"/> is about; a claim's <see cref="Spec.Of"/> names the obligations each is checked for.</summary>
-public static class Aspect
-{
-    /// <summary>The host starts, or refuses to as the README says.</summary>
-    public const string Start = "start";
-    /// <summary>Reporting a member left out throws, naming the endpoint and the member.</summary>
-    public const string LeftOut = "left-out";
-    /// <summary>A member's status, on the wire and in the problem's status field.</summary>
-    public const string Status = "status";
-    /// <summary>The problem's fault, its type and its detail.</summary>
-    public const string Fault = "fault", Type = "type", Detail = "detail";
-    /// <summary>The operation's statuses (which), their order, the problem schema's fault and rule, and the problem types its description names.</summary>
-    public const string DocListed = "doc-listed", DocOrder = "doc-order", DocDescribes = "doc-describes", DocTypes = "doc-types";
-    public static readonly string[] Answer = [Status, Fault, Type, Detail];
-    public static readonly string[] Doc = [DocListed, DocOrder, DocDescribes, DocTypes];
-}
-
-/// <summary>What one claim's row asks: see the header.</summary>
-public sealed class Spec
-{
-    /// <summary>The obligations a comparison of an aspect is checked for, given the member it is about (none for the start and the document).</summary>
-    public Func<string, Mem?, string[]> Of = (_, _) => ["claim"];
-    /// <summary>What the README's rules are compared as: the sentence of the claim's source.</summary>
-    public Baseline Against = Baseline.Model;
-    /// <summary>The obligations whose check holds a refusal by its type and what it names.</summary>
-    public string[] Refusals = [];
-    public MGrp? Minimal;                  // under the outer group /m, where the host has minimal APIs
-    public string[] Controllers = [];      // FxCtl keys, where it has MVC
-    public Decl[] Builder = [];            // added to MapControllers()'s builder, after the response's own
-    public int[] Errors = [];              // the HFault members each endpoint reports (FxErr.E)
-    public bool Typed = true;              // the host's mapping gives a problem type per kind; else AddFaultResponses<TSet>() by kind
-    public string[]? Refused;              // the host must not start, with an InvalidOperationException naming each of these
-    public Func<Exception, string?>? RefusedAs;   // or: the host must not start, and this judges the exception (null: as expected)
-    public Func<Mem, (int Status, string? Type)>? Map;   // how the host maps each member; default by kind, with a type per kind where Typed
-    public string? Mapping;                // HostCfg.Mapping in place of Typed's
-    public Action<IServiceCollection>? Services;
-    public Action<IEndpointRouteBuilder>? Extra;   // more minimal endpoints, at the root
-    public Type[] ExtraControllers = [];
-}
-
-/// <summary>What http.response makes every endpoint of the row answer, and what the outermost scope adds.</summary>
-public sealed record Resp(string T, Decl[] Outer, int[] Declared)
-{
-    public static Resp Of(Row r) => r["http.response"] switch
-    {
-        "composed-fault" => new("two", [], []),
-        "two-faults-same-name" => new("dup", [], []),
-        "group-with-fault-status" => new("one", [new("HFault", "Clash", 422)], []),
-        "endpoint-without-faults" => new("one", [new("HFault", "Missing", 0)], []),
-        "declared-produces-problem" => new("decl", [], [429]),
-        _ => new("one", [], []),
-    };
-}
-
-/// <summary>The baseline's problem response in MVC (see FaultClaim.DocRefusedByAspNetAlone).</summary>
-[ApiController]
-internal sealed class FxProblemBaseline : ControllerBase
-{
-    [HttpGet("baseline-problem/c"), ProducesResponseType<ProblemDetails>(404, "application/problem+json")] public IActionResult Get() => NoContent();
-}
-
-public static class FaultClaim
-{
-    public static string TypeOf(string kind) => "https://p.example/" + kind;
-    static string? Un(Row r, string? s) => r.Is("json.Converters", "own-for-wrapped") && s is not null && s.StartsWith("own:") ? s[4..].Trim('"') : s;
-    static string Cut(string? s) => s is null ? "(null)" : s.Length > 300 ? s[..300] + "..." : s;
-    static void Process(Row r, Entry en) { if (r.Is("process.converter-lookup", "wrapped-type-converter-looked-up-first")) _ = System.ComponentModel.TypeDescriptor.GetConverter(Make.Held(en.Plain)); }
-
-    static T Member<T>(string name) => (T)typeof(T).GetField(name)!.GetValue(null)!;
-    static TB Apply<TB>(TB b, Decl d) where TB : IEndpointConventionBuilder => (d.Type, d.Out) switch
-    {
-        ("HFault", true) => b.WithoutFaults(Member<HFault>(d.Member)),
-        ("HFault", false) => b.WithFaultStatus(Member<HFault>(d.Member), d.Status),
-        ("GFault", true) => b.WithoutFaults(Member<GFault>(d.Member)),
-        ("GFault", false) => b.WithFaultStatus(Member<GFault>(d.Member), d.Status),
-        ("KFault", true) => b.WithoutFaults(Member<KFault>(d.Member)),
-        _ => b.WithFaultStatus(Member<KFault>(d.Member), d.Status),
-    };
-
-    static RouteHandlerBuilder MapT(IEndpointRouteBuilder g, string path, string t, string? how) => (t, how) switch
-    {
-        ("two", "prt") => g.MapGet(path, [ProducesResponseType<ProblemDetails>(404)] (int e) => FxErr.Two(e).ToHttpResult()),
-        ("dup", "prt") => g.MapGet(path, [ProducesResponseType<ProblemDetails>(404)] (int e) => FxErr.Dup(e).ToHttpResult()),
-        (_, "prt") => g.MapGet(path, [ProducesResponseType<ProblemDetails>(404)] (int e) => FxErr.One(e).ToHttpResult()),
-        ("two", _) => g.MapGet(path, (int e) => FxErr.Two(e).ToHttpResult()),
-        ("dup", _) => g.MapGet(path, (int e) => FxErr.Dup(e).ToHttpResult()),
-        _ => g.MapGet(path, (int e) => FxErr.One(e).ToHttpResult()),
-    };
-
-    /// <summary>Walks a minimal tree: maps it where <paramref name="b"/> is given, and lists its endpoints with their declarations in metadata order.</summary>
-    static void Walk(IEndpointRouteBuilder? b, MGrp g, Decl[] above, string prefix, Resp resp, List<(string Path, Decl[] Decls, int[] Declared)> eps)
-    {
-        RouteGroupBuilder? grp = null;
-        if (b is not null) { grp = b.MapGroup(g.Prefix); foreach (var d in g.Decls) Apply(grp, d); }
-        Decl[] decls = [.. above, .. g.Decls];
-        var pre = prefix + g.Prefix;
-        foreach (var sub in g.Groups) Walk(grp, sub, decls, pre, resp, eps);
-        foreach (var ep in g.Eps)
-        {
-            var path = "/" + ep.Route + "/" + resp.T;
-            if (grp is not null)
-            {
-                var rb = MapT(grp, path, resp.T, ep.How);
-                foreach (var d in ep.Decls) Apply(rb, d);
-                if (ep.How == "pp") foreach (var s in ep.Declared ?? []) rb.ProducesProblem(s);
-                if (resp.T == "decl") rb.ProducesProblem(429);
-            }
-            eps.Add((pre + path, [.. decls, .. ep.Decls], [.. ep.Declared ?? [], .. resp.Declared]));
-        }
-    }
-
-    static (List<Ep> Eps, HostCfg Cfg) Plan(Row r, Spec s, Resp resp)
-    {
-        var eps = new List<Ep>();
-        var map = s.Map ?? (m => (m.Status, s.Typed ? TypeOf(m.Kind) : (string?)null));
-        MGrp? root = s.Minimal is null ? null : new MGrp("/m", resp.Outer, [s.Minimal], []);
-        if (root is not null && Hx.HasMinimal(r))
-        {
-            var found = new List<(string Path, Decl[] Decls, int[] Declared)>();
-            Walk(null, root, [], "", resp, found);
-            eps.AddRange(found.Select(x => new Ep(false, Hx.M(r, x.Path), resp.T, x.Decls, x.Declared, map)));
-        }
-        var controllers = new List<Type>();
-        Decl[] builder = [.. resp.Outer, .. s.Builder];
-        if (Hx.HasMvc(r))
-            foreach (var key in s.Controllers)
-            {
-                var c = FxCtl.All[key];
-                controllers.Add(Hx.Plain(r) ? c.Plain : c.Api);
-                foreach (var a in c.Actions)
-                    eps.Add(new Ep(true, Hx.C(r, "/c/" + a.Route + "/" + resp.T), resp.T, [.. c.Decls, .. a.Decls, .. builder], [.. a.Declared, .. resp.Declared], map));
-            }
-        if (Hx.HasMvc(r)) controllers.AddRange(s.ExtraControllers);
-        var cfg = new HostCfg
-        {
-            FaultControllers = true, Controllers = [.. controllers],
-            Mapping = s.Mapping ?? (s.Typed ? "own-IFault-mapping" : "per-set"),
-            Services = sv => { if (s.Mapping is null && !s.Typed) sv.AddFaultResponses<KFault>(); s.Services?.Invoke(sv); },
-            Minimal = b => { if (root is not null) Walk(b, root, [], "", resp, []); s.Extra?.Invoke(b); },
-            ControllerBuilder = cb => { foreach (var d in builder) Apply(cb, d); return cb; },
-        };
-        return (eps, cfg);
-    }
-
-    public static async Task<string?> Run(Row r, Spec s)
-    {
-        var en = Registry.Of(r); Process(r, en);
-        var resp = Resp.Of(r);
-        var (eps, cfg) = Plan(r, s, resp);
-        if (eps.Count == 0) return "harness: the row maps no endpoint of the claim (an excluded pair?)";
-        WebApplication? app = null; Exception? down = null;
-        try { app = await Hx.Start(r, en, cfg); }
-        catch (Exception ex) when (ex is not Sides.InputsNotEquivalent) { down = ex; }
-        await using var _ = app;
-        Baseline Against(string o) => s.Refusals.Contains(o) ? Baseline.Refusal : s.Against;
-        string? failed = null;
-
-        // A host the README says must not start: that is the row's one comparison.
-        if (s.Refused is not null || s.RefusedAs is not null)
-        {
-            foreach (var o in s.Of(Aspect.Start, null))
-            {
-                var f = r.Check(o, Against(o), _ => down is null
-                    ? (s.RefusedAs is not null ? "host started, though the README says this set stops the start"
-                                              : $"host started, though a status every endpoint of its scope leaves out must stop it ({string.Join(", ", s.Refused!)})")
-                    : StartRefused(s, down));
-                failed ??= f;
-            }
-            return failed;
-        }
-
-        var members = s.Errors.Select(e => FxErr.H[e - 1]).ToList();
-        var obligations = Aspect.Answer.Append(Aspect.LeftOut).SelectMany(a => members.SelectMany(m => s.Of(a, m)))
-            .Concat(Aspect.Doc.SelectMany(a => s.Of(a, null))).Distinct().ToList();
-        if (down is not null)
-        {
-            foreach (var o in obligations) { var f = r.Check(o, Against(o), _ => "host did not start: " + down.GetType().Name + ": " + Cut(down.Message)); failed ??= f; }
-            return failed;
-        }
-
-        var display = app!.Services.GetRequiredService<EndpointDataSource>().Endpoints.OfType<RouteEndpoint>()
-            .GroupBy(e => "/" + (e.RoutePattern.RawText ?? "").TrimStart('/'), StringComparer.OrdinalIgnoreCase)
-            .ToDictionary(g => g.Key, g => g.First().DisplayName ?? "", StringComparer.OrdinalIgnoreCase);
-        JsonNode? doc = null; Exception? docFailed = null;
-        try { doc = await Hx.Doc(app); }
-        catch (Exception ex) { docFailed = ex; }
-        var wires = new Dictionary<(string Url, int E), Hx.Wire>();
-        foreach (var ep in eps)
-            foreach (var e in s.Errors)
-                wires[(ep.Url, e)] = await Hx.Get(app, $"{ep.Url}?e={e}");
-
-        foreach (var o in obligations)
-        {
-            var f = await r.Check(o, Against(o), async c =>
-            {
-                var wire = false;   // whether the check compared an answer on the wire before the document
-                bool want(string aspect, Mem? m)
-                {
-                    var wanted = s.Of(aspect, m).Contains(o);
-                    if (wanted && !Aspect.Doc.Contains(aspect)) wire = true;
-                    return wanted;
-                }
-                foreach (var ep in eps)
-                    foreach (var e in s.Errors)
-                        if (Wire(r, ep, FxErr.H[e - 1], wires[(ep.Url, e)], display, want) is { } fail) return fail;
-                if (!Aspect.Doc.Any(a => want(a, null))) return null;
-                // A document ASP.NET alone refuses too has nothing to check (noted there); any other failure is returned.
-                if (docFailed is not null) return await DocRefusedByAspNetAlone(c, r, en, cfg, docFailed, wire);
-                foreach (var ep in eps)
-                    if (DocOf(r, doc!, ep, want) is { } fail) return fail;
-                return null;
-            });
-            failed ??= f;
-        }
-        return failed;
-    }
-
-    /// <summary>The host refused to start: as the README says, with an InvalidOperationException naming each of <see cref="Spec.Refused"/>, or as <see cref="Spec.RefusedAs"/> judges.</summary>
-    static string? StartRefused(Spec s, Exception ex)
-    {
-        if (s.RefusedAs is { } judge) return judge(ex);
-        var names = s.Refused!;
-        var ioe = ex as InvalidOperationException ?? ex.InnerException as InvalidOperationException;
-        if (ioe is null) return $"host refused to start, but with {ex.GetType().Name}, not InvalidOperationException: {Cut(ex.Message)}";
-        foreach (var name in names)
-            if (!ioe.Message.Contains(name, StringComparison.Ordinal)) return $"host refused to start, but not naming {name}: {Cut(ioe.Message)}";
-        return null;
-    }
-
-    /// <summary>
-    /// Hx.DocRefusedByAspNetAlone, with a baseline that has a problem response: the same host without AddTypeKit(), plus one endpoint (and one
-    /// action, where the host has MVC) declaring ProducesProblem(404). AddTypeKit() adds its problem responses "as ProducesProblem would"
-    /// (README "A Result as a response"), so ASP.NET alone writing a document of the same host without any problem response says nothing about
-    /// them: under json.MaxDepth=3 System.Text.Json refuses the problem schema of ASP.NET's own ProducesProblem too (decision 99).
-    /// </summary>
-    static async Task<string?> DocRefusedByAspNetAlone(Check c, Row r, Entry en, HostCfg cfg, Exception withTypeKit, bool comparedBefore)
-    {
-        static string Say(Exception x) => x.GetType().Name + ": " + Cut(x.Message);
-        var alone = cfg.Copy(); alone.TypeKitOpenApi = false;
-        alone.Controllers = [.. cfg.Controllers ?? [], typeof(FxProblemBaseline)];
-        alone.Minimal = b => { cfg.Minimal?.Invoke(b); b.MapGet("/baseline-problem", () => Results.NoContent()).ProducesProblem(404); };
-        try
-        {
-            await using var app = await Hx.Start(r, en, alone);
-            await Hx.Doc(app);
-        }
-        // the same refusal by type and stage, never by its words (Hx.DocAlike)
-        catch (Exception ex) when (Hx.DocAlike(ex, withTypeKit))
-        {
-            Hx.DocRefused(r, ex, comparedBefore);
-            return null;
-        }
-        catch (Exception ex) when (r.Is("json.MaxDepth", "3") && Depth(ex) && Depth(withTypeKit))
-        {
-            // Both refuse the problem schema under MaxDepth=3, by System.Text.Json's own depth checks, but on different paths (TypeKit's
-            // transformer through the schema exporter, ProducesProblem through the document writer): a refusal of STJ's own, nothing to check
-            // (decision 99: under MaxDepth=3 System.Text.Json refuses the OpenAPI document of a problem response for plain ASP.NET too).
-            return c.Refused(Cite.Record("0099"), $"{Say(withTypeKit)} / {Say(ex)}");
-        }
-        catch (Exception ex) { return $"document: AddTypeKit() fails ({Say(withTypeKit)}), ASP.NET alone with a ProducesProblem fails otherwise ({Say(ex)})"; }
-        return $"document: AddTypeKit() fails ({Say(withTypeKit)}), ASP.NET alone with a ProducesProblem writes it";
-    }
-
-    static bool Depth(Exception x) => x is InvalidOperationException or System.Text.Json.JsonException;
-
-    /// <summary>One endpoint's answer <paramref name="w"/> to reporting <paramref name="m"/>, judged on the aspects <paramref name="want"/> names.</summary>
-    static string? Wire(Row r, Ep ep, Mem m, Hx.Wire w, Dictionary<string, string> display, Func<string, Mem?, bool> want)
-    {
-        var at = $"{ep.Url} reporting {m.Q}";
-        if (ep.LeftOut(m))
-        {
-            if (!want(Aspect.LeftOut, m)) return null;
-            if (w.Thrown is null) return $"{at}: left out of its document, but answered {(int)w.Status}: {Cut(w.Body)}";
-            if (!w.Thrown.StartsWith(nameof(InvalidOperationException) + ":", StringComparison.Ordinal)) return $"{at}: left out, threw {Cut(w.Thrown)}, expected an InvalidOperationException";
-            if (!display.TryGetValue(ep.Url, out var name) || name.Length == 0) return $"harness: no endpoint named at {ep.Url}";
-            if (!w.Thrown.Contains(name, StringComparison.Ordinal) || !w.Thrown.Contains(m.Q, StringComparison.Ordinal))
-                return $"{at}: the refusal does not name the endpoint ({name}) and the member ({m.Q}): {Cut(w.Thrown)}";
-            return null;
-        }
-        if (!Aspect.Answer.Any(a => want(a, m))) return null;
-        if (w.Thrown is not null) return $"{at}: request threw {Cut(w.Thrown)}";
-        var status = ep.StatusOf(m);
-        if (want(Aspect.Status, m) && (int)w.Status != status) return $"{at}: status {(int)w.Status}, expected {status}: {Cut(w.Body)}";
-        JsonNode? body; try { body = JsonNode.Parse(w.Body); } catch { return $"{at}: body is not JSON: {Cut(w.Body)}"; }
-        var fault = Un(r, body?["fault"]?.GetValue<string>());
-        if (want(Aspect.Fault, m) && fault != m.Name) return $"{at}: fault {fault ?? "(none)"}, expected {m.Name}";
-        if (want(Aspect.Status, m) && int.Parse(body?["status"]?.ToString() is { } st ? Un(r, st)!.Trim('"') : "0") != status) return $"{at}: problem status field {body?["status"]}, expected {status}";
-        if (want(Aspect.Type, m) && ep.Map(m).Type is { } type && Un(r, body?["type"]?.GetValue<string>()) != type) return $"{at}: type {body?["type"]}, expected {type}";
-        var detail = Un(r, body?["detail"]?.GetValue<string>());
-        var wantDetail = m.Q == "HFault.Missing" ? "Missing." : null;
-        if (want(Aspect.Detail, m) && detail != wantDetail) return $"{at}: detail {detail ?? "(none)"}, expected {wantDetail ?? "none (the member has no description)"}";
-        return null;
-    }
-
-    /// <summary>One endpoint's operation in the document, judged on the aspects <paramref name="want"/> names.</summary>
-    static string? DocOf(Row r, JsonNode doc, Ep ep, Func<string, Mem?, bool> want)
-    {
-        var op = doc["paths"]?[ep.Url]?["get"];
-        if (op is null && ep.Mvc && !Hx.InDocument(r)) { r.Note(NoteKeys.DocControllerNotInApiExplorer); return null; }
-        if (op is null) return $"document has no GET {ep.Url}";
-        var responses = op["responses"]?.AsObject();
-        if (responses is null) return $"{ep.Url}: operation has no responses";
-        var nums = responses.Select(kv => kv.Key).Where(k => int.TryParse(k, out _)).Select(int.Parse).ToList();
-        if (want(Aspect.DocOrder, null) && !nums.SequenceEqual(nums.Order())) return $"{ep.Url}: responses {string.Join(",", responses.Select(kv => kv.Key))} are not in ascending order";
-        var got = nums.Where(n => n >= 400).ToList();
-        var listed = ep.DocStatuses();
-        // which statuses are listed, as a set: their order is DocOrder's, above
-        if (want(Aspect.DocListed, null) && !got.Order().SequenceEqual(listed)) return $"{ep.Url}: document lists {string.Join(",", got)}, expected {string.Join(",", listed)} ({string.Join(" ", ep.Decls)})";
-        foreach (var status in ep.FaultStatuses())
-        {
-            var resp = responses[status.ToString()];
-            var txt = Hx.Deep(doc, resp)?.ToJsonString() ?? "";
-            if (want(Aspect.DocDescribes, null) && !txt.Contains("\"fault\"")) return $"{ep.Url} {status}: response schema does not describe fault: {Cut(txt)}";
-            if (want(Aspect.DocDescribes, null) && !txt.Contains("\"rule\"")) return $"{ep.Url} {status}: response schema does not describe rule: {Cut(txt)}";
-            var desc = resp?["description"]?.GetValue<string>() ?? "";
-            const string Lead = "Problem types: ";
-            var i = desc.IndexOf(Lead, StringComparison.Ordinal);
-            var types = i < 0 ? [] : desc[(i + Lead.Length)..].Split(", ").ToHashSet();
-            var wantTypes = ep.TypesAt(status);
-            if (want(Aspect.DocTypes, null) && !types.SetEquals(wantTypes))
-                return $"{ep.Url} {status}: description \"{desc}\" names problem types {{{string.Join(", ", types)}}}, expected {{{string.Join(", ", wantTypes)}}}";
-        }
-        return null;
-    }
-}
diff --git a/tools/probe/corpus/harness/FaultClaimControllers.g.cs b/tools/probe/corpus/harness/FaultClaimControllers.g.cs
deleted file mode 100644
index afec71e4..00000000
--- a/tools/probe/corpus/harness/FaultClaimControllers.g.cs
+++ /dev/null
@@ -1,206 +0,0 @@
-// Generated by tools/probe/generators/faults.cs (the fault claims' MVC controllers, C04 C06 C14 C15): do not edit by hand.
-// Every action answers FxErr's errors; its route ends in the result type it answers (one, two, dup) or decl (one, with a
-// [ProducesResponseType<ProblemDetails>(429)] of its own). The table FxCtl.All restates what each class and action declares,
-// in ASP.NET's metadata order (controller, then action), as the input FaultClaim computes the expected response and document from.
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.AspNetCore;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Http.HttpResults;
-using Microsoft.AspNetCore.Mvc;
-namespace Probes.Faults;
-
-internal abstract class FxC04EpBase : ControllerBase
-{
-    [HttpGet("c/fx/ep/wo/one"), WithoutFaults<HFault>("Down")] public Results<NoContent, FaultProblem<HFault>> FxEpWoOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/fx/ep/wo/two"), WithoutFaults<HFault>("Down")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> FxEpWoTwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/fx/ep/wo/dup"), WithoutFaults<HFault>("Down")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> FxEpWoDup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/fx/ep/wo/decl"), WithoutFaults<HFault>("Down"), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> FxEpWoDecl(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/fx/ep/keep/one")] public Results<NoContent, FaultProblem<HFault>> FxEpKeepOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/fx/ep/keep/two")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> FxEpKeepTwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/fx/ep/keep/dup")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> FxEpKeepDup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/fx/ep/keep/decl"), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> FxEpKeepDecl(int e) => FxErr.One(e).ToHttpResult();
-}
-[ApiController] internal sealed class FxC04EpApi : FxC04EpBase { }
-internal sealed class FxC04EpPlain : FxC04EpBase { }
-[ApiController, FaultStatus<HFault>("Down", 507)] internal sealed class FxC04EpSApi : FxC04EpBase { }
-[FaultStatus<HFault>("Down", 507)] internal sealed class FxC04EpSPlain : FxC04EpBase { }
-
-internal abstract class FxC04CtWoBase : ControllerBase
-{
-    [HttpGet("c/fx/ct/wo/a/one")] public Results<NoContent, FaultProblem<HFault>> FxCtWoAOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/fx/ct/wo/a/two")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> FxCtWoATwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/fx/ct/wo/a/dup")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> FxCtWoADup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/fx/ct/wo/a/decl"), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> FxCtWoADecl(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/fx/ct/wo/b/one")] public Results<NoContent, FaultProblem<HFault>> FxCtWoBOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/fx/ct/wo/b/two")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> FxCtWoBTwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/fx/ct/wo/b/dup")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> FxCtWoBDup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/fx/ct/wo/b/decl"), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> FxCtWoBDecl(int e) => FxErr.One(e).ToHttpResult();
-}
-[ApiController, WithoutFaults<HFault>("Down")] internal sealed class FxC04CtWoApi : FxC04CtWoBase { }
-[WithoutFaults<HFault>("Down")] internal sealed class FxC04CtWoPlain : FxC04CtWoBase { }
-
-internal abstract class FxC04CtKeepBase : ControllerBase
-{
-    [HttpGet("c/fx/ct/keep/one")] public Results<NoContent, FaultProblem<HFault>> FxCtKeepOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/fx/ct/keep/two")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> FxCtKeepTwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/fx/ct/keep/dup")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> FxCtKeepDup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/fx/ct/keep/decl"), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> FxCtKeepDecl(int e) => FxErr.One(e).ToHttpResult();
-}
-[ApiController] internal sealed class FxC04CtKeepApi : FxC04CtKeepBase { }
-internal sealed class FxC04CtKeepPlain : FxC04CtKeepBase { }
-
-internal abstract class FxC04GrBase : ControllerBase
-{
-    [HttpGet("c/fx/gr/a/one")] public Results<NoContent, FaultProblem<HFault>> FxGrAOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/fx/gr/a/two")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> FxGrATwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/fx/gr/a/dup")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> FxGrADup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/fx/gr/a/decl"), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> FxGrADecl(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/fx/gr/b/one")] public Results<NoContent, FaultProblem<HFault>> FxGrBOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/fx/gr/b/two")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> FxGrBTwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/fx/gr/b/dup")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> FxGrBDup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/fx/gr/b/decl"), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> FxGrBDecl(int e) => FxErr.One(e).ToHttpResult();
-}
-[ApiController] internal sealed class FxC04GrApi : FxC04GrBase { }
-internal sealed class FxC04GrPlain : FxC04GrBase { }
-
-internal abstract class FxC06KBase : ControllerBase
-{
-    [HttpGet("c/k/one")] public Results<NoContent, FaultProblem<HFault>> KOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/k/two")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> KTwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/k/dup")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> KDup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/k/decl"), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> KDecl(int e) => FxErr.One(e).ToHttpResult();
-}
-[ApiController] internal sealed class FxC06KApi : FxC06KBase { }
-internal sealed class FxC06KPlain : FxC06KBase { }
-
-internal abstract class FxC14PpBase : ControllerBase
-{
-    [HttpGet("c/d/pp/one"), ProducesResponseType<ProblemDetails>(404, "application/problem+json")] public Results<NoContent, FaultProblem<HFault>> DPpOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/d/pp/two"), ProducesResponseType<ProblemDetails>(404, "application/problem+json")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> DPpTwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/d/pp/dup"), ProducesResponseType<ProblemDetails>(404, "application/problem+json")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> DPpDup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/d/pp/decl"), ProducesResponseType<ProblemDetails>(404, "application/problem+json"), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> DPpDecl(int e) => FxErr.One(e).ToHttpResult();
-}
-[ApiController] internal sealed class FxC14PpApi : FxC14PpBase { }
-internal sealed class FxC14PpPlain : FxC14PpBase { }
-
-internal abstract class FxC14PrtBase : ControllerBase
-{
-    [HttpGet("c/d/prt/one"), ProducesResponseType<ProblemDetails>(404)] public Results<NoContent, FaultProblem<HFault>> DPrtOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/d/prt/two"), ProducesResponseType<ProblemDetails>(404)] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> DPrtTwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/d/prt/dup"), ProducesResponseType<ProblemDetails>(404)] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> DPrtDup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/d/prt/decl"), ProducesResponseType<ProblemDetails>(404), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> DPrtDecl(int e) => FxErr.One(e).ToHttpResult();
-}
-[ApiController] internal sealed class FxC14PrtApi : FxC14PrtBase { }
-internal sealed class FxC14PrtPlain : FxC14PrtBase { }
-
-internal abstract class FxC14NoneBase : ControllerBase
-{
-    [HttpGet("c/d/none/one")] public Results<NoContent, FaultProblem<HFault>> DNoneOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/d/none/two")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> DNoneTwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/d/none/dup")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> DNoneDup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/d/none/decl"), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> DNoneDecl(int e) => FxErr.One(e).ToHttpResult();
-}
-[ApiController] internal sealed class FxC14NoneApi : FxC14NoneBase { }
-internal sealed class FxC14NonePlain : FxC14NoneBase { }
-
-internal abstract class FxC15MBase : ControllerBase
-{
-    [HttpGet("c/s/a/one")] public Results<NoContent, FaultProblem<HFault>> SAOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/s/a/two")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> SATwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/s/a/dup")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> SADup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/s/a/decl"), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> SADecl(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/s/p/one"), FaultStatus<HFault>("Denied", 452)] public Results<NoContent, FaultProblem<HFault>> SPOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/s/p/two"), FaultStatus<HFault>("Denied", 452)] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> SPTwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/s/p/dup"), FaultStatus<HFault>("Denied", 452)] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> SPDup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/s/p/decl"), FaultStatus<HFault>("Denied", 452), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> SPDecl(int e) => FxErr.One(e).ToHttpResult();
-}
-[ApiController] internal sealed class FxC15MApi : FxC15MBase { }
-internal sealed class FxC15MPlain : FxC15MBase { }
-
-internal abstract class FxC15ASBase : ControllerBase
-{
-    [HttpGet("c/s/a/one"), FaultStatus<HFault>("Denied", 451)] public Results<NoContent, FaultProblem<HFault>> SAOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/s/a/two"), FaultStatus<HFault>("Denied", 451)] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> SATwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/s/a/dup"), FaultStatus<HFault>("Denied", 451)] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> SADup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/s/a/decl"), FaultStatus<HFault>("Denied", 451), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> SADecl(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/s/k/one")] public Results<NoContent, FaultProblem<HFault>> SKOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/s/k/two")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> SKTwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/s/k/dup")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> SKDup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/s/k/decl"), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> SKDecl(int e) => FxErr.One(e).ToHttpResult();
-}
-[ApiController] internal sealed class FxC15ASApi : FxC15ASBase { }
-internal sealed class FxC15ASPlain : FxC15ASBase { }
-
-internal abstract class FxC15AWBase : ControllerBase
-{
-    [HttpGet("c/s/a/one"), WithoutFaults<HFault>("Down")] public Results<NoContent, FaultProblem<HFault>> SAOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/s/a/two"), WithoutFaults<HFault>("Down")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> SATwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/s/a/dup"), WithoutFaults<HFault>("Down")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> SADup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/s/a/decl"), WithoutFaults<HFault>("Down"), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> SADecl(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/s/k/one")] public Results<NoContent, FaultProblem<HFault>> SKOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/s/k/two")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> SKTwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/s/k/dup")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> SKDup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/s/k/decl"), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> SKDecl(int e) => FxErr.One(e).ToHttpResult();
-}
-[ApiController] internal sealed class FxC15AWApi : FxC15AWBase { }
-internal sealed class FxC15AWPlain : FxC15AWBase { }
-
-internal abstract class FxC15CSBase : ControllerBase
-{
-    [HttpGet("c/s/a/one")] public Results<NoContent, FaultProblem<HFault>> SAOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/s/a/two")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> SATwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/s/a/dup")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> SADup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/s/a/decl"), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> SADecl(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/s/p/one"), FaultStatus<HFault>("Denied", 452)] public Results<NoContent, FaultProblem<HFault>> SPOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/s/p/two"), FaultStatus<HFault>("Denied", 452)] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> SPTwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/s/p/dup"), FaultStatus<HFault>("Denied", 452)] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> SPDup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/s/p/decl"), FaultStatus<HFault>("Denied", 452), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> SPDecl(int e) => FxErr.One(e).ToHttpResult();
-}
-[ApiController, FaultStatus<HFault>("Denied", 451)] internal sealed class FxC15CSApi : FxC15CSBase { }
-[FaultStatus<HFault>("Denied", 451)] internal sealed class FxC15CSPlain : FxC15CSBase { }
-
-internal abstract class FxC15CWBase : ControllerBase
-{
-    [HttpGet("c/s/a/one")] public Results<NoContent, FaultProblem<HFault>> SAOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/s/a/two")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> SATwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/s/a/dup")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> SADup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/s/a/decl"), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> SADecl(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/s/p/one"), FaultStatus<HFault>("Denied", 452)] public Results<NoContent, FaultProblem<HFault>> SPOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/s/p/two"), FaultStatus<HFault>("Denied", 452)] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> SPTwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/s/p/dup"), FaultStatus<HFault>("Denied", 452)] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> SPDup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/s/p/decl"), FaultStatus<HFault>("Denied", 452), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> SPDecl(int e) => FxErr.One(e).ToHttpResult();
-}
-[ApiController, WithoutFaults<HFault>("Down")] internal sealed class FxC15CWApi : FxC15CWBase { }
-[WithoutFaults<HFault>("Down")] internal sealed class FxC15CWPlain : FxC15CWBase { }
-
-internal abstract class FxC15KBase : ControllerBase
-{
-    [HttpGet("c/s/k/one")] public Results<NoContent, FaultProblem<HFault>> SKOne(int e) => FxErr.One(e).ToHttpResult();
-    [HttpGet("c/s/k/two")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> SKTwo(int e) => FxErr.Two(e).ToHttpResult();
-    [HttpGet("c/s/k/dup")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> SKDup(int e) => FxErr.Dup(e).ToHttpResult();
-    [HttpGet("c/s/k/decl"), ProducesResponseType<ProblemDetails>(429)] public Results<NoContent, FaultProblem<HFault>> SKDecl(int e) => FxErr.One(e).ToHttpResult();
-}
-[ApiController] internal sealed class FxC15KApi : FxC15KBase { }
-internal sealed class FxC15KPlain : FxC15KBase { }
-
-public static partial class FxCtl
-{
-    static partial void Fill(Dictionary<string, Ctl> d)
-    {
-        d["C04Ep"] = new(typeof(FxC04EpApi), typeof(FxC04EpPlain), [], [new("fx/ep/wo", [new("HFault", "Down", 0)], []), new("fx/ep/keep", [], [])]);
-        d["C04EpS"] = new(typeof(FxC04EpSApi), typeof(FxC04EpSPlain), [new("HFault", "Down", 507)], [new("fx/ep/wo", [new("HFault", "Down", 0)], []), new("fx/ep/keep", [], [])]);
-        d["C04CtWo"] = new(typeof(FxC04CtWoApi), typeof(FxC04CtWoPlain), [new("HFault", "Down", 0)], [new("fx/ct/wo/a", [], []), new("fx/ct/wo/b", [], [])]);
-        d["C04CtKeep"] = new(typeof(FxC04CtKeepApi), typeof(FxC04CtKeepPlain), [], [new("fx/ct/keep", [], [])]);
-        d["C04Gr"] = new(typeof(FxC04GrApi), typeof(FxC04GrPlain), [], [new("fx/gr/a", [], []), new("fx/gr/b", [], [])]);
-        d["C06K"] = new(typeof(FxC06KApi), typeof(FxC06KPlain), [], [new("k", [], [])]);
-        d["C14Pp"] = new(typeof(FxC14PpApi), typeof(FxC14PpPlain), [], [new("d/pp", [], [404])]);
-        d["C14Prt"] = new(typeof(FxC14PrtApi), typeof(FxC14PrtPlain), [], [new("d/prt", [], [404])]);
-        d["C14None"] = new(typeof(FxC14NoneApi), typeof(FxC14NonePlain), [], [new("d/none", [], [])]);
-        d["C15M"] = new(typeof(FxC15MApi), typeof(FxC15MPlain), [], [new("s/a", [], []), new("s/p", [new("HFault", "Denied", 452)], [])]);
-        d["C15AS"] = new(typeof(FxC15ASApi), typeof(FxC15ASPlain), [], [new("s/a", [new("HFault", "Denied", 451)], []), new("s/k", [], [])]);
-        d["C15AW"] = new(typeof(FxC15AWApi), typeof(FxC15AWPlain), [], [new("s/a", [new("HFault", "Down", 0)], []), new("s/k", [], [])]);
-        d["C15CS"] = new(typeof(FxC15CSApi), typeof(FxC15CSPlain), [new("HFault", "Denied", 451)], [new("s/a", [], []), new("s/p", [new("HFault", "Denied", 452)], [])]);
-        d["C15CW"] = new(typeof(FxC15CWApi), typeof(FxC15CWPlain), [new("HFault", "Down", 0)], [new("s/a", [], []), new("s/p", [new("HFault", "Denied", 452)], [])]);
-        d["C15K"] = new(typeof(FxC15KApi), typeof(FxC15KPlain), [], [new("s/k", [], [])]);
-    }
-}
diff --git a/tools/probe/corpus/harness/FaultClaimSets.cs b/tools/probe/corpus/harness/FaultClaimSets.cs
deleted file mode 100644
index 30111c23..00000000
--- a/tools/probe/corpus/harness/FaultClaimSets.cs
+++ /dev/null
@@ -1,70 +0,0 @@
-// Fault types for C07-fault-responses-blanket (AspNetCore README#every-fault-set-at-once), each answered by one endpoint of its own beside the
-// claim's: an enum (which no mapping for every set covers), a fault set with a member of no kind, and two fault sets the host's mapping
-// refuses (one it throws for, one it gives a status that is no error).
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.AspNetCore;
-using CodoMetis.TypeKit.ClosedSets;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Http.HttpResults;
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.AspNetCore.Routing;
-namespace Probes.Faults;
-
-public enum FxEnum { Lost, Taken }
-public sealed partial class FxNoKind : IFaultSet<FxNoKind>
-{
-    public static readonly FxNoKind Fine = new(FaultKind.NotFound, null);
-#pragma warning disable CMTK0014 // a member of no kind, on purpose: the claim is that it stops the start
-    public static readonly FxNoKind Blank = new(default, null);
-#pragma warning restore CMTK0014
-    private FxNoKind(FaultKind kind, string? description) { Kind = kind; Description = description; }
-    public FaultKind Kind { get; }
-    public string? Description { get; }
-}
-public sealed partial class FxThrows : IFaultSet<FxThrows>
-{
-    public static readonly FxThrows Odd = new(FaultKind.Conflict, null);
-    private FxThrows(FaultKind kind, string? description) { Kind = kind; Description = description; }
-    public FaultKind Kind { get; }
-    public string? Description { get; }
-}
-public sealed partial class FxStatus : IFaultSet<FxStatus>
-{
-    public static readonly FxStatus Moved = new(FaultKind.NotFound, null);
-    private FxStatus(FaultKind kind, string? description) { Kind = kind; Description = description; }
-    public FaultKind Kind { get; }
-    public string? Description { get; }
-}
-/// <summary>What the application's mapping throws (set=mapping-throws).</summary>
-public sealed class FxMappingRefused() : Exception("the mapping refuses FxThrows");
-
-public static class FxSets
-{
-    public static Result<Fault<FxEnum>> Enum(int e) { if (e == 0) return Result<Fault<FxEnum>>.Success(); return Fault.Of(FxEnum.Lost); }
-    public static Result<Fault<FxNoKind>> NoKind(int e) { if (e == 0) return Result<Fault<FxNoKind>>.Success(); return Fault.Of(FxNoKind.Fine); }
-    public static Result<Fault<FxThrows>> Throws(int e) { if (e == 0) return Result<Fault<FxThrows>>.Success(); return Fault.Of(FxThrows.Odd); }
-    public static Result<Fault<FxStatus>> Status(int e) { if (e == 0) return Result<Fault<FxStatus>>.Success(); return Fault.Of(FxStatus.Moved); }
-
-    /// <summary>The minimal endpoint answering the row's set, at /c7x.</summary>
-    public static void Map(IEndpointRouteBuilder b, string set)
-    {
-        switch (set)
-        {
-            case "enum-unmapped": b.MapGet("/c7x", (int e) => Enum(e).ToHttpResult()); break;
-            case "member-without-kind": b.MapGet("/c7x", (int e) => NoKind(e).ToHttpResult()); break;
-            case "mapping-throws": b.MapGet("/c7x", (int e) => Throws(e).ToHttpResult()); break;
-            case "status-not-error": b.MapGet("/c7x", (int e) => Status(e).ToHttpResult()); break;
-        }
-    }
-    /// <summary>The MVC controller answering the row's set.</summary>
-    public static Type[] Controllers(string set) => set switch
-    {
-        "enum-unmapped" => [typeof(FxC07Enum)], "member-without-kind" => [typeof(FxC07NoKind)],
-        "mapping-throws" => [typeof(FxC07Throws)], "status-not-error" => [typeof(FxC07Status)], _ => [],
-    };
-}
-[ApiController] internal sealed class FxC07Enum : ControllerBase { [HttpGet("c/c7x/enum")] public Results<NoContent, FaultProblem<FxEnum>> Get(int e) => FxSets.Enum(e).ToHttpResult(); }
-[ApiController] internal sealed class FxC07NoKind : ControllerBase { [HttpGet("c/c7x/nokind")] public Results<NoContent, FaultProblem<FxNoKind>> Get(int e) => FxSets.NoKind(e).ToHttpResult(); }
-[ApiController] internal sealed class FxC07Throws : ControllerBase { [HttpGet("c/c7x/throws")] public Results<NoContent, FaultProblem<FxThrows>> Get(int e) => FxSets.Throws(e).ToHttpResult(); }
-[ApiController] internal sealed class FxC07Status : ControllerBase { [HttpGet("c/c7x/status")] public Results<NoContent, FaultProblem<FxStatus>> Get(int e) => FxSets.Status(e).ToHttpResult(); }
diff --git a/tools/probe/corpus/harness/FaultControllers.cs b/tools/probe/corpus/harness/FaultControllers.cs
deleted file mode 100644
index f93ff5dc..00000000
--- a/tools/probe/corpus/harness/FaultControllers.cs
+++ /dev/null
@@ -1,49 +0,0 @@
-// Controllers answering with faults; the Plain* copies have no [ApiController] (http.host=controller-without-ApiController, and
-// controller-without-ApiController-visible, where a convention puts them into the document).
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.AspNetCore;
-using Microsoft.AspNetCore.Http.HttpResults;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Mvc;
-namespace Probes;
-
-[ApiController]
-public sealed class MvcAController : ControllerBase
-{
-    [HttpGet("c/two")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> Two(int e) => Errors.Two(e).ToHttpResult();
-    [HttpGet("c/wo"), WithoutFaults<HFault>(nameof(HFault.Missing), nameof(HFault.Bad))]
-    public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> Wo(int e) => Errors.Two(e).ToHttpResult();
-    [HttpGet("c/fs"), FaultStatus<HFault>(nameof(HFault.Clash), 422)]
-    public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> Fs(int e) => Errors.Two(e).ToHttpResult();
-    [HttpGet("c/three")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>, FaultProblem<SFault>> Three(int e) => Errors.Three(e).ToHttpResult();
-    [HttpGet("c/declared404"), ProducesResponseType<ProblemDetails>(404)]
-    public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> Declared404(int e) => Errors.Two(e).ToHttpResult();
-    [HttpGet("c/declared"), ProducesResponseType<ProblemDetails>(429)]
-    public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> Declared(int e) => Errors.Two(e).ToHttpResult();
-}
-[ApiController, FaultStatus<HFault>(nameof(HFault.Denied), 451), WithoutFaults<HFault>(nameof(HFault.Down))]
-public sealed class MvcBController : ControllerBase
-{
-    [HttpGet("d/two")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> Two(int e) => Errors.Two(e).ToHttpResult();
-}
-
-
-public sealed class PlainAController : ControllerBase
-{
-    [HttpGet("c/two")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> Two(int e) => Errors.Two(e).ToHttpResult();
-    [HttpGet("c/wo"), WithoutFaults<HFault>(nameof(HFault.Missing), nameof(HFault.Bad))]
-    public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> Wo(int e) => Errors.Two(e).ToHttpResult();
-    [HttpGet("c/fs"), FaultStatus<HFault>(nameof(HFault.Clash), 422)]
-    public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> Fs(int e) => Errors.Two(e).ToHttpResult();
-    [HttpGet("c/three")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>, FaultProblem<SFault>> Three(int e) => Errors.Three(e).ToHttpResult();
-    [HttpGet("c/declared404"), ProducesResponseType<ProblemDetails>(404)]
-    public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> Declared404(int e) => Errors.Two(e).ToHttpResult();
-    [HttpGet("c/declared"), ProducesResponseType<ProblemDetails>(429)]
-    public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> Declared(int e) => Errors.Two(e).ToHttpResult();
-}
-[FaultStatus<HFault>(nameof(HFault.Denied), 451), WithoutFaults<HFault>(nameof(HFault.Down))]
-public sealed class PlainBController : ControllerBase
-{
-    [HttpGet("d/two")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> Two(int e) => Errors.Two(e).ToHttpResult();
-}
-
diff --git a/tools/probe/corpus/harness/Faults.cs b/tools/probe/corpus/harness/Faults.cs
deleted file mode 100644
index eac16d31..00000000
--- a/tools/probe/corpus/harness/Faults.cs
+++ /dev/null
@@ -1,106 +0,0 @@
-// Fault types, error tables and shared logging for the HTTP probes (harness; see HttpHost.cs).
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.ValueObjects;
-using CodoMetis.TypeKit.ClosedSets;
-using Microsoft.AspNetCore.Mvc.ApplicationParts;
-using Microsoft.AspNetCore.Mvc.Controllers;
-using Microsoft.Extensions.Logging;
-using System.Reflection;
-namespace Probes;
-
-public sealed partial class HFault : IFaultSet<HFault>
-{
-    public static readonly HFault Missing = new(FaultKind.NotFound, "Missing.");
-    public static readonly HFault Clash = new(FaultKind.Conflict, null);
-    public static readonly HFault Bad = new(FaultKind.Invalid, null);
-    public static readonly HFault Denied = new(FaultKind.Forbidden, null);
-    public static readonly HFault Down = new(FaultKind.Unavailable, null);
-    public static readonly HFault Stale = new(FaultKind.PreconditionFailed, null);
-    public static readonly HFault Garbled = new(FaultKind.Malformed, null);
-    private HFault(FaultKind kind, string? description) { Kind = kind; Description = description; }
-    public FaultKind Kind { get; }
-    public string? Description { get; }
-}
-public sealed partial class GFault : IFaultSet<GFault>
-{
-    public static readonly GFault Gone = new(FaultKind.NotFound, null);
-    public static readonly GFault Raced = new(FaultKind.Conflict, null);
-    public static readonly GFault Old = new(FaultKind.PreconditionFailed, null);
-    private GFault(FaultKind kind, string? description) { Kind = kind; Description = description; }
-    public FaultKind Kind { get; }
-    public string? Description { get; }
-}
-public enum SFault { First, Second }
-public enum PRule { A, B }
-[Flags] public enum FRule { P = 1, Q = 2 }
-public static class Holder { public enum NestedRule { N } }
-public sealed partial class RuleSet : IClosedSet<RuleSet> { public static readonly RuleSet X = new(); public static readonly RuleSet Y = new(); }
-
-public static class Errors
-{
-    public static Result<Fault<HFault, GFault>> Two(int e) => e switch
-    {
-        0 => Result<Fault<HFault, GFault>>.Success(),
-        1 => Fault<HFault, GFault>.Of(HFault.Missing),
-        2 => Fault<HFault, GFault>.Of(HFault.Clash),
-        3 => Fault<HFault, GFault>.Of(HFault.Bad),
-        4 => Fault<HFault, GFault>.Of(HFault.Denied),
-        5 => Fault<HFault, GFault>.Of(HFault.Down),
-        6 => Fault<HFault, GFault>.Of(HFault.Stale),
-        7 => Fault<HFault, GFault>.Of(HFault.Garbled),
-        8 => Fault<HFault, GFault>.Of(GFault.Gone),
-        9 => Fault<HFault, GFault>.Of(GFault.Raced),
-        10 => Fault<HFault, GFault>.Of(GFault.Old),
-        _ => throw new ArgumentOutOfRangeException(nameof(e)),
-    };
-    public static Result<Fault<HFault, GFault, SFault>> Three(int e) => e switch
-    {
-        0 => Result<Fault<HFault, GFault, SFault>>.Success(),
-        1 => Fault<HFault, GFault, SFault>.Of(HFault.Missing),
-        8 => Fault<HFault, GFault, SFault>.Of(GFault.Gone),
-        11 => Fault<HFault, GFault, SFault>.Of(SFault.First),
-        12 => Fault<HFault, GFault, SFault>.Of(Fault.Of(SFault.Second, "second detail").WithRule(PRule.B)),
-        13 => Fault<HFault, GFault, SFault>.Of(Fault.Of(HFault.Clash).WithRule(RuleSet.X)),
-        14 => Fault<HFault, GFault, SFault>.Of(Fault.Of(GFault.Raced).WithRule(Holder.NestedRule.N)),
-        _ => throw new ArgumentOutOfRangeException(nameof(e)),
-    };
-    public static Result<Fault<HFault>> One(int e) => e switch
-    {
-        0 => Result<Fault<HFault>>.Success(),
-        1 => Fault.Of(HFault.Missing),
-        2 => Fault.Of(HFault.Clash),
-        4 => Fault.Of(HFault.Denied),
-        5 => Fault.Of(HFault.Down),
-        _ => throw new ArgumentOutOfRangeException(nameof(e)),
-    };
-    public static Result<Fault<GFault>> OneG(int e) => e switch
-    {
-        0 => Result<Fault<GFault>>.Success(),
-        8 => Fault.Of(GFault.Gone),
-        9 => Fault.Of(GFault.Raced),
-        _ => throw new ArgumentOutOfRangeException(nameof(e)),
-    };
-}
-
-public sealed class ListedLogs : ILoggerProvider
-{
-    public List<string> Lines { get; } = [];
-    public ILogger CreateLogger(string categoryName) => new L(this);
-    public void Dispose() { }
-    private sealed class L(ListedLogs o) : ILogger
-    {
-        public IDisposable? BeginScope<TState>(TState state) where TState : notnull => null;
-        public bool IsEnabled(LogLevel logLevel) => true;
-        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter) =>
-            o.Lines.Add($"{logLevel}: {formatter(state, exception)}");
-    }
-}
-
-public sealed class OnlyControllers(Type[] controllers) : IApplicationFeatureProvider<ControllerFeature>
-{
-    public void PopulateFeature(IEnumerable<ApplicationPart> parts, ControllerFeature feature)
-    {
-        foreach (var c in controllers) feature.Controllers.Add(c.GetTypeInfo());
-    }
-}
-
diff --git a/tools/probe/corpus/harness/HandOrdered.cs b/tools/probe/corpus/harness/HandOrdered.cs
deleted file mode 100644
index c1c72cfb..00000000
--- a/tools/probe/corpus/harness/HandOrdered.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Value objects that declare their own CompareTo(TSelf) (a descending order), for the EF claims about hand-written ordering.
-#nullable enable
-#pragma warning disable CMTK0014, CS8618, CS1591, CMTK0005, CMTK1000, CMTK0003, CMTK0006
-using CodoMetis.TypeKit.ValueObjects;
-namespace Probes.Ef;
-
-public readonly partial record struct HO_int_struct : IValue<int> { public int CompareTo(HO_int_struct other) => other.Value.CompareTo(Value); }
-public readonly partial record struct HO_string_struct : IValue<string> { public int CompareTo(HO_string_struct other) => string.CompareOrdinal(other.Value, Value); }
-public readonly partial record struct HO_decimal_struct : IValue<decimal> { public int CompareTo(HO_decimal_struct other) => other.Value.CompareTo(Value); }
-public readonly partial record struct HO_DateTime_struct : IValue<DateTime> { public int CompareTo(HO_DateTime_struct other) => other.Value.CompareTo(Value); }
-public sealed partial record class HO_int_class : IValue<int> { public int CompareTo(HO_int_class? other) => other is null ? 1 : other.Value.CompareTo(Value); }
-public sealed partial record class HO_string_class : IValue<string> { public int CompareTo(HO_string_class? other) => other is null ? 1 : string.CompareOrdinal(other.Value, Value); }
-
-public static class HandOrdered
-{
-    public sealed record Entry(string Name, Type Vo, Type Plain, object[] Values);
-    public static readonly Entry[] All =
-    [
-        new("int-struct", typeof(HO_int_struct), typeof(int), [1, 2, 3]),
-        new("string-struct", typeof(HO_string_struct), typeof(string), ["a", "b", "c"]),
-        new("decimal-struct", typeof(HO_decimal_struct), typeof(decimal), [1.5m, 2.5m, 3.5m]),
-        new("DateTime-struct", typeof(HO_DateTime_struct), typeof(DateTime), [new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc), new DateTime(2026, 1, 2, 0, 0, 0, DateTimeKind.Utc), new DateTime(2026, 1, 3, 0, 0, 0, DateTimeKind.Utc)]),
-        new("int-class", typeof(HO_int_class), typeof(int), [1, 2, 3]),
-        new("string-class", typeof(HO_string_class), typeof(string), ["a", "b", "c"]),
-    ];
-    public static Entry Of(string name) => All.First(e => e.Name == name);
-    public static object Make(Entry e, object plain) => e.Vo.GetMethod("From", [e.Plain])!.Invoke(null, [plain])!;
-}
diff --git a/tools/probe/corpus/harness/HttpBaseline.cs b/tools/probe/corpus/harness/HttpBaseline.cs
deleted file mode 100644
index 731f5d84..00000000
--- a/tools/probe/corpus/harness/HttpBaseline.cs
+++ /dev/null
@@ -1,800 +0,0 @@
-// The baseline every http claim shares: under the row's options, a payload with the value object behaves like the same payload with the wrapped
-// type (response bytes, request reading, parameter binding, OpenAPI schema), in the hosting models the row's http.host names.
-// Oracle: differential (JSON/wire/schema parity), each comparison a check (Row.Check); a difference a document makes intended ends its check
-// as that citation (Cite), and one no document makes intended is compared.
-using System.Net;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Options;
-using System.Text.Json;
-using System.Text.Json.Nodes;
-using CodoMetis.TypeKit.Facts;
-namespace Probes.Shapes;
-
-public static class HttpBaseline
-{
-    static string Cut(string? s) => s is null ? "(null)" : s.Length > 220 ? s[..220] + "..." : s;
-
-    /// True only where the shape's Create refuses exactly the wrapped type's limit (the validated byte refuses 255):
-    /// anywhere else a refused limit is the value object's to explain.
-    static bool RefusesItsLimit(Entry e)
-    {
-        var refused = e.RefusedFn();   // the plain value the shape's Create refuses
-        if (refused is null) return false;
-        var t = Make.Held(e.Plain);
-        return new[] { "MaxValue", "MinValue" }.Any(f => t.GetField(f)?.GetValue(null) is { } limit && limit.Equals(refused));
-    }
-
-    /// <summary>
-    /// One wire comparison with the twin, inside its check <paramref name="c"/>: the wrapped type's answer <paramref name="p"/> (side (2)) and the
-    /// value object's <paramref name="v"/> (side (3)); side (1) refusing alike was decided before the check (<see cref="Wire"/>). A difference a
-    /// document makes intended ends the check as that document's citation; BaseProbe calibrates the host on C07's rows, whose claim promises
-    /// nothing of the wire, so these cite the sentence itself, not a not-promised entry of C07.
-    /// </summary>
-    static string? Same(Check c, Row r, Entry e, string what, Hx.Wire p, Hx.Wire v, string input = "valid")
-    {
-        r.Log.AppendLine($"{what}: plain {(int)p.Status} {Cut(p.Body)} {p.Thrown} | vo {(int)v.Status} {Cut(v.Body)} {v.Thrown}");
-        bool ok(Hx.Wire w) => (int)w.Status is >= 200 and < 300;
-        // both refused, and not as the twin without TypeKit refuses (Sides.Alike): evidence about refusing, and nothing to compare
-        if (!ok(p) && !ok(v)) return c.Inconclusive($"{what}: both refuse, not alike: wrapped {p.Side(what)}, value object {v.Side(what)}");
-        // "Your own converter wins": the application's converter writes the value object instead of the generated one.
-        if (r.Is("json.Converters", "own-for-value-object") && ok(v)) return c.Inapplicable(Cite.Docs("src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says"), what);
-        if (ok(p) && !ok(v))
-        {
-            if (ReadRefusedAsDocumented(c, r, e, input, what)) return null;
-            // the same: the value object's array reads a JSON array of numbers, never the base64 string the twin's byte[] wrote and reads
-            if (ByteArray(r, e)) return c.Inapplicable(Cite.Docs("docs/json.md#the-wrapped-types-json"), what);
-            // A closed set travels as its member's name; the wrapped type under the application's converter is no reference.
-            if (e.Kind == "closed-set" && r.Is("json.Converters", "own-for-wrapped")) return c.Inapplicable(Cite.Docs("README.md#what-you-get"), what);
-            // The validated shapes' Create refuses the wrapped type's limit on purpose, so the limit input is a refusal.
-            if (e.Kind.StartsWith("validated") && input == "at-type-limit" && RefusesItsLimit(e)) return c.Refused(Cite.Docs("docs/json.md#when-a-value-is-rejected"), what);
-            return (e.Wrapped == "NodaTime.Instant" && what.StartsWith("mvc bind") ? "[F1] " : "") + $"{what}: wrapped answered {(int)p.Status} {Cut(p.Body)}, value object answered {(int)v.Status} {Cut(v.Body)} {v.Thrown}";
-        }
-        if (!ok(p) && ok(v))
-        {
-            // docs/json.md "Null and missing": a struct value object rejects a JSON null; a sealed partial record reads it as null,
-            // like any class, where the struct it wraps refuses it.
-            if (input == "null" && Make.AdmitsNull(e.Vo) && !Make.AdmitsNull(e.Plain)) return c.Refused(Cite.Docs("docs/json.md#null-and-missing"), what);
-            return $"{what}: value object answered {(int)v.Status} {Cut(v.Body)} where wrapped answered {(int)p.Status} {Cut(p.Body)} {p.Thrown}";
-        }
-        if (p.Body != v.Body)
-        {
-            // A closed set travels as its member's name, never as the string or number standing in for it.
-            if (e.Kind == "closed-set") return c.Inapplicable(Cite.Docs("README.md#what-you-get"), what);
-            // docs/json.md "The wrapped type's JSON": an array of value objects over byte is a JSON array of numbers, where the twin, a byte[],
-            // is one base64 string (KB-038).
-            if (ByteArray(r, e)) return c.Inapplicable(Cite.Docs("docs/json.md#the-wrapped-types-json"), what);
-            return $"{what}: bodies differ: wrapped {Cut(p.Body)} vs value object {Cut(v.Body)}";
-        }
-        c.Note(NoteKeys.Compared, what);
-        return null;
-    }
-
-    /// <summary>
-    /// One check of the wire, three-sided (Sides): side (2) <paramref name="p"/> and side (3) <paramref name="v"/> answered on the host with
-    /// TypeKit; side (1) is asked of the host without it (<paramref name="one"/>), lazily, only where they disagree or refuse. Where (1)
-    /// refuses alike with (3), the check is the framework's refusal against Baseline.Framework; where (1) answers and the value object's
-    /// write was refused under a depth limit, side (1) is a converter's value there (KB-040, in process); otherwise <paramref name="body"/>
-    /// compares, once (2) is held to (1).
-    /// </summary>
-    static async Task<string?> Wire(Row r, Entry e, string obligation, Baseline against, string what, Hx.Wire p, Hx.Wire v, Func<Task<Hx.Wire?>> one, Func<Check, Task<string?>> body)
-    {
-        var two = p.Side(what); var three = v.Side(what);
-        Sides.Answer? first = null; Sides.Side? framework = null;
-        if (two.Refused || three.Refused || p.Body != v.Body)
-        {
-            if (await one() is { } w) first = w.Side(what);
-            if (three.Refused && first is { Refused: true } && Sides.Alike(first, three)) framework = Sides.Measured(first, "the twin on a host without TypeKit");
-            else if (three.Refused && v.Ex is { } thrown && first is { Refused: false } && (Sides.Why = null) is null
-                     && Sides.WrittenByAConverter(r, e, Twin(r, e), Sides.WithoutTypeKit(JsonRow.Apply(r, e).Options!), new("write", null, thrown)) is { } converter
-                     && Sides.Alike(converter.Answer, new("write", null, thrown)))
-                return Sides.Check(r, obligation, against, converter, new("write", null, thrown), null, null, _ => (string?)null);
-        }
-        var failed = await Sides.Check(r, obligation, against, framework, three, first, first is null ? null : two, body);
-        // the failure names side (1), for the triage of the row
-        return failed is null || first is null ? failed : failed + $" [side (1), the twin without TypeKit: {first}{(Sides.Why is { } why ? "; " + why : "")}]";
-    }
-
-    /// <summary>The wrapped twin's payload, as the echo writes it: the row's position and containing type around the wrapped value.</summary>
-    static Held Twin(Row r, Entry e) => Pos.Build(r["shape.position"], r.Get("shape.containing") ?? "class", e, false, e.Valid());
-
-    /// <summary>An array of value objects over byte, whose twin is a byte[] (KB-038).</summary>
-    static bool ByteArray(Row r, Entry e) => e.Wrapped == "byte" && r["shape.position"] == "array-element";
-
-    /// <summary>What MVC writes for a type's default: null for no content (a reference, or a Nullable), else its JSON under MVC's options.</summary>
-    static string? DefaultBody(WebApplication app, Type t) =>
-        !t.IsValueType || Nullable.GetUnderlyingType(t) is not null ? null
-        : JsonSerializer.Serialize(Activator.CreateInstance(t), t, app.Services.GetRequiredService<IOptions<Microsoft.AspNetCore.Mvc.JsonOptions>>().Value.JsonSerializerOptions);
-
-    /// <summary>
-    /// Whether an answer is the type's default as MVC writes it: 204 for null, else 200 with its JSON, compared as JSON, since MVC's
-    /// formatter escapes with its own encoder where the options name none.
-    /// </summary>
-    static bool HoldsDefault(Hx.Wire w, string? body)
-    {
-        if (body is null) return w.Status == HttpStatusCode.NoContent;
-        if (w.Status != HttpStatusCode.OK) return false;
-        try { return JsonNode.DeepEquals(JsonNode.Parse(w.Body), JsonNode.Parse(body)); }
-        catch (JsonException) { return false; }
-    }
-
-    /// <summary>A text the wrapped type does not read, for a twin that shows what MVC does with a binding failure; none where any text binds.</summary>
-    static string? Unreadable(Entry e) => e.Wrapped is "string" or "Uri" or "own-record-class" ? null : "abc";
-
-    /// <summary>
-    /// The value object refused a read the wrapped type answered, as a document says it does (the JSON family's documented differences, each
-    /// cited by its sentence; JsonParity.ReadMayDiffer listed them uncited): side (1) answered and (3) refused, which the citation makes
-    /// intended (Sides). The check ends as that refusal and true is returned.
-    /// </summary>
-    static bool ReadRefusedAsDocumented(Check c, Row r, Entry e, string input, string what)
-    {
-        if (r.Is("json.ReferenceHandler", "Preserve") && e.Wrapped == "own-record-class") { c.Refused(Cite.Docs("src/CodoMetis.TypeKit.Generators/README.md#json"), what); return true; }
-        if (e.Kind.StartsWith("validated") && input == "refused-by-create" && r.Get("json.Converters") != "StoredJsonConverterFactory") { c.Refused(Cite.Docs("docs/json.md#when-a-value-is-rejected"), what); return true; }
-        if (input == "null" && !Make.AdmitsNull(e.Vo)) { c.Refused(Cite.Docs("docs/json.md#null-and-missing"), what); return true; }
-        if (e.Kind == "closed-set" && input != "valid") { c.Refused(Cite.Docs("README.md#what-you-get"), what); return true; }
-        return false;
-    }
-
-    /// <summary>Where two schemas first differ, and what each side has there: the comparison's 220 characters rarely reach it.</summary>
-    static string FirstDifference(JsonNode? p, JsonNode? v, string path) =>
-        Difference(p, v, path) is var d ? $"{d.Path}: wrapped {Cut(d.P?.ToJsonString() ?? "(absent)")} | value object {Cut(d.V?.ToJsonString() ?? "(absent)")}" : "";
-
-    /// <summary>
-    /// Where two schemas first differ: the path as it is shown, the keys that lead there (a property's name, an element's index), each
-    /// side's node there (null where it is absent) and the node holding it, so a difference is told by its structure, never by its path's text.
-    /// </summary>
-    sealed record Diff(string Path, IReadOnlyList<string> Keys, JsonNode? P, JsonNode? V, JsonNode? ParentP, JsonNode? ParentV);
-
-    static Diff Difference(JsonNode? p, JsonNode? v, string path) => Difference(p, v, path, [], null, null);
-
-    static Diff Difference(JsonNode? p, JsonNode? v, string path, List<string> keys, JsonNode? parentP, JsonNode? parentV)
-    {
-        if (p is JsonObject po && v is JsonObject vo)
-        {
-            foreach (var k in po.Select(kv => kv.Key).Union(vo.Select(kv => kv.Key)).Order(StringComparer.Ordinal))
-                if (!JsonNode.DeepEquals(po[k], vo[k])) return Difference(po[k], vo[k], path + "." + k, [.. keys, k], p, v);
-        }
-        else if (p is JsonArray pa && v is JsonArray va && pa.Count == va.Count)
-        {
-            for (var i = 0; i < pa.Count; i++)
-                if (!JsonNode.DeepEquals(pa[i], va[i])) return Difference(pa[i], va[i], $"{path}[{i}]", [.. keys, i.ToString(System.Globalization.CultureInfo.InvariantCulture)], p, v);
-        }
-        return new(path, keys, p, v, parentP, parentV);
-    }
-
-    /// <summary>The node the keys of a <see cref="Diff"/> lead to in another schema, or null where it has none.</summary>
-    static JsonNode? At(JsonNode? node, IEnumerable<string> keys)
-    {
-        foreach (var k in keys)
-            node = node switch { JsonObject o => o[k], JsonArray a when int.TryParse(k, out var i) && i < a.Count => a[i], _ => null };
-        return node;
-    }
-
-    /// <summary>
-    /// Side (1) of a row's wire and schema comparisons: the same host started without TypeKit (HostCfg.WithoutTypeKit), once, on the first
-    /// comparison that asks for it; null where it does not start, which no comparison then excuses anything by. The twin's side (1) is a
-    /// host with the twin's endpoints alone (<c>plain</c>): ASP.NET alone describing the value object's types beside them names components
-    /// after them and writes the twin's own schemas otherwise. A host with both (<c>both</c>) answers for the value object's position.
-    /// </summary>
-    sealed class SideOne(Row r, Entry e, string only) : IAsyncDisposable
-    {
-        Task<WebApplication?>? started;
-        public string? Down { get; private set; }
-        public Task<WebApplication?> Host() => started ??= Start();
-        async Task<WebApplication?> Start()
-        {
-            try { return await Hx.Start(r, e, new HostCfg { FaultControllers = false, MapBlanketMapping = false, WithoutTypeKit = true, PayloadOnly = only }); }
-            catch (Exception x) when (x is not Sides.InputsNotEquivalent) { Down = x.GetType().Name + ": " + Cut(x.Message); r.Log.AppendLine("side (1) host did not start: " + Down); return null; }
-        }
-        public async Task<Hx.Wire?> Ask(Func<WebApplication, Task<Hx.Wire>> ask) => await Host() is { } app ? await ask(app) : null;
-        public async ValueTask DisposeAsync() { if (started is not null && await started is { } app) await app.DisposeAsync(); }
-    }
-
-    /// <summary>
-    /// BaseProbe's calibration of the shared host: every wire comparison a check of its own, named <paramref name="obligation"/> (BaseProbe
-    /// runs on rows of C07, which promises nothing of the wire, so its checks are the implicit <c>claim</c>). Per side: the echo against the
-    /// twin; the request read with the row's input.json, against the twin, or a closed set against its own response read back; the binding of
-    /// the row's http.binding with a valid value against the twin, and with a value Create refuses against the documented 400. Each is
-    /// three-sided (Sides): side (1), the twin on the same host without TypeKit, is asked where the twin and the value object disagree or
-    /// refuse. With <paramref name="schema"/>, the schema parity too (C21's check). Every check runs; the first failure is returned.
-    /// </summary>
-    public static async Task<string?> Run(Row r, Entry e, bool schema = true, string obligation = "claim")
-    {
-        WebApplication app;
-        try { app = await Hx.Start(r, e, new HostCfg { FaultControllers = false, MapBlanketMapping = false }); }
-        catch (Exception ex) when (ex is not Sides.InputsNotEquivalent) { return "baseline host did not start: " + ex.GetType().Name + ": " + Cut(ex.Message); }
-        await using var _ = app;
-        await using var one = new SideOne(r, e, "plain");
-        await using var alone = new SideOne(r, e, "both");
-        var jopts = JsonRow.Apply(r, e).Options!;
-        var position = r["shape.position"];
-        var plainSample = e.Valid();
-        var input = r.Get("input.json") ?? "valid";
-        var ownVo = r.Is("json.Converters", "own-for-value-object");
-        var bind = r["http.binding"];
-        string? failed = null;
-        var sides = new List<(string name, Func<string, string> path, string echo, string inn, string bindPre)>();
-        if (Hx.HasMinimal(r)) sides.Add(("minimal", p => Hx.M(r, p), "/echo/", "/in/", "/bind/"));
-        if (Hx.HasMvc(r)) sides.Add(("mvc", p => Hx.C(r, p), "/mvc/echo/", "/mvc/in/", "/mvc/bind/"));
-        foreach (var (name, path, echo, inn, bindPre) in sides)
-        {
-            // 1. response side
-            var ep = await Hx.Get(app, path(echo + "plain")); var ev = await Hx.Get(app, path(echo + "vo"));
-            var f1 = await Wire(r, e, obligation, Baseline.Twin, name + " echo", ep, ev, () => one.Ask(h => Hx.Get(h, path(echo + "plain"))),
-                c => Task.FromResult(Same(c, r, e, name + " echo", ep, ev)));
-            failed ??= f1;
-            // 2. request side, with the row's input.json, where the wrapped type's echo gave a body to change
-            if ((int)ep.Status == 200)
-            {
-                string? f2;
-                if (ownVo)
-                    // "Your own converter wins": the application's converter reads the value object, so the twin's text is none of its;
-                    // only that it reads its own response back is held, and the check earns nothing.
-                    f2 = await r.Check(obligation, Baseline.RoundTrip, async c =>
-                    {
-                        var ip = await Hx.Send(app, HttpMethod.Post, path(inn + "plain"), ep.Body); var iv = await Hx.Send(app, HttpMethod.Post, path(inn + "vo"), ev.Body);
-                        if ((int)ev.Status == 200 && (int)iv.Status != 200 && (int)ip.Status == 200) return $"{name} in: the value object cannot read its own response ({(int)iv.Status}): {Cut(iv.Body)}";
-                        return c.Inapplicable(Cite.Docs("src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says"), name + " in");
-                    });
-                else if (e.Kind == "closed-set")
-                    // A closed set travels as its member's name (README "What you get"): the string standing in for it is no twin, so the
-                    // value object reads its own response back.
-                    f2 = await r.Check(obligation, Baseline.RoundTrip, async c =>
-                    {
-                        if ((int)ev.Status != 200) return c.Inconclusive($"{name} in: the value object's echo answered {(int)ev.Status}, no response of its own to read back");
-                        var ip = await Hx.Send(app, HttpMethod.Post, path(inn + "plain"), ep.Body); var iv = await Hx.Send(app, HttpMethod.Post, path(inn + "vo"), ev.Body);
-                        r.Log.AppendLine($"{name} in(own response): plain {(int)ip.Status} {Cut(ip.Body)} {ip.Thrown} | vo {(int)iv.Status} {Cut(iv.Body)} {iv.Thrown}");
-                        // The wrapped type does not read its own response back under the row's options either: nothing to tell.
-                        if ((int)iv.Status != 200 && (int)ip.Status != 200) return c.Inconclusive($"{name} in: neither side reads its own response back ({(int)ip.Status}, {(int)iv.Status})");
-                        if ((int)iv.Status != 200) return $"{name} in: the closed set cannot read its own response ({(int)iv.Status}), the wrapped type reads its own: {Cut(iv.Body)} {iv.Thrown}";
-                        c.Note(NoteKeys.Compared, name + " in: its own response read back");
-                        return null;
-                    });
-                else
-                {
-                    var text = JsonParity.InputFor(input, e, jopts, ep.Body, position);
-                    var ip = await Hx.Send(app, HttpMethod.Post, path(inn + "plain"), text); var iv = await Hx.Send(app, HttpMethod.Post, path(inn + "vo"), text);
-                    var what = name + " in(" + input + ")";
-                    f2 = await Wire(r, e, obligation, Baseline.Twin, what, ip, iv, () => one.Ask(h => Hx.Send(h, HttpMethod.Post, path(inn + "plain"), text)),
-                        c => Task.FromResult(Same(c, r, e, what, ip, iv, input)));
-                }
-                failed ??= f2;
-            }
-            // 3. binding, the row's http.binding
-            var unbindable = e.Wrapped == "own-record-class" && bind != "body" ? "a record class"
-                           : e.Wrapped == "NodaTime.Instant" && name == "minimal" && bind != "body" ? "Instant in a minimal API" : null;
-            if (unbindable is not null)
-            {
-                // No sentence cites it: the wrapped type is not bound from text either, so neither side has an endpoint and there is no twin.
-                r.Check(obligation, Baseline.Twin, c => c.Inconclusive($"{name} bind {bind}: {unbindable} is not bound from text, the wrapped type neither"));
-                continue;
-            }
-            if (bind == "body" && ownVo)
-            {
-                // "Your own converter wins": the application's converter reads the body, not the twin's JSON.
-                r.Check(obligation, Baseline.Twin, c => c.Inapplicable(Cite.Docs("src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says"), $"{name} bind body"));
-                continue;
-            }
-            var valid = Hx.BindText(e, plainSample);
-            var refused = e.Refused() is { } rf ? Hx.BindText(e, rf) : null;
-            async Task<Hx.Wire> B(WebApplication host, string which, string txt, string w)
-            {
-                var enc = Uri.EscapeDataString(txt);
-                return bind switch
-                {
-                    "route" => await Hx.Get(host, path(bindPre + "route/" + w + "/" + enc)),
-                    "query" => await Hx.Get(host, path(bindPre + "query/" + w + "?v=" + enc)),
-                    "as-parameters" => await Hx.Get(host, path(bindPre + "params/" + w + "?v=" + enc)),
-                    "header" => await Hx.Send(host, HttpMethod.Get, path(bindPre + "header/" + w), header: ("v", txt)),
-                    "form" => await Hx.Send(host, HttpMethod.Post, path(bindPre + "form/" + w), "v=" + enc, "application/x-www-form-urlencoded"),
-                    _ => await Hx.Send(host, HttpMethod.Post, path(bindPre + "body/" + w),
-                        which == "valid" ? JsonSerializer.Serialize(plainSample, e.Plain, jopts) : which == "refused" ? JsonSerializer.Serialize(e.Refused(), e.Plain, jopts) : JsonSerializer.Serialize(txt)),
-                };
-            }
-            // Both sides are mapped for every binding they reach here: a 404 is the harness's routing, never a binding result. Counted as
-            // "plain unbindable", a plain route mapped under another name went unnoticed.
-            static string? Routed(string name, string bind, Hx.Wire bp, Hx.Wire bv) =>
-                bp.Status == HttpStatusCode.NotFound || bv.Status == HttpStatusCode.NotFound
-                    ? $"harness: {name} bind {bind} has no endpoint (plain {(int)bp.Status}, value object {(int)bv.Status})" : null;
-            // A text a route segment cannot carry as it is ('/', ':', '?', '#'): escaped, it arrives as other text ('%2F' stays), so the value
-            // bound is not the one sent. A limit of the harness, which no sentence cites: the check cannot tell.
-            bool Unsafe(string txt) => bind == "route" && (txt.Contains('/') || txt.Contains(':') || txt.Contains('?') || txt.Contains('#'));
-            string? Unplaceable(Check c, string txt) => c.Inconclusive($"{name} bind route: the text {txt} cannot be carried by a route segment as it is");
-            string? f3;
-            if (Unsafe(valid)) f3 = r.Check(obligation, Baseline.Twin, c => Unplaceable(c, valid));
-            else
-            {
-                var bp = await B(app, "valid", valid, "plain"); var bv = await B(app, "valid", valid, "vo");
-                r.Log.AppendLine($"{name} bind {bind} valid text={valid}: plain {(int)bp.Status} {Cut(bp.Body)} {bp.Thrown} | vo {(int)bv.Status} {Cut(bv.Body)} {bv.Thrown}");
-                f3 = Routed(name, bind, bp, bv) is { } unrouted
-                    ? r.Check(obligation, Baseline.Twin, _ => unrouted)
-                    : await Wire(r, e, obligation, Baseline.Twin, name + " bind " + bind, bp, bv, () => one.Ask(h => B(h, "valid", valid, "plain")),
-                        c => Task.FromResult(Same(c, r, e, name + " bind " + bind, bp, bv)));
-            }
-            failed ??= f3;
-            if (refused is null) continue;
-            // README "Binding" (AspNetCore): a value Create rejects gets a 400, the one set of rules.
-            var against = Baseline.Docs("src/CodoMetis.TypeKit.AspNetCore/README.md#binding");
-            if (Unsafe(refused)) { failed ??= r.Check(obligation, against, c => Unplaceable(c, refused)); continue; }
-            var rp = await B(app, "refused", refused, "plain"); var rv = await B(app, "refused", refused, "vo");
-            r.Log.AppendLine($"{name} bind {bind} refused text={refused}: plain {(int)rp.Status} {Cut(rp.Body)} {rp.Thrown} | vo {(int)rv.Status} {Cut(rv.Body)} {rv.Thrown}");
-            if (Routed(name, bind, rp, rv) is { } unrouted2) { failed ??= r.Check(obligation, against, _ => unrouted2); continue; }
-            // Side (1) of a refused binding: the twin on the host without TypeKit, refused a binding too, as MVC refuses a text the wrapped
-            // type cannot read. Where the value object's refusal could not be answered (a 500, which MVC's 400 under a source-generated
-            // context that does not list ValidationProblemDetails is, KB-041), the twin's refused binding is side (1): read from KB-041's
-            // fixture where it covers the row, else asked of the host without TypeKit.
-            Sides.Side? framework = null;
-            if (rv.Ex is { } refusal && Unreadable(e) is { } unreadable)
-            {
-                var settings = Sides.Settings(r, ("endpoint", name == "mvc" ? "mvc-api-controller" : "minimal"), ("binding", "fails"));
-                if (Sides.Covered(r, "KB-041", settings) is { Kind: FactAnswer.Exception } answer)
-                    framework = new(new(name + " bind " + bind + " refused", null, Status: 500, FixtureRefusal: (string?)answer.Value["type"]), Baseline.Fact("KB-041"), $"KB-041 {answer.Id}: a binding MVC refuses, under a source-generated context");
-                else if (await one.Ask(h => B(h, "unreadable", unreadable, "plain")) is { } twin)
-                    framework = Sides.Measured(twin.Side(name + " bind " + bind + " refused"), $"the twin on a host without TypeKit, sent {unreadable}");
-            }
-            var f4 = await Sides.Check(r, obligation, against, framework, rv.Side(name + " bind " + bind + " refused"), null, null, async c =>
-            {
-                if ((int)rp.Status is not (>= 200 and < 300)) return c.Inconclusive($"{name} bind {bind}: the wrapped type refuses the value Create refuses too ({(int)rp.Status})");
-                if (r.Is("json.ReferenceHandler", "Preserve") && e.Wrapped == "own-record-class") return c.Refused(Cite.Docs("src/CodoMetis.TypeKit.Generators/README.md#json"), "bind");
-                // README "What TypeKit guarantees": StoredJsonConverterFactory reads JSON the application stored itself, without validation.
-                if (bind == "body" && r.Is("json.Converters", "StoredJsonConverterFactory")) return c.Inapplicable(Cite.Docs("README.md#what-typekit-guarantees"), "bind body");
-                // KB-037: under MaxValidationDepth=1 MVC runs an action whose parameter it could not bind, with the parameter at its default. The
-                // value object must hold its default then, never the refused value; side (1), the twin sent a text it cannot read, shows the
-                // framework doing the same: read from KB-037's fixture where it covers the row, else asked of the host without TypeKit.
-                if (name == "mvc" && r.Is("mvc.MaxValidationDepth", "1") && (int)rv.Status is >= 200 and < 300)
-                {
-                    if (DefaultBody(app, e.Vo) is var voDefault && !HoldsDefault(rv, voDefault))
-                        return $"{name} bind {bind}: validated value object bound the refused value (status {(int)rv.Status}) {Cut(rv.Body)}, not its default ({(voDefault is null ? "204" : "200 " + Cut(voDefault))})";
-                    if (Unreadable(e) is not { } text)
-                        return c.Inapplicable(Cite.Fact("KB-037"), $"{name} bind {bind}: the value object holds its default; any text binds the wrapped type, so no twin shows it");
-                    Hx.Wire? bt;
-                    if (Sides.Covered(r, "KB-037", Sides.Settings(r, ("text", text))) is { Kind: FactAnswer.Status } answer)
-                        bt = new((HttpStatusCode)(int)answer.Value["status"]!, (string?)answer.Value["body"] ?? "");
-                    else bt = await one.Ask(h => B(h, "unreadable", text, "plain"));
-                    if (bt is null) return c.Inconclusive($"{name} bind {bind}: the value object holds its default (KB-037); no host without TypeKit to show the wrapped type's ({one.Down})");
-                    r.Log.AppendLine($"{name} bind {bind} unreadable text={text}: plain {(int)bt.Status} {Cut(bt.Body)} {bt.Thrown}");
-                    if (HoldsDefault(bt, DefaultBody(app, e.Plain)))
-                        return c.Inapplicable(Cite.Fact("KB-037"), $"{name} bind {bind}: both hold their default, the wrapped type for a text it cannot read");
-                    if ((int)bt.Status is >= 400 and < 500)
-                        return $"{name} bind {bind}: the value object answered {(int)rv.Status} holding its default, where the wrapped type rejects a text it cannot read ({(int)bt.Status})";
-                    // KB-037's class from the query: the validator throws at the twin's property, and the value object, written by a
-                    // converter of its own, is no class it walks
-                    return c.Inconclusive($"{name} bind {bind}: the value object holds its default (KB-037); the wrapped type answered {(int)bt.Status} {Cut(bt.Body)} {bt.Thrown}");
-                }
-                // a refused value must not bind (the one set of rules), except where the application skips validation on purpose
-                if ((int)rv.Status is >= 200 and < 300) return $"{name} bind {bind}: validated value object bound the refused value (status {(int)rv.Status}) {Cut(rv.Body)}";
-                if ((int)rv.Status != 400) return $"{name} bind {bind}: refused value answered {(int)rv.Status}, expected 400: {Cut(rv.Body)} {rv.Thrown}";
-                c.Note(NoteKeys.Compared, $"{name} bind {bind}: the refused value answered 400");
-                return null;
-            });
-            failed ??= f4;
-        }
-        // 4. schema parity
-        if (schema) { var f5 = await r.Check(obligation, Baseline.Twin, async c => await SchemaParity(app, one, alone, r, e, c)); failed ??= f5; }
-        return failed;
-    }
-
-    /// <summary>
-    /// The schema parity alone, on the same host as <see cref="Run"/>: claim C21's check (C21OpenapiSchemaParityProbe), which BaseProbe leaves
-    /// out of its calibration, run once for each of the row's <paramref name="obligations"/> against the twin. C21 promises the schema ASP.NET
-    /// Core publishes for the underlying type, so side (1), the same host without TypeKit, is started on every row (Sides.Unconditional).
-    /// Every check runs; the first failure is returned.
-    /// </summary>
-    public static async Task<string?> Schema(Row r, Entry e, IEnumerable<string> obligations)
-    {
-        WebApplication? app = null; string? down = null;
-        try { app = await Hx.Start(r, e, new HostCfg { FaultControllers = false, MapBlanketMapping = false }); }
-        catch (Exception ex) when (ex is not Sides.InputsNotEquivalent) { down = "schema host did not start: " + ex.GetType().Name + ": " + Cut(ex.Message); }
-        await using var _ = app;
-        await using var one = new SideOne(r, e, "plain");
-        await using var alone = new SideOne(r, e, "both");
-        var list = obligations.ToList();
-        if (down is null && list.Any(o => Sides.Unconditional(r, o))) await one.Host();
-        string? failed = null;
-        foreach (var obligation in list)
-        {
-            var f = await r.Check(obligation, Baseline.Twin, c => down is not null ? Task.FromResult<string?>(down) : SchemaParity(app!, one, alone, r, e, c));
-            failed ??= f;
-        }
-        return failed;
-    }
-
-    /// <summary>
-    /// Where either side is a null-or-reference (<c>oneOf [null, component]</c>), both sides there in one spelling:
-    /// the null as <c>x-null</c> beside the schema, wherever the side spelled it (<c>type [null, X]</c>, <c>nullable</c>,
-    /// <c>x-nullable</c>, a null in an enum, or the null-or itself). A shared component cannot hold the null of one
-    /// position, so a nullable value object that is one is null around its reference, where ASP.NET writes the
-    /// wrapped type's null inside its inline schema (decision 36: "as a container's element (`oneOf: [null,
-    /// component]`, ASP.NET's own form)"; AspNetCore README: "A nullable element (`List&lt;Quantity?&gt;`,
-    /// `Dictionary&lt;string, Quantity?&gt;`) is the component or null, as a nullable property is."). Whether a side
-    /// admits null is kept; everywhere else, inlined schemas included, the comparison stays byte for byte (rows 170,
-    /// 196 and 215 of C21). Returns both sides without the marks <see cref="Hx.Deep"/> put on resolved references.
-    /// </summary>
-    static (string, string, bool) NullAroundReferences(string sp, string sv)
-    {
-        var around = false;
-        static bool IsNull(JsonNode? a) => a is JsonObject ao && (ao["type"]?.ToJsonString() == "\"null\"" || ao["enum"]?.ToJsonString() == "[null]");
-        static bool NullOrReference(JsonNode? n) =>
-            n is JsonObject o && o["oneOf"] is JsonArray alts && alts.Count == 2 && alts.Any(IsNull) && alts.Any(a => a is JsonObject ao && ao.ContainsKey(Hx.ResolvedReference));
-        static JsonNode? Unmark(JsonNode? n) => n switch
-        {
-            JsonObject o => new JsonObject(o.Where(kv => kv.Key != Hx.ResolvedReference).Select(kv => KeyValuePair.Create(kv.Key, Unmark(kv.Value)))),
-            JsonArray a => new JsonArray(a.Select(Unmark).ToArray()),
-            _ => n?.DeepClone(),
-        };
-        static JsonNode? OneSpelling(JsonNode? n)
-        {
-            switch (n)
-            {
-                case JsonObject o when o["oneOf"] is JsonArray alts && alts.Count == 2 && alts.Any(IsNull) && alts.FirstOrDefault(a => !IsNull(a)) is JsonObject keep:
-                {
-                    var c = (JsonObject)OneSpelling(keep)!; c["x-null"] = true; return Sorted(c);
-                }
-                case JsonObject o:
-                {
-                    var c = new JsonObject();
-                    foreach (var (k, v) in o)
-                    {
-                        if (k == Hx.ResolvedReference) continue;
-                        if (k is "nullable" or "x-nullable") { if (v?.GetValue<bool>() == true) c["x-null"] = true; continue; }
-                        if (k == "allOf" && v is JsonArray aa && aa.Count == 1 && aa[0] is JsonObject a0 && a0.Count == 1 && a0.ContainsKey("x-nullable")) { c["x-null"] = true; continue; }
-                        if (k == "type" && v is JsonArray ta && ta.Any(x => x?.GetValue<string>() == "null"))
-                        {
-                            var f = ta.Where(x => x?.GetValue<string>() != "null").ToList();
-                            c["type"] = f.Count == 1 ? f[0]!.DeepClone() : new JsonArray(f.Select(x => x!.DeepClone()).ToArray()); c["x-null"] = true; continue;
-                        }
-                        if (k == "type" && v?.ToJsonString() == "\"null\"") { c["x-null"] = true; continue; }
-                        if (k == "enum" && v is JsonArray en && en.Any(x => x is null)) { c["enum"] = new JsonArray(en.Where(x => x is not null).Select(x => x!.DeepClone()).ToArray()); c["x-null"] = true; continue; }
-                        if (k == "anyOf" && v is JsonArray any && any.Any(IsNull)) { c["anyOf"] = new JsonArray(any.Where(x => !IsNull(x)).Select(OneSpelling).ToArray()); c["x-null"] = true; continue; }
-                        c[k] = OneSpelling(v);
-                    }
-                    return Sorted(c);
-                }
-                case JsonArray a: return new JsonArray(a.Select(OneSpelling).ToArray());
-                default: return n?.DeepClone();
-            }
-        }
-        static JsonObject Sorted(JsonObject o) => new(o.OrderBy(kv => kv.Key, StringComparer.Ordinal).Select(kv => KeyValuePair.Create(kv.Key, kv.Value?.DeepClone())));
-        (JsonNode?, JsonNode?) Walk(JsonNode? p, JsonNode? v)
-        {
-            if (NullOrReference(p) || NullOrReference(v)) { around = true; return (OneSpelling(p), OneSpelling(v)); }
-            if (p is JsonObject po && v is JsonObject vo)
-            {
-                var cp = new JsonObject(); var cv = new JsonObject();
-                foreach (var k in po.Select(kv => kv.Key).Union(vo.Select(kv => kv.Key)).Where(k => k != Hx.ResolvedReference).Order(StringComparer.Ordinal))
-                {
-                    if (!po.ContainsKey(k)) { cv[k] = Unmark(vo[k]); continue; }
-                    if (!vo.ContainsKey(k)) { cp[k] = Unmark(po[k]); continue; }
-                    var (a, b) = Walk(po[k], vo[k]); cp[k] = a; cv[k] = b;
-                }
-                return (cp, cv);
-            }
-            if (p is JsonArray pa && v is JsonArray va && pa.Count == va.Count)
-            {
-                var cp = new JsonArray(); var cv = new JsonArray();
-                for (var i = 0; i < pa.Count; i++) { var (a, b) = Walk(pa[i], va[i]); cp.Add(a); cv.Add(b); }
-                return (cp, cv);
-            }
-            return (Unmark(p), Unmark(v));
-        }
-        var (np, nv) = Walk(JsonNode.Parse(sp), JsonNode.Parse(sv));
-        return (np?.ToJsonString() ?? "null", nv?.ToJsonString() ?? "null", around);
-    }
-
-    /// <summary>
-    /// The component two operations of one document both refer to at the same place (a parameter's or the body's schema), where one
-    /// substitutes the value object for the twin: two types under one name, told by the references' structure.
-    /// </summary>
-    static string? SharedComponent(JsonNode twin, JsonNode valueObject)
-    {
-        static IEnumerable<(string, string)> References(JsonNode op)
-        {
-            if (op["parameters"] is JsonArray ps)
-                for (var i = 0; i < ps.Count; i++)
-                    if (ps[i]?["schema"]?["$ref"]?.GetValue<string>() is { } p) yield return ($"parameter {i}", p);
-            if (op["requestBody"]?["content"] is JsonObject content)
-                foreach (var (media, body) in content)
-                    if (body?["schema"]?["$ref"]?.GetValue<string>() is { } b) yield return ($"body {media}", b);
-        }
-        var twins = References(twin).ToDictionary(x => x.Item1, x => x.Item2);
-        return References(valueObject).FirstOrDefault(x => twins.TryGetValue(x.Item1, out var t) && t == x.Item2).Item2;
-    }
-
-    /// <summary>A schema that is the OpenAPI 2.0 null flag and nothing else: <c>{"allOf":[{"x-nullable":true}]}</c>.</summary>
-    static bool OnlyTheNullFlag(JsonObject o) =>
-        o.Count == 1 && o["allOf"] is JsonArray { Count: 1 } all && all[0] is JsonObject { Count: 1 } flag && flag["x-nullable"]?.GetValueKind() == JsonValueKind.True;
-
-    /// <summary>
-    /// The OpenAPI 2.0 null flag with the wrapped type's <c>format</c> beside it and nothing else, <c>{"format":"uri","allOf":[{"x-nullable":true}]}</c>:
-    /// a nullable component's property, which TypeKit gives the wrapped type's format (KB-026).
-    /// </summary>
-    static bool TheNullFlagBeside(JsonObject o) =>
-        o.ContainsKey("format") && o.Count == 2 && OnlyTheNullFlag(new JsonObject { ["allOf"] = o["allOf"]?.DeepClone() });
-
-    /// <summary>The keys of a difference up to the property it lies in (<c>…, properties, P</c>), or null where it lies in none.</summary>
-    static IReadOnlyList<string>? PropertyAt(IReadOnlyList<string> keys)
-    {
-        for (var i = keys.Count - 2; i >= 0; i--)
-            if (keys[i] == "properties") return [.. keys.Take(i + 2)];
-        return null;
-    }
-
-    /// <summary>
-    /// OpenAPI 2.0's nullable property of a component (KB-026): <c>allOf: [{x-nullable: true}]</c>, without the reference and so without a
-    /// type, beside what TypeKit kept of the wrapped type (a <c>format</c>).
-    /// </summary>
-    static bool TheNullFlagWithoutItsReference(JsonObject o) =>
-        o["allOf"] is JsonArray { Count: 1 } all && all[0] is JsonObject { Count: 1 } flag && flag["x-nullable"]?.GetValueKind() == JsonValueKind.True
-        && !o.ContainsKey("$ref") && !o.ContainsKey(Hx.ResolvedReference) && !o.ContainsKey("type");
-
-    /// <summary>
-    /// A body whose schema is its format and its null alone, <c>{"schema": {"format": "int32", "allOf": [{"x-nullable": true}]}}</c>, or its null
-    /// alone where the type has no format, anywhere in an operation: told by its structure (KB-001).
-    /// </summary>
-    static bool OnlyItsNull(JsonNode? n) => n switch
-    {
-        JsonObject o => o["schema"] is JsonObject schema && schema.All(kv => kv.Key is "allOf" or "format")
-                        && schema["allOf"] is JsonArray { Count: 1 } all && all[0] is JsonObject { Count: 1 } flag
-                        && flag["x-nullable"]?.GetValueKind() == JsonValueKind.True
-                        || o.Any(kv => OnlyItsNull(kv.Value)),
-        JsonArray a => a.Any(OnlyItsNull),
-        _ => false,
-    };
-
-    /// <summary>
-    /// The value object's schema (3) against the wrapped twin's (2) at each endpoint pair, three-sided (Sides): the twin's schema is held to
-    /// the one ASP.NET publishes on the same host without TypeKit (1), where that host writes a document; and where the value object's schema
-    /// differs from the twin's, side (1)'s document at the same path tells whether ASP.NET alone writes that difference.
-    /// </summary>
-    static async Task<string?> SchemaParity(WebApplication app, SideOne one, SideOne alone, Row r, Entry e, Check c)
-    {
-        JsonNode doc;
-        try { doc = (await Hx.Doc(app))!; }
-        catch (Exception ex)
-        {
-            // The baseline is ASP.NET alone on the same host: a document it refuses too has no schema to compare (decision 99).
-            return await Hx.DocRefusedByAspNetAlone(r, e, new HostCfg { FaultControllers = false, MapBlanketMapping = false }, ex);
-        }
-        // docs/json.md "Describing what a converter writes": ASP.NET drops items/additionalProperties of a converter it cannot see into, the value
-        // object's schema is the underlying type's; and the application's converter for the value object describes it as that converter says.
-        // C21 declares both on every obligation (claims.json inapplicable), so Row.Check records them before this body runs and no row of
-        // C21 is generated with them; these lines hold for the schema half run under another claim (ShrinkProbe's baseline).
-        if (r.Is("json.Converters", "own-for-wrapped")) return c.Inapplicable(Cite.NotPromised("own-converter-for-the-wrapped-type"));
-        if (r.Is("json.Converters", "own-for-value-object")) return c.Inapplicable(Cite.NotPromised("own-converter-for-the-value-object"));
-        // side (1): the document ASP.NET writes for the twin's endpoints without TypeKit, where it writes one; and, asked only where the value
-        // object's schema differs from the twin's, the one it writes for both sides' endpoints, for the value object's position
-        async Task<JsonNode?> Document(SideOne host)
-        {
-            if (await host.Host() is not { } h) return null;
-            try { return await Hx.Doc(h); }
-            catch (Exception x) { r.Log.AppendLine("side (1) document refused: " + x.GetType().Name + ": " + Cut(x.Message)); return null; }
-        }
-        var doc1 = await Document(one);
-        JsonNode? Op(JsonNode d, string path, string method) => d["paths"]?[path]?[method];
-        // only the schemas are compared (the claim is about the schema); whether a parameter or body is required follows the .NET type's nullability
-        JsonNode? Schemas(JsonNode? n)
-        {
-            switch (n)
-            {
-                case JsonArray a: { var c = new JsonArray(); foreach (var x in a) c.Add(Schemas(x)); return c; }
-                case JsonObject o:
-                {
-                    var c = new JsonObject();
-                    foreach (var kv in o.OrderBy(k => k.Key, StringComparer.Ordinal))
-                    {
-                        if (kv.Key == "required" && kv.Value is JsonValue) continue;   // parameter / body / old-style flags
-                        c[kv.Key] = Schemas(kv.Value);
-                    }
-                    return c;
-                }
-                default: return n?.DeepClone();
-            }
-        }
-        string Sig(JsonNode d, JsonNode op)
-        {
-            var o = new JsonObject();
-            o["parameters"] = Schemas(Hx.Deep(d, op["parameters"], mark: true));
-            o["requestBody"] = Schemas(Hx.Deep(d, op["requestBody"], mark: true));
-            o["ok"] = Schemas(Hx.Deep(d, op["responses"]?["200"], mark: true));
-            return o.ToJsonString();
-        }
-        // The media types of an operation's request body and 200 response, each named by where it is
-        static HashSet<string> MediaTypes(JsonNode op) =>
-        [
-            .. (op["requestBody"]?["content"] as JsonObject ?? []).Select(kv => "requestBody:" + kv.Key),
-            .. (op["responses"]?["200"]?["content"] as JsonObject ?? []).Select(kv => "ok:" + kv.Key),
-        ];
-        // A signature with only the request body's and the 200 response's media types given
-        static string UnderMediaTypes(string sig, IEnumerable<string> media)
-        {
-            var keep = media.ToHashSet();
-            var o = JsonNode.Parse(sig)!.AsObject();
-            foreach (var (part, name) in new[] { ("requestBody", "requestBody"), ("ok", "ok") })
-                if (o[part]?["content"] is JsonObject content)
-                    foreach (var key in content.Select(kv => kv.Key).ToList())
-                        if (!keep.Contains(name + ":" + key)) content.Remove(key);
-            return o.ToJsonString();
-        }
-        var checks = new List<(string, string)>();
-        if (Hx.HasMinimal(r)) { checks.Add((Hx.M(r, "/schema/plain"), Hx.M(r, "/schema/vo"))); }
-        if (Hx.HasMvc(r))
-        {
-            var bind = r["http.binding"] switch { "route" => "route", "query" => "query", "header" => "header", "form" => "form", "as-parameters" => "params", _ => "body" };
-            var sfx = bind == "route" ? "/{v}" : "";
-            checks.Add((Hx.C(r, $"/mvc/bind/{bind}/plain{sfx}"), Hx.C(r, $"/mvc/bind/{bind}/vo{sfx}")));
-        }
-        if (Hx.HasMinimal(r))
-        {
-            var bind = r["http.binding"] switch { "route" => "route", "query" => "query", "header" => "header", "form" => "form", "as-parameters" => "params", _ => "body" };
-            // route: /bind/route/{which}/{v}
-            checks.Add((bind == "route" ? Hx.M(r, "/bind/route/plain/{v}") : Hx.M(r, $"/bind/{bind}/plain"), bind == "route" ? Hx.M(r, "/bind/route/vo/{v}") : Hx.M(r, $"/bind/{bind}/vo")));
-        }
-        // The inputs of the two sides, apart from the type substituted: where each value is bound, under which
-        // name, and whether it is required. They must agree before the schemas are compared; otherwise the
-        // comparison measures the harness (G1: a nullable class value object against a required int).
-        string Inputs(JsonNode op)
-        {
-            var parts = new List<string>();
-            if (op["parameters"] is JsonArray ps)
-                foreach (var prm in ps) { var q = Hx.Deep(doc, prm); parts.Add($"{q?["in"]}:{q?["name"]}:required={q?["required"]?.ToJsonString() ?? "false"}"); }
-            if (Hx.Deep(doc, op["requestBody"]) is JsonObject rb) parts.Add($"body:required={rb["required"]?.ToJsonString() ?? "false"}");
-            return string.Join(",", parts);
-        }
-        foreach (var (pp0, vp) in checks)
-        {
-            var method = pp0.Contains("/schema/") || pp0.Contains("/body/") || pp0.Contains("/form/") ? "post" : "get";
-            // Like with like from the start: the twin is the wrapped type at the value object's nullability (shapes.cs), so a class
-            // value object over a struct faces the struct made nullable, at every endpoint (row 384 of C07: a record class over TimeOnly,
-            // optional, against TimeOnly?).
-            var pp = pp0;
-            var po = Op(doc, pp, method); var vo = Op(doc, vp, method);
-            if (po is null)
-            {
-                // Mapped for bodies only (a record class, Instant in a minimal API): neither side is there.
-                if (vo is not null) return $"harness: the value object's {method} {vp} is documented, its plain twin is not (missing {method} {pp})";
-                c.Note(NoteKeys.SchemaNeitherSideDocumented, $"missing {method} {pp}"); continue;
-            }
-            if (vo is null) return $"missing {method} {vp}";
-            // The twin's and the value object's shapes are two .NET types; one component name for both (an id the row's CreateSchemaReferenceId
-            // makes alike for both, such as an array of a generic type) holds one schema for the two, so the document cannot tell them apart.
-            if (SharedComponent(po, vo) is { } shared)
-            { c.Inconclusive($"{pp} vs {vp}: the twin's and the value object's shapes are one component, {shared}, in the document: nothing to compare"); continue; }
-            // (2) held to (1): the twin's schema is the one ASP.NET publishes on the same host without TypeKit, but where the twin itself
-            // holds one of TypeKit's types (a Patch), which no host without TypeKit describes
-            var po1 = doc1 is null ? null : Op(doc1, pp, method);
-            var twinHoldsTypeKit = pp.Contains("/schema/") && Sides.HoldsTypeKit(Twin(r, e).Declared);
-            if (po1 is not null && !twinHoldsTypeKit && Sig(doc1!, po1) is var s1 && Sig(doc, po) is var s2 && s1 != s2)
-                return $"schema of the wrapped type at {pp}: TypeKit changed the wrapped type's schema, at {FirstDifference(JsonNode.Parse(s1), JsonNode.Parse(s2), "$")} (without TypeKit, then with it)";
-            if (Inputs(po) is var ip && Inputs(vo) is var iv && ip != iv)
-            {
-                // No twin of the wrapped type at the value object's nullability here (a struct value object over a class, which no plain
-                // type mirrors), or a wrapped record class, which ASP.NET binds by its properties where the value object is one value: the
-                // two sides are not alike, and no sentence cites it, so the check cannot tell.
-                if (Make.AdmitsNull(e.Vo) != Make.AdmitsNull(e.Plain))
-                    c.Inconclusive($"{pp} vs {vp}: no twin of {e.Plain.Name} at the value object's nullability, the inputs differ: wrapped [{ip}] vs value object [{iv}]");
-                else if (e.Wrapped == "own-record-class")
-                    c.Inconclusive($"{pp} vs {vp}: the wrapped record class is bound by its properties, the value object as one value, the inputs differ: wrapped [{ip}] vs value object [{iv}]");
-                else r.Outcome("harness-error", $"inputs not equivalent for {pp} vs {vp}: wrapped [{ip}] vs value object [{iv}]");
-                continue;
-            }
-            var sp = Sig(doc, po); var sv = Sig(doc, vo);
-            // MVC lists a body's and a response's media types by what its formatters can read and write of the .NET type, and the twin
-            // and the value object are two types (row 38 of C21: XmlSerializerInputFormatter reads a record class value object, not the
-            // Uri it wraps). Where the lists differ and side (1), ASP.NET alone with both sides' endpoints, lists each side's the same,
-            // the formatters decided it, not TypeKit: the schemas are compared under the media types both list. Otherwise as they are.
-            if (MediaTypes(po) is var mp && MediaTypes(vo) is var mv && !mp.SetEquals(mv)
-                && await Document(alone) is { } both0 && Op(both0, pp, method) is { } pAlone && Op(both0, vp, method) is { } vAlone
-                && MediaTypes(pAlone).SetEquals(mp) && MediaTypes(vAlone).SetEquals(mv))
-            {
-                r.Log.AppendLine($"{pp} vs {vp}: media types the formatters list differ alike without TypeKit, compared under [{string.Join(", ", mp.Intersect(mv))}]");
-                sp = UnderMediaTypes(sp, mp.Intersect(mv)); sv = UnderMediaTypes(sv, mp.Intersect(mv));
-            }
-            if (NullAroundReferences(sp, sv) is var (np, nv, around)) { sp = np; sv = nv; if (around) c.Note(NoteKeys.SchemaNullAroundReferenceNormalised); }
-            if (sp != sv && Make.AdmitsNull(e.Vo) && Make.AdmitsNull(e.Plain) && e.Vo.IsValueType != e.Plain.IsValueType)
-            {
-                // Both sides nullable alike, one a class and the other a struct made nullable (a class value object and its nullable twin, or
-                // a nullable struct value object and a wrapped class); OpenAPI 3.x spells nullability two ways (oneOf [null, X] or type [null, X]).
-                sp = Hx.NoNull(JsonNode.Parse(sp))!.ToJsonString(); sv = Hx.NoNull(JsonNode.Parse(sv))!.ToJsonString();
-                c.Note(NoteKeys.SchemaNullableSpellingsNormalised);
-            }
-            if (sp != sv && Make.AdmitsNull(e.Vo) != Make.AdmitsNull(e.Plain))
-            {
-                // A struct value object over a class, whose twin is nullable by being a class where the value object is not (no plain
-                // type mirrors it); the markers go, the rest of the schema must agree.
-                sp = Hx.NoNull(JsonNode.Parse(sp))!.ToJsonString(); sv = Hx.NoNull(JsonNode.Parse(sv))!.ToJsonString();
-                c.Note(NoteKeys.SchemaClassVoNullabilityNormalised);
-            }
-            if (sp != sv)
-            {
-                if (e.Kind == "closed-set") { c.Inapplicable(Cite.NotPromised("a-closed-set-is-a-string-enum"), "schema"); continue; }
-                // A form binds the wrapped record class by its properties and the value object otherwise, as the parameters above: the two
-                // sides' fields are not alike, and no sentence cites it, so the check cannot tell (row 62 of C21).
-                if (e.Wrapped == "own-record-class" && pp.Contains("/form/") && method == "post")
-                { c.Inconclusive($"{pp} vs {vp}: the wrapped record class is bound from a form by its properties, the value object otherwise: the fields differ"); continue; }
-                var d = Difference(JsonNode.Parse(sp), JsonNode.Parse(sv), "$");
-                // Decision 36: a nullable value object admits null wherever it appears, where ASP.NET may write the twin's nullable type without
-                // it (the items of a list of double? under AllowNamedFloatingPointLiterals, row 216 of C21; the twin is held to side (1) above).
-                // Only that null differs: the value object admits it where the twin does not, and the schemas are otherwise the same.
-                if (Make.AdmitsNull(e.Vo) && d.Keys is [.., "x-null"] && d.P is null && d.V?.GetValueKind() == JsonValueKind.True
-                    && JsonNode.DeepEquals(Hx.NoNull(JsonNode.Parse(sp)), Hx.NoNull(JsonNode.Parse(sv))))
-                { c.Inapplicable(Cite.NotPromised("a-nullable-value-object-admits-null"), d.Path); continue; }
-                var openApi2 = r.Is("openapi.OpenApiVersion", "OpenApi2_0");
-                // Side (1) at the same path: the twin's and the value object's operations in the document ASP.NET writes without TypeKit.
-                var twin1 = po1 is null ? null : JsonNode.Parse(Sig(doc1!, po1));
-                var both1 = openApi2 && d.P is null && d.V is not null ? await Document(alone) : null;
-                var vo1 = both1 is null ? null : Op(both1, vp, method) is { } o1 ? JsonNode.Parse(Sig(both1, o1)) : null;
-                var vo3 = JsonNode.Parse(Sig(doc, vo));
-                // KB-026: OpenAPI 2.0 writes a nullable property of any component as allOf [{x-nullable: true}], without the reference, and a
-                // value object keeps a component of its own (not-promised openapi-2-nullable-component-loses-its-type; row 38 of C21). Side (1)
-                // shows it: without TypeKit, ASP.NET writes the value object's position at the same path the same, where the twin has nothing.
-                if (openApi2 && d.P is null && d.V is not null && At(vo1, d.Keys) is { } same1 && JsonNode.DeepEquals(same1, At(vo3, d.Keys)))
-                { c.Inapplicable(Cite.NotPromised("openapi-2-nullable-component-loses-its-type"), d.Path); continue; }
-                // The same, where the spellings of the null were normalised above, which takes the null flag out of the value object's
-                // schema and leaves it without what the 2.0 writer dropped with the reference: its type, its pattern (rows 386, 178, 181
-                // and 243 of C21: a nullable struct value object over Uri as a required-init property, and class value objects whose
-                // property admits null as a type parameter's or set through the constructor). Told by its structure: the value object's
-                // property is the null flag, alone or beside the wrapped type's format, and the twin's, which admits null, has that format.
-                if (openApi2 && PropertyAt(d.Keys) is { } property
-                    && At(vo3, property) is JsonObject flagged3 && (TheNullFlagBeside(flagged3) || OnlyTheNullFlag(flagged3))
-                    && At(JsonNode.Parse(Sig(doc, po)), property) is JsonObject typed2
-                    && (typed2["x-nullable"]?.GetValueKind() == JsonValueKind.True
-                        // or the twin is a component itself (a wrapped record class, row 444 of C21), whose reference ASP.NET's own rule
-                        // leaves without the null the value object admits (decision 36: a-nullable-value-object-admits-null)
-                        || typed2.ContainsKey(Hx.ResolvedReference) && Make.AdmitsNull(e.Vo))
-                    && JsonNode.DeepEquals(typed2["format"], flagged3["format"]))
-                { c.Inapplicable(Cite.NotPromised("openapi-2-nullable-component-loses-its-type"), d.Path); continue; }
-                // AspNetCore README "What the document says": a nullable element is the component or null, as a nullable property is, which
-                // OpenAPI 2.0 writes as allOf [{x-nullable: true}] without the reference (not-promised openapi-2-nullable-element-loses-its-type;
-                // row 358 of C21, a dictionary's value). ASP.NET alone drops a converter-backed element, so side (1) has nothing there; told by
-                // its structure, the value object's element is the null flag alone where the twin's admits null.
-                if (openApi2 && d.Keys is [.., "items" or "additionalProperties", "allOf"] && d.P is null
-                    && At(vo3, d.Keys.SkipLast(1)) is JsonObject element3 && OnlyTheNullFlag(element3)
-                    && At(JsonNode.Parse(Sig(doc, po)), d.Keys.SkipLast(1)) is JsonObject element2 && element2["x-nullable"]?.GetValueKind() == JsonValueKind.True)
-                { c.Inapplicable(Cite.NotPromised("openapi-2-nullable-element-loses-its-type"), d.Path); continue; }
-                // The same loss told by the row's axes, where side (1) cannot show it: a nullable value object that is a component is a
-                // nullable property wherever the serializer's contract says so (a get-only or a type parameter's property among them), where
-                // ASP.NET alone adds the null only for a settable annotated one. Its property is then the null flag without the reference,
-                // where the twin's keeps its type beside x-nullable.
-                if (openApi2 && Make.AdmitsNull(e.Vo) && !r.Is("openapi.CreateSchemaReferenceId", "null-inlines-all") && d.V is null
-                    && At(vo3, d.Keys.SkipLast(1)) is JsonObject lost && TheNullFlagWithoutItsReference(lost)
-                    && At(JsonNode.Parse(Sig(doc, po)), d.Keys.SkipLast(1)) is JsonObject kept && kept["x-nullable"]?.GetValueKind() == JsonValueKind.True)
-                { c.Inapplicable(Cite.NotPromised("openapi-2-nullable-component-loses-its-type"), d.Path); continue; }
-                // KB-001: OpenAPI 2.0 writes a nullable body of the wrapped value type as its format and allOf [{x-nullable: true}] alone (the
-                // null alone where it has no format, an enum), where a class value object's body in a minimal API is not nullable and keeps its
-                // schema (not-promised openapi-2-nullable-body-keeps-only-its-null; row 257, and rows 113 and 282 over TimeOnly and char). Side (1)
-                // shows it: without TypeKit, the twin's schema there is that format and that null alone.
-                // AspNetCore README "What the document says" (KB-026), seen from the twin: OpenAPI 2.0 writes a nullable property of any component,
-                // the twin's nullable enum among them, as allOf [{x-nullable: true}] without the reference, where the value object keeps its type.
-                // Side (1) shows it: without TypeKit, the twin's property there is that null alone.
-                if (openApi2 && d.P is null && d.V is not null && Make.AdmitsNull(e.Plain) && At(twin1, d.Keys.SkipLast(1)) is JsonObject t1 && OnlyTheNullFlag(t1))
-                { c.Inapplicable(Cite.Docs("src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says"), d.Path); continue; }
-                if (openApi2 && !e.Vo.IsValueType && Nullable.GetUnderlyingType(e.Plain) is not null && OnlyItsNull(twin1) && OnlyItsNull(JsonNode.Parse(Sig(doc, po))))
-                { c.Inapplicable(Cite.NotPromised("openapi-2-nullable-body-keeps-only-its-null"), pp); continue; }
-                // KB-027: the component ASP.NET makes for an enum written by name is the schema of the first use it meets, so a wrapped E?
-                // parameter lists null through E's component where E was first met nullable; the value object's parameter is the enum's
-                // content without it wherever the enum is a component (not-promised enum-component-is-its-first-use; row 285 of C21). Side (1)
-                // shows it: without TypeKit, the twin's parameter lists the same null, through the same resolved component.
-                // The same component met first as a nullable use lists that null for a property too, the twin's non-nullable one included
-                // (not-promised enum-component-lists-the-null-of-its-first-use; row 196 of C21, a polymorphic derived type's property).
-                if (d.Keys is [.., "enum"] && d.P is JsonArray we && d.V is JsonArray ve && we.Count == ve.Count + 1 && we[^1] is null
-                    && JsonNode.DeepEquals(new JsonArray(we.Take(ve.Count).Select(x => x?.DeepClone()).ToArray()), ve)
-                    && At(JsonNode.Parse(Sig(doc, po)), d.Keys.SkipLast(1)) is JsonObject held && held.ContainsKey(Hx.ResolvedReference)
-                    && At(twin1, d.Keys) is { } listed1 && JsonNode.DeepEquals(listed1, d.P))
-                {
-                    if (d.Keys is ["parameters", ..]) c.Inapplicable(Cite.NotPromised("enum-component-is-its-first-use"), vp);
-                    else c.Inapplicable(Cite.NotPromised("enum-component-lists-the-null-of-its-first-use"), vp);
-                    continue;
-                }
-                // AspNetCore README "A described type": ASP.NET cannot see through a converter it did not write, one a library registers for
-                // its own type among them, and drops a list's items and a dictionary's additionalProperties of that type, where the value
-                // object's element is put back (not-promised a-librarys-converter-for-the-wrapped-type; row 422 of C21, a list of Instant?).
-                // Side (1) shows it: without TypeKit, the twin's container has no element schema either.
-                if (e.Wrapped == "NodaTime.Instant" && d.Keys is [.., "items" or "additionalProperties"] && d.P is null && d.V is not null
-                    && twin1 is not null && At(twin1, d.Keys.SkipLast(1)) is JsonObject container1 && !container1.ContainsKey(d.Keys[^1]))
-                { c.Inapplicable(Cite.NotPromised("a-librarys-converter-for-the-wrapped-type"), d.Path); continue; }
-                return $"schema differs for {pp} vs {vp} at {FirstDifference(JsonNode.Parse(sp), JsonNode.Parse(sv), "$")}:\n  wrapped {Cut(sp)}\n  value object {Cut(sv)}";
-            }
-        }
-        return null;
-    }
-}
diff --git a/tools/probe/corpus/harness/HttpHost.cs b/tools/probe/corpus/harness/HttpHost.cs
deleted file mode 100644
index d37238fc..00000000
--- a/tools/probe/corpus/harness/HttpHost.cs
+++ /dev/null
@@ -1,438 +0,0 @@
-// The shared HTTP host: applies a row's json.*, openapi.*, mvc.* and http.* axes and the shape axes, then runs the baseline checks
-// (payload echo/in/binding parity, schema parity) that every http claim shares. Claim-specific scenarios plug in through HostCfg.
-using System.Net;
-using System.Net.Http.Headers;
-using System.Reflection;
-using System.Text;
-using System.Text.Json;
-using System.Text.Json.Nodes;
-using System.Text.Json.Serialization;
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.AspNetCore;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Routing;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.AspNetCore.Mvc.ApplicationModels;
-using Microsoft.AspNetCore.Mvc.ApplicationParts;
-using Microsoft.AspNetCore.Mvc.Controllers;
-using Microsoft.AspNetCore.Mvc.Formatters;
-using Microsoft.AspNetCore.Mvc.ModelBinding;
-using Microsoft.AspNetCore.Mvc.ModelBinding.Binders;
-using Microsoft.AspNetCore.Mvc.Routing;
-using Microsoft.AspNetCore.Mvc.ActionConstraints;
-using Microsoft.AspNetCore.OpenApi;
-using Microsoft.AspNetCore.TestHost;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-using Microsoft.OpenApi;
-using HttpJsonOptions = Microsoft.AspNetCore.Http.Json.JsonOptions;
-using MvcJsonOptions = Microsoft.AspNetCore.Mvc.JsonOptions;
-namespace Probes.Shapes;
-
-public sealed record Payload(Held Vo, Held Plain);
-
-public sealed class NullBinderProvider : IModelBinderProvider { public IModelBinder? GetBinder(ModelBinderProviderContext context) => null; }
-public sealed class PrefixConvention(string prefix) : IApplicationModelConvention
-{
-    public void Apply(ApplicationModel application)
-    {
-        foreach (var c in application.Controllers)
-            foreach (var s in c.Selectors.Concat(c.Actions.SelectMany(a => a.Selectors)))
-                if (s.AttributeRouteModel is { } m && !(m.Template?.StartsWith('/') ?? false))
-                    s.AttributeRouteModel = AttributeRouteModel.CombineAttributeRouteModel(new AttributeRouteModel(new RouteAttribute(prefix)), m);
-    }
-}
-
-/// <summary>
-/// http.host=controller-without-ApiController-visible: what ASP.NET documents as the switch beside [ApiController] and
-/// [ApiExplorerSettings], a convention that sets ApiExplorer.IsVisible, so the document checks reach those controllers.
-/// </summary>
-public sealed class VisibleToApiExplorer : IApplicationModelConvention
-{
-    public void Apply(ApplicationModel application)
-    {
-        foreach (var c in application.Controllers) c.ApiExplorer.IsVisible = true;
-    }
-}
-
-/// <summary>Closed generic controllers: one over the value object, one over the wrapped type; routes are set by BindConvention.</summary>
-[ApiController]
-public sealed class MvcBind<T> : ControllerBase
-{
-    public sealed class Q { public T V { get; set; } = default!; }
-    [ProducesResponseType(200), Route("_")]
-    public IActionResult RouteA([FromRoute(Name = "v")] T v) => new ObjectResult(v) { DeclaredType = typeof(T) };
-    [ProducesResponseType(200), Route("_")]
-    public IActionResult QueryA([FromQuery(Name = "v")] T v) => new ObjectResult(v) { DeclaredType = typeof(T) };
-    [ProducesResponseType(200), Route("_")]
-    public IActionResult HeaderA([FromHeader(Name = "v")] T v) => new ObjectResult(v) { DeclaredType = typeof(T) };
-    [ProducesResponseType(200), Route("_")]
-    public IActionResult BodyA([FromBody] T v) => new ObjectResult(v) { DeclaredType = typeof(T) };
-    [ProducesResponseType(200), Route("_")]
-    public IActionResult FormA([FromForm(Name = "v")] T v) => new ObjectResult(v) { DeclaredType = typeof(T) };
-    [ProducesResponseType(200), Route("_")]
-    public IActionResult ParamsA([FromQuery] Q q) => new ObjectResult(q.V) { DeclaredType = typeof(T) };
-}
-public sealed class BindConvention(Type vo, Type plain, string prefix) : IControllerModelConvention
-{
-    public void Apply(ControllerModel c)
-    {
-        if (!c.ControllerType.IsGenericType || c.ControllerType.GetGenericTypeDefinition() != typeof(MvcBind<>)) return;
-        var arg = c.ControllerType.GenericTypeArguments[0];
-        // By the entry's own types: the plain side is the twin, at the value object's nullability.
-        var which = arg == vo ? "vo" : arg == plain ? "plain" : throw new InvalidOperationException($"MvcBind<{arg.Name}> is neither side's");
-        foreach (var a in c.Actions)
-        {
-            var (kind, post) = a.ActionName switch { "RouteA" => ("route", false), "QueryA" => ("query", false), "HeaderA" => ("header", false), "BodyA" => ("body", true), "FormA" => ("form", true), _ => ("params", false) };
-            a.Selectors.Clear();
-            a.Selectors.Add(new SelectorModel
-            {
-                AttributeRouteModel = new AttributeRouteModel(new RouteAttribute($"{prefix}mvc/bind/{kind}/{which}" + (kind == "route" ? "/{v}" : ""))),
-                ActionConstraints = { new Microsoft.AspNetCore.Mvc.ActionConstraints.HttpMethodActionConstraint([post ? "POST" : "GET"]) },
-                EndpointMetadata = { new Microsoft.AspNetCore.Routing.HttpMethodMetadata([post ? "POST" : "GET"]) },
-            });
-        }
-    }
-}
-[ApiController]
-public sealed class MvcPayloadController(Payload payload) : ControllerBase
-{
-    [HttpGet("mvc/echo/{which}")]
-    public IActionResult Echo(string which) { var h = which == "vo" ? payload.Vo : payload.Plain; return new ObjectResult(h.Value) { DeclaredType = h.Declared }; }
-
-    [HttpPost("mvc/in/{which}")]
-    public async Task<IActionResult> In(string which)
-    {
-        var h = which == "vo" ? payload.Vo : payload.Plain;
-        var f = HttpContext.RequestServices.GetRequiredService<IOptions<MvcOptions>>().Value.InputFormatters.OfType<SystemTextJsonInputFormatter>().First();
-        var meta = HttpContext.RequestServices.GetRequiredService<IModelMetadataProvider>().GetMetadataForType(h.Declared);
-        var factory = HttpContext.RequestServices.GetRequiredService<Microsoft.AspNetCore.Mvc.Infrastructure.IHttpRequestStreamReaderFactory>();
-        var ctx = new InputFormatterContext(HttpContext, "model", ModelState, meta, factory.CreateReader);
-        var result = await f.ReadAsync(ctx);
-        if (result.HasError) return StatusCode(400);
-        return new ObjectResult(result.Model) { DeclaredType = h.Declared };
-    }
-}
-
-public sealed class HostCfg
-{
-    public Action<IEndpointRouteBuilder>? Minimal;
-    public Func<IEndpointConventionBuilder, IEndpointConventionBuilder>? ControllerBuilder;
-    public Action<IServiceCollection>? Services;
-    public string Mapping = "by-kind";
-    public bool Qualified;
-    public ListedLogs? Logs;
-    public Type[]? Controllers;          // null: the fault controllers of the host
-    public bool FaultControllers = true;
-    public bool Payload = true;          // payload echo / in / binding / schema endpoints
-    public string PayloadOnly = "both";  // "both", "vo" or "plain": the endpoints of one side only, minimal and MVC (side (1)'s twin alone, a document refusal isolated)
-    public bool MapBlanketMapping = true;
-    public bool TypeKitOpenApi = true;   // false: the document as ASP.NET alone writes it, the baseline of a refused one
-    /// <summary>
-    /// The three-sided differential's side (1) (Sides): no AddTypeKit(), none of TypeKit's JSON converters on either set of options, and no
-    /// fault responses; the wrapped twin's endpoints answer as ASP.NET and System.Text.Json have them without TypeKit.
-    /// </summary>
-    public bool WithoutTypeKit;
-    public HostCfg Copy() => (HostCfg)MemberwiseClone();
-}
-
-public static class Hx
-{
-    public static bool HasMinimal(Row r) => r["http.host"] is "minimal" or "both" or "route-group";
-    public static bool HasMvc(Row r) => r["http.host"] is "mvc" or "both" or "controller-without-ApiController" or "controller-without-ApiController-visible";
-    /// <summary>The fault controllers have no [ApiController]: MVC infers no [FromBody] and answers no automatic 400.</summary>
-    public static bool Plain(Row r) => r["http.host"] is "controller-without-ApiController" or "controller-without-ApiController-visible";
-    /// <summary>A controller without [ApiController] is in the document only when something makes it visible to the API explorer.</summary>
-    public static bool InDocument(Row r) => r["http.host"] != "controller-without-ApiController";
-    /// <summary>Path of a minimal endpoint (route-group hosts map everything under /rg).</summary>
-    public static string M(Row r, string path) => (r["http.host"] == "route-group" ? "/rg" : "") + path;
-    /// <summary>Path of a controller endpoint (own-route-prefix convention puts /px before relative routes).</summary>
-    public static string C(Row r, string path) => (r.Is("mvc.Conventions", "own-route-prefix") ? "/px" : "") + path;
-
-    public static Type[] FaultControllers(Row r) =>
-        Plain(r) ? [typeof(PlainAController), typeof(PlainBController)] : [typeof(MvcAController), typeof(MvcBController)];
-
-    static void ApplyMvc(MvcOptions o, Row r)
-    {
-        foreach (var kv in r.All.Where(kv => kv.Key.StartsWith("mvc.") && kv.Value != "default"))
-        {
-            var n = kv.Key[4..];
-            switch (n)
-            {
-                case "InputFormatters": o.InputFormatters.Add(new XmlSerializerInputFormatter(o)); continue;
-                case "OutputFormatters": o.OutputFormatters.Add(new XmlSerializerOutputFormatter()); continue;
-                case "ModelBinderProviders": o.ModelBinderProviders.Insert(0, new NullBinderProvider()); continue;
-                case "Conventions": o.Conventions.Add(new PrefixConvention("px")); continue;
-            }
-            var p = typeof(MvcOptions).GetProperty(n) ?? throw new ArgumentException("no mvc option " + n);
-            var t = Nullable.GetUnderlyingType(p.PropertyType) ?? p.PropertyType;
-            object v = t == typeof(bool) ? bool.Parse(kv.Value) : t == typeof(int) ? int.Parse(kv.Value) : t.IsEnum ? Enum.Parse(t, kv.Value) : throw new ArgumentException($"no hand value for mvc.{n}");
-            p.SetValue(o, v);
-        }
-    }
-
-    static void ApplyOpenApi(OpenApiOptions o, Row r)
-    {
-        var v = r.Get("openapi.OpenApiVersion");
-        if (v is not (null or "default")) o.OpenApiVersion = Enum.Parse<OpenApiSpecVersion>(v);
-        switch (r.Get("openapi.CreateSchemaReferenceId"))
-        {
-            case "own-prefixing": o.CreateSchemaReferenceId = ti => OpenApiOptions.CreateDefaultSchemaReferenceId(ti) is { } id ? "X" + id : null; break;
-            case "null-inlines-all": o.CreateSchemaReferenceId = _ => null; break;
-        }
-        switch (r.Get("openapi.transformers"))
-        {
-            case "own-schema-transformer": o.AddSchemaTransformer((s, c, ct) => Task.CompletedTask); break;
-            case "own-operation-transformer": o.AddOperationTransformer((op, c, ct) => Task.CompletedTask); break;
-            case "own-document-transformer": o.AddDocumentTransformer((d, c, ct) => Task.CompletedTask); break;
-        }
-    }
-
-    public static async Task<WebApplication> Start(Row r, Entry e, HostCfg c)
-    {
-        var builder = WebApplication.CreateBuilder(new WebApplicationOptions { EnvironmentName = Environments.Production });
-        builder.WebHost.UseTestServer();
-        builder.Logging.ClearProviders();
-        if (c.Logs is not null) builder.Logging.AddProvider(c.Logs);
-        var plain = e.Valid(); var vo = Make.Vo(e, plain);
-        var (twin, held) = Sides.Twins(r["shape.position"], r.Get("shape.containing") ?? "class", e, plain, vo);
-        var payload = new Payload(held, twin);
-        builder.Services.AddSingleton(payload);
-        builder.Services.ConfigureHttpJsonOptions(o => { JsonRow.Apply(r, e, o.SerializerOptions); if (c.WithoutTypeKit) Sides.DropTypeKit(o.SerializerOptions); });
-        builder.Services.AddOpenApi(x => { ApplyOpenApi(x, r); if (c.TypeKitOpenApi && !c.WithoutTypeKit) x.AddTypeKit(); });
-        if (!c.WithoutTypeKit) builder.Services.Configure<FaultResponseOptions>(x => x.QualifiedFaultNames = c.Qualified);
-        c.Services?.Invoke(builder.Services);
-        if (c.MapBlanketMapping && !c.WithoutTypeKit)
-        {
-            builder.Services.AddFaultResponses<SFault>(f => f switch { SFault.First => 409, SFault.Second => 410, _ => throw new ArgumentOutOfRangeException(nameof(f)) });
-            if (c.Mapping == "by-kind") builder.Services.AddFaultResponses();
-            else if (c.Mapping == "own-IFault-mapping") builder.Services.AddFaultResponses(f => FaultResponse.For(f.Kind).WithType(new Uri($"https://p.example/{f.Kind}")));
-            else if (c.Mapping == "per-set") { builder.Services.AddFaultResponses<HFault>(); builder.Services.AddFaultResponses<GFault>(); }
-        }
-        var mvc = HasMvc(r);
-        if (mvc)
-        {
-            var controllers = new List<Type>();
-            if (c.FaultControllers) controllers.AddRange(c.Controllers ?? FaultControllers(r));
-            if (c.Payload)
-            {
-                controllers.Add(typeof(MvcPayloadController));
-                if (c.PayloadOnly != "plain") controllers.Add(typeof(MvcBind<>).MakeGenericType(e.Vo));
-                if (c.PayloadOnly != "vo") controllers.Add(typeof(MvcBind<>).MakeGenericType(e.Plain));
-            }
-            var pfx = "";
-            builder.Services.AddControllers(o =>
-            {
-                o.Conventions.Add(new BindConvention(e.Vo, e.Plain, pfx));   // before the prefix convention, so that it prefixes these routes too
-                if (r["http.host"] == "controller-without-ApiController-visible") o.Conventions.Add(new VisibleToApiExplorer());
-                ApplyMvc(o, r);
-            })
-            .AddJsonOptions(o => { JsonRow.Apply(r, e, o.JsonSerializerOptions); if (c.WithoutTypeKit) Sides.DropTypeKit(o.JsonSerializerOptions); })
-            .ConfigureApplicationPartManager(p => { p.ApplicationParts.Clear(); p.FeatureProviders.Add(new OnlyControllers([.. controllers])); });
-        }
-        var app = builder.Build();
-        app.MapOpenApi();
-        if (HasMinimal(r))
-        {
-            IEndpointRouteBuilder root = r["http.host"] == "route-group" ? app.MapGroup("/rg") : app;
-            c.Minimal?.Invoke(root);
-            if (c.Payload) MapPayload(root, payload, r, e, c.PayloadOnly);
-        }
-        if (mvc) { var cb = app.MapControllers(); c.ControllerBuilder?.Invoke(cb); }
-        try { await app.StartAsync(); } catch { await app.DisposeAsync(); throw; }
-        return app;
-    }
-
-    // ---- minimal payload endpoints
-    static void MapPayload(IEndpointRouteBuilder b, Payload p, Row r, Entry e, string only)
-    {
-        foreach (var which in new[] { "vo", "plain" })
-        {
-            if (only != "both" && only != which) continue;
-            var h = which == "vo" ? p.Vo : p.Plain;
-            b.MapGet($"/echo/{which}", async (HttpContext ctx) => { await ctx.Response.WriteAsJsonAsync(h.Value, h.Declared, options: null, contentType: null, ctx.RequestAborted); });
-            b.MapPost($"/in/{which}", async (HttpContext ctx) =>
-            {
-                object? v;
-                try { v = await ctx.Request.ReadFromJsonAsync(h.Declared, ctx.RequestAborted); }
-                catch (JsonException) { ctx.Response.StatusCode = 400; return; }
-                catch (BadHttpRequestException) { ctx.Response.StatusCode = 400; return; }
-                await ctx.Response.WriteAsJsonAsync(v, h.Declared, options: null, contentType: null, ctx.RequestAborted);
-            });
-            typeof(Hx).GetMethod(nameof(MapBind), BindingFlags.NonPublic | BindingFlags.Static)!.MakeGenericMethod(which == "vo" ? e.Vo : e.Plain)
-                .Invoke(null, [b, which, e.Wrapped is "own-record-class" or "NodaTime.Instant"]);
-            typeof(Hx).GetMethod(nameof(MapSchema), BindingFlags.NonPublic | BindingFlags.Static)!.MakeGenericMethod(h.Declared).Invoke(null, [b, which]);
-        }
-    }
-
-    sealed record AsP<T>([FromQuery(Name = "v")] T V);
-    static void MapBind<T>(IEndpointRouteBuilder b, string which, bool bodyOnly)
-    {
-        static IResult Out(HttpContext ctx, T v) => Results.Json(v, ctx.RequestServices.GetRequiredService<IOptions<HttpJsonOptions>>().Value.SerializerOptions, null, null);
-        b.MapPost($"/bind/body/{which}", (HttpContext ctx, [FromBody] T v) => Out(ctx, v));
-        if (bodyOnly) return;   // a record class cannot be bound from a route, query, header or form (the wrapped type neither)
-        b.MapGet($"/bind/route/{which}/{{v}}", (HttpContext ctx, T v) => Out(ctx, v));
-        b.MapGet($"/bind/query/{which}", (HttpContext ctx, [FromQuery(Name = "v")] T v) => Out(ctx, v));
-        b.MapGet($"/bind/header/{which}", (HttpContext ctx, [FromHeader(Name = "v")] T v) => Out(ctx, v));
-        b.MapPost($"/bind/form/{which}", (HttpContext ctx, [FromForm(Name = "v")] T v) => Out(ctx, v)).DisableAntiforgery();
-        b.MapGet($"/bind/params/{which}", (HttpContext ctx, [AsParameters] AsP<T> p) => Out(ctx, p.V));
-    }
-    static void MapSchema<T>(IEndpointRouteBuilder b, string which) =>
-        b.MapPost($"/schema/{which}", ([FromBody] T body) => Results.Ok(body));
-
-    // ---- client side
-    /// <summary>An answer on the wire: its status and body, or the exception the server threw (<see cref="Ex"/>, a 500), named in <see cref="Thrown"/>.</summary>
-    public sealed record Wire(HttpStatusCode Status, string Body, string? Thrown = null, Exception? Ex = null)
-    {
-        /// <summary>The answer as the three-sided differential compares it (Sides): the status, the body, and the exception's type and stage.</summary>
-        public Sides.Answer Side(string operation) => new(operation, Ex is null ? Body : null, Ex, (int)Status);
-    }
-    public static async Task<Wire> Send(WebApplication app, HttpMethod m, string path, string? body = null, string? contentType = null, (string, string)? header = null)
-    {
-        var req = new HttpRequestMessage(m, path);
-        req.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
-        if (body is not null) req.Content = new StringContent(body, Encoding.UTF8, contentType ?? "application/json");
-        if (header is { } h) req.Headers.TryAddWithoutValidation(h.Item1, h.Item2);
-        try
-        {
-            var resp = await app.GetTestClient().SendAsync(req);
-            return new(resp.StatusCode, await resp.Content.ReadAsStringAsync());
-        }
-        catch (Exception ex) { return new(HttpStatusCode.InternalServerError, "", ex.GetType().Name + ": " + ex.Message, ex); }
-    }
-    public static Task<Wire> Get(WebApplication app, string path) => Send(app, HttpMethod.Get, path);
-    public static async Task<JsonNode?> Doc(WebApplication app) => JsonNode.Parse(await app.GetTestClient().GetStringAsync("/openapi/v1.json"));
-
-    /// <summary>
-    /// The document failed with AddTypeKit(). The same host without it is side (1) of the three (Sides): where ASP.NET alone refuses the
-    /// document alike, by exception type and stage and never by message (<see cref="DocAlike"/>), the document part has nothing to check
-    /// (<see cref="DocRefused"/>); where it writes the document, or refuses it otherwise, the failure is returned (F2 hid behind a baseline
-    /// that kept AddTypeKit() on both sides). <paramref name="comparedBefore"/> says whether the check compared an answer before the document.
-    /// </summary>
-    public static async Task<string?> DocRefusedByAspNetAlone(Row r, Entry e, HostCfg c, Exception withTypeKit, bool comparedBefore = false)
-    {
-        static string Say(Exception x) => x.GetType().Name + ": " + (x.Message.Length > 200 ? x.Message[..200] + "..." : x.Message);
-        var alone = c.Copy(); alone.TypeKitOpenApi = false;
-        try
-        {
-            await using var app = await Start(r, e, alone);
-            await Doc(app);
-        }
-        catch (Exception ex) when (DocAlike(ex, withTypeKit))
-        {
-            DocRefused(r, ex, comparedBefore);
-            return null;
-        }
-        catch (Exception ex) { return $"document: AddTypeKit() fails ({Say(withTypeKit)}), ASP.NET alone fails otherwise ({Say(ex)})"; }
-        return $"document: AddTypeKit() fails ({Say(withTypeKit)}), ASP.NET alone writes it";
-    }
-
-    /// <summary>
-    /// ASP.NET alone (side (1)) and AddTypeKit() (side (3)) refuse the document alike: the same exception type at the same stage (a
-    /// JsonException's Path), as <see cref="Sides.Alike"/> compares two refusals. No message is compared: the two documents differ in length
-    /// by what AddTypeKit() wrote, so one refusal is at another line and byte of each (rows 31 and 140 of C21), and a refusal's words decide
-    /// no row (decision 99, WS2's three-sided differential).
-    /// </summary>
-    public static bool DocAlike(Exception one, Exception three) =>
-        Sides.Alike(new Sides.Answer("document", null, one), new Sides.Answer("document", null, three));
-
-    /// <summary>
-    /// The document refused alike by ASP.NET alone: its part has nothing to check. A check that compared nothing before it is the framework's
-    /// refusal, an expected refusal that earns nothing (framework-refuses); one that compared an answer on the wire first is judged by that
-    /// answer (doc:refused-by-aspnet-alone, a pass: decision 99's "judged by its other checks").
-    /// </summary>
-    public static void DocRefused(Row r, Exception one, bool comparedBefore)
-    {
-        if (comparedBefore) r.Note(NoteKeys.DocRefusedByAspnetAlone, one.GetType().Name);
-        else r.Note(NoteKeys.FrameworkRefuses, $"document refused by ASP.NET alone too ({one.GetType().Name}), side (1) measured on the same host without AddTypeKit()");
-    }
-
-    public static string BindText(Entry e, object plain) => e.Wrapped switch
-    {
-        "DateTime" => ((DateTime)plain).ToString("O"), "DateTimeOffset" => ((DateTimeOffset)plain).ToString("O"),
-        "DateOnly" => ((DateOnly)plain).ToString("yyyy-MM-dd"), "TimeOnly" => ((TimeOnly)plain).ToString("HH:mm:ss"),
-        "TimeSpan" => ((TimeSpan)plain).ToString("c"), "bool" => (bool)plain ? "true" : "false", "enum" or "flags-enum" => plain.ToString()!,
-        _ => Convert.ToString(plain, System.Globalization.CultureInfo.InvariantCulture)!
-    };
-
-    // ---- schema comparison
-    /// <summary>Drops nullability markers (a class value object over a value type is nullable by being a class; not the value object's doing).</summary>
-    public static JsonNode? NoNull(JsonNode? n)
-    {
-        switch (n)
-        {
-            case JsonObject o:
-                static bool IsNull(JsonNode? a) => a is JsonObject ao && (ao["type"]?.ToJsonString() == "\"null\"" || ao["enum"]?.ToJsonString() == "[null]");
-                if (o["oneOf"] is JsonArray alts && alts.Count == 2 && alts.Any(IsNull) && alts.FirstOrDefault(a => !IsNull(a)) is { } keep)
-                    return NoNull(keep.DeepClone());
-                var c = new JsonObject();
-                foreach (var kv in o)
-                {
-                    if (kv.Key is "nullable" or "x-nullable" or "x-null" or "required") continue;
-                    if (kv.Key == "type" && kv.Value is JsonArray ta) { var f = ta.Where(x => x?.GetValue<string>() != "null").ToList(); c["type"] = f.Count == 1 ? f[0]!.DeepClone() : new JsonArray(f.Select(x => x!.DeepClone()).ToArray()); continue; }
-                    if (kv.Key == "allOf" && kv.Value is JsonArray aa && aa.Count == 1 && aa[0] is JsonObject a0 && a0.Count == 1 && a0.ContainsKey("x-nullable")) continue;
-                    // OpenAPI 3.0 writes a type of several with null as anyOf [{type: integer}, {type: string}, {enum: [null]}] (row 260 of C21)
-                    if (kv.Key == "anyOf" && kv.Value is JsonArray any && any.Any(IsNull)) { c["anyOf"] = new JsonArray(any.Where(x => !IsNull(x)).Select(NoNull).ToArray()); continue; }
-                    if (kv.Key == "enum" && kv.Value is JsonArray en && en.Any(x => x is null)) { c["enum"] = new JsonArray(en.Where(x => x is not null).Select(x => x!.DeepClone()).ToArray()); continue; }
-                    c[kv.Key] = NoNull(kv.Value);
-                }
-                return c;
-            case JsonArray a: var ca = new JsonArray(); foreach (var x in a) ca.Add(NoNull(x)); return ca;
-            default: return n?.DeepClone();
-        }
-    }
-
-    /// <summary>The key <see cref="Deep"/> puts on a schema it resolved from a reference, when asked to mark them.</summary>
-    public const string ResolvedReference = "x-probe-resolved-reference";
-
-    public static JsonNode? Deep(JsonNode doc, JsonNode? n, HashSet<string>? seen = null, bool mark = false)
-    {
-        seen ??= [];
-        switch (n)
-        {
-            case JsonObject o:
-                if (o["$ref"] is { } rf)
-                {
-                    var key = rf.GetValue<string>();
-                    if (!seen.Add(key)) return JsonValue.Create("<cycle>");
-                    var target = doc; foreach (var seg in key.TrimStart('#', '/').Split('/')) target = target?[seg];
-                    var res = Deep(doc, target, seen, mark); seen.Remove(key);
-                    if (mark && res is JsonObject resolved) resolved[ResolvedReference] = true;
-                    return res;
-                }
-                var c = new JsonObject();
-                foreach (var kv in o.OrderBy(k => k.Key, StringComparer.Ordinal))
-                    if (kv.Key is not ("title" or "description" or "example" or "examples"))
-                        c[kv.Key] = kv.Key == "discriminator" ? Discriminator(o, kv.Value) : Deep(doc, kv.Value, seen, mark);
-                return c;
-            case JsonArray a: var ca = new JsonArray(); foreach (var x in a) ca.Add(Deep(doc, x, seen, mark)); return ca;
-            default: return n?.DeepClone();
-        }
-    }
-
-    /// <summary>
-    /// A discriminator's mapping names a component per value, and a component's name is made of the type's, which
-    /// differs between the two sides by construction (row 347 of C07: <c>PB&lt;TimeSpan&gt;</c> against
-    /// <c>PB&lt;V&gt;</c>). Each value names instead the branch of the same schema's anyOf or oneOf it maps to, whose
-    /// content <see cref="Deep"/> compares; a target that is no branch stays as it is, and so still differs.
-    /// </summary>
-    static JsonNode? Discriminator(JsonObject schema, JsonNode? discriminator)
-    {
-        if (discriminator is not JsonObject d || d["mapping"] is not JsonObject mapping) return discriminator?.DeepClone();
-        var branches = (schema["anyOf"] ?? schema["oneOf"]) as JsonArray;
-        var c = (JsonObject)d.DeepClone();
-        var named = new JsonObject();
-        foreach (var (value, target) in mapping.OrderBy(m => m.Key, StringComparer.Ordinal))
-        {
-            var index = -1;
-            for (var i = 0; target is JsonValue && i < (branches?.Count ?? 0); i++)
-                if (branches![i]?["$ref"]?.GetValue<string>() == target.GetValue<string>()) { index = i; break; }
-            named[value] = index >= 0 ? $"branch {index}" : target?.DeepClone();
-        }
-        c["mapping"] = named;
-        return c;
-    }
-}
diff --git a/tools/probe/corpus/harness/JsonFamily.cs b/tools/probe/corpus/harness/JsonFamily.cs
deleted file mode 100644
index 8a1ef837..00000000
--- a/tools/probe/corpus/harness/JsonFamily.cs
+++ /dev/null
@@ -1,89 +0,0 @@
-// Shared code of the JSON family's claim checks (C01 decimal spelling, C10 Preserve guard, L06 off the wire):
-// serializing a held shape, reading its tokens, rewriting one token, and reading what a document holds back.
-using System.Text;
-using System.Text.Json;
-using Probes.Shapes;
-namespace Probes.Json;
-
-/// <summary>One token of a JSON document: its kind, its raw text (a string's without quotes), its value as text, and its byte span.</summary>
-public sealed record JTok(JsonTokenType Type, string Raw, string? Text, int Start, int End);
-
-public static class Jx
-{
-    public static (string? Json, Exception? Ex) Ser(Held h, JsonSerializerOptions o)
-    { try { return (JsonSerializer.Serialize(h.Value, h.Declared, o), null); } catch (Exception ex) { return (null, ex); } }
-
-    public static (object? Value, Exception? Ex) De(string text, Type declared, JsonSerializerOptions o)
-    { try { return (JsonSerializer.Deserialize(text, declared, o), null); } catch (Exception ex) { return (null, ex); } }
-
-    /// <summary>Every token of a document, with the byte span it takes (a string's and a property name's quotes included).</summary>
-    public static List<JTok> Tokens(string json)
-    {
-        var bytes = Encoding.UTF8.GetBytes(json);
-        var rd = new Utf8JsonReader(bytes, new JsonReaderOptions { AllowTrailingCommas = true, CommentHandling = JsonCommentHandling.Skip });
-        var list = new List<JTok>();
-        while (rd.Read())
-        {
-            var start = (int)rd.TokenStartIndex;
-            switch (rd.TokenType)
-            {
-                case JsonTokenType.Number:
-                    list.Add(new(rd.TokenType, Encoding.UTF8.GetString(rd.ValueSpan), Encoding.UTF8.GetString(rd.ValueSpan), start, start + rd.ValueSpan.Length)); break;
-                case JsonTokenType.String or JsonTokenType.PropertyName:
-                    list.Add(new(rd.TokenType, Encoding.UTF8.GetString(rd.ValueSpan), rd.GetString(), start, start + rd.ValueSpan.Length + 2)); break;
-                default:
-                    list.Add(new(rd.TokenType, "", null, start, start)); break;
-            }
-        }
-        return list;
-    }
-
-    /// <summary>The document with the tokens <paramref name="at"/> replaced by <paramref name="with"/> (raw JSON text).</summary>
-    public static string Rewrite(string json, IEnumerable<JTok> at, Func<JTok, string> with)
-    {
-        var bytes = Encoding.UTF8.GetBytes(json);
-        var sb = new StringBuilder(); var pos = 0;
-        foreach (var t in at.OrderBy(t => t.Start))
-        {
-            sb.Append(Encoding.UTF8.GetString(bytes, pos, t.Start - pos)); sb.Append(with(t)); pos = t.End;
-        }
-        sb.Append(Encoding.UTF8.GetString(bytes, pos, bytes.Length - pos));
-        return sb.ToString();
-    }
-
-    /// <summary>Options that write what a value holds as the serializer writes it by default (a decimal with its scale, every field).</summary>
-    public static readonly JsonSerializerOptions Plain = new() { IncludeFields = true };
-
-    public static string Cut(string? s) => s is null ? "(null)" : s.Length > 220 ? s[..220] + "..." : s;
-    public static string Name(Type t) => t.IsGenericType ? t.Name[..t.Name.IndexOf('`')] + "<" + string.Join(", ", t.GetGenericArguments().Select(Name)) + ">" : t.Name;
-    /// <summary>A refusal's message with the type the other side holds named instead: the serializer names the shape it refused.</summary>
-    public static string Swap(string message, Type from, Type to) => message.Replace(from.ToString(), to.ToString());
-    /// <summary>What a containing type holds: its property P or its field F.</summary>
-    public static object? Member(Type declared, object? holder) =>
-        holder is null ? null : declared.GetProperty("P") is { } p ? p.GetValue(holder) : declared.GetField("F") is { } f ? f.GetValue(holder) : null;
-    public static string Ex(Exception e) => e.GetType().Name + ": " + Cut(e.Message);
-
-    /// <summary>A copy of the options that writes every member: the ignore conditions reset, so a read has the member to read.</summary>
-    public static JsonSerializerOptions Full(JsonSerializerOptions o) => new(o)
-    {
-        DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.Never, IgnoreReadOnlyProperties = false, IgnoreReadOnlyFields = false,
-        // A number written as a string reads back only with AllowReadingFromString; the document is input, so it says its other numbers plainly.
-        NumberHandling = o.NumberHandling & ~System.Text.Json.Serialization.JsonNumberHandling.WriteAsString,
-    };
-}
-
-/// <summary>
-/// The row's json.* axes, applied by JsonRow: under json.TypeInfoResolver=source-generated-context the resolver is ProbeContext alone
-/// (Shapes.g.cs), which lists every shape a row holds and its twin, so the setting runs as the row names it. A shape of the claim's own
-/// the context does not list (L06's Option or Result) is the generator's gap: a harness error.
-/// </summary>
-public static class JCtx
-{
-    public static JsonSerializerOptions Apply(Row r, Entry e, params Type[] shapes)
-    {
-        var o = JsonRow.Apply(r, e).Options!;
-        var missing = JsonRow.Unlisted(r, shapes).Select(Jx.Name).ToList();
-        if (missing.Count > 0) throw new InvalidOperationException("ProbeContext does not list (run tools/probe/generators/shapes.cs): " + string.Join(", ", missing));
-        return o;
-    }
-}
diff --git a/tools/probe/corpus/harness/JsonFamilyShapes.g.cs b/tools/probe/corpus/harness/JsonFamilyShapes.g.cs
deleted file mode 100644
index 5cb98433..00000000
--- a/tools/probe/corpus/harness/JsonFamilyShapes.g.cs
+++ /dev/null
@@ -1,493 +0,0 @@
-// <auto-generated/> by tools/probe/generators/json-family.cs stand-ins: L06's polymorphic stand-ins over Option and Result. Do not edit.
-#nullable disable
-#pragma warning disable CS8618, CS1591, CMTK0005, CMTK0006
-using CodoMetis.TypeKit;
-using Probes.Shapes;
-namespace Probes.Json;
-
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_string_O), "d")] public abstract class L06PB_V_record_struct_string_O { }
-public sealed class L06PD_V_record_struct_string_O : L06PB_V_record_struct_string_O { public Option<V_record_struct_string> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_string_RTE), "d")] public abstract class L06PB_V_record_struct_string_RTE { }
-public sealed class L06PD_V_record_struct_string_RTE : L06PB_V_record_struct_string_RTE { public Result<V_record_struct_string, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_string_RE), "d")] public abstract class L06PB_V_record_struct_string_RE { }
-public sealed class L06PD_V_record_struct_string_RE : L06PB_V_record_struct_string_RE { public Result<V_record_struct_string> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_Guid_O), "d")] public abstract class L06PB_V_record_struct_Guid_O { }
-public sealed class L06PD_V_record_struct_Guid_O : L06PB_V_record_struct_Guid_O { public Option<V_record_struct_Guid> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_Guid_RTE), "d")] public abstract class L06PB_V_record_struct_Guid_RTE { }
-public sealed class L06PD_V_record_struct_Guid_RTE : L06PB_V_record_struct_Guid_RTE { public Result<V_record_struct_Guid, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_Guid_RE), "d")] public abstract class L06PB_V_record_struct_Guid_RE { }
-public sealed class L06PD_V_record_struct_Guid_RE : L06PB_V_record_struct_Guid_RE { public Result<V_record_struct_Guid> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_int_O), "d")] public abstract class L06PB_V_record_struct_int_O { }
-public sealed class L06PD_V_record_struct_int_O : L06PB_V_record_struct_int_O { public Option<V_record_struct_int> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_int_RTE), "d")] public abstract class L06PB_V_record_struct_int_RTE { }
-public sealed class L06PD_V_record_struct_int_RTE : L06PB_V_record_struct_int_RTE { public Result<V_record_struct_int, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_int_RE), "d")] public abstract class L06PB_V_record_struct_int_RE { }
-public sealed class L06PD_V_record_struct_int_RE : L06PB_V_record_struct_int_RE { public Result<V_record_struct_int> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_long_O), "d")] public abstract class L06PB_V_record_struct_long_O { }
-public sealed class L06PD_V_record_struct_long_O : L06PB_V_record_struct_long_O { public Option<V_record_struct_long> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_long_RTE), "d")] public abstract class L06PB_V_record_struct_long_RTE { }
-public sealed class L06PD_V_record_struct_long_RTE : L06PB_V_record_struct_long_RTE { public Result<V_record_struct_long, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_long_RE), "d")] public abstract class L06PB_V_record_struct_long_RE { }
-public sealed class L06PD_V_record_struct_long_RE : L06PB_V_record_struct_long_RE { public Result<V_record_struct_long> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_byte_O), "d")] public abstract class L06PB_V_record_struct_byte_O { }
-public sealed class L06PD_V_record_struct_byte_O : L06PB_V_record_struct_byte_O { public Option<V_record_struct_byte> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_byte_RTE), "d")] public abstract class L06PB_V_record_struct_byte_RTE { }
-public sealed class L06PD_V_record_struct_byte_RTE : L06PB_V_record_struct_byte_RTE { public Result<V_record_struct_byte, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_byte_RE), "d")] public abstract class L06PB_V_record_struct_byte_RE { }
-public sealed class L06PD_V_record_struct_byte_RE : L06PB_V_record_struct_byte_RE { public Result<V_record_struct_byte> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_ulong_O), "d")] public abstract class L06PB_V_record_struct_ulong_O { }
-public sealed class L06PD_V_record_struct_ulong_O : L06PB_V_record_struct_ulong_O { public Option<V_record_struct_ulong> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_ulong_RTE), "d")] public abstract class L06PB_V_record_struct_ulong_RTE { }
-public sealed class L06PD_V_record_struct_ulong_RTE : L06PB_V_record_struct_ulong_RTE { public Result<V_record_struct_ulong, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_ulong_RE), "d")] public abstract class L06PB_V_record_struct_ulong_RE { }
-public sealed class L06PD_V_record_struct_ulong_RE : L06PB_V_record_struct_ulong_RE { public Result<V_record_struct_ulong> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_decimal_O), "d")] public abstract class L06PB_V_record_struct_decimal_O { }
-public sealed class L06PD_V_record_struct_decimal_O : L06PB_V_record_struct_decimal_O { public Option<V_record_struct_decimal> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_decimal_RTE), "d")] public abstract class L06PB_V_record_struct_decimal_RTE { }
-public sealed class L06PD_V_record_struct_decimal_RTE : L06PB_V_record_struct_decimal_RTE { public Result<V_record_struct_decimal, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_decimal_RE), "d")] public abstract class L06PB_V_record_struct_decimal_RE { }
-public sealed class L06PD_V_record_struct_decimal_RE : L06PB_V_record_struct_decimal_RE { public Result<V_record_struct_decimal> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_double_O), "d")] public abstract class L06PB_V_record_struct_double_O { }
-public sealed class L06PD_V_record_struct_double_O : L06PB_V_record_struct_double_O { public Option<V_record_struct_double> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_double_RTE), "d")] public abstract class L06PB_V_record_struct_double_RTE { }
-public sealed class L06PD_V_record_struct_double_RTE : L06PB_V_record_struct_double_RTE { public Result<V_record_struct_double, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_double_RE), "d")] public abstract class L06PB_V_record_struct_double_RE { }
-public sealed class L06PD_V_record_struct_double_RE : L06PB_V_record_struct_double_RE { public Result<V_record_struct_double> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_bool_O), "d")] public abstract class L06PB_V_record_struct_bool_O { }
-public sealed class L06PD_V_record_struct_bool_O : L06PB_V_record_struct_bool_O { public Option<V_record_struct_bool> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_bool_RTE), "d")] public abstract class L06PB_V_record_struct_bool_RTE { }
-public sealed class L06PD_V_record_struct_bool_RTE : L06PB_V_record_struct_bool_RTE { public Result<V_record_struct_bool, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_bool_RE), "d")] public abstract class L06PB_V_record_struct_bool_RE { }
-public sealed class L06PD_V_record_struct_bool_RE : L06PB_V_record_struct_bool_RE { public Result<V_record_struct_bool> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_char_O), "d")] public abstract class L06PB_V_record_struct_char_O { }
-public sealed class L06PD_V_record_struct_char_O : L06PB_V_record_struct_char_O { public Option<V_record_struct_char> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_char_RTE), "d")] public abstract class L06PB_V_record_struct_char_RTE { }
-public sealed class L06PD_V_record_struct_char_RTE : L06PB_V_record_struct_char_RTE { public Result<V_record_struct_char, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_char_RE), "d")] public abstract class L06PB_V_record_struct_char_RE { }
-public sealed class L06PD_V_record_struct_char_RE : L06PB_V_record_struct_char_RE { public Result<V_record_struct_char> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_DateTime_O), "d")] public abstract class L06PB_V_record_struct_DateTime_O { }
-public sealed class L06PD_V_record_struct_DateTime_O : L06PB_V_record_struct_DateTime_O { public Option<V_record_struct_DateTime> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_DateTime_RTE), "d")] public abstract class L06PB_V_record_struct_DateTime_RTE { }
-public sealed class L06PD_V_record_struct_DateTime_RTE : L06PB_V_record_struct_DateTime_RTE { public Result<V_record_struct_DateTime, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_DateTime_RE), "d")] public abstract class L06PB_V_record_struct_DateTime_RE { }
-public sealed class L06PD_V_record_struct_DateTime_RE : L06PB_V_record_struct_DateTime_RE { public Result<V_record_struct_DateTime> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_DateTimeOffset_O), "d")] public abstract class L06PB_V_record_struct_DateTimeOffset_O { }
-public sealed class L06PD_V_record_struct_DateTimeOffset_O : L06PB_V_record_struct_DateTimeOffset_O { public Option<V_record_struct_DateTimeOffset> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_DateTimeOffset_RTE), "d")] public abstract class L06PB_V_record_struct_DateTimeOffset_RTE { }
-public sealed class L06PD_V_record_struct_DateTimeOffset_RTE : L06PB_V_record_struct_DateTimeOffset_RTE { public Result<V_record_struct_DateTimeOffset, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_DateTimeOffset_RE), "d")] public abstract class L06PB_V_record_struct_DateTimeOffset_RE { }
-public sealed class L06PD_V_record_struct_DateTimeOffset_RE : L06PB_V_record_struct_DateTimeOffset_RE { public Result<V_record_struct_DateTimeOffset> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_DateOnly_O), "d")] public abstract class L06PB_V_record_struct_DateOnly_O { }
-public sealed class L06PD_V_record_struct_DateOnly_O : L06PB_V_record_struct_DateOnly_O { public Option<V_record_struct_DateOnly> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_DateOnly_RTE), "d")] public abstract class L06PB_V_record_struct_DateOnly_RTE { }
-public sealed class L06PD_V_record_struct_DateOnly_RTE : L06PB_V_record_struct_DateOnly_RTE { public Result<V_record_struct_DateOnly, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_DateOnly_RE), "d")] public abstract class L06PB_V_record_struct_DateOnly_RE { }
-public sealed class L06PD_V_record_struct_DateOnly_RE : L06PB_V_record_struct_DateOnly_RE { public Result<V_record_struct_DateOnly> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_TimeOnly_O), "d")] public abstract class L06PB_V_record_struct_TimeOnly_O { }
-public sealed class L06PD_V_record_struct_TimeOnly_O : L06PB_V_record_struct_TimeOnly_O { public Option<V_record_struct_TimeOnly> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_TimeOnly_RTE), "d")] public abstract class L06PB_V_record_struct_TimeOnly_RTE { }
-public sealed class L06PD_V_record_struct_TimeOnly_RTE : L06PB_V_record_struct_TimeOnly_RTE { public Result<V_record_struct_TimeOnly, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_TimeOnly_RE), "d")] public abstract class L06PB_V_record_struct_TimeOnly_RE { }
-public sealed class L06PD_V_record_struct_TimeOnly_RE : L06PB_V_record_struct_TimeOnly_RE { public Result<V_record_struct_TimeOnly> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_TimeSpan_O), "d")] public abstract class L06PB_V_record_struct_TimeSpan_O { }
-public sealed class L06PD_V_record_struct_TimeSpan_O : L06PB_V_record_struct_TimeSpan_O { public Option<V_record_struct_TimeSpan> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_TimeSpan_RTE), "d")] public abstract class L06PB_V_record_struct_TimeSpan_RTE { }
-public sealed class L06PD_V_record_struct_TimeSpan_RTE : L06PB_V_record_struct_TimeSpan_RTE { public Result<V_record_struct_TimeSpan, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_TimeSpan_RE), "d")] public abstract class L06PB_V_record_struct_TimeSpan_RE { }
-public sealed class L06PD_V_record_struct_TimeSpan_RE : L06PB_V_record_struct_TimeSpan_RE { public Result<V_record_struct_TimeSpan> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_enum_O), "d")] public abstract class L06PB_V_record_struct_enum_O { }
-public sealed class L06PD_V_record_struct_enum_O : L06PB_V_record_struct_enum_O { public Option<V_record_struct_enum> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_enum_RTE), "d")] public abstract class L06PB_V_record_struct_enum_RTE { }
-public sealed class L06PD_V_record_struct_enum_RTE : L06PB_V_record_struct_enum_RTE { public Result<V_record_struct_enum, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_enum_RE), "d")] public abstract class L06PB_V_record_struct_enum_RE { }
-public sealed class L06PD_V_record_struct_enum_RE : L06PB_V_record_struct_enum_RE { public Result<V_record_struct_enum> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_flags_enum_O), "d")] public abstract class L06PB_V_record_struct_flags_enum_O { }
-public sealed class L06PD_V_record_struct_flags_enum_O : L06PB_V_record_struct_flags_enum_O { public Option<V_record_struct_flags_enum> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_flags_enum_RTE), "d")] public abstract class L06PB_V_record_struct_flags_enum_RTE { }
-public sealed class L06PD_V_record_struct_flags_enum_RTE : L06PB_V_record_struct_flags_enum_RTE { public Result<V_record_struct_flags_enum, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_flags_enum_RE), "d")] public abstract class L06PB_V_record_struct_flags_enum_RE { }
-public sealed class L06PD_V_record_struct_flags_enum_RE : L06PB_V_record_struct_flags_enum_RE { public Result<V_record_struct_flags_enum> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_Uri_O), "d")] public abstract class L06PB_V_record_struct_Uri_O { }
-public sealed class L06PD_V_record_struct_Uri_O : L06PB_V_record_struct_Uri_O { public Option<V_record_struct_Uri> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_Uri_RTE), "d")] public abstract class L06PB_V_record_struct_Uri_RTE { }
-public sealed class L06PD_V_record_struct_Uri_RTE : L06PB_V_record_struct_Uri_RTE { public Result<V_record_struct_Uri, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_Uri_RE), "d")] public abstract class L06PB_V_record_struct_Uri_RE { }
-public sealed class L06PD_V_record_struct_Uri_RE : L06PB_V_record_struct_Uri_RE { public Result<V_record_struct_Uri> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_NodaTime_Instant_O), "d")] public abstract class L06PB_V_record_struct_NodaTime_Instant_O { }
-public sealed class L06PD_V_record_struct_NodaTime_Instant_O : L06PB_V_record_struct_NodaTime_Instant_O { public Option<V_record_struct_NodaTime_Instant> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_NodaTime_Instant_RTE), "d")] public abstract class L06PB_V_record_struct_NodaTime_Instant_RTE { }
-public sealed class L06PD_V_record_struct_NodaTime_Instant_RTE : L06PB_V_record_struct_NodaTime_Instant_RTE { public Result<V_record_struct_NodaTime_Instant, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_NodaTime_Instant_RE), "d")] public abstract class L06PB_V_record_struct_NodaTime_Instant_RE { }
-public sealed class L06PD_V_record_struct_NodaTime_Instant_RE : L06PB_V_record_struct_NodaTime_Instant_RE { public Result<V_record_struct_NodaTime_Instant> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_own_record_class_O), "d")] public abstract class L06PB_V_record_struct_own_record_class_O { }
-public sealed class L06PD_V_record_struct_own_record_class_O : L06PB_V_record_struct_own_record_class_O { public Option<V_record_struct_own_record_class> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_own_record_class_RTE), "d")] public abstract class L06PB_V_record_struct_own_record_class_RTE { }
-public sealed class L06PD_V_record_struct_own_record_class_RTE : L06PB_V_record_struct_own_record_class_RTE { public Result<V_record_struct_own_record_class, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_record_struct_own_record_class_RE), "d")] public abstract class L06PB_V_record_struct_own_record_class_RE { }
-public sealed class L06PD_V_record_struct_own_record_class_RE : L06PB_V_record_struct_own_record_class_RE { public Result<V_record_struct_own_record_class> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_string_O), "d")] public abstract class L06PB_V_sealed_record_class_string_O { }
-public sealed class L06PD_V_sealed_record_class_string_O : L06PB_V_sealed_record_class_string_O { public Option<V_sealed_record_class_string> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_string_RTE), "d")] public abstract class L06PB_V_sealed_record_class_string_RTE { }
-public sealed class L06PD_V_sealed_record_class_string_RTE : L06PB_V_sealed_record_class_string_RTE { public Result<V_sealed_record_class_string, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_string_RE), "d")] public abstract class L06PB_V_sealed_record_class_string_RE { }
-public sealed class L06PD_V_sealed_record_class_string_RE : L06PB_V_sealed_record_class_string_RE { public Result<V_sealed_record_class_string> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_Guid_O), "d")] public abstract class L06PB_V_sealed_record_class_Guid_O { }
-public sealed class L06PD_V_sealed_record_class_Guid_O : L06PB_V_sealed_record_class_Guid_O { public Option<V_sealed_record_class_Guid> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_Guid_RTE), "d")] public abstract class L06PB_V_sealed_record_class_Guid_RTE { }
-public sealed class L06PD_V_sealed_record_class_Guid_RTE : L06PB_V_sealed_record_class_Guid_RTE { public Result<V_sealed_record_class_Guid, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_Guid_RE), "d")] public abstract class L06PB_V_sealed_record_class_Guid_RE { }
-public sealed class L06PD_V_sealed_record_class_Guid_RE : L06PB_V_sealed_record_class_Guid_RE { public Result<V_sealed_record_class_Guid> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_int_O), "d")] public abstract class L06PB_V_sealed_record_class_int_O { }
-public sealed class L06PD_V_sealed_record_class_int_O : L06PB_V_sealed_record_class_int_O { public Option<V_sealed_record_class_int> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_int_RTE), "d")] public abstract class L06PB_V_sealed_record_class_int_RTE { }
-public sealed class L06PD_V_sealed_record_class_int_RTE : L06PB_V_sealed_record_class_int_RTE { public Result<V_sealed_record_class_int, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_int_RE), "d")] public abstract class L06PB_V_sealed_record_class_int_RE { }
-public sealed class L06PD_V_sealed_record_class_int_RE : L06PB_V_sealed_record_class_int_RE { public Result<V_sealed_record_class_int> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_long_O), "d")] public abstract class L06PB_V_sealed_record_class_long_O { }
-public sealed class L06PD_V_sealed_record_class_long_O : L06PB_V_sealed_record_class_long_O { public Option<V_sealed_record_class_long> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_long_RTE), "d")] public abstract class L06PB_V_sealed_record_class_long_RTE { }
-public sealed class L06PD_V_sealed_record_class_long_RTE : L06PB_V_sealed_record_class_long_RTE { public Result<V_sealed_record_class_long, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_long_RE), "d")] public abstract class L06PB_V_sealed_record_class_long_RE { }
-public sealed class L06PD_V_sealed_record_class_long_RE : L06PB_V_sealed_record_class_long_RE { public Result<V_sealed_record_class_long> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_byte_O), "d")] public abstract class L06PB_V_sealed_record_class_byte_O { }
-public sealed class L06PD_V_sealed_record_class_byte_O : L06PB_V_sealed_record_class_byte_O { public Option<V_sealed_record_class_byte> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_byte_RTE), "d")] public abstract class L06PB_V_sealed_record_class_byte_RTE { }
-public sealed class L06PD_V_sealed_record_class_byte_RTE : L06PB_V_sealed_record_class_byte_RTE { public Result<V_sealed_record_class_byte, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_byte_RE), "d")] public abstract class L06PB_V_sealed_record_class_byte_RE { }
-public sealed class L06PD_V_sealed_record_class_byte_RE : L06PB_V_sealed_record_class_byte_RE { public Result<V_sealed_record_class_byte> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_ulong_O), "d")] public abstract class L06PB_V_sealed_record_class_ulong_O { }
-public sealed class L06PD_V_sealed_record_class_ulong_O : L06PB_V_sealed_record_class_ulong_O { public Option<V_sealed_record_class_ulong> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_ulong_RTE), "d")] public abstract class L06PB_V_sealed_record_class_ulong_RTE { }
-public sealed class L06PD_V_sealed_record_class_ulong_RTE : L06PB_V_sealed_record_class_ulong_RTE { public Result<V_sealed_record_class_ulong, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_ulong_RE), "d")] public abstract class L06PB_V_sealed_record_class_ulong_RE { }
-public sealed class L06PD_V_sealed_record_class_ulong_RE : L06PB_V_sealed_record_class_ulong_RE { public Result<V_sealed_record_class_ulong> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_decimal_O), "d")] public abstract class L06PB_V_sealed_record_class_decimal_O { }
-public sealed class L06PD_V_sealed_record_class_decimal_O : L06PB_V_sealed_record_class_decimal_O { public Option<V_sealed_record_class_decimal> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_decimal_RTE), "d")] public abstract class L06PB_V_sealed_record_class_decimal_RTE { }
-public sealed class L06PD_V_sealed_record_class_decimal_RTE : L06PB_V_sealed_record_class_decimal_RTE { public Result<V_sealed_record_class_decimal, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_decimal_RE), "d")] public abstract class L06PB_V_sealed_record_class_decimal_RE { }
-public sealed class L06PD_V_sealed_record_class_decimal_RE : L06PB_V_sealed_record_class_decimal_RE { public Result<V_sealed_record_class_decimal> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_double_O), "d")] public abstract class L06PB_V_sealed_record_class_double_O { }
-public sealed class L06PD_V_sealed_record_class_double_O : L06PB_V_sealed_record_class_double_O { public Option<V_sealed_record_class_double> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_double_RTE), "d")] public abstract class L06PB_V_sealed_record_class_double_RTE { }
-public sealed class L06PD_V_sealed_record_class_double_RTE : L06PB_V_sealed_record_class_double_RTE { public Result<V_sealed_record_class_double, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_double_RE), "d")] public abstract class L06PB_V_sealed_record_class_double_RE { }
-public sealed class L06PD_V_sealed_record_class_double_RE : L06PB_V_sealed_record_class_double_RE { public Result<V_sealed_record_class_double> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_bool_O), "d")] public abstract class L06PB_V_sealed_record_class_bool_O { }
-public sealed class L06PD_V_sealed_record_class_bool_O : L06PB_V_sealed_record_class_bool_O { public Option<V_sealed_record_class_bool> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_bool_RTE), "d")] public abstract class L06PB_V_sealed_record_class_bool_RTE { }
-public sealed class L06PD_V_sealed_record_class_bool_RTE : L06PB_V_sealed_record_class_bool_RTE { public Result<V_sealed_record_class_bool, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_bool_RE), "d")] public abstract class L06PB_V_sealed_record_class_bool_RE { }
-public sealed class L06PD_V_sealed_record_class_bool_RE : L06PB_V_sealed_record_class_bool_RE { public Result<V_sealed_record_class_bool> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_char_O), "d")] public abstract class L06PB_V_sealed_record_class_char_O { }
-public sealed class L06PD_V_sealed_record_class_char_O : L06PB_V_sealed_record_class_char_O { public Option<V_sealed_record_class_char> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_char_RTE), "d")] public abstract class L06PB_V_sealed_record_class_char_RTE { }
-public sealed class L06PD_V_sealed_record_class_char_RTE : L06PB_V_sealed_record_class_char_RTE { public Result<V_sealed_record_class_char, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_char_RE), "d")] public abstract class L06PB_V_sealed_record_class_char_RE { }
-public sealed class L06PD_V_sealed_record_class_char_RE : L06PB_V_sealed_record_class_char_RE { public Result<V_sealed_record_class_char> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_DateTime_O), "d")] public abstract class L06PB_V_sealed_record_class_DateTime_O { }
-public sealed class L06PD_V_sealed_record_class_DateTime_O : L06PB_V_sealed_record_class_DateTime_O { public Option<V_sealed_record_class_DateTime> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_DateTime_RTE), "d")] public abstract class L06PB_V_sealed_record_class_DateTime_RTE { }
-public sealed class L06PD_V_sealed_record_class_DateTime_RTE : L06PB_V_sealed_record_class_DateTime_RTE { public Result<V_sealed_record_class_DateTime, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_DateTime_RE), "d")] public abstract class L06PB_V_sealed_record_class_DateTime_RE { }
-public sealed class L06PD_V_sealed_record_class_DateTime_RE : L06PB_V_sealed_record_class_DateTime_RE { public Result<V_sealed_record_class_DateTime> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_DateTimeOffset_O), "d")] public abstract class L06PB_V_sealed_record_class_DateTimeOffset_O { }
-public sealed class L06PD_V_sealed_record_class_DateTimeOffset_O : L06PB_V_sealed_record_class_DateTimeOffset_O { public Option<V_sealed_record_class_DateTimeOffset> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_DateTimeOffset_RTE), "d")] public abstract class L06PB_V_sealed_record_class_DateTimeOffset_RTE { }
-public sealed class L06PD_V_sealed_record_class_DateTimeOffset_RTE : L06PB_V_sealed_record_class_DateTimeOffset_RTE { public Result<V_sealed_record_class_DateTimeOffset, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_DateTimeOffset_RE), "d")] public abstract class L06PB_V_sealed_record_class_DateTimeOffset_RE { }
-public sealed class L06PD_V_sealed_record_class_DateTimeOffset_RE : L06PB_V_sealed_record_class_DateTimeOffset_RE { public Result<V_sealed_record_class_DateTimeOffset> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_DateOnly_O), "d")] public abstract class L06PB_V_sealed_record_class_DateOnly_O { }
-public sealed class L06PD_V_sealed_record_class_DateOnly_O : L06PB_V_sealed_record_class_DateOnly_O { public Option<V_sealed_record_class_DateOnly> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_DateOnly_RTE), "d")] public abstract class L06PB_V_sealed_record_class_DateOnly_RTE { }
-public sealed class L06PD_V_sealed_record_class_DateOnly_RTE : L06PB_V_sealed_record_class_DateOnly_RTE { public Result<V_sealed_record_class_DateOnly, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_DateOnly_RE), "d")] public abstract class L06PB_V_sealed_record_class_DateOnly_RE { }
-public sealed class L06PD_V_sealed_record_class_DateOnly_RE : L06PB_V_sealed_record_class_DateOnly_RE { public Result<V_sealed_record_class_DateOnly> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_TimeOnly_O), "d")] public abstract class L06PB_V_sealed_record_class_TimeOnly_O { }
-public sealed class L06PD_V_sealed_record_class_TimeOnly_O : L06PB_V_sealed_record_class_TimeOnly_O { public Option<V_sealed_record_class_TimeOnly> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_TimeOnly_RTE), "d")] public abstract class L06PB_V_sealed_record_class_TimeOnly_RTE { }
-public sealed class L06PD_V_sealed_record_class_TimeOnly_RTE : L06PB_V_sealed_record_class_TimeOnly_RTE { public Result<V_sealed_record_class_TimeOnly, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_TimeOnly_RE), "d")] public abstract class L06PB_V_sealed_record_class_TimeOnly_RE { }
-public sealed class L06PD_V_sealed_record_class_TimeOnly_RE : L06PB_V_sealed_record_class_TimeOnly_RE { public Result<V_sealed_record_class_TimeOnly> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_TimeSpan_O), "d")] public abstract class L06PB_V_sealed_record_class_TimeSpan_O { }
-public sealed class L06PD_V_sealed_record_class_TimeSpan_O : L06PB_V_sealed_record_class_TimeSpan_O { public Option<V_sealed_record_class_TimeSpan> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_TimeSpan_RTE), "d")] public abstract class L06PB_V_sealed_record_class_TimeSpan_RTE { }
-public sealed class L06PD_V_sealed_record_class_TimeSpan_RTE : L06PB_V_sealed_record_class_TimeSpan_RTE { public Result<V_sealed_record_class_TimeSpan, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_TimeSpan_RE), "d")] public abstract class L06PB_V_sealed_record_class_TimeSpan_RE { }
-public sealed class L06PD_V_sealed_record_class_TimeSpan_RE : L06PB_V_sealed_record_class_TimeSpan_RE { public Result<V_sealed_record_class_TimeSpan> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_enum_O), "d")] public abstract class L06PB_V_sealed_record_class_enum_O { }
-public sealed class L06PD_V_sealed_record_class_enum_O : L06PB_V_sealed_record_class_enum_O { public Option<V_sealed_record_class_enum> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_enum_RTE), "d")] public abstract class L06PB_V_sealed_record_class_enum_RTE { }
-public sealed class L06PD_V_sealed_record_class_enum_RTE : L06PB_V_sealed_record_class_enum_RTE { public Result<V_sealed_record_class_enum, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_enum_RE), "d")] public abstract class L06PB_V_sealed_record_class_enum_RE { }
-public sealed class L06PD_V_sealed_record_class_enum_RE : L06PB_V_sealed_record_class_enum_RE { public Result<V_sealed_record_class_enum> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_flags_enum_O), "d")] public abstract class L06PB_V_sealed_record_class_flags_enum_O { }
-public sealed class L06PD_V_sealed_record_class_flags_enum_O : L06PB_V_sealed_record_class_flags_enum_O { public Option<V_sealed_record_class_flags_enum> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_flags_enum_RTE), "d")] public abstract class L06PB_V_sealed_record_class_flags_enum_RTE { }
-public sealed class L06PD_V_sealed_record_class_flags_enum_RTE : L06PB_V_sealed_record_class_flags_enum_RTE { public Result<V_sealed_record_class_flags_enum, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_flags_enum_RE), "d")] public abstract class L06PB_V_sealed_record_class_flags_enum_RE { }
-public sealed class L06PD_V_sealed_record_class_flags_enum_RE : L06PB_V_sealed_record_class_flags_enum_RE { public Result<V_sealed_record_class_flags_enum> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_Uri_O), "d")] public abstract class L06PB_V_sealed_record_class_Uri_O { }
-public sealed class L06PD_V_sealed_record_class_Uri_O : L06PB_V_sealed_record_class_Uri_O { public Option<V_sealed_record_class_Uri> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_Uri_RTE), "d")] public abstract class L06PB_V_sealed_record_class_Uri_RTE { }
-public sealed class L06PD_V_sealed_record_class_Uri_RTE : L06PB_V_sealed_record_class_Uri_RTE { public Result<V_sealed_record_class_Uri, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_Uri_RE), "d")] public abstract class L06PB_V_sealed_record_class_Uri_RE { }
-public sealed class L06PD_V_sealed_record_class_Uri_RE : L06PB_V_sealed_record_class_Uri_RE { public Result<V_sealed_record_class_Uri> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_NodaTime_Instant_O), "d")] public abstract class L06PB_V_sealed_record_class_NodaTime_Instant_O { }
-public sealed class L06PD_V_sealed_record_class_NodaTime_Instant_O : L06PB_V_sealed_record_class_NodaTime_Instant_O { public Option<V_sealed_record_class_NodaTime_Instant> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_NodaTime_Instant_RTE), "d")] public abstract class L06PB_V_sealed_record_class_NodaTime_Instant_RTE { }
-public sealed class L06PD_V_sealed_record_class_NodaTime_Instant_RTE : L06PB_V_sealed_record_class_NodaTime_Instant_RTE { public Result<V_sealed_record_class_NodaTime_Instant, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_NodaTime_Instant_RE), "d")] public abstract class L06PB_V_sealed_record_class_NodaTime_Instant_RE { }
-public sealed class L06PD_V_sealed_record_class_NodaTime_Instant_RE : L06PB_V_sealed_record_class_NodaTime_Instant_RE { public Result<V_sealed_record_class_NodaTime_Instant> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_own_record_class_O), "d")] public abstract class L06PB_V_sealed_record_class_own_record_class_O { }
-public sealed class L06PD_V_sealed_record_class_own_record_class_O : L06PB_V_sealed_record_class_own_record_class_O { public Option<V_sealed_record_class_own_record_class> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_own_record_class_RTE), "d")] public abstract class L06PB_V_sealed_record_class_own_record_class_RTE { }
-public sealed class L06PD_V_sealed_record_class_own_record_class_RTE : L06PB_V_sealed_record_class_own_record_class_RTE { public Result<V_sealed_record_class_own_record_class, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_sealed_record_class_own_record_class_RE), "d")] public abstract class L06PB_V_sealed_record_class_own_record_class_RE { }
-public sealed class L06PD_V_sealed_record_class_own_record_class_RE : L06PB_V_sealed_record_class_own_record_class_RE { public Result<V_sealed_record_class_own_record_class> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_string_O), "d")] public abstract class L06PB_V_validated_struct_string_O { }
-public sealed class L06PD_V_validated_struct_string_O : L06PB_V_validated_struct_string_O { public Option<V_validated_struct_string> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_string_RTE), "d")] public abstract class L06PB_V_validated_struct_string_RTE { }
-public sealed class L06PD_V_validated_struct_string_RTE : L06PB_V_validated_struct_string_RTE { public Result<V_validated_struct_string, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_string_RE), "d")] public abstract class L06PB_V_validated_struct_string_RE { }
-public sealed class L06PD_V_validated_struct_string_RE : L06PB_V_validated_struct_string_RE { public Result<V_validated_struct_string> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_Guid_O), "d")] public abstract class L06PB_V_validated_struct_Guid_O { }
-public sealed class L06PD_V_validated_struct_Guid_O : L06PB_V_validated_struct_Guid_O { public Option<V_validated_struct_Guid> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_Guid_RTE), "d")] public abstract class L06PB_V_validated_struct_Guid_RTE { }
-public sealed class L06PD_V_validated_struct_Guid_RTE : L06PB_V_validated_struct_Guid_RTE { public Result<V_validated_struct_Guid, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_Guid_RE), "d")] public abstract class L06PB_V_validated_struct_Guid_RE { }
-public sealed class L06PD_V_validated_struct_Guid_RE : L06PB_V_validated_struct_Guid_RE { public Result<V_validated_struct_Guid> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_int_O), "d")] public abstract class L06PB_V_validated_struct_int_O { }
-public sealed class L06PD_V_validated_struct_int_O : L06PB_V_validated_struct_int_O { public Option<V_validated_struct_int> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_int_RTE), "d")] public abstract class L06PB_V_validated_struct_int_RTE { }
-public sealed class L06PD_V_validated_struct_int_RTE : L06PB_V_validated_struct_int_RTE { public Result<V_validated_struct_int, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_int_RE), "d")] public abstract class L06PB_V_validated_struct_int_RE { }
-public sealed class L06PD_V_validated_struct_int_RE : L06PB_V_validated_struct_int_RE { public Result<V_validated_struct_int> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_long_O), "d")] public abstract class L06PB_V_validated_struct_long_O { }
-public sealed class L06PD_V_validated_struct_long_O : L06PB_V_validated_struct_long_O { public Option<V_validated_struct_long> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_long_RTE), "d")] public abstract class L06PB_V_validated_struct_long_RTE { }
-public sealed class L06PD_V_validated_struct_long_RTE : L06PB_V_validated_struct_long_RTE { public Result<V_validated_struct_long, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_long_RE), "d")] public abstract class L06PB_V_validated_struct_long_RE { }
-public sealed class L06PD_V_validated_struct_long_RE : L06PB_V_validated_struct_long_RE { public Result<V_validated_struct_long> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_byte_O), "d")] public abstract class L06PB_V_validated_struct_byte_O { }
-public sealed class L06PD_V_validated_struct_byte_O : L06PB_V_validated_struct_byte_O { public Option<V_validated_struct_byte> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_byte_RTE), "d")] public abstract class L06PB_V_validated_struct_byte_RTE { }
-public sealed class L06PD_V_validated_struct_byte_RTE : L06PB_V_validated_struct_byte_RTE { public Result<V_validated_struct_byte, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_byte_RE), "d")] public abstract class L06PB_V_validated_struct_byte_RE { }
-public sealed class L06PD_V_validated_struct_byte_RE : L06PB_V_validated_struct_byte_RE { public Result<V_validated_struct_byte> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_ulong_O), "d")] public abstract class L06PB_V_validated_struct_ulong_O { }
-public sealed class L06PD_V_validated_struct_ulong_O : L06PB_V_validated_struct_ulong_O { public Option<V_validated_struct_ulong> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_ulong_RTE), "d")] public abstract class L06PB_V_validated_struct_ulong_RTE { }
-public sealed class L06PD_V_validated_struct_ulong_RTE : L06PB_V_validated_struct_ulong_RTE { public Result<V_validated_struct_ulong, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_ulong_RE), "d")] public abstract class L06PB_V_validated_struct_ulong_RE { }
-public sealed class L06PD_V_validated_struct_ulong_RE : L06PB_V_validated_struct_ulong_RE { public Result<V_validated_struct_ulong> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_decimal_O), "d")] public abstract class L06PB_V_validated_struct_decimal_O { }
-public sealed class L06PD_V_validated_struct_decimal_O : L06PB_V_validated_struct_decimal_O { public Option<V_validated_struct_decimal> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_decimal_RTE), "d")] public abstract class L06PB_V_validated_struct_decimal_RTE { }
-public sealed class L06PD_V_validated_struct_decimal_RTE : L06PB_V_validated_struct_decimal_RTE { public Result<V_validated_struct_decimal, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_decimal_RE), "d")] public abstract class L06PB_V_validated_struct_decimal_RE { }
-public sealed class L06PD_V_validated_struct_decimal_RE : L06PB_V_validated_struct_decimal_RE { public Result<V_validated_struct_decimal> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_double_O), "d")] public abstract class L06PB_V_validated_struct_double_O { }
-public sealed class L06PD_V_validated_struct_double_O : L06PB_V_validated_struct_double_O { public Option<V_validated_struct_double> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_double_RTE), "d")] public abstract class L06PB_V_validated_struct_double_RTE { }
-public sealed class L06PD_V_validated_struct_double_RTE : L06PB_V_validated_struct_double_RTE { public Result<V_validated_struct_double, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_double_RE), "d")] public abstract class L06PB_V_validated_struct_double_RE { }
-public sealed class L06PD_V_validated_struct_double_RE : L06PB_V_validated_struct_double_RE { public Result<V_validated_struct_double> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_bool_O), "d")] public abstract class L06PB_V_validated_struct_bool_O { }
-public sealed class L06PD_V_validated_struct_bool_O : L06PB_V_validated_struct_bool_O { public Option<V_validated_struct_bool> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_bool_RTE), "d")] public abstract class L06PB_V_validated_struct_bool_RTE { }
-public sealed class L06PD_V_validated_struct_bool_RTE : L06PB_V_validated_struct_bool_RTE { public Result<V_validated_struct_bool, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_bool_RE), "d")] public abstract class L06PB_V_validated_struct_bool_RE { }
-public sealed class L06PD_V_validated_struct_bool_RE : L06PB_V_validated_struct_bool_RE { public Result<V_validated_struct_bool> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_char_O), "d")] public abstract class L06PB_V_validated_struct_char_O { }
-public sealed class L06PD_V_validated_struct_char_O : L06PB_V_validated_struct_char_O { public Option<V_validated_struct_char> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_char_RTE), "d")] public abstract class L06PB_V_validated_struct_char_RTE { }
-public sealed class L06PD_V_validated_struct_char_RTE : L06PB_V_validated_struct_char_RTE { public Result<V_validated_struct_char, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_char_RE), "d")] public abstract class L06PB_V_validated_struct_char_RE { }
-public sealed class L06PD_V_validated_struct_char_RE : L06PB_V_validated_struct_char_RE { public Result<V_validated_struct_char> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_DateTime_O), "d")] public abstract class L06PB_V_validated_struct_DateTime_O { }
-public sealed class L06PD_V_validated_struct_DateTime_O : L06PB_V_validated_struct_DateTime_O { public Option<V_validated_struct_DateTime> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_DateTime_RTE), "d")] public abstract class L06PB_V_validated_struct_DateTime_RTE { }
-public sealed class L06PD_V_validated_struct_DateTime_RTE : L06PB_V_validated_struct_DateTime_RTE { public Result<V_validated_struct_DateTime, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_DateTime_RE), "d")] public abstract class L06PB_V_validated_struct_DateTime_RE { }
-public sealed class L06PD_V_validated_struct_DateTime_RE : L06PB_V_validated_struct_DateTime_RE { public Result<V_validated_struct_DateTime> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_DateTimeOffset_O), "d")] public abstract class L06PB_V_validated_struct_DateTimeOffset_O { }
-public sealed class L06PD_V_validated_struct_DateTimeOffset_O : L06PB_V_validated_struct_DateTimeOffset_O { public Option<V_validated_struct_DateTimeOffset> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_DateTimeOffset_RTE), "d")] public abstract class L06PB_V_validated_struct_DateTimeOffset_RTE { }
-public sealed class L06PD_V_validated_struct_DateTimeOffset_RTE : L06PB_V_validated_struct_DateTimeOffset_RTE { public Result<V_validated_struct_DateTimeOffset, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_DateTimeOffset_RE), "d")] public abstract class L06PB_V_validated_struct_DateTimeOffset_RE { }
-public sealed class L06PD_V_validated_struct_DateTimeOffset_RE : L06PB_V_validated_struct_DateTimeOffset_RE { public Result<V_validated_struct_DateTimeOffset> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_DateOnly_O), "d")] public abstract class L06PB_V_validated_struct_DateOnly_O { }
-public sealed class L06PD_V_validated_struct_DateOnly_O : L06PB_V_validated_struct_DateOnly_O { public Option<V_validated_struct_DateOnly> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_DateOnly_RTE), "d")] public abstract class L06PB_V_validated_struct_DateOnly_RTE { }
-public sealed class L06PD_V_validated_struct_DateOnly_RTE : L06PB_V_validated_struct_DateOnly_RTE { public Result<V_validated_struct_DateOnly, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_DateOnly_RE), "d")] public abstract class L06PB_V_validated_struct_DateOnly_RE { }
-public sealed class L06PD_V_validated_struct_DateOnly_RE : L06PB_V_validated_struct_DateOnly_RE { public Result<V_validated_struct_DateOnly> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_TimeOnly_O), "d")] public abstract class L06PB_V_validated_struct_TimeOnly_O { }
-public sealed class L06PD_V_validated_struct_TimeOnly_O : L06PB_V_validated_struct_TimeOnly_O { public Option<V_validated_struct_TimeOnly> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_TimeOnly_RTE), "d")] public abstract class L06PB_V_validated_struct_TimeOnly_RTE { }
-public sealed class L06PD_V_validated_struct_TimeOnly_RTE : L06PB_V_validated_struct_TimeOnly_RTE { public Result<V_validated_struct_TimeOnly, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_TimeOnly_RE), "d")] public abstract class L06PB_V_validated_struct_TimeOnly_RE { }
-public sealed class L06PD_V_validated_struct_TimeOnly_RE : L06PB_V_validated_struct_TimeOnly_RE { public Result<V_validated_struct_TimeOnly> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_TimeSpan_O), "d")] public abstract class L06PB_V_validated_struct_TimeSpan_O { }
-public sealed class L06PD_V_validated_struct_TimeSpan_O : L06PB_V_validated_struct_TimeSpan_O { public Option<V_validated_struct_TimeSpan> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_TimeSpan_RTE), "d")] public abstract class L06PB_V_validated_struct_TimeSpan_RTE { }
-public sealed class L06PD_V_validated_struct_TimeSpan_RTE : L06PB_V_validated_struct_TimeSpan_RTE { public Result<V_validated_struct_TimeSpan, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_TimeSpan_RE), "d")] public abstract class L06PB_V_validated_struct_TimeSpan_RE { }
-public sealed class L06PD_V_validated_struct_TimeSpan_RE : L06PB_V_validated_struct_TimeSpan_RE { public Result<V_validated_struct_TimeSpan> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_enum_O), "d")] public abstract class L06PB_V_validated_struct_enum_O { }
-public sealed class L06PD_V_validated_struct_enum_O : L06PB_V_validated_struct_enum_O { public Option<V_validated_struct_enum> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_enum_RTE), "d")] public abstract class L06PB_V_validated_struct_enum_RTE { }
-public sealed class L06PD_V_validated_struct_enum_RTE : L06PB_V_validated_struct_enum_RTE { public Result<V_validated_struct_enum, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_enum_RE), "d")] public abstract class L06PB_V_validated_struct_enum_RE { }
-public sealed class L06PD_V_validated_struct_enum_RE : L06PB_V_validated_struct_enum_RE { public Result<V_validated_struct_enum> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_flags_enum_O), "d")] public abstract class L06PB_V_validated_struct_flags_enum_O { }
-public sealed class L06PD_V_validated_struct_flags_enum_O : L06PB_V_validated_struct_flags_enum_O { public Option<V_validated_struct_flags_enum> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_flags_enum_RTE), "d")] public abstract class L06PB_V_validated_struct_flags_enum_RTE { }
-public sealed class L06PD_V_validated_struct_flags_enum_RTE : L06PB_V_validated_struct_flags_enum_RTE { public Result<V_validated_struct_flags_enum, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_flags_enum_RE), "d")] public abstract class L06PB_V_validated_struct_flags_enum_RE { }
-public sealed class L06PD_V_validated_struct_flags_enum_RE : L06PB_V_validated_struct_flags_enum_RE { public Result<V_validated_struct_flags_enum> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_Uri_O), "d")] public abstract class L06PB_V_validated_struct_Uri_O { }
-public sealed class L06PD_V_validated_struct_Uri_O : L06PB_V_validated_struct_Uri_O { public Option<V_validated_struct_Uri> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_Uri_RTE), "d")] public abstract class L06PB_V_validated_struct_Uri_RTE { }
-public sealed class L06PD_V_validated_struct_Uri_RTE : L06PB_V_validated_struct_Uri_RTE { public Result<V_validated_struct_Uri, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_Uri_RE), "d")] public abstract class L06PB_V_validated_struct_Uri_RE { }
-public sealed class L06PD_V_validated_struct_Uri_RE : L06PB_V_validated_struct_Uri_RE { public Result<V_validated_struct_Uri> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_NodaTime_Instant_O), "d")] public abstract class L06PB_V_validated_struct_NodaTime_Instant_O { }
-public sealed class L06PD_V_validated_struct_NodaTime_Instant_O : L06PB_V_validated_struct_NodaTime_Instant_O { public Option<V_validated_struct_NodaTime_Instant> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_NodaTime_Instant_RTE), "d")] public abstract class L06PB_V_validated_struct_NodaTime_Instant_RTE { }
-public sealed class L06PD_V_validated_struct_NodaTime_Instant_RTE : L06PB_V_validated_struct_NodaTime_Instant_RTE { public Result<V_validated_struct_NodaTime_Instant, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_NodaTime_Instant_RE), "d")] public abstract class L06PB_V_validated_struct_NodaTime_Instant_RE { }
-public sealed class L06PD_V_validated_struct_NodaTime_Instant_RE : L06PB_V_validated_struct_NodaTime_Instant_RE { public Result<V_validated_struct_NodaTime_Instant> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_own_record_class_O), "d")] public abstract class L06PB_V_validated_struct_own_record_class_O { }
-public sealed class L06PD_V_validated_struct_own_record_class_O : L06PB_V_validated_struct_own_record_class_O { public Option<V_validated_struct_own_record_class> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_own_record_class_RTE), "d")] public abstract class L06PB_V_validated_struct_own_record_class_RTE { }
-public sealed class L06PD_V_validated_struct_own_record_class_RTE : L06PB_V_validated_struct_own_record_class_RTE { public Result<V_validated_struct_own_record_class, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_struct_own_record_class_RE), "d")] public abstract class L06PB_V_validated_struct_own_record_class_RE { }
-public sealed class L06PD_V_validated_struct_own_record_class_RE : L06PB_V_validated_struct_own_record_class_RE { public Result<V_validated_struct_own_record_class> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_string_O), "d")] public abstract class L06PB_V_validated_class_string_O { }
-public sealed class L06PD_V_validated_class_string_O : L06PB_V_validated_class_string_O { public Option<V_validated_class_string> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_string_RTE), "d")] public abstract class L06PB_V_validated_class_string_RTE { }
-public sealed class L06PD_V_validated_class_string_RTE : L06PB_V_validated_class_string_RTE { public Result<V_validated_class_string, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_string_RE), "d")] public abstract class L06PB_V_validated_class_string_RE { }
-public sealed class L06PD_V_validated_class_string_RE : L06PB_V_validated_class_string_RE { public Result<V_validated_class_string> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_Guid_O), "d")] public abstract class L06PB_V_validated_class_Guid_O { }
-public sealed class L06PD_V_validated_class_Guid_O : L06PB_V_validated_class_Guid_O { public Option<V_validated_class_Guid> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_Guid_RTE), "d")] public abstract class L06PB_V_validated_class_Guid_RTE { }
-public sealed class L06PD_V_validated_class_Guid_RTE : L06PB_V_validated_class_Guid_RTE { public Result<V_validated_class_Guid, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_Guid_RE), "d")] public abstract class L06PB_V_validated_class_Guid_RE { }
-public sealed class L06PD_V_validated_class_Guid_RE : L06PB_V_validated_class_Guid_RE { public Result<V_validated_class_Guid> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_int_O), "d")] public abstract class L06PB_V_validated_class_int_O { }
-public sealed class L06PD_V_validated_class_int_O : L06PB_V_validated_class_int_O { public Option<V_validated_class_int> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_int_RTE), "d")] public abstract class L06PB_V_validated_class_int_RTE { }
-public sealed class L06PD_V_validated_class_int_RTE : L06PB_V_validated_class_int_RTE { public Result<V_validated_class_int, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_int_RE), "d")] public abstract class L06PB_V_validated_class_int_RE { }
-public sealed class L06PD_V_validated_class_int_RE : L06PB_V_validated_class_int_RE { public Result<V_validated_class_int> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_long_O), "d")] public abstract class L06PB_V_validated_class_long_O { }
-public sealed class L06PD_V_validated_class_long_O : L06PB_V_validated_class_long_O { public Option<V_validated_class_long> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_long_RTE), "d")] public abstract class L06PB_V_validated_class_long_RTE { }
-public sealed class L06PD_V_validated_class_long_RTE : L06PB_V_validated_class_long_RTE { public Result<V_validated_class_long, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_long_RE), "d")] public abstract class L06PB_V_validated_class_long_RE { }
-public sealed class L06PD_V_validated_class_long_RE : L06PB_V_validated_class_long_RE { public Result<V_validated_class_long> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_byte_O), "d")] public abstract class L06PB_V_validated_class_byte_O { }
-public sealed class L06PD_V_validated_class_byte_O : L06PB_V_validated_class_byte_O { public Option<V_validated_class_byte> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_byte_RTE), "d")] public abstract class L06PB_V_validated_class_byte_RTE { }
-public sealed class L06PD_V_validated_class_byte_RTE : L06PB_V_validated_class_byte_RTE { public Result<V_validated_class_byte, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_byte_RE), "d")] public abstract class L06PB_V_validated_class_byte_RE { }
-public sealed class L06PD_V_validated_class_byte_RE : L06PB_V_validated_class_byte_RE { public Result<V_validated_class_byte> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_ulong_O), "d")] public abstract class L06PB_V_validated_class_ulong_O { }
-public sealed class L06PD_V_validated_class_ulong_O : L06PB_V_validated_class_ulong_O { public Option<V_validated_class_ulong> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_ulong_RTE), "d")] public abstract class L06PB_V_validated_class_ulong_RTE { }
-public sealed class L06PD_V_validated_class_ulong_RTE : L06PB_V_validated_class_ulong_RTE { public Result<V_validated_class_ulong, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_ulong_RE), "d")] public abstract class L06PB_V_validated_class_ulong_RE { }
-public sealed class L06PD_V_validated_class_ulong_RE : L06PB_V_validated_class_ulong_RE { public Result<V_validated_class_ulong> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_decimal_O), "d")] public abstract class L06PB_V_validated_class_decimal_O { }
-public sealed class L06PD_V_validated_class_decimal_O : L06PB_V_validated_class_decimal_O { public Option<V_validated_class_decimal> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_decimal_RTE), "d")] public abstract class L06PB_V_validated_class_decimal_RTE { }
-public sealed class L06PD_V_validated_class_decimal_RTE : L06PB_V_validated_class_decimal_RTE { public Result<V_validated_class_decimal, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_decimal_RE), "d")] public abstract class L06PB_V_validated_class_decimal_RE { }
-public sealed class L06PD_V_validated_class_decimal_RE : L06PB_V_validated_class_decimal_RE { public Result<V_validated_class_decimal> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_double_O), "d")] public abstract class L06PB_V_validated_class_double_O { }
-public sealed class L06PD_V_validated_class_double_O : L06PB_V_validated_class_double_O { public Option<V_validated_class_double> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_double_RTE), "d")] public abstract class L06PB_V_validated_class_double_RTE { }
-public sealed class L06PD_V_validated_class_double_RTE : L06PB_V_validated_class_double_RTE { public Result<V_validated_class_double, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_double_RE), "d")] public abstract class L06PB_V_validated_class_double_RE { }
-public sealed class L06PD_V_validated_class_double_RE : L06PB_V_validated_class_double_RE { public Result<V_validated_class_double> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_bool_O), "d")] public abstract class L06PB_V_validated_class_bool_O { }
-public sealed class L06PD_V_validated_class_bool_O : L06PB_V_validated_class_bool_O { public Option<V_validated_class_bool> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_bool_RTE), "d")] public abstract class L06PB_V_validated_class_bool_RTE { }
-public sealed class L06PD_V_validated_class_bool_RTE : L06PB_V_validated_class_bool_RTE { public Result<V_validated_class_bool, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_bool_RE), "d")] public abstract class L06PB_V_validated_class_bool_RE { }
-public sealed class L06PD_V_validated_class_bool_RE : L06PB_V_validated_class_bool_RE { public Result<V_validated_class_bool> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_char_O), "d")] public abstract class L06PB_V_validated_class_char_O { }
-public sealed class L06PD_V_validated_class_char_O : L06PB_V_validated_class_char_O { public Option<V_validated_class_char> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_char_RTE), "d")] public abstract class L06PB_V_validated_class_char_RTE { }
-public sealed class L06PD_V_validated_class_char_RTE : L06PB_V_validated_class_char_RTE { public Result<V_validated_class_char, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_char_RE), "d")] public abstract class L06PB_V_validated_class_char_RE { }
-public sealed class L06PD_V_validated_class_char_RE : L06PB_V_validated_class_char_RE { public Result<V_validated_class_char> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_DateTime_O), "d")] public abstract class L06PB_V_validated_class_DateTime_O { }
-public sealed class L06PD_V_validated_class_DateTime_O : L06PB_V_validated_class_DateTime_O { public Option<V_validated_class_DateTime> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_DateTime_RTE), "d")] public abstract class L06PB_V_validated_class_DateTime_RTE { }
-public sealed class L06PD_V_validated_class_DateTime_RTE : L06PB_V_validated_class_DateTime_RTE { public Result<V_validated_class_DateTime, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_DateTime_RE), "d")] public abstract class L06PB_V_validated_class_DateTime_RE { }
-public sealed class L06PD_V_validated_class_DateTime_RE : L06PB_V_validated_class_DateTime_RE { public Result<V_validated_class_DateTime> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_DateTimeOffset_O), "d")] public abstract class L06PB_V_validated_class_DateTimeOffset_O { }
-public sealed class L06PD_V_validated_class_DateTimeOffset_O : L06PB_V_validated_class_DateTimeOffset_O { public Option<V_validated_class_DateTimeOffset> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_DateTimeOffset_RTE), "d")] public abstract class L06PB_V_validated_class_DateTimeOffset_RTE { }
-public sealed class L06PD_V_validated_class_DateTimeOffset_RTE : L06PB_V_validated_class_DateTimeOffset_RTE { public Result<V_validated_class_DateTimeOffset, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_DateTimeOffset_RE), "d")] public abstract class L06PB_V_validated_class_DateTimeOffset_RE { }
-public sealed class L06PD_V_validated_class_DateTimeOffset_RE : L06PB_V_validated_class_DateTimeOffset_RE { public Result<V_validated_class_DateTimeOffset> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_DateOnly_O), "d")] public abstract class L06PB_V_validated_class_DateOnly_O { }
-public sealed class L06PD_V_validated_class_DateOnly_O : L06PB_V_validated_class_DateOnly_O { public Option<V_validated_class_DateOnly> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_DateOnly_RTE), "d")] public abstract class L06PB_V_validated_class_DateOnly_RTE { }
-public sealed class L06PD_V_validated_class_DateOnly_RTE : L06PB_V_validated_class_DateOnly_RTE { public Result<V_validated_class_DateOnly, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_DateOnly_RE), "d")] public abstract class L06PB_V_validated_class_DateOnly_RE { }
-public sealed class L06PD_V_validated_class_DateOnly_RE : L06PB_V_validated_class_DateOnly_RE { public Result<V_validated_class_DateOnly> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_TimeOnly_O), "d")] public abstract class L06PB_V_validated_class_TimeOnly_O { }
-public sealed class L06PD_V_validated_class_TimeOnly_O : L06PB_V_validated_class_TimeOnly_O { public Option<V_validated_class_TimeOnly> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_TimeOnly_RTE), "d")] public abstract class L06PB_V_validated_class_TimeOnly_RTE { }
-public sealed class L06PD_V_validated_class_TimeOnly_RTE : L06PB_V_validated_class_TimeOnly_RTE { public Result<V_validated_class_TimeOnly, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_TimeOnly_RE), "d")] public abstract class L06PB_V_validated_class_TimeOnly_RE { }
-public sealed class L06PD_V_validated_class_TimeOnly_RE : L06PB_V_validated_class_TimeOnly_RE { public Result<V_validated_class_TimeOnly> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_TimeSpan_O), "d")] public abstract class L06PB_V_validated_class_TimeSpan_O { }
-public sealed class L06PD_V_validated_class_TimeSpan_O : L06PB_V_validated_class_TimeSpan_O { public Option<V_validated_class_TimeSpan> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_TimeSpan_RTE), "d")] public abstract class L06PB_V_validated_class_TimeSpan_RTE { }
-public sealed class L06PD_V_validated_class_TimeSpan_RTE : L06PB_V_validated_class_TimeSpan_RTE { public Result<V_validated_class_TimeSpan, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_TimeSpan_RE), "d")] public abstract class L06PB_V_validated_class_TimeSpan_RE { }
-public sealed class L06PD_V_validated_class_TimeSpan_RE : L06PB_V_validated_class_TimeSpan_RE { public Result<V_validated_class_TimeSpan> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_enum_O), "d")] public abstract class L06PB_V_validated_class_enum_O { }
-public sealed class L06PD_V_validated_class_enum_O : L06PB_V_validated_class_enum_O { public Option<V_validated_class_enum> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_enum_RTE), "d")] public abstract class L06PB_V_validated_class_enum_RTE { }
-public sealed class L06PD_V_validated_class_enum_RTE : L06PB_V_validated_class_enum_RTE { public Result<V_validated_class_enum, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_enum_RE), "d")] public abstract class L06PB_V_validated_class_enum_RE { }
-public sealed class L06PD_V_validated_class_enum_RE : L06PB_V_validated_class_enum_RE { public Result<V_validated_class_enum> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_flags_enum_O), "d")] public abstract class L06PB_V_validated_class_flags_enum_O { }
-public sealed class L06PD_V_validated_class_flags_enum_O : L06PB_V_validated_class_flags_enum_O { public Option<V_validated_class_flags_enum> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_flags_enum_RTE), "d")] public abstract class L06PB_V_validated_class_flags_enum_RTE { }
-public sealed class L06PD_V_validated_class_flags_enum_RTE : L06PB_V_validated_class_flags_enum_RTE { public Result<V_validated_class_flags_enum, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_flags_enum_RE), "d")] public abstract class L06PB_V_validated_class_flags_enum_RE { }
-public sealed class L06PD_V_validated_class_flags_enum_RE : L06PB_V_validated_class_flags_enum_RE { public Result<V_validated_class_flags_enum> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_Uri_O), "d")] public abstract class L06PB_V_validated_class_Uri_O { }
-public sealed class L06PD_V_validated_class_Uri_O : L06PB_V_validated_class_Uri_O { public Option<V_validated_class_Uri> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_Uri_RTE), "d")] public abstract class L06PB_V_validated_class_Uri_RTE { }
-public sealed class L06PD_V_validated_class_Uri_RTE : L06PB_V_validated_class_Uri_RTE { public Result<V_validated_class_Uri, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_Uri_RE), "d")] public abstract class L06PB_V_validated_class_Uri_RE { }
-public sealed class L06PD_V_validated_class_Uri_RE : L06PB_V_validated_class_Uri_RE { public Result<V_validated_class_Uri> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_NodaTime_Instant_O), "d")] public abstract class L06PB_V_validated_class_NodaTime_Instant_O { }
-public sealed class L06PD_V_validated_class_NodaTime_Instant_O : L06PB_V_validated_class_NodaTime_Instant_O { public Option<V_validated_class_NodaTime_Instant> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_NodaTime_Instant_RTE), "d")] public abstract class L06PB_V_validated_class_NodaTime_Instant_RTE { }
-public sealed class L06PD_V_validated_class_NodaTime_Instant_RTE : L06PB_V_validated_class_NodaTime_Instant_RTE { public Result<V_validated_class_NodaTime_Instant, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_NodaTime_Instant_RE), "d")] public abstract class L06PB_V_validated_class_NodaTime_Instant_RE { }
-public sealed class L06PD_V_validated_class_NodaTime_Instant_RE : L06PB_V_validated_class_NodaTime_Instant_RE { public Result<V_validated_class_NodaTime_Instant> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_own_record_class_O), "d")] public abstract class L06PB_V_validated_class_own_record_class_O { }
-public sealed class L06PD_V_validated_class_own_record_class_O : L06PB_V_validated_class_own_record_class_O { public Option<V_validated_class_own_record_class> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_own_record_class_RTE), "d")] public abstract class L06PB_V_validated_class_own_record_class_RTE { }
-public sealed class L06PD_V_validated_class_own_record_class_RTE : L06PB_V_validated_class_own_record_class_RTE { public Result<V_validated_class_own_record_class, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_V_validated_class_own_record_class_RE), "d")] public abstract class L06PB_V_validated_class_own_record_class_RE { }
-public sealed class L06PD_V_validated_class_own_record_class_RE : L06PB_V_validated_class_own_record_class_RE { public Result<V_validated_class_own_record_class> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_PSet_O), "d")] public abstract class L06PB_PSet_O { }
-public sealed class L06PD_PSet_O : L06PB_PSet_O { public Option<PSet> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_PSet_RTE), "d")] public abstract class L06PB_PSet_RTE { }
-public sealed class L06PD_PSet_RTE : L06PB_PSet_RTE { public Result<PSet, ShapeFault> Value { get; set; } }
-[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof(L06PD_PSet_RE), "d")] public abstract class L06PB_PSet_RE { }
-public sealed class L06PD_PSet_RE : L06PB_PSet_RE { public Result<PSet> Value { get; set; } }
diff --git a/tools/probe/corpus/harness/JsonRow.cs b/tools/probe/corpus/harness/JsonRow.cs
deleted file mode 100644
index f39be575..00000000
--- a/tools/probe/corpus/harness/JsonRow.cs
+++ /dev/null
@@ -1,183 +0,0 @@
-// Applies a row's json.* axes to JsonSerializerOptions (reflection for every plain bool/enum setting, hand-listed values by name).
-using System.Reflection;
-using System.Text.Encodings.Web;
-using System.Text.Json;
-using System.Text.Json.Serialization;
-using System.Text.Json.Serialization.Metadata;
-using CodoMetis.TypeKit.ValueObjects;
-using NodaTime;
-using NodaTime.Serialization.SystemTextJson;
-namespace Probes.Shapes;
-
-public sealed class UpperPolicy : JsonNamingPolicy { public override string ConvertName(string name) => name.ToUpperInvariant(); }
-
-public static class Make
-{
-    /// <summary>
-    /// The type a nullable one holds: under http.nullability=nullable an entry's Vo and Plain are <c>T?</c>, the types the
-    /// endpoints declare, while the value object is still made by <c>From(T)</c> and read through its <c>Value</c>.
-    /// </summary>
-    public static Type Held(Type t) => Nullable.GetUnderlyingType(t) ?? t;
-    /// <summary>Whether a type admits null: a class, or a struct made nullable. A value object and its twin admit it alike (Equivalence).</summary>
-    public static bool AdmitsNull(Type t) => !t.IsValueType || Nullable.GetUnderlyingType(t) is not null;
-
-    /// <summary>Creates the value object over a plain sample (From / FromKnownGood), with optional parameters filled.</summary>
-    public static object Vo(Entry e, object plain)
-    {
-        if (e.Kind == "closed-set") return PSet.All.First(x => x.Name == (string)plain);
-        var m = Held(e.Vo).GetMethods(BindingFlags.Public | BindingFlags.Static)
-            .First(x => (x.Name is "FromKnownGood" or "From") && x.GetParameters().Length > 0 && x.GetParameters()[0].ParameterType == Held(e.Plain));
-        var args = m.GetParameters().Select((p, i) => i == 0 ? plain : Type.Missing).ToArray();
-        return m.Invoke(null, BindingFlags.OptionalParamBinding | BindingFlags.Default, null, args, null)!;
-    }
-    public static object Unwrap(Entry e, object vo) => e.Kind == "closed-set" ? ((PSet)vo).Name : Held(e.Vo).GetProperty("Value")!.GetValue(vo)!;
-}
-
-/// <summary>A converter an application registers for the wrapped type: writes "own:" + the default JSON.</summary>
-public sealed class OwnWrappedConverter<T>(JsonSerializerOptions inner) : JsonConverter<T>
-{
-    public override T? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
-    {
-        var s = reader.GetString() ?? throw new JsonException("null");
-        if (!s.StartsWith("own:")) throw new JsonException("not own");
-        return JsonSerializer.Deserialize<T>(s[4..], inner);
-    }
-    public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options) => writer.WriteStringValue("own:" + JsonSerializer.Serialize(value, inner));
-    public override T ReadAsPropertyName(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => Read(ref reader, typeToConvert, options)!;
-    public override void WriteAsPropertyName(Utf8JsonWriter writer, T value, JsonSerializerOptions options) => writer.WritePropertyName("own:" + JsonSerializer.Serialize(value, inner));
-}
-
-/// <summary>A converter an application registers for the value object itself: writes "vo:" + the wrapped value's default JSON.</summary>
-public sealed class OwnVoFactory(Entry e, JsonSerializerOptions inner) : JsonConverterFactory
-{
-    public override bool CanConvert(Type t) => t == Make.Held(e.Vo);   // System.Text.Json asks for T, never for T?
-    public override JsonConverter? CreateConverter(Type t, JsonSerializerOptions options) =>
-        (JsonConverter)Activator.CreateInstance(typeof(OwnVo<>).MakeGenericType(t), e, inner)!;
-}
-public sealed class OwnVo<V>(Entry e, JsonSerializerOptions inner) : JsonConverter<V>
-{
-    public override V? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
-    {
-        var s = reader.GetString() ?? throw new JsonException("null");
-        if (!s.StartsWith("vo:")) throw new JsonException("not vo");
-        return (V)Make.Vo(e, JsonSerializer.Deserialize(s[3..], Make.Held(e.Plain), inner)!);
-    }
-    public override void Write(Utf8JsonWriter writer, V value, JsonSerializerOptions options) =>
-        writer.WriteStringValue("vo:" + JsonSerializer.Serialize(Make.Unwrap(e, value!), Make.Held(e.Plain), inner));
-    public override V ReadAsPropertyName(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => Read(ref reader, typeToConvert, options)!;
-    public override void WriteAsPropertyName(Utf8JsonWriter writer, V value, JsonSerializerOptions options) =>
-        writer.WritePropertyName("vo:" + JsonSerializer.Serialize(Make.Unwrap(e, value!), Make.Held(e.Plain), inner));
-}
-
-public sealed record Applied(JsonSerializerOptions? Options, string? Refused);
-
-public static class JsonRow
-{
-    public static JsonSerializerOptions Inner(Entry e)
-    {
-        var o = new JsonSerializerOptions();
-        if (e.Wrapped == "NodaTime.Instant") o.ConfigureForNodaTime(DateTimeZoneProviders.Tzdb);
-        return o;
-    }
-
-    /// <summary>Applies every json.* axis of the row to <paramref name="into"/> (or a new instance). Refused = STJ rejected a combination with an exception of its own (a pass).</summary>
-    public static Applied Apply(Row r, Entry e, JsonSerializerOptions? into = null)
-    {
-        var o = into ?? new JsonSerializerOptions();
-        var dropped = new List<string>();
-        if (e.Wrapped == "NodaTime.Instant") o.ConfigureForNodaTime(DateTimeZoneProviders.Tzdb);
-        if (r.Get("json.PreferredObjectCreationHandling") == "Populate" && r.Get("json.ReferenceHandler") is not (null or "default"))
-        {
-            dropped.Add("json.PreferredObjectCreationHandling=Populate (STJ: incompatible with reference handling)");
-            r.Substituted("json.PreferredObjectCreationHandling", "default", "STJ: incompatible with reference handling");
-            r = r.With("json.PreferredObjectCreationHandling", "default");
-        }
-        // resolver before chain: a chain on top of a resolver is a combination STJ may refuse
-        foreach (var kv in r.All.Where(kv => kv.Key.StartsWith("json.") && kv.Value != "default").OrderBy(kv => kv.Key == "json.TypeInfoResolverChain" ? 1 : 0))
-        {
-            try { Set(r, o, kv.Key[5..], kv.Value, e); }
-            catch (Exception ex) when (ex is ArgumentException or InvalidOperationException or NotSupportedException)
-            {
-                // STJ refuses this setting with an exception of its own: a pass for the pairs of that value; the rest of the row is still probed
-                dropped.Add($"{kv.Key}={kv.Value} ({ex.GetType().Name})");
-                r.Substituted(kv.Key, "default", "STJ refused it: " + ex.GetType().Name);
-            }
-        }
-        r.Note(NoteKeys.Dropped, string.Join(",", dropped));
-        return new(o, dropped.Count == 0 ? null : string.Join(",", dropped));
-    }
-
-    static JsonNamingPolicy? Policy(string v) => v switch
-    {
-        "CamelCase" => JsonNamingPolicy.CamelCase, "SnakeCaseLower" => JsonNamingPolicy.SnakeCaseLower, "SnakeCaseUpper" => JsonNamingPolicy.SnakeCaseUpper,
-        "KebabCaseLower" => JsonNamingPolicy.KebabCaseLower, "KebabCaseUpper" => JsonNamingPolicy.KebabCaseUpper, "own-upper-case" => new UpperPolicy(),
-        _ => throw new ArgumentException("unknown policy " + v)
-    };
-
-    /// <summary>
-    /// json.TypeInfoResolver=source-generated-context is strict: the options resolve through ProbeContext alone, which lists every shape a row
-    /// holds and its twin (shapes.cs), with no reflection behind it; json.TypeInfoResolverChain=context-then-default is the configuration with
-    /// the reflection fallback, the context then reflection, beside it or on its own. A row's shape the context does not list is the generator's gap, a harness error: the serializer's refusal of
-    /// an unlisted type would read as the framework's.
-    /// </summary>
-    static void Listed(Row r, Entry e)
-    {
-        var plain = e.Valid(); var vo = Make.Vo(e, plain);
-        var pos = r["shape.position"]; var con = (r.Get("shape.containing") ?? "class");
-        var (hp, hv) = Sides.Twins(pos, con, e, plain, vo);
-        var missing = Missing(hp.Declared, hv.Declared).Select(t => t.ToString()).ToList();
-        if (missing.Count > 0) { r.Outcome("harness-error", $"ProbeContext does not list {string.Join(", ", missing)}: run tools/probe/generators/shapes.cs"); return; }
-        r.Note(NoteKeys.CtxStrict);
-    }
-
-    /// <summary>The <paramref name="shapes"/> ProbeContext does not list, under json.TypeInfoResolver=source-generated-context: the generator's gap, which the caller reports as a harness error.</summary>
-    public static IEnumerable<Type> Unlisted(Row r, params Type[] shapes) =>
-        r.Is("json.TypeInfoResolver", "source-generated-context") ? Missing(shapes) : [];
-
-    /// <summary>
-    /// The types ProbeContext has no metadata for, asked through the resolver's interface, which builds no contract: building one is the
-    /// serializer's step, where a context refuses an Option or Result made nullable (L06's not-promised entry), not the listing's.
-    /// </summary>
-    static IEnumerable<Type> Missing(params Type[] shapes)
-    {
-        // the context answers what a type's metadata asks the options for (the struct a Nullable holds) too
-        var probe = new JsonSerializerOptions { TypeInfoResolver = ProbeContext.Default };
-        return shapes.Where(t => ((IJsonTypeInfoResolver)ProbeContext.Default).GetTypeInfo(t, probe) is null).ToList();
-    }
-
-    static void Set(Row row, JsonSerializerOptions o, string name, string v, Entry e)
-    {
-        switch (name)
-        {
-            case "PropertyNamingPolicy": o.PropertyNamingPolicy = Policy(v); return;
-            case "DictionaryKeyPolicy": o.DictionaryKeyPolicy = Policy(v); return;
-            case "ReferenceHandler": o.ReferenceHandler = v == "Preserve" ? ReferenceHandler.Preserve : ReferenceHandler.IgnoreCycles; return;
-            case "Encoder": o.Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping; return;
-            case "MaxDepth": o.MaxDepth = int.Parse(v); return;
-            case "Converters":
-                switch (v)
-                {
-                    case "own-for-wrapped": o.Converters.Insert(0, (JsonConverter)Activator.CreateInstance(typeof(OwnWrappedConverter<>).MakeGenericType(Make.Held(e.Plain)), Inner(e))!); break;
-                    case "own-for-value-object": o.Converters.Insert(0, new OwnVoFactory(e, Inner(e))); break;
-                    case "JsonStringEnumConverter": o.Converters.Add(new JsonStringEnumConverter()); break;
-                    case "StoredJsonConverterFactory": o.Converters.Add(new StoredJsonConverterFactory()); break;
-                    default: throw new ArgumentException("unknown converter " + v);
-                }
-                return;
-            case "TypeInfoResolver":
-                if (v == "source-generated-context") { o.TypeInfoResolver = ProbeContext.Default; Listed(row, e); }
-                else o.TypeInfoResolver = new DefaultJsonTypeInfoResolver { Modifiers = { ti => { foreach (var p in ti.Properties) p.Name += "_x"; } } };
-                return;
-            case "TypeInfoResolverChain":
-                // The context, then reflection for what it does not list: under json.TypeInfoResolver=source-generated-context the chain
-                // already starts with the context, which System.Text.Json refuses to insert a second time (the resolver into its own
-                // chain), so the reflection fallback follows it. That pair is the context with the fallback, the strict context's other side.
-                if (!o.TypeInfoResolverChain.Contains(ProbeContext.Default)) o.TypeInfoResolverChain.Add(ProbeContext.Default);
-                o.TypeInfoResolverChain.Add(new DefaultJsonTypeInfoResolver()); return;
-        }
-        var prop = typeof(JsonSerializerOptions).GetProperty(name) ?? throw new ArgumentException("no json option " + name);
-        object value = prop.PropertyType == typeof(bool) ? bool.Parse(v) : prop.PropertyType.IsEnum ? Enum.Parse(prop.PropertyType, v) : throw new ArgumentException($"no hand value for {name}");
-        try { prop.SetValue(o, value); }
-        catch (TargetInvocationException ex) { throw ex.InnerException!; }
-    }
-}
diff --git a/tools/probe/corpus/harness/KeyShapes.g.cs b/tools/probe/corpus/harness/KeyShapes.g.cs
deleted file mode 100644
index 0a98b904..00000000
--- a/tools/probe/corpus/harness/KeyShapes.g.cs
+++ /dev/null
@@ -1,128 +0,0 @@
-// <auto-generated/> by tools/probe/generators/ef.cs keys; the EF key probes' shape catalogue (shape.kind x shape.wrapped). Do not edit.
-#nullable enable
-#pragma warning disable CMTK0014, CS8618, CS1591, CMTK0005, CMTK1000, CMTK0003, CMTK0006, CA1000
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.ValueObjects;
-using Probes.Shapes;
-namespace Probes.Ef;
-public readonly partial record struct K_record_struct_Guid : IValue<Guid>;
-public readonly partial record struct K_record_struct_byte : IValue<byte>;
-public readonly partial record struct K_record_struct_char : IValue<char>;
-public readonly partial record struct K_record_struct_int : IValue<int>;
-public readonly partial record struct K_record_struct_long : IValue<long>;
-public readonly partial record struct K_record_struct_string : IValue<string>;
-public readonly partial record struct K_record_struct_ulong : IValue<ulong>;
-public sealed partial record class K_sealed_record_class_Guid : IValue<Guid>;
-public sealed partial record class K_sealed_record_class_byte : IValue<byte>;
-public sealed partial record class K_sealed_record_class_char : IValue<char>;
-public sealed partial record class K_sealed_record_class_int : IValue<int>;
-public sealed partial record class K_sealed_record_class_long : IValue<long>;
-public sealed partial record class K_sealed_record_class_string : IValue<string>;
-public sealed partial record class K_sealed_record_class_ulong : IValue<ulong>;
-public sealed partial record class K_validated_class_Guid : IValidatedValue<K_validated_class_Guid, Guid, ShapeFault>
-{
-    public static Result<K_validated_class_Guid, ShapeFault> Create(Guid value) =>
-        EqualityComparer<Guid>.Default.Equals(value, Guid.Empty) ? Result.Error(ShapeFault.Refused) : new K_validated_class_Guid(value);
-}
-public sealed partial record class K_validated_class_byte : IValidatedValue<K_validated_class_byte, byte, ShapeFault>
-{
-    public static Result<K_validated_class_byte, ShapeFault> Create(byte value) =>
-        EqualityComparer<byte>.Default.Equals(value, (byte)255) ? Result.Error(ShapeFault.Refused) : new K_validated_class_byte(value);
-}
-public sealed partial record class K_validated_class_char : IValidatedValue<K_validated_class_char, char, ShapeFault>
-{
-    public static Result<K_validated_class_char, ShapeFault> Create(char value) =>
-        EqualityComparer<char>.Default.Equals(value, 'x') ? Result.Error(ShapeFault.Refused) : new K_validated_class_char(value);
-}
-public sealed partial record class K_validated_class_int : IValidatedValue<K_validated_class_int, int, ShapeFault>
-{
-    public static Result<K_validated_class_int, ShapeFault> Create(int value) =>
-        EqualityComparer<int>.Default.Equals(value, -1) ? Result.Error(ShapeFault.Refused) : new K_validated_class_int(value);
-}
-public sealed partial record class K_validated_class_long : IValidatedValue<K_validated_class_long, long, ShapeFault>
-{
-    public static Result<K_validated_class_long, ShapeFault> Create(long value) =>
-        EqualityComparer<long>.Default.Equals(value, -1L) ? Result.Error(ShapeFault.Refused) : new K_validated_class_long(value);
-}
-public sealed partial record class K_validated_class_string : IValidatedValue<K_validated_class_string, string, ShapeFault>
-{
-    public static Result<K_validated_class_string, ShapeFault> Create(string value) =>
-        EqualityComparer<string>.Default.Equals(value, "SECRET-7f3a") ? Result.Error(ShapeFault.Refused) : new K_validated_class_string(value);
-}
-public sealed partial record class K_validated_class_ulong : IValidatedValue<K_validated_class_ulong, ulong, ShapeFault>
-{
-    public static Result<K_validated_class_ulong, ShapeFault> Create(ulong value) =>
-        EqualityComparer<ulong>.Default.Equals(value, 0UL) ? Result.Error(ShapeFault.Refused) : new K_validated_class_ulong(value);
-}
-public readonly partial record struct K_validated_struct_Guid : IValidatedValue<K_validated_struct_Guid, Guid, ShapeFault>
-{
-    public static Result<K_validated_struct_Guid, ShapeFault> Create(Guid value) =>
-        EqualityComparer<Guid>.Default.Equals(value, Guid.Empty) ? Result.Error(ShapeFault.Refused) : new K_validated_struct_Guid(value);
-}
-public readonly partial record struct K_validated_struct_byte : IValidatedValue<K_validated_struct_byte, byte, ShapeFault>
-{
-    public static Result<K_validated_struct_byte, ShapeFault> Create(byte value) =>
-        EqualityComparer<byte>.Default.Equals(value, (byte)255) ? Result.Error(ShapeFault.Refused) : new K_validated_struct_byte(value);
-}
-public readonly partial record struct K_validated_struct_char : IValidatedValue<K_validated_struct_char, char, ShapeFault>
-{
-    public static Result<K_validated_struct_char, ShapeFault> Create(char value) =>
-        EqualityComparer<char>.Default.Equals(value, 'x') ? Result.Error(ShapeFault.Refused) : new K_validated_struct_char(value);
-}
-public readonly partial record struct K_validated_struct_int : IValidatedValue<K_validated_struct_int, int, ShapeFault>
-{
-    public static Result<K_validated_struct_int, ShapeFault> Create(int value) =>
-        EqualityComparer<int>.Default.Equals(value, -1) ? Result.Error(ShapeFault.Refused) : new K_validated_struct_int(value);
-}
-public readonly partial record struct K_validated_struct_long : IValidatedValue<K_validated_struct_long, long, ShapeFault>
-{
-    public static Result<K_validated_struct_long, ShapeFault> Create(long value) =>
-        EqualityComparer<long>.Default.Equals(value, -1L) ? Result.Error(ShapeFault.Refused) : new K_validated_struct_long(value);
-}
-public readonly partial record struct K_validated_struct_string : IValidatedValue<K_validated_struct_string, string, ShapeFault>
-{
-    public static Result<K_validated_struct_string, ShapeFault> Create(string value) =>
-        EqualityComparer<string>.Default.Equals(value, "SECRET-7f3a") ? Result.Error(ShapeFault.Refused) : new K_validated_struct_string(value);
-}
-public readonly partial record struct K_validated_struct_ulong : IValidatedValue<K_validated_struct_ulong, ulong, ShapeFault>
-{
-    public static Result<K_validated_struct_ulong, ShapeFault> Create(ulong value) =>
-        EqualityComparer<ulong>.Default.Equals(value, 0UL) ? Result.Error(ShapeFault.Refused) : new K_validated_struct_ulong(value);
-}
-public static partial class KeyRegistry
-{
-    public static readonly List<EfEntry> All = Build();
-    static List<EfEntry> Build() { var e = new List<EfEntry>(); Fill(e); return e; }
-    public static EfEntry Of(Probes.Shapes.Row r) { var k = r["shape.kind"]; var w = r["shape.wrapped"]; return All.First(x => x.Kind == k && x.Wrapped == w); }
-    public static void Fill(List<EfEntry> e)
-    {
-        e.Add(new EfEntry("record-struct", "Guid", "top-level", typeof(K_record_struct_Guid), typeof(Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111")));
-        e.Add(new EfEntry("record-struct", "byte", "top-level", typeof(K_record_struct_byte), typeof(byte), () => (byte)7));
-        e.Add(new EfEntry("record-struct", "char", "top-level", typeof(K_record_struct_char), typeof(char), () => 'a'));
-        e.Add(new EfEntry("record-struct", "int", "top-level", typeof(K_record_struct_int), typeof(int), () => 42));
-        e.Add(new EfEntry("record-struct", "long", "top-level", typeof(K_record_struct_long), typeof(long), () => 4200000000L));
-        e.Add(new EfEntry("record-struct", "string", "top-level", typeof(K_record_struct_string), typeof(string), () => "alpha"));
-        e.Add(new EfEntry("record-struct", "ulong", "top-level", typeof(K_record_struct_ulong), typeof(ulong), () => 4200000000UL));
-        e.Add(new EfEntry("sealed-record-class", "Guid", "top-level", typeof(K_sealed_record_class_Guid), typeof(Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111")));
-        e.Add(new EfEntry("sealed-record-class", "byte", "top-level", typeof(K_sealed_record_class_byte), typeof(byte), () => (byte)7));
-        e.Add(new EfEntry("sealed-record-class", "char", "top-level", typeof(K_sealed_record_class_char), typeof(char), () => 'a'));
-        e.Add(new EfEntry("sealed-record-class", "int", "top-level", typeof(K_sealed_record_class_int), typeof(int), () => 42));
-        e.Add(new EfEntry("sealed-record-class", "long", "top-level", typeof(K_sealed_record_class_long), typeof(long), () => 4200000000L));
-        e.Add(new EfEntry("sealed-record-class", "string", "top-level", typeof(K_sealed_record_class_string), typeof(string), () => "alpha"));
-        e.Add(new EfEntry("sealed-record-class", "ulong", "top-level", typeof(K_sealed_record_class_ulong), typeof(ulong), () => 4200000000UL));
-        e.Add(new EfEntry("validated-class", "Guid", "top-level", typeof(K_validated_class_Guid), typeof(Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111")));
-        e.Add(new EfEntry("validated-class", "byte", "top-level", typeof(K_validated_class_byte), typeof(byte), () => (byte)7));
-        e.Add(new EfEntry("validated-class", "char", "top-level", typeof(K_validated_class_char), typeof(char), () => 'a'));
-        e.Add(new EfEntry("validated-class", "int", "top-level", typeof(K_validated_class_int), typeof(int), () => 42));
-        e.Add(new EfEntry("validated-class", "long", "top-level", typeof(K_validated_class_long), typeof(long), () => 4200000000L));
-        e.Add(new EfEntry("validated-class", "string", "top-level", typeof(K_validated_class_string), typeof(string), () => "alpha"));
-        e.Add(new EfEntry("validated-class", "ulong", "top-level", typeof(K_validated_class_ulong), typeof(ulong), () => 4200000000UL));
-        e.Add(new EfEntry("validated-struct", "Guid", "top-level", typeof(K_validated_struct_Guid), typeof(Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111")));
-        e.Add(new EfEntry("validated-struct", "byte", "top-level", typeof(K_validated_struct_byte), typeof(byte), () => (byte)7));
-        e.Add(new EfEntry("validated-struct", "char", "top-level", typeof(K_validated_struct_char), typeof(char), () => 'a'));
-        e.Add(new EfEntry("validated-struct", "int", "top-level", typeof(K_validated_struct_int), typeof(int), () => 42));
-        e.Add(new EfEntry("validated-struct", "long", "top-level", typeof(K_validated_struct_long), typeof(long), () => 4200000000L));
-        e.Add(new EfEntry("validated-struct", "string", "top-level", typeof(K_validated_struct_string), typeof(string), () => "alpha"));
-        e.Add(new EfEntry("validated-struct", "ulong", "top-level", typeof(K_validated_struct_ulong), typeof(ulong), () => 4200000000UL));
-    }
-}
diff --git a/tools/probe/corpus/harness/L01JsonBytesProbe.cs b/tools/probe/corpus/harness/L01JsonBytesProbe.cs
deleted file mode 100644
index 4eb89c77..00000000
--- a/tools/probe/corpus/harness/L01JsonBytesProbe.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Claim L01-json-bytes (README#what-typekit-guarantees "Swapping a primitive for a value object keeps the JSON"; docs/json.md#the-wrapped-types-json):
-// the value object's JSON is the wrapped type's, byte for byte, under whatever options, as value and as key, and each reads the other's JSON.
-// Oracle: differential (JsonParity). Expected: no failure for any row; STJ refusing its own option combination, and the documented
-// Preserve refusal, are passes.
-using Probes.Shapes;
-using System.Text.Json;
-namespace Probes;
-public sealed class L01JsonBytesProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("L01JsonBytesProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, async r =>
-    {
-        var e = Registry.Of(r);
-        var a = JsonRow.Apply(r, e);
-        JsonSerializerOptions? plainOpts = null;
-        if (e.Kind == "closed-set" && r.Is("json.Converters", "own-for-wrapped")) plainOpts = JsonRow.Apply(r.With("json.Converters", "default"), e).Options; // a closed set travels as its name, not as a string
-        await Task.CompletedTask;
-        return JsonParity.Check(r, e, a.Options!, r["shape.position"], (r.Get("shape.containing") ?? "class"), r["input.json"], plainOpts);
-    });
-}
diff --git a/tools/probe/corpus/harness/L02NoQuoteProbe.cs b/tools/probe/corpus/harness/L02NoQuoteProbe.cs
deleted file mode 100644
index 11f88a8b..00000000
--- a/tools/probe/corpus/harness/L02NoQuoteProbe.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Claim L02-no-quote (README#what-typekit-guarantees; src/CodoMetis.TypeKit.Generators/README.md#parsing-and-formatting). L02 (exception): a rejection never repeats the input.
-// Expected: no failure for any row; the documented differences (lossy default text of TimeOnly/DateTime/DateTimeOffset, a registered converter, StoredJsonConverterFactory) are passes.
-using Probes.Shapes;
-namespace Probes;
-public sealed class L02NoQuoteProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("L02NoQuoteProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, r => Task.FromResult(TextClaims.NoQuote(r, Registry.Of(r))));
-}
diff --git a/tools/probe/corpus/harness/L03OneRuleProbe.cs b/tools/probe/corpus/harness/L03OneRuleProbe.cs
deleted file mode 100644
index e8e1fd24..00000000
--- a/tools/probe/corpus/harness/L03OneRuleProbe.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Claim L03-one-rule (README#what-typekit-guarantees; src/CodoMetis.TypeKit.Generators/README.md#parsing-and-formatting). L03 (claim): every entry runs Create and names its fault.
-// Expected: no failure for any row; the documented differences (lossy default text of TimeOnly/DateTime/DateTimeOffset, a registered converter, StoredJsonConverterFactory) are passes.
-using Probes.Shapes;
-namespace Probes;
-public sealed class L03OneRuleProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("L03OneRuleProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, r => Task.FromResult(TextClaims.OneRule(r, Registry.Of(r))));
-}
diff --git a/tools/probe/corpus/harness/L04RoundTripProbe.cs b/tools/probe/corpus/harness/L04RoundTripProbe.cs
deleted file mode 100644
index 2ae7ad0c..00000000
--- a/tools/probe/corpus/harness/L04RoundTripProbe.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Claim L04-round-trip (README#what-typekit-guarantees; src/CodoMetis.TypeKit.Generators/README.md#parsing-and-formatting). L04 round trip (metamorphic): VO text/JSON written by the project reads back as the same value.
-// Expected: no failure for any row; the documented differences (lossy default text of TimeOnly/DateTime/DateTimeOffset, a registered converter, StoredJsonConverterFactory) are passes.
-using Probes.Shapes;
-namespace Probes;
-public sealed class L04RoundTripProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("L04RoundTripProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, r => Task.FromResult(TextClaims.RoundTrip(r, Registry.Of(r))));
-}
diff --git a/tools/probe/corpus/harness/L05Shapes.g.cs b/tools/probe/corpus/harness/L05Shapes.g.cs
deleted file mode 100644
index f3f576ad..00000000
--- a/tools/probe/corpus/harness/L05Shapes.g.cs
+++ /dev/null
@@ -1,575 +0,0 @@
-// <auto-generated/> by tools/probe/generators/json-family.cs from the rows of L05-equality. Do not edit.
-#nullable enable
-#pragma warning disable CS1591, CMTK0005, CMTK1023 // CMTK1023: a base record with an explicit IEquatable is the shape under test
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.ValueObjects;
-using CodoMetis.TypeKit.ClosedSets;
-using Probes.Shapes;
-namespace Probes.Json;
-
-public interface IL05Tag { string Tag { get; } }
-public abstract record L05B1;
-public abstract record L05B2a;
-public abstract record L05B2b : L05B2a;
-public abstract record L05B3a;
-public abstract record L05B3b : L05B3a;
-public abstract record L05B3c : L05B3b;
-// a deeper base whose own IEquatable says "never equal": the value object must not use it
-public abstract record L05E0 : IEquatable<L05E0> { bool IEquatable<L05E0>.Equals(L05E0? other) => false; }
-public abstract record L05E1 : L05E0;
-public abstract class L05CB1;
-public abstract class L05CB2a;
-public abstract class L05CB2b : L05CB2a;
-public abstract class L05CB3a;
-public abstract class L05CB3b : L05CB3a;
-public abstract class L05CB3c : L05CB3b;
-public abstract class L05CE0 : IEquatable<L05CE0> { bool IEquatable<L05CE0>.Equals(L05CE0? other) => ReferenceEquals(this, other); }
-public abstract class L05CE1 : L05CE0;
-
-public partial class L05Oc0 { public sealed partial class L05_0_closed_set__ : L05CB1, IClosedSet<L05_0_closed_set__> { public static readonly L05_0_closed_set__ Alpha = new(); public static readonly L05_0_closed_set__ Beta = new(); } }
-public partial class L05Ot1 { public partial class Inner { public sealed partial class L05_1_closed_set__ : L05CB1, IClosedSet<L05_1_closed_set__> { public static readonly L05_1_closed_set__ Alpha = new(); public static readonly L05_1_closed_set__ Beta = new(); } } }
-public partial class L05Oc2 { public sealed partial class L05_2_closed_set__ : L05CB2b, IClosedSet<L05_2_closed_set__> { public static readonly L05_2_closed_set__ Alpha = new(); public static readonly L05_2_closed_set__ Beta = new(); } }
-public partial struct L05Os3 { public sealed partial class L05_3_closed_set__ : L05CB2b, IClosedSet<L05_3_closed_set__> { public static readonly L05_3_closed_set__ Alpha = new(); public static readonly L05_3_closed_set__ Beta = new(); } }
-public sealed partial class L05_4_closed_set__ : L05CB2b, IClosedSet<L05_4_closed_set__> { public static readonly L05_4_closed_set__ Alpha = new(); public static readonly L05_4_closed_set__ Beta = new(); }
-public partial class L05Oc5 { public sealed partial class L05_5_closed_set__ : L05CB3c, IClosedSet<L05_5_closed_set__> { public static readonly L05_5_closed_set__ Alpha = new(); public static readonly L05_5_closed_set__ Beta = new(); } }
-public partial struct L05Os6 { public sealed partial class L05_6_closed_set__ : L05CB3c, IClosedSet<L05_6_closed_set__> { public static readonly L05_6_closed_set__ Alpha = new(); public static readonly L05_6_closed_set__ Beta = new(); } }
-public partial class L05Ot7 { public partial class Inner { public sealed partial class L05_7_closed_set__ : L05CB3c, IClosedSet<L05_7_closed_set__> { public static readonly L05_7_closed_set__ Alpha = new(); public static readonly L05_7_closed_set__ Beta = new(); } } }
-public sealed partial class L05_8_closed_set__ : L05CB3c, IClosedSet<L05_8_closed_set__> { public static readonly L05_8_closed_set__ Alpha = new(); public static readonly L05_8_closed_set__ Beta = new(); }
-public partial class L05Oc9 { public sealed partial class L05_9_closed_set__ : L05CE1, IClosedSet<L05_9_closed_set__> { public static readonly L05_9_closed_set__ Alpha = new(); public static readonly L05_9_closed_set__ Beta = new(); } }
-public partial struct L05Os10 { public sealed partial class L05_10_closed_set__ : L05CE1, IClosedSet<L05_10_closed_set__> { public static readonly L05_10_closed_set__ Alpha = new(); public static readonly L05_10_closed_set__ Beta = new(); } }
-public partial class L05Ot11 { public partial class Inner { public sealed partial class L05_11_closed_set__ : L05CE1, IClosedSet<L05_11_closed_set__> { public static readonly L05_11_closed_set__ Alpha = new(); public static readonly L05_11_closed_set__ Beta = new(); } } }
-public sealed partial class L05_12_closed_set__ : L05CE1, IClosedSet<L05_12_closed_set__> { public static readonly L05_12_closed_set__ Alpha = new(); public static readonly L05_12_closed_set__ Beta = new(); }
-public partial class L05Oc13 { public sealed partial class L05_13_closed_set__ : IL05Tag, IClosedSet<L05_13_closed_set__> { public static readonly L05_13_closed_set__ Alpha = new(); public static readonly L05_13_closed_set__ Beta = new(); string IL05Tag.Tag => "t"; } }
-public sealed partial class L05_14_closed_set__ : IL05Tag, IClosedSet<L05_14_closed_set__> { public static readonly L05_14_closed_set__ Alpha = new(); public static readonly L05_14_closed_set__ Beta = new(); string IL05Tag.Tag => "t"; }
-public partial struct L05Os15 { public sealed partial class L05_15_closed_set__ : IClosedSet<L05_15_closed_set__> { public static readonly L05_15_closed_set__ Alpha = new(); public static readonly L05_15_closed_set__ Beta = new(); } }
-public partial class L05Oc16 { public readonly partial record struct L05_16_record_struct_DateOnly : IL05Tag, IValue<DateOnly> { string IL05Tag.Tag => "t"; } }
-public partial struct L05Os17 { public readonly partial record struct L05_17_record_struct_DateOnly : IL05Tag, IValue<DateOnly> { string IL05Tag.Tag => "t"; } }
-public partial class L05Ot18 { public partial class Inner { public readonly partial record struct L05_18_record_struct_DateOnly : IL05Tag, IValue<DateOnly> { string IL05Tag.Tag => "t"; } } }
-public partial class L05Oc19 { public readonly partial record struct L05_19_record_struct_DateTime : IValue<DateTime> { } }
-public partial struct L05Os20 { public readonly partial record struct L05_20_record_struct_DateTimeOffset : IValue<DateTimeOffset> { } }
-public partial struct L05Os21 { public readonly partial record struct L05_21_record_struct_Guid : IL05Tag, IValue<Guid> { string IL05Tag.Tag => "t"; } }
-public readonly partial record struct L05_22_record_struct_Guid : IL05Tag, IValue<Guid> { string IL05Tag.Tag => "t"; }
-public partial class L05Oc23 { public readonly partial record struct L05_23_record_struct_NodaTime_Instant : IL05Tag, IValue<global::NodaTime.Instant> { string IL05Tag.Tag => "t"; } }
-public partial struct L05Os24 { public readonly partial record struct L05_24_record_struct_NodaTime_Instant : IL05Tag, IValue<global::NodaTime.Instant> { string IL05Tag.Tag => "t"; } }
-public readonly partial record struct L05_25_record_struct_NodaTime_Instant : IL05Tag, IValue<global::NodaTime.Instant> { string IL05Tag.Tag => "t"; }
-public partial class L05Ot26 { public partial class Inner { public readonly partial record struct L05_26_record_struct_TimeOnly : IL05Tag, IValue<TimeOnly> { string IL05Tag.Tag => "t"; } } }
-public readonly partial record struct L05_27_record_struct_TimeOnly : IL05Tag, IValue<TimeOnly> { string IL05Tag.Tag => "t"; }
-public partial struct L05Os28 { public readonly partial record struct L05_28_record_struct_TimeOnly : IValue<TimeOnly> { } }
-public partial class L05Oc29 { public readonly partial record struct L05_29_record_struct_TimeSpan : IL05Tag, IValue<TimeSpan> { string IL05Tag.Tag => "t"; } }
-public partial class L05Oc30 { public readonly partial record struct L05_30_record_struct_TimeSpan : IValue<TimeSpan> { } }
-public readonly partial record struct L05_31_record_struct_Uri : IL05Tag, IValue<Uri> { string IL05Tag.Tag => "t"; }
-public readonly partial record struct L05_32_record_struct_Uri : IValue<Uri> { }
-public partial struct L05Os33 { public readonly partial record struct L05_33_record_struct_bool : IL05Tag, IValue<bool> { string IL05Tag.Tag => "t"; } }
-public partial class L05Ot34 { public partial class Inner { public readonly partial record struct L05_34_record_struct_bool : IL05Tag, IValue<bool> { string IL05Tag.Tag => "t"; } } }
-public readonly partial record struct L05_35_record_struct_bool : IL05Tag, IValue<bool> { string IL05Tag.Tag => "t"; }
-public readonly partial record struct L05_36_record_struct_byte : IL05Tag, IValue<byte> { string IL05Tag.Tag => "t"; }
-public partial class L05Oc37 { public readonly partial record struct L05_37_record_struct_byte : IValue<byte> { } }
-public readonly partial record struct L05_38_record_struct_char : IL05Tag, IValue<char> { string IL05Tag.Tag => "t"; }
-public partial struct L05Os39 { public readonly partial record struct L05_39_record_struct_char : IValue<char> { } }
-public partial class L05Oc40 { public readonly partial record struct L05_40_record_struct_decimal : IL05Tag, IValue<decimal> { string IL05Tag.Tag => "t"; } }
-public readonly partial record struct L05_41_record_struct_decimal : IL05Tag, IValue<decimal> { string IL05Tag.Tag => "t"; }
-public partial class L05Oc42 { public readonly partial record struct L05_42_record_struct_decimal : IValue<decimal> { } }
-public partial class L05Oc43 { public readonly partial record struct L05_43_record_struct_double : IL05Tag, IValue<double> { string IL05Tag.Tag => "t"; } }
-public partial struct L05Os44 { public readonly partial record struct L05_44_record_struct_double : IL05Tag, IValue<double> { string IL05Tag.Tag => "t"; } }
-public partial class L05Ot45 { public partial class Inner { public readonly partial record struct L05_45_record_struct_double : IL05Tag, IValue<double> { string IL05Tag.Tag => "t"; } } }
-public partial class L05Ot46 { public partial class Inner { public readonly partial record struct L05_46_record_struct_double : IValue<double> { } } }
-public partial class L05Oc47 { public readonly partial record struct L05_47_record_struct_enum : IL05Tag, IValue<PEnum> { string IL05Tag.Tag => "t"; } }
-public partial struct L05Os48 { public readonly partial record struct L05_48_record_struct_enum : IL05Tag, IValue<PEnum> { string IL05Tag.Tag => "t"; } }
-public readonly partial record struct L05_49_record_struct_flags_enum : IL05Tag, IValue<PFlags> { string IL05Tag.Tag => "t"; }
-public readonly partial record struct L05_50_record_struct_flags_enum : IValue<PFlags> { }
-public partial struct L05Os51 { public readonly partial record struct L05_51_record_struct_int : IL05Tag, IValue<int> { string IL05Tag.Tag => "t"; } }
-public partial class L05Ot52 { public partial class Inner { public readonly partial record struct L05_52_record_struct_int : IValue<int> { } } }
-public partial class L05Ot53 { public partial class Inner { public readonly partial record struct L05_53_record_struct_long : IValue<long> { } } }
-public readonly partial record struct L05_54_record_struct_long : IValue<long> { }
-public partial class L05Ot55 { public partial class Inner { public readonly partial record struct L05_55_record_struct_own_record_class : IL05Tag, IValue<PRec> { string IL05Tag.Tag => "t"; } } }
-public partial struct L05Os56 { public readonly partial record struct L05_56_record_struct_string : IL05Tag, IValue<string> { string IL05Tag.Tag => "t"; } }
-public readonly partial record struct L05_57_record_struct_string : IL05Tag, IValue<string> { string IL05Tag.Tag => "t"; }
-public partial class L05Oc58 { public readonly partial record struct L05_58_record_struct_string : IValue<string> { } }
-public partial class L05Oc59 { public readonly partial record struct L05_59_record_struct_ulong : IL05Tag, IValue<ulong> { string IL05Tag.Tag => "t"; } }
-public partial struct L05Os60 { public readonly partial record struct L05_60_record_struct_ulong : IL05Tag, IValue<ulong> { string IL05Tag.Tag => "t"; } }
-public partial struct L05Os61 { public sealed partial record L05_61_sealed_record_class_DateOnly : L05B2b, IValue<DateOnly> { } }
-public sealed partial record L05_62_sealed_record_class_DateOnly : L05B3c, IValue<DateOnly> { }
-public partial struct L05Os63 { public sealed partial record L05_63_sealed_record_class_DateOnly : IValue<DateOnly> { } }
-public sealed partial record L05_64_sealed_record_class_DateOnly : IValue<DateOnly> { }
-public sealed partial record L05_65_sealed_record_class_DateTime : L05B1, IValue<DateTime> { }
-public partial class L05Oc66 { public sealed partial record L05_66_sealed_record_class_DateTime : L05B2b, IValue<DateTime> { } }
-public partial struct L05Os67 { public sealed partial record L05_67_sealed_record_class_DateTime : L05B3c, IValue<DateTime> { } }
-public partial class L05Ot68 { public partial class Inner { public sealed partial record L05_68_sealed_record_class_DateTime : L05B3c, IValue<DateTime> { } } }
-public sealed partial record L05_69_sealed_record_class_DateTime : L05B3c, IValue<DateTime> { }
-public partial struct L05Os70 { public sealed partial record L05_70_sealed_record_class_DateTime : L05E1, IValue<DateTime> { } }
-public partial class L05Oc71 { public sealed partial record L05_71_sealed_record_class_DateTimeOffset : L05B1, IValue<DateTimeOffset> { } }
-public sealed partial record L05_72_sealed_record_class_DateTimeOffset : L05B2b, IValue<DateTimeOffset> { }
-public partial class L05Oc73 { public sealed partial record L05_73_sealed_record_class_DateTimeOffset : L05B3c, IValue<DateTimeOffset> { } }
-public partial class L05Ot74 { public partial class Inner { public sealed partial record L05_74_sealed_record_class_DateTimeOffset : L05B3c, IValue<DateTimeOffset> { } } }
-public sealed partial record L05_75_sealed_record_class_DateTimeOffset : L05B3c, IValue<DateTimeOffset> { }
-public partial class L05Oc76 { public sealed partial record L05_76_sealed_record_class_DateTimeOffset : L05E1, IValue<DateTimeOffset> { } }
-public sealed partial record L05_77_sealed_record_class_DateTimeOffset : L05E1, IValue<DateTimeOffset> { }
-public partial class L05Oc78 { public sealed partial record L05_78_sealed_record_class_Guid : L05B1, IValue<Guid> { } }
-public partial struct L05Os79 { public sealed partial record L05_79_sealed_record_class_Guid : L05B1, IValue<Guid> { } }
-public sealed partial record L05_80_sealed_record_class_Guid : L05B2b, IValue<Guid> { }
-public sealed partial record L05_81_sealed_record_class_Guid : L05B3c, IValue<Guid> { }
-public partial class L05Oc82 { public sealed partial record L05_82_sealed_record_class_Guid : L05E1, IValue<Guid> { } }
-public partial class L05Ot83 { public partial class Inner { public sealed partial record L05_83_sealed_record_class_Guid : L05E1, IValue<Guid> { } } }
-public partial class L05Ot84 { public partial class Inner { public sealed partial record L05_84_sealed_record_class_NodaTime_Instant : L05B1, IValue<global::NodaTime.Instant> { } } }
-public partial struct L05Os85 { public sealed partial record L05_85_sealed_record_class_NodaTime_Instant : L05E1, IValue<global::NodaTime.Instant> { } }
-public partial struct L05Os86 { public sealed partial record L05_86_sealed_record_class_NodaTime_Instant : IValue<global::NodaTime.Instant> { } }
-public partial struct L05Os87 { public sealed partial record L05_87_sealed_record_class_TimeOnly : L05B3c, IValue<TimeOnly> { } }
-public partial class L05Ot88 { public partial class Inner { public sealed partial record L05_88_sealed_record_class_TimeOnly : L05B3c, IValue<TimeOnly> { } } }
-public partial class L05Oc89 { public sealed partial record L05_89_sealed_record_class_TimeSpan : L05B1, IValue<TimeSpan> { } }
-public partial class L05Ot90 { public partial class Inner { public sealed partial record L05_90_sealed_record_class_TimeSpan : L05B1, IValue<TimeSpan> { } } }
-public sealed partial record L05_91_sealed_record_class_TimeSpan : L05B2b, IValue<TimeSpan> { }
-public sealed partial record L05_92_sealed_record_class_TimeSpan : L05B3c, IValue<TimeSpan> { }
-public partial struct L05Os93 { public sealed partial record L05_93_sealed_record_class_TimeSpan : IL05Tag, IValue<TimeSpan> { string IL05Tag.Tag => "t"; } }
-public partial class L05Oc94 { public sealed partial record L05_94_sealed_record_class_TimeSpan : IValue<TimeSpan> { } }
-public partial class L05Oc95 { public sealed partial record L05_95_sealed_record_class_Uri : L05B1, IValue<Uri> { } }
-public partial struct L05Os96 { public sealed partial record L05_96_sealed_record_class_Uri : L05B2b, IValue<Uri> { } }
-public partial struct L05Os97 { public sealed partial record L05_97_sealed_record_class_Uri : L05B3c, IValue<Uri> { } }
-public partial class L05Ot98 { public partial class Inner { public sealed partial record L05_98_sealed_record_class_Uri : L05E1, IValue<Uri> { } } }
-public partial class L05Oc99 { public sealed partial record L05_99_sealed_record_class_bool : L05B2b, IValue<bool> { } }
-public partial class L05Ot100 { public partial class Inner { public sealed partial record L05_100_sealed_record_class_bool : L05B2b, IValue<bool> { } } }
-public partial struct L05Os101 { public sealed partial record L05_101_sealed_record_class_bool : L05B3c, IValue<bool> { } }
-public partial class L05Ot102 { public partial class Inner { public sealed partial record L05_102_sealed_record_class_bool : L05E1, IValue<bool> { } } }
-public partial class L05Ot103 { public partial class Inner { public sealed partial record L05_103_sealed_record_class_bool : IL05Tag, IValue<bool> { string IL05Tag.Tag => "t"; } } }
-public partial class L05Ot104 { public partial class Inner { public sealed partial record L05_104_sealed_record_class_byte : L05B1, IValue<byte> { } } }
-public partial struct L05Os105 { public sealed partial record L05_105_sealed_record_class_byte : L05B2b, IValue<byte> { } }
-public partial class L05Oc106 { public sealed partial record L05_106_sealed_record_class_byte : L05B3c, IValue<byte> { } }
-public sealed partial record L05_107_sealed_record_class_byte : L05B3c, IValue<byte> { }
-public partial class L05Ot108 { public partial class Inner { public sealed partial record L05_108_sealed_record_class_byte : IL05Tag, IValue<byte> { string IL05Tag.Tag => "t"; } } }
-public sealed partial record L05_109_sealed_record_class_byte : IL05Tag, IValue<byte> { string IL05Tag.Tag => "t"; }
-public sealed partial record L05_110_sealed_record_class_byte : IValue<byte> { }
-public partial class L05Ot111 { public partial class Inner { public sealed partial record L05_111_sealed_record_class_char : L05B1, IValue<char> { } } }
-public sealed partial record L05_112_sealed_record_class_char : L05B2b, IValue<char> { }
-public sealed partial record L05_113_sealed_record_class_char : L05E1, IValue<char> { }
-public partial class L05Ot114 { public partial class Inner { public sealed partial record L05_114_sealed_record_class_char : IL05Tag, IValue<char> { string IL05Tag.Tag => "t"; } } }
-public partial class L05Oc115 { public sealed partial record L05_115_sealed_record_class_decimal : L05B1, IValue<decimal> { } }
-public partial struct L05Os116 { public sealed partial record L05_116_sealed_record_class_decimal : L05B3c, IValue<decimal> { } }
-public partial class L05Oc117 { public sealed partial record L05_117_sealed_record_class_decimal : L05E1, IValue<decimal> { } }
-public sealed partial record L05_118_sealed_record_class_decimal : L05E1, IValue<decimal> { }
-public partial class L05Ot119 { public partial class Inner { public sealed partial record L05_119_sealed_record_class_double : L05B1, IValue<double> { } } }
-public sealed partial record L05_120_sealed_record_class_double : L05B2b, IValue<double> { }
-public partial class L05Oc121 { public sealed partial record L05_121_sealed_record_class_double : L05B3c, IValue<double> { } }
-public partial class L05Oc122 { public sealed partial record L05_122_sealed_record_class_double : L05E1, IValue<double> { } }
-public partial struct L05Os123 { public sealed partial record L05_123_sealed_record_class_enum : L05B1, IValue<PEnum> { } }
-public partial class L05Ot124 { public partial class Inner { public sealed partial record L05_124_sealed_record_class_enum : L05B2b, IValue<PEnum> { } } }
-public partial class L05Ot125 { public partial class Inner { public sealed partial record L05_125_sealed_record_class_enum : L05B3c, IValue<PEnum> { } } }
-public partial class L05Ot126 { public partial class Inner { public sealed partial record L05_126_sealed_record_class_enum : L05E1, IValue<PEnum> { } } }
-public partial struct L05Os127 { public sealed partial record L05_127_sealed_record_class_enum : IL05Tag, IValue<PEnum> { string IL05Tag.Tag => "t"; } }
-public partial class L05Oc128 { public sealed partial record L05_128_sealed_record_class_enum : IValue<PEnum> { } }
-public partial class L05Oc129 { public sealed partial record L05_129_sealed_record_class_flags_enum : L05B1, IValue<PFlags> { } }
-public partial class L05Ot130 { public partial class Inner { public sealed partial record L05_130_sealed_record_class_flags_enum : L05B1, IValue<PFlags> { } } }
-public sealed partial record L05_131_sealed_record_class_flags_enum : L05B2b, IValue<PFlags> { }
-public sealed partial record L05_132_sealed_record_class_flags_enum : L05B3c, IValue<PFlags> { }
-public partial class L05Ot133 { public partial class Inner { public sealed partial record L05_133_sealed_record_class_flags_enum : L05E1, IValue<PFlags> { } } }
-public partial struct L05Os134 { public sealed partial record L05_134_sealed_record_class_flags_enum : IL05Tag, IValue<PFlags> { string IL05Tag.Tag => "t"; } }
-public sealed partial record L05_135_sealed_record_class_int : L05B2b, IValue<int> { }
-public partial struct L05Os136 { public sealed partial record L05_136_sealed_record_class_int : L05E1, IValue<int> { } }
-public partial class L05Ot137 { public partial class Inner { public sealed partial record L05_137_sealed_record_class_long : L05B2b, IValue<long> { } } }
-public partial class L05Ot138 { public partial class Inner { public sealed partial record L05_138_sealed_record_class_long : L05B3c, IValue<long> { } } }
-public partial struct L05Os139 { public sealed partial record L05_139_sealed_record_class_long : L05E1, IValue<long> { } }
-public partial class L05Ot140 { public partial class Inner { public sealed partial record L05_140_sealed_record_class_own_record_class : L05B2b, IValue<PRec> { } } }
-public partial struct L05Os141 { public sealed partial record L05_141_sealed_record_class_own_record_class : L05E1, IValue<PRec> { } }
-public partial class L05Ot142 { public partial class Inner { public sealed partial record L05_142_sealed_record_class_own_record_class : L05E1, IValue<PRec> { } } }
-public partial struct L05Os143 { public sealed partial record L05_143_sealed_record_class_string : L05B1, IValue<string> { } }
-public sealed partial record L05_144_sealed_record_class_string : L05B3c, IValue<string> { }
-public partial class L05Ot145 { public partial class Inner { public sealed partial record L05_145_sealed_record_class_string : L05E1, IValue<string> { } } }
-public partial class L05Ot146 { public partial class Inner { public sealed partial record L05_146_sealed_record_class_ulong : L05B3c, IValue<ulong> { } } }
-public partial class L05Ot147 { public partial class Inner { public sealed partial record L05_147_sealed_record_class_ulong : L05E1, IValue<ulong> { } } }
-public sealed partial record L05_148_sealed_record_class_ulong : L05E1, IValue<ulong> { }
-public partial struct L05Os149 { public sealed partial record L05_149_validated_class_DateOnly : L05B1, IValidatedValue<L05_149_validated_class_DateOnly, DateOnly, ShapeFault> { public static Result<L05_149_validated_class_DateOnly, ShapeFault> Create(DateOnly value) => new L05_149_validated_class_DateOnly(value); } }
-public sealed partial record L05_150_validated_class_DateOnly : L05E1, IValidatedValue<L05_150_validated_class_DateOnly, DateOnly, ShapeFault> { public static Result<L05_150_validated_class_DateOnly, ShapeFault> Create(DateOnly value) => new L05_150_validated_class_DateOnly(value); }
-public sealed partial record L05_151_validated_class_DateOnly : IL05Tag, IValidatedValue<L05_151_validated_class_DateOnly, DateOnly, ShapeFault> { public static Result<L05_151_validated_class_DateOnly, ShapeFault> Create(DateOnly value) => new L05_151_validated_class_DateOnly(value); string IL05Tag.Tag => "t"; }
-public partial class L05Ot152 { public partial class Inner { public sealed partial record L05_152_validated_class_DateOnly : IValidatedValue<L05_152_validated_class_DateOnly, DateOnly, ShapeFault> { public static Result<L05_152_validated_class_DateOnly, ShapeFault> Create(DateOnly value) => new L05_152_validated_class_DateOnly(value); } } }
-public partial struct L05Os153 { public sealed partial record L05_153_validated_class_DateTime : L05B1, IValidatedValue<L05_153_validated_class_DateTime, DateTime, ShapeFault> { public static Result<L05_153_validated_class_DateTime, ShapeFault> Create(DateTime value) => new L05_153_validated_class_DateTime(value); } }
-public partial class L05Ot154 { public partial class Inner { public sealed partial record L05_154_validated_class_DateTime : L05B1, IValidatedValue<L05_154_validated_class_DateTime, DateTime, ShapeFault> { public static Result<L05_154_validated_class_DateTime, ShapeFault> Create(DateTime value) => new L05_154_validated_class_DateTime(value); } } }
-public sealed partial record L05_155_validated_class_DateTime : L05B2b, IValidatedValue<L05_155_validated_class_DateTime, DateTime, ShapeFault> { public static Result<L05_155_validated_class_DateTime, ShapeFault> Create(DateTime value) => new L05_155_validated_class_DateTime(value); }
-public partial class L05Oc156 { public sealed partial record L05_156_validated_class_DateTime : L05B3c, IValidatedValue<L05_156_validated_class_DateTime, DateTime, ShapeFault> { public static Result<L05_156_validated_class_DateTime, ShapeFault> Create(DateTime value) => new L05_156_validated_class_DateTime(value); } }
-public partial struct L05Os157 { public sealed partial record L05_157_validated_class_DateTime : L05E1, IValidatedValue<L05_157_validated_class_DateTime, DateTime, ShapeFault> { public static Result<L05_157_validated_class_DateTime, ShapeFault> Create(DateTime value) => new L05_157_validated_class_DateTime(value); } }
-public partial class L05Oc158 { public sealed partial record L05_158_validated_class_DateTimeOffset : IL05Tag, IValidatedValue<L05_158_validated_class_DateTimeOffset, DateTimeOffset, ShapeFault> { public static Result<L05_158_validated_class_DateTimeOffset, ShapeFault> Create(DateTimeOffset value) => new L05_158_validated_class_DateTimeOffset(value); string IL05Tag.Tag => "t"; } }
-public partial class L05Oc159 { public sealed partial record L05_159_validated_class_Guid : L05B2b, IValidatedValue<L05_159_validated_class_Guid, Guid, ShapeFault> { public static Result<L05_159_validated_class_Guid, ShapeFault> Create(Guid value) => new L05_159_validated_class_Guid(value); } }
-public partial class L05Ot160 { public partial class Inner { public sealed partial record L05_160_validated_class_Guid : L05B2b, IValidatedValue<L05_160_validated_class_Guid, Guid, ShapeFault> { public static Result<L05_160_validated_class_Guid, ShapeFault> Create(Guid value) => new L05_160_validated_class_Guid(value); } } }
-public partial class L05Oc161 { public sealed partial record L05_161_validated_class_Guid : IL05Tag, IValidatedValue<L05_161_validated_class_Guid, Guid, ShapeFault> { public static Result<L05_161_validated_class_Guid, ShapeFault> Create(Guid value) => new L05_161_validated_class_Guid(value); string IL05Tag.Tag => "t"; } }
-public partial class L05Ot162 { public partial class Inner { public sealed partial record L05_162_validated_class_NodaTime_Instant : L05B2b, IValidatedValue<L05_162_validated_class_NodaTime_Instant, global::NodaTime.Instant, ShapeFault> { public static Result<L05_162_validated_class_NodaTime_Instant, ShapeFault> Create(global::NodaTime.Instant value) => new L05_162_validated_class_NodaTime_Instant(value); } } }
-public partial class L05Oc163 { public sealed partial record L05_163_validated_class_NodaTime_Instant : L05B3c, IValidatedValue<L05_163_validated_class_NodaTime_Instant, global::NodaTime.Instant, ShapeFault> { public static Result<L05_163_validated_class_NodaTime_Instant, ShapeFault> Create(global::NodaTime.Instant value) => new L05_163_validated_class_NodaTime_Instant(value); } }
-public partial struct L05Os164 { public sealed partial record L05_164_validated_class_NodaTime_Instant : L05B3c, IValidatedValue<L05_164_validated_class_NodaTime_Instant, global::NodaTime.Instant, ShapeFault> { public static Result<L05_164_validated_class_NodaTime_Instant, ShapeFault> Create(global::NodaTime.Instant value) => new L05_164_validated_class_NodaTime_Instant(value); } }
-public partial class L05Ot165 { public partial class Inner { public sealed partial record L05_165_validated_class_NodaTime_Instant : L05B3c, IValidatedValue<L05_165_validated_class_NodaTime_Instant, global::NodaTime.Instant, ShapeFault> { public static Result<L05_165_validated_class_NodaTime_Instant, ShapeFault> Create(global::NodaTime.Instant value) => new L05_165_validated_class_NodaTime_Instant(value); } } }
-public partial class L05Oc166 { public sealed partial record L05_166_validated_class_NodaTime_Instant : L05E1, IValidatedValue<L05_166_validated_class_NodaTime_Instant, global::NodaTime.Instant, ShapeFault> { public static Result<L05_166_validated_class_NodaTime_Instant, ShapeFault> Create(global::NodaTime.Instant value) => new L05_166_validated_class_NodaTime_Instant(value); } }
-public sealed partial record L05_167_validated_class_NodaTime_Instant : L05E1, IValidatedValue<L05_167_validated_class_NodaTime_Instant, global::NodaTime.Instant, ShapeFault> { public static Result<L05_167_validated_class_NodaTime_Instant, ShapeFault> Create(global::NodaTime.Instant value) => new L05_167_validated_class_NodaTime_Instant(value); }
-public partial class L05Oc168 { public sealed partial record L05_168_validated_class_TimeOnly : L05B1, IValidatedValue<L05_168_validated_class_TimeOnly, TimeOnly, ShapeFault> { public static Result<L05_168_validated_class_TimeOnly, ShapeFault> Create(TimeOnly value) => new L05_168_validated_class_TimeOnly(value); } }
-public partial struct L05Os169 { public sealed partial record L05_169_validated_class_TimeOnly : L05B1, IValidatedValue<L05_169_validated_class_TimeOnly, TimeOnly, ShapeFault> { public static Result<L05_169_validated_class_TimeOnly, ShapeFault> Create(TimeOnly value) => new L05_169_validated_class_TimeOnly(value); } }
-public sealed partial record L05_170_validated_class_TimeOnly : L05B2b, IValidatedValue<L05_170_validated_class_TimeOnly, TimeOnly, ShapeFault> { public static Result<L05_170_validated_class_TimeOnly, ShapeFault> Create(TimeOnly value) => new L05_170_validated_class_TimeOnly(value); }
-public partial class L05Oc171 { public sealed partial record L05_171_validated_class_TimeOnly : L05E1, IValidatedValue<L05_171_validated_class_TimeOnly, TimeOnly, ShapeFault> { public static Result<L05_171_validated_class_TimeOnly, ShapeFault> Create(TimeOnly value) => new L05_171_validated_class_TimeOnly(value); } }
-public sealed partial record L05_172_validated_class_TimeOnly : IValidatedValue<L05_172_validated_class_TimeOnly, TimeOnly, ShapeFault> { public static Result<L05_172_validated_class_TimeOnly, ShapeFault> Create(TimeOnly value) => new L05_172_validated_class_TimeOnly(value); }
-public sealed partial record L05_173_validated_class_TimeSpan : L05B1, IValidatedValue<L05_173_validated_class_TimeSpan, TimeSpan, ShapeFault> { public static Result<L05_173_validated_class_TimeSpan, ShapeFault> Create(TimeSpan value) => new L05_173_validated_class_TimeSpan(value); }
-public partial class L05Oc174 { public sealed partial record L05_174_validated_class_TimeSpan : L05B2b, IValidatedValue<L05_174_validated_class_TimeSpan, TimeSpan, ShapeFault> { public static Result<L05_174_validated_class_TimeSpan, ShapeFault> Create(TimeSpan value) => new L05_174_validated_class_TimeSpan(value); } }
-public partial struct L05Os175 { public sealed partial record L05_175_validated_class_TimeSpan : L05B2b, IValidatedValue<L05_175_validated_class_TimeSpan, TimeSpan, ShapeFault> { public static Result<L05_175_validated_class_TimeSpan, ShapeFault> Create(TimeSpan value) => new L05_175_validated_class_TimeSpan(value); } }
-public partial class L05Ot176 { public partial class Inner { public sealed partial record L05_176_validated_class_TimeSpan : L05E1, IValidatedValue<L05_176_validated_class_TimeSpan, TimeSpan, ShapeFault> { public static Result<L05_176_validated_class_TimeSpan, ShapeFault> Create(TimeSpan value) => new L05_176_validated_class_TimeSpan(value); } } }
-public partial struct L05Os177 { public sealed partial record L05_177_validated_class_Uri : L05B1, IValidatedValue<L05_177_validated_class_Uri, Uri, ShapeFault> { public static Result<L05_177_validated_class_Uri, ShapeFault> Create(Uri value) => new L05_177_validated_class_Uri(value); } }
-public partial class L05Ot178 { public partial class Inner { public sealed partial record L05_178_validated_class_Uri : L05B3c, IValidatedValue<L05_178_validated_class_Uri, Uri, ShapeFault> { public static Result<L05_178_validated_class_Uri, ShapeFault> Create(Uri value) => new L05_178_validated_class_Uri(value); } } }
-public sealed partial record L05_179_validated_class_Uri : IL05Tag, IValidatedValue<L05_179_validated_class_Uri, Uri, ShapeFault> { public static Result<L05_179_validated_class_Uri, ShapeFault> Create(Uri value) => new L05_179_validated_class_Uri(value); string IL05Tag.Tag => "t"; }
-public partial class L05Oc180 { public sealed partial record L05_180_validated_class_Uri : IValidatedValue<L05_180_validated_class_Uri, Uri, ShapeFault> { public static Result<L05_180_validated_class_Uri, ShapeFault> Create(Uri value) => new L05_180_validated_class_Uri(value); } }
-public partial struct L05Os181 { public sealed partial record L05_181_validated_class_bool : L05B1, IValidatedValue<L05_181_validated_class_bool, bool, ShapeFault> { public static Result<L05_181_validated_class_bool, ShapeFault> Create(bool value) => new L05_181_validated_class_bool(value); } }
-public partial class L05Oc182 { public sealed partial record L05_182_validated_class_bool : L05E1, IValidatedValue<L05_182_validated_class_bool, bool, ShapeFault> { public static Result<L05_182_validated_class_bool, ShapeFault> Create(bool value) => new L05_182_validated_class_bool(value); } }
-public partial struct L05Os183 { public sealed partial record L05_183_validated_class_bool : IL05Tag, IValidatedValue<L05_183_validated_class_bool, bool, ShapeFault> { public static Result<L05_183_validated_class_bool, ShapeFault> Create(bool value) => new L05_183_validated_class_bool(value); string IL05Tag.Tag => "t"; } }
-public partial struct L05Os184 { public sealed partial record L05_184_validated_class_byte : L05B2b, IValidatedValue<L05_184_validated_class_byte, byte, ShapeFault> { public static Result<L05_184_validated_class_byte, ShapeFault> Create(byte value) => new L05_184_validated_class_byte(value); } }
-public partial class L05Oc185 { public sealed partial record L05_185_validated_class_byte : L05E1, IValidatedValue<L05_185_validated_class_byte, byte, ShapeFault> { public static Result<L05_185_validated_class_byte, ShapeFault> Create(byte value) => new L05_185_validated_class_byte(value); } }
-public partial class L05Ot186 { public partial class Inner { public sealed partial record L05_186_validated_class_byte : L05E1, IValidatedValue<L05_186_validated_class_byte, byte, ShapeFault> { public static Result<L05_186_validated_class_byte, ShapeFault> Create(byte value) => new L05_186_validated_class_byte(value); } } }
-public partial struct L05Os187 { public sealed partial record L05_187_validated_class_byte : IL05Tag, IValidatedValue<L05_187_validated_class_byte, byte, ShapeFault> { public static Result<L05_187_validated_class_byte, ShapeFault> Create(byte value) => new L05_187_validated_class_byte(value); string IL05Tag.Tag => "t"; } }
-public partial class L05Oc188 { public sealed partial record L05_188_validated_class_char : L05B2b, IValidatedValue<L05_188_validated_class_char, char, ShapeFault> { public static Result<L05_188_validated_class_char, ShapeFault> Create(char value) => new L05_188_validated_class_char(value); } }
-public partial class L05Oc189 { public sealed partial record L05_189_validated_class_char : L05B3c, IValidatedValue<L05_189_validated_class_char, char, ShapeFault> { public static Result<L05_189_validated_class_char, ShapeFault> Create(char value) => new L05_189_validated_class_char(value); } }
-public partial class L05Ot190 { public partial class Inner { public sealed partial record L05_190_validated_class_char : L05B3c, IValidatedValue<L05_190_validated_class_char, char, ShapeFault> { public static Result<L05_190_validated_class_char, ShapeFault> Create(char value) => new L05_190_validated_class_char(value); } } }
-public partial class L05Ot191 { public partial class Inner { public sealed partial record L05_191_validated_class_char : L05E1, IValidatedValue<L05_191_validated_class_char, char, ShapeFault> { public static Result<L05_191_validated_class_char, ShapeFault> Create(char value) => new L05_191_validated_class_char(value); } } }
-public sealed partial record L05_192_validated_class_char : L05E1, IValidatedValue<L05_192_validated_class_char, char, ShapeFault> { public static Result<L05_192_validated_class_char, ShapeFault> Create(char value) => new L05_192_validated_class_char(value); }
-public sealed partial record L05_193_validated_class_decimal : L05B1, IValidatedValue<L05_193_validated_class_decimal, decimal, ShapeFault> { public static Result<L05_193_validated_class_decimal, ShapeFault> Create(decimal value) => new L05_193_validated_class_decimal(value); }
-public partial class L05Ot194 { public partial class Inner { public sealed partial record L05_194_validated_class_decimal : L05B2b, IValidatedValue<L05_194_validated_class_decimal, decimal, ShapeFault> { public static Result<L05_194_validated_class_decimal, ShapeFault> Create(decimal value) => new L05_194_validated_class_decimal(value); } } }
-public sealed partial record L05_195_validated_class_decimal : L05B2b, IValidatedValue<L05_195_validated_class_decimal, decimal, ShapeFault> { public static Result<L05_195_validated_class_decimal, ShapeFault> Create(decimal value) => new L05_195_validated_class_decimal(value); }
-public partial struct L05Os196 { public sealed partial record L05_196_validated_class_decimal : IValidatedValue<L05_196_validated_class_decimal, decimal, ShapeFault> { public static Result<L05_196_validated_class_decimal, ShapeFault> Create(decimal value) => new L05_196_validated_class_decimal(value); } }
-public sealed partial record L05_197_validated_class_decimal : IValidatedValue<L05_197_validated_class_decimal, decimal, ShapeFault> { public static Result<L05_197_validated_class_decimal, ShapeFault> Create(decimal value) => new L05_197_validated_class_decimal(value); }
-public sealed partial record L05_198_validated_class_double : L05B2b, IValidatedValue<L05_198_validated_class_double, double, ShapeFault> { public static Result<L05_198_validated_class_double, ShapeFault> Create(double value) => new L05_198_validated_class_double(value); }
-public partial struct L05Os199 { public sealed partial record L05_199_validated_class_double : L05B3c, IValidatedValue<L05_199_validated_class_double, double, ShapeFault> { public static Result<L05_199_validated_class_double, ShapeFault> Create(double value) => new L05_199_validated_class_double(value); } }
-public partial struct L05Os200 { public sealed partial record L05_200_validated_class_double : IL05Tag, IValidatedValue<L05_200_validated_class_double, double, ShapeFault> { public static Result<L05_200_validated_class_double, ShapeFault> Create(double value) => new L05_200_validated_class_double(value); string IL05Tag.Tag => "t"; } }
-public partial class L05Ot201 { public partial class Inner { public sealed partial record L05_201_validated_class_enum : L05B1, IValidatedValue<L05_201_validated_class_enum, PEnum, ShapeFault> { public static Result<L05_201_validated_class_enum, ShapeFault> Create(PEnum value) => new L05_201_validated_class_enum(value); } } }
-public sealed partial record L05_202_validated_class_enum : L05B2b, IValidatedValue<L05_202_validated_class_enum, PEnum, ShapeFault> { public static Result<L05_202_validated_class_enum, ShapeFault> Create(PEnum value) => new L05_202_validated_class_enum(value); }
-public partial class L05Oc203 { public sealed partial record L05_203_validated_class_flags_enum : L05E1, IValidatedValue<L05_203_validated_class_flags_enum, PFlags, ShapeFault> { public static Result<L05_203_validated_class_flags_enum, ShapeFault> Create(PFlags value) => new L05_203_validated_class_flags_enum(value); } }
-public partial class L05Ot204 { public partial class Inner { public sealed partial record L05_204_validated_class_flags_enum : IL05Tag, IValidatedValue<L05_204_validated_class_flags_enum, PFlags, ShapeFault> { public static Result<L05_204_validated_class_flags_enum, ShapeFault> Create(PFlags value) => new L05_204_validated_class_flags_enum(value); string IL05Tag.Tag => "t"; } } }
-public partial struct L05Os205 { public sealed partial record L05_205_validated_class_int : L05B1, IValidatedValue<L05_205_validated_class_int, int, ShapeFault> { public static Result<L05_205_validated_class_int, ShapeFault> Create(int value) => new L05_205_validated_class_int(value); } }
-public partial class L05Oc206 { public sealed partial record L05_206_validated_class_int : L05B3c, IValidatedValue<L05_206_validated_class_int, int, ShapeFault> { public static Result<L05_206_validated_class_int, ShapeFault> Create(int value) => new L05_206_validated_class_int(value); } }
-public partial class L05Oc207 { public sealed partial record L05_207_validated_class_int : IL05Tag, IValidatedValue<L05_207_validated_class_int, int, ShapeFault> { public static Result<L05_207_validated_class_int, ShapeFault> Create(int value) => new L05_207_validated_class_int(value); string IL05Tag.Tag => "t"; } }
-public partial class L05Oc208 { public sealed partial record L05_208_validated_class_long : L05B1, IValidatedValue<L05_208_validated_class_long, long, ShapeFault> { public static Result<L05_208_validated_class_long, ShapeFault> Create(long value) => new L05_208_validated_class_long(value); } }
-public partial class L05Ot209 { public partial class Inner { public sealed partial record L05_209_validated_class_long : L05B2b, IValidatedValue<L05_209_validated_class_long, long, ShapeFault> { public static Result<L05_209_validated_class_long, ShapeFault> Create(long value) => new L05_209_validated_class_long(value); } } }
-public partial class L05Oc210 { public sealed partial record L05_210_validated_class_long : L05E1, IValidatedValue<L05_210_validated_class_long, long, ShapeFault> { public static Result<L05_210_validated_class_long, ShapeFault> Create(long value) => new L05_210_validated_class_long(value); } }
-public partial struct L05Os211 { public sealed partial record L05_211_validated_class_long : L05E1, IValidatedValue<L05_211_validated_class_long, long, ShapeFault> { public static Result<L05_211_validated_class_long, ShapeFault> Create(long value) => new L05_211_validated_class_long(value); } }
-public partial class L05Ot212 { public partial class Inner { public sealed partial record L05_212_validated_class_long : IL05Tag, IValidatedValue<L05_212_validated_class_long, long, ShapeFault> { public static Result<L05_212_validated_class_long, ShapeFault> Create(long value) => new L05_212_validated_class_long(value); string IL05Tag.Tag => "t"; } } }
-public partial struct L05Os213 { public sealed partial record L05_213_validated_class_own_record_class : L05B1, IValidatedValue<L05_213_validated_class_own_record_class, PRec, ShapeFault> { public static Result<L05_213_validated_class_own_record_class, ShapeFault> Create(PRec value) => new L05_213_validated_class_own_record_class(value); } }
-public partial class L05Ot214 { public partial class Inner { public sealed partial record L05_214_validated_class_own_record_class : L05B1, IValidatedValue<L05_214_validated_class_own_record_class, PRec, ShapeFault> { public static Result<L05_214_validated_class_own_record_class, ShapeFault> Create(PRec value) => new L05_214_validated_class_own_record_class(value); } } }
-public sealed partial record L05_215_validated_class_own_record_class : L05B2b, IValidatedValue<L05_215_validated_class_own_record_class, PRec, ShapeFault> { public static Result<L05_215_validated_class_own_record_class, ShapeFault> Create(PRec value) => new L05_215_validated_class_own_record_class(value); }
-public partial struct L05Os216 { public sealed partial record L05_216_validated_class_own_record_class : L05B3c, IValidatedValue<L05_216_validated_class_own_record_class, PRec, ShapeFault> { public static Result<L05_216_validated_class_own_record_class, ShapeFault> Create(PRec value) => new L05_216_validated_class_own_record_class(value); } }
-public partial class L05Ot217 { public partial class Inner { public sealed partial record L05_217_validated_class_own_record_class : L05B3c, IValidatedValue<L05_217_validated_class_own_record_class, PRec, ShapeFault> { public static Result<L05_217_validated_class_own_record_class, ShapeFault> Create(PRec value) => new L05_217_validated_class_own_record_class(value); } } }
-public partial struct L05Os218 { public sealed partial record L05_218_validated_class_own_record_class : L05E1, IValidatedValue<L05_218_validated_class_own_record_class, PRec, ShapeFault> { public static Result<L05_218_validated_class_own_record_class, ShapeFault> Create(PRec value) => new L05_218_validated_class_own_record_class(value); } }
-public partial class L05Oc219 { public sealed partial record L05_219_validated_class_own_record_class : IValidatedValue<L05_219_validated_class_own_record_class, PRec, ShapeFault> { public static Result<L05_219_validated_class_own_record_class, ShapeFault> Create(PRec value) => new L05_219_validated_class_own_record_class(value); } }
-public partial struct L05Os220 { public sealed partial record L05_220_validated_class_string : L05B1, IValidatedValue<L05_220_validated_class_string, string, ShapeFault> { public static Result<L05_220_validated_class_string, ShapeFault> Create(string value) => new L05_220_validated_class_string(value); } }
-public partial class L05Ot221 { public partial class Inner { public sealed partial record L05_221_validated_class_string : L05B2b, IValidatedValue<L05_221_validated_class_string, string, ShapeFault> { public static Result<L05_221_validated_class_string, ShapeFault> Create(string value) => new L05_221_validated_class_string(value); } } }
-public partial class L05Oc222 { public sealed partial record L05_222_validated_class_string : L05B3c, IValidatedValue<L05_222_validated_class_string, string, ShapeFault> { public static Result<L05_222_validated_class_string, ShapeFault> Create(string value) => new L05_222_validated_class_string(value); } }
-public sealed partial record L05_223_validated_class_string : IL05Tag, IValidatedValue<L05_223_validated_class_string, string, ShapeFault> { public static Result<L05_223_validated_class_string, ShapeFault> Create(string value) => new L05_223_validated_class_string(value); string IL05Tag.Tag => "t"; }
-public partial struct L05Os224 { public sealed partial record L05_224_validated_class_ulong : L05B1, IValidatedValue<L05_224_validated_class_ulong, ulong, ShapeFault> { public static Result<L05_224_validated_class_ulong, ShapeFault> Create(ulong value) => new L05_224_validated_class_ulong(value); } }
-public sealed partial record L05_225_validated_class_ulong : L05B1, IValidatedValue<L05_225_validated_class_ulong, ulong, ShapeFault> { public static Result<L05_225_validated_class_ulong, ShapeFault> Create(ulong value) => new L05_225_validated_class_ulong(value); }
-public sealed partial record L05_226_validated_class_ulong : L05B2b, IValidatedValue<L05_226_validated_class_ulong, ulong, ShapeFault> { public static Result<L05_226_validated_class_ulong, ShapeFault> Create(ulong value) => new L05_226_validated_class_ulong(value); }
-public partial class L05Oc227 { public sealed partial record L05_227_validated_class_ulong : L05B3c, IValidatedValue<L05_227_validated_class_ulong, ulong, ShapeFault> { public static Result<L05_227_validated_class_ulong, ShapeFault> Create(ulong value) => new L05_227_validated_class_ulong(value); } }
-public partial class L05Oc228 { public sealed partial record L05_228_validated_class_ulong : IL05Tag, IValidatedValue<L05_228_validated_class_ulong, ulong, ShapeFault> { public static Result<L05_228_validated_class_ulong, ShapeFault> Create(ulong value) => new L05_228_validated_class_ulong(value); string IL05Tag.Tag => "t"; } }
-public partial struct L05Os229 { public sealed partial record L05_229_validated_class_ulong : IL05Tag, IValidatedValue<L05_229_validated_class_ulong, ulong, ShapeFault> { public static Result<L05_229_validated_class_ulong, ShapeFault> Create(ulong value) => new L05_229_validated_class_ulong(value); string IL05Tag.Tag => "t"; } }
-public partial struct L05Os230 { public sealed partial record L05_230_validated_class_ulong : IValidatedValue<L05_230_validated_class_ulong, ulong, ShapeFault> { public static Result<L05_230_validated_class_ulong, ShapeFault> Create(ulong value) => new L05_230_validated_class_ulong(value); } }
-public partial class L05Ot231 { public partial class Inner { public readonly partial record struct L05_231_validated_struct_DateOnly : IL05Tag, IValidatedValue<L05_231_validated_struct_DateOnly, DateOnly, ShapeFault> { public static Result<L05_231_validated_struct_DateOnly, ShapeFault> Create(DateOnly value) => new L05_231_validated_struct_DateOnly(value); string IL05Tag.Tag => "t"; } } }
-public readonly partial record struct L05_232_validated_struct_DateOnly : IValidatedValue<L05_232_validated_struct_DateOnly, DateOnly, ShapeFault> { public static Result<L05_232_validated_struct_DateOnly, ShapeFault> Create(DateOnly value) => new L05_232_validated_struct_DateOnly(value); }
-public partial class L05Ot233 { public partial class Inner { public readonly partial record struct L05_233_validated_struct_DateTime : IL05Tag, IValidatedValue<L05_233_validated_struct_DateTime, DateTime, ShapeFault> { public static Result<L05_233_validated_struct_DateTime, ShapeFault> Create(DateTime value) => new L05_233_validated_struct_DateTime(value); string IL05Tag.Tag => "t"; } } }
-public partial struct L05Os234 { public readonly partial record struct L05_234_validated_struct_DateTimeOffset : IValidatedValue<L05_234_validated_struct_DateTimeOffset, DateTimeOffset, ShapeFault> { public static Result<L05_234_validated_struct_DateTimeOffset, ShapeFault> Create(DateTimeOffset value) => new L05_234_validated_struct_DateTimeOffset(value); } }
-public readonly partial record struct L05_235_validated_struct_DateTimeOffset : IValidatedValue<L05_235_validated_struct_DateTimeOffset, DateTimeOffset, ShapeFault> { public static Result<L05_235_validated_struct_DateTimeOffset, ShapeFault> Create(DateTimeOffset value) => new L05_235_validated_struct_DateTimeOffset(value); }
-public partial class L05Oc236 { public readonly partial record struct L05_236_validated_struct_Guid : IValidatedValue<L05_236_validated_struct_Guid, Guid, ShapeFault> { public static Result<L05_236_validated_struct_Guid, ShapeFault> Create(Guid value) => new L05_236_validated_struct_Guid(value); } }
-public partial struct L05Os237 { public readonly partial record struct L05_237_validated_struct_Guid : IValidatedValue<L05_237_validated_struct_Guid, Guid, ShapeFault> { public static Result<L05_237_validated_struct_Guid, ShapeFault> Create(Guid value) => new L05_237_validated_struct_Guid(value); } }
-public readonly partial record struct L05_238_validated_struct_NodaTime_Instant : IValidatedValue<L05_238_validated_struct_NodaTime_Instant, global::NodaTime.Instant, ShapeFault> { public static Result<L05_238_validated_struct_NodaTime_Instant, ShapeFault> Create(global::NodaTime.Instant value) => new L05_238_validated_struct_NodaTime_Instant(value); }
-public partial class L05Oc239 { public readonly partial record struct L05_239_validated_struct_TimeOnly : IL05Tag, IValidatedValue<L05_239_validated_struct_TimeOnly, TimeOnly, ShapeFault> { public static Result<L05_239_validated_struct_TimeOnly, ShapeFault> Create(TimeOnly value) => new L05_239_validated_struct_TimeOnly(value); string IL05Tag.Tag => "t"; } }
-public readonly partial record struct L05_240_validated_struct_TimeOnly : IValidatedValue<L05_240_validated_struct_TimeOnly, TimeOnly, ShapeFault> { public static Result<L05_240_validated_struct_TimeOnly, ShapeFault> Create(TimeOnly value) => new L05_240_validated_struct_TimeOnly(value); }
-public partial class L05Oc241 { public readonly partial record struct L05_241_validated_struct_TimeSpan : IValidatedValue<L05_241_validated_struct_TimeSpan, TimeSpan, ShapeFault> { public static Result<L05_241_validated_struct_TimeSpan, ShapeFault> Create(TimeSpan value) => new L05_241_validated_struct_TimeSpan(value); } }
-public partial struct L05Os242 { public readonly partial record struct L05_242_validated_struct_Uri : IL05Tag, IValidatedValue<L05_242_validated_struct_Uri, Uri, ShapeFault> { public static Result<L05_242_validated_struct_Uri, ShapeFault> Create(Uri value) => new L05_242_validated_struct_Uri(value); string IL05Tag.Tag => "t"; } }
-public readonly partial record struct L05_243_validated_struct_Uri : IL05Tag, IValidatedValue<L05_243_validated_struct_Uri, Uri, ShapeFault> { public static Result<L05_243_validated_struct_Uri, ShapeFault> Create(Uri value) => new L05_243_validated_struct_Uri(value); string IL05Tag.Tag => "t"; }
-public partial class L05Oc244 { public readonly partial record struct L05_244_validated_struct_Uri : IValidatedValue<L05_244_validated_struct_Uri, Uri, ShapeFault> { public static Result<L05_244_validated_struct_Uri, ShapeFault> Create(Uri value) => new L05_244_validated_struct_Uri(value); } }
-public partial class L05Oc245 { public readonly partial record struct L05_245_validated_struct_bool : IL05Tag, IValidatedValue<L05_245_validated_struct_bool, bool, ShapeFault> { public static Result<L05_245_validated_struct_bool, ShapeFault> Create(bool value) => new L05_245_validated_struct_bool(value); string IL05Tag.Tag => "t"; } }
-public partial class L05Ot246 { public partial class Inner { public readonly partial record struct L05_246_validated_struct_bool : IValidatedValue<L05_246_validated_struct_bool, bool, ShapeFault> { public static Result<L05_246_validated_struct_bool, ShapeFault> Create(bool value) => new L05_246_validated_struct_bool(value); } } }
-public readonly partial record struct L05_247_validated_struct_byte : IL05Tag, IValidatedValue<L05_247_validated_struct_byte, byte, ShapeFault> { public static Result<L05_247_validated_struct_byte, ShapeFault> Create(byte value) => new L05_247_validated_struct_byte(value); string IL05Tag.Tag => "t"; }
-public partial class L05Oc248 { public readonly partial record struct L05_248_validated_struct_char : IL05Tag, IValidatedValue<L05_248_validated_struct_char, char, ShapeFault> { public static Result<L05_248_validated_struct_char, ShapeFault> Create(char value) => new L05_248_validated_struct_char(value); string IL05Tag.Tag => "t"; } }
-public readonly partial record struct L05_249_validated_struct_decimal : IL05Tag, IValidatedValue<L05_249_validated_struct_decimal, decimal, ShapeFault> { public static Result<L05_249_validated_struct_decimal, ShapeFault> Create(decimal value) => new L05_249_validated_struct_decimal(value); string IL05Tag.Tag => "t"; }
-public partial class L05Ot250 { public partial class Inner { public readonly partial record struct L05_250_validated_struct_double : IL05Tag, IValidatedValue<L05_250_validated_struct_double, double, ShapeFault> { public static Result<L05_250_validated_struct_double, ShapeFault> Create(double value) => new L05_250_validated_struct_double(value); string IL05Tag.Tag => "t"; } } }
-public partial class L05Ot251 { public partial class Inner { public readonly partial record struct L05_251_validated_struct_double : IValidatedValue<L05_251_validated_struct_double, double, ShapeFault> { public static Result<L05_251_validated_struct_double, ShapeFault> Create(double value) => new L05_251_validated_struct_double(value); } } }
-public partial class L05Oc252 { public readonly partial record struct L05_252_validated_struct_enum : IValidatedValue<L05_252_validated_struct_enum, PEnum, ShapeFault> { public static Result<L05_252_validated_struct_enum, ShapeFault> Create(PEnum value) => new L05_252_validated_struct_enum(value); } }
-public partial struct L05Os253 { public readonly partial record struct L05_253_validated_struct_enum : IValidatedValue<L05_253_validated_struct_enum, PEnum, ShapeFault> { public static Result<L05_253_validated_struct_enum, ShapeFault> Create(PEnum value) => new L05_253_validated_struct_enum(value); } }
-public partial class L05Ot254 { public partial class Inner { public readonly partial record struct L05_254_validated_struct_enum : IValidatedValue<L05_254_validated_struct_enum, PEnum, ShapeFault> { public static Result<L05_254_validated_struct_enum, ShapeFault> Create(PEnum value) => new L05_254_validated_struct_enum(value); } } }
-public partial class L05Ot255 { public partial class Inner { public readonly partial record struct L05_255_validated_struct_flags_enum : IValidatedValue<L05_255_validated_struct_flags_enum, PFlags, ShapeFault> { public static Result<L05_255_validated_struct_flags_enum, ShapeFault> Create(PFlags value) => new L05_255_validated_struct_flags_enum(value); } } }
-public readonly partial record struct L05_256_validated_struct_flags_enum : IValidatedValue<L05_256_validated_struct_flags_enum, PFlags, ShapeFault> { public static Result<L05_256_validated_struct_flags_enum, ShapeFault> Create(PFlags value) => new L05_256_validated_struct_flags_enum(value); }
-public partial struct L05Os257 { public readonly partial record struct L05_257_validated_struct_int : IL05Tag, IValidatedValue<L05_257_validated_struct_int, int, ShapeFault> { public static Result<L05_257_validated_struct_int, ShapeFault> Create(int value) => new L05_257_validated_struct_int(value); string IL05Tag.Tag => "t"; } }
-public partial class L05Ot258 { public partial class Inner { public readonly partial record struct L05_258_validated_struct_int : IL05Tag, IValidatedValue<L05_258_validated_struct_int, int, ShapeFault> { public static Result<L05_258_validated_struct_int, ShapeFault> Create(int value) => new L05_258_validated_struct_int(value); string IL05Tag.Tag => "t"; } } }
-public partial class L05Ot259 { public partial class Inner { public readonly partial record struct L05_259_validated_struct_int : IValidatedValue<L05_259_validated_struct_int, int, ShapeFault> { public static Result<L05_259_validated_struct_int, ShapeFault> Create(int value) => new L05_259_validated_struct_int(value); } } }
-public readonly partial record struct L05_260_validated_struct_int : IValidatedValue<L05_260_validated_struct_int, int, ShapeFault> { public static Result<L05_260_validated_struct_int, ShapeFault> Create(int value) => new L05_260_validated_struct_int(value); }
-public partial struct L05Os261 { public readonly partial record struct L05_261_validated_struct_long : IL05Tag, IValidatedValue<L05_261_validated_struct_long, long, ShapeFault> { public static Result<L05_261_validated_struct_long, ShapeFault> Create(long value) => new L05_261_validated_struct_long(value); string IL05Tag.Tag => "t"; } }
-public readonly partial record struct L05_262_validated_struct_long : IL05Tag, IValidatedValue<L05_262_validated_struct_long, long, ShapeFault> { public static Result<L05_262_validated_struct_long, ShapeFault> Create(long value) => new L05_262_validated_struct_long(value); string IL05Tag.Tag => "t"; }
-public readonly partial record struct L05_263_validated_struct_own_record_class : IL05Tag, IValidatedValue<L05_263_validated_struct_own_record_class, PRec, ShapeFault> { public static Result<L05_263_validated_struct_own_record_class, ShapeFault> Create(PRec value) => new L05_263_validated_struct_own_record_class(value); string IL05Tag.Tag => "t"; }
-public partial struct L05Os264 { public readonly partial record struct L05_264_validated_struct_own_record_class : IValidatedValue<L05_264_validated_struct_own_record_class, PRec, ShapeFault> { public static Result<L05_264_validated_struct_own_record_class, ShapeFault> Create(PRec value) => new L05_264_validated_struct_own_record_class(value); } }
-public partial class L05Ot265 { public partial class Inner { public readonly partial record struct L05_265_validated_struct_string : IL05Tag, IValidatedValue<L05_265_validated_struct_string, string, ShapeFault> { public static Result<L05_265_validated_struct_string, ShapeFault> Create(string value) => new L05_265_validated_struct_string(value); string IL05Tag.Tag => "t"; } } }
-public partial class L05Oc266 { public readonly partial record struct L05_266_validated_struct_string : IValidatedValue<L05_266_validated_struct_string, string, ShapeFault> { public static Result<L05_266_validated_struct_string, ShapeFault> Create(string value) => new L05_266_validated_struct_string(value); } }
-public readonly partial record struct L05_267_validated_struct_string : IValidatedValue<L05_267_validated_struct_string, string, ShapeFault> { public static Result<L05_267_validated_struct_string, ShapeFault> Create(string value) => new L05_267_validated_struct_string(value); }
-public readonly partial record struct L05_268_validated_struct_ulong : IL05Tag, IValidatedValue<L05_268_validated_struct_ulong, ulong, ShapeFault> { public static Result<L05_268_validated_struct_ulong, ShapeFault> Create(ulong value) => new L05_268_validated_struct_ulong(value); string IL05Tag.Tag => "t"; }
-public readonly partial record struct L05_269_validated_struct_ulong : IValidatedValue<L05_269_validated_struct_ulong, ulong, ShapeFault> { public static Result<L05_269_validated_struct_ulong, ShapeFault> Create(ulong value) => new L05_269_validated_struct_ulong(value); }
-
-public static partial class L05Registry
-{
-    static partial void Fill()
-    {
-        Add("closed-set", "-", "base-depth-1", "nested-in-class", typeof(L05Oc0.L05_0_closed_set__), () => L05Oc0.L05_0_closed_set__.Alpha, () => L05Oc0.L05_0_closed_set__.All.First(m => m.Name == "Alpha"), () => L05Oc0.L05_0_closed_set__.Beta);
-        Add("closed-set", "-", "base-depth-1", "nested-two-levels", typeof(L05Ot1.Inner.L05_1_closed_set__), () => L05Ot1.Inner.L05_1_closed_set__.Alpha, () => L05Ot1.Inner.L05_1_closed_set__.All.First(m => m.Name == "Alpha"), () => L05Ot1.Inner.L05_1_closed_set__.Beta);
-        Add("closed-set", "-", "base-depth-2", "nested-in-class", typeof(L05Oc2.L05_2_closed_set__), () => L05Oc2.L05_2_closed_set__.Alpha, () => L05Oc2.L05_2_closed_set__.All.First(m => m.Name == "Alpha"), () => L05Oc2.L05_2_closed_set__.Beta);
-        Add("closed-set", "-", "base-depth-2", "nested-in-struct", typeof(L05Os3.L05_3_closed_set__), () => L05Os3.L05_3_closed_set__.Alpha, () => L05Os3.L05_3_closed_set__.All.First(m => m.Name == "Alpha"), () => L05Os3.L05_3_closed_set__.Beta);
-        Add("closed-set", "-", "base-depth-2", "top-level", typeof(L05_4_closed_set__), () => L05_4_closed_set__.Alpha, () => L05_4_closed_set__.All.First(m => m.Name == "Alpha"), () => L05_4_closed_set__.Beta);
-        Add("closed-set", "-", "base-depth-3", "nested-in-class", typeof(L05Oc5.L05_5_closed_set__), () => L05Oc5.L05_5_closed_set__.Alpha, () => L05Oc5.L05_5_closed_set__.All.First(m => m.Name == "Alpha"), () => L05Oc5.L05_5_closed_set__.Beta);
-        Add("closed-set", "-", "base-depth-3", "nested-in-struct", typeof(L05Os6.L05_6_closed_set__), () => L05Os6.L05_6_closed_set__.Alpha, () => L05Os6.L05_6_closed_set__.All.First(m => m.Name == "Alpha"), () => L05Os6.L05_6_closed_set__.Beta);
-        Add("closed-set", "-", "base-depth-3", "nested-two-levels", typeof(L05Ot7.Inner.L05_7_closed_set__), () => L05Ot7.Inner.L05_7_closed_set__.Alpha, () => L05Ot7.Inner.L05_7_closed_set__.All.First(m => m.Name == "Alpha"), () => L05Ot7.Inner.L05_7_closed_set__.Beta);
-        Add("closed-set", "-", "base-depth-3", "top-level", typeof(L05_8_closed_set__), () => L05_8_closed_set__.Alpha, () => L05_8_closed_set__.All.First(m => m.Name == "Alpha"), () => L05_8_closed_set__.Beta);
-        Add("closed-set", "-", "base-explicit-IEquatable", "nested-in-class", typeof(L05Oc9.L05_9_closed_set__), () => L05Oc9.L05_9_closed_set__.Alpha, () => L05Oc9.L05_9_closed_set__.All.First(m => m.Name == "Alpha"), () => L05Oc9.L05_9_closed_set__.Beta);
-        Add("closed-set", "-", "base-explicit-IEquatable", "nested-in-struct", typeof(L05Os10.L05_10_closed_set__), () => L05Os10.L05_10_closed_set__.Alpha, () => L05Os10.L05_10_closed_set__.All.First(m => m.Name == "Alpha"), () => L05Os10.L05_10_closed_set__.Beta);
-        Add("closed-set", "-", "base-explicit-IEquatable", "nested-two-levels", typeof(L05Ot11.Inner.L05_11_closed_set__), () => L05Ot11.Inner.L05_11_closed_set__.Alpha, () => L05Ot11.Inner.L05_11_closed_set__.All.First(m => m.Name == "Alpha"), () => L05Ot11.Inner.L05_11_closed_set__.Beta);
-        Add("closed-set", "-", "base-explicit-IEquatable", "top-level", typeof(L05_12_closed_set__), () => L05_12_closed_set__.Alpha, () => L05_12_closed_set__.All.First(m => m.Name == "Alpha"), () => L05_12_closed_set__.Beta);
-        Add("closed-set", "-", "explicit-interface-member", "nested-in-class", typeof(L05Oc13.L05_13_closed_set__), () => L05Oc13.L05_13_closed_set__.Alpha, () => L05Oc13.L05_13_closed_set__.All.First(m => m.Name == "Alpha"), () => L05Oc13.L05_13_closed_set__.Beta);
-        Add("closed-set", "-", "explicit-interface-member", "top-level", typeof(L05_14_closed_set__), () => L05_14_closed_set__.Alpha, () => L05_14_closed_set__.All.First(m => m.Name == "Alpha"), () => L05_14_closed_set__.Beta);
-        Add("closed-set", "-", "none", "nested-in-struct", typeof(L05Os15.L05_15_closed_set__), () => L05Os15.L05_15_closed_set__.Alpha, () => L05Os15.L05_15_closed_set__.All.First(m => m.Name == "Alpha"), () => L05Os15.L05_15_closed_set__.Beta);
-        Add("record-struct", "DateOnly", "explicit-interface-member", "nested-in-class", typeof(L05Oc16.L05_16_record_struct_DateOnly), () => new DateOnly(2026, 10, 15), () => DateOnly.FromDayNumber(new DateOnly(2026, 10, 15).DayNumber), () => new DateOnly(2026, 10, 16));
-        Add("record-struct", "DateOnly", "explicit-interface-member", "nested-in-struct", typeof(L05Os17.L05_17_record_struct_DateOnly), () => new DateOnly(2026, 10, 15), () => DateOnly.FromDayNumber(new DateOnly(2026, 10, 15).DayNumber), () => new DateOnly(2026, 10, 16));
-        Add("record-struct", "DateOnly", "explicit-interface-member", "nested-two-levels", typeof(L05Ot18.Inner.L05_18_record_struct_DateOnly), () => new DateOnly(2026, 10, 15), () => DateOnly.FromDayNumber(new DateOnly(2026, 10, 15).DayNumber), () => new DateOnly(2026, 10, 16));
-        Add("record-struct", "DateTime", "none", "nested-in-class", typeof(L05Oc19.L05_19_record_struct_DateTime), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Utc), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Unspecified), () => new DateTime(2026, 10, 15, 8, 31, 0, DateTimeKind.Utc));
-        Add("record-struct", "DateTimeOffset", "none", "nested-in-struct", typeof(L05Os20.L05_20_record_struct_DateTimeOffset), () => new DateTimeOffset(2026, 10, 15, 8, 30, 0, TimeSpan.Zero), () => new DateTimeOffset(2026, 10, 15, 10, 30, 0, TimeSpan.FromHours(2)), () => new DateTimeOffset(2026, 10, 15, 8, 31, 0, TimeSpan.Zero));
-        Add("record-struct", "Guid", "explicit-interface-member", "nested-in-struct", typeof(L05Os21.L05_21_record_struct_Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111"), () => new Guid("11111111111111111111111111111111"), () => Guid.Parse("22222222-2222-2222-2222-222222222222"));
-        Add("record-struct", "Guid", "explicit-interface-member", "top-level", typeof(L05_22_record_struct_Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111"), () => new Guid("11111111111111111111111111111111"), () => Guid.Parse("22222222-2222-2222-2222-222222222222"));
-        Add("record-struct", "NodaTime.Instant", "explicit-interface-member", "nested-in-class", typeof(L05Oc23.L05_23_record_struct_NodaTime_Instant), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30), () => global::NodaTime.Instant.FromUnixTimeTicks(global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30).ToUnixTimeTicks()), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 31));
-        Add("record-struct", "NodaTime.Instant", "explicit-interface-member", "nested-in-struct", typeof(L05Os24.L05_24_record_struct_NodaTime_Instant), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30), () => global::NodaTime.Instant.FromUnixTimeTicks(global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30).ToUnixTimeTicks()), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 31));
-        Add("record-struct", "NodaTime.Instant", "explicit-interface-member", "top-level", typeof(L05_25_record_struct_NodaTime_Instant), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30), () => global::NodaTime.Instant.FromUnixTimeTicks(global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30).ToUnixTimeTicks()), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 31));
-        Add("record-struct", "TimeOnly", "explicit-interface-member", "nested-two-levels", typeof(L05Ot26.Inner.L05_26_record_struct_TimeOnly), () => new TimeOnly(8, 30, 15), () => new TimeOnly(new TimeOnly(8, 30, 15).Ticks), () => new TimeOnly(8, 30, 16));
-        Add("record-struct", "TimeOnly", "explicit-interface-member", "top-level", typeof(L05_27_record_struct_TimeOnly), () => new TimeOnly(8, 30, 15), () => new TimeOnly(new TimeOnly(8, 30, 15).Ticks), () => new TimeOnly(8, 30, 16));
-        Add("record-struct", "TimeOnly", "none", "nested-in-struct", typeof(L05Os28.L05_28_record_struct_TimeOnly), () => new TimeOnly(8, 30, 15), () => new TimeOnly(new TimeOnly(8, 30, 15).Ticks), () => new TimeOnly(8, 30, 16));
-        Add("record-struct", "TimeSpan", "explicit-interface-member", "nested-in-class", typeof(L05Oc29.L05_29_record_struct_TimeSpan), () => TimeSpan.FromMinutes(90), () => TimeSpan.FromSeconds(5400), () => TimeSpan.FromMinutes(91));
-        Add("record-struct", "TimeSpan", "none", "nested-in-class", typeof(L05Oc30.L05_30_record_struct_TimeSpan), () => TimeSpan.FromMinutes(90), () => TimeSpan.FromSeconds(5400), () => TimeSpan.FromMinutes(91));
-        Add("record-struct", "Uri", "explicit-interface-member", "top-level", typeof(L05_31_record_struct_Uri), () => new Uri("https://example.com/a"), () => new Uri("HTTPS://EXAMPLE.COM/a"), () => new Uri("https://example.com/b"));
-        Add("record-struct", "Uri", "none", "top-level", typeof(L05_32_record_struct_Uri), () => new Uri("https://example.com/a"), () => new Uri("HTTPS://EXAMPLE.COM/a"), () => new Uri("https://example.com/b"));
-        Add("record-struct", "bool", "explicit-interface-member", "nested-in-struct", typeof(L05Os33.L05_33_record_struct_bool), () => false, () => false, () => true);
-        Add("record-struct", "bool", "explicit-interface-member", "nested-two-levels", typeof(L05Ot34.Inner.L05_34_record_struct_bool), () => false, () => false, () => true);
-        Add("record-struct", "bool", "explicit-interface-member", "top-level", typeof(L05_35_record_struct_bool), () => false, () => false, () => true);
-        Add("record-struct", "byte", "explicit-interface-member", "top-level", typeof(L05_36_record_struct_byte), () => (byte)7, () => (byte)7, () => (byte)8);
-        Add("record-struct", "byte", "none", "nested-in-class", typeof(L05Oc37.L05_37_record_struct_byte), () => (byte)7, () => (byte)7, () => (byte)8);
-        Add("record-struct", "char", "explicit-interface-member", "top-level", typeof(L05_38_record_struct_char), () => 'a', () => 'a', () => 'b');
-        Add("record-struct", "char", "none", "nested-in-struct", typeof(L05Os39.L05_39_record_struct_char), () => 'a', () => 'a', () => 'b');
-        Add("record-struct", "decimal", "explicit-interface-member", "nested-in-class", typeof(L05Oc40.L05_40_record_struct_decimal), () => 7.8m, () => 7.80m, () => 7.81m);
-        Add("record-struct", "decimal", "explicit-interface-member", "top-level", typeof(L05_41_record_struct_decimal), () => 7.8m, () => 7.80m, () => 7.81m);
-        Add("record-struct", "decimal", "none", "nested-in-class", typeof(L05Oc42.L05_42_record_struct_decimal), () => 7.8m, () => 7.80m, () => 7.81m);
-        Add("record-struct", "double", "explicit-interface-member", "nested-in-class", typeof(L05Oc43.L05_43_record_struct_double), () => 0.0, () => -0.0, () => 1.5);
-        Add("record-struct", "double", "explicit-interface-member", "nested-in-struct", typeof(L05Os44.L05_44_record_struct_double), () => 0.0, () => -0.0, () => 1.5);
-        Add("record-struct", "double", "explicit-interface-member", "nested-two-levels", typeof(L05Ot45.Inner.L05_45_record_struct_double), () => 0.0, () => -0.0, () => 1.5);
-        Add("record-struct", "double", "none", "nested-two-levels", typeof(L05Ot46.Inner.L05_46_record_struct_double), () => 0.0, () => -0.0, () => 1.5);
-        Add("record-struct", "enum", "explicit-interface-member", "nested-in-class", typeof(L05Oc47.L05_47_record_struct_enum), () => PEnum.B, () => (PEnum)1, () => PEnum.C);
-        Add("record-struct", "enum", "explicit-interface-member", "nested-in-struct", typeof(L05Os48.L05_48_record_struct_enum), () => PEnum.B, () => (PEnum)1, () => PEnum.C);
-        Add("record-struct", "flags-enum", "explicit-interface-member", "top-level", typeof(L05_49_record_struct_flags_enum), () => PFlags.P | PFlags.Q, () => (PFlags)3, () => PFlags.R);
-        Add("record-struct", "flags-enum", "none", "top-level", typeof(L05_50_record_struct_flags_enum), () => PFlags.P | PFlags.Q, () => (PFlags)3, () => PFlags.R);
-        Add("record-struct", "int", "explicit-interface-member", "nested-in-struct", typeof(L05Os51.L05_51_record_struct_int), () => 42, () => 42, () => 43);
-        Add("record-struct", "int", "none", "nested-two-levels", typeof(L05Ot52.Inner.L05_52_record_struct_int), () => 42, () => 42, () => 43);
-        Add("record-struct", "long", "none", "nested-two-levels", typeof(L05Ot53.Inner.L05_53_record_struct_long), () => 4200000000L, () => 4200000000L, () => 4200000001L);
-        Add("record-struct", "long", "none", "top-level", typeof(L05_54_record_struct_long), () => 4200000000L, () => 4200000000L, () => 4200000001L);
-        Add("record-struct", "own-record-class", "explicit-interface-member", "nested-two-levels", typeof(L05Ot55.Inner.L05_55_record_struct_own_record_class), () => new PRec { A = "x", B = 1 }, () => new PRec { A = new string("x".ToCharArray()), B = 1 }, () => new PRec { A = "y", B = 1 });
-        Add("record-struct", "string", "explicit-interface-member", "nested-in-struct", typeof(L05Os56.L05_56_record_struct_string), () => "alpha", () => new string("alpha".ToCharArray()), () => "beta");
-        Add("record-struct", "string", "explicit-interface-member", "top-level", typeof(L05_57_record_struct_string), () => "alpha", () => new string("alpha".ToCharArray()), () => "beta");
-        Add("record-struct", "string", "none", "nested-in-class", typeof(L05Oc58.L05_58_record_struct_string), () => "alpha", () => new string("alpha".ToCharArray()), () => "beta");
-        Add("record-struct", "ulong", "explicit-interface-member", "nested-in-class", typeof(L05Oc59.L05_59_record_struct_ulong), () => 4200000000UL, () => 4200000000UL, () => 4200000001UL);
-        Add("record-struct", "ulong", "explicit-interface-member", "nested-in-struct", typeof(L05Os60.L05_60_record_struct_ulong), () => 4200000000UL, () => 4200000000UL, () => 4200000001UL);
-        Add("sealed-record-class", "DateOnly", "base-depth-2", "nested-in-struct", typeof(L05Os61.L05_61_sealed_record_class_DateOnly), () => new DateOnly(2026, 10, 15), () => DateOnly.FromDayNumber(new DateOnly(2026, 10, 15).DayNumber), () => new DateOnly(2026, 10, 16));
-        Add("sealed-record-class", "DateOnly", "base-depth-3", "top-level", typeof(L05_62_sealed_record_class_DateOnly), () => new DateOnly(2026, 10, 15), () => DateOnly.FromDayNumber(new DateOnly(2026, 10, 15).DayNumber), () => new DateOnly(2026, 10, 16));
-        Add("sealed-record-class", "DateOnly", "none", "nested-in-struct", typeof(L05Os63.L05_63_sealed_record_class_DateOnly), () => new DateOnly(2026, 10, 15), () => DateOnly.FromDayNumber(new DateOnly(2026, 10, 15).DayNumber), () => new DateOnly(2026, 10, 16));
-        Add("sealed-record-class", "DateOnly", "none", "top-level", typeof(L05_64_sealed_record_class_DateOnly), () => new DateOnly(2026, 10, 15), () => DateOnly.FromDayNumber(new DateOnly(2026, 10, 15).DayNumber), () => new DateOnly(2026, 10, 16));
-        Add("sealed-record-class", "DateTime", "base-depth-1", "top-level", typeof(L05_65_sealed_record_class_DateTime), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Utc), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Unspecified), () => new DateTime(2026, 10, 15, 8, 31, 0, DateTimeKind.Utc));
-        Add("sealed-record-class", "DateTime", "base-depth-2", "nested-in-class", typeof(L05Oc66.L05_66_sealed_record_class_DateTime), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Utc), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Unspecified), () => new DateTime(2026, 10, 15, 8, 31, 0, DateTimeKind.Utc));
-        Add("sealed-record-class", "DateTime", "base-depth-3", "nested-in-struct", typeof(L05Os67.L05_67_sealed_record_class_DateTime), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Utc), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Unspecified), () => new DateTime(2026, 10, 15, 8, 31, 0, DateTimeKind.Utc));
-        Add("sealed-record-class", "DateTime", "base-depth-3", "nested-two-levels", typeof(L05Ot68.Inner.L05_68_sealed_record_class_DateTime), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Utc), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Unspecified), () => new DateTime(2026, 10, 15, 8, 31, 0, DateTimeKind.Utc));
-        Add("sealed-record-class", "DateTime", "base-depth-3", "top-level", typeof(L05_69_sealed_record_class_DateTime), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Utc), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Unspecified), () => new DateTime(2026, 10, 15, 8, 31, 0, DateTimeKind.Utc));
-        Add("sealed-record-class", "DateTime", "base-explicit-IEquatable", "nested-in-struct", typeof(L05Os70.L05_70_sealed_record_class_DateTime), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Utc), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Unspecified), () => new DateTime(2026, 10, 15, 8, 31, 0, DateTimeKind.Utc));
-        Add("sealed-record-class", "DateTimeOffset", "base-depth-1", "nested-in-class", typeof(L05Oc71.L05_71_sealed_record_class_DateTimeOffset), () => new DateTimeOffset(2026, 10, 15, 8, 30, 0, TimeSpan.Zero), () => new DateTimeOffset(2026, 10, 15, 10, 30, 0, TimeSpan.FromHours(2)), () => new DateTimeOffset(2026, 10, 15, 8, 31, 0, TimeSpan.Zero));
-        Add("sealed-record-class", "DateTimeOffset", "base-depth-2", "top-level", typeof(L05_72_sealed_record_class_DateTimeOffset), () => new DateTimeOffset(2026, 10, 15, 8, 30, 0, TimeSpan.Zero), () => new DateTimeOffset(2026, 10, 15, 10, 30, 0, TimeSpan.FromHours(2)), () => new DateTimeOffset(2026, 10, 15, 8, 31, 0, TimeSpan.Zero));
-        Add("sealed-record-class", "DateTimeOffset", "base-depth-3", "nested-in-class", typeof(L05Oc73.L05_73_sealed_record_class_DateTimeOffset), () => new DateTimeOffset(2026, 10, 15, 8, 30, 0, TimeSpan.Zero), () => new DateTimeOffset(2026, 10, 15, 10, 30, 0, TimeSpan.FromHours(2)), () => new DateTimeOffset(2026, 10, 15, 8, 31, 0, TimeSpan.Zero));
-        Add("sealed-record-class", "DateTimeOffset", "base-depth-3", "nested-two-levels", typeof(L05Ot74.Inner.L05_74_sealed_record_class_DateTimeOffset), () => new DateTimeOffset(2026, 10, 15, 8, 30, 0, TimeSpan.Zero), () => new DateTimeOffset(2026, 10, 15, 10, 30, 0, TimeSpan.FromHours(2)), () => new DateTimeOffset(2026, 10, 15, 8, 31, 0, TimeSpan.Zero));
-        Add("sealed-record-class", "DateTimeOffset", "base-depth-3", "top-level", typeof(L05_75_sealed_record_class_DateTimeOffset), () => new DateTimeOffset(2026, 10, 15, 8, 30, 0, TimeSpan.Zero), () => new DateTimeOffset(2026, 10, 15, 10, 30, 0, TimeSpan.FromHours(2)), () => new DateTimeOffset(2026, 10, 15, 8, 31, 0, TimeSpan.Zero));
-        Add("sealed-record-class", "DateTimeOffset", "base-explicit-IEquatable", "nested-in-class", typeof(L05Oc76.L05_76_sealed_record_class_DateTimeOffset), () => new DateTimeOffset(2026, 10, 15, 8, 30, 0, TimeSpan.Zero), () => new DateTimeOffset(2026, 10, 15, 10, 30, 0, TimeSpan.FromHours(2)), () => new DateTimeOffset(2026, 10, 15, 8, 31, 0, TimeSpan.Zero));
-        Add("sealed-record-class", "DateTimeOffset", "base-explicit-IEquatable", "top-level", typeof(L05_77_sealed_record_class_DateTimeOffset), () => new DateTimeOffset(2026, 10, 15, 8, 30, 0, TimeSpan.Zero), () => new DateTimeOffset(2026, 10, 15, 10, 30, 0, TimeSpan.FromHours(2)), () => new DateTimeOffset(2026, 10, 15, 8, 31, 0, TimeSpan.Zero));
-        Add("sealed-record-class", "Guid", "base-depth-1", "nested-in-class", typeof(L05Oc78.L05_78_sealed_record_class_Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111"), () => new Guid("11111111111111111111111111111111"), () => Guid.Parse("22222222-2222-2222-2222-222222222222"));
-        Add("sealed-record-class", "Guid", "base-depth-1", "nested-in-struct", typeof(L05Os79.L05_79_sealed_record_class_Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111"), () => new Guid("11111111111111111111111111111111"), () => Guid.Parse("22222222-2222-2222-2222-222222222222"));
-        Add("sealed-record-class", "Guid", "base-depth-2", "top-level", typeof(L05_80_sealed_record_class_Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111"), () => new Guid("11111111111111111111111111111111"), () => Guid.Parse("22222222-2222-2222-2222-222222222222"));
-        Add("sealed-record-class", "Guid", "base-depth-3", "top-level", typeof(L05_81_sealed_record_class_Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111"), () => new Guid("11111111111111111111111111111111"), () => Guid.Parse("22222222-2222-2222-2222-222222222222"));
-        Add("sealed-record-class", "Guid", "base-explicit-IEquatable", "nested-in-class", typeof(L05Oc82.L05_82_sealed_record_class_Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111"), () => new Guid("11111111111111111111111111111111"), () => Guid.Parse("22222222-2222-2222-2222-222222222222"));
-        Add("sealed-record-class", "Guid", "base-explicit-IEquatable", "nested-two-levels", typeof(L05Ot83.Inner.L05_83_sealed_record_class_Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111"), () => new Guid("11111111111111111111111111111111"), () => Guid.Parse("22222222-2222-2222-2222-222222222222"));
-        Add("sealed-record-class", "NodaTime.Instant", "base-depth-1", "nested-two-levels", typeof(L05Ot84.Inner.L05_84_sealed_record_class_NodaTime_Instant), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30), () => global::NodaTime.Instant.FromUnixTimeTicks(global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30).ToUnixTimeTicks()), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 31));
-        Add("sealed-record-class", "NodaTime.Instant", "base-explicit-IEquatable", "nested-in-struct", typeof(L05Os85.L05_85_sealed_record_class_NodaTime_Instant), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30), () => global::NodaTime.Instant.FromUnixTimeTicks(global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30).ToUnixTimeTicks()), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 31));
-        Add("sealed-record-class", "NodaTime.Instant", "none", "nested-in-struct", typeof(L05Os86.L05_86_sealed_record_class_NodaTime_Instant), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30), () => global::NodaTime.Instant.FromUnixTimeTicks(global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30).ToUnixTimeTicks()), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 31));
-        Add("sealed-record-class", "TimeOnly", "base-depth-3", "nested-in-struct", typeof(L05Os87.L05_87_sealed_record_class_TimeOnly), () => new TimeOnly(8, 30, 15), () => new TimeOnly(new TimeOnly(8, 30, 15).Ticks), () => new TimeOnly(8, 30, 16));
-        Add("sealed-record-class", "TimeOnly", "base-depth-3", "nested-two-levels", typeof(L05Ot88.Inner.L05_88_sealed_record_class_TimeOnly), () => new TimeOnly(8, 30, 15), () => new TimeOnly(new TimeOnly(8, 30, 15).Ticks), () => new TimeOnly(8, 30, 16));
-        Add("sealed-record-class", "TimeSpan", "base-depth-1", "nested-in-class", typeof(L05Oc89.L05_89_sealed_record_class_TimeSpan), () => TimeSpan.FromMinutes(90), () => TimeSpan.FromSeconds(5400), () => TimeSpan.FromMinutes(91));
-        Add("sealed-record-class", "TimeSpan", "base-depth-1", "nested-two-levels", typeof(L05Ot90.Inner.L05_90_sealed_record_class_TimeSpan), () => TimeSpan.FromMinutes(90), () => TimeSpan.FromSeconds(5400), () => TimeSpan.FromMinutes(91));
-        Add("sealed-record-class", "TimeSpan", "base-depth-2", "top-level", typeof(L05_91_sealed_record_class_TimeSpan), () => TimeSpan.FromMinutes(90), () => TimeSpan.FromSeconds(5400), () => TimeSpan.FromMinutes(91));
-        Add("sealed-record-class", "TimeSpan", "base-depth-3", "top-level", typeof(L05_92_sealed_record_class_TimeSpan), () => TimeSpan.FromMinutes(90), () => TimeSpan.FromSeconds(5400), () => TimeSpan.FromMinutes(91));
-        Add("sealed-record-class", "TimeSpan", "explicit-interface-member", "nested-in-struct", typeof(L05Os93.L05_93_sealed_record_class_TimeSpan), () => TimeSpan.FromMinutes(90), () => TimeSpan.FromSeconds(5400), () => TimeSpan.FromMinutes(91));
-        Add("sealed-record-class", "TimeSpan", "none", "nested-in-class", typeof(L05Oc94.L05_94_sealed_record_class_TimeSpan), () => TimeSpan.FromMinutes(90), () => TimeSpan.FromSeconds(5400), () => TimeSpan.FromMinutes(91));
-        Add("sealed-record-class", "Uri", "base-depth-1", "nested-in-class", typeof(L05Oc95.L05_95_sealed_record_class_Uri), () => new Uri("https://example.com/a"), () => new Uri("HTTPS://EXAMPLE.COM/a"), () => new Uri("https://example.com/b"));
-        Add("sealed-record-class", "Uri", "base-depth-2", "nested-in-struct", typeof(L05Os96.L05_96_sealed_record_class_Uri), () => new Uri("https://example.com/a"), () => new Uri("HTTPS://EXAMPLE.COM/a"), () => new Uri("https://example.com/b"));
-        Add("sealed-record-class", "Uri", "base-depth-3", "nested-in-struct", typeof(L05Os97.L05_97_sealed_record_class_Uri), () => new Uri("https://example.com/a"), () => new Uri("HTTPS://EXAMPLE.COM/a"), () => new Uri("https://example.com/b"));
-        Add("sealed-record-class", "Uri", "base-explicit-IEquatable", "nested-two-levels", typeof(L05Ot98.Inner.L05_98_sealed_record_class_Uri), () => new Uri("https://example.com/a"), () => new Uri("HTTPS://EXAMPLE.COM/a"), () => new Uri("https://example.com/b"));
-        Add("sealed-record-class", "bool", "base-depth-2", "nested-in-class", typeof(L05Oc99.L05_99_sealed_record_class_bool), () => false, () => false, () => true);
-        Add("sealed-record-class", "bool", "base-depth-2", "nested-two-levels", typeof(L05Ot100.Inner.L05_100_sealed_record_class_bool), () => false, () => false, () => true);
-        Add("sealed-record-class", "bool", "base-depth-3", "nested-in-struct", typeof(L05Os101.L05_101_sealed_record_class_bool), () => false, () => false, () => true);
-        Add("sealed-record-class", "bool", "base-explicit-IEquatable", "nested-two-levels", typeof(L05Ot102.Inner.L05_102_sealed_record_class_bool), () => false, () => false, () => true);
-        Add("sealed-record-class", "bool", "explicit-interface-member", "nested-two-levels", typeof(L05Ot103.Inner.L05_103_sealed_record_class_bool), () => false, () => false, () => true);
-        Add("sealed-record-class", "byte", "base-depth-1", "nested-two-levels", typeof(L05Ot104.Inner.L05_104_sealed_record_class_byte), () => (byte)7, () => (byte)7, () => (byte)8);
-        Add("sealed-record-class", "byte", "base-depth-2", "nested-in-struct", typeof(L05Os105.L05_105_sealed_record_class_byte), () => (byte)7, () => (byte)7, () => (byte)8);
-        Add("sealed-record-class", "byte", "base-depth-3", "nested-in-class", typeof(L05Oc106.L05_106_sealed_record_class_byte), () => (byte)7, () => (byte)7, () => (byte)8);
-        Add("sealed-record-class", "byte", "base-depth-3", "top-level", typeof(L05_107_sealed_record_class_byte), () => (byte)7, () => (byte)7, () => (byte)8);
-        Add("sealed-record-class", "byte", "explicit-interface-member", "nested-two-levels", typeof(L05Ot108.Inner.L05_108_sealed_record_class_byte), () => (byte)7, () => (byte)7, () => (byte)8);
-        Add("sealed-record-class", "byte", "explicit-interface-member", "top-level", typeof(L05_109_sealed_record_class_byte), () => (byte)7, () => (byte)7, () => (byte)8);
-        Add("sealed-record-class", "byte", "none", "top-level", typeof(L05_110_sealed_record_class_byte), () => (byte)7, () => (byte)7, () => (byte)8);
-        Add("sealed-record-class", "char", "base-depth-1", "nested-two-levels", typeof(L05Ot111.Inner.L05_111_sealed_record_class_char), () => 'a', () => 'a', () => 'b');
-        Add("sealed-record-class", "char", "base-depth-2", "top-level", typeof(L05_112_sealed_record_class_char), () => 'a', () => 'a', () => 'b');
-        Add("sealed-record-class", "char", "base-explicit-IEquatable", "top-level", typeof(L05_113_sealed_record_class_char), () => 'a', () => 'a', () => 'b');
-        Add("sealed-record-class", "char", "explicit-interface-member", "nested-two-levels", typeof(L05Ot114.Inner.L05_114_sealed_record_class_char), () => 'a', () => 'a', () => 'b');
-        Add("sealed-record-class", "decimal", "base-depth-1", "nested-in-class", typeof(L05Oc115.L05_115_sealed_record_class_decimal), () => 7.8m, () => 7.80m, () => 7.81m);
-        Add("sealed-record-class", "decimal", "base-depth-3", "nested-in-struct", typeof(L05Os116.L05_116_sealed_record_class_decimal), () => 7.8m, () => 7.80m, () => 7.81m);
-        Add("sealed-record-class", "decimal", "base-explicit-IEquatable", "nested-in-class", typeof(L05Oc117.L05_117_sealed_record_class_decimal), () => 7.8m, () => 7.80m, () => 7.81m);
-        Add("sealed-record-class", "decimal", "base-explicit-IEquatable", "top-level", typeof(L05_118_sealed_record_class_decimal), () => 7.8m, () => 7.80m, () => 7.81m);
-        Add("sealed-record-class", "double", "base-depth-1", "nested-two-levels", typeof(L05Ot119.Inner.L05_119_sealed_record_class_double), () => 0.0, () => -0.0, () => 1.5);
-        Add("sealed-record-class", "double", "base-depth-2", "top-level", typeof(L05_120_sealed_record_class_double), () => 0.0, () => -0.0, () => 1.5);
-        Add("sealed-record-class", "double", "base-depth-3", "nested-in-class", typeof(L05Oc121.L05_121_sealed_record_class_double), () => 0.0, () => -0.0, () => 1.5);
-        Add("sealed-record-class", "double", "base-explicit-IEquatable", "nested-in-class", typeof(L05Oc122.L05_122_sealed_record_class_double), () => 0.0, () => -0.0, () => 1.5);
-        Add("sealed-record-class", "enum", "base-depth-1", "nested-in-struct", typeof(L05Os123.L05_123_sealed_record_class_enum), () => PEnum.B, () => (PEnum)1, () => PEnum.C);
-        Add("sealed-record-class", "enum", "base-depth-2", "nested-two-levels", typeof(L05Ot124.Inner.L05_124_sealed_record_class_enum), () => PEnum.B, () => (PEnum)1, () => PEnum.C);
-        Add("sealed-record-class", "enum", "base-depth-3", "nested-two-levels", typeof(L05Ot125.Inner.L05_125_sealed_record_class_enum), () => PEnum.B, () => (PEnum)1, () => PEnum.C);
-        Add("sealed-record-class", "enum", "base-explicit-IEquatable", "nested-two-levels", typeof(L05Ot126.Inner.L05_126_sealed_record_class_enum), () => PEnum.B, () => (PEnum)1, () => PEnum.C);
-        Add("sealed-record-class", "enum", "explicit-interface-member", "nested-in-struct", typeof(L05Os127.L05_127_sealed_record_class_enum), () => PEnum.B, () => (PEnum)1, () => PEnum.C);
-        Add("sealed-record-class", "enum", "none", "nested-in-class", typeof(L05Oc128.L05_128_sealed_record_class_enum), () => PEnum.B, () => (PEnum)1, () => PEnum.C);
-        Add("sealed-record-class", "flags-enum", "base-depth-1", "nested-in-class", typeof(L05Oc129.L05_129_sealed_record_class_flags_enum), () => PFlags.P | PFlags.Q, () => (PFlags)3, () => PFlags.R);
-        Add("sealed-record-class", "flags-enum", "base-depth-1", "nested-two-levels", typeof(L05Ot130.Inner.L05_130_sealed_record_class_flags_enum), () => PFlags.P | PFlags.Q, () => (PFlags)3, () => PFlags.R);
-        Add("sealed-record-class", "flags-enum", "base-depth-2", "top-level", typeof(L05_131_sealed_record_class_flags_enum), () => PFlags.P | PFlags.Q, () => (PFlags)3, () => PFlags.R);
-        Add("sealed-record-class", "flags-enum", "base-depth-3", "top-level", typeof(L05_132_sealed_record_class_flags_enum), () => PFlags.P | PFlags.Q, () => (PFlags)3, () => PFlags.R);
-        Add("sealed-record-class", "flags-enum", "base-explicit-IEquatable", "nested-two-levels", typeof(L05Ot133.Inner.L05_133_sealed_record_class_flags_enum), () => PFlags.P | PFlags.Q, () => (PFlags)3, () => PFlags.R);
-        Add("sealed-record-class", "flags-enum", "explicit-interface-member", "nested-in-struct", typeof(L05Os134.L05_134_sealed_record_class_flags_enum), () => PFlags.P | PFlags.Q, () => (PFlags)3, () => PFlags.R);
-        Add("sealed-record-class", "int", "base-depth-2", "top-level", typeof(L05_135_sealed_record_class_int), () => 42, () => 42, () => 43);
-        Add("sealed-record-class", "int", "base-explicit-IEquatable", "nested-in-struct", typeof(L05Os136.L05_136_sealed_record_class_int), () => 42, () => 42, () => 43);
-        Add("sealed-record-class", "long", "base-depth-2", "nested-two-levels", typeof(L05Ot137.Inner.L05_137_sealed_record_class_long), () => 4200000000L, () => 4200000000L, () => 4200000001L);
-        Add("sealed-record-class", "long", "base-depth-3", "nested-two-levels", typeof(L05Ot138.Inner.L05_138_sealed_record_class_long), () => 4200000000L, () => 4200000000L, () => 4200000001L);
-        Add("sealed-record-class", "long", "base-explicit-IEquatable", "nested-in-struct", typeof(L05Os139.L05_139_sealed_record_class_long), () => 4200000000L, () => 4200000000L, () => 4200000001L);
-        Add("sealed-record-class", "own-record-class", "base-depth-2", "nested-two-levels", typeof(L05Ot140.Inner.L05_140_sealed_record_class_own_record_class), () => new PRec { A = "x", B = 1 }, () => new PRec { A = new string("x".ToCharArray()), B = 1 }, () => new PRec { A = "y", B = 1 });
-        Add("sealed-record-class", "own-record-class", "base-explicit-IEquatable", "nested-in-struct", typeof(L05Os141.L05_141_sealed_record_class_own_record_class), () => new PRec { A = "x", B = 1 }, () => new PRec { A = new string("x".ToCharArray()), B = 1 }, () => new PRec { A = "y", B = 1 });
-        Add("sealed-record-class", "own-record-class", "base-explicit-IEquatable", "nested-two-levels", typeof(L05Ot142.Inner.L05_142_sealed_record_class_own_record_class), () => new PRec { A = "x", B = 1 }, () => new PRec { A = new string("x".ToCharArray()), B = 1 }, () => new PRec { A = "y", B = 1 });
-        Add("sealed-record-class", "string", "base-depth-1", "nested-in-struct", typeof(L05Os143.L05_143_sealed_record_class_string), () => "alpha", () => new string("alpha".ToCharArray()), () => "beta");
-        Add("sealed-record-class", "string", "base-depth-3", "top-level", typeof(L05_144_sealed_record_class_string), () => "alpha", () => new string("alpha".ToCharArray()), () => "beta");
-        Add("sealed-record-class", "string", "base-explicit-IEquatable", "nested-two-levels", typeof(L05Ot145.Inner.L05_145_sealed_record_class_string), () => "alpha", () => new string("alpha".ToCharArray()), () => "beta");
-        Add("sealed-record-class", "ulong", "base-depth-3", "nested-two-levels", typeof(L05Ot146.Inner.L05_146_sealed_record_class_ulong), () => 4200000000UL, () => 4200000000UL, () => 4200000001UL);
-        Add("sealed-record-class", "ulong", "base-explicit-IEquatable", "nested-two-levels", typeof(L05Ot147.Inner.L05_147_sealed_record_class_ulong), () => 4200000000UL, () => 4200000000UL, () => 4200000001UL);
-        Add("sealed-record-class", "ulong", "base-explicit-IEquatable", "top-level", typeof(L05_148_sealed_record_class_ulong), () => 4200000000UL, () => 4200000000UL, () => 4200000001UL);
-        Add("validated-class", "DateOnly", "base-depth-1", "nested-in-struct", typeof(L05Os149.L05_149_validated_class_DateOnly), () => new DateOnly(2026, 10, 15), () => DateOnly.FromDayNumber(new DateOnly(2026, 10, 15).DayNumber), () => new DateOnly(2026, 10, 16));
-        Add("validated-class", "DateOnly", "base-explicit-IEquatable", "top-level", typeof(L05_150_validated_class_DateOnly), () => new DateOnly(2026, 10, 15), () => DateOnly.FromDayNumber(new DateOnly(2026, 10, 15).DayNumber), () => new DateOnly(2026, 10, 16));
-        Add("validated-class", "DateOnly", "explicit-interface-member", "top-level", typeof(L05_151_validated_class_DateOnly), () => new DateOnly(2026, 10, 15), () => DateOnly.FromDayNumber(new DateOnly(2026, 10, 15).DayNumber), () => new DateOnly(2026, 10, 16));
-        Add("validated-class", "DateOnly", "none", "nested-two-levels", typeof(L05Ot152.Inner.L05_152_validated_class_DateOnly), () => new DateOnly(2026, 10, 15), () => DateOnly.FromDayNumber(new DateOnly(2026, 10, 15).DayNumber), () => new DateOnly(2026, 10, 16));
-        Add("validated-class", "DateTime", "base-depth-1", "nested-in-struct", typeof(L05Os153.L05_153_validated_class_DateTime), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Utc), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Unspecified), () => new DateTime(2026, 10, 15, 8, 31, 0, DateTimeKind.Utc));
-        Add("validated-class", "DateTime", "base-depth-1", "nested-two-levels", typeof(L05Ot154.Inner.L05_154_validated_class_DateTime), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Utc), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Unspecified), () => new DateTime(2026, 10, 15, 8, 31, 0, DateTimeKind.Utc));
-        Add("validated-class", "DateTime", "base-depth-2", "top-level", typeof(L05_155_validated_class_DateTime), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Utc), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Unspecified), () => new DateTime(2026, 10, 15, 8, 31, 0, DateTimeKind.Utc));
-        Add("validated-class", "DateTime", "base-depth-3", "nested-in-class", typeof(L05Oc156.L05_156_validated_class_DateTime), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Utc), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Unspecified), () => new DateTime(2026, 10, 15, 8, 31, 0, DateTimeKind.Utc));
-        Add("validated-class", "DateTime", "base-explicit-IEquatable", "nested-in-struct", typeof(L05Os157.L05_157_validated_class_DateTime), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Utc), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Unspecified), () => new DateTime(2026, 10, 15, 8, 31, 0, DateTimeKind.Utc));
-        Add("validated-class", "DateTimeOffset", "explicit-interface-member", "nested-in-class", typeof(L05Oc158.L05_158_validated_class_DateTimeOffset), () => new DateTimeOffset(2026, 10, 15, 8, 30, 0, TimeSpan.Zero), () => new DateTimeOffset(2026, 10, 15, 10, 30, 0, TimeSpan.FromHours(2)), () => new DateTimeOffset(2026, 10, 15, 8, 31, 0, TimeSpan.Zero));
-        Add("validated-class", "Guid", "base-depth-2", "nested-in-class", typeof(L05Oc159.L05_159_validated_class_Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111"), () => new Guid("11111111111111111111111111111111"), () => Guid.Parse("22222222-2222-2222-2222-222222222222"));
-        Add("validated-class", "Guid", "base-depth-2", "nested-two-levels", typeof(L05Ot160.Inner.L05_160_validated_class_Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111"), () => new Guid("11111111111111111111111111111111"), () => Guid.Parse("22222222-2222-2222-2222-222222222222"));
-        Add("validated-class", "Guid", "explicit-interface-member", "nested-in-class", typeof(L05Oc161.L05_161_validated_class_Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111"), () => new Guid("11111111111111111111111111111111"), () => Guid.Parse("22222222-2222-2222-2222-222222222222"));
-        Add("validated-class", "NodaTime.Instant", "base-depth-2", "nested-two-levels", typeof(L05Ot162.Inner.L05_162_validated_class_NodaTime_Instant), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30), () => global::NodaTime.Instant.FromUnixTimeTicks(global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30).ToUnixTimeTicks()), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 31));
-        Add("validated-class", "NodaTime.Instant", "base-depth-3", "nested-in-class", typeof(L05Oc163.L05_163_validated_class_NodaTime_Instant), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30), () => global::NodaTime.Instant.FromUnixTimeTicks(global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30).ToUnixTimeTicks()), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 31));
-        Add("validated-class", "NodaTime.Instant", "base-depth-3", "nested-in-struct", typeof(L05Os164.L05_164_validated_class_NodaTime_Instant), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30), () => global::NodaTime.Instant.FromUnixTimeTicks(global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30).ToUnixTimeTicks()), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 31));
-        Add("validated-class", "NodaTime.Instant", "base-depth-3", "nested-two-levels", typeof(L05Ot165.Inner.L05_165_validated_class_NodaTime_Instant), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30), () => global::NodaTime.Instant.FromUnixTimeTicks(global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30).ToUnixTimeTicks()), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 31));
-        Add("validated-class", "NodaTime.Instant", "base-explicit-IEquatable", "nested-in-class", typeof(L05Oc166.L05_166_validated_class_NodaTime_Instant), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30), () => global::NodaTime.Instant.FromUnixTimeTicks(global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30).ToUnixTimeTicks()), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 31));
-        Add("validated-class", "NodaTime.Instant", "base-explicit-IEquatable", "top-level", typeof(L05_167_validated_class_NodaTime_Instant), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30), () => global::NodaTime.Instant.FromUnixTimeTicks(global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30).ToUnixTimeTicks()), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 31));
-        Add("validated-class", "TimeOnly", "base-depth-1", "nested-in-class", typeof(L05Oc168.L05_168_validated_class_TimeOnly), () => new TimeOnly(8, 30, 15), () => new TimeOnly(new TimeOnly(8, 30, 15).Ticks), () => new TimeOnly(8, 30, 16));
-        Add("validated-class", "TimeOnly", "base-depth-1", "nested-in-struct", typeof(L05Os169.L05_169_validated_class_TimeOnly), () => new TimeOnly(8, 30, 15), () => new TimeOnly(new TimeOnly(8, 30, 15).Ticks), () => new TimeOnly(8, 30, 16));
-        Add("validated-class", "TimeOnly", "base-depth-2", "top-level", typeof(L05_170_validated_class_TimeOnly), () => new TimeOnly(8, 30, 15), () => new TimeOnly(new TimeOnly(8, 30, 15).Ticks), () => new TimeOnly(8, 30, 16));
-        Add("validated-class", "TimeOnly", "base-explicit-IEquatable", "nested-in-class", typeof(L05Oc171.L05_171_validated_class_TimeOnly), () => new TimeOnly(8, 30, 15), () => new TimeOnly(new TimeOnly(8, 30, 15).Ticks), () => new TimeOnly(8, 30, 16));
-        Add("validated-class", "TimeOnly", "none", "top-level", typeof(L05_172_validated_class_TimeOnly), () => new TimeOnly(8, 30, 15), () => new TimeOnly(new TimeOnly(8, 30, 15).Ticks), () => new TimeOnly(8, 30, 16));
-        Add("validated-class", "TimeSpan", "base-depth-1", "top-level", typeof(L05_173_validated_class_TimeSpan), () => TimeSpan.FromMinutes(90), () => TimeSpan.FromSeconds(5400), () => TimeSpan.FromMinutes(91));
-        Add("validated-class", "TimeSpan", "base-depth-2", "nested-in-class", typeof(L05Oc174.L05_174_validated_class_TimeSpan), () => TimeSpan.FromMinutes(90), () => TimeSpan.FromSeconds(5400), () => TimeSpan.FromMinutes(91));
-        Add("validated-class", "TimeSpan", "base-depth-2", "nested-in-struct", typeof(L05Os175.L05_175_validated_class_TimeSpan), () => TimeSpan.FromMinutes(90), () => TimeSpan.FromSeconds(5400), () => TimeSpan.FromMinutes(91));
-        Add("validated-class", "TimeSpan", "base-explicit-IEquatable", "nested-two-levels", typeof(L05Ot176.Inner.L05_176_validated_class_TimeSpan), () => TimeSpan.FromMinutes(90), () => TimeSpan.FromSeconds(5400), () => TimeSpan.FromMinutes(91));
-        Add("validated-class", "Uri", "base-depth-1", "nested-in-struct", typeof(L05Os177.L05_177_validated_class_Uri), () => new Uri("https://example.com/a"), () => new Uri("HTTPS://EXAMPLE.COM/a"), () => new Uri("https://example.com/b"));
-        Add("validated-class", "Uri", "base-depth-3", "nested-two-levels", typeof(L05Ot178.Inner.L05_178_validated_class_Uri), () => new Uri("https://example.com/a"), () => new Uri("HTTPS://EXAMPLE.COM/a"), () => new Uri("https://example.com/b"));
-        Add("validated-class", "Uri", "explicit-interface-member", "top-level", typeof(L05_179_validated_class_Uri), () => new Uri("https://example.com/a"), () => new Uri("HTTPS://EXAMPLE.COM/a"), () => new Uri("https://example.com/b"));
-        Add("validated-class", "Uri", "none", "nested-in-class", typeof(L05Oc180.L05_180_validated_class_Uri), () => new Uri("https://example.com/a"), () => new Uri("HTTPS://EXAMPLE.COM/a"), () => new Uri("https://example.com/b"));
-        Add("validated-class", "bool", "base-depth-1", "nested-in-struct", typeof(L05Os181.L05_181_validated_class_bool), () => false, () => false, () => true);
-        Add("validated-class", "bool", "base-explicit-IEquatable", "nested-in-class", typeof(L05Oc182.L05_182_validated_class_bool), () => false, () => false, () => true);
-        Add("validated-class", "bool", "explicit-interface-member", "nested-in-struct", typeof(L05Os183.L05_183_validated_class_bool), () => false, () => false, () => true);
-        Add("validated-class", "byte", "base-depth-2", "nested-in-struct", typeof(L05Os184.L05_184_validated_class_byte), () => (byte)7, () => (byte)7, () => (byte)8);
-        Add("validated-class", "byte", "base-explicit-IEquatable", "nested-in-class", typeof(L05Oc185.L05_185_validated_class_byte), () => (byte)7, () => (byte)7, () => (byte)8);
-        Add("validated-class", "byte", "base-explicit-IEquatable", "nested-two-levels", typeof(L05Ot186.Inner.L05_186_validated_class_byte), () => (byte)7, () => (byte)7, () => (byte)8);
-        Add("validated-class", "byte", "explicit-interface-member", "nested-in-struct", typeof(L05Os187.L05_187_validated_class_byte), () => (byte)7, () => (byte)7, () => (byte)8);
-        Add("validated-class", "char", "base-depth-2", "nested-in-class", typeof(L05Oc188.L05_188_validated_class_char), () => 'a', () => 'a', () => 'b');
-        Add("validated-class", "char", "base-depth-3", "nested-in-class", typeof(L05Oc189.L05_189_validated_class_char), () => 'a', () => 'a', () => 'b');
-        Add("validated-class", "char", "base-depth-3", "nested-two-levels", typeof(L05Ot190.Inner.L05_190_validated_class_char), () => 'a', () => 'a', () => 'b');
-        Add("validated-class", "char", "base-explicit-IEquatable", "nested-two-levels", typeof(L05Ot191.Inner.L05_191_validated_class_char), () => 'a', () => 'a', () => 'b');
-        Add("validated-class", "char", "base-explicit-IEquatable", "top-level", typeof(L05_192_validated_class_char), () => 'a', () => 'a', () => 'b');
-        Add("validated-class", "decimal", "base-depth-1", "top-level", typeof(L05_193_validated_class_decimal), () => 7.8m, () => 7.80m, () => 7.81m);
-        Add("validated-class", "decimal", "base-depth-2", "nested-two-levels", typeof(L05Ot194.Inner.L05_194_validated_class_decimal), () => 7.8m, () => 7.80m, () => 7.81m);
-        Add("validated-class", "decimal", "base-depth-2", "top-level", typeof(L05_195_validated_class_decimal), () => 7.8m, () => 7.80m, () => 7.81m);
-        Add("validated-class", "decimal", "none", "nested-in-struct", typeof(L05Os196.L05_196_validated_class_decimal), () => 7.8m, () => 7.80m, () => 7.81m);
-        Add("validated-class", "decimal", "none", "top-level", typeof(L05_197_validated_class_decimal), () => 7.8m, () => 7.80m, () => 7.81m);
-        Add("validated-class", "double", "base-depth-2", "top-level", typeof(L05_198_validated_class_double), () => 0.0, () => -0.0, () => 1.5);
-        Add("validated-class", "double", "base-depth-3", "nested-in-struct", typeof(L05Os199.L05_199_validated_class_double), () => 0.0, () => -0.0, () => 1.5);
-        Add("validated-class", "double", "explicit-interface-member", "nested-in-struct", typeof(L05Os200.L05_200_validated_class_double), () => 0.0, () => -0.0, () => 1.5);
-        Add("validated-class", "enum", "base-depth-1", "nested-two-levels", typeof(L05Ot201.Inner.L05_201_validated_class_enum), () => PEnum.B, () => (PEnum)1, () => PEnum.C);
-        Add("validated-class", "enum", "base-depth-2", "top-level", typeof(L05_202_validated_class_enum), () => PEnum.B, () => (PEnum)1, () => PEnum.C);
-        Add("validated-class", "flags-enum", "base-explicit-IEquatable", "nested-in-class", typeof(L05Oc203.L05_203_validated_class_flags_enum), () => PFlags.P | PFlags.Q, () => (PFlags)3, () => PFlags.R);
-        Add("validated-class", "flags-enum", "explicit-interface-member", "nested-two-levels", typeof(L05Ot204.Inner.L05_204_validated_class_flags_enum), () => PFlags.P | PFlags.Q, () => (PFlags)3, () => PFlags.R);
-        Add("validated-class", "int", "base-depth-1", "nested-in-struct", typeof(L05Os205.L05_205_validated_class_int), () => 42, () => 42, () => 43);
-        Add("validated-class", "int", "base-depth-3", "nested-in-class", typeof(L05Oc206.L05_206_validated_class_int), () => 42, () => 42, () => 43);
-        Add("validated-class", "int", "explicit-interface-member", "nested-in-class", typeof(L05Oc207.L05_207_validated_class_int), () => 42, () => 42, () => 43);
-        Add("validated-class", "long", "base-depth-1", "nested-in-class", typeof(L05Oc208.L05_208_validated_class_long), () => 4200000000L, () => 4200000000L, () => 4200000001L);
-        Add("validated-class", "long", "base-depth-2", "nested-two-levels", typeof(L05Ot209.Inner.L05_209_validated_class_long), () => 4200000000L, () => 4200000000L, () => 4200000001L);
-        Add("validated-class", "long", "base-explicit-IEquatable", "nested-in-class", typeof(L05Oc210.L05_210_validated_class_long), () => 4200000000L, () => 4200000000L, () => 4200000001L);
-        Add("validated-class", "long", "base-explicit-IEquatable", "nested-in-struct", typeof(L05Os211.L05_211_validated_class_long), () => 4200000000L, () => 4200000000L, () => 4200000001L);
-        Add("validated-class", "long", "explicit-interface-member", "nested-two-levels", typeof(L05Ot212.Inner.L05_212_validated_class_long), () => 4200000000L, () => 4200000000L, () => 4200000001L);
-        Add("validated-class", "own-record-class", "base-depth-1", "nested-in-struct", typeof(L05Os213.L05_213_validated_class_own_record_class), () => new PRec { A = "x", B = 1 }, () => new PRec { A = new string("x".ToCharArray()), B = 1 }, () => new PRec { A = "y", B = 1 });
-        Add("validated-class", "own-record-class", "base-depth-1", "nested-two-levels", typeof(L05Ot214.Inner.L05_214_validated_class_own_record_class), () => new PRec { A = "x", B = 1 }, () => new PRec { A = new string("x".ToCharArray()), B = 1 }, () => new PRec { A = "y", B = 1 });
-        Add("validated-class", "own-record-class", "base-depth-2", "top-level", typeof(L05_215_validated_class_own_record_class), () => new PRec { A = "x", B = 1 }, () => new PRec { A = new string("x".ToCharArray()), B = 1 }, () => new PRec { A = "y", B = 1 });
-        Add("validated-class", "own-record-class", "base-depth-3", "nested-in-struct", typeof(L05Os216.L05_216_validated_class_own_record_class), () => new PRec { A = "x", B = 1 }, () => new PRec { A = new string("x".ToCharArray()), B = 1 }, () => new PRec { A = "y", B = 1 });
-        Add("validated-class", "own-record-class", "base-depth-3", "nested-two-levels", typeof(L05Ot217.Inner.L05_217_validated_class_own_record_class), () => new PRec { A = "x", B = 1 }, () => new PRec { A = new string("x".ToCharArray()), B = 1 }, () => new PRec { A = "y", B = 1 });
-        Add("validated-class", "own-record-class", "base-explicit-IEquatable", "nested-in-struct", typeof(L05Os218.L05_218_validated_class_own_record_class), () => new PRec { A = "x", B = 1 }, () => new PRec { A = new string("x".ToCharArray()), B = 1 }, () => new PRec { A = "y", B = 1 });
-        Add("validated-class", "own-record-class", "none", "nested-in-class", typeof(L05Oc219.L05_219_validated_class_own_record_class), () => new PRec { A = "x", B = 1 }, () => new PRec { A = new string("x".ToCharArray()), B = 1 }, () => new PRec { A = "y", B = 1 });
-        Add("validated-class", "string", "base-depth-1", "nested-in-struct", typeof(L05Os220.L05_220_validated_class_string), () => "alpha", () => new string("alpha".ToCharArray()), () => "beta");
-        Add("validated-class", "string", "base-depth-2", "nested-two-levels", typeof(L05Ot221.Inner.L05_221_validated_class_string), () => "alpha", () => new string("alpha".ToCharArray()), () => "beta");
-        Add("validated-class", "string", "base-depth-3", "nested-in-class", typeof(L05Oc222.L05_222_validated_class_string), () => "alpha", () => new string("alpha".ToCharArray()), () => "beta");
-        Add("validated-class", "string", "explicit-interface-member", "top-level", typeof(L05_223_validated_class_string), () => "alpha", () => new string("alpha".ToCharArray()), () => "beta");
-        Add("validated-class", "ulong", "base-depth-1", "nested-in-struct", typeof(L05Os224.L05_224_validated_class_ulong), () => 4200000000UL, () => 4200000000UL, () => 4200000001UL);
-        Add("validated-class", "ulong", "base-depth-1", "top-level", typeof(L05_225_validated_class_ulong), () => 4200000000UL, () => 4200000000UL, () => 4200000001UL);
-        Add("validated-class", "ulong", "base-depth-2", "top-level", typeof(L05_226_validated_class_ulong), () => 4200000000UL, () => 4200000000UL, () => 4200000001UL);
-        Add("validated-class", "ulong", "base-depth-3", "nested-in-class", typeof(L05Oc227.L05_227_validated_class_ulong), () => 4200000000UL, () => 4200000000UL, () => 4200000001UL);
-        Add("validated-class", "ulong", "explicit-interface-member", "nested-in-class", typeof(L05Oc228.L05_228_validated_class_ulong), () => 4200000000UL, () => 4200000000UL, () => 4200000001UL);
-        Add("validated-class", "ulong", "explicit-interface-member", "nested-in-struct", typeof(L05Os229.L05_229_validated_class_ulong), () => 4200000000UL, () => 4200000000UL, () => 4200000001UL);
-        Add("validated-class", "ulong", "none", "nested-in-struct", typeof(L05Os230.L05_230_validated_class_ulong), () => 4200000000UL, () => 4200000000UL, () => 4200000001UL);
-        Add("validated-struct", "DateOnly", "explicit-interface-member", "nested-two-levels", typeof(L05Ot231.Inner.L05_231_validated_struct_DateOnly), () => new DateOnly(2026, 10, 15), () => DateOnly.FromDayNumber(new DateOnly(2026, 10, 15).DayNumber), () => new DateOnly(2026, 10, 16));
-        Add("validated-struct", "DateOnly", "none", "top-level", typeof(L05_232_validated_struct_DateOnly), () => new DateOnly(2026, 10, 15), () => DateOnly.FromDayNumber(new DateOnly(2026, 10, 15).DayNumber), () => new DateOnly(2026, 10, 16));
-        Add("validated-struct", "DateTime", "explicit-interface-member", "nested-two-levels", typeof(L05Ot233.Inner.L05_233_validated_struct_DateTime), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Utc), () => new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Unspecified), () => new DateTime(2026, 10, 15, 8, 31, 0, DateTimeKind.Utc));
-        Add("validated-struct", "DateTimeOffset", "none", "nested-in-struct", typeof(L05Os234.L05_234_validated_struct_DateTimeOffset), () => new DateTimeOffset(2026, 10, 15, 8, 30, 0, TimeSpan.Zero), () => new DateTimeOffset(2026, 10, 15, 10, 30, 0, TimeSpan.FromHours(2)), () => new DateTimeOffset(2026, 10, 15, 8, 31, 0, TimeSpan.Zero));
-        Add("validated-struct", "DateTimeOffset", "none", "top-level", typeof(L05_235_validated_struct_DateTimeOffset), () => new DateTimeOffset(2026, 10, 15, 8, 30, 0, TimeSpan.Zero), () => new DateTimeOffset(2026, 10, 15, 10, 30, 0, TimeSpan.FromHours(2)), () => new DateTimeOffset(2026, 10, 15, 8, 31, 0, TimeSpan.Zero));
-        Add("validated-struct", "Guid", "none", "nested-in-class", typeof(L05Oc236.L05_236_validated_struct_Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111"), () => new Guid("11111111111111111111111111111111"), () => Guid.Parse("22222222-2222-2222-2222-222222222222"));
-        Add("validated-struct", "Guid", "none", "nested-in-struct", typeof(L05Os237.L05_237_validated_struct_Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111"), () => new Guid("11111111111111111111111111111111"), () => Guid.Parse("22222222-2222-2222-2222-222222222222"));
-        Add("validated-struct", "NodaTime.Instant", "none", "top-level", typeof(L05_238_validated_struct_NodaTime_Instant), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30), () => global::NodaTime.Instant.FromUnixTimeTicks(global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30).ToUnixTimeTicks()), () => global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 31));
-        Add("validated-struct", "TimeOnly", "explicit-interface-member", "nested-in-class", typeof(L05Oc239.L05_239_validated_struct_TimeOnly), () => new TimeOnly(8, 30, 15), () => new TimeOnly(new TimeOnly(8, 30, 15).Ticks), () => new TimeOnly(8, 30, 16));
-        Add("validated-struct", "TimeOnly", "none", "top-level", typeof(L05_240_validated_struct_TimeOnly), () => new TimeOnly(8, 30, 15), () => new TimeOnly(new TimeOnly(8, 30, 15).Ticks), () => new TimeOnly(8, 30, 16));
-        Add("validated-struct", "TimeSpan", "none", "nested-in-class", typeof(L05Oc241.L05_241_validated_struct_TimeSpan), () => TimeSpan.FromMinutes(90), () => TimeSpan.FromSeconds(5400), () => TimeSpan.FromMinutes(91));
-        Add("validated-struct", "Uri", "explicit-interface-member", "nested-in-struct", typeof(L05Os242.L05_242_validated_struct_Uri), () => new Uri("https://example.com/a"), () => new Uri("HTTPS://EXAMPLE.COM/a"), () => new Uri("https://example.com/b"));
-        Add("validated-struct", "Uri", "explicit-interface-member", "top-level", typeof(L05_243_validated_struct_Uri), () => new Uri("https://example.com/a"), () => new Uri("HTTPS://EXAMPLE.COM/a"), () => new Uri("https://example.com/b"));
-        Add("validated-struct", "Uri", "none", "nested-in-class", typeof(L05Oc244.L05_244_validated_struct_Uri), () => new Uri("https://example.com/a"), () => new Uri("HTTPS://EXAMPLE.COM/a"), () => new Uri("https://example.com/b"));
-        Add("validated-struct", "bool", "explicit-interface-member", "nested-in-class", typeof(L05Oc245.L05_245_validated_struct_bool), () => false, () => false, () => true);
-        Add("validated-struct", "bool", "none", "nested-two-levels", typeof(L05Ot246.Inner.L05_246_validated_struct_bool), () => false, () => false, () => true);
-        Add("validated-struct", "byte", "explicit-interface-member", "top-level", typeof(L05_247_validated_struct_byte), () => (byte)7, () => (byte)7, () => (byte)8);
-        Add("validated-struct", "char", "explicit-interface-member", "nested-in-class", typeof(L05Oc248.L05_248_validated_struct_char), () => 'a', () => 'a', () => 'b');
-        Add("validated-struct", "decimal", "explicit-interface-member", "top-level", typeof(L05_249_validated_struct_decimal), () => 7.8m, () => 7.80m, () => 7.81m);
-        Add("validated-struct", "double", "explicit-interface-member", "nested-two-levels", typeof(L05Ot250.Inner.L05_250_validated_struct_double), () => 0.0, () => -0.0, () => 1.5);
-        Add("validated-struct", "double", "none", "nested-two-levels", typeof(L05Ot251.Inner.L05_251_validated_struct_double), () => 0.0, () => -0.0, () => 1.5);
-        Add("validated-struct", "enum", "none", "nested-in-class", typeof(L05Oc252.L05_252_validated_struct_enum), () => PEnum.B, () => (PEnum)1, () => PEnum.C);
-        Add("validated-struct", "enum", "none", "nested-in-struct", typeof(L05Os253.L05_253_validated_struct_enum), () => PEnum.B, () => (PEnum)1, () => PEnum.C);
-        Add("validated-struct", "enum", "none", "nested-two-levels", typeof(L05Ot254.Inner.L05_254_validated_struct_enum), () => PEnum.B, () => (PEnum)1, () => PEnum.C);
-        Add("validated-struct", "flags-enum", "none", "nested-two-levels", typeof(L05Ot255.Inner.L05_255_validated_struct_flags_enum), () => PFlags.P | PFlags.Q, () => (PFlags)3, () => PFlags.R);
-        Add("validated-struct", "flags-enum", "none", "top-level", typeof(L05_256_validated_struct_flags_enum), () => PFlags.P | PFlags.Q, () => (PFlags)3, () => PFlags.R);
-        Add("validated-struct", "int", "explicit-interface-member", "nested-in-struct", typeof(L05Os257.L05_257_validated_struct_int), () => 42, () => 42, () => 43);
-        Add("validated-struct", "int", "explicit-interface-member", "nested-two-levels", typeof(L05Ot258.Inner.L05_258_validated_struct_int), () => 42, () => 42, () => 43);
-        Add("validated-struct", "int", "none", "nested-two-levels", typeof(L05Ot259.Inner.L05_259_validated_struct_int), () => 42, () => 42, () => 43);
-        Add("validated-struct", "int", "none", "top-level", typeof(L05_260_validated_struct_int), () => 42, () => 42, () => 43);
-        Add("validated-struct", "long", "explicit-interface-member", "nested-in-struct", typeof(L05Os261.L05_261_validated_struct_long), () => 4200000000L, () => 4200000000L, () => 4200000001L);
-        Add("validated-struct", "long", "explicit-interface-member", "top-level", typeof(L05_262_validated_struct_long), () => 4200000000L, () => 4200000000L, () => 4200000001L);
-        Add("validated-struct", "own-record-class", "explicit-interface-member", "top-level", typeof(L05_263_validated_struct_own_record_class), () => new PRec { A = "x", B = 1 }, () => new PRec { A = new string("x".ToCharArray()), B = 1 }, () => new PRec { A = "y", B = 1 });
-        Add("validated-struct", "own-record-class", "none", "nested-in-struct", typeof(L05Os264.L05_264_validated_struct_own_record_class), () => new PRec { A = "x", B = 1 }, () => new PRec { A = new string("x".ToCharArray()), B = 1 }, () => new PRec { A = "y", B = 1 });
-        Add("validated-struct", "string", "explicit-interface-member", "nested-two-levels", typeof(L05Ot265.Inner.L05_265_validated_struct_string), () => "alpha", () => new string("alpha".ToCharArray()), () => "beta");
-        Add("validated-struct", "string", "none", "nested-in-class", typeof(L05Oc266.L05_266_validated_struct_string), () => "alpha", () => new string("alpha".ToCharArray()), () => "beta");
-        Add("validated-struct", "string", "none", "top-level", typeof(L05_267_validated_struct_string), () => "alpha", () => new string("alpha".ToCharArray()), () => "beta");
-        Add("validated-struct", "ulong", "explicit-interface-member", "top-level", typeof(L05_268_validated_struct_ulong), () => 4200000000UL, () => 4200000000UL, () => 4200000001UL);
-        Add("validated-struct", "ulong", "none", "top-level", typeof(L05_269_validated_struct_ulong), () => 4200000000UL, () => 4200000000UL, () => 4200000001UL);
-    }
-}
diff --git a/tools/probe/corpus/harness/OffTheWire.cs b/tools/probe/corpus/harness/OffTheWire.cs
deleted file mode 100644
index eae52bbf..00000000
--- a/tools/probe/corpus/harness/OffTheWire.cs
+++ /dev/null
@@ -1,221 +0,0 @@
-// Claim L06-off-the-wire (README.md#what-typekit-guarantees): "Option and Result stay off the wire. System.Text.Json throws
-// NotSupportedException for either, in both directions, instead of writing {} that reads back as None. [...] If you want a wire format of
-// your own, a converter you register on the options takes precedence." The message names the type (src/CodoMetis.TypeKit/README.md
-// "Option or Result in JSON"); a source-generated context refuses an Option<T>? or Result<...>? property with the serializer's own
-// InvalidOperationException when it builds that contract (ibid., "Good to know").
-// Oracle: exception, in every position, with the row's options and input, for an Option or Result produced by the row's operation. A
-// converter of the application's for the same type in the same row is the baseline: it must win in both directions, and where the options
-// leave the member out (it writes and reads nothing there), no converter runs, which is intended ("A missing property reaches no converter").
-#pragma warning disable CMTK0001 // default-instance: the default Option and Result are the shapes under test
-using System.Reflection;
-using System.Text.Json;
-using System.Text.Json.Serialization;
-using CodoMetis.TypeKit;
-using Probes.Shapes;
-namespace Probes.Json;
-
-/// <summary>An application's own converter for an Option or Result: writes "own-or" and reads it back as the value it was made with, counting reads.</summary>
-public sealed class OwnOrConverter<T>(T value) : JsonConverter<T>
-{
-    public int Reads;
-    public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
-    {
-        Reads++;
-        if (reader.TokenType is not (JsonTokenType.String or JsonTokenType.PropertyName) || reader.GetString() != "own-or") throw new JsonException("not own-or");
-        return value;
-    }
-    public override void Write(Utf8JsonWriter writer, T v, JsonSerializerOptions options) => writer.WriteStringValue("own-or");
-    public override T ReadAsPropertyName(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => Read(ref reader, typeToConvert, options);
-    public override void WriteAsPropertyName(Utf8JsonWriter writer, T v, JsonSerializerOptions options) => writer.WritePropertyName("own-or");
-}
-
-public static class OffTheWire
-{
-    public static async Task<string?> Check(Row r)
-    {
-        var kind = r["shape.kind"];
-        var e = kind == "closed-set" ? Registry.Get(kind, "-") : Registry.Get(kind, r["shape.wrapped"]);
-        var position = r["shape.position"];
-        var containing = position == "root" ? "class" : r["shape.containing"];
-        var shape = r["or.shape"]; var op = r["or.operation"];
-        _ = r["input.json"];   // the row's input, which every check of the row runs under; the read applies it
-        if (shape == "Result-E" && op is "query-syntax" or "FirstOrNone")
-        { r.Substituted("or.operation", "Match", "Result<TError> has no " + op + " (claims.json excludes the pair)"); op = "Match"; }
-        var voValue = Make.Vo(e, e.Valid());
-        var v = Make.Held(e.Vo);
-        var produce = typeof(OffTheWire).GetMethod(nameof(Produce), BindingFlags.NonPublic | BindingFlags.Static)!.MakeGenericMethod(v);
-        var (orType, orValue) = await (Task<(Type, object)>)produce.Invoke(null, [shape, op, voValue])!;
-        var key = shape == "Option" ? "O" : shape == "Result-E" ? "RE" : "RTE";
-        var pb = typeof(OffTheWire).Assembly.GetType($"Probes.Json.L06PB_{v.Name}_{key}")!; var pd = typeof(OffTheWire).Assembly.GetType($"Probes.Json.L06PD_{v.Name}_{key}")!;
-        var eo = e with { Vo = orType, Plain = orType, PolyBase = pb, PolyDerived = pd, PolyBasePlain = pb, PolyDerivedPlain = pd };
-        var hv = Pos.Build(position, containing, e, true, voValue);     // the value object's shape: its document is the read's input
-        var ho = Pos.Build(position, containing, eo, true, orValue);
-        var o = JCtx.Apply(r, e, hv.Declared, ho.Declared);
-        var own = (JsonConverter)Activator.CreateInstance(typeof(OwnOrConverter<>).MakeGenericType(orType), orValue)!;
-        var oOwn = new JsonSerializerOptions(o); oOwn.Converters.Insert(0, own);
-        int OwnReads() => (int)own.GetType().GetField("Reads")!.GetValue(own)!;
-        var name = Jx.Name(orType);
-        // not-promised a-source-generated-context-refuses-a-nullable
-        var nullableUnderContext = r.Is("json.TypeInfoResolver", "source-generated-context") && position == "nullable-property";
-        string? Refused(Exception? x, string dir)
-        {
-            if (nullableUnderContext)
-                return x is InvalidOperationException ? null : $"{dir}: a source-generated context refuses an {name}? property with the serializer's InvalidOperationException; got {(x is null ? "no exception" : Jx.Ex(x))}";
-            if (x is not NotSupportedException) return $"{dir}: expected NotSupportedException naming {name}, got {(x is null ? "no exception" : Jx.Ex(x))}";
-            // TypeKit's refusal, told by its type and never by its words: the serializer passes a converter's NotSupportedException on as the
-            // inner exception of its own, so one in the chain is thrown by NotWireTypeJsonConverterFactory's converter, by nameof
-            if (!ThrownBy(x, typeof(NotWireTypeJsonConverterFactory))) return $"{dir}: the NotSupportedException is not {nameof(NotWireTypeJsonConverterFactory)}'s: {Jx.Ex(x)}";
-            return null;
-        }
-
-        // the baseline: the application's own converter for the type wins, in both directions
-        var (jOwn, xOwn) = Jx.Ser(ho, oOwn);
-        var (jv, xv) = Jx.Ser(hv, o);
-        var refused = Baseline.Refusal;
-        var fw = r.Check("never-written", refused, c =>
-        {
-            if (xOwn is not null)
-            {
-                if (xv is not null && xv.GetType() == xOwn.GetType()) return c.Inconclusive("write: the options refuse the shape itself, with the application's converter alike: " + Jx.Ex(xv));
-                return $"write: a converter registered on the options for {name} does not take precedence: {Jx.Ex(xOwn)}";
-            }
-            var ownWritten = Jx.Tokens(jOwn!).Any(t => t.Text == "own-or");
-            var (jo, xo) = Jx.Ser(ho, o);
-            if (xo is null)
-            {
-                if (ownWritten || jo != jOwn) return $"write: {name} was written: {Jx.Cut(jo)}";
-                // the options leave the member out, the application's converter's document alike: no converter ran
-                c.Note(NoteKeys.JsonMemberLeftOutByOptions, "write: " + Jx.Cut(jo));
-                return c.Inconclusive("write: the options leave the member out, so no converter runs: " + Jx.Cut(jo));
-            }
-            if (Refused(xo, "write") is { } f) return f;
-            c.Note(NoteKeys.Compared, $"{name} by {op}, {position}: write refused");
-            return null;
-        });
-        // reading: the value object's document with the row's input, where the Option or Result stands; measured before the check, so that
-        // a document the serializer refuses before the member (side (1), Sides) decides the check's baseline
-        var full = Jx.Full(o);
-        var (jf, xf) = Jx.Ser(hv, full);
-        // does the application's converter get called there? Its own document, read under the same options, says so
-        var (jOwnFull, _) = Jx.Ser(ho, Jx.Full(oOwn));
-        string input = r["input.json"], text = "";
-        if (xf is null) text = JsonParity.InputFor(input, e, full, jf!, position);
-        else if (jOwnFull is not null) { input = "valid"; text = jOwnFull; }
-        var reads = xOwn is null && (xf is null || jOwnFull is not null);
-        var (_, xOwnRead) = reads ? Jx.De(jOwnFull ?? "null", ho.Declared, oOwn) : (null, null);
-        var memberRead = reads && OwnReads() > 0;
-        var (vr, xr) = reads ? Jx.De(text, ho.Declared, o) : (null, null);
-        // side (1): the same document with the value object where the Option or Result stands, read under the same options; refusing alike
-        // (the same exception type at the same path, no message compared), the serializer refused the document before the member
-        var three = new Sides.Answer("read", null, xr);
-        var one = new Sides.Answer("read", null, reads && xr is not null && !ThrownBy(xr, typeof(NotWireTypeJsonConverterFactory)) ? Jx.De(text, hv.Declared, o).Ex : null);
-        var framework = Sides.Alike(one, three) ? Sides.Measured(one, "the document with the value object where the Option or Result stands") : null;
-        var fr = await Sides.Check(r, "never-read", refused, framework, three, null, null, async c =>
-        {
-            await Task.CompletedTask;
-            if (xOwn is not null) return c.Inconclusive("read: the options refuse the shape itself, so no document has the member: " + Jx.Ex(xOwn));
-            _ = c["input.json"];
-            if (xf is not null)
-            {
-                // the value object's own shape cannot be written here (a value object over a class under Preserve, a class as a key): the
-                // document with the application's converter has a token where the Option or Result stands, and is read as it is
-                if (jOwnFull is null) return c.Inconclusive("read: no document has the member: " + Jx.Ex(xf));
-                c.Substituted("input.json", "valid", "the value object's document cannot be written: " + xf.GetType().Name);
-            }
-            if (xOwnRead is not null) return $"read: a converter registered on the options for {name} does not take precedence: {Jx.Ex(xOwnRead)}";
-            if (xr is null && input == "null" && position == "in-patch" && Jx.Member(ho.Declared, vr) is { } patch && patch.GetType().GetProperty("State")!.GetValue(patch)!.ToString() == "Null")
-                // a JSON null is the patch's own null (docs/merge-patches.md): it holds no Option or Result, and none was read
-                return c.Inapplicable(Cite.Docs("docs/merge-patches.md#tell-absent-null-and-a-value-apart"), $"read null: the Patch<{name}> is null, nothing of {name} read");
-            if (xr is null)
-            {
-                if (memberRead) return $"read {input}: {name} was read without an exception\n  text={Jx.Cut(text)}";
-                c.Note(NoteKeys.JsonMemberLeftOutByOptions, "read " + input);
-                return c.Inapplicable(Cite.NotPromised("a-missing-property-reaches-no-converter"), "read " + input);
-            }
-            if (Refused(xr, "read " + input) is { } f) return f + $"\n  text={Jx.Cut(text)}";
-            c.Note(NoteKeys.Compared, $"{name} by {op}, {position}: read {input} refused");
-            return null;
-        });
-        return fw ?? fr;
-    }
-
-    /// <summary>
-    /// Whether a refusal, or one in its chain of inner exceptions, was thrown by a converter that <paramref name="factory"/> declares: the
-    /// method that threw it (its TargetSite) belongs to the factory's type or to a type nested in it. Told by types, never by a message.
-    /// </summary>
-    static bool ThrownBy(Exception? x, Type factory)
-    {
-        for (; x is not null; x = x.InnerException)
-            for (var t = x.TargetSite?.DeclaringType; t is not null; t = t.DeclaringType)
-                if (t == factory) return true;
-        return false;
-    }
-
-    static async Task<(Type, object)> Produce<V>(string shape, string op, V v) where V : notnull
-    {
-        switch (shape)
-        {
-            case "Option":
-            {
-                Option<V> x = op switch
-                {
-                    "Match" => Option.Some(v).Match(s => Option.Some(s), () => Option.None<V>()),
-                    "Bind-Map-chain" => Option.Some(v).Bind(s => Option.Some(s)).Map(s => s),
-                    "query-syntax" => from s in Option.Some(v) select s,
-                    "Sequence-Transpose" => Option.Some(Result<V, ShapeFault>.Success(v)).Transpose().Match(s => s, _ => Option.None<V>()),
-                    "Result.Catch" => Result.Catch(() => v).ToOption(),
-                    "FirstOrNone" => new[] { v }.FirstOrNone(),
-                    "default-instance" => default,
-                    "after-await-elsewhere" => await Task.Run(() => Option.Some(v)).ConfigureAwait(false),
-                    _ => throw new ArgumentException(op),
-                };
-                return (typeof(Option<V>), x);
-            }
-            case "Result-E":
-            {
-                Result<V> x = op switch
-                {
-                    "Match" => Result<V>.Error(v).Match(() => Result<V>.Success(), er => Result<V>.Error(er)),
-                    "Bind-Map-chain" => Result<V>.Success().Bind(() => Result<V>.Error(v)),
-                    "Sequence-Transpose" => new[] { Result<V>.Error(v) }.Sequence(),
-                    "Result.Catch" => Result.Catch(() => { }).MapError(_ => v),
-                    "default-instance" => default,
-                    "after-await-elsewhere" => await Task.Run(() => Result<V>.Error(v)).ConfigureAwait(false),
-                    _ => throw new ArgumentException(op),
-                };
-                return (typeof(Result<V>), x);
-            }
-            default:
-            {
-                Result<V, ShapeFault> x;
-                if (shape == "Task-of-Result")
-                {
-                    var ok = Task.FromResult(Result<V, ShapeFault>.Success(v));
-                    x = op switch
-                    {
-                        "Bind-Map-chain" => await ok.BindAsync(s => Result<V, ShapeFault>.Success(s)).MapAsync(s => s),
-                        "FirstOrNone" => await Task.FromResult(new[] { v }.FirstOrNone()).ToResultAsync(ShapeFault.Refused),
-                        "Result.Catch" => await Result.CatchAsync(() => Task.FromResult(v)).MapErrorAsync(_ => ShapeFault.Refused),
-                        _ => await Task.FromResult(await Sync(op, v)).ConfigureAwait(false),
-                    };
-                }
-                else if (shape == "ValueTask-of-Result") x = await new ValueTask<Result<V, ShapeFault>>(await Sync(op, v));
-                else x = await Sync(op, v);
-                return (typeof(Result<V, ShapeFault>), x);
-            }
-        }
-    }
-
-    static async Task<Result<V, ShapeFault>> Sync<V>(string op, V v) where V : notnull => op switch
-    {
-        "Match" => Result<V, ShapeFault>.Success(v).Match(s => Result<V, ShapeFault>.Success(s), er => Result<V, ShapeFault>.Error(er)),
-        "Bind-Map-chain" => Result<V, ShapeFault>.Success(v).Bind(s => Result<V, ShapeFault>.Success(s)).Map(s => s),
-        "query-syntax" => from s in Result<V, ShapeFault>.Success(v) select s,
-        "Sequence-Transpose" => new[] { Result<V, ShapeFault>.Success(v) }.Sequence().Map(l => l[0]),
-        "Result.Catch" => Result.Catch(() => v).MapError(_ => ShapeFault.Refused),
-        "FirstOrNone" => new[] { v }.FirstOrNone().ToResult(ShapeFault.Refused),
-        "default-instance" => default,
-        "after-await-elsewhere" => await Task.Run(() => Result<V, ShapeFault>.Success(v)).ConfigureAwait(false),
-        _ => throw new ArgumentException(op),
-    };
-}
diff --git a/tools/probe/corpus/harness/Positions.cs b/tools/probe/corpus/harness/Positions.cs
deleted file mode 100644
index 800e60ba..00000000
--- a/tools/probe/corpus/harness/Positions.cs
+++ /dev/null
@@ -1,328 +0,0 @@
-// Builds the value a probe serializes for a row's shape.position x shape.containing (VO side and plain side), and the JSON parity oracle.
-using System.Collections;
-using System.Collections.Immutable;
-using System.Globalization;
-using System.Reflection;
-using System.Text.Json;
-using CodoMetis.TypeKit;
-namespace Probes.Shapes;
-
-public sealed record Held(Type Declared, object Value);
-
-public static class Pos
-{
-    static Type Family(string containing, string style, Type m)
-    {
-        var n = containing.Replace('-', '_');
-        var arity = containing == "generic-type" ? 2 : 1;
-        var open = typeof(PSet).Assembly.GetType($"Probes.Shapes.Cn_{n}_{style}`{arity}") ?? throw new InvalidOperationException($"no container Cn_{n}_{style}");
-        return arity == 2 ? open.MakeGenericType(m, typeof(int)) : open.MakeGenericType(m);
-    }
-
-    public static Held Build(string position, string containing, Entry e, bool vo, object sample)
-    {
-        var t = vo ? e.Vo : e.Plain;
-        if (position == "root") return new(t, sample);
-        Type m; object member; string style = "P";
-        switch (position)
-        {
-            case "property": case "required-init": case "field": case "record-ctor-parameter":
-                m = t; member = sample;
-                style = position switch { "field" => "F", "record-ctor-parameter" => "C", "required-init" => "R", _ => "P" };
-                break;
-            case "nullable-property": m = t.IsValueType && Nullable.GetUnderlyingType(t) is null ? typeof(Nullable<>).MakeGenericType(t) : t; member = sample; break;
-            case "list-element": case "read-only-list-element":
-            {
-                var l = (IList)Activator.CreateInstance(typeof(List<>).MakeGenericType(t))!; l.Add(sample);
-                member = l; m = position == "list-element" ? l.GetType() : typeof(IReadOnlyList<>).MakeGenericType(t); break;
-            }
-            case "array-element": { var a = Array.CreateInstance(t, 1); a.SetValue(sample, 0); member = a; m = a.GetType(); break; }
-            case "immutable-array-element":
-            {
-                var l = (IList)Activator.CreateInstance(typeof(List<>).MakeGenericType(t))!; l.Add(sample);
-                var create = typeof(ImmutableArray).GetMethods().First(x => x.Name == "CreateRange" && x.GetParameters().Length == 1).MakeGenericMethod(t);
-                member = create.Invoke(null, [l])!; m = member.GetType(); break;
-            }
-            // a dictionary key is never null: a nullable twin (or, under http.nullability=nullable, a nullable value object) is a key of the type it holds
-            case "dictionary-key": { var d = (IDictionary)Activator.CreateInstance(typeof(Dictionary<,>).MakeGenericType(Make.Held(t), typeof(int)))!; d.Add(sample, 1); member = d; m = d.GetType(); break; }
-            case "dictionary-value": { var d = (IDictionary)Activator.CreateInstance(typeof(Dictionary<,>).MakeGenericType(typeof(string), t))!; d.Add("k", sample); member = d; m = d.GetType(); break; }
-            // a Patch<T> holds no null (T : notnull): a nullable twin is patched as the type it holds, as a dictionary key is
-            case "in-patch":
-                member = typeof(Patch).GetMethod("Value")!.MakeGenericMethod(Make.Held(t)).Invoke(null, [sample])!; m = member.GetType(); break;
-            case "polymorphic-derived-property":
-            {
-                var derived = vo ? e.PolyDerived : e.PolyDerivedPlain;
-                var inst = Activator.CreateInstance(derived)!; derived.GetProperty("Value")!.SetValue(inst, sample);
-                member = inst; m = vo ? e.PolyBase : e.PolyBasePlain; break;
-            }
-            default: throw new ArgumentException("unknown position " + position);
-        }
-        var ct = Family(containing, style, m);
-        object c;
-        if (style == "C") c = Activator.CreateInstance(ct, member)!;
-        else
-        {
-            c = Activator.CreateInstance(ct)!;
-            if (style == "F") ct.GetField("F")!.SetValue(c, member); else ct.GetProperty("P")!.SetValue(c, member);
-        }
-        return new(ct, c);
-    }
-}
-
-/// <summary>
-/// Input equivalence for the differential oracles: the twin and the value object must hold the same shape under the same options, the
-/// twin standing where the value object stands, at its nullability: both admit null or neither (shapes.cs makes the twin of a class value
-/// object over a struct the struct made nullable). The one difference no plain type can mirror is a struct value object over a class,
-/// which refuses the null its twin reads (not-promised a-struct-refuses-a-json-null), and a dictionary key and what a patch holds, which
-/// are never null on either side. A mismatch is a harness error, never a pass or a product violation (Sides.Twins).
-/// </summary>
-public static class Equivalence
-{
-    public static string? Shapes(Type plain, Type vo, Entry e) => Shapes(plain, vo, e, key: false);
-
-    static string? Shapes(Type plain, Type vo, Entry e, bool key)
-    {
-        if (plain == vo) return null;
-        if (Make.Held(vo) == Make.Held(e.Vo)) return Member(plain, vo, e, key);
-        if (plain.IsArray && vo.IsArray) return Shapes(plain.GetElementType()!, vo.GetElementType()!, e, false);
-        if (plain.IsGenericType && vo.IsGenericType && plain.GetGenericTypeDefinition() == vo.GetGenericTypeDefinition())
-        {
-            var pa = plain.GetGenericArguments(); var va = vo.GetGenericArguments();
-            // a dictionary's key and what a patch holds are never null, on either side
-            var notNull = plain.GetGenericTypeDefinition() == typeof(Dictionary<,>) || plain.GetGenericTypeDefinition() == typeof(Patch<>);
-            for (var i = 0; i < pa.Length; i++) if (Shapes(pa[i], va[i], e, notNull && i == 0) is { } why) return why;
-            return null;
-        }
-        // The generated stand-ins (the polymorphic bases and derived types): one per side by design, equal in
-        // structure: the same properties by name, each of an equivalent type, and the same polymorphism.
-        if (plain.IsClass && vo.IsClass && !plain.IsGenericType && !vo.IsGenericType)
-        {
-            var pp = plain.GetProperties().ToDictionary(x => x.Name); var vp = vo.GetProperties().ToDictionary(x => x.Name);
-            if (!pp.Keys.Order().SequenceEqual(vp.Keys.Order())) return $"{Name(plain)} and {Name(vo)} have different properties";
-            foreach (var (name, prop) in pp) if (Shapes(prop.PropertyType, vp[name].PropertyType, e, false) is { } why) return $"{name}: {why}";
-            var pd = plain.GetCustomAttributes(typeof(System.Text.Json.Serialization.JsonDerivedTypeAttribute), false).Length;
-            var vd = vo.GetCustomAttributes(typeof(System.Text.Json.Serialization.JsonDerivedTypeAttribute), false).Length;
-            if (pd != vd) return $"{Name(plain)} and {Name(vo)} declare {pd} and {vd} derived types";
-            if ((plain.BaseType is { } pb && pb != typeof(object)) || (vo.BaseType is { } vb && vb != typeof(object)))
-                return Shapes(plain.BaseType!, vo.BaseType!, e, false);
-            return null;
-        }
-        return $"{Name(plain)} and {Name(vo)} are different shapes";
-    }
-
-    /// <summary>Where the value object stands: its twin, at its nullability.</summary>
-    static string? Member(Type plain, Type vo, Entry e, bool key)
-    {
-        if (Make.Held(plain) != Make.Held(e.Plain)) return $"{Name(plain)} stands where {Name(vo)} should face {Name(e.Plain)}";
-        if (key || Make.AdmitsNull(plain) == Make.AdmitsNull(vo)) return null;
-        // a struct value object over a class refuses the JSON null its twin reads: no plain type mirrors it, the claims cite it
-        if (!Make.AdmitsNull(vo) && !Make.Held(e.Plain).IsValueType) return null;
-        return $"{Name(plain)} and {Name(vo)} differ in nullability: the twin {(Make.AdmitsNull(plain) ? "admits" : "refuses")} null, the value object {(Make.AdmitsNull(vo) ? "admits" : "refuses")} it";
-    }
-
-    public static string? Options(JsonSerializerOptions plain, JsonSerializerOptions vo, bool allowConverters)
-    {
-        if (ReferenceEquals(plain, vo)) return null;
-        foreach (var p in typeof(JsonSerializerOptions).GetProperties())
-        {
-            if (p.GetIndexParameters().Length > 0 || (allowConverters && p.Name == "Converters")) continue;
-            var a = Print(p.GetValue(plain)); var b = Print(p.GetValue(vo));
-            if (a != b) return $"options differ in {p.Name}: {a} vs {b}";
-        }
-        return null;
-    }
-
-    static string Print(object? v) => v switch
-    {
-        null => "null",
-        string or bool or char or int or Enum => v.ToString()!,
-        System.Collections.IEnumerable list => "[" + string.Join(",", list.Cast<object?>().Select(x => x?.GetType().FullName)) + "]",
-        _ => v.GetType().FullName!,
-    };
-
-    static string Name(Type t) => t.IsGenericType ? t.Name[..t.Name.IndexOf('`')] + "<" + string.Join(",", t.GetGenericArguments().Select(Name)) + ">" : t.Name;
-}
-
-public static class JsonParity
-{
-    static (string? Json, Exception? Ex) Ser(Held h, JsonSerializerOptions o)
-    { try { return (JsonSerializer.Serialize(h.Value, h.Declared, o), null); } catch (Exception ex) { return (null, ex); } }
-    static (string? Json, Exception? Ex) De(string text, Held h, JsonSerializerOptions o)
-    {
-        try { var v = JsonSerializer.Deserialize(text, h.Declared, o); return (v is null ? "null" : JsonSerializer.Serialize(v, h.Declared, o), null); }
-        catch (Exception ex) { return (null, ex); }
-    }
-
-    static string Limit(Entry e) => e.Wrapped switch
-    {
-        "int" => "2147483647", "long" => "9223372036854775807", "byte" => "255", "ulong" => "18446744073709551615",
-        "decimal" => "79228162514264337593543950335", "double" => "1.7976931348623157E+308", "bool" => "true",
-        "string" => "\"" + new string('x', 70000) + "\"", "char" => "\"\\uffff\"", "enum" => "2147483647", "flags-enum" => "7",
-        "DateTime" => "\"9999-12-31T23:59:59.9999999Z\"", "DateTimeOffset" => "\"9999-12-31T23:59:59.9999999+00:00\"",
-        "DateOnly" => "\"9999-12-31\"", "TimeOnly" => "\"23:59:59.9999999\"", "TimeSpan" => "\"10675199.02:48:05.4775807\"",
-        "Uri" => "\"https://example.com/" + new string('p', 3000) + "\"", "NodaTime.Instant" => "\"9999-12-31T23:59:59.999999999Z\"",
-        "own-record-class" => "{\"A\":\"x\",\"B\":2147483647}", "Guid" => "\"ffffffff-ffff-ffff-ffff-ffffffffffff\"",
-        _ => "\"Beta\""
-    };
-
-    /// <summary>Text a position's JSON takes for an input.json value, built from the plain side's JSON by replacing the sample's own text.</summary>
-    public static string InputFor(string input, Entry e, JsonSerializerOptions o, string jp, string position) => Input(input, e, o, jp, position);
-    static string Input(string input, Entry e, JsonSerializerOptions o, string jp, string position)
-    {
-        string sample;
-        try { sample = JsonSerializer.Serialize(e.Valid(), e.Plain, o); } catch { return jp; }
-        var at = jp.IndexOf(sample, StringComparison.Ordinal);
-        string Swap(string with) => at < 0 ? jp : jp[..at] + with + jp[(at + sample.Length)..];
-        switch (input)
-        {
-            case "valid": return jp;
-            case "refused-by-create":
-                if (e.Refused() is not { } rf) return jp;
-                try { return Swap(JsonSerializer.Serialize(rf, e.Plain, o)); } catch { return jp; }
-            case "wrong-token": return Swap(sample.StartsWith('"') || sample.StartsWith('{') ? "[]" : "\"zz\"");
-            case "null": return Swap("null");
-            case "empty-string": return Swap("\"\"");
-            case "at-type-limit": return Swap(Limit(e));
-            case "quoted-number": return Swap(sample.StartsWith('"') ? sample : "\"" + sample + "\"");
-            case "escape-sequence":
-                return sample.StartsWith('"') && sample.Length > 3 ? Swap(sample[..1] + "\\u00" + ((int)sample[1]).ToString("x2") + sample[2..]) : jp;
-            case "duplicate-property": return jp.StartsWith('{') && jp.Length > 2 ? "{" + jp[1..^1] + "," + jp[1..^1] + "}" : jp;
-            case "metadata-property": return jp.StartsWith('{') ? (jp.Length > 2 ? "{\"$id\":\"1\"," + jp[1..] : "{\"$id\":\"1\"}") : jp;
-            default: throw new ArgumentException("input " + input);
-        }
-    }
-
-    static bool Validated(Entry e) => e.Kind.StartsWith("validated");
-
-    /// <summary>
-    /// The oracle "JSON parity" (differential) as L01's checks, three-sided (Sides): the value object's write (3) against the wrapped twin in
-    /// the same shape under the same options (2), held to the twin under the application's options less TypeKit's converters (1), as
-    /// the-underlying-types-json, or as-a-dictionary-key-too where the value object is a dictionary key; and the read of the twin's document
-    /// with the row's input.json, read-as-the-underlying-type-reads, alike. L01 promises the underlying type's JSON, so side (1) runs on every
-    /// row. Under an application's converter for the value object, which writes it instead of the generated one, the read is that
-    /// converter's own document read back. Every check runs; returns the first failure.
-    /// </summary>
-    public static string? Check(Row r, Entry e, JsonSerializerOptions o, string position, string containing, string input, JsonSerializerOptions? oPlain = null)
-    {
-        oPlain ??= o;
-        var plain = e.Valid();
-        var voV = Make.Vo(e, plain);
-        var (hp, hv) = Sides.Twins(position, containing, e, plain, voV);
-        // Input equivalence of the options: the two sides may differ only by the substituted type, not in options (the shapes: Sides.Twins).
-        if (Equivalence.Options(oPlain, o, allowConverters: e.Kind == "closed-set") is { } whyOptions) { r.Outcome("harness-error", "inputs not equivalent: " + whyOptions); return null; }
-        var one = Sides.WithoutTypeKit(oPlain);
-        var w1 = Sides.Write(hp, one); var w2 = Sides.Write(hp, oPlain); var w3 = Sides.Write(hv, o);
-        var write = position == "dictionary-key" ? "as-a-dictionary-key-too" : "the-underlying-types-json";
-        const string read = "read-as-the-underlying-type-reads";
-        string? fw, fr;
-        if (r.Get("json.Converters") == "own-for-value-object")
-        {
-            // "Your own converter wins" (AspNetCore README#what-the-document-says): the application's converter writes the value object
-            // instead of the generated one, so the twin's bytes are none of its. claims.json declares the write inapplicable there.
-            fw = r.Check(write, Baseline.Twin, c => c.Inapplicable(Cite.Docs("src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says"), "write"));
-            fr = r.Check(read, Baseline.RoundTrip, c => Sides.Interferes(w1, w2) ?? OwnVoRead(c, e, hp, hv, oPlain, o, w3.Value, w3.Thrown, w2.Thrown));
-            return fw ?? fr;
-        }
-        fw = Sides.Check(r, write, Baseline.Twin, Sides.Framework(r, e, hp, one, w1, w3), w3, w1, w2, c => Write(c, e, position, w2, w3));
-        if (e.Wrapped == "byte" && position == "array-element")
-            fr = r.Check(read, Baseline.Twin, c => c.Inapplicable(Cite.NotPromised("a-byte-array-is-base64"), "read"));
-        else if (e.Kind == "closed-set" && position == "dictionary-key" && r.Get("json.DictionaryKeyPolicy") is not (null or "default"))
-            fr = r.Check(read, Baseline.Twin, c => c.Inapplicable(Cite.NotPromised("a-closed-set-key-is-its-name"), "read"));
-        else if (w2.Value is not { } jp)
-            fr = r.Check(read, Baseline.Twin, c => c.Inconclusive("read: the wrapped type is not written under these options, so there is no document to read"));
-        else
-        {
-            var text = Input(input, e, oPlain, jp, position);
-            var r1 = Sides.Read(text, hp, one); var r2 = Sides.Read(text, hp, oPlain); var r3 = Sides.Read(text, hv, o);
-            fr = Sides.Check(r, read, Baseline.Twin, Sides.Framework(r, e, hp, one, r1, r3), r3, r1, r2, c => Read(c, e, position, input, text, jp, r2, r3));
-        }
-        return fw ?? fr;
-    }
-
-    /// <summary>The value object's document (3) is the wrapped twin's (2), byte for byte, in the same shape under the same options; (1) and (3) refusing alike is decided before (Sides).</summary>
-    static string? Write(Check c, Entry e, string position, Sides.Answer p, Sides.Answer v)
-    {
-        // System.Text.Json writes byte[] as base64 and an array of value objects over byte as a JSON array (KB-038); claims.json declares it
-        if (e.Wrapped == "byte" && position == "array-element" && p.Value != v.Value) return c.Inapplicable(Cite.NotPromised("a-byte-array-is-base64"), "write");
-        if (p.Refused && v.Refused)
-            // Both refused, not alike (Sides.Alike): evidence about refusing, not about serializing, and nothing to compare.
-            return c.Inconclusive($"write: both refuse, not alike: the wrapped type {p}, the value object {v}");
-        if (!p.Refused && v.Refused)
-        {
-            if (c.Is("json.ReferenceHandler", "Preserve") && e.Wrapped == "own-record-class" && v.Thrown is NotSupportedException) return c.Refused(Cite.NotPromised("preserved-references-over-a-walked-class"), "write");
-            return $"wrapped serialized ({p.Value}) but the value object threw {v.Thrown!.GetType().Name}: {v.Thrown.Message}";
-        }
-        if (p.Refused) return $"value object serialized ({v.Value}) where the wrapped type threw {p.Thrown!.GetType().Name}: {p.Thrown.Message}";
-        // a closed set travels as its name, which no key policy renames; claims.json declares it
-        if (p.Value != v.Value && e.Kind == "closed-set" && position == "dictionary-key" && c.Get("json.DictionaryKeyPolicy") is not (null or "default")) return c.Inapplicable(Cite.NotPromised("a-closed-set-key-is-its-name"), "write");
-        if (p.Value != v.Value) return $"JSON differs: wrapped {Cut(p.Value)} vs value object {Cut(v.Value)}";
-        c.Note(NoteKeys.Compared, "write");
-        return null;
-    }
-
-    /// <summary>
-    /// The wrapped twin's document, with the row's input.json, read into both shapes (and what each read written again): each reads it as the
-    /// other does, or refuses as a document says; (1) and (3) refusing alike is decided before (Sides).
-    /// </summary>
-    static string? Read(Check c, Entry e, string position, string input, string text, string jp, Sides.Answer p, Sides.Answer v)
-    {
-        var stored = c.Get("json.Converters") == "StoredJsonConverterFactory";
-        if (p.Refused && v.Refused) return c.Inconclusive($"read {input}: both refuse, not alike: the wrapped type {p}, the value object {v}");
-        if (!p.Refused && v.Refused)
-        {
-            var xv = v.Thrown!;
-            if (c.Is("json.ReferenceHandler", "Preserve") && e.Wrapped == "own-record-class" && xv is NotSupportedException) return c.Refused(Cite.NotPromised("preserved-references-over-a-walked-class"), "read");
-            // The documented refusals, each the JsonException the generated converter throws.
-            if (!(xv is JsonException) && ((Validated(e) && input == "refused-by-create" && !stored) || (input == "null" && e.Vo.IsValueType) || (e.Kind == "closed-set" && input != "valid")))
-                return $"input {input}: the refusal is {xv.GetType().Name}, not JsonException: {Cut(xv.Message)}";
-            if (Validated(e) && input == "refused-by-create" && !stored) return c.Refused(Cite.NotPromised("a-validated-value-object-refuses-what-create-refuses"), $"read {input}");
-            if (input == "null" && e.Vo.IsValueType) return c.Refused(Cite.NotPromised("a-struct-refuses-a-json-null"), $"read {input}");
-            if (e.Kind == "closed-set" && input != "valid") return c.Refused(Cite.Docs("src/CodoMetis.TypeKit.Generators/README.md#matching-parsing-and-binding"), $"read {input}");   // "Unknown names are rejected."
-            return $"input {input}: wrapped read it, value object threw {xv.GetType().Name}: {Cut(xv.Message)}\n  text={Cut(text)}";
-        }
-        // a reference-type value object takes JSON null as null, as any class does
-        if (p.Refused && input == "null" && Make.AdmitsNull(e.Vo) && !Make.AdmitsNull(e.Plain)) return c.Inapplicable(Cite.Docs("docs/json.md#null-and-missing"), "read null");
-        if (p.Refused) return $"input {input}: value object read what the wrapped type refused ({p.Thrown?.GetType().Name}: {Cut(p.Thrown?.Message)})\n  text={Cut(text)}";
-        if (Validated(e) && input == "refused-by-create" && text != jp && !stored)
-            return $"validated value object accepted the refused value{(position == "dictionary-key" ? " as a dictionary key" : "")}: {Cut(text)}";
-        if (p.Value != v.Value) return $"input {input}: read-back differs: wrapped {Cut(p.Value)} vs value object {Cut(v.Value)}";
-        c.Note(NoteKeys.Compared, "read " + input);
-        return null;
-    }
-
-    /// <summary>
-    /// Under an application's converter for the value object, the generated converter does not run: the value object's document is that
-    /// converter's, and it reads back as written under the row's options. Where the value object's document cannot be written, a converter
-    /// the application registers for the wrapped type at the same position is the baseline.
-    /// </summary>
-    static string? OwnVoRead(Check c, Entry e, Held hp, Held hv, JsonSerializerOptions oPlain, JsonSerializerOptions o, string? jv, Exception? ev, Exception? ep)
-    {
-        var oOwn = new JsonSerializerOptions(oPlain);
-        oOwn.Converters.Insert(0, (System.Text.Json.Serialization.JsonConverter)Activator.CreateInstance(typeof(OwnWrappedConverter<>).MakeGenericType(Make.Held(e.Plain)), JsonRow.Inner(e))!);
-        var (jo, eo) = Ser(hp, oOwn);
-        if (ev is not null)
-        {
-            // System.Text.Json refuses any custom converter there (MaxDepth counts its value one level deeper, KB-040), the wrapped
-            // type's under a converter of the application's alike
-            if (ep is not null || (eo is not null && eo.GetType() == ev.GetType())) return c.Inconclusive($"the application's converter cannot write here, for the wrapped type too: {ev.GetType().Name}");
-            return $"own VO converter row: VO serialization threw {ev.GetType().Name}: {ev.Message}";
-        }
-        c.Note(NoteKeys.OwnVo);
-        var (back, eb) = De(jv!, hv, o);
-        if (eb is not null)
-        {
-            // the same converter for the wrapped type, at the same position: its own document does not read back under these options either
-            var ebOwn = jo is null ? eo : De(jo, hp, oOwn).Ex;
-            if (ebOwn is not null && ebOwn.GetType() == eb.GetType()) return c.Inconclusive($"the application's converter's document does not read back under these options, for the wrapped type too: {eb.GetType().Name}");
-            return "own VO converter: read-back threw " + eb.GetType().Name + ": " + eb.Message;
-        }
-        if (back != jv) return $"own VO converter round trip differs: {jv} vs {back}";
-        return null;
-    }
-    static string Cut(string? s) => s is null ? "(null)" : s.Length > 200 ? s[..200] + "..." : s;
-}
-
-public static class EntryExt
-{
-    public static object? Refused(this Entry e) => e.Kind.StartsWith("validated") ? e.RefusedFn() : null;
-}
diff --git a/tools/probe/corpus/harness/PreserveGuard.cs b/tools/probe/corpus/harness/PreserveGuard.cs
deleted file mode 100644
index 2f046f3d..00000000
--- a/tools/probe/corpus/harness/PreserveGuard.cs
+++ /dev/null
@@ -1,252 +0,0 @@
-// Claim C10-preserve-guard (src/CodoMetis.TypeKit.Generators/README.md#json): "Preserved references (ReferenceHandler.Preserve) throw a
-// NotSupportedException where the serializer could write $id or $ref inside the underlying value. That's a class it walks as an object [...]
-// These are unaffected: a value the serializer writes with a value converter (a number, a string, a Guid, a Uri), anything a converter of
-// your own writes, on the options or on one property, a struct of such values, and ReferenceHandler.IgnoreCycles."
-// Oracle: claim for the guarded rows (a value object over a class the serializer walks, under Preserve, with no converter of the
-// application's for it: NotSupportedException naming the type and Preserve, both directions, never a document); differential for the
-// unaffected rows (the value object's document is the wrapped type's under the same options, never an $id twice, and every read agrees
-// with the wrapped type's, a refusal being the section's: a JsonException naming the value object, with no inner exception).
-using System.Text.Json;
-using Probes.Shapes;
-namespace Probes.Json;
-
-public static class PreserveGuard
-{
-    public static string? Check(Row r)
-    {
-        var handler = r["handler"];
-        var want = handler == "none" ? "default" : handler;
-        var row = r;
-        if (r.Get("json.ReferenceHandler") is { } jr && jr != want)
-        {
-            // one setting under two names: the claim's handler decides (claims.json excludes the differing pairs)
-            r.Substituted("json.ReferenceHandler", want, "handler is the same setting");
-            row = r.With("json.ReferenceHandler", want);
-        }
-        var kind = r["shape.kind"];
-        var e = kind == "closed-set" ? Registry.Get(kind, "-") : Registry.Get(kind, r["shape.wrapped"]);
-        var position = r["shape.position"];
-        var containing = position == "root" ? "class" : r["shape.containing"];
-        _ = r["input.json"];   // the row's input, which every check of the row runs under; the reads apply it
-        var plain = e.Valid(); var voValue = Make.Vo(e, plain);
-        var (hp, hv) = Sides.Twins(position, containing, e, plain, voValue);
-        var o = JCtx.Apply(row, e, hp.Declared, hv.Declared);
-        // A closed set travels as its name, which no naming policy renames and no converter for strings writes (docs/closed-sets.md).
-        var op = kind == "closed-set" && (row.Get("json.DictionaryKeyPolicy") is not (null or "default") || row.Is("json.Converters", "own-for-wrapped"))
-            ? JCtx.Apply(row.With("json.DictionaryKeyPolicy", "default").With("json.Converters", row.Is("json.Converters", "own-for-wrapped") ? "default" : row["json.Converters"]), e, hp.Declared, hv.Declared)
-            : o;
-        var ownWrapped = row.Is("json.Converters", "own-for-wrapped");
-        var ownVo = row.Is("json.Converters", "own-for-value-object");
-        var guarded = want == "Preserve" && e.Wrapped == "own-record-class" && !ownWrapped && !ownVo;
-        // The obligation the row's handler and converters select: a converter of the application's, the guarded class under Preserve,
-        // IgnoreCycles, and otherwise a value the serializer writes with a value converter, under Preserve or with no handler at all.
-        var obligation = ownWrapped || ownVo ? "own-converters-unaffected" : guarded ? "refused-where-references-could-be-written"
-                       : want == "IgnoreCycles" ? "ignore-cycles-unaffected" : "value-converters-unaffected";
-        return guarded ? Guarded(r, obligation, e, hp, hv, o) : Unaffected(r, obligation, e, hp, hv, op, o, ownVo);
-    }
-
-    /// <summary>
-    /// The guarded rows: NotSupportedException naming the wrapped type and Preserve, in both directions, never a document. The read of the
-    /// wrapped type's document is three-sided (Sides): where the twin without TypeKit refuses it alike, the serializer refused the document
-    /// before any converter ran.
-    /// </summary>
-    static string? Guarded(Row r, string obligation, Entry e, Held hp, Held hv, JsonSerializerOptions o)
-    {
-        var wrapped = Make.Held(e.Plain);
-        string? Refusal(Exception? x, string what)
-        {
-            if (x is not NotSupportedException) return $"{what}: expected NotSupportedException naming {wrapped.Name} under ReferenceHandler.Preserve, got {(x is null ? "no exception" : Jx.Ex(x))}";
-            if (!x.Message.Contains(wrapped.FullName!) || !x.Message.Contains("ReferenceHandler.Preserve")) return $"{what}: the NotSupportedException does not name {wrapped.FullName} and ReferenceHandler.Preserve: {x.Message}";
-            return null;
-        }
-        var (jv, xv) = Jx.Ser(hv, o);
-        var (jp, xp) = Jx.Ser(hp, o);
-        var fw = r.Check(obligation, Baseline.Refusal, c =>
-        {
-            if (jv is not null)
-            {
-                // the options may leave the member out of the document, for the wrapped type too: then no converter ran, and nothing was refused
-                if (jp is not null && !Jx.Tokens(jp).Any(t => t.Text == "x") && !Jx.Tokens(jv).Any(t => t.Text == "x"))
-                { c.Note(NoteKeys.JsonMemberLeftOutByOptions, "write: " + Jx.Cut(jv)); return c.Inconclusive("write: the options leave the member out, for the wrapped type too: " + Jx.Cut(jv)); }
-                return Refusal(null, "write") + $"; it wrote {Jx.Cut(jv)}" + (DuplicateId(jv) is { } dup ? $" with {dup} twice" : "");
-            }
-            if (Refusal(xv, "write") is { } f) return f;
-            c.Note(NoteKeys.Compared, "write refused");
-            return null;
-        });
-        if (xp is not null)
-            return fw ?? r.Check(obligation, Baseline.Refusal, c => c.Inconclusive("read: the wrapped type's document is refused under these options, so there is none to read: " + Jx.Ex(xp)));
-        // reading: the wrapped type's own document, with the row's input applied
-        var input = r["input.json"];
-        var text = JsonParity.InputFor(input, e, Jx.Full(o), Jx.Ser(hp, Jx.Full(o)).Json ?? jp!, r["shape.position"]);
-        var (vp, ep) = Jx.De(text, hp.Declared, o);
-        var (vv, ev) = Jx.De(text, hv.Declared, o);
-        var one = Sides.WithoutTypeKit(o);
-        var r1 = new Sides.Answer("read", null, Jx.De(text, hp.Declared, one).Ex);
-        var r3 = new Sides.Answer("read", null, ev);
-        var fr = Sides.Check(r, obligation, Baseline.Refusal, r1.Refused && Sides.Alike(r1, r3) ? Sides.Measured(r1, "the twin's read under the application's options, less TypeKit's converters") : null, r3, null, null, c =>
-        {
-            if (ev is null)
-            {
-                // no converter ran: the read holds none of the wrapped value (a JSON null for a class, a member the options do not read)
-                if (vv is not null && Jx.Tokens(JsonSerializer.Serialize(vv, hv.Declared, Jx.Plain)).Any(t => t.Text == "x"))
-                    return $"read {input}: the value object over {Make.Held(e.Plain).Name} read a document under Preserve: {Jx.Cut(text)}";
-                c.Note(NoteKeys.JsonMemberLeftOutByOptions, "read " + input);
-                return c.Inconclusive($"read {input}: no converter ran, the read holds none of the wrapped value");
-            }
-            if (ev is NotSupportedException) { if (Refusal(ev, "read " + input) is { } f) return f; c.Note(NoteKeys.Compared, "read " + input + " refused"); return null; }
-            // refused before the guard: a JsonException naming the value object, with no inner exception (Generators README#json)
-            if (ev is not JsonException || ev.InnerException is not null) return Refusal(ev, "read " + input) + $"\n  text={Jx.Cut(text)}";
-            if (!ev.Message.Contains(Make.Held(e.Vo).Name)) return Refusal(ev, "read " + input) + $"\n  text={Jx.Cut(text)}";
-            c.Note(NoteKeys.Compared, "read " + input + ": refused naming the value object before the guard");
-            return null;
-        });
-        return fw ?? fr;
-    }
-
-    /// <summary>
-    /// The unaffected rows, three-sided (Sides; C10 promises these are unaffected, so side (1) runs on every row): the value object's
-    /// document (3) is the wrapped type's under the same options (2), which is the twin's without TypeKit's converters (1), never an $id
-    /// twice, and its read agrees with the wrapped type's (ReadAlike); under a converter of the application's for the value object, that
-    /// converter's document reads back and reads the row's input alike with and without the reference handler.
-    /// </summary>
-    static string? Unaffected(Row r, string obligation, Entry e, Held hp, Held hv, JsonSerializerOptions op, JsonSerializerOptions o, bool ownVo)
-    {
-        var one = Sides.WithoutTypeKit(op);
-        var w1 = Sides.Write(hp, one); var w2 = Sides.Write(hp, op); var w3 = Sides.Write(hv, o);
-        var (jp, xp) = (w2.Value, w2.Thrown); var (jv, xv) = (w3.Value, w3.Thrown);
-        // byte[] is base64 by the serializer's own rule (KB-038), an array of value objects a JSON array: unaffected means the value
-        // object's document reads back as written
-        var byteArray = e.Wrapped == "byte" && r.Is("shape.position", "array-element") && jv is not null && jp is not null && jv != jp;
-        var written = Sides.Framework(r, e, hp, one, w1, w3);
-        var fw = Sides.Check(r, obligation, ownVo || byteArray ? Baseline.RoundTrip : Baseline.Twin, written, w3, w1, w2, c =>
-        {
-            if (xp is not null && xv is not null) return $"write: both threw, not alike: the wrapped type {w2}, the value object {w3}";
-            if (xv is not null) return $"write: the value object threw {Jx.Ex(xv)} where the wrapped type wrote {Jx.Cut(jp)}";
-            // the application's converter for the value object writes its own document: its baseline is that document read back, whatever
-            // the twin's writes ("anything a converter of your own writes" is unaffected)
-            if (xp is not null && !ownVo) return $"write: the value object wrote {Jx.Cut(jv)} where the wrapped type threw {Jx.Ex(xp)}";
-            if (DuplicateId(jv!) is { } dup) return $"write: $id {dup} twice in {Jx.Cut(jv)}";
-            if (ownVo)
-            {
-                c.Note(NoteKeys.OwnVo);   // the application's converter for the value object writes its own document; it reads it back, unaffected
-                var (jf, _) = Jx.Ser(hv, Jx.Full(o));
-                var (_, xr) = Jx.De(jf ?? jv!, hv.Declared, o);
-                if (xr is not null) return "own converter for the value object: its document does not read back: " + Jx.Ex(xr);
-                return null;
-            }
-            if (byteArray)
-            {
-                var (back, xb) = Jx.De(jv!, hv.Declared, o);
-                if (xb is not null) return "write: the array of byte value objects does not read back: " + Jx.Ex(xb);
-                var again = JsonSerializer.Serialize(back, hv.Declared, o);
-                if (again != jv) return $"round trip: {Jx.Cut(jv)} read back as {Jx.Cut(again)}";
-                c.Note(NoteKeys.Compared, "an array of byte value objects round-trips as a JSON array");
-                return null;
-            }
-            if (jv != jp) return $"write: the value object wrote {Jx.Cut(jv)}, the wrapped type {Jx.Cut(jp)}";
-            c.Note(NoteKeys.Compared, "write");
-            return null;
-        });
-        if (ownVo) return fw ?? OwnReadsInput(r, obligation, e, hp, hv, o);
-        // the wrapped type's base64 document is no array of value objects (KB-038): the round trip above holds the value object to its own
-        if (byteArray) return fw ?? r.Check(obligation, Baseline.Twin, c => c.Inapplicable(Cite.Fact("KB-038"), "read: the wrapped type's document is a base64 string"));
-        // the value object's document is refused as the framework refuses it, so is its read: the write's refusal, as it is
-        if (written is not null && Sides.Alike(written.Answer, w3)) return fw ?? Sides.Check(r, obligation, Baseline.Twin, written, w3, null, null, _ => (string?)null);
-        var full = Jx.Ser(hp, Jx.Full(op)).Json ?? jp;
-        if (full is null) return fw ?? r.Check(obligation, Baseline.Twin, c => c.Inconclusive("read: the wrapped type is not written under these options, so there is no document to read"));
-        var input = r["input.json"];
-        var text = JsonParity.InputFor(input, e, Jx.Full(op), full, r["shape.position"]);
-        var r1 = Sides.Read(text, hp, one); var r2 = Sides.Read(text, hp, op); var r3 = Sides.Read(text, hv, o);
-        var fr = Sides.Check(r, obligation, Baseline.Twin, Sides.Framework(r, e, hp, one, r1, r3), r3, r1, r2, c => ReadAlike.Check(c, e, input, text, r2, r3, hp, hv, op, o));
-        return fw ?? fr;
-    }
-
-    /// <summary>
-    /// The application's converter for the value object reads the row's input inside its own spelling ("vo:" and the wrapped
-    /// type's JSON) alike under the row's reference handler and under none: "anything a converter of your own writes" is unaffected
-    /// (Generators README#json). Each side writes its own document, so Preserve's metadata is its own, and only the value is rewritten.
-    /// Where the handler's document is refused as the framework refuses a converter's value (KB-040), the check is that refusal.
-    /// </summary>
-    static string? OwnReadsInput(Row r, string obligation, Entry e, Held hp, Held hv, JsonSerializerOptions o)
-    {
-        var input = r["input.json"];
-        var inner = JsonRow.Inner(e);
-        var wrapped = JsonSerializer.Serialize(Make.Unwrap(e, Make.Vo(e, e.Valid())), Make.Held(e.Plain), inner);
-        var value = "vo:" + JsonParity.InputFor(input, e, inner, wrapped, "root");
-        var bare = new JsonSerializerOptions(o) { ReferenceHandler = null };
-        (string? Read, string? Refused, Sides.Answer? Write) Through(JsonSerializerOptions x)
-        {
-            var w = Sides.Write(hv, Jx.Full(x));
-            if (w.Refused) return (null, "write: " + w.Thrown!.GetType().Name, w);
-            var own = Jx.Tokens(w.Value!).Where(t => t.Type is JsonTokenType.String or JsonTokenType.PropertyName && t.Text is { } s && s.StartsWith("vo:", StringComparison.Ordinal)).ToList();
-            if (own.Count == 0) return (null, null, null);
-            var (v, rx) = Jx.De(Jx.Rewrite(w.Value!, own, _ => JsonSerializer.Serialize(value)), hv.Declared, x);
-            if (rx is not null) return (null, "read: " + rx.GetType().Name, null);
-            return (JsonSerializer.Serialize(v, hv.Declared, bare), null, null);
-        }
-        var handled = Through(o); var unhandled = Through(bare);
-        // the handler's document, written by the application's converter, refused as the framework refuses any converter's value there
-        var framework = (handled.Write ?? unhandled.Write) is { } refused ? Sides.WrittenByAConverter(r, e, hp, Sides.WithoutTypeKit(Jx.Full(handled.Write is null ? bare : o)), refused) : null;
-        return Sides.Check(r, obligation, Baseline.RoundTrip, framework, (handled.Write ?? unhandled.Write) ?? new Sides.Answer("write", null), null, null, c =>
-        {
-            if (handled.Read is null && handled.Refused is null && unhandled.Read is null && unhandled.Refused is null)
-            { c.Note(NoteKeys.JsonMemberLeftOutByOptions, "own converter: the options write no member"); return c.Inconclusive("own converter: the options write no member to read"); }
-            if (handled.Read != unhandled.Read || handled.Refused != unhandled.Refused)
-                return $"read {input} through the application's converter: {handled.Read ?? handled.Refused ?? "no member"} under ReferenceHandler {c["handler"]}, {unhandled.Read ?? unhandled.Refused ?? "no member"} without one";
-            c.Note(NoteKeys.Compared, $"read {input} through the application's converter, alike with and without the reference handler: {Jx.Cut(handled.Read ?? handled.Refused)}");
-            return null;
-        });
-    }
-
-    /// <summary>The first $id value a document holds twice, or null.</summary>
-    public static string? DuplicateId(string json)
-    {
-        var t = Jx.Tokens(json); var seen = new HashSet<string>();
-        for (var i = 0; i + 1 < t.Count; i++)
-            if (t[i].Type == JsonTokenType.PropertyName && t[i].Text == "$id" && !seen.Add(t[i + 1].Text ?? t[i + 1].Raw)) return t[i + 1].Text;
-        return null;
-    }
-}
-
-/// <summary>
-/// One read of the same text into the wrapped type's shape (2) and the value object's (3), each written again to be compared: they agree, or
-/// differ only as the documents say (a struct value object refuses a JSON null, a sealed record reads it as null, a validated one refuses what
-/// Create refuses, a closed set has only its members); a refusal of the value object's is a JsonException naming it, with no inner exception
-/// (Generators README#json). Side (1) refusing alike with (3) is decided before (Sides).
-/// </summary>
-public static class ReadAlike
-{
-    public static string? Check(Check c, Entry e, string input, string text, Sides.Answer p, Sides.Answer v, Held hp, Held hv, JsonSerializerOptions op, JsonSerializerOptions ov)
-    {
-        var voName = Make.Held(e.Vo).Name;
-        string? Named(Exception x) => x is JsonException && x.Message.Contains(voName) && x.InnerException is null ? null
-            : $"read {input}: the value object's refusal is {Jx.Ex(x)}{(x.InnerException is null ? "" : " with an inner exception")}, not a JsonException naming {voName}\n  text={Jx.Cut(text)}";
-        var stored = c.Is("json.Converters", "StoredJsonConverterFactory");
-        if (!p.Refused && !v.Refused)
-        {
-            if (e.Kind.StartsWith("validated") && input == "refused-by-create" && !stored && e.Refused() is not null && text != Jx.Ser(hp, op).Json && !c.Is("shape.position", "dictionary-key"))
-                return $"read {input}: the validated value object read what Create refuses\n  text={Jx.Cut(text)}";
-            if (p.Value != v.Value) return $"read {input}: read back differs: wrapped {Jx.Cut(p.Value)} vs value object {Jx.Cut(v.Value)}\n  text={Jx.Cut(text)}";
-            c.Note(NoteKeys.Compared, "read " + input); return null;
-        }
-        if (p.Refused && v.Refused)
-        {
-            if (v.Operation != "read") return $"read {input}: both refuse, not alike: the wrapped type {p}, the value object {v}";
-            if (Named(v.Thrown!) is { } f) return f + $"; the wrapped type: {p}";
-            c.Note(NoteKeys.Compared, "read " + input + ": both refuse, the value object naming itself"); return null;
-        }
-        if (v.Refused)
-        {
-            var intended = v.Operation == "read" && ((input == "null" && e.Vo.IsValueType) || (e.Kind.StartsWith("validated") && input == "refused-by-create" && !stored) || (e.Kind == "closed-set" && input != "valid"));
-            if (!intended) return $"read {input}: the wrapped type read it, the value object refused: {v} {Jx.Ex(v.Thrown!)}\n  text={Jx.Cut(text)}";
-            if (Named(v.Thrown!) is { } f) return f;
-            c.Note(NoteKeys.Compared, "read " + input + ": refused as documented"); return null;
-        }
-        // the wrapped type refused and the value object read: only a JSON null for a sealed record, which reads it as any class does
-        if (input == "null" && Make.AdmitsNull(e.Vo) && !Make.AdmitsNull(e.Plain) && Jx.De(text, hv.Declared, ov).Value is { } read
-            && Jx.Tokens(JsonSerializer.Serialize(read, hv.Declared, Jx.Plain)).Any(t => t.Type == JsonTokenType.Null))
-        { c.Note(NoteKeys.Compared, "read null: the sealed record reads null, as any class does"); return null; }
-        return $"read {input}: the value object read what the wrapped type refused ({p})\n  text={Jx.Cut(text)}";
-    }
-}
diff --git a/tools/probe/corpus/harness/Registry.cs b/tools/probe/corpus/harness/Registry.cs
deleted file mode 100644
index abe2a1d8..00000000
--- a/tools/probe/corpus/harness/Registry.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Hand half of the shape registry (see gen_shapes.py). Looks an entry up by the row's shape.kind and shape.wrapped.
-namespace Probes.Shapes;
-public static partial class Registry
-{
-    public static readonly List<Entry> All = Build();
-    static List<Entry> Build() { var e = new List<Entry>(); Fill(e); return e; }
-    static partial void Fill(List<Entry> e);
-    /// <summary>The entry a row names. record-class (CMTK1006) and over-value-object (CMTK1005) are refused at build, verified; the row's other axes are
-    /// still probed on the nearest buildable kind.</summary>
-    public static Entry Of(Row r)
-    {
-        var k = r["shape.kind"];
-        if (k is "record-class" or "over-value-object") { k = k == "record-class" ? "sealed-record-class" : "record-struct"; r.Substituted("shape.kind", k, "the generators refuse the requested kind"); }
-        var e = Get(k, r["shape.wrapped"]);
-        if (r.Is("http.nullability", "nullable"))
-        {
-            // The parameter or body declared nullable on both sides (T? against wrapped?): the dimension G1 exposed.
-            static Type N(Type t) => t.IsValueType && Nullable.GetUnderlyingType(t) is null ? typeof(Nullable<>).MakeGenericType(t) : t;
-            r.Note(NoteKeys.BindingNullable);
-            e = e with { Vo = N(e.Vo), Plain = N(e.Plain) };
-        }
-        return e;
-    }
-    public static Entry Get(string kind, string wrapped) =>
-        kind == "closed-set" ? All.First(x => x.Kind == "closed-set")
-        : All.First(x => x.Kind == kind && x.Wrapped == wrapped);
-}
diff --git a/tools/probe/corpus/harness/ReplayProbe.cs b/tools/probe/corpus/harness/ReplayProbe.cs
deleted file mode 100644
index 07249dad..00000000
--- a/tools/probe/corpus/harness/ReplayProbe.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Debug aid (not a claim): PROBE_REPLAY="rowsfile:idx" re-runs the baseline for one row and writes its exchange log to /tmp/replay.txt.
-using Probes.Shapes;
-namespace Probes;
-public sealed class ReplayProbe
-{
-    [Fact]
-    public async Task Replay()
-    {
-        var spec = Environment.GetEnvironmentVariable("PROBE_REPLAY"); if (spec is null) return;
-        var parts = spec.Split(':'); var r = Rows.Get(parts[0], int.Parse(parts[1]));
-        var f = await HttpBaseline.Run(r, Registry.Of(r));
-        File.WriteAllText("/tmp/replay.txt", r.ToString() + "\nRESULT: " + (f ?? "pass") + "\nNOTES: " + r.Notes + "\n" + r.Log);
-    }
-}
diff --git a/tools/probe/corpus/harness/Row.cs b/tools/probe/corpus/harness/Row.cs
deleted file mode 100644
index 79703c65..00000000
--- a/tools/probe/corpus/harness/Row.cs
+++ /dev/null
@@ -1,592 +0,0 @@
-// Row plumbing shared by every probe: each probe's rows are its own file, written by `prober rows --probe P` (the corpus's
-// rows/P.json.gz, unpacked by the replay to Probes/rows/P.json); each probe records one line per row to $PROBE_OUT/<label>.jsonl
-// (idx, category, applied settings, reasons, findings, note, and the checks the row ran), which the replay reads.
-using System.Text.Json;
-using System.Text.Json.Nodes;
-using System.Text.RegularExpressions;
-namespace Probes.Shapes;
-
-/// <summary>
-/// What a row actually did, shared by the row and every copy made of it (With, Fresh): the axes the harness
-/// read, the settings it substituted, how the row ended, the open findings it stepped around, and the checks it
-/// ran (<see cref="Row.Check(string, Baseline?, Func{Check, string?})"/>), each with evidence of its own. The ledger
-/// credits only the axes read, at the value that applied, and only for a check that ended as a pass.
-/// </summary>
-public sealed class Evidence
-{
-    public readonly HashSet<string> Read = new();
-    public readonly Dictionary<string, string> Applied = new();
-    public readonly SortedSet<string> Findings = new(StringComparer.Ordinal);
-    /// <summary>How the row ended: the highest of its own outcomes and its checks'.</summary>
-    public string Category = "pass";
-    /// <summary>How the row ended outside any check: its own notes, a failure it returned, an exception it threw.</summary>
-    public string Own = "pass";
-    public readonly List<string> Reasons = new();
-    /// <summary>The checks the row ran, in the order they ended.</summary>
-    public readonly List<Check> Checks = new();
-    static readonly string[] Order = ["pass", "inapplicable", "expected-refusal", "inconclusive", "known-finding", "harness-error", "violation"];
-    public static int Rank(string category) =>
-        Array.IndexOf(Order, category) is var i and >= 0 ? i : throw new ArgumentException("no outcome category " + category, nameof(category));
-    public void Raise(string category, string reason)
-    {
-        if (Rank(category) > Rank(Own)) Own = category;
-        Lift(category);
-        Reasons.Add(category + ":" + reason);
-    }
-    /// <summary>Raises the row's category to a check's, without a reason of the row's own: the check keeps its reasons.</summary>
-    public void Lift(string category)
-    {
-        if (Rank(category) > Rank(Category)) Category = category;
-    }
-}
-
-public sealed class Row
-{
-    readonly Dictionary<string, string> d;
-    public Evidence Ev { get; }
-    public int Index { get; }
-    /// <summary>The claim whose rows file holds the row, whose declarations <see cref="Check(string, Baseline?, Func{Check, string?})"/> applies; null for a row in hand.</summary>
-    public string? Claim { get; }
-    public Row(int index, Dictionary<string, string> d, string? claim = null) : this(index, d, new Evidence(), claim) { }
-    Row(int index, Dictionary<string, string> d, Evidence ev, string? claim) { Index = index; this.d = d; Ev = ev; Claim = claim; }
-    public string this[string axis] => d.TryGetValue(axis, out var v) ? Mark(axis, v) : throw new KeyNotFoundException($"row has no axis {axis}");
-    public string? Get(string axis) => d.TryGetValue(axis, out var v) ? Mark(axis, v) : null;
-    public bool Is(string axis, string value) => d.TryGetValue(axis, out var v) && Mark(axis, v) == value;
-    /// <summary>Every axis, each marked read: a caller that enumerates is applying them (the JSON options builder).</summary>
-    public IEnumerable<KeyValuePair<string, string>> All { get { foreach (var kv in d) { Mark(kv.Key, kv.Value); yield return kv; } } }
-    /// <summary>
-    /// Marks an axis read: for the check of this row that is running, if one is (a helper handed the row inside a
-    /// check's body reads for that check), else for the row, whose reads every check of it ran under.
-    /// </summary>
-    string Mark(string axis, string v)
-    {
-        if (Scope.Running(Ev) is { } c) c.MarkRead(axis);
-        else lock (Ev) Ev.Read.Add(axis);
-        return v;
-    }
-    /// <summary>The value the row holds for an axis, without marking it read: a check marks its own.</summary>
-    internal string? Raw(string axis) => d.TryGetValue(axis, out var v) ? v : null;
-    /// <summary>Every axis and its value, none marked read: what a fact's fixture is matched against (Sides.Settings), whose covering answer then reads its own.</summary>
-    internal IReadOnlyDictionary<string, string> Values => d;
-    /// <summary>The setting ran as <paramref name="actual"/>, not as the row asked: only the actual value earns credit.</summary>
-    public void Substituted(string axis, string actual, string reason)
-    {
-        if (Scope.Running(Ev) is { } c) { c.Substituted(axis, actual, reason); return; }
-        lock (Ev) Ev.Applied[axis] = actual;
-        Note(NoteKeys.Substituted, $"{axis}={actual}, {reason}");
-    }
-    public void Outcome(string category, string reason)
-    {
-        if (Scope.Running(Ev) is { } c) c.Outcome(category, reason);
-        else lock (Ev) Ev.Raise(category, reason);
-    }
-    /// <summary>The settings that ran: the axes the harness read outside any check, at the value that applied.</summary>
-    public Dictionary<string, string> AppliedSettings()
-    {
-        lock (Ev) return Ev.Read.Where(d.ContainsKey).ToDictionary(a => a, a => Ev.Applied.TryGetValue(a, out var v) ? v : d[a]);
-    }
-    public string Notes { get; private set; } = "";
-    /// <summary>
-    /// Records what a check saw, by a key of <see cref="NoteKeys"/>; the key alone decides the outcome, the
-    /// detail only explains it. Inside a check's body the note is the check's.
-    /// </summary>
-    public void Note(NoteKeys key, string? detail = null)
-    {
-        if (Scope.Running(Ev) is { } c) { c.Noted(key, detail); return; }
-        var n = detail is null ? key.Key : $"{key.Key}({detail})";
-        if (!Notes.Split(';').Contains(n)) Notes += (Notes.Length == 0 ? "" : ";") + n;
-        if (key.Outcome != "pass") Outcome(key.Outcome, n);
-    }
-    /// <summary>
-    /// Steps around an open finding: the row (or, inside a check's body, the check) ends as known-finding and earns
-    /// nothing. The replay fails a probe that skips for a finding the ledger has fixed or dismissed, and the release
-    /// gate refuses while any skips.
-    /// </summary>
-    public void Skip(string finding, string why)
-    {
-        lock (Ev) Ev.Findings.Add(finding);
-        Outcome("known-finding", $"{finding}: {why}");
-    }
-    public System.Text.StringBuilder Log { get; } = new();
-    public Row Fresh() => new Row(Index, new Dictionary<string, string>(d), Ev, Claim);
-    public Row With(string axis, string value) { var c = new Dictionary<string, string>(d) { [axis] = value }; return new Row(Index, c, Ev, Claim); }
-    public override string ToString() => string.Join(" ", d.Where(kv => kv.Value != "default").OrderBy(kv => kv.Key).Select(kv => $"{kv.Key}={kv.Value}"));
-
-    /// <summary>The check running in this flow, so a Row whose method is named Check reaches the type's flow by another name.</summary>
-    static class Scope
-    {
-        public static Check? Running(Evidence ev) => Probes.Shapes.Check.Running(ev);
-        public static Check? Enter(Check c) => Probes.Shapes.Check.Enter(c);
-        public static void Leave(Check? outer) => Probes.Shapes.Check.Leave(outer);
-    }
-
-    /// <summary>
-    /// Runs one check of the row: one obligation of the claim, compared against one <paramref name="baseline"/>, with
-    /// reads, substitutions, notes and an outcome of its own. A failure the body returns is a violation; an exception
-    /// is a harness error, recorded and not rethrown, so the row's other checks still run (and null is returned, so
-    /// no exception ever reads as a violation); otherwise the highest of its notes, else a pass, and a pass with no
-    /// baseline is the harness error <c>pass-without-baseline</c>: a pass is a comparison that ran. The row's category
-    /// is raised to the check's. Returns the failure, so a probe may stop the row at its first violation or run every
-    /// check. A body that only returns null or throws names its form, <c>_ => (string?)null</c>, or the two overloads are ambiguous.
-    /// Before the body, the claim's declarations of where the obligation does not apply are read (claims.json, staged
-    /// beside the rows): where one matches the row's values, the check is inapplicable with the declaration's citation
-    /// and the body does not run.
-    /// </summary>
-    public async Task<string?> Check(string obligation, Baseline? baseline, Func<Check, Task<string?>> body)
-    {
-        var c = new Check(this, obligation, baseline);
-        var outer = Scope.Enter(c);
-        string? fail = null; Exception? thrown = null;
-        try { if (!Declared(c)) fail = await body(c); }
-        catch (Exception ex) { thrown = ex; }
-        finally { Scope.Leave(outer); }
-        return Close(c, fail, thrown);
-    }
-
-    /// <summary>The synchronous form of <see cref="Check(string, Baseline?, Func{Check, Task{string?}})"/>.</summary>
-    public string? Check(string obligation, Baseline? baseline, Func<Check, string?> body)
-    {
-        var c = new Check(this, obligation, baseline);
-        var outer = Scope.Enter(c);
-        string? fail = null; Exception? thrown = null;
-        try { if (!Declared(c)) fail = body(c); }
-        catch (Exception ex) { thrown = ex; }
-        finally { Scope.Leave(outer); }
-        return Close(c, fail, thrown);
-    }
-
-    /// <summary>
-    /// Applies the first declaration of the check's obligation whose every axis the row holds at a value it lists: the
-    /// check is inapplicable with the declaration's citation, those axes read for it. True when one matched.
-    /// </summary>
-    bool Declared(Check c)
-    {
-        foreach (var (axes, cite) in Rows.Declarations(Claim, c.Obligation))
-            if (axes.All(kv => d.TryGetValue(kv.Key, out var v) && kv.Value.Contains(v)))
-            {
-                c.Declared(cite, string.Join(" ", axes.Keys.Order(StringComparer.Ordinal).Select(a => $"{a}={c[a]}")));
-                return true;
-            }
-        return false;
-    }
-
-    string? Close(Check c, string? fail, Exception? thrown)
-    {
-        if (thrown is not null) c.Outcome("harness-error", "UNEXPECTED " + thrown.GetType().Name + ": " + thrown.Message);
-        else if (fail is not null) { c.Failure = fail; c.Outcome("violation", fail); }
-        if (c.Category == "pass" && c.Against is null) c.Outcome("harness-error", "pass-without-baseline");
-        lock (Ev) { Ev.Checks.Add(c); Ev.Lift(c.Category); }
-        return thrown is null ? fail : null;
-    }
-}
-
-/// <summary>
-/// One check of a row (<see cref="Row.Check(string, Baseline?, Func{Check, string?})"/>): the obligation it checks, the
-/// baseline it compares against, the axes it read at the value that applied, its notes and how it ended. Its evidence
-/// is its own; the row's reads, made outside any check, are what every check of the row ran under.
-/// </summary>
-public sealed class Check
-{
-    static readonly AsyncLocal<Check?> Current = new();
-    static readonly Regex Id = new("^[a-z0-9][a-z0-9-]*$");
-    readonly Row row;
-    internal Check(Row row, string obligation, Baseline? against)
-    {
-        this.row = row; Obligation = obligation; Against = against;
-        // An obligation is an id of the claim's obligations (claims.json), or "claim"; anything else is the harness's mistake.
-        if (!Id.IsMatch(obligation ?? "")) Outcome("harness-error", $"obligation-not-an-id({obligation})");
-    }
-    /// <summary>The claim's obligation this check checks, as claims.json names it, or <c>claim</c> for a claim without obligations.</summary>
-    public string Obligation { get; }
-    /// <summary>What the check compared against; null where it compared nothing, which no pass may be.</summary>
-    public Baseline? Against { get; }
-    /// <summary>The evidence of this check alone: its reads, substitutions, reasons and category.</summary>
-    public Evidence Ev { get; } = new();
-    public string Category { get { lock (Ev) return Ev.Category; } }
-    /// <summary>The failure the body returned, if it returned one.</summary>
-    public string? Failure { get; internal set; }
-    public string Notes { get; private set; } = "";
-
-    internal static Check? Running(Evidence rowEvidence) => Current.Value is { } c && ReferenceEquals(c.row.Ev, rowEvidence) ? c : null;
-    internal static Check? Enter(Check c) { var outer = Current.Value; Current.Value = c; return outer; }
-    internal static void Leave(Check? outer) => Current.Value = outer;
-
-    public string this[string axis] => row.Raw(axis) is { } v ? Mark(axis, v) : throw new KeyNotFoundException($"row has no axis {axis}");
-    public string? Get(string axis) => row.Raw(axis) is { } v ? Mark(axis, v) : null;
-    public bool Is(string axis, string value) => row.Raw(axis) is { } v && Mark(axis, v) == value;
-    string Mark(string axis, string v) { MarkRead(axis); return v; }
-    internal void MarkRead(string axis) { lock (Ev) Ev.Read.Add(axis); }
-    /// <summary>The setting ran as <paramref name="actual"/> for this check, not as the row asked: only the actual value earns credit.</summary>
-    public void Substituted(string axis, string actual, string reason)
-    {
-        lock (Ev) Ev.Applied[axis] = actual;
-        Note(NoteKeys.Substituted, $"{axis}={actual}, {reason}");
-    }
-    /// <summary>How the check was compared, by a key of <see cref="NoteKeys"/>; a key of another outcome raises the check's.</summary>
-    public void Note(NoteKeys key, string? detail = null) => Noted(key, detail);
-    /// <summary>A note the row routes here from inside the check's body; its key is a member, written out where the row's note was made.</summary>
-    internal void Noted(NoteKeys key, string? detail)
-    {
-        var n = detail is null ? key.Key : $"{key.Key}({detail})";
-        Remember(n);
-        if (key.Outcome != "pass") Outcome(key.Outcome, n);
-    }
-    /// <summary>The check does not apply to this row, for the reason <paramref name="cite"/> names; returns null, no failure.</summary>
-    public string? Inapplicable(Cite cite, string? detail = null) => Cited("inapplicable", cite, detail);
-    /// <summary>The check met the refusal <paramref name="cite"/> says is intended; returns null, no failure.</summary>
-    public string? Refused(Cite cite, string? detail = null) => Cited("expected-refusal", cite, detail);
-    /// <summary>The check does not apply where its claim declares so (claims.json): the declaration's cite, read from the file, not a literal.</summary>
-    internal void Declared(Cite cite, string settings) => Cited("inapplicable", cite, "declared " + settings);
-    /// <summary>The check could not tell; returns null, no failure.</summary>
-    public string? Inconclusive(string reason) { Outcome("inconclusive", reason); return null; }
-    public System.Text.StringBuilder Log => row.Log;
-
-    string? Cited(string category, Cite cite, string? detail)
-    {
-        var n = detail is null ? cite.Spelling : $"{cite.Spelling}({detail})";
-        Remember(n);
-        Outcome(category, n);
-        return null;
-    }
-    void Remember(string n) { lock (Ev) if (!Notes.Split(';').Contains(n)) Notes += (Notes.Length == 0 ? "" : ";") + n; }
-    internal void Outcome(string category, string reason) { lock (Ev) Ev.Raise(category, reason); }
-
-    /// <summary>The axes this check read, at the value that applied: its own substitution, else the row's, else the row's value.</summary>
-    public Dictionary<string, string> AppliedSettings()
-    {
-        Dictionary<string, string> rowApplied;
-        lock (row.Ev) rowApplied = new(row.Ev.Applied);
-        lock (Ev)
-            return Ev.Read.Where(a => row.Raw(a) is not null)
-                     .ToDictionary(a => a, a => Ev.Applied.TryGetValue(a, out var v) ? v : rowApplied.TryGetValue(a, out var w) ? w : row.Raw(a)!);
-    }
-}
-
-/// <summary>
-/// What a check compared the value object against: a closed catalogue, as <see cref="NoteKeys"/> is, each member
-/// spelled as the evidence line carries it. There is no text baseline: a check that matched a message names the
-/// refusal, the fact or the sentence of the docs it held the message to, or it compared nothing.
-/// </summary>
-public sealed class Baseline
-{
-    /// <summary>The baseline as a check's evidence spells it.</summary>
-    public string Spelling { get; }
-    Baseline(string spelling) { Spelling = spelling; }
-    public override string ToString() => Spelling;
-
-    /// <summary>The wrapped twin in the same place, with TypeKit.</summary>
-    public static readonly Baseline Twin = new("twin");
-    /// <summary>The wrapped twin without TypeKit.</summary>
-    public static readonly Baseline Framework = new("framework");
-    /// <summary>The input itself, read back.</summary>
-    public static readonly Baseline RoundTrip = new("round-trip");
-    /// <summary>An in-memory model of the same operations.</summary>
-    public static readonly Baseline Model = new("model");
-    /// <summary>The documented refusal: its type, the name it gives, no inner exception, no quoted input.</summary>
-    public static readonly Baseline Refusal = new("refusal");
-    /// <summary>The wrapped type's path in the same process.</summary>
-    public static readonly Baseline Cost = new("cost");
-    /// <summary>A pinned fact's fixture, by its id under design/knowledge/ (<c>KB-031</c>).</summary>
-    public static Baseline Fact(string id) => new("fact:" + Cite.FactForm(id));
-    /// <summary>A sentence of the docs, by <c>file#anchor</c>, where the wrapped type's side cannot answer.</summary>
-    public static Baseline Docs(string source) => new("docs:" + Cite.DocsForm(source));
-}
-
-/// <summary>
-/// Why a check did not apply or met an intended refusal: a claim's not-promised entry, a section of the docs, a
-/// pinned fact or a decision record. Each factory checks the form of what it is given; that it exists is held by
-/// `prober register` and `publish` and by the conventions tests, which also require a string literal.
-/// </summary>
-public sealed class Cite
-{
-    static readonly Regex Id = new("^[a-z0-9][a-z0-9-]*$");
-    static readonly Regex Source = new(@"^(?!/)(?!.*(^|/)\.\.?(/|#|$))[A-Za-z0-9_./-]+\.[A-Za-z0-9]+(#[A-Za-z0-9][A-Za-z0-9._-]*)?$");
-    static readonly Regex FactId = new(@"^KB-\d{3}$");
-    static readonly Regex RecordId = new(@"^\d{4}$");
-    /// <summary>The citation as a reason spells it: <c>not-promised:id</c>, <c>docs:file#anchor</c>, <c>fact:KB-031</c>, <c>record:0094</c>.</summary>
-    public string Spelling { get; }
-    Cite(string spelling) { Spelling = spelling; }
-    public override string ToString() => Spelling;
-
-    /// <summary>An id of the claim's <c>not-promised</c> list.</summary>
-    public static Cite NotPromised(string id) => new("not-promised:" + Form(id, Id, "a not-promised id", "closed-set-has-no-text"));
-    /// <summary>A section of the docs, as a not-promised entry's <c>source</c> spells it: <c>file#anchor</c>, the file from the repository root.</summary>
-    public static Cite Docs(string source) => new("docs:" + DocsForm(source));
-    /// <summary>A knowledge entry under design/knowledge/.</summary>
-    public static Cite Fact(string id) => new("fact:" + FactForm(id));
-    /// <summary>A decision record under design/adr/.</summary>
-    public static Cite Record(string id) => new("record:" + Form(id, RecordId, "a decision record's number", "0094"));
-
-    /// <summary>A citation as claims.json spells it (<c>not-promised:id</c>, <c>docs:file#anchor</c>, <c>fact:KB-031</c>, <c>record:0094</c>), by its factory.</summary>
-    internal static Cite Parse(string spelling)
-    {
-        var at = spelling.IndexOf(':');
-        var value = at < 0 ? "" : spelling[(at + 1)..];
-        return (at < 0 ? "" : spelling[..at]) switch
-        {
-            "not-promised" => NotPromised(value), "docs" => Docs(value), "fact" => Fact(value), "record" => Record(value),
-            _ => throw new ArgumentException($"a citation is not-promised:id, docs:file#anchor, fact:KB-NNN or record:NNNN, not '{spelling}'", nameof(spelling)),
-        };
-    }
-
-    internal static string DocsForm(string source) => Form(source, Source, "a docs source", "docs/json.md#decimals-in-one-spelling");
-    internal static string FactForm(string id) => Form(id, FactId, "a knowledge entry's id", "KB-031");
-    static string Form(string value, Regex form, string what, string example) =>
-        value is not null && form.IsMatch(value) ? value : throw new ArgumentException($"{what} is spelled like {example}, not '{value}'", nameof(value));
-}
-
-/// <summary>
-/// Every note a check may make, by exact key, and the outcome it stands for: the catalogue, and each of its
-/// members one key. A check writes <c>r.Note(NoteKeys.Compared, detail)</c>; the constructor is private, so a
-/// key outside the catalogue, a misspelled one or one built from text does not compile (decision 103). "pass"
-/// keys only explain how a check that ran was compared. A check that did not apply, ended in a refusal or could
-/// not tell says so through its scope, citing what makes it so (<c>c.Inapplicable(Cite…)</c>, <c>c.Refused(Cite…)</c>,
-/// <c>c.Inconclusive(reason)</c>); the one other key is <see cref="FrameworkRefuses"/>, the three-sided
-/// differential's expected refusal, against side (1)'s baseline. The outcome keys of the notes those replaced
-/// were removed once no harness or probe source called them (WS2's close).
-/// </summary>
-public sealed class NoteKeys
-{
-    const string Pass = "pass", ExpectedRefusal = "expected-refusal";
-    /// <summary>The key as a row's notes and reasons spell it.</summary>
-    public string Key { get; }
-    /// <summary>The outcome a note with this key stands for; a note never makes a violation or a harness error.</summary>
-    public string Outcome { get; }
-    NoteKeys(string key, string outcome) { Key = key; Outcome = outcome; }
-    public override string ToString() => Key;
-
-    // how a check that ran was compared
-    public static readonly NoteKeys Compared = new("compared", Pass);
-    public static readonly NoteKeys Substituted = new("substituted", Pass);
-    public static readonly NoteKeys Dropped = new("dropped", Pass);
-    public static readonly NoteKeys CtxStrict = new("ctx-strict", Pass);
-    public static readonly NoteKeys CtxFallback = new("ctx-fallback", Pass);   // not called since the one ProbeContext lists every shape (shapes.cs): no fallback under the context
-    public static readonly NoteKeys BindingNullable = new("binding:nullable", Pass);
-    public static readonly NoteKeys OwnVo = new("own-vo", Pass);
-    public static readonly NoteKeys ConverterWrapsInner = new("converter-wraps-inner", Pass);
-    public static readonly NoteKeys DocumentedCharGuidKeyNeverGeneratedChecked = new("documented-char-guid-key-never-generated-checked", Pass);
-    public static readonly NoteKeys DocumentedCharGuidNotGeneratedChecked = new("documented-char-guid-not-generated-checked", Pass);
-    public static readonly NoteKeys SchemaComparedWithNullableWrapped = new("schema:compared-with-nullable-wrapped", Pass);   // not called since the twin is at the value object's nullability (shapes.cs)
-    public static readonly NoteKeys SchemaNullableSpellingsNormalised = new("schema:nullable-spellings-normalised", Pass);
-    public static readonly NoteKeys SchemaClassVoNullabilityNormalised = new("schema:class-vo-nullability-normalised", Pass);
-    public static readonly NoteKeys SchemaNeitherSideDocumented = new("schema:neither-side-documented", Pass);
-    // a nullable value object that is a component is null around its reference, the wrapped type null inside its schema (decision 36)
-    public static readonly NoteKeys SchemaNullAroundReferenceNormalised = new("schema:null-around-reference-normalised", Pass);
-    // EF: the claim's check ran, against the documented expectation where the wrapped type's own side cannot answer
-    public static readonly NoteKeys RefusalNamesTheType = new("refusal-names-the-type", Pass);
-    public static readonly NoteKeys StoredFactoryReadUnvalidated = new("stored-factory-read-unvalidated", Pass);
-    public static readonly NoteKeys DocumentedCharGuidDefaultGenerationNormalized = new("documented-char-guid-default-generation-normalized", Pass);
-    public static readonly NoteKeys PlainKeyThrowsOnSqliteVoCheckedAgainstExpected = new("plain-key-throws-on-sqlite-vo-checked-against-expected", Pass);
-    public static readonly NoteKeys TpcSqliteNoSequenceAssignChecked = new("tpc-sqlite-no-sequence-assign-checked", Pass);
-    // the document part has nothing to check: ASP.NET alone refuses the same document in the same row, or
-    // leaves the controller out of it (docs/aspnet-core.md, "Bind value objects in MVC"), checked absent
-    public static readonly NoteKeys DocRefusedByAspnetAlone = new("doc:refused-by-aspnet-alone", Pass);
-    public static readonly NoteKeys DocControllerNotInApiExplorer = new("doc:controller-not-in-api-explorer", Pass);
-    // L03's JSON half has nothing to compare: the wrapped type alone refuses under the row's options, the value object alike, in the same row
-    public static readonly NoteKeys JsonHalfWrappedAloneRefuses = new("json-half:wrapped-alone-refuses", Pass);   // not called since the three-sided differential (Sides): framework-refuses
-    // JSON family (C01, C10, L06): the options leave the member out of one direction for the plain type without TypeKit too, shown by a
-    // baseline in the same row; that direction has nothing to check, and the row is judged by the other one (both left out: each direction inconclusive)
-    public static readonly NoteKeys JsonMemberLeftOutByOptions = new("json:member-left-out-by-options", Pass);
-    // a read the wrapped type's shape refuses with the very same exception and message: the serializer refused the document before any
-    // value object ran (the baseline in the same row), so the read has nothing to check; the row is judged by its write and other reads
-    public static readonly NoteKeys JsonReadRefusedByStjAlone = new("json:read-refused-by-stj-alone", Pass);   // not called since the three-sided differential (Sides): framework-refuses
-    // ASP.NET's OpenAPI 2.0 writer drops the reference of a nullable struct component; a plain struct beside it in the same
-    // schema, without a converter, is written the same, so that position has nothing to check (C12)
-    public static readonly NoteKeys SchemaNullableReferenceLostForPlainToo = new("schema:nullable-reference-lost-for-plain-too", Pass);
-    // the three-sided differential (Sides): the wrapped twin without TypeKit and the value object refuse alike, at the same operation and
-    // stage with the same exception type and status, so the framework refuses; no message is compared
-    public static readonly NoteKeys FrameworkRefuses = new("framework-refuses", ExpectedRefusal);
-}
-
-public static class Rows
-{
-    public static string Root() => TryRoot() ?? throw new DirectoryNotFoundException("no CodoMetis.TypeKit.Samples.csproj above " + AppContext.BaseDirectory);
-    static string? TryRoot()
-    {
-        var dir = new DirectoryInfo(AppContext.BaseDirectory);
-        while (dir is not null && !File.Exists(Path.Combine(dir.FullName, "CodoMetis.TypeKit.Samples.csproj"))) dir = dir.Parent;
-        return dir?.FullName;
-    }
-
-    /// <summary>
-    /// The claims the replay stages beside the rows (Probes/claims.json); where none is staged, as for a probe the prober's
-    /// own tests run in-process, no claim declares anything. The prober's tests point it at a file of their own.
-    /// </summary>
-    internal static string? ClaimsFile { get; set; } = TryRoot() is { } root ? Path.Combine(root, "Probes", "claims.json") : null;
-    static readonly Dictionary<string, Dictionary<string, JsonObject>> Claims = new();
-
-    /// <summary>A claim as the staged claims.json holds it, or null where the file or the claim is not there.</summary>
-    public static JsonObject? Claim(string id)
-    {
-        if (ClaimsFile is not { } path) return null;
-        lock (Claims)
-        {
-            if (!Claims.TryGetValue(path, out var claims))
-                Claims[path] = claims = !File.Exists(path) ? new()
-                    : JsonNode.Parse(File.ReadAllText(path))!.AsArray().OfType<JsonObject>().ToDictionary(c => c["id"]!.GetValue<string>());
-            return claims.GetValueOrDefault(id);
-        }
-    }
-
-    /// <summary>The declarations of where <paramref name="obligation"/> of <paramref name="claim"/> does not apply: each its axis values and its citation.</summary>
-    public static IEnumerable<(Dictionary<string, string[]> Axes, Cite Cite)> Declarations(string? claim, string obligation)
-    {
-        var o = (claim is null ? null : Claim(claim))?["obligations"]?.AsArray().OfType<JsonObject>().FirstOrDefault(x => x["id"]?.GetValue<string>() == obligation);
-        foreach (var declared in (o?["inapplicable"]?.AsArray() ?? []).OfType<JsonObject>())
-            yield return (declared["axes"]!.AsObject().ToDictionary(kv => kv.Key, kv => kv.Value!.AsArray().Select(v => v!.GetValue<string>()).ToArray()),
-                          Cite.Parse(declared["cite"]!.GetValue<string>()));
-    }
-    /// <summary>The rows of one probe, from its own file (rows/<paramref name="probe"/>.json); a sibling probe of the claim reads its own.</summary>
-    public static IEnumerable<Row> Load(string probe)
-    {
-        var path = Path.Combine(Root(), "Probes", "rows", probe + ".json");
-        if (!File.Exists(path)) throw new FileNotFoundException($"no rows file for the probe {probe}: {path}", path);
-        return Read(path);
-    }
-    /// <summary>The rows of a rows file, each holding the file's claim, whose declarations its checks apply.</summary>
-    internal static IEnumerable<Row> Read(string path)
-    {
-        var doc = JsonNode.Parse(File.ReadAllText(path))!;
-        var claim = doc["claim"]?.GetValue<string>();
-        var i = 0;
-        foreach (var r in doc["rows"]!.AsArray())
-            yield return new Row(i++, r!["row"]!.AsObject().ToDictionary(kv => kv.Key, kv => kv.Value!.GetValue<string>()), claim);
-    }
-    /// <summary>
-    /// xunit MemberData: (probe, index), the probe naming its rows file, labelled with the row's settings so a test list or a
-    /// failure names them. Optional filter by env PROBE_ROWS="0-20" for quick runs.
-    /// </summary>
-    public static TheoryData<string, int> Data(string probe)
-    {
-        var d = new TheoryData<string, int>();
-        var range = Environment.GetEnvironmentVariable("PROBE_ROWS");
-        (int lo, int hi) = range is null ? (0, int.MaxValue) : (int.Parse(range.Split('-')[0]), int.Parse(range.Split('-')[1]));
-        var only = Environment.GetEnvironmentVariable("PROBE_ONLY"); // "axis=value" keeps rows with that value
-        foreach (var r in Load(probe))
-            if (r.Index >= lo && r.Index <= hi && (only is null || only.Split(',').All(c => c.Contains("!=") ? !r.Is(c.Split("!=")[0], c.Split("!=")[1]) : r.Is(c.Split('=')[0], c.Split('=')[1]))))
-                d.Add(new TheoryDataRow<string, int>(probe, r.Index) { Label = $"#{r.Index} {r}" });
-        return d;
-    }
-    static readonly Dictionary<string, List<Row>> Cache = new();
-    public static Row Get(string probe, int index)
-    {
-        lock (Cache) { if (!Cache.TryGetValue(probe, out var l)) Cache[probe] = l = Load(probe).ToList(); return l[index]; }
-    }
-}
-
-public static class Rec
-{
-    static readonly object Gate = new();
-    /// <summary>
-    /// One line per row to $PROBE_OUT/label.jsonl: how it ended and the settings that ran, and for a row that ran
-    /// checks, each check's obligation, baseline, outcome, settings, reasons and notes. <paramref name="passed"/> is
-    /// the row's test result where its category alone does not say it (a row with a passing check and another that
-    /// did not apply passes).
-    /// </summary>
-    public static void Write(string label, int idx, string category, string note, Row? row = null, bool? passed = null)
-    {
-        var dir = Environment.GetEnvironmentVariable("PROBE_OUT") ?? "/tmp/probe-out";
-        Directory.CreateDirectory(dir);
-        var applied = row?.AppliedSettings() ?? new Dictionary<string, string>();
-        var reasons = row is null ? [] : row.Ev.Reasons.ToArray();
-        var findings = row is null ? [] : row.Ev.Findings.ToArray();
-        var status = passed ?? category == "pass" ? "pass" : "fail";
-        note = note.Length > 600 ? note[..600] : note;
-        var checks = row is null ? [] : Checks(row);
-        var line = checks.Count == 0
-            ? JsonSerializer.Serialize(new { idx, status, category, completed = row is not null, applied, reasons, findings, note })
-            : JsonSerializer.Serialize(new
-            {
-                idx, status, category, completed = row is not null, applied, reasons, findings, note,
-                checks = checks.Select(c => new
-                {
-                    obligation = c.Obligation, baseline = c.Against?.Spelling, category = c.Category, applied = c.AppliedSettings(),
-                    reasons = Reasons(c), notes = c.Notes,
-                }),
-            });
-        lock (Gate) File.AppendAllText(Path.Combine(dir, label + ".jsonl"), line + "\n");
-    }
-
-    static List<Check> Checks(Row row) { lock (row.Ev) return [.. row.Ev.Checks]; }
-    static string[] Reasons(Check c) { lock (c.Ev) return [.. c.Ev.Reasons]; }
-
-    /// <summary>
-    /// Runs the check on a fresh copy of the row (its own evidence); null = no failure, otherwise the failure text.
-    /// An exception the check did not expect is a harness error until triaged, never a pass and never a
-    /// violation: the row fails the test with the exception named, and no seed counts it caught. A violation or a
-    /// harness error fails the test; any other outcome but a pass skips it with its reasons, so a test run
-    /// counts what earned nothing. A row that ran checks (<see cref="Row.Check(string, Baseline?, Func{Check, string?})"/>)
-    /// fails when the row itself or any check ended as a violation or a harness error, passes when at least one check
-    /// passed, and otherwise skips, listing each check's outcome. <paramref name="label"/> names the row in a failure and
-    /// its evidence file, and is the probe whose rows file holds the row unless <paramref name="rowsOf"/> names it: a
-    /// probe passes its theory's first argument, the probe's own name, as one or the other.
-    /// </summary>
-    public static Task Run(string label, int idx, Func<Row, Task<string?>> check, string? rowsOf = null) => Run(label, Rows.Get(rowsOf ?? label, idx), check);
-
-    /// <summary>The same for a row in hand, without a rows file: how the prober's tests run the harness.</summary>
-    public static async Task Run(string label, Row cached, Func<Row, Task<string?>> check)
-    {
-        var idx = cached.Index;
-        var row = new Row(cached.Index, cached.All.ToDictionary(kv => kv.Key, kv => kv.Value), cached.Claim);
-        string? fail = null, unexpected = null;
-        try { fail = await check(row); }
-        catch (Exception ex) { unexpected = "UNEXPECTED " + ex.GetType().Name + ": " + ex.Message; row.Outcome("harness-error", unexpected); }
-        var checks = Checks(row);
-        if (checks.Count == 0)
-        {
-            // An exception is the harness breaking, not the claim's check firing: a harness error and never a
-            // violation, so a seeded defect that only makes a check throw is no catch (decision 103).
-            if (fail is not null) row.Outcome("violation", fail);
-            Write(label, idx, row.Ev.Category, fail ?? unexpected ?? row.Notes, row);
-            if (fail is not null) Assert.Fail($"[{label} #{idx}] {row}\n{fail}");
-            if (row.Ev.Category == "harness-error") Assert.Fail($"[{label} #{idx}] {row}\nharness error: {string.Join("; ", row.Ev.Reasons)}");
-            if (row.Ev.Category != "pass") Assert.Skip($"{row.Ev.Category}: {string.Join("; ", row.Ev.Reasons.Where(x => !x.StartsWith("pass:")))}");
-            return;
-        }
-        // A failure the row returns from one of its checks is that check's violation, recorded there; any other is the row's own.
-        if (fail is not null && !checks.Any(c => c.Failure == fail)) row.Outcome("violation", fail);
-        var failing = checks.Where(c => c.Category is "violation" or "harness-error").ToList();
-        var own = row.Ev.Reasons.Where(x => !x.StartsWith("pass:")).ToList();
-        var ownFailed = row.Ev.Own is "violation" or "harness-error";
-        var passed = !ownFailed && failing.Count == 0 && checks.Any(c => c.Category == "pass");
-        Write(label, idx, row.Ev.Category, fail ?? unexpected ?? row.Notes, row, passed);
-        if (ownFailed || failing.Count > 0)
-            Assert.Fail($"[{label} #{idx}] {row}\n" + string.Join("\n", (ownFailed ? own : []).Concat(failing.Select(Shown))));
-        if (!passed) Assert.Skip(string.Join("; ", own.Concat(checks.Select(Shown))));
-    }
-
-    /// <summary>A check as a failure or a skip lists it: <c>smallest-scale inapplicable: not-promised:closed-set-has-no-scale</c>.</summary>
-    static string Shown(Check c)
-    {
-        var category = c.Category;
-        var reasons = Reasons(c).Where(x => !x.StartsWith("pass:")).Select(x => x.StartsWith(category + ":") ? x[(category.Length + 1)..] : x);
-        return $"{c.Obligation} {category}: {string.Join(", ", reasons)}";
-    }
-}
-
-public static class Shrinker
-{
-    /// <summary>Greedy shrink: reset each axis to its default (shape axes to a fixed base) while the failure (same first 50 characters) persists.</summary>
-    public static async Task<(Row Row, string Failure)> Shrink(Row r, Func<Row, Task<string?>> check)
-    {
-        var baseShape = new Dictionary<string, string> { ["shape.kind"] = "record-struct", ["shape.wrapped"] = "int", ["shape.position"] = "property", ["shape.containing"] = "class", ["input.json"] = "valid" };
-        async Task<string?> Safe(Row x) { try { return await check(x.Fresh()); } catch (Exception ex) { return "UNEXPECTED " + ex.GetType().Name + ": " + ex.Message; } }
-        var fail = await Safe(r) ?? throw new InvalidOperationException("row does not fail");
-        var key = fail[..Math.Min(50, fail.Length)];
-        var cur = r;
-        var changed = true;
-        while (changed)
-        {
-            changed = false;
-            foreach (var kv in cur.All.ToList())
-            {
-                var def = baseShape.TryGetValue(kv.Key, out var b) ? b : "default";
-                if (kv.Value == def) continue;
-                var cand = cur.With(kv.Key, def);
-                var f = await Safe(cand);
-                if (f is not null && f.StartsWith(key[..Math.Min(30, key.Length)])) { cur = cand; changed = true; fail = f; }
-            }
-        }
-        return (cur, fail);
-    }
-}
diff --git a/tools/probe/corpus/harness/RuleControllers.g.cs b/tools/probe/corpus/harness/RuleControllers.g.cs
deleted file mode 100644
index 9b3f57cf..00000000
--- a/tools/probe/corpus/harness/RuleControllers.g.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Generated by tools/probe/generators/rules.cs: controllers answering composed faults, one action per arity x response variant (C03, C05).
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.AspNetCore;
-using Microsoft.AspNetCore.Http.HttpResults;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Mvc;
-namespace Probes;
-public abstract class RuleCtlBase : ControllerBase
-{
-    [HttpGet("c/2/plain")]
-    public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> A2Plain(int e) => Cmp.Two(e).ToHttpResult();
-    [HttpGet("c/3/plain")]
-    public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>, FaultProblem<SFault>> A3Plain(int e) => Cmp.Three(e).ToHttpResult();
-    [HttpGet("c/2/wo"), WithoutFaults<HFault>(nameof(HFault.Bad))]
-    public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> A2Wo(int e) => Cmp.Two(e).ToHttpResult();
-    [HttpGet("c/3/wo"), WithoutFaults<HFault>(nameof(HFault.Bad))]
-    public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>, FaultProblem<SFault>> A3Wo(int e) => Cmp.Three(e).ToHttpResult();
-    [HttpGet("c/2/group"), FaultStatus<HFault>(nameof(HFault.Clash), 422)]
-    public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> A2Group(int e) => Cmp.Two(e).ToHttpResult();
-    [HttpGet("c/3/group"), FaultStatus<HFault>(nameof(HFault.Clash), 422)]
-    public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>, FaultProblem<SFault>> A3Group(int e) => Cmp.Three(e).ToHttpResult();
-    [HttpGet("c/2/declared"), ProducesResponseType<ProblemDetails>(429)]
-    public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>> A2Declared(int e) => Cmp.Two(e).ToHttpResult();
-    [HttpGet("c/3/declared"), ProducesResponseType<ProblemDetails>(429)]
-    public Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>, FaultProblem<SFault>> A3Declared(int e) => Cmp.Three(e).ToHttpResult();
-    [HttpGet("c/2/dup")]
-    public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> A2Dup(int e) => Cmp.TwoK(e).ToHttpResult();
-    [HttpGet("c/3/dup")]
-    public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>, FaultProblem<SFault>> A3Dup(int e) => Cmp.ThreeK(e).ToHttpResult();
-}
-[ApiController] public sealed class RuleApiController : RuleCtlBase { }
-public sealed class RulePlainController : RuleCtlBase { }
diff --git a/tools/probe/corpus/harness/SchemaClaim.cs b/tools/probe/corpus/harness/SchemaClaim.cs
deleted file mode 100644
index 65b49f19..00000000
--- a/tools/probe/corpus/harness/SchemaClaim.cs
+++ /dev/null
@@ -1,720 +0,0 @@
-// Shared code of the claims C08-same-name-warning, C12-described-converter, C13-patch-required and C16-options-agreement
-// (harness; the probes are in probes/C08..., C12..., C13..., C16...). Every check starts the shared host (Hx.Start, which applies the
-// row's json.*, openapi.*, mvc.* and http.* axes) with only the endpoints of its claim: minimal ones under Hx.M, controllers of its own
-// under Hx.C, the actions it does not need removed by a convention.
-// - C08 (AspNetCore README#faults-of-several-types, "Keep names distinct"): two fault types an endpoint answers with that write one
-//   name for two errors make the host log a warning at startup naming both; qualified names, or leaving one out, fix it.
-// - C12 (docs/json.md#describing-what-a-converter-writes, AspNetCore README "A described type"): the document describes a type as its
-//   described converter or the options' JsonSchemaDescriptions say, as a property, a nullable one, a list's items, a dictionary's
-//   additionalProperties, inside a value object and inside a patch; a parameter keeps ASP.NET's schema.
-// - C13 (docs/merge-patches.md#required-constructor-parameters): under RespectRequiredConstructorParameters a constructor-parameter
-//   patch is required in the document and on the wire, an init one is neither, and without the option neither is.
-// - C16 (AspNetCore README#what-the-document-says, "Register the same on both option sets"): a host with controllers whose two option
-//   sets register different converters or descriptions has its document refused, naming the type and what the options say of it,
-//   also for a type held only inside a patch; a minimal-API host builds it. The docs name converters and descriptions: a different
-//   naming policy or number handling is not "described differently", so the document builds there (DescribedOptionsAgreement
-//   compares JsonSchemaDescription.For, which neither setting changes).
-// Each claim's obligations are checks of their own (Row.Check), every check of a row on the same host or hosts, the answers fetched once.
-#pragma warning disable xUnit1051
-using System.Globalization;
-using System.Net;
-using System.Reflection;
-using System.Text.Json;
-using System.Text.Json.Nodes;
-using System.Text.Json.Serialization;
-using System.Text.Json.Serialization.Metadata;
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.AspNetCore;
-using CodoMetis.TypeKit.ClosedSets;
-using CodoMetis.TypeKit.ValueObjects;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Http.HttpResults;
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.AspNetCore.Mvc.ApplicationModels;
-using Microsoft.AspNetCore.Routing;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-using Probes.Shapes;
-using HttpJsonOptions = Microsoft.AspNetCore.Http.Json.JsonOptions;
-using MvcJsonOptions = Microsoft.AspNetCore.Mvc.JsonOptions;
-namespace Probes.Schema.NsA
-{
-    /// <summary>One of two fault sets of one nesting chain (Twin) in two namespaces: qualified names meet too.</summary>
-    public sealed partial class Twin : IFaultSet<Twin>
-    {
-        public static readonly Twin Same = new(FaultKind.Conflict, null);
-        public static readonly Twin OnlyA = new(FaultKind.NotFound, null);
-        private Twin(FaultKind kind, string? description) { Kind = kind; Description = description; }
-        public FaultKind Kind { get; }
-        public string? Description { get; }
-    }
-}
-namespace Probes.Schema.NsB
-{
-    public sealed partial class Twin : IFaultSet<Twin>
-    {
-        public static readonly Twin Same = new(FaultKind.Conflict, null);
-        public static readonly Twin OnlyB = new(FaultKind.Unavailable, null);
-        private Twin(FaultKind kind, string? description) { Kind = kind; Description = description; }
-        public FaultKind Kind { get; }
-        public string? Description { get; }
-    }
-}
-namespace Probes.Schema
-{
-    using TwinA = Probes.Schema.NsA.Twin;
-    using TwinB = Probes.Schema.NsB.Twin;
-
-    // ---------------------------------------------------------------- types the documents describe
-
-    /// <summary>A type an application writes with a converter of its own (docs/json.md's Coordinates).</summary>
-    public readonly record struct Coord(double Lat, double Lon);
-    /// <summary>A second one, held only inside a patch (C16).</summary>
-    public readonly record struct CoordP(double Lat, double Lon);
-    public readonly partial record struct CoordVo : IValue<Coord>;
-    public readonly partial record struct DecVo : IValue<decimal>;
-
-    static class CoordText
-    {
-        public static (double, double) Read(ref Utf8JsonReader reader, string prefix) =>
-            reader.GetString() is { } s && s.StartsWith(prefix, StringComparison.Ordinal) && s[prefix.Length..].Split(',') is [var a, var b]
-                ? (double.Parse(a, CultureInfo.InvariantCulture), double.Parse(b, CultureInfo.InvariantCulture))
-                : throw new JsonException();
-        public static string Write(string prefix, double a, double b) => string.Create(CultureInfo.InvariantCulture, $"{prefix}{a},{b}");
-    }
-
-    /// <summary>source=IDescribedJsonConverter: a converter that says what it writes.</summary>
-    public sealed class CoordConverter : JsonConverter<Coord>, IDescribedJsonConverter
-    {
-        public static JsonObject Schema() => new() { ["type"] = "string", ["pattern"] = @"^c:-?\d+(\.\d+)?,-?\d+(\.\d+)?$" };
-        public override Coord Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) { var (a, b) = CoordText.Read(ref reader, "c:"); return new(a, b); }
-        public override void Write(Utf8JsonWriter writer, Coord value, JsonSerializerOptions options) => writer.WriteStringValue(CoordText.Write("c:", value.Lat, value.Lon));
-        public JsonSchemaDescription? DescribeJson(Type typeToConvert, JsonSerializerOptions options) => JsonSchemaDescription.Of(Schema());
-    }
-    /// <summary>source=JsonSchemaDescriptions: a converter someone else wrote, which says nothing; the options describe it.</summary>
-    public sealed class CoordPlainConverter : JsonConverter<Coord>
-    {
-        public static JsonObject Schema() => new() { ["type"] = "string", ["pattern"] = @"^d:-?\d+(\.\d+)?,-?\d+(\.\d+)?$" };
-        public override Coord Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) { var (a, b) = CoordText.Read(ref reader, "d:"); return new(a, b); }
-        public override void Write(Utf8JsonWriter writer, Coord value, JsonSerializerOptions options) => writer.WriteStringValue(CoordText.Write("d:", value.Lat, value.Lon));
-    }
-    public sealed class CoordPConverter : JsonConverter<CoordP>, IDescribedJsonConverter
-    {
-        public static JsonObject Schema() => new() { ["type"] = "string", ["pattern"] = @"^p:-?\d+(\.\d+)?,-?\d+(\.\d+)?$" };
-        public override CoordP Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) { var (a, b) = CoordText.Read(ref reader, "p:"); return new(a, b); }
-        public override void Write(Utf8JsonWriter writer, CoordP value, JsonSerializerOptions options) => writer.WriteStringValue(CoordText.Write("p:", value.Lat, value.Lon));
-        public JsonSchemaDescription? DescribeJson(Type typeToConvert, JsonSerializerOptions options) => JsonSchemaDescription.Of(Schema());
-    }
-
-    /// <summary>C12: every position the docs name ("a property, a body, a nullable one, a list's element, a dictionary's value, and inside a value object or a patch").</summary>
-    public sealed record CoordDto
-    {
-        public Coord At { get; init; }
-        public Coord? Maybe { get; init; }
-        /// <summary>A plain nullable struct beside Maybe: what ASP.NET writes for a nullable reference in the same document.</summary>
-        public Box? Twin { get; init; }
-        public List<Coord> Route { get; init; } = [];
-        public Dictionary<string, Coord> ByName { get; init; } = [];
-        public required CoordVo Vo { get; init; }
-        public Patch<Coord> Patched { get; init; }
-    }
-    public sealed record DecDto
-    {
-        public decimal At { get; init; }
-        public decimal? Maybe { get; init; }
-        public List<decimal> Route { get; init; } = [];
-        public Dictionary<string, decimal> ByName { get; init; } = [];
-        public required DecVo Vo { get; init; }
-        public Patch<decimal> Patched { get; init; }
-    }
-    /// <summary>A plain struct without a converter of its own: the baselines' twin.</summary>
-    public readonly record struct Box(int V);
-    public sealed record BoxDto { public Box Inner { get; init; } }
-    /// <summary>C13: the docs' two declarations of a patch field.</summary>
-    public sealed record InitPatchDto { public Patch<int> Floor { get; init; } }
-    public sealed record CtorPatchDto(Patch<int> Floor);
-    /// <summary>C16: a described type as a property, and one held only inside a patch.</summary>
-    public sealed record AgreeDto { public Coord At { get; init; } }
-    public sealed record AgreePatchDto { public Patch<CoordP> P { get; init; } }
-
-    /// <summary>
-    /// The application lists its own types for json.TypeInfoResolver=source-generated-context: appended to the resolver chain, it
-    /// answers only where the row's resolver does not (a reflection resolver always does). Under the strict context the chain is
-    /// ProbeContext then this, with no reflection behind them.
-    /// </summary>
-    [JsonSerializable(typeof(CoordDto)), JsonSerializable(typeof(DecDto)), JsonSerializable(typeof(InitPatchDto)), JsonSerializable(typeof(CtorPatchDto))]
-    [JsonSerializable(typeof(AgreeDto)), JsonSerializable(typeof(AgreePatchDto)), JsonSerializable(typeof(Coord)), JsonSerializable(typeof(CoordP))]
-    [JsonSerializable(typeof(Coord?)), JsonSerializable(typeof(List<Coord>)), JsonSerializable(typeof(Dictionary<string, Coord>)), JsonSerializable(typeof(CoordVo))]
-    [JsonSerializable(typeof(Patch<Coord>)), JsonSerializable(typeof(Patch<CoordP>)), JsonSerializable(typeof(Patch<int>)), JsonSerializable(typeof(Patch<decimal>))]
-    [JsonSerializable(typeof(decimal)), JsonSerializable(typeof(decimal?)), JsonSerializable(typeof(List<decimal>)), JsonSerializable(typeof(Dictionary<string, decimal>))]
-    [JsonSerializable(typeof(BoxDto)), JsonSerializable(typeof(Box?))]
-    [JsonSerializable(typeof(ProblemDetails))]   // what a fault is answered as (C08), as an application on a source-generated context lists it
-    [JsonSerializable(typeof(DecVo)), JsonSerializable(typeof(int)), JsonSerializable(typeof(string)), JsonSerializable(typeof(double))]
-    public partial class SchemaJson : JsonSerializerContext { }
-
-    // ---------------------------------------------------------------- controllers
-
-    /// <summary>Keeps only the named actions of the probe's own controllers: one controller type serves every row.</summary>
-    public sealed class KeepOnly(Type controllerBase, params string[] actions) : IApplicationModelConvention
-    {
-        public void Apply(ApplicationModel application)
-        {
-            foreach (var c in application.Controllers.Where(c => controllerBase.IsAssignableFrom(c.ControllerType)))
-                foreach (var a in c.Actions.ToList())
-                    if (!actions.Contains(a.ActionName)) c.Actions.Remove(a);
-        }
-    }
-
-    public abstract class SchemaCtlBase : ControllerBase
-    {
-        [HttpPost("s/coord/c")] public CoordDto Coord([FromBody] CoordDto b) => b;
-        [HttpPost("s/dec/c")] public DecDto Dec([FromBody] DecDto b, [FromQuery] decimal q) => b;
-        [HttpPost("s/init/c")] public IActionResult Init([FromBody] InitPatchDto b) => ModelState.IsValid && b is not null ? Content(b.Floor.State.ToString()) : BadRequest();
-        [HttpPost("s/ctor/c")] public IActionResult Ctor([FromBody] CtorPatchDto b) => ModelState.IsValid && b is not null ? Content(b.Floor.State.ToString()) : BadRequest();
-        [HttpPost("s/box/c")] public IActionResult Boxed([FromBody] BoxDto b) => ModelState.IsValid && b is not null ? Content("Box") : BadRequest();
-        [HttpPost("s/agree/c")] public AgreeDto Agree([FromBody] AgreeDto b) => b;
-        [HttpPost("s/agreep/c")] public AgreePatchDto AgreeP([FromBody] AgreePatchDto b) => b;
-    }
-    [ApiController] public sealed class SchemaApiCtl : SchemaCtlBase { }
-    public sealed class SchemaPlainCtl : SchemaCtlBase { }
-
-    /// <summary>C08: errors that two fault types write alike. e: 1 the first type's, 2 the second type's, 3 SFault.First (arity 3).</summary>
-    public static class AlikeErr
-    {
-        public static Result<Fault<HFault, KFault>> K2(int e) => e switch
-        { 1 => Fault<HFault, KFault>.Of(HFault.Clash), 2 => Fault<HFault, KFault>.Of(KFault.Clash), _ => Result<Fault<HFault, KFault>>.Success() };
-        public static Result<Fault<HFault, KFault, SFault>> K3(int e) => e switch
-        {
-            1 => Fault<HFault, KFault, SFault>.Of(HFault.Clash), 2 => Fault<HFault, KFault, SFault>.Of(KFault.Clash), 3 => Fault<HFault, KFault, SFault>.Of(SFault.First),
-            _ => Result<Fault<HFault, KFault, SFault>>.Success(),
-        };
-        public static Result<Fault<TwinA, TwinB>> T2(int e) => e switch
-        { 1 => Fault<TwinA, TwinB>.Of(TwinA.Same), 2 => Fault<TwinA, TwinB>.Of(TwinB.Same), _ => Result<Fault<TwinA, TwinB>>.Success() };
-        public static Result<Fault<TwinA, TwinB, SFault>> T3(int e) => e switch
-        {
-            1 => Fault<TwinA, TwinB, SFault>.Of(TwinA.Same), 2 => Fault<TwinA, TwinB, SFault>.Of(TwinB.Same), 3 => Fault<TwinA, TwinB, SFault>.Of(SFault.First),
-            _ => Result<Fault<TwinA, TwinB, SFault>>.Success(),
-        };
-    }
-    public abstract class AlikeCtlBase : ControllerBase
-    {
-        [HttpGet("s/alike/c")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> K2None(int e) => AlikeErr.K2(e).ToHttpResult();
-        [HttpGet("s/alike/c"), WithoutFaults<KFault>(nameof(KFault.Clash))] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>> K2Wo(int e) => AlikeErr.K2(e).ToHttpResult();
-        [HttpGet("s/alike/c")] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>, FaultProblem<SFault>> K3None(int e) => AlikeErr.K3(e).ToHttpResult();
-        [HttpGet("s/alike/c"), WithoutFaults<KFault>(nameof(KFault.Clash))] public Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>, FaultProblem<SFault>> K3Wo(int e) => AlikeErr.K3(e).ToHttpResult();
-        [HttpGet("s/alike/c")] public Results<NoContent, FaultProblem<TwinA>, FaultProblem<TwinB>> T2None(int e) => AlikeErr.T2(e).ToHttpResult();
-        [HttpGet("s/alike/c"), WithoutFaults<TwinB>(nameof(TwinB.Same))] public Results<NoContent, FaultProblem<TwinA>, FaultProblem<TwinB>> T2Wo(int e) => AlikeErr.T2(e).ToHttpResult();
-        [HttpGet("s/alike/c")] public Results<NoContent, FaultProblem<TwinA>, FaultProblem<TwinB>, FaultProblem<SFault>> T3None(int e) => AlikeErr.T3(e).ToHttpResult();
-        [HttpGet("s/alike/c"), WithoutFaults<TwinB>(nameof(TwinB.Same))] public Results<NoContent, FaultProblem<TwinA>, FaultProblem<TwinB>, FaultProblem<SFault>> T3Wo(int e) => AlikeErr.T3(e).ToHttpResult();
-    }
-    [ApiController] public sealed class AlikeApiCtl : AlikeCtlBase { }
-    public sealed class AlikePlainCtl : AlikeCtlBase { }
-
-    /// <summary>Every log line with its category and level (ListedLogs keeps neither).</summary>
-    public sealed class CategoryLogs : ILoggerProvider
-    {
-        public readonly List<(string Category, LogLevel Level, string Message)> Lines = [];
-        public ILogger CreateLogger(string categoryName) => new L(this, categoryName);
-        public void Dispose() { }
-        sealed class L(CategoryLogs o, string category) : ILogger
-        {
-            public IDisposable? BeginScope<TState>(TState state) where TState : notnull => null;
-            public bool IsEnabled(LogLevel logLevel) => true;
-            public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
-            { lock (o.Lines) o.Lines.Add((category, logLevel, formatter(state, exception))); }
-        }
-    }
-
-    // ---------------------------------------------------------------- the checks
-
-    public static class SchemaChecks
-    {
-        static string Cut(string? s) => s is null ? "(null)" : s.Length > 300 ? s[..300] + "..." : s;
-        static void Process(Row r, Entry en) { if (r.Is("process.converter-lookup", "wrapped-type-converter-looked-up-first")) _ = System.ComponentModel.TypeDescriptor.GetConverter(Make.Held(en.Plain)); }
-
-        /// <summary>The host's minimal-API JSON options, which the document is built from.</summary>
-        static JsonSerializerOptions HttpOptions(WebApplication app) => app.Services.GetRequiredService<IOptions<HttpJsonOptions>>().Value.SerializerOptions;
-        /// <summary>The JSON name of a CLR property under the options (naming policy, renaming modifier).</summary>
-        static string JsonName(JsonSerializerOptions o, Type t, string clr) =>
-            o.GetTypeInfo(t).Properties.First(p => (p.AttributeProvider as MemberInfo)?.Name == clr).Name;
-        static void ListOwnTypes(JsonSerializerOptions o) => o.TypeInfoResolverChain.Add(SchemaJson.Default);
-
-        static HostCfg Cfg(Row r, string[] actions, Action<IEndpointRouteBuilder> minimal, Action<IServiceCollection>? services = null) => new()
-        {
-            Payload = false, FaultControllers = true,
-            Controllers = [Hx.Plain(r) ? typeof(SchemaPlainCtl) : typeof(SchemaApiCtl)],
-            Minimal = minimal,
-            Services = s =>
-            {
-                s.Configure<MvcOptions>(o => o.Conventions.Add(new KeepOnly(typeof(SchemaCtlBase), actions)));
-                s.PostConfigure<HttpJsonOptions>(o => ListOwnTypes(o.SerializerOptions));
-                s.PostConfigure<MvcJsonOptions>(o => ListOwnTypes(o.JsonSerializerOptions));
-                services?.Invoke(s);
-            },
-        };
-
-        /// <summary>The paths of one endpoint family on the row's sides: the minimal one and the controller's.</summary>
-        static List<string> Sides(Row r, string family)
-        {
-            var sides = new List<string>();
-            if (Hx.HasMinimal(r)) sides.Add(Hx.M(r, $"/s/{family}/m"));
-            if (Hx.HasMvc(r)) sides.Add(Hx.C(r, $"/s/{family}/c"));
-            return sides;
-        }
-
-        /// <summary>The operation of a path, by the document's spelling of it.</summary>
-        static JsonNode? Op(JsonNode doc, string path, string method) => doc["paths"]?[path]?[method];
-        /// <summary>The request body's schema, references resolved: OpenAPI 3 (requestBody) and 2.0 (a body parameter).</summary>
-        static JsonNode? BodySchema(JsonNode doc, JsonNode op)
-        {
-            var s = op["requestBody"]?["content"]?["application/json"]?["schema"]
-                 ?? op["parameters"]?.AsArray().FirstOrDefault(p => p?["in"]?.GetValue<string>() == "body")?["schema"];
-            return s is null ? null : Hx.Deep(doc, s);
-        }
-        /// <summary>A schema with its keys sorted and its nullability markers gone, to compare with a description.</summary>
-        static JsonNode? Norm(JsonNode? n) => Hx.NoNull(Hx.Deep(new JsonObject(), n));
-        static bool Admits(JsonNode? n)
-        {
-            var t = n?.ToJsonString() ?? "";
-            return t.Contains("\"null\"") || t.Contains("\"nullable\":true") || t.Contains("\"x-nullable\":true");
-        }
-
-        // ============================================================ C08
-        /// <summary>
-        /// C08, a check per obligation over two hosts (HFault.Clash beside KFault.Clash, and NsA.Twin.Same beside NsB.Twin.Same): each host's
-        /// warning, or none, is checked for the obligation its naming and leave-out select (bare-names-warn, qualified-chain-warns,
-        /// qualified-names-fix, leave-one-out-fixes), with what its endpoints answer; warning-names-both, where a host warns, for the names
-        /// the warning gives.
-        /// </summary>
-        public static async Task<string?> C08(Row r)
-        {
-            var en = Registry.Of(r); Process(r, en);
-            var qualified = r["naming"] == "qualified";
-            var arity = int.Parse(r["arity"]);
-            var leave = r["leave-out"] == "WithoutFaults-one";
-            var runs = new[] { await Alike(r, en, twin: false, arity, leave, qualified), await Alike(r, en, twin: true, arity, leave, qualified) };
-            string? failed = null;
-            foreach (var o in runs.SelectMany(a => a.Obligations).Distinct().ToList())
-            {
-                var f = r.Check(o, Baseline.Docs("src/CodoMetis.TypeKit.AspNetCore/README.md#faults-of-several-types"), c =>
-                {
-                    foreach (var a in runs) if (a.Judge(o) is { } fail) return fail;
-                    c.Note(NoteKeys.Compared, string.Join(", ", runs.Where(a => a.Obligations.Contains(o)).Select(a => a.Action)));
-                    return null;
-                });
-                failed ??= f;
-            }
-            return failed;
-        }
-
-        /// <summary>
-        /// One host of C08: what its endpoints answered and what it logged at startup, judged per obligation by <see cref="Judge"/>. Warns:
-        /// the obligation of whether the host warns (and what it answers); the names the warning gives are warning-names-both's.
-        /// </summary>
-        sealed record AlikeRun(string Action, string? Down, bool Twin, bool Leave, bool Qualified, bool OwnWrapped, List<string> Sides,
-                               List<(string Path, int E, Hx.Wire Wire)> Answers, List<string> Lines)
-        {
-            string First => Twin ? "Twin" : "HFault";
-            string Second => Twin ? "Twin" : "KFault";
-            string Member => Twin ? "Same" : "Clash";
-            string Written(string type) => Qualified ? $"{type}.{Member}" : Member;
-            bool Warn => Written(First) == Written(Second) && !Leave;
-            public string Warns => Leave ? "leave-one-out-fixes" : !Qualified ? "bare-names-warn" : Twin ? "qualified-chain-warns" : "qualified-names-fix";
-            public string[] Obligations => Warn ? [Warns, "warning-names-both"] : [Warns];
-
-            public string? Judge(string o)
-            {
-                if (!Obligations.Contains(o)) return null;
-                if (Down is not null) return Down;
-                if (o == Warns)
-                {
-                    foreach (var (path, e, w) in Answers)
-                    {
-                        if (e == 2 && Leave)
-                        {
-                            // the member left out is not answered (README#leaving-out-what-a-route-cannot-answer): proof that the leave-out applied
-                            if (w.Thrown is null || !w.Thrown.StartsWith(nameof(InvalidOperationException))) return $"{Action} {path} e=2: the member left out was answered: {(int)w.Status} {Cut(w.Body)} {w.Thrown}";
-                            continue;
-                        }
-                        if (w.Thrown is not null) return $"{Action} {path} e={e}: request threw {w.Thrown}";
-                        var want = e == 3 ? (Qualified ? "SFault.First" : "First") : Written(e == 1 ? First : Second);
-                        const int status = 409;   // Conflict for both clashing members, and SFault.First as the host maps it
-                        if ((int)w.Status != status) return $"{Action} {path} e={e}: status {(int)w.Status}, expected {status}: {Cut(w.Body)}";
-                        JsonNode? body; try { body = JsonNode.Parse(w.Body); } catch { return $"{Action} {path} e={e}: body is not JSON: {Cut(w.Body)}"; }
-                        // the application's own string converter (json.Converters=own-for-wrapped over string) wraps every string it writes
-                        var fault = body?["fault"]?.GetValue<string>() is { } f && OwnWrapped && f.StartsWith("own:") ? f[4..].Trim('"') : body?["fault"]?.GetValue<string>();
-                        if (fault != want) return $"{Action} {path} e={e}: fault {fault}, expected {want}";
-                    }
-                    if (!Warn)
-                        return Lines.Count == 0 ? null : $"{Action} ({(Qualified ? "qualified" : "bare")} names, {(Leave ? "one left out" : "none left out")}): the errors are written {Written(First)} and {Written(Second)}, yet the host warned: {Cut(Lines[0])}";
-                    return Lines.Count == Sides.Count ? null : $"{Action}: {Sides.Count} endpoint(s) answer {First}.{Member} and {Second}.{Member} alike as \"{Written(First)}\", {Lines.Count} warning(s) at startup{(Lines.Count > 0 ? ": " + Cut(Lines[0]) : "")}";
-                }
-                var names = Twin ? (Qualified ? new[] { "NsA.Twin.Same", "NsB.Twin.Same" } : ["Twin.Same"]) : ["HFault.Clash", "KFault.Clash"];
-                foreach (var l in Lines)
-                    if (names.FirstOrDefault(n => !l.Contains(n, StringComparison.Ordinal)) is { } missing) return $"{Action}: the warning does not name {missing}: {Cut(l)}";
-                return null;
-            }
-        }
-
-        /// <summary>
-        /// One endpoint per side answering two fault types whose clashing members are HFault.Clash and KFault.Clash (bare names meet,
-        /// qualified ones do not) or NsA.Twin.Same and NsB.Twin.Same (one nesting chain in two namespaces: both meet).
-        /// </summary>
-        static async Task<AlikeRun> Alike(Row r, Entry en, bool twin, int arity, bool leave, bool qualified)
-        {
-            var logs = new CategoryLogs();
-            var action = (twin ? "T" : "K") + arity + (leave ? "Wo" : "None");
-            var cfg = new HostCfg
-            {
-                Payload = false, FaultControllers = true, Qualified = qualified,
-                Controllers = [Hx.Plain(r) ? typeof(AlikePlainCtl) : typeof(AlikeApiCtl)],
-                Minimal = b =>
-                {
-                    RouteHandlerBuilder m = (twin, arity) switch
-                    {
-                        (false, 2) => b.MapGet("/s/alike/m", (int e) => AlikeErr.K2(e).ToHttpResult()),
-                        (false, _) => b.MapGet("/s/alike/m", (int e) => AlikeErr.K3(e).ToHttpResult()),
-                        (true, 2) => b.MapGet("/s/alike/m", (int e) => AlikeErr.T2(e).ToHttpResult()),
-                        (true, _) => b.MapGet("/s/alike/m", (int e) => AlikeErr.T3(e).ToHttpResult()),
-                    };
-                    if (leave && twin) m.WithoutFaults(TwinB.Same);
-                    else if (leave) m.WithoutFaults(KFault.Clash);
-                },
-                Services = s =>
-                {
-                    s.AddSingleton<ILoggerProvider>(logs);
-                    s.Configure<MvcOptions>(o => o.Conventions.Add(new KeepOnly(typeof(AlikeCtlBase), action)));
-                    // the application lists its own types (ProblemDetails, what a fault is answered as) beside the row's resolver
-                    s.PostConfigure<HttpJsonOptions>(o => ListOwnTypes(o.SerializerOptions));
-                    s.PostConfigure<MvcJsonOptions>(o => ListOwnTypes(o.JsonSerializerOptions));
-                },
-            };
-            var sides = Sides(r, "alike");
-            var ownWrapped = r.Is("json.Converters", "own-for-wrapped");
-            var answers = new List<(string, int, Hx.Wire)>();
-            WebApplication app;
-            try { app = await Hx.Start(r, en, cfg); }
-            catch (Exception ex) when (ex is not Probes.Shapes.Sides.InputsNotEquivalent) { return new(action, $"{action}: host did not start: {ex.GetType().Name}: {Cut(ex.Message)}", twin, leave, qualified, ownWrapped, sides, answers, []); }
-            await using var _ = app;
-            // what each error is written as on the wire: the client's view of the two
-            foreach (var path in sides)
-                foreach (var e in arity == 3 ? new[] { 1, 2, 3 } : [1, 2])
-                    answers.Add((path, e, await Hx.Get(app, $"{path}?e={e}")));
-            List<string> lines;
-            lock (logs.Lines) lines = logs.Lines.Where(l => l.Category == "CodoMetis.TypeKit.AspNetCore.FaultResponses" && l.Level == LogLevel.Warning).Select(l => l.Message).ToList();
-            return new(action, null, twin, leave, qualified, ownWrapped, sides, answers, lines);
-        }
-
-        // ============================================================ C12
-        /// <summary>
-        /// C12, a check per obligation on one host: the source's own (own-converter-describes-itself, or options-describe for
-        /// JsonSchemaDescriptions) at a property, every-position at every position the docs name, and for the decimal converter
-        /// parameter-keeps-aspnet, the query parameter against what ASP.NET writes without converters.
-        /// </summary>
-        public static async Task<string?> C12(Row r)
-        {
-            var en = Registry.Of(r); Process(r, en);
-            var source = r["source"];
-            var dec = source == "decimal-converter";
-            var family = dec ? "dec" : "coord";
-            var dto = dec ? typeof(DecDto) : typeof(CoordDto);
-            void Register(JsonSerializerOptions o)
-            {
-                // first among the options' converters, on both option sets in the same order ("Register the same on both option sets")
-                switch (source)
-                {
-                    case "IDescribedJsonConverter": o.Converters.Insert(0, new CoordConverter()); break;
-                    case "JsonSchemaDescriptions":
-                        o.Converters.Insert(0, new CoordPlainConverter());
-                        o.Converters.Insert(1, new JsonSchemaDescriptions().Describe<Coord>(JsonSchemaDescription.Of(CoordPlainConverter.Schema())));
-                        break;
-                    case "decimal-converter": o.Converters.Insert(0, new DecimalStringJsonConverter()); break;
-                    default: throw new ArgumentException("unknown source " + source);
-                }
-            }
-            var cfg = Cfg(r, [dec ? "Dec" : "Coord"],
-                b => { if (dec) b.MapPost("/s/dec/m", (DecDto body, decimal q) => body); else b.MapPost("/s/coord/m", (CoordDto body) => body); },
-                s => { s.PostConfigure<HttpJsonOptions>(o => Register(o.SerializerOptions)); s.PostConfigure<MvcJsonOptions>(o => Register(o.JsonSerializerOptions)); });
-            WebApplication? app = null; string? down = null;
-            try { app = await Hx.Start(r, en, cfg); }
-            catch (Exception ex) when (ex is not Probes.Shapes.Sides.InputsNotEquivalent) { down = "host did not start: " + ex.GetType().Name + ": " + Cut(ex.Message); }
-            await using var _ = app;
-            JsonNode? doc = null; Exception? docFailed = null;
-            if (app is not null) { try { doc = await Hx.Doc(app); } catch (Exception ex) { docFailed = ex; } }
-            var described = source == "JsonSchemaDescriptions" ? "options-describe" : "own-converter-describes-itself";
-            string[] obligations = dec ? [described, "every-position", "parameter-keeps-aspnet"] : [described, "every-position"];
-            string? failed = null;
-            foreach (var o in obligations)
-            {
-                var against = o == "parameter-keeps-aspnet" ? Baseline.Framework : Baseline.Docs("docs/json.md#describing-what-a-converter-writes");
-                var f = await r.Check(o, against, async c =>
-                {
-                    if (down is not null) return down;
-                    // a document ASP.NET alone refuses the same way has nothing to check (noted there)
-                    if (docFailed is not null) return await Hx.DocRefusedByAspNetAlone(r, en, cfg, docFailed);
-                    var http = HttpOptions(app!);
-                    var want = Norm(dec ? new DecimalStringJsonConverter().DescribeJson(typeof(decimal), http)!.Schema
-                                        : source == "IDescribedJsonConverter" ? CoordConverter.Schema() : CoordPlainConverter.Schema());
-                    foreach (var path in Sides(r, family))
-                    {
-                        var op = Op(doc!, path, "post");
-                        if (op is null) return $"document has no POST {path}";
-                        if (o == "parameter-keeps-aspnet")
-                        {
-                            // "Parameters aren't JSON": the query parameter keeps ASP.NET's number, never the converter's string
-                            var q = op["parameters"]?.AsArray().FirstOrDefault(p => p?["name"]?.GetValue<string>() == "q");
-                            if (q is null) return $"{path}: no parameter q";
-                            var qs = Hx.Deep(doc!, q["schema"] ?? q);
-                            if (!(qs?.ToJsonString() ?? "").Contains("\"number\"")) return $"{path}: the query parameter q is described as {Cut(qs?.ToJsonString())}, not ASP.NET's number";
-                            if (JsonNode.DeepEquals(Norm(qs), want)) return $"{path}: the query parameter q is described as the converter's JSON";
-                            continue;
-                        }
-                        if (BodySchema(doc!, op) is not JsonObject body) return $"{path}: no request body schema";
-                        var props = body["properties"]?.AsObject();
-                        JsonNode? P(string clr) => props?[JsonName(http, dto, clr)];
-                        var positions = new (string What, JsonNode? Got, bool Null)[]
-                        {
-                            ("a property", P("At"), false), ("a nullable property", P("Maybe"), true), ("a list's items", P("Route")?["items"], false),
-                            ("a dictionary's additionalProperties", P("ByName")?["additionalProperties"], false), ("inside a value object", P("Vo"), false),
-                            ("inside a patch", P("Patched"), true),
-                        };
-                        foreach (var (what, got, admitsNull) in positions)
-                        {
-                            // the source's own obligation is held at a property; every-position at each position the docs name
-                            if (o != "every-position" && what != "a property") continue;
-                            if (got is null) return $"{path}: {what} is missing from the body schema: {Cut(body.ToJsonString())}";
-                            // ASP.NET's OpenAPI 2.0 writer drops the reference of a nullable struct component ({"allOf":[{"x-nullable":true}]}):
-                            // the plain struct beside it, which has no converter, is written the same, so the position has nothing to check
-                            if (what == "a nullable property" && !dec && P("Twin") is { } twin && JsonNode.DeepEquals(got, twin) && Norm(twin) is JsonObject { Count: 0 })
-                            {
-                                c.Note(NoteKeys.SchemaNullableReferenceLostForPlainToo, path);
-                                continue;
-                            }
-                            if (!JsonNode.DeepEquals(Norm(got), want)) return $"{path}: {what} is {Cut(got.ToJsonString())}, the {source} says {want!.ToJsonString()}";
-                            if (admitsNull && !Admits(got)) return $"{path}: {what} does not admit null: {Cut(got.ToJsonString())}";
-                        }
-                    }
-                    c.Note(NoteKeys.Compared, source);
-                    return null;
-                });
-                failed ??= f;
-            }
-            return failed;
-        }
-
-        // ============================================================ C13
-        /// <summary>
-        /// C13, a check per obligation on one host: where the options require the constructor-parameter patch, doc-required-where-rejected
-        /// (a body without it is rejected, and the document lists it in required); elsewhere doc-optional-where-absent (the document leaves it
-        /// out of required); and absent-is-default for what the patch reads where a body leaves it out, sets it null or gives it a value.
-        /// </summary>
-        public static async Task<string?> C13(Row r)
-        {
-            var en = Registry.Of(r); Process(r, en);
-            var ctor = r["declared"] == "ctor-parameter";
-            var family = ctor ? "ctor" : "init";
-            var dto = ctor ? typeof(CtorPatchDto) : typeof(InitPatchDto);
-            var cfg = Cfg(r, [ctor ? "Ctor" : "Init", "Boxed"], b =>
-            {
-                if (ctor) b.MapPost("/s/ctor/m", (CtorPatchDto body) => Results.Text(body.Floor.State.ToString()));
-                else b.MapPost("/s/init/m", (InitPatchDto body) => Results.Text(body.Floor.State.ToString()));
-            },
-            // The actions answer a rejected body with 400 themselves: the serializer's rejection reaches ModelState under both kinds of
-            // controller, and ASP.NET's own ValidationProblemDetails is not this claim's (it cannot be written under MaxDepth=3 or a
-            // source-generated context that does not list it).
-            s => s.Configure<ApiBehaviorOptions>(o => { o.SuppressModelStateInvalidFilter = true; o.SuppressMapClientErrors = true; }));
-            WebApplication app;
-            try { app = await Hx.Start(r, en, cfg); }
-            catch (Exception ex) when (ex is not Probes.Shapes.Sides.InputsNotEquivalent) { return "host did not start: " + ex.GetType().Name + ": " + Cut(ex.Message); }
-            await using var _ = app;
-            var http = HttpOptions(app);
-            var respect = http.RespectRequiredConstructorParameters;
-            // "a patch that is a constructor parameter is required" under the option; an init property "keeps its default, which is Absent"
-            var required = ctor && respect;
-            var listing = required ? "doc-required-where-rejected" : "doc-optional-where-absent";
-            var floor = JsonName(http, dto, "Floor");
-            // 3 as the options read an int: an application's own converter for int (json.Converters=own-for-wrapped) reads its own spelling
-            var three = Reads(http, "3") ? "3" : JsonSerializer.Serialize(3, http);
-            JsonNode? doc = null; Exception? docFailed = null;
-            try { doc = await Hx.Doc(app); }
-            catch (Exception ex) { docFailed = ex; }
-            // What each side answered to a body that leaves the patch out, sets it null, and gives it a value; where the request threw, MVC's
-            // validator throws for any nested struct of a body under a small MaxValidationDepth, which the plain twin on the same side shows.
-            var bodies = new[] { ("absent", "{}"), ("cleared", $"{{\"{floor}\":null}}"), ("set", $"{{\"{floor}\":{three}}}") };
-            var answers = new List<(string Path, string Kind, string Body, Hx.Wire Wire, string? TwinThrew)>();
-            foreach (var path in Sides(r, family))
-                foreach (var (kind, body) in bodies)
-                {
-                    var w = await Hx.Send(app, HttpMethod.Post, path, body);
-                    var twin = w.Thrown is not null && path.EndsWith("/c", StringComparison.Ordinal) ? await Hx.Send(app, HttpMethod.Post, path.Replace($"/s/{family}/c", "/s/box/c"), "{}") : null;
-                    answers.Add((path, kind, body, w, twin?.Thrown is { } t && t.Split(':')[0] == w.Thrown!.Split(':')[0] ? t.Split(':')[0] : null));
-                }
-            string? failed = null;
-            foreach (var o in new[] { listing, "absent-is-default" })
-            {
-                var f = await r.Check(o, Baseline.Docs("docs/merge-patches.md#required-constructor-parameters"), async c =>
-                {
-                    var compared = false;   // whether the check judged an answer before the document
-                    foreach (var (path, kind, body, w, twinThrew) in answers)
-                    {
-                        // a body without the patch is the listing's premise where the options reject it, else what absent-is-default reads
-                        if ((kind == "absent" && required ? listing : "absent-is-default") != o) continue;
-                        if (twinThrew is not null)
-                        {
-                            // No sentence cites it: MVC's validator throws for the plain twin's nested struct too, so the check cannot tell.
-                            c.Inconclusive($"{path} {body}: MVC's validator throws {twinThrew} for the plain twin's body too");
-                            continue;
-                        }
-                        compared = true;
-                        if (w.Thrown is not null) return $"{path} {body}: request threw {w.Thrown}";
-                        switch (kind)
-                        {
-                            case "absent" when required && w.Status != HttpStatusCode.BadRequest:
-                                return $"{path}: a body without the constructor-parameter patch was answered {(int)w.Status} {Cut(w.Body)} under RespectRequiredConstructorParameters, not rejected";
-                            case "absent" when !required && (w.Status != HttpStatusCode.OK || w.Body != "Absent"):
-                                return $"{path}: a body without the {(ctor ? "constructor-parameter" : "init")} patch was answered {(int)w.Status} {Cut(w.Body)}, not Absent";
-                            case "cleared" when w.Status != HttpStatusCode.OK || w.Body != "Null":
-                                return $"{path}: a body with {floor}: null was answered {(int)w.Status} {Cut(w.Body)}, not Null";
-                            case "set" when w.Status != HttpStatusCode.OK || w.Body != "Value":
-                                return $"{path}: a body with {floor}: {three} was answered {(int)w.Status} {Cut(w.Body)}, not Value";
-                        }
-                    }
-                    if (o != listing) return null;
-                    // a document ASP.NET alone refuses the same way has nothing to check (noted there)
-                    if (docFailed is not null) return await Hx.DocRefusedByAspNetAlone(r, en, cfg, docFailed, compared);
-                    foreach (var path in Sides(r, family))
-                    {
-                        var op = Op(doc!, path, "post");
-                        if (op is null) return $"document has no POST {path}";
-                        if (BodySchema(doc!, op) is not JsonObject body) return $"{path}: no request body schema";
-                        if (body["properties"]?[floor] is null) return $"{path}: the body schema has no property {floor}: {Cut(body.ToJsonString())}";
-                        var listed = body["required"]?.AsArray().Any(x => x?.GetValue<string>() == floor) == true;
-                        if (listed != required)
-                            return $"{path}: the {(ctor ? "constructor-parameter" : "init")} patch {floor} is {(listed ? "" : "not ")}in required under RespectRequiredConstructorParameters={respect}, the serializer {(required ? "rejects" : "accepts")} a body without it";
-                    }
-                    c.Note(NoteKeys.Compared, $"{floor} {(required ? "" : "not ")}required");
-                    return null;
-                });
-                failed ??= f;
-            }
-            return failed;
-        }
-        static bool Reads(JsonSerializerOptions o, string json) { try { return JsonSerializer.Deserialize<int>(json, o) == 3; } catch (Exception ex) when (ex is JsonException or InvalidOperationException) { return false; } }
-
-        // ============================================================ C16
-        /// <summary>
-        /// C16, a check per obligation over two hosts (a described type as a property, and one held only inside a patch). Where the host has
-        /// controllers and only the minimal-API options carry the converter: differing-refused and patch-held-refused (the document refused
-        /// with an InvalidOperationException naming the type, for the property's host and the patch's), and error-names-type-and-descriptions
-        /// (the refusal names what the options say of it, for both), against the refusal. Elsewhere the document builds and describes the
-        /// type as the converter says: minimal-host-not-compared for a host of minimal APIs alone, same-converters-build where both option
-        /// sets carry the converter and differ only in naming policy or number handling.
-        /// </summary>
-        public static async Task<string?> C16(Row r)
-        {
-            var en = Registry.Of(r); Process(r, en);
-            var refuse = r["difference"] == "converter-only-http" && Hx.HasMvc(r);
-            var runs = new[] { await Agree(r, en, patch: false), await Agree(r, en, patch: true) };
-            var built = r["difference"] == "converter-only-http" ? "minimal-host-not-compared" : "same-converters-build";
-            (string Obligation, AgreeRun[] Runs)[] checks = refuse
-                ? [("differing-refused", [runs[0]]), ("patch-held-refused", [runs[1]]), ("error-names-type-and-descriptions", runs)]
-                : [(built, runs)];
-            string? failed = null;
-            foreach (var (o, mine) in checks)
-            {
-                var f = await r.Check(o, refuse ? Baseline.Refusal : Baseline.Docs("src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says"), async c =>
-                {
-                    foreach (var a in mine)
-                        if ((refuse ? await a.Refusal(c, r, en, names: o == "error-names-type-and-descriptions") : await a.Built(c, r, en)) is { } fail) return fail;
-                    return null;
-                });
-                failed ??= f;
-            }
-            return failed;
-        }
-
-        /// <summary>A naming policy no row sets: the minimal-API options' names then differ from MVC's whatever the row says.</summary>
-        sealed class PrefixPolicy : JsonNamingPolicy { public override string ConvertName(string name) => "h_" + name; }
-
-        /// <summary>One host of C16: its document or the exception building it threw, judged by <see cref="Refusal"/> or <see cref="Built"/>.</summary>
-        sealed record AgreeRun(bool Patch, Type Type, HostCfg Cfg, List<string> Sides, string? Down, JsonNode? Doc, Exception? Failed, string? Name)
-        {
-            string Said => (Patch ? CoordPConverter.Schema() : CoordConverter.Schema()).ToJsonString();
-            JsonNode? Want => Norm(Patch ? CoordPConverter.Schema() : CoordConverter.Schema());
-
-            /// <summary>
-            /// The document refused with an InvalidOperationException naming the type, and with <paramref name="names"/> what the minimal-API
-            /// options say of it; a refusal ASP.NET alone makes the same way has nothing to check.
-            /// </summary>
-            public async Task<string?> Refusal(Check c, Row r, Entry en, bool names)
-            {
-                if (Down is not null) return Down;
-                if (Failed is null) return $"{(Patch ? "a type held only inside a patch, " : "")}{Type.Name}: the host has controllers, its minimal-API options alone describe it ({Want!.ToJsonString()}), and the document was built";
-                // not the refusal the claim names: judged against ASP.NET alone
-                if (Failed is not InvalidOperationException || !Failed.Message.Contains($"'{Type}'", StringComparison.Ordinal))
-                    return await Hx.DocRefusedByAspNetAlone(r, en, Cfg, Failed) is null ? null
-                        : $"{(Patch ? "patch-held " : "")}{Type.Name}: the document was refused otherwise than naming the type and what the options say: {Failed.GetType().Name}: {Cut(Failed.Message)}";
-                if (names && !Failed.Message.Contains(Said, StringComparison.Ordinal))
-                    return await Hx.DocRefusedByAspNetAlone(r, en, Cfg, Failed) is null ? null
-                        : $"{(Patch ? "patch-held " : "")}{Type.Name}: the refusal names the type but not what the options say ({Said}): {Cut(Failed.Message)}";
-                c.Note(NoteKeys.Compared, names ? "refused naming the type and the minimal-API options' description" : "refused naming the type");
-                return null;
-            }
-
-            /// <summary>The document built, describing the type as the converter on both option sets, or the minimal-API options alone, says.</summary>
-            public async Task<string?> Built(Check c, Row r, Entry en)
-            {
-                if (Down is not null) return Down;
-                // a document ASP.NET alone refuses the same way has nothing to check (noted there)
-                if (Failed is not null) return await Hx.DocRefusedByAspNetAlone(r, en, Cfg, Failed);
-                foreach (var path in Sides)
-                {
-                    var op = Op(Doc!, path, "post");
-                    if (op is null) return $"document has no POST {path}";
-                    if (BodySchema(Doc!, op) is not JsonObject body) return $"{path}: no request body schema";
-                    var got = body["properties"]?[Name!];
-                    if (got is null) return $"{path}: the body schema has no property {Name} (the minimal-API options' name): {Cut(body.ToJsonString())}";
-                    if (!JsonNode.DeepEquals(Norm(got), Want)) return $"{path}: {Name} is {Cut(got.ToJsonString())}, the converter on both option sets says {Want!.ToJsonString()}";
-                }
-                c.Note(NoteKeys.Compared, $"{Type.Name} described as its converter says");
-                return null;
-            }
-        }
-
-        static async Task<AgreeRun> Agree(Row r, Entry en, bool patch)
-        {
-            var difference = r["difference"];
-            var type = patch ? typeof(CoordP) : typeof(Coord);
-            var dto = patch ? typeof(AgreePatchDto) : typeof(AgreeDto);
-            JsonConverter Converter() => patch ? new CoordPConverter() : new CoordConverter();
-            var cfg = Cfg(r, [patch ? "AgreeP" : "Agree"],
-                b => { if (patch) b.MapPost("/s/agreep/m", (AgreePatchDto body) => body); else b.MapPost("/s/agree/m", (AgreeDto body) => body); },
-                s =>
-                {
-                    s.PostConfigure<HttpJsonOptions>(o =>
-                    {
-                        var x = o.SerializerOptions;
-                        x.Converters.Insert(0, Converter());
-                        switch (difference)
-                        {
-                            case "converter-only-http": break;
-                            case "naming-policy": x.PropertyNamingPolicy = new PrefixPolicy(); break;
-                            case "number-handling": x.NumberHandling = x.NumberHandling == JsonNumberHandling.Strict ? JsonNumberHandling.AllowReadingFromString : JsonNumberHandling.Strict; break;
-                            default: throw new ArgumentException("unknown difference " + difference);
-                        }
-                    });
-                    if (difference != "converter-only-http") s.PostConfigure<MvcJsonOptions>(o => o.JsonSerializerOptions.Converters.Insert(0, Converter()));
-                });
-            var sides = Sides(r, patch ? "agreep" : "agree");
-            WebApplication app;
-            try { app = await Hx.Start(r, en, cfg); }
-            catch (Exception ex) when (ex is not Probes.Shapes.Sides.InputsNotEquivalent) { return new(patch, type, cfg, sides, "host did not start: " + ex.GetType().Name + ": " + Cut(ex.Message), null, null, null); }
-            await using var _ = app;
-            var name = JsonName(HttpOptions(app), dto, patch ? "P" : "At");
-            try { return new(patch, type, cfg, sides, null, await Hx.Doc(app), null, name); }
-            catch (Exception ex) { return new(patch, type, cfg, sides, null, null, ex, name); }
-        }
-    }
-}
diff --git a/tools/probe/corpus/harness/Shapes.g.cs b/tools/probe/corpus/harness/Shapes.g.cs
deleted file mode 100644
index 786b9c57..00000000
--- a/tools/probe/corpus/harness/Shapes.g.cs
+++ /dev/null
@@ -1,9559 +0,0 @@
-// <auto-generated/> by tools/probe/generators/shapes.cs; probes' shape catalogue. Do not edit.
-#nullable enable
-#pragma warning disable CMTK0014, CS8618, CS1591, CMTK0005, CMTK1000, CMTK0003
-using System.Collections.Immutable;
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.ValueObjects;
-using CodoMetis.TypeKit.ClosedSets;
-using System.Text.Json.Serialization;
-namespace Probes.Shapes;
-public enum PEnum { A, B, C }
-[Flags] public enum PFlags { P = 1, Q = 2, R = 4 }
-public enum ShapeFault { Refused }
-public sealed record PRec { public string A { get; init; } = ""; public int B { get; init; } }
-public sealed partial class PSet : IClosedSet<PSet> { public static readonly PSet Alpha = new(); public static readonly PSet Beta = new(); }
-public readonly partial record struct V_record_struct_string : IValue<string>;
-public readonly partial record struct V_record_struct_Guid : IValue<Guid>;
-public readonly partial record struct V_record_struct_int : IValue<int>;
-public readonly partial record struct V_record_struct_long : IValue<long>;
-public readonly partial record struct V_record_struct_byte : IValue<byte>;
-public readonly partial record struct V_record_struct_ulong : IValue<ulong>;
-public readonly partial record struct V_record_struct_decimal : IValue<decimal>;
-public readonly partial record struct V_record_struct_double : IValue<double>;
-public readonly partial record struct V_record_struct_bool : IValue<bool>;
-public readonly partial record struct V_record_struct_char : IValue<char>;
-public readonly partial record struct V_record_struct_DateTime : IValue<DateTime>;
-public readonly partial record struct V_record_struct_DateTimeOffset : IValue<DateTimeOffset>;
-public readonly partial record struct V_record_struct_DateOnly : IValue<DateOnly>;
-public readonly partial record struct V_record_struct_TimeOnly : IValue<TimeOnly>;
-public readonly partial record struct V_record_struct_TimeSpan : IValue<TimeSpan>;
-public readonly partial record struct V_record_struct_enum : IValue<PEnum>;
-public readonly partial record struct V_record_struct_flags_enum : IValue<PFlags>;
-public readonly partial record struct V_record_struct_Uri : IValue<Uri>;
-public readonly partial record struct V_record_struct_NodaTime_Instant : IValue<global::NodaTime.Instant>;
-public readonly partial record struct V_record_struct_own_record_class : IValue<PRec>;
-public sealed partial record class V_sealed_record_class_string : IValue<string>;
-public sealed partial record class V_sealed_record_class_Guid : IValue<Guid>;
-public sealed partial record class V_sealed_record_class_int : IValue<int>;
-public sealed partial record class V_sealed_record_class_long : IValue<long>;
-public sealed partial record class V_sealed_record_class_byte : IValue<byte>;
-public sealed partial record class V_sealed_record_class_ulong : IValue<ulong>;
-public sealed partial record class V_sealed_record_class_decimal : IValue<decimal>;
-public sealed partial record class V_sealed_record_class_double : IValue<double>;
-public sealed partial record class V_sealed_record_class_bool : IValue<bool>;
-public sealed partial record class V_sealed_record_class_char : IValue<char>;
-public sealed partial record class V_sealed_record_class_DateTime : IValue<DateTime>;
-public sealed partial record class V_sealed_record_class_DateTimeOffset : IValue<DateTimeOffset>;
-public sealed partial record class V_sealed_record_class_DateOnly : IValue<DateOnly>;
-public sealed partial record class V_sealed_record_class_TimeOnly : IValue<TimeOnly>;
-public sealed partial record class V_sealed_record_class_TimeSpan : IValue<TimeSpan>;
-public sealed partial record class V_sealed_record_class_enum : IValue<PEnum>;
-public sealed partial record class V_sealed_record_class_flags_enum : IValue<PFlags>;
-public sealed partial record class V_sealed_record_class_Uri : IValue<Uri>;
-public sealed partial record class V_sealed_record_class_NodaTime_Instant : IValue<global::NodaTime.Instant>;
-public sealed partial record class V_sealed_record_class_own_record_class : IValue<PRec>;
-public readonly partial record struct V_validated_struct_string : IValidatedValue<V_validated_struct_string, string, ShapeFault>
-{
-    public static Result<V_validated_struct_string, ShapeFault> Create(string value) =>
-        EqualityComparer<string>.Default.Equals(value, "SECRET-7f3a") ? Result.Error(ShapeFault.Refused) : new V_validated_struct_string(value);
-}
-public readonly partial record struct V_validated_struct_Guid : IValidatedValue<V_validated_struct_Guid, Guid, ShapeFault>
-{
-    public static Result<V_validated_struct_Guid, ShapeFault> Create(Guid value) =>
-        EqualityComparer<Guid>.Default.Equals(value, Guid.Empty) ? Result.Error(ShapeFault.Refused) : new V_validated_struct_Guid(value);
-}
-public readonly partial record struct V_validated_struct_int : IValidatedValue<V_validated_struct_int, int, ShapeFault>
-{
-    public static Result<V_validated_struct_int, ShapeFault> Create(int value) =>
-        EqualityComparer<int>.Default.Equals(value, -1) ? Result.Error(ShapeFault.Refused) : new V_validated_struct_int(value);
-}
-public readonly partial record struct V_validated_struct_long : IValidatedValue<V_validated_struct_long, long, ShapeFault>
-{
-    public static Result<V_validated_struct_long, ShapeFault> Create(long value) =>
-        EqualityComparer<long>.Default.Equals(value, -1L) ? Result.Error(ShapeFault.Refused) : new V_validated_struct_long(value);
-}
-public readonly partial record struct V_validated_struct_byte : IValidatedValue<V_validated_struct_byte, byte, ShapeFault>
-{
-    public static Result<V_validated_struct_byte, ShapeFault> Create(byte value) =>
-        EqualityComparer<byte>.Default.Equals(value, (byte)255) ? Result.Error(ShapeFault.Refused) : new V_validated_struct_byte(value);
-}
-public readonly partial record struct V_validated_struct_ulong : IValidatedValue<V_validated_struct_ulong, ulong, ShapeFault>
-{
-    public static Result<V_validated_struct_ulong, ShapeFault> Create(ulong value) =>
-        EqualityComparer<ulong>.Default.Equals(value, 0UL) ? Result.Error(ShapeFault.Refused) : new V_validated_struct_ulong(value);
-}
-public readonly partial record struct V_validated_struct_decimal : IValidatedValue<V_validated_struct_decimal, decimal, ShapeFault>
-{
-    public static Result<V_validated_struct_decimal, ShapeFault> Create(decimal value) =>
-        EqualityComparer<decimal>.Default.Equals(value, -1m) ? Result.Error(ShapeFault.Refused) : new V_validated_struct_decimal(value);
-}
-public readonly partial record struct V_validated_struct_double : IValidatedValue<V_validated_struct_double, double, ShapeFault>
-{
-    public static Result<V_validated_struct_double, ShapeFault> Create(double value) =>
-        EqualityComparer<double>.Default.Equals(value, -1.0) ? Result.Error(ShapeFault.Refused) : new V_validated_struct_double(value);
-}
-public readonly partial record struct V_validated_struct_bool : IValidatedValue<V_validated_struct_bool, bool, ShapeFault>
-{
-    public static Result<V_validated_struct_bool, ShapeFault> Create(bool value) =>
-        EqualityComparer<bool>.Default.Equals(value, false) ? Result.Error(ShapeFault.Refused) : new V_validated_struct_bool(value);
-}
-public readonly partial record struct V_validated_struct_char : IValidatedValue<V_validated_struct_char, char, ShapeFault>
-{
-    public static Result<V_validated_struct_char, ShapeFault> Create(char value) =>
-        EqualityComparer<char>.Default.Equals(value, 'x') ? Result.Error(ShapeFault.Refused) : new V_validated_struct_char(value);
-}
-public readonly partial record struct V_validated_struct_DateTime : IValidatedValue<V_validated_struct_DateTime, DateTime, ShapeFault>
-{
-    public static Result<V_validated_struct_DateTime, ShapeFault> Create(DateTime value) =>
-        EqualityComparer<DateTime>.Default.Equals(value, DateTime.MinValue) ? Result.Error(ShapeFault.Refused) : new V_validated_struct_DateTime(value);
-}
-public readonly partial record struct V_validated_struct_DateTimeOffset : IValidatedValue<V_validated_struct_DateTimeOffset, DateTimeOffset, ShapeFault>
-{
-    public static Result<V_validated_struct_DateTimeOffset, ShapeFault> Create(DateTimeOffset value) =>
-        EqualityComparer<DateTimeOffset>.Default.Equals(value, DateTimeOffset.MinValue) ? Result.Error(ShapeFault.Refused) : new V_validated_struct_DateTimeOffset(value);
-}
-public readonly partial record struct V_validated_struct_DateOnly : IValidatedValue<V_validated_struct_DateOnly, DateOnly, ShapeFault>
-{
-    public static Result<V_validated_struct_DateOnly, ShapeFault> Create(DateOnly value) =>
-        EqualityComparer<DateOnly>.Default.Equals(value, DateOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V_validated_struct_DateOnly(value);
-}
-public readonly partial record struct V_validated_struct_TimeOnly : IValidatedValue<V_validated_struct_TimeOnly, TimeOnly, ShapeFault>
-{
-    public static Result<V_validated_struct_TimeOnly, ShapeFault> Create(TimeOnly value) =>
-        EqualityComparer<TimeOnly>.Default.Equals(value, TimeOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V_validated_struct_TimeOnly(value);
-}
-public readonly partial record struct V_validated_struct_TimeSpan : IValidatedValue<V_validated_struct_TimeSpan, TimeSpan, ShapeFault>
-{
-    public static Result<V_validated_struct_TimeSpan, ShapeFault> Create(TimeSpan value) =>
-        EqualityComparer<TimeSpan>.Default.Equals(value, TimeSpan.MinValue) ? Result.Error(ShapeFault.Refused) : new V_validated_struct_TimeSpan(value);
-}
-public readonly partial record struct V_validated_struct_enum : IValidatedValue<V_validated_struct_enum, PEnum, ShapeFault>
-{
-    public static Result<V_validated_struct_enum, ShapeFault> Create(PEnum value) =>
-        EqualityComparer<PEnum>.Default.Equals(value, (PEnum)99) ? Result.Error(ShapeFault.Refused) : new V_validated_struct_enum(value);
-}
-public readonly partial record struct V_validated_struct_flags_enum : IValidatedValue<V_validated_struct_flags_enum, PFlags, ShapeFault>
-{
-    public static Result<V_validated_struct_flags_enum, ShapeFault> Create(PFlags value) =>
-        EqualityComparer<PFlags>.Default.Equals(value, (PFlags)0) ? Result.Error(ShapeFault.Refused) : new V_validated_struct_flags_enum(value);
-}
-public readonly partial record struct V_validated_struct_Uri : IValidatedValue<V_validated_struct_Uri, Uri, ShapeFault>
-{
-    public static Result<V_validated_struct_Uri, ShapeFault> Create(Uri value) =>
-        EqualityComparer<Uri>.Default.Equals(value, new Uri("https://example.com/refused")) ? Result.Error(ShapeFault.Refused) : new V_validated_struct_Uri(value);
-}
-public readonly partial record struct V_validated_struct_NodaTime_Instant : IValidatedValue<V_validated_struct_NodaTime_Instant, global::NodaTime.Instant, ShapeFault>
-{
-    public static Result<V_validated_struct_NodaTime_Instant, ShapeFault> Create(global::NodaTime.Instant value) =>
-        EqualityComparer<global::NodaTime.Instant>.Default.Equals(value, global::NodaTime.Instant.MinValue) ? Result.Error(ShapeFault.Refused) : new V_validated_struct_NodaTime_Instant(value);
-}
-public readonly partial record struct V_validated_struct_own_record_class : IValidatedValue<V_validated_struct_own_record_class, PRec, ShapeFault>
-{
-    public static Result<V_validated_struct_own_record_class, ShapeFault> Create(PRec value) =>
-        EqualityComparer<PRec>.Default.Equals(value, new PRec { A = "refused", B = 0 }) ? Result.Error(ShapeFault.Refused) : new V_validated_struct_own_record_class(value);
-}
-public sealed partial record class V_validated_class_string : IValidatedValue<V_validated_class_string, string, ShapeFault>
-{
-    public static Result<V_validated_class_string, ShapeFault> Create(string value) =>
-        EqualityComparer<string>.Default.Equals(value, "SECRET-7f3a") ? Result.Error(ShapeFault.Refused) : new V_validated_class_string(value);
-}
-public sealed partial record class V_validated_class_Guid : IValidatedValue<V_validated_class_Guid, Guid, ShapeFault>
-{
-    public static Result<V_validated_class_Guid, ShapeFault> Create(Guid value) =>
-        EqualityComparer<Guid>.Default.Equals(value, Guid.Empty) ? Result.Error(ShapeFault.Refused) : new V_validated_class_Guid(value);
-}
-public sealed partial record class V_validated_class_int : IValidatedValue<V_validated_class_int, int, ShapeFault>
-{
-    public static Result<V_validated_class_int, ShapeFault> Create(int value) =>
-        EqualityComparer<int>.Default.Equals(value, -1) ? Result.Error(ShapeFault.Refused) : new V_validated_class_int(value);
-}
-public sealed partial record class V_validated_class_long : IValidatedValue<V_validated_class_long, long, ShapeFault>
-{
-    public static Result<V_validated_class_long, ShapeFault> Create(long value) =>
-        EqualityComparer<long>.Default.Equals(value, -1L) ? Result.Error(ShapeFault.Refused) : new V_validated_class_long(value);
-}
-public sealed partial record class V_validated_class_byte : IValidatedValue<V_validated_class_byte, byte, ShapeFault>
-{
-    public static Result<V_validated_class_byte, ShapeFault> Create(byte value) =>
-        EqualityComparer<byte>.Default.Equals(value, (byte)255) ? Result.Error(ShapeFault.Refused) : new V_validated_class_byte(value);
-}
-public sealed partial record class V_validated_class_ulong : IValidatedValue<V_validated_class_ulong, ulong, ShapeFault>
-{
-    public static Result<V_validated_class_ulong, ShapeFault> Create(ulong value) =>
-        EqualityComparer<ulong>.Default.Equals(value, 0UL) ? Result.Error(ShapeFault.Refused) : new V_validated_class_ulong(value);
-}
-public sealed partial record class V_validated_class_decimal : IValidatedValue<V_validated_class_decimal, decimal, ShapeFault>
-{
-    public static Result<V_validated_class_decimal, ShapeFault> Create(decimal value) =>
-        EqualityComparer<decimal>.Default.Equals(value, -1m) ? Result.Error(ShapeFault.Refused) : new V_validated_class_decimal(value);
-}
-public sealed partial record class V_validated_class_double : IValidatedValue<V_validated_class_double, double, ShapeFault>
-{
-    public static Result<V_validated_class_double, ShapeFault> Create(double value) =>
-        EqualityComparer<double>.Default.Equals(value, -1.0) ? Result.Error(ShapeFault.Refused) : new V_validated_class_double(value);
-}
-public sealed partial record class V_validated_class_bool : IValidatedValue<V_validated_class_bool, bool, ShapeFault>
-{
-    public static Result<V_validated_class_bool, ShapeFault> Create(bool value) =>
-        EqualityComparer<bool>.Default.Equals(value, false) ? Result.Error(ShapeFault.Refused) : new V_validated_class_bool(value);
-}
-public sealed partial record class V_validated_class_char : IValidatedValue<V_validated_class_char, char, ShapeFault>
-{
-    public static Result<V_validated_class_char, ShapeFault> Create(char value) =>
-        EqualityComparer<char>.Default.Equals(value, 'x') ? Result.Error(ShapeFault.Refused) : new V_validated_class_char(value);
-}
-public sealed partial record class V_validated_class_DateTime : IValidatedValue<V_validated_class_DateTime, DateTime, ShapeFault>
-{
-    public static Result<V_validated_class_DateTime, ShapeFault> Create(DateTime value) =>
-        EqualityComparer<DateTime>.Default.Equals(value, DateTime.MinValue) ? Result.Error(ShapeFault.Refused) : new V_validated_class_DateTime(value);
-}
-public sealed partial record class V_validated_class_DateTimeOffset : IValidatedValue<V_validated_class_DateTimeOffset, DateTimeOffset, ShapeFault>
-{
-    public static Result<V_validated_class_DateTimeOffset, ShapeFault> Create(DateTimeOffset value) =>
-        EqualityComparer<DateTimeOffset>.Default.Equals(value, DateTimeOffset.MinValue) ? Result.Error(ShapeFault.Refused) : new V_validated_class_DateTimeOffset(value);
-}
-public sealed partial record class V_validated_class_DateOnly : IValidatedValue<V_validated_class_DateOnly, DateOnly, ShapeFault>
-{
-    public static Result<V_validated_class_DateOnly, ShapeFault> Create(DateOnly value) =>
-        EqualityComparer<DateOnly>.Default.Equals(value, DateOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V_validated_class_DateOnly(value);
-}
-public sealed partial record class V_validated_class_TimeOnly : IValidatedValue<V_validated_class_TimeOnly, TimeOnly, ShapeFault>
-{
-    public static Result<V_validated_class_TimeOnly, ShapeFault> Create(TimeOnly value) =>
-        EqualityComparer<TimeOnly>.Default.Equals(value, TimeOnly.MinValue) ? Result.Error(ShapeFault.Refused) : new V_validated_class_TimeOnly(value);
-}
-public sealed partial record class V_validated_class_TimeSpan : IValidatedValue<V_validated_class_TimeSpan, TimeSpan, ShapeFault>
-{
-    public static Result<V_validated_class_TimeSpan, ShapeFault> Create(TimeSpan value) =>
-        EqualityComparer<TimeSpan>.Default.Equals(value, TimeSpan.MinValue) ? Result.Error(ShapeFault.Refused) : new V_validated_class_TimeSpan(value);
-}
-public sealed partial record class V_validated_class_enum : IValidatedValue<V_validated_class_enum, PEnum, ShapeFault>
-{
-    public static Result<V_validated_class_enum, ShapeFault> Create(PEnum value) =>
-        EqualityComparer<PEnum>.Default.Equals(value, (PEnum)99) ? Result.Error(ShapeFault.Refused) : new V_validated_class_enum(value);
-}
-public sealed partial record class V_validated_class_flags_enum : IValidatedValue<V_validated_class_flags_enum, PFlags, ShapeFault>
-{
-    public static Result<V_validated_class_flags_enum, ShapeFault> Create(PFlags value) =>
-        EqualityComparer<PFlags>.Default.Equals(value, (PFlags)0) ? Result.Error(ShapeFault.Refused) : new V_validated_class_flags_enum(value);
-}
-public sealed partial record class V_validated_class_Uri : IValidatedValue<V_validated_class_Uri, Uri, ShapeFault>
-{
-    public static Result<V_validated_class_Uri, ShapeFault> Create(Uri value) =>
-        EqualityComparer<Uri>.Default.Equals(value, new Uri("https://example.com/refused")) ? Result.Error(ShapeFault.Refused) : new V_validated_class_Uri(value);
-}
-public sealed partial record class V_validated_class_NodaTime_Instant : IValidatedValue<V_validated_class_NodaTime_Instant, global::NodaTime.Instant, ShapeFault>
-{
-    public static Result<V_validated_class_NodaTime_Instant, ShapeFault> Create(global::NodaTime.Instant value) =>
-        EqualityComparer<global::NodaTime.Instant>.Default.Equals(value, global::NodaTime.Instant.MinValue) ? Result.Error(ShapeFault.Refused) : new V_validated_class_NodaTime_Instant(value);
-}
-public sealed partial record class V_validated_class_own_record_class : IValidatedValue<V_validated_class_own_record_class, PRec, ShapeFault>
-{
-    public static Result<V_validated_class_own_record_class, ShapeFault> Create(PRec value) =>
-        EqualityComparer<PRec>.Default.Equals(value, new PRec { A = "refused", B = 0 }) ? Result.Error(ShapeFault.Refused) : new V_validated_class_own_record_class(value);
-}
-#nullable disable
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_string), "d")] public abstract class PB_V_record_struct_string { }
-public sealed class PD_V_record_struct_string : PB_V_record_struct_string { public V_record_struct_string Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_Guid), "d")] public abstract class PB_V_record_struct_Guid { }
-public sealed class PD_V_record_struct_Guid : PB_V_record_struct_Guid { public V_record_struct_Guid Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_int), "d")] public abstract class PB_V_record_struct_int { }
-public sealed class PD_V_record_struct_int : PB_V_record_struct_int { public V_record_struct_int Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_long), "d")] public abstract class PB_V_record_struct_long { }
-public sealed class PD_V_record_struct_long : PB_V_record_struct_long { public V_record_struct_long Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_byte), "d")] public abstract class PB_V_record_struct_byte { }
-public sealed class PD_V_record_struct_byte : PB_V_record_struct_byte { public V_record_struct_byte Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_ulong), "d")] public abstract class PB_V_record_struct_ulong { }
-public sealed class PD_V_record_struct_ulong : PB_V_record_struct_ulong { public V_record_struct_ulong Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_decimal), "d")] public abstract class PB_V_record_struct_decimal { }
-public sealed class PD_V_record_struct_decimal : PB_V_record_struct_decimal { public V_record_struct_decimal Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_double), "d")] public abstract class PB_V_record_struct_double { }
-public sealed class PD_V_record_struct_double : PB_V_record_struct_double { public V_record_struct_double Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_bool), "d")] public abstract class PB_V_record_struct_bool { }
-public sealed class PD_V_record_struct_bool : PB_V_record_struct_bool { public V_record_struct_bool Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_char), "d")] public abstract class PB_V_record_struct_char { }
-public sealed class PD_V_record_struct_char : PB_V_record_struct_char { public V_record_struct_char Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_DateTime), "d")] public abstract class PB_V_record_struct_DateTime { }
-public sealed class PD_V_record_struct_DateTime : PB_V_record_struct_DateTime { public V_record_struct_DateTime Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_DateTimeOffset), "d")] public abstract class PB_V_record_struct_DateTimeOffset { }
-public sealed class PD_V_record_struct_DateTimeOffset : PB_V_record_struct_DateTimeOffset { public V_record_struct_DateTimeOffset Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_DateOnly), "d")] public abstract class PB_V_record_struct_DateOnly { }
-public sealed class PD_V_record_struct_DateOnly : PB_V_record_struct_DateOnly { public V_record_struct_DateOnly Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_TimeOnly), "d")] public abstract class PB_V_record_struct_TimeOnly { }
-public sealed class PD_V_record_struct_TimeOnly : PB_V_record_struct_TimeOnly { public V_record_struct_TimeOnly Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_TimeSpan), "d")] public abstract class PB_V_record_struct_TimeSpan { }
-public sealed class PD_V_record_struct_TimeSpan : PB_V_record_struct_TimeSpan { public V_record_struct_TimeSpan Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_enum), "d")] public abstract class PB_V_record_struct_enum { }
-public sealed class PD_V_record_struct_enum : PB_V_record_struct_enum { public V_record_struct_enum Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_flags_enum), "d")] public abstract class PB_V_record_struct_flags_enum { }
-public sealed class PD_V_record_struct_flags_enum : PB_V_record_struct_flags_enum { public V_record_struct_flags_enum Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_Uri), "d")] public abstract class PB_V_record_struct_Uri { }
-public sealed class PD_V_record_struct_Uri : PB_V_record_struct_Uri { public V_record_struct_Uri Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_NodaTime_Instant), "d")] public abstract class PB_V_record_struct_NodaTime_Instant { }
-public sealed class PD_V_record_struct_NodaTime_Instant : PB_V_record_struct_NodaTime_Instant { public V_record_struct_NodaTime_Instant Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_record_struct_own_record_class), "d")] public abstract class PB_V_record_struct_own_record_class { }
-public sealed class PD_V_record_struct_own_record_class : PB_V_record_struct_own_record_class { public V_record_struct_own_record_class Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_string), "d")] public abstract class PB_V_sealed_record_class_string { }
-public sealed class PD_V_sealed_record_class_string : PB_V_sealed_record_class_string { public V_sealed_record_class_string Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_Guid), "d")] public abstract class PB_V_sealed_record_class_Guid { }
-public sealed class PD_V_sealed_record_class_Guid : PB_V_sealed_record_class_Guid { public V_sealed_record_class_Guid Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_int), "d")] public abstract class PB_V_sealed_record_class_int { }
-public sealed class PD_V_sealed_record_class_int : PB_V_sealed_record_class_int { public V_sealed_record_class_int Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_long), "d")] public abstract class PB_V_sealed_record_class_long { }
-public sealed class PD_V_sealed_record_class_long : PB_V_sealed_record_class_long { public V_sealed_record_class_long Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_byte), "d")] public abstract class PB_V_sealed_record_class_byte { }
-public sealed class PD_V_sealed_record_class_byte : PB_V_sealed_record_class_byte { public V_sealed_record_class_byte Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_ulong), "d")] public abstract class PB_V_sealed_record_class_ulong { }
-public sealed class PD_V_sealed_record_class_ulong : PB_V_sealed_record_class_ulong { public V_sealed_record_class_ulong Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_decimal), "d")] public abstract class PB_V_sealed_record_class_decimal { }
-public sealed class PD_V_sealed_record_class_decimal : PB_V_sealed_record_class_decimal { public V_sealed_record_class_decimal Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_double), "d")] public abstract class PB_V_sealed_record_class_double { }
-public sealed class PD_V_sealed_record_class_double : PB_V_sealed_record_class_double { public V_sealed_record_class_double Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_bool), "d")] public abstract class PB_V_sealed_record_class_bool { }
-public sealed class PD_V_sealed_record_class_bool : PB_V_sealed_record_class_bool { public V_sealed_record_class_bool Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_char), "d")] public abstract class PB_V_sealed_record_class_char { }
-public sealed class PD_V_sealed_record_class_char : PB_V_sealed_record_class_char { public V_sealed_record_class_char Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_DateTime), "d")] public abstract class PB_V_sealed_record_class_DateTime { }
-public sealed class PD_V_sealed_record_class_DateTime : PB_V_sealed_record_class_DateTime { public V_sealed_record_class_DateTime Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_DateTimeOffset), "d")] public abstract class PB_V_sealed_record_class_DateTimeOffset { }
-public sealed class PD_V_sealed_record_class_DateTimeOffset : PB_V_sealed_record_class_DateTimeOffset { public V_sealed_record_class_DateTimeOffset Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_DateOnly), "d")] public abstract class PB_V_sealed_record_class_DateOnly { }
-public sealed class PD_V_sealed_record_class_DateOnly : PB_V_sealed_record_class_DateOnly { public V_sealed_record_class_DateOnly Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_TimeOnly), "d")] public abstract class PB_V_sealed_record_class_TimeOnly { }
-public sealed class PD_V_sealed_record_class_TimeOnly : PB_V_sealed_record_class_TimeOnly { public V_sealed_record_class_TimeOnly Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_TimeSpan), "d")] public abstract class PB_V_sealed_record_class_TimeSpan { }
-public sealed class PD_V_sealed_record_class_TimeSpan : PB_V_sealed_record_class_TimeSpan { public V_sealed_record_class_TimeSpan Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_enum), "d")] public abstract class PB_V_sealed_record_class_enum { }
-public sealed class PD_V_sealed_record_class_enum : PB_V_sealed_record_class_enum { public V_sealed_record_class_enum Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_flags_enum), "d")] public abstract class PB_V_sealed_record_class_flags_enum { }
-public sealed class PD_V_sealed_record_class_flags_enum : PB_V_sealed_record_class_flags_enum { public V_sealed_record_class_flags_enum Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_Uri), "d")] public abstract class PB_V_sealed_record_class_Uri { }
-public sealed class PD_V_sealed_record_class_Uri : PB_V_sealed_record_class_Uri { public V_sealed_record_class_Uri Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_NodaTime_Instant), "d")] public abstract class PB_V_sealed_record_class_NodaTime_Instant { }
-public sealed class PD_V_sealed_record_class_NodaTime_Instant : PB_V_sealed_record_class_NodaTime_Instant { public V_sealed_record_class_NodaTime_Instant Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_sealed_record_class_own_record_class), "d")] public abstract class PB_V_sealed_record_class_own_record_class { }
-public sealed class PD_V_sealed_record_class_own_record_class : PB_V_sealed_record_class_own_record_class { public V_sealed_record_class_own_record_class Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_string), "d")] public abstract class PB_V_validated_struct_string { }
-public sealed class PD_V_validated_struct_string : PB_V_validated_struct_string { public V_validated_struct_string Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_Guid), "d")] public abstract class PB_V_validated_struct_Guid { }
-public sealed class PD_V_validated_struct_Guid : PB_V_validated_struct_Guid { public V_validated_struct_Guid Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_int), "d")] public abstract class PB_V_validated_struct_int { }
-public sealed class PD_V_validated_struct_int : PB_V_validated_struct_int { public V_validated_struct_int Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_long), "d")] public abstract class PB_V_validated_struct_long { }
-public sealed class PD_V_validated_struct_long : PB_V_validated_struct_long { public V_validated_struct_long Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_byte), "d")] public abstract class PB_V_validated_struct_byte { }
-public sealed class PD_V_validated_struct_byte : PB_V_validated_struct_byte { public V_validated_struct_byte Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_ulong), "d")] public abstract class PB_V_validated_struct_ulong { }
-public sealed class PD_V_validated_struct_ulong : PB_V_validated_struct_ulong { public V_validated_struct_ulong Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_decimal), "d")] public abstract class PB_V_validated_struct_decimal { }
-public sealed class PD_V_validated_struct_decimal : PB_V_validated_struct_decimal { public V_validated_struct_decimal Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_double), "d")] public abstract class PB_V_validated_struct_double { }
-public sealed class PD_V_validated_struct_double : PB_V_validated_struct_double { public V_validated_struct_double Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_bool), "d")] public abstract class PB_V_validated_struct_bool { }
-public sealed class PD_V_validated_struct_bool : PB_V_validated_struct_bool { public V_validated_struct_bool Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_char), "d")] public abstract class PB_V_validated_struct_char { }
-public sealed class PD_V_validated_struct_char : PB_V_validated_struct_char { public V_validated_struct_char Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_DateTime), "d")] public abstract class PB_V_validated_struct_DateTime { }
-public sealed class PD_V_validated_struct_DateTime : PB_V_validated_struct_DateTime { public V_validated_struct_DateTime Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_DateTimeOffset), "d")] public abstract class PB_V_validated_struct_DateTimeOffset { }
-public sealed class PD_V_validated_struct_DateTimeOffset : PB_V_validated_struct_DateTimeOffset { public V_validated_struct_DateTimeOffset Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_DateOnly), "d")] public abstract class PB_V_validated_struct_DateOnly { }
-public sealed class PD_V_validated_struct_DateOnly : PB_V_validated_struct_DateOnly { public V_validated_struct_DateOnly Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_TimeOnly), "d")] public abstract class PB_V_validated_struct_TimeOnly { }
-public sealed class PD_V_validated_struct_TimeOnly : PB_V_validated_struct_TimeOnly { public V_validated_struct_TimeOnly Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_TimeSpan), "d")] public abstract class PB_V_validated_struct_TimeSpan { }
-public sealed class PD_V_validated_struct_TimeSpan : PB_V_validated_struct_TimeSpan { public V_validated_struct_TimeSpan Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_enum), "d")] public abstract class PB_V_validated_struct_enum { }
-public sealed class PD_V_validated_struct_enum : PB_V_validated_struct_enum { public V_validated_struct_enum Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_flags_enum), "d")] public abstract class PB_V_validated_struct_flags_enum { }
-public sealed class PD_V_validated_struct_flags_enum : PB_V_validated_struct_flags_enum { public V_validated_struct_flags_enum Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_Uri), "d")] public abstract class PB_V_validated_struct_Uri { }
-public sealed class PD_V_validated_struct_Uri : PB_V_validated_struct_Uri { public V_validated_struct_Uri Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_NodaTime_Instant), "d")] public abstract class PB_V_validated_struct_NodaTime_Instant { }
-public sealed class PD_V_validated_struct_NodaTime_Instant : PB_V_validated_struct_NodaTime_Instant { public V_validated_struct_NodaTime_Instant Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_struct_own_record_class), "d")] public abstract class PB_V_validated_struct_own_record_class { }
-public sealed class PD_V_validated_struct_own_record_class : PB_V_validated_struct_own_record_class { public V_validated_struct_own_record_class Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_string), "d")] public abstract class PB_V_validated_class_string { }
-public sealed class PD_V_validated_class_string : PB_V_validated_class_string { public V_validated_class_string Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_Guid), "d")] public abstract class PB_V_validated_class_Guid { }
-public sealed class PD_V_validated_class_Guid : PB_V_validated_class_Guid { public V_validated_class_Guid Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_int), "d")] public abstract class PB_V_validated_class_int { }
-public sealed class PD_V_validated_class_int : PB_V_validated_class_int { public V_validated_class_int Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_long), "d")] public abstract class PB_V_validated_class_long { }
-public sealed class PD_V_validated_class_long : PB_V_validated_class_long { public V_validated_class_long Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_byte), "d")] public abstract class PB_V_validated_class_byte { }
-public sealed class PD_V_validated_class_byte : PB_V_validated_class_byte { public V_validated_class_byte Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_ulong), "d")] public abstract class PB_V_validated_class_ulong { }
-public sealed class PD_V_validated_class_ulong : PB_V_validated_class_ulong { public V_validated_class_ulong Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_decimal), "d")] public abstract class PB_V_validated_class_decimal { }
-public sealed class PD_V_validated_class_decimal : PB_V_validated_class_decimal { public V_validated_class_decimal Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_double), "d")] public abstract class PB_V_validated_class_double { }
-public sealed class PD_V_validated_class_double : PB_V_validated_class_double { public V_validated_class_double Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_bool), "d")] public abstract class PB_V_validated_class_bool { }
-public sealed class PD_V_validated_class_bool : PB_V_validated_class_bool { public V_validated_class_bool Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_char), "d")] public abstract class PB_V_validated_class_char { }
-public sealed class PD_V_validated_class_char : PB_V_validated_class_char { public V_validated_class_char Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_DateTime), "d")] public abstract class PB_V_validated_class_DateTime { }
-public sealed class PD_V_validated_class_DateTime : PB_V_validated_class_DateTime { public V_validated_class_DateTime Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_DateTimeOffset), "d")] public abstract class PB_V_validated_class_DateTimeOffset { }
-public sealed class PD_V_validated_class_DateTimeOffset : PB_V_validated_class_DateTimeOffset { public V_validated_class_DateTimeOffset Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_DateOnly), "d")] public abstract class PB_V_validated_class_DateOnly { }
-public sealed class PD_V_validated_class_DateOnly : PB_V_validated_class_DateOnly { public V_validated_class_DateOnly Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_TimeOnly), "d")] public abstract class PB_V_validated_class_TimeOnly { }
-public sealed class PD_V_validated_class_TimeOnly : PB_V_validated_class_TimeOnly { public V_validated_class_TimeOnly Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_TimeSpan), "d")] public abstract class PB_V_validated_class_TimeSpan { }
-public sealed class PD_V_validated_class_TimeSpan : PB_V_validated_class_TimeSpan { public V_validated_class_TimeSpan Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_enum), "d")] public abstract class PB_V_validated_class_enum { }
-public sealed class PD_V_validated_class_enum : PB_V_validated_class_enum { public V_validated_class_enum Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_flags_enum), "d")] public abstract class PB_V_validated_class_flags_enum { }
-public sealed class PD_V_validated_class_flags_enum : PB_V_validated_class_flags_enum { public V_validated_class_flags_enum Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_Uri), "d")] public abstract class PB_V_validated_class_Uri { }
-public sealed class PD_V_validated_class_Uri : PB_V_validated_class_Uri { public V_validated_class_Uri Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_NodaTime_Instant), "d")] public abstract class PB_V_validated_class_NodaTime_Instant { }
-public sealed class PD_V_validated_class_NodaTime_Instant : PB_V_validated_class_NodaTime_Instant { public V_validated_class_NodaTime_Instant Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_V_validated_class_own_record_class), "d")] public abstract class PB_V_validated_class_own_record_class { }
-public sealed class PD_V_validated_class_own_record_class : PB_V_validated_class_own_record_class { public V_validated_class_own_record_class Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PD_PSet), "d")] public abstract class PB_PSet { }
-public sealed class PD_PSet : PB_PSet { public PSet Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_string), "d")] public abstract class PBP_string { }
-public sealed class PDP_string : PBP_string { public string Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_Guid), "d")] public abstract class PBP_Guid { }
-public sealed class PDP_Guid : PBP_Guid { public Guid Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_int), "d")] public abstract class PBP_int { }
-public sealed class PDP_int : PBP_int { public int Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_long), "d")] public abstract class PBP_long { }
-public sealed class PDP_long : PBP_long { public long Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_byte), "d")] public abstract class PBP_byte { }
-public sealed class PDP_byte : PBP_byte { public byte Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_ulong), "d")] public abstract class PBP_ulong { }
-public sealed class PDP_ulong : PBP_ulong { public ulong Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_decimal), "d")] public abstract class PBP_decimal { }
-public sealed class PDP_decimal : PBP_decimal { public decimal Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_double), "d")] public abstract class PBP_double { }
-public sealed class PDP_double : PBP_double { public double Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_bool), "d")] public abstract class PBP_bool { }
-public sealed class PDP_bool : PBP_bool { public bool Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_char), "d")] public abstract class PBP_char { }
-public sealed class PDP_char : PBP_char { public char Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_DateTime), "d")] public abstract class PBP_DateTime { }
-public sealed class PDP_DateTime : PBP_DateTime { public DateTime Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_DateTimeOffset), "d")] public abstract class PBP_DateTimeOffset { }
-public sealed class PDP_DateTimeOffset : PBP_DateTimeOffset { public DateTimeOffset Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_DateOnly), "d")] public abstract class PBP_DateOnly { }
-public sealed class PDP_DateOnly : PBP_DateOnly { public DateOnly Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_TimeOnly), "d")] public abstract class PBP_TimeOnly { }
-public sealed class PDP_TimeOnly : PBP_TimeOnly { public TimeOnly Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_TimeSpan), "d")] public abstract class PBP_TimeSpan { }
-public sealed class PDP_TimeSpan : PBP_TimeSpan { public TimeSpan Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_enum), "d")] public abstract class PBP_enum { }
-public sealed class PDP_enum : PBP_enum { public PEnum Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_flags_enum), "d")] public abstract class PBP_flags_enum { }
-public sealed class PDP_flags_enum : PBP_flags_enum { public PFlags Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_Uri), "d")] public abstract class PBP_Uri { }
-public sealed class PDP_Uri : PBP_Uri { public Uri Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_NodaTime_Instant), "d")] public abstract class PBP_NodaTime_Instant { }
-public sealed class PDP_NodaTime_Instant : PBP_NodaTime_Instant { public global::NodaTime.Instant Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_own_record_class), "d")] public abstract class PBP_own_record_class { }
-public sealed class PDP_own_record_class : PBP_own_record_class { public PRec Value { get; set; } = default!; }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_Guid_N), "d")] public abstract class PBP_Guid_N { }
-public sealed class PDP_Guid_N : PBP_Guid_N { public Guid? Value { get; set; } }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_int_N), "d")] public abstract class PBP_int_N { }
-public sealed class PDP_int_N : PBP_int_N { public int? Value { get; set; } }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_long_N), "d")] public abstract class PBP_long_N { }
-public sealed class PDP_long_N : PBP_long_N { public long? Value { get; set; } }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_byte_N), "d")] public abstract class PBP_byte_N { }
-public sealed class PDP_byte_N : PBP_byte_N { public byte? Value { get; set; } }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_ulong_N), "d")] public abstract class PBP_ulong_N { }
-public sealed class PDP_ulong_N : PBP_ulong_N { public ulong? Value { get; set; } }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_decimal_N), "d")] public abstract class PBP_decimal_N { }
-public sealed class PDP_decimal_N : PBP_decimal_N { public decimal? Value { get; set; } }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_double_N), "d")] public abstract class PBP_double_N { }
-public sealed class PDP_double_N : PBP_double_N { public double? Value { get; set; } }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_bool_N), "d")] public abstract class PBP_bool_N { }
-public sealed class PDP_bool_N : PBP_bool_N { public bool? Value { get; set; } }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_char_N), "d")] public abstract class PBP_char_N { }
-public sealed class PDP_char_N : PBP_char_N { public char? Value { get; set; } }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_DateTime_N), "d")] public abstract class PBP_DateTime_N { }
-public sealed class PDP_DateTime_N : PBP_DateTime_N { public DateTime? Value { get; set; } }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_DateTimeOffset_N), "d")] public abstract class PBP_DateTimeOffset_N { }
-public sealed class PDP_DateTimeOffset_N : PBP_DateTimeOffset_N { public DateTimeOffset? Value { get; set; } }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_DateOnly_N), "d")] public abstract class PBP_DateOnly_N { }
-public sealed class PDP_DateOnly_N : PBP_DateOnly_N { public DateOnly? Value { get; set; } }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_TimeOnly_N), "d")] public abstract class PBP_TimeOnly_N { }
-public sealed class PDP_TimeOnly_N : PBP_TimeOnly_N { public TimeOnly? Value { get; set; } }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_TimeSpan_N), "d")] public abstract class PBP_TimeSpan_N { }
-public sealed class PDP_TimeSpan_N : PBP_TimeSpan_N { public TimeSpan? Value { get; set; } }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_enum_N), "d")] public abstract class PBP_enum_N { }
-public sealed class PDP_enum_N : PBP_enum_N { public PEnum? Value { get; set; } }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_flags_enum_N), "d")] public abstract class PBP_flags_enum_N { }
-public sealed class PDP_flags_enum_N : PBP_flags_enum_N { public PFlags? Value { get; set; } }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_NodaTime_Instant_N), "d")] public abstract class PBP_NodaTime_Instant_N { }
-public sealed class PDP_NodaTime_Instant_N : PBP_NodaTime_Instant_N { public global::NodaTime.Instant? Value { get; set; } }
-[JsonPolymorphic] [JsonDerivedType(typeof(PDP_string_), "d")] public abstract class PBP_string_ { }
-public sealed class PDP_string_ : PBP_string_ { public string Value { get; set; } = ""; }
-#nullable enable
-public sealed record Entry(string Kind, string Wrapped, Type Vo, Type Plain, Func<object> Valid, Func<object?> RefusedFn, Type PolyBase, Type PolyDerived, Type PolyBasePlain, Type PolyDerivedPlain);
-public static partial class Registry
-{
-    static partial void Fill(List<Entry> e)
-    {
-        e.Add(new Entry("record-struct", "string", typeof(V_record_struct_string), typeof(string), () => "alpha", () => null, typeof(PB_V_record_struct_string), typeof(PD_V_record_struct_string), typeof(PBP_string), typeof(PDP_string)));
-        e.Add(new Entry("record-struct", "Guid", typeof(V_record_struct_Guid), typeof(Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111"), () => null, typeof(PB_V_record_struct_Guid), typeof(PD_V_record_struct_Guid), typeof(PBP_Guid), typeof(PDP_Guid)));
-        e.Add(new Entry("record-struct", "int", typeof(V_record_struct_int), typeof(int), () => 42, () => null, typeof(PB_V_record_struct_int), typeof(PD_V_record_struct_int), typeof(PBP_int), typeof(PDP_int)));
-        e.Add(new Entry("record-struct", "long", typeof(V_record_struct_long), typeof(long), () => 4200000000L, () => null, typeof(PB_V_record_struct_long), typeof(PD_V_record_struct_long), typeof(PBP_long), typeof(PDP_long)));
-        e.Add(new Entry("record-struct", "byte", typeof(V_record_struct_byte), typeof(byte), () => (byte)7, () => null, typeof(PB_V_record_struct_byte), typeof(PD_V_record_struct_byte), typeof(PBP_byte), typeof(PDP_byte)));
-        e.Add(new Entry("record-struct", "ulong", typeof(V_record_struct_ulong), typeof(ulong), () => 4200000000UL, () => null, typeof(PB_V_record_struct_ulong), typeof(PD_V_record_struct_ulong), typeof(PBP_ulong), typeof(PDP_ulong)));
-        e.Add(new Entry("record-struct", "decimal", typeof(V_record_struct_decimal), typeof(decimal), () => 7.80m, () => null, typeof(PB_V_record_struct_decimal), typeof(PD_V_record_struct_decimal), typeof(PBP_decimal), typeof(PDP_decimal)));
-        e.Add(new Entry("record-struct", "double", typeof(V_record_struct_double), typeof(double), () => 1.5, () => null, typeof(PB_V_record_struct_double), typeof(PD_V_record_struct_double), typeof(PBP_double), typeof(PDP_double)));
-        e.Add(new Entry("record-struct", "bool", typeof(V_record_struct_bool), typeof(bool), () => true, () => null, typeof(PB_V_record_struct_bool), typeof(PD_V_record_struct_bool), typeof(PBP_bool), typeof(PDP_bool)));
-        e.Add(new Entry("record-struct", "char", typeof(V_record_struct_char), typeof(char), () => 'a', () => null, typeof(PB_V_record_struct_char), typeof(PD_V_record_struct_char), typeof(PBP_char), typeof(PDP_char)));
-        e.Add(new Entry("record-struct", "DateTime", typeof(V_record_struct_DateTime), typeof(DateTime), () => new DateTime(2026,10,15,8,30,0,DateTimeKind.Utc), () => null, typeof(PB_V_record_struct_DateTime), typeof(PD_V_record_struct_DateTime), typeof(PBP_DateTime), typeof(PDP_DateTime)));
-        e.Add(new Entry("record-struct", "DateTimeOffset", typeof(V_record_struct_DateTimeOffset), typeof(DateTimeOffset), () => new DateTimeOffset(2026,10,15,8,30,0,TimeSpan.Zero), () => null, typeof(PB_V_record_struct_DateTimeOffset), typeof(PD_V_record_struct_DateTimeOffset), typeof(PBP_DateTimeOffset), typeof(PDP_DateTimeOffset)));
-        e.Add(new Entry("record-struct", "DateOnly", typeof(V_record_struct_DateOnly), typeof(DateOnly), () => new DateOnly(2026,10,15), () => null, typeof(PB_V_record_struct_DateOnly), typeof(PD_V_record_struct_DateOnly), typeof(PBP_DateOnly), typeof(PDP_DateOnly)));
-        e.Add(new Entry("record-struct", "TimeOnly", typeof(V_record_struct_TimeOnly), typeof(TimeOnly), () => new TimeOnly(8,30,15), () => null, typeof(PB_V_record_struct_TimeOnly), typeof(PD_V_record_struct_TimeOnly), typeof(PBP_TimeOnly), typeof(PDP_TimeOnly)));
-        e.Add(new Entry("record-struct", "TimeSpan", typeof(V_record_struct_TimeSpan), typeof(TimeSpan), () => TimeSpan.FromMinutes(90), () => null, typeof(PB_V_record_struct_TimeSpan), typeof(PD_V_record_struct_TimeSpan), typeof(PBP_TimeSpan), typeof(PDP_TimeSpan)));
-        e.Add(new Entry("record-struct", "enum", typeof(V_record_struct_enum), typeof(PEnum), () => PEnum.B, () => null, typeof(PB_V_record_struct_enum), typeof(PD_V_record_struct_enum), typeof(PBP_enum), typeof(PDP_enum)));
-        e.Add(new Entry("record-struct", "flags-enum", typeof(V_record_struct_flags_enum), typeof(PFlags), () => PFlags.P | PFlags.Q, () => null, typeof(PB_V_record_struct_flags_enum), typeof(PD_V_record_struct_flags_enum), typeof(PBP_flags_enum), typeof(PDP_flags_enum)));
-        e.Add(new Entry("record-struct", "Uri", typeof(V_record_struct_Uri), typeof(Uri), () => new Uri("https://example.com/a"), () => null, typeof(PB_V_record_struct_Uri), typeof(PD_V_record_struct_Uri), typeof(PBP_Uri), typeof(PDP_Uri)));
-        e.Add(new Entry("record-struct", "NodaTime.Instant", typeof(V_record_struct_NodaTime_Instant), typeof(global::NodaTime.Instant), () => global::NodaTime.Instant.FromUtc(2026,10,15,8,30), () => null, typeof(PB_V_record_struct_NodaTime_Instant), typeof(PD_V_record_struct_NodaTime_Instant), typeof(PBP_NodaTime_Instant), typeof(PDP_NodaTime_Instant)));
-        e.Add(new Entry("record-struct", "own-record-class", typeof(V_record_struct_own_record_class), typeof(PRec), () => new PRec { A = "x", B = 1 }, () => null, typeof(PB_V_record_struct_own_record_class), typeof(PD_V_record_struct_own_record_class), typeof(PBP_own_record_class), typeof(PDP_own_record_class)));
-        e.Add(new Entry("sealed-record-class", "string", typeof(V_sealed_record_class_string), typeof(string), () => "alpha", () => null, typeof(PB_V_sealed_record_class_string), typeof(PD_V_sealed_record_class_string), typeof(PBP_string), typeof(PDP_string)));
-        e.Add(new Entry("sealed-record-class", "Guid", typeof(V_sealed_record_class_Guid), typeof(Guid?), () => Guid.Parse("11111111-1111-1111-1111-111111111111"), () => null, typeof(PB_V_sealed_record_class_Guid), typeof(PD_V_sealed_record_class_Guid), typeof(PBP_Guid_N), typeof(PDP_Guid_N)));
-        e.Add(new Entry("sealed-record-class", "int", typeof(V_sealed_record_class_int), typeof(int?), () => 42, () => null, typeof(PB_V_sealed_record_class_int), typeof(PD_V_sealed_record_class_int), typeof(PBP_int_N), typeof(PDP_int_N)));
-        e.Add(new Entry("sealed-record-class", "long", typeof(V_sealed_record_class_long), typeof(long?), () => 4200000000L, () => null, typeof(PB_V_sealed_record_class_long), typeof(PD_V_sealed_record_class_long), typeof(PBP_long_N), typeof(PDP_long_N)));
-        e.Add(new Entry("sealed-record-class", "byte", typeof(V_sealed_record_class_byte), typeof(byte?), () => (byte)7, () => null, typeof(PB_V_sealed_record_class_byte), typeof(PD_V_sealed_record_class_byte), typeof(PBP_byte_N), typeof(PDP_byte_N)));
-        e.Add(new Entry("sealed-record-class", "ulong", typeof(V_sealed_record_class_ulong), typeof(ulong?), () => 4200000000UL, () => null, typeof(PB_V_sealed_record_class_ulong), typeof(PD_V_sealed_record_class_ulong), typeof(PBP_ulong_N), typeof(PDP_ulong_N)));
-        e.Add(new Entry("sealed-record-class", "decimal", typeof(V_sealed_record_class_decimal), typeof(decimal?), () => 7.80m, () => null, typeof(PB_V_sealed_record_class_decimal), typeof(PD_V_sealed_record_class_decimal), typeof(PBP_decimal_N), typeof(PDP_decimal_N)));
-        e.Add(new Entry("sealed-record-class", "double", typeof(V_sealed_record_class_double), typeof(double?), () => 1.5, () => null, typeof(PB_V_sealed_record_class_double), typeof(PD_V_sealed_record_class_double), typeof(PBP_double_N), typeof(PDP_double_N)));
-        e.Add(new Entry("sealed-record-class", "bool", typeof(V_sealed_record_class_bool), typeof(bool?), () => true, () => null, typeof(PB_V_sealed_record_class_bool), typeof(PD_V_sealed_record_class_bool), typeof(PBP_bool_N), typeof(PDP_bool_N)));
-        e.Add(new Entry("sealed-record-class", "char", typeof(V_sealed_record_class_char), typeof(char?), () => 'a', () => null, typeof(PB_V_sealed_record_class_char), typeof(PD_V_sealed_record_class_char), typeof(PBP_char_N), typeof(PDP_char_N)));
-        e.Add(new Entry("sealed-record-class", "DateTime", typeof(V_sealed_record_class_DateTime), typeof(DateTime?), () => new DateTime(2026,10,15,8,30,0,DateTimeKind.Utc), () => null, typeof(PB_V_sealed_record_class_DateTime), typeof(PD_V_sealed_record_class_DateTime), typeof(PBP_DateTime_N), typeof(PDP_DateTime_N)));
-        e.Add(new Entry("sealed-record-class", "DateTimeOffset", typeof(V_sealed_record_class_DateTimeOffset), typeof(DateTimeOffset?), () => new DateTimeOffset(2026,10,15,8,30,0,TimeSpan.Zero), () => null, typeof(PB_V_sealed_record_class_DateTimeOffset), typeof(PD_V_sealed_record_class_DateTimeOffset), typeof(PBP_DateTimeOffset_N), typeof(PDP_DateTimeOffset_N)));
-        e.Add(new Entry("sealed-record-class", "DateOnly", typeof(V_sealed_record_class_DateOnly), typeof(DateOnly?), () => new DateOnly(2026,10,15), () => null, typeof(PB_V_sealed_record_class_DateOnly), typeof(PD_V_sealed_record_class_DateOnly), typeof(PBP_DateOnly_N), typeof(PDP_DateOnly_N)));
-        e.Add(new Entry("sealed-record-class", "TimeOnly", typeof(V_sealed_record_class_TimeOnly), typeof(TimeOnly?), () => new TimeOnly(8,30,15), () => null, typeof(PB_V_sealed_record_class_TimeOnly), typeof(PD_V_sealed_record_class_TimeOnly), typeof(PBP_TimeOnly_N), typeof(PDP_TimeOnly_N)));
-        e.Add(new Entry("sealed-record-class", "TimeSpan", typeof(V_sealed_record_class_TimeSpan), typeof(TimeSpan?), () => TimeSpan.FromMinutes(90), () => null, typeof(PB_V_sealed_record_class_TimeSpan), typeof(PD_V_sealed_record_class_TimeSpan), typeof(PBP_TimeSpan_N), typeof(PDP_TimeSpan_N)));
-        e.Add(new Entry("sealed-record-class", "enum", typeof(V_sealed_record_class_enum), typeof(PEnum?), () => PEnum.B, () => null, typeof(PB_V_sealed_record_class_enum), typeof(PD_V_sealed_record_class_enum), typeof(PBP_enum_N), typeof(PDP_enum_N)));
-        e.Add(new Entry("sealed-record-class", "flags-enum", typeof(V_sealed_record_class_flags_enum), typeof(PFlags?), () => PFlags.P | PFlags.Q, () => null, typeof(PB_V_sealed_record_class_flags_enum), typeof(PD_V_sealed_record_class_flags_enum), typeof(PBP_flags_enum_N), typeof(PDP_flags_enum_N)));
-        e.Add(new Entry("sealed-record-class", "Uri", typeof(V_sealed_record_class_Uri), typeof(Uri), () => new Uri("https://example.com/a"), () => null, typeof(PB_V_sealed_record_class_Uri), typeof(PD_V_sealed_record_class_Uri), typeof(PBP_Uri), typeof(PDP_Uri)));
-        e.Add(new Entry("sealed-record-class", "NodaTime.Instant", typeof(V_sealed_record_class_NodaTime_Instant), typeof(global::NodaTime.Instant?), () => global::NodaTime.Instant.FromUtc(2026,10,15,8,30), () => null, typeof(PB_V_sealed_record_class_NodaTime_Instant), typeof(PD_V_sealed_record_class_NodaTime_Instant), typeof(PBP_NodaTime_Instant_N), typeof(PDP_NodaTime_Instant_N)));
-        e.Add(new Entry("sealed-record-class", "own-record-class", typeof(V_sealed_record_class_own_record_class), typeof(PRec), () => new PRec { A = "x", B = 1 }, () => null, typeof(PB_V_sealed_record_class_own_record_class), typeof(PD_V_sealed_record_class_own_record_class), typeof(PBP_own_record_class), typeof(PDP_own_record_class)));
-        e.Add(new Entry("validated-struct", "string", typeof(V_validated_struct_string), typeof(string), () => "alpha", () => "SECRET-7f3a", typeof(PB_V_validated_struct_string), typeof(PD_V_validated_struct_string), typeof(PBP_string), typeof(PDP_string)));
-        e.Add(new Entry("validated-struct", "Guid", typeof(V_validated_struct_Guid), typeof(Guid), () => Guid.Parse("11111111-1111-1111-1111-111111111111"), () => Guid.Empty, typeof(PB_V_validated_struct_Guid), typeof(PD_V_validated_struct_Guid), typeof(PBP_Guid), typeof(PDP_Guid)));
-        e.Add(new Entry("validated-struct", "int", typeof(V_validated_struct_int), typeof(int), () => 42, () => -1, typeof(PB_V_validated_struct_int), typeof(PD_V_validated_struct_int), typeof(PBP_int), typeof(PDP_int)));
-        e.Add(new Entry("validated-struct", "long", typeof(V_validated_struct_long), typeof(long), () => 4200000000L, () => -1L, typeof(PB_V_validated_struct_long), typeof(PD_V_validated_struct_long), typeof(PBP_long), typeof(PDP_long)));
-        e.Add(new Entry("validated-struct", "byte", typeof(V_validated_struct_byte), typeof(byte), () => (byte)7, () => (byte)255, typeof(PB_V_validated_struct_byte), typeof(PD_V_validated_struct_byte), typeof(PBP_byte), typeof(PDP_byte)));
-        e.Add(new Entry("validated-struct", "ulong", typeof(V_validated_struct_ulong), typeof(ulong), () => 4200000000UL, () => 0UL, typeof(PB_V_validated_struct_ulong), typeof(PD_V_validated_struct_ulong), typeof(PBP_ulong), typeof(PDP_ulong)));
-        e.Add(new Entry("validated-struct", "decimal", typeof(V_validated_struct_decimal), typeof(decimal), () => 7.80m, () => -1m, typeof(PB_V_validated_struct_decimal), typeof(PD_V_validated_struct_decimal), typeof(PBP_decimal), typeof(PDP_decimal)));
-        e.Add(new Entry("validated-struct", "double", typeof(V_validated_struct_double), typeof(double), () => 1.5, () => -1.0, typeof(PB_V_validated_struct_double), typeof(PD_V_validated_struct_double), typeof(PBP_double), typeof(PDP_double)));
-        e.Add(new Entry("validated-struct", "bool", typeof(V_validated_struct_bool), typeof(bool), () => true, () => false, typeof(PB_V_validated_struct_bool), typeof(PD_V_validated_struct_bool), typeof(PBP_bool), typeof(PDP_bool)));
-        e.Add(new Entry("validated-struct", "char", typeof(V_validated_struct_char), typeof(char), () => 'a', () => 'x', typeof(PB_V_validated_struct_char), typeof(PD_V_validated_struct_char), typeof(PBP_char), typeof(PDP_char)));
-        e.Add(new Entry("validated-struct", "DateTime", typeof(V_validated_struct_DateTime), typeof(DateTime), () => new DateTime(2026,10,15,8,30,0,DateTimeKind.Utc), () => DateTime.MinValue, typeof(PB_V_validated_struct_DateTime), typeof(PD_V_validated_struct_DateTime), typeof(PBP_DateTime), typeof(PDP_DateTime)));
-        e.Add(new Entry("validated-struct", "DateTimeOffset", typeof(V_validated_struct_DateTimeOffset), typeof(DateTimeOffset), () => new DateTimeOffset(2026,10,15,8,30,0,TimeSpan.Zero), () => DateTimeOffset.MinValue, typeof(PB_V_validated_struct_DateTimeOffset), typeof(PD_V_validated_struct_DateTimeOffset), typeof(PBP_DateTimeOffset), typeof(PDP_DateTimeOffset)));
-        e.Add(new Entry("validated-struct", "DateOnly", typeof(V_validated_struct_DateOnly), typeof(DateOnly), () => new DateOnly(2026,10,15), () => DateOnly.MinValue, typeof(PB_V_validated_struct_DateOnly), typeof(PD_V_validated_struct_DateOnly), typeof(PBP_DateOnly), typeof(PDP_DateOnly)));
-        e.Add(new Entry("validated-struct", "TimeOnly", typeof(V_validated_struct_TimeOnly), typeof(TimeOnly), () => new TimeOnly(8,30,15), () => TimeOnly.MinValue, typeof(PB_V_validated_struct_TimeOnly), typeof(PD_V_validated_struct_TimeOnly), typeof(PBP_TimeOnly), typeof(PDP_TimeOnly)));
-        e.Add(new Entry("validated-struct", "TimeSpan", typeof(V_validated_struct_TimeSpan), typeof(TimeSpan), () => TimeSpan.FromMinutes(90), () => TimeSpan.MinValue, typeof(PB_V_validated_struct_TimeSpan), typeof(PD_V_validated_struct_TimeSpan), typeof(PBP_TimeSpan), typeof(PDP_TimeSpan)));
-        e.Add(new Entry("validated-struct", "enum", typeof(V_validated_struct_enum), typeof(PEnum), () => PEnum.B, () => (PEnum)99, typeof(PB_V_validated_struct_enum), typeof(PD_V_validated_struct_enum), typeof(PBP_enum), typeof(PDP_enum)));
-        e.Add(new Entry("validated-struct", "flags-enum", typeof(V_validated_struct_flags_enum), typeof(PFlags), () => PFlags.P | PFlags.Q, () => (PFlags)0, typeof(PB_V_validated_struct_flags_enum), typeof(PD_V_validated_struct_flags_enum), typeof(PBP_flags_enum), typeof(PDP_flags_enum)));
-        e.Add(new Entry("validated-struct", "Uri", typeof(V_validated_struct_Uri), typeof(Uri), () => new Uri("https://example.com/a"), () => new Uri("https://example.com/refused"), typeof(PB_V_validated_struct_Uri), typeof(PD_V_validated_struct_Uri), typeof(PBP_Uri), typeof(PDP_Uri)));
-        e.Add(new Entry("validated-struct", "NodaTime.Instant", typeof(V_validated_struct_NodaTime_Instant), typeof(global::NodaTime.Instant), () => global::NodaTime.Instant.FromUtc(2026,10,15,8,30), () => global::NodaTime.Instant.MinValue, typeof(PB_V_validated_struct_NodaTime_Instant), typeof(PD_V_validated_struct_NodaTime_Instant), typeof(PBP_NodaTime_Instant), typeof(PDP_NodaTime_Instant)));
-        e.Add(new Entry("validated-struct", "own-record-class", typeof(V_validated_struct_own_record_class), typeof(PRec), () => new PRec { A = "x", B = 1 }, () => new PRec { A = "refused", B = 0 }, typeof(PB_V_validated_struct_own_record_class), typeof(PD_V_validated_struct_own_record_class), typeof(PBP_own_record_class), typeof(PDP_own_record_class)));
-        e.Add(new Entry("validated-class", "string", typeof(V_validated_class_string), typeof(string), () => "alpha", () => "SECRET-7f3a", typeof(PB_V_validated_class_string), typeof(PD_V_validated_class_string), typeof(PBP_string), typeof(PDP_string)));
-        e.Add(new Entry("validated-class", "Guid", typeof(V_validated_class_Guid), typeof(Guid?), () => Guid.Parse("11111111-1111-1111-1111-111111111111"), () => Guid.Empty, typeof(PB_V_validated_class_Guid), typeof(PD_V_validated_class_Guid), typeof(PBP_Guid_N), typeof(PDP_Guid_N)));
-        e.Add(new Entry("validated-class", "int", typeof(V_validated_class_int), typeof(int?), () => 42, () => -1, typeof(PB_V_validated_class_int), typeof(PD_V_validated_class_int), typeof(PBP_int_N), typeof(PDP_int_N)));
-        e.Add(new Entry("validated-class", "long", typeof(V_validated_class_long), typeof(long?), () => 4200000000L, () => -1L, typeof(PB_V_validated_class_long), typeof(PD_V_validated_class_long), typeof(PBP_long_N), typeof(PDP_long_N)));
-        e.Add(new Entry("validated-class", "byte", typeof(V_validated_class_byte), typeof(byte?), () => (byte)7, () => (byte)255, typeof(PB_V_validated_class_byte), typeof(PD_V_validated_class_byte), typeof(PBP_byte_N), typeof(PDP_byte_N)));
-        e.Add(new Entry("validated-class", "ulong", typeof(V_validated_class_ulong), typeof(ulong?), () => 4200000000UL, () => 0UL, typeof(PB_V_validated_class_ulong), typeof(PD_V_validated_class_ulong), typeof(PBP_ulong_N), typeof(PDP_ulong_N)));
-        e.Add(new Entry("validated-class", "decimal", typeof(V_validated_class_decimal), typeof(decimal?), () => 7.80m, () => -1m, typeof(PB_V_validated_class_decimal), typeof(PD_V_validated_class_decimal), typeof(PBP_decimal_N), typeof(PDP_decimal_N)));
-        e.Add(new Entry("validated-class", "double", typeof(V_validated_class_double), typeof(double?), () => 1.5, () => -1.0, typeof(PB_V_validated_class_double), typeof(PD_V_validated_class_double), typeof(PBP_double_N), typeof(PDP_double_N)));
-        e.Add(new Entry("validated-class", "bool", typeof(V_validated_class_bool), typeof(bool?), () => true, () => false, typeof(PB_V_validated_class_bool), typeof(PD_V_validated_class_bool), typeof(PBP_bool_N), typeof(PDP_bool_N)));
-        e.Add(new Entry("validated-class", "char", typeof(V_validated_class_char), typeof(char?), () => 'a', () => 'x', typeof(PB_V_validated_class_char), typeof(PD_V_validated_class_char), typeof(PBP_char_N), typeof(PDP_char_N)));
-        e.Add(new Entry("validated-class", "DateTime", typeof(V_validated_class_DateTime), typeof(DateTime?), () => new DateTime(2026,10,15,8,30,0,DateTimeKind.Utc), () => DateTime.MinValue, typeof(PB_V_validated_class_DateTime), typeof(PD_V_validated_class_DateTime), typeof(PBP_DateTime_N), typeof(PDP_DateTime_N)));
-        e.Add(new Entry("validated-class", "DateTimeOffset", typeof(V_validated_class_DateTimeOffset), typeof(DateTimeOffset?), () => new DateTimeOffset(2026,10,15,8,30,0,TimeSpan.Zero), () => DateTimeOffset.MinValue, typeof(PB_V_validated_class_DateTimeOffset), typeof(PD_V_validated_class_DateTimeOffset), typeof(PBP_DateTimeOffset_N), typeof(PDP_DateTimeOffset_N)));
-        e.Add(new Entry("validated-class", "DateOnly", typeof(V_validated_class_DateOnly), typeof(DateOnly?), () => new DateOnly(2026,10,15), () => DateOnly.MinValue, typeof(PB_V_validated_class_DateOnly), typeof(PD_V_validated_class_DateOnly), typeof(PBP_DateOnly_N), typeof(PDP_DateOnly_N)));
-        e.Add(new Entry("validated-class", "TimeOnly", typeof(V_validated_class_TimeOnly), typeof(TimeOnly?), () => new TimeOnly(8,30,15), () => TimeOnly.MinValue, typeof(PB_V_validated_class_TimeOnly), typeof(PD_V_validated_class_TimeOnly), typeof(PBP_TimeOnly_N), typeof(PDP_TimeOnly_N)));
-        e.Add(new Entry("validated-class", "TimeSpan", typeof(V_validated_class_TimeSpan), typeof(TimeSpan?), () => TimeSpan.FromMinutes(90), () => TimeSpan.MinValue, typeof(PB_V_validated_class_TimeSpan), typeof(PD_V_validated_class_TimeSpan), typeof(PBP_TimeSpan_N), typeof(PDP_TimeSpan_N)));
-        e.Add(new Entry("validated-class", "enum", typeof(V_validated_class_enum), typeof(PEnum?), () => PEnum.B, () => (PEnum)99, typeof(PB_V_validated_class_enum), typeof(PD_V_validated_class_enum), typeof(PBP_enum_N), typeof(PDP_enum_N)));
-        e.Add(new Entry("validated-class", "flags-enum", typeof(V_validated_class_flags_enum), typeof(PFlags?), () => PFlags.P | PFlags.Q, () => (PFlags)0, typeof(PB_V_validated_class_flags_enum), typeof(PD_V_validated_class_flags_enum), typeof(PBP_flags_enum_N), typeof(PDP_flags_enum_N)));
-        e.Add(new Entry("validated-class", "Uri", typeof(V_validated_class_Uri), typeof(Uri), () => new Uri("https://example.com/a"), () => new Uri("https://example.com/refused"), typeof(PB_V_validated_class_Uri), typeof(PD_V_validated_class_Uri), typeof(PBP_Uri), typeof(PDP_Uri)));
-        e.Add(new Entry("validated-class", "NodaTime.Instant", typeof(V_validated_class_NodaTime_Instant), typeof(global::NodaTime.Instant?), () => global::NodaTime.Instant.FromUtc(2026,10,15,8,30), () => global::NodaTime.Instant.MinValue, typeof(PB_V_validated_class_NodaTime_Instant), typeof(PD_V_validated_class_NodaTime_Instant), typeof(PBP_NodaTime_Instant_N), typeof(PDP_NodaTime_Instant_N)));
-        e.Add(new Entry("validated-class", "own-record-class", typeof(V_validated_class_own_record_class), typeof(PRec), () => new PRec { A = "x", B = 1 }, () => new PRec { A = "refused", B = 0 }, typeof(PB_V_validated_class_own_record_class), typeof(PD_V_validated_class_own_record_class), typeof(PBP_own_record_class), typeof(PDP_own_record_class)));
-        e.Add(new Entry("closed-set", "-", typeof(PSet), typeof(string), () => "Alpha", () => null, typeof(PB_PSet), typeof(PD_PSet), typeof(PBP_string_), typeof(PDP_string_)));
-    }
-}
-[JsonSourceGenerationOptions]
-[JsonSerializable(typeof(V_record_struct_string))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_string>), TypeInfoPropertyName = "T0")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_string>), TypeInfoPropertyName = "T1")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_string>), TypeInfoPropertyName = "T2")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_string>), TypeInfoPropertyName = "T3")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_string, int>), TypeInfoPropertyName = "T4")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_string?>), TypeInfoPropertyName = "T5")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_string?>), TypeInfoPropertyName = "T6")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_string?>), TypeInfoPropertyName = "T7")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_string?>), TypeInfoPropertyName = "T8")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_string?, int>), TypeInfoPropertyName = "T9")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_string>), TypeInfoPropertyName = "T10")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_string>), TypeInfoPropertyName = "T11")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_string>), TypeInfoPropertyName = "T12")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_string>), TypeInfoPropertyName = "T13")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_string, int>), TypeInfoPropertyName = "T14")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_string>>), TypeInfoPropertyName = "T15")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_string>>), TypeInfoPropertyName = "T16")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_string>>), TypeInfoPropertyName = "T17")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_string>>), TypeInfoPropertyName = "T18")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_string>, int>), TypeInfoPropertyName = "T19")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_string[]>), TypeInfoPropertyName = "T20")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_string[]>), TypeInfoPropertyName = "T21")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_string[]>), TypeInfoPropertyName = "T22")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_string[]>), TypeInfoPropertyName = "T23")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_string[], int>), TypeInfoPropertyName = "T24")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_string>>), TypeInfoPropertyName = "T25")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_string>>), TypeInfoPropertyName = "T26")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_string>>), TypeInfoPropertyName = "T27")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_string>>), TypeInfoPropertyName = "T28")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_string>, int>), TypeInfoPropertyName = "T29")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_string>>), TypeInfoPropertyName = "T30")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_string>>), TypeInfoPropertyName = "T31")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_string>>), TypeInfoPropertyName = "T32")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_string>>), TypeInfoPropertyName = "T33")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_string>, int>), TypeInfoPropertyName = "T34")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_string, int>>), TypeInfoPropertyName = "T35")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_string, int>>), TypeInfoPropertyName = "T36")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_string, int>>), TypeInfoPropertyName = "T37")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_string, int>>), TypeInfoPropertyName = "T38")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_string, int>, int>), TypeInfoPropertyName = "T39")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_string>>), TypeInfoPropertyName = "T40")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_string>>), TypeInfoPropertyName = "T41")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_string>>), TypeInfoPropertyName = "T42")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_string>>), TypeInfoPropertyName = "T43")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_string>, int>), TypeInfoPropertyName = "T44")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_string>), TypeInfoPropertyName = "T45")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_string>), TypeInfoPropertyName = "T46")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_string>), TypeInfoPropertyName = "T47")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_string>), TypeInfoPropertyName = "T48")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_string, int>), TypeInfoPropertyName = "T49")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_string>), TypeInfoPropertyName = "T50")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_string>), TypeInfoPropertyName = "T51")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_string>), TypeInfoPropertyName = "T52")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_string>), TypeInfoPropertyName = "T53")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_string, int>), TypeInfoPropertyName = "T54")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_string>>), TypeInfoPropertyName = "T55")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_string>>), TypeInfoPropertyName = "T56")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_string>>), TypeInfoPropertyName = "T57")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_string>>), TypeInfoPropertyName = "T58")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_string>, int>), TypeInfoPropertyName = "T59")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_string>), TypeInfoPropertyName = "T60")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_string>), TypeInfoPropertyName = "T61")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_string>), TypeInfoPropertyName = "T62")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_string>), TypeInfoPropertyName = "T63")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_string, int>), TypeInfoPropertyName = "T64")]
-[JsonSerializable(typeof(V_record_struct_Guid))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_Guid>), TypeInfoPropertyName = "T65")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_Guid>), TypeInfoPropertyName = "T66")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_Guid>), TypeInfoPropertyName = "T67")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_Guid>), TypeInfoPropertyName = "T68")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_Guid, int>), TypeInfoPropertyName = "T69")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_Guid?>), TypeInfoPropertyName = "T70")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_Guid?>), TypeInfoPropertyName = "T71")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_Guid?>), TypeInfoPropertyName = "T72")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_Guid?>), TypeInfoPropertyName = "T73")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_Guid?, int>), TypeInfoPropertyName = "T74")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_Guid>), TypeInfoPropertyName = "T75")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_Guid>), TypeInfoPropertyName = "T76")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_Guid>), TypeInfoPropertyName = "T77")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_Guid>), TypeInfoPropertyName = "T78")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_Guid, int>), TypeInfoPropertyName = "T79")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_Guid>>), TypeInfoPropertyName = "T80")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_Guid>>), TypeInfoPropertyName = "T81")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_Guid>>), TypeInfoPropertyName = "T82")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_Guid>>), TypeInfoPropertyName = "T83")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_Guid>, int>), TypeInfoPropertyName = "T84")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_Guid[]>), TypeInfoPropertyName = "T85")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_Guid[]>), TypeInfoPropertyName = "T86")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_Guid[]>), TypeInfoPropertyName = "T87")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_Guid[]>), TypeInfoPropertyName = "T88")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_Guid[], int>), TypeInfoPropertyName = "T89")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_Guid>>), TypeInfoPropertyName = "T90")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_Guid>>), TypeInfoPropertyName = "T91")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_Guid>>), TypeInfoPropertyName = "T92")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_Guid>>), TypeInfoPropertyName = "T93")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_Guid>, int>), TypeInfoPropertyName = "T94")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_Guid>>), TypeInfoPropertyName = "T95")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_Guid>>), TypeInfoPropertyName = "T96")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_Guid>>), TypeInfoPropertyName = "T97")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_Guid>>), TypeInfoPropertyName = "T98")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_Guid>, int>), TypeInfoPropertyName = "T99")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_Guid, int>>), TypeInfoPropertyName = "T100")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_Guid, int>>), TypeInfoPropertyName = "T101")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_Guid, int>>), TypeInfoPropertyName = "T102")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_Guid, int>>), TypeInfoPropertyName = "T103")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_Guid, int>, int>), TypeInfoPropertyName = "T104")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_Guid>>), TypeInfoPropertyName = "T105")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_Guid>>), TypeInfoPropertyName = "T106")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_Guid>>), TypeInfoPropertyName = "T107")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_Guid>>), TypeInfoPropertyName = "T108")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_Guid>, int>), TypeInfoPropertyName = "T109")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_Guid>), TypeInfoPropertyName = "T110")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_Guid>), TypeInfoPropertyName = "T111")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_Guid>), TypeInfoPropertyName = "T112")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_Guid>), TypeInfoPropertyName = "T113")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_Guid, int>), TypeInfoPropertyName = "T114")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_Guid>), TypeInfoPropertyName = "T115")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_Guid>), TypeInfoPropertyName = "T116")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_Guid>), TypeInfoPropertyName = "T117")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_Guid>), TypeInfoPropertyName = "T118")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_Guid, int>), TypeInfoPropertyName = "T119")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_Guid>>), TypeInfoPropertyName = "T120")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_Guid>>), TypeInfoPropertyName = "T121")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_Guid>>), TypeInfoPropertyName = "T122")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_Guid>>), TypeInfoPropertyName = "T123")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_Guid>, int>), TypeInfoPropertyName = "T124")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_Guid>), TypeInfoPropertyName = "T125")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_Guid>), TypeInfoPropertyName = "T126")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_Guid>), TypeInfoPropertyName = "T127")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_Guid>), TypeInfoPropertyName = "T128")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_Guid, int>), TypeInfoPropertyName = "T129")]
-[JsonSerializable(typeof(V_record_struct_int))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_int>), TypeInfoPropertyName = "T130")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_int>), TypeInfoPropertyName = "T131")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_int>), TypeInfoPropertyName = "T132")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_int>), TypeInfoPropertyName = "T133")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_int, int>), TypeInfoPropertyName = "T134")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_int?>), TypeInfoPropertyName = "T135")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_int?>), TypeInfoPropertyName = "T136")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_int?>), TypeInfoPropertyName = "T137")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_int?>), TypeInfoPropertyName = "T138")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_int?, int>), TypeInfoPropertyName = "T139")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_int>), TypeInfoPropertyName = "T140")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_int>), TypeInfoPropertyName = "T141")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_int>), TypeInfoPropertyName = "T142")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_int>), TypeInfoPropertyName = "T143")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_int, int>), TypeInfoPropertyName = "T144")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_int>>), TypeInfoPropertyName = "T145")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_int>>), TypeInfoPropertyName = "T146")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_int>>), TypeInfoPropertyName = "T147")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_int>>), TypeInfoPropertyName = "T148")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_int>, int>), TypeInfoPropertyName = "T149")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_int[]>), TypeInfoPropertyName = "T150")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_int[]>), TypeInfoPropertyName = "T151")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_int[]>), TypeInfoPropertyName = "T152")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_int[]>), TypeInfoPropertyName = "T153")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_int[], int>), TypeInfoPropertyName = "T154")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_int>>), TypeInfoPropertyName = "T155")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_int>>), TypeInfoPropertyName = "T156")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_int>>), TypeInfoPropertyName = "T157")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_int>>), TypeInfoPropertyName = "T158")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_int>, int>), TypeInfoPropertyName = "T159")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_int>>), TypeInfoPropertyName = "T160")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_int>>), TypeInfoPropertyName = "T161")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_int>>), TypeInfoPropertyName = "T162")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_int>>), TypeInfoPropertyName = "T163")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_int>, int>), TypeInfoPropertyName = "T164")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_int, int>>), TypeInfoPropertyName = "T165")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_int, int>>), TypeInfoPropertyName = "T166")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_int, int>>), TypeInfoPropertyName = "T167")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_int, int>>), TypeInfoPropertyName = "T168")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_int, int>, int>), TypeInfoPropertyName = "T169")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_int>>), TypeInfoPropertyName = "T170")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_int>>), TypeInfoPropertyName = "T171")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_int>>), TypeInfoPropertyName = "T172")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_int>>), TypeInfoPropertyName = "T173")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_int>, int>), TypeInfoPropertyName = "T174")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_int>), TypeInfoPropertyName = "T175")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_int>), TypeInfoPropertyName = "T176")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_int>), TypeInfoPropertyName = "T177")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_int>), TypeInfoPropertyName = "T178")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_int, int>), TypeInfoPropertyName = "T179")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_int>), TypeInfoPropertyName = "T180")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_int>), TypeInfoPropertyName = "T181")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_int>), TypeInfoPropertyName = "T182")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_int>), TypeInfoPropertyName = "T183")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_int, int>), TypeInfoPropertyName = "T184")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_int>>), TypeInfoPropertyName = "T185")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_int>>), TypeInfoPropertyName = "T186")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_int>>), TypeInfoPropertyName = "T187")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_int>>), TypeInfoPropertyName = "T188")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_int>, int>), TypeInfoPropertyName = "T189")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_int>), TypeInfoPropertyName = "T190")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_int>), TypeInfoPropertyName = "T191")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_int>), TypeInfoPropertyName = "T192")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_int>), TypeInfoPropertyName = "T193")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_int, int>), TypeInfoPropertyName = "T194")]
-[JsonSerializable(typeof(V_record_struct_long))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_long>), TypeInfoPropertyName = "T195")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_long>), TypeInfoPropertyName = "T196")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_long>), TypeInfoPropertyName = "T197")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_long>), TypeInfoPropertyName = "T198")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_long, int>), TypeInfoPropertyName = "T199")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_long?>), TypeInfoPropertyName = "T200")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_long?>), TypeInfoPropertyName = "T201")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_long?>), TypeInfoPropertyName = "T202")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_long?>), TypeInfoPropertyName = "T203")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_long?, int>), TypeInfoPropertyName = "T204")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_long>), TypeInfoPropertyName = "T205")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_long>), TypeInfoPropertyName = "T206")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_long>), TypeInfoPropertyName = "T207")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_long>), TypeInfoPropertyName = "T208")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_long, int>), TypeInfoPropertyName = "T209")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_long>>), TypeInfoPropertyName = "T210")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_long>>), TypeInfoPropertyName = "T211")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_long>>), TypeInfoPropertyName = "T212")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_long>>), TypeInfoPropertyName = "T213")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_long>, int>), TypeInfoPropertyName = "T214")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_long[]>), TypeInfoPropertyName = "T215")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_long[]>), TypeInfoPropertyName = "T216")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_long[]>), TypeInfoPropertyName = "T217")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_long[]>), TypeInfoPropertyName = "T218")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_long[], int>), TypeInfoPropertyName = "T219")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_long>>), TypeInfoPropertyName = "T220")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_long>>), TypeInfoPropertyName = "T221")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_long>>), TypeInfoPropertyName = "T222")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_long>>), TypeInfoPropertyName = "T223")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_long>, int>), TypeInfoPropertyName = "T224")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_long>>), TypeInfoPropertyName = "T225")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_long>>), TypeInfoPropertyName = "T226")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_long>>), TypeInfoPropertyName = "T227")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_long>>), TypeInfoPropertyName = "T228")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_long>, int>), TypeInfoPropertyName = "T229")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_long, int>>), TypeInfoPropertyName = "T230")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_long, int>>), TypeInfoPropertyName = "T231")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_long, int>>), TypeInfoPropertyName = "T232")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_long, int>>), TypeInfoPropertyName = "T233")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_long, int>, int>), TypeInfoPropertyName = "T234")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_long>>), TypeInfoPropertyName = "T235")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_long>>), TypeInfoPropertyName = "T236")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_long>>), TypeInfoPropertyName = "T237")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_long>>), TypeInfoPropertyName = "T238")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_long>, int>), TypeInfoPropertyName = "T239")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_long>), TypeInfoPropertyName = "T240")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_long>), TypeInfoPropertyName = "T241")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_long>), TypeInfoPropertyName = "T242")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_long>), TypeInfoPropertyName = "T243")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_long, int>), TypeInfoPropertyName = "T244")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_long>), TypeInfoPropertyName = "T245")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_long>), TypeInfoPropertyName = "T246")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_long>), TypeInfoPropertyName = "T247")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_long>), TypeInfoPropertyName = "T248")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_long, int>), TypeInfoPropertyName = "T249")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_long>>), TypeInfoPropertyName = "T250")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_long>>), TypeInfoPropertyName = "T251")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_long>>), TypeInfoPropertyName = "T252")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_long>>), TypeInfoPropertyName = "T253")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_long>, int>), TypeInfoPropertyName = "T254")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_long>), TypeInfoPropertyName = "T255")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_long>), TypeInfoPropertyName = "T256")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_long>), TypeInfoPropertyName = "T257")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_long>), TypeInfoPropertyName = "T258")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_long, int>), TypeInfoPropertyName = "T259")]
-[JsonSerializable(typeof(V_record_struct_byte))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_byte>), TypeInfoPropertyName = "T260")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_byte>), TypeInfoPropertyName = "T261")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_byte>), TypeInfoPropertyName = "T262")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_byte>), TypeInfoPropertyName = "T263")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_byte, int>), TypeInfoPropertyName = "T264")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_byte?>), TypeInfoPropertyName = "T265")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_byte?>), TypeInfoPropertyName = "T266")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_byte?>), TypeInfoPropertyName = "T267")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_byte?>), TypeInfoPropertyName = "T268")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_byte?, int>), TypeInfoPropertyName = "T269")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_byte>), TypeInfoPropertyName = "T270")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_byte>), TypeInfoPropertyName = "T271")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_byte>), TypeInfoPropertyName = "T272")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_byte>), TypeInfoPropertyName = "T273")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_byte, int>), TypeInfoPropertyName = "T274")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_byte>>), TypeInfoPropertyName = "T275")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_byte>>), TypeInfoPropertyName = "T276")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_byte>>), TypeInfoPropertyName = "T277")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_byte>>), TypeInfoPropertyName = "T278")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_byte>, int>), TypeInfoPropertyName = "T279")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_byte[]>), TypeInfoPropertyName = "T280")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_byte[]>), TypeInfoPropertyName = "T281")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_byte[]>), TypeInfoPropertyName = "T282")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_byte[]>), TypeInfoPropertyName = "T283")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_byte[], int>), TypeInfoPropertyName = "T284")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_byte>>), TypeInfoPropertyName = "T285")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_byte>>), TypeInfoPropertyName = "T286")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_byte>>), TypeInfoPropertyName = "T287")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_byte>>), TypeInfoPropertyName = "T288")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_byte>, int>), TypeInfoPropertyName = "T289")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_byte>>), TypeInfoPropertyName = "T290")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_byte>>), TypeInfoPropertyName = "T291")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_byte>>), TypeInfoPropertyName = "T292")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_byte>>), TypeInfoPropertyName = "T293")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_byte>, int>), TypeInfoPropertyName = "T294")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_byte, int>>), TypeInfoPropertyName = "T295")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_byte, int>>), TypeInfoPropertyName = "T296")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_byte, int>>), TypeInfoPropertyName = "T297")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_byte, int>>), TypeInfoPropertyName = "T298")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_byte, int>, int>), TypeInfoPropertyName = "T299")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_byte>>), TypeInfoPropertyName = "T300")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_byte>>), TypeInfoPropertyName = "T301")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_byte>>), TypeInfoPropertyName = "T302")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_byte>>), TypeInfoPropertyName = "T303")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_byte>, int>), TypeInfoPropertyName = "T304")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_byte>), TypeInfoPropertyName = "T305")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_byte>), TypeInfoPropertyName = "T306")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_byte>), TypeInfoPropertyName = "T307")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_byte>), TypeInfoPropertyName = "T308")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_byte, int>), TypeInfoPropertyName = "T309")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_byte>), TypeInfoPropertyName = "T310")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_byte>), TypeInfoPropertyName = "T311")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_byte>), TypeInfoPropertyName = "T312")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_byte>), TypeInfoPropertyName = "T313")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_byte, int>), TypeInfoPropertyName = "T314")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_byte>>), TypeInfoPropertyName = "T315")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_byte>>), TypeInfoPropertyName = "T316")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_byte>>), TypeInfoPropertyName = "T317")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_byte>>), TypeInfoPropertyName = "T318")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_byte>, int>), TypeInfoPropertyName = "T319")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_byte>), TypeInfoPropertyName = "T320")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_byte>), TypeInfoPropertyName = "T321")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_byte>), TypeInfoPropertyName = "T322")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_byte>), TypeInfoPropertyName = "T323")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_byte, int>), TypeInfoPropertyName = "T324")]
-[JsonSerializable(typeof(V_record_struct_ulong))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_ulong>), TypeInfoPropertyName = "T325")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_ulong>), TypeInfoPropertyName = "T326")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_ulong>), TypeInfoPropertyName = "T327")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_ulong>), TypeInfoPropertyName = "T328")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_ulong, int>), TypeInfoPropertyName = "T329")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_ulong?>), TypeInfoPropertyName = "T330")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_ulong?>), TypeInfoPropertyName = "T331")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_ulong?>), TypeInfoPropertyName = "T332")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_ulong?>), TypeInfoPropertyName = "T333")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_ulong?, int>), TypeInfoPropertyName = "T334")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_ulong>), TypeInfoPropertyName = "T335")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_ulong>), TypeInfoPropertyName = "T336")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_ulong>), TypeInfoPropertyName = "T337")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_ulong>), TypeInfoPropertyName = "T338")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_ulong, int>), TypeInfoPropertyName = "T339")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_ulong>>), TypeInfoPropertyName = "T340")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_ulong>>), TypeInfoPropertyName = "T341")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_ulong>>), TypeInfoPropertyName = "T342")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_ulong>>), TypeInfoPropertyName = "T343")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_ulong>, int>), TypeInfoPropertyName = "T344")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_ulong[]>), TypeInfoPropertyName = "T345")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_ulong[]>), TypeInfoPropertyName = "T346")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_ulong[]>), TypeInfoPropertyName = "T347")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_ulong[]>), TypeInfoPropertyName = "T348")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_ulong[], int>), TypeInfoPropertyName = "T349")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_ulong>>), TypeInfoPropertyName = "T350")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_ulong>>), TypeInfoPropertyName = "T351")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_ulong>>), TypeInfoPropertyName = "T352")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_ulong>>), TypeInfoPropertyName = "T353")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_ulong>, int>), TypeInfoPropertyName = "T354")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_ulong>>), TypeInfoPropertyName = "T355")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_ulong>>), TypeInfoPropertyName = "T356")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_ulong>>), TypeInfoPropertyName = "T357")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_ulong>>), TypeInfoPropertyName = "T358")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_ulong>, int>), TypeInfoPropertyName = "T359")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_ulong, int>>), TypeInfoPropertyName = "T360")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_ulong, int>>), TypeInfoPropertyName = "T361")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_ulong, int>>), TypeInfoPropertyName = "T362")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_ulong, int>>), TypeInfoPropertyName = "T363")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_ulong, int>, int>), TypeInfoPropertyName = "T364")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_ulong>>), TypeInfoPropertyName = "T365")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_ulong>>), TypeInfoPropertyName = "T366")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_ulong>>), TypeInfoPropertyName = "T367")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_ulong>>), TypeInfoPropertyName = "T368")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_ulong>, int>), TypeInfoPropertyName = "T369")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_ulong>), TypeInfoPropertyName = "T370")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_ulong>), TypeInfoPropertyName = "T371")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_ulong>), TypeInfoPropertyName = "T372")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_ulong>), TypeInfoPropertyName = "T373")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_ulong, int>), TypeInfoPropertyName = "T374")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_ulong>), TypeInfoPropertyName = "T375")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_ulong>), TypeInfoPropertyName = "T376")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_ulong>), TypeInfoPropertyName = "T377")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_ulong>), TypeInfoPropertyName = "T378")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_ulong, int>), TypeInfoPropertyName = "T379")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_ulong>>), TypeInfoPropertyName = "T380")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_ulong>>), TypeInfoPropertyName = "T381")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_ulong>>), TypeInfoPropertyName = "T382")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_ulong>>), TypeInfoPropertyName = "T383")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_ulong>, int>), TypeInfoPropertyName = "T384")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_ulong>), TypeInfoPropertyName = "T385")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_ulong>), TypeInfoPropertyName = "T386")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_ulong>), TypeInfoPropertyName = "T387")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_ulong>), TypeInfoPropertyName = "T388")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_ulong, int>), TypeInfoPropertyName = "T389")]
-[JsonSerializable(typeof(V_record_struct_decimal))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_decimal>), TypeInfoPropertyName = "T390")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_decimal>), TypeInfoPropertyName = "T391")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_decimal>), TypeInfoPropertyName = "T392")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_decimal>), TypeInfoPropertyName = "T393")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_decimal, int>), TypeInfoPropertyName = "T394")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_decimal?>), TypeInfoPropertyName = "T395")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_decimal?>), TypeInfoPropertyName = "T396")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_decimal?>), TypeInfoPropertyName = "T397")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_decimal?>), TypeInfoPropertyName = "T398")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_decimal?, int>), TypeInfoPropertyName = "T399")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_decimal>), TypeInfoPropertyName = "T400")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_decimal>), TypeInfoPropertyName = "T401")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_decimal>), TypeInfoPropertyName = "T402")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_decimal>), TypeInfoPropertyName = "T403")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_decimal, int>), TypeInfoPropertyName = "T404")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_decimal>>), TypeInfoPropertyName = "T405")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_decimal>>), TypeInfoPropertyName = "T406")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_decimal>>), TypeInfoPropertyName = "T407")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_decimal>>), TypeInfoPropertyName = "T408")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_decimal>, int>), TypeInfoPropertyName = "T409")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_decimal[]>), TypeInfoPropertyName = "T410")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_decimal[]>), TypeInfoPropertyName = "T411")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_decimal[]>), TypeInfoPropertyName = "T412")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_decimal[]>), TypeInfoPropertyName = "T413")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_decimal[], int>), TypeInfoPropertyName = "T414")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_decimal>>), TypeInfoPropertyName = "T415")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_decimal>>), TypeInfoPropertyName = "T416")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_decimal>>), TypeInfoPropertyName = "T417")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_decimal>>), TypeInfoPropertyName = "T418")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_decimal>, int>), TypeInfoPropertyName = "T419")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_decimal>>), TypeInfoPropertyName = "T420")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_decimal>>), TypeInfoPropertyName = "T421")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_decimal>>), TypeInfoPropertyName = "T422")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_decimal>>), TypeInfoPropertyName = "T423")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_decimal>, int>), TypeInfoPropertyName = "T424")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_decimal, int>>), TypeInfoPropertyName = "T425")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_decimal, int>>), TypeInfoPropertyName = "T426")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_decimal, int>>), TypeInfoPropertyName = "T427")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_decimal, int>>), TypeInfoPropertyName = "T428")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_decimal, int>, int>), TypeInfoPropertyName = "T429")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_decimal>>), TypeInfoPropertyName = "T430")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_decimal>>), TypeInfoPropertyName = "T431")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_decimal>>), TypeInfoPropertyName = "T432")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_decimal>>), TypeInfoPropertyName = "T433")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_decimal>, int>), TypeInfoPropertyName = "T434")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_decimal>), TypeInfoPropertyName = "T435")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_decimal>), TypeInfoPropertyName = "T436")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_decimal>), TypeInfoPropertyName = "T437")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_decimal>), TypeInfoPropertyName = "T438")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_decimal, int>), TypeInfoPropertyName = "T439")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_decimal>), TypeInfoPropertyName = "T440")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_decimal>), TypeInfoPropertyName = "T441")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_decimal>), TypeInfoPropertyName = "T442")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_decimal>), TypeInfoPropertyName = "T443")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_decimal, int>), TypeInfoPropertyName = "T444")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_decimal>>), TypeInfoPropertyName = "T445")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_decimal>>), TypeInfoPropertyName = "T446")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_decimal>>), TypeInfoPropertyName = "T447")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_decimal>>), TypeInfoPropertyName = "T448")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_decimal>, int>), TypeInfoPropertyName = "T449")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_decimal>), TypeInfoPropertyName = "T450")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_decimal>), TypeInfoPropertyName = "T451")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_decimal>), TypeInfoPropertyName = "T452")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_decimal>), TypeInfoPropertyName = "T453")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_decimal, int>), TypeInfoPropertyName = "T454")]
-[JsonSerializable(typeof(V_record_struct_double))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_double>), TypeInfoPropertyName = "T455")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_double>), TypeInfoPropertyName = "T456")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_double>), TypeInfoPropertyName = "T457")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_double>), TypeInfoPropertyName = "T458")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_double, int>), TypeInfoPropertyName = "T459")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_double?>), TypeInfoPropertyName = "T460")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_double?>), TypeInfoPropertyName = "T461")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_double?>), TypeInfoPropertyName = "T462")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_double?>), TypeInfoPropertyName = "T463")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_double?, int>), TypeInfoPropertyName = "T464")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_double>), TypeInfoPropertyName = "T465")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_double>), TypeInfoPropertyName = "T466")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_double>), TypeInfoPropertyName = "T467")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_double>), TypeInfoPropertyName = "T468")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_double, int>), TypeInfoPropertyName = "T469")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_double>>), TypeInfoPropertyName = "T470")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_double>>), TypeInfoPropertyName = "T471")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_double>>), TypeInfoPropertyName = "T472")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_double>>), TypeInfoPropertyName = "T473")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_double>, int>), TypeInfoPropertyName = "T474")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_double[]>), TypeInfoPropertyName = "T475")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_double[]>), TypeInfoPropertyName = "T476")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_double[]>), TypeInfoPropertyName = "T477")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_double[]>), TypeInfoPropertyName = "T478")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_double[], int>), TypeInfoPropertyName = "T479")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_double>>), TypeInfoPropertyName = "T480")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_double>>), TypeInfoPropertyName = "T481")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_double>>), TypeInfoPropertyName = "T482")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_double>>), TypeInfoPropertyName = "T483")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_double>, int>), TypeInfoPropertyName = "T484")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_double>>), TypeInfoPropertyName = "T485")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_double>>), TypeInfoPropertyName = "T486")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_double>>), TypeInfoPropertyName = "T487")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_double>>), TypeInfoPropertyName = "T488")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_double>, int>), TypeInfoPropertyName = "T489")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_double, int>>), TypeInfoPropertyName = "T490")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_double, int>>), TypeInfoPropertyName = "T491")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_double, int>>), TypeInfoPropertyName = "T492")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_double, int>>), TypeInfoPropertyName = "T493")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_double, int>, int>), TypeInfoPropertyName = "T494")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_double>>), TypeInfoPropertyName = "T495")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_double>>), TypeInfoPropertyName = "T496")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_double>>), TypeInfoPropertyName = "T497")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_double>>), TypeInfoPropertyName = "T498")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_double>, int>), TypeInfoPropertyName = "T499")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_double>), TypeInfoPropertyName = "T500")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_double>), TypeInfoPropertyName = "T501")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_double>), TypeInfoPropertyName = "T502")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_double>), TypeInfoPropertyName = "T503")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_double, int>), TypeInfoPropertyName = "T504")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_double>), TypeInfoPropertyName = "T505")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_double>), TypeInfoPropertyName = "T506")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_double>), TypeInfoPropertyName = "T507")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_double>), TypeInfoPropertyName = "T508")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_double, int>), TypeInfoPropertyName = "T509")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_double>>), TypeInfoPropertyName = "T510")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_double>>), TypeInfoPropertyName = "T511")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_double>>), TypeInfoPropertyName = "T512")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_double>>), TypeInfoPropertyName = "T513")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_double>, int>), TypeInfoPropertyName = "T514")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_double>), TypeInfoPropertyName = "T515")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_double>), TypeInfoPropertyName = "T516")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_double>), TypeInfoPropertyName = "T517")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_double>), TypeInfoPropertyName = "T518")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_double, int>), TypeInfoPropertyName = "T519")]
-[JsonSerializable(typeof(V_record_struct_bool))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_bool>), TypeInfoPropertyName = "T520")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_bool>), TypeInfoPropertyName = "T521")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_bool>), TypeInfoPropertyName = "T522")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_bool>), TypeInfoPropertyName = "T523")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_bool, int>), TypeInfoPropertyName = "T524")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_bool?>), TypeInfoPropertyName = "T525")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_bool?>), TypeInfoPropertyName = "T526")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_bool?>), TypeInfoPropertyName = "T527")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_bool?>), TypeInfoPropertyName = "T528")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_bool?, int>), TypeInfoPropertyName = "T529")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_bool>), TypeInfoPropertyName = "T530")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_bool>), TypeInfoPropertyName = "T531")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_bool>), TypeInfoPropertyName = "T532")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_bool>), TypeInfoPropertyName = "T533")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_bool, int>), TypeInfoPropertyName = "T534")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_bool>>), TypeInfoPropertyName = "T535")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_bool>>), TypeInfoPropertyName = "T536")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_bool>>), TypeInfoPropertyName = "T537")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_bool>>), TypeInfoPropertyName = "T538")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_bool>, int>), TypeInfoPropertyName = "T539")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_bool[]>), TypeInfoPropertyName = "T540")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_bool[]>), TypeInfoPropertyName = "T541")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_bool[]>), TypeInfoPropertyName = "T542")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_bool[]>), TypeInfoPropertyName = "T543")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_bool[], int>), TypeInfoPropertyName = "T544")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_bool>>), TypeInfoPropertyName = "T545")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_bool>>), TypeInfoPropertyName = "T546")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_bool>>), TypeInfoPropertyName = "T547")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_bool>>), TypeInfoPropertyName = "T548")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_bool>, int>), TypeInfoPropertyName = "T549")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_bool>>), TypeInfoPropertyName = "T550")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_bool>>), TypeInfoPropertyName = "T551")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_bool>>), TypeInfoPropertyName = "T552")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_bool>>), TypeInfoPropertyName = "T553")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_bool>, int>), TypeInfoPropertyName = "T554")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_bool, int>>), TypeInfoPropertyName = "T555")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_bool, int>>), TypeInfoPropertyName = "T556")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_bool, int>>), TypeInfoPropertyName = "T557")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_bool, int>>), TypeInfoPropertyName = "T558")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_bool, int>, int>), TypeInfoPropertyName = "T559")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_bool>>), TypeInfoPropertyName = "T560")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_bool>>), TypeInfoPropertyName = "T561")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_bool>>), TypeInfoPropertyName = "T562")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_bool>>), TypeInfoPropertyName = "T563")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_bool>, int>), TypeInfoPropertyName = "T564")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_bool>), TypeInfoPropertyName = "T565")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_bool>), TypeInfoPropertyName = "T566")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_bool>), TypeInfoPropertyName = "T567")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_bool>), TypeInfoPropertyName = "T568")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_bool, int>), TypeInfoPropertyName = "T569")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_bool>), TypeInfoPropertyName = "T570")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_bool>), TypeInfoPropertyName = "T571")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_bool>), TypeInfoPropertyName = "T572")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_bool>), TypeInfoPropertyName = "T573")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_bool, int>), TypeInfoPropertyName = "T574")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_bool>>), TypeInfoPropertyName = "T575")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_bool>>), TypeInfoPropertyName = "T576")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_bool>>), TypeInfoPropertyName = "T577")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_bool>>), TypeInfoPropertyName = "T578")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_bool>, int>), TypeInfoPropertyName = "T579")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_bool>), TypeInfoPropertyName = "T580")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_bool>), TypeInfoPropertyName = "T581")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_bool>), TypeInfoPropertyName = "T582")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_bool>), TypeInfoPropertyName = "T583")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_bool, int>), TypeInfoPropertyName = "T584")]
-[JsonSerializable(typeof(V_record_struct_char))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_char>), TypeInfoPropertyName = "T585")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_char>), TypeInfoPropertyName = "T586")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_char>), TypeInfoPropertyName = "T587")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_char>), TypeInfoPropertyName = "T588")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_char, int>), TypeInfoPropertyName = "T589")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_char?>), TypeInfoPropertyName = "T590")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_char?>), TypeInfoPropertyName = "T591")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_char?>), TypeInfoPropertyName = "T592")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_char?>), TypeInfoPropertyName = "T593")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_char?, int>), TypeInfoPropertyName = "T594")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_char>), TypeInfoPropertyName = "T595")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_char>), TypeInfoPropertyName = "T596")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_char>), TypeInfoPropertyName = "T597")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_char>), TypeInfoPropertyName = "T598")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_char, int>), TypeInfoPropertyName = "T599")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_char>>), TypeInfoPropertyName = "T600")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_char>>), TypeInfoPropertyName = "T601")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_char>>), TypeInfoPropertyName = "T602")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_char>>), TypeInfoPropertyName = "T603")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_char>, int>), TypeInfoPropertyName = "T604")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_char[]>), TypeInfoPropertyName = "T605")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_char[]>), TypeInfoPropertyName = "T606")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_char[]>), TypeInfoPropertyName = "T607")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_char[]>), TypeInfoPropertyName = "T608")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_char[], int>), TypeInfoPropertyName = "T609")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_char>>), TypeInfoPropertyName = "T610")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_char>>), TypeInfoPropertyName = "T611")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_char>>), TypeInfoPropertyName = "T612")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_char>>), TypeInfoPropertyName = "T613")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_char>, int>), TypeInfoPropertyName = "T614")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_char>>), TypeInfoPropertyName = "T615")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_char>>), TypeInfoPropertyName = "T616")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_char>>), TypeInfoPropertyName = "T617")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_char>>), TypeInfoPropertyName = "T618")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_char>, int>), TypeInfoPropertyName = "T619")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_char, int>>), TypeInfoPropertyName = "T620")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_char, int>>), TypeInfoPropertyName = "T621")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_char, int>>), TypeInfoPropertyName = "T622")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_char, int>>), TypeInfoPropertyName = "T623")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_char, int>, int>), TypeInfoPropertyName = "T624")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_char>>), TypeInfoPropertyName = "T625")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_char>>), TypeInfoPropertyName = "T626")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_char>>), TypeInfoPropertyName = "T627")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_char>>), TypeInfoPropertyName = "T628")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_char>, int>), TypeInfoPropertyName = "T629")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_char>), TypeInfoPropertyName = "T630")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_char>), TypeInfoPropertyName = "T631")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_char>), TypeInfoPropertyName = "T632")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_char>), TypeInfoPropertyName = "T633")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_char, int>), TypeInfoPropertyName = "T634")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_char>), TypeInfoPropertyName = "T635")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_char>), TypeInfoPropertyName = "T636")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_char>), TypeInfoPropertyName = "T637")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_char>), TypeInfoPropertyName = "T638")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_char, int>), TypeInfoPropertyName = "T639")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_char>>), TypeInfoPropertyName = "T640")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_char>>), TypeInfoPropertyName = "T641")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_char>>), TypeInfoPropertyName = "T642")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_char>>), TypeInfoPropertyName = "T643")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_char>, int>), TypeInfoPropertyName = "T644")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_char>), TypeInfoPropertyName = "T645")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_char>), TypeInfoPropertyName = "T646")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_char>), TypeInfoPropertyName = "T647")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_char>), TypeInfoPropertyName = "T648")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_char, int>), TypeInfoPropertyName = "T649")]
-[JsonSerializable(typeof(V_record_struct_DateTime))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_DateTime>), TypeInfoPropertyName = "T650")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_DateTime>), TypeInfoPropertyName = "T651")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_DateTime>), TypeInfoPropertyName = "T652")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_DateTime>), TypeInfoPropertyName = "T653")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_DateTime, int>), TypeInfoPropertyName = "T654")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_DateTime?>), TypeInfoPropertyName = "T655")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_DateTime?>), TypeInfoPropertyName = "T656")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_DateTime?>), TypeInfoPropertyName = "T657")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_DateTime?>), TypeInfoPropertyName = "T658")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_DateTime?, int>), TypeInfoPropertyName = "T659")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_DateTime>), TypeInfoPropertyName = "T660")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_DateTime>), TypeInfoPropertyName = "T661")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_DateTime>), TypeInfoPropertyName = "T662")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_DateTime>), TypeInfoPropertyName = "T663")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_DateTime, int>), TypeInfoPropertyName = "T664")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_DateTime>>), TypeInfoPropertyName = "T665")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_DateTime>>), TypeInfoPropertyName = "T666")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_DateTime>>), TypeInfoPropertyName = "T667")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_DateTime>>), TypeInfoPropertyName = "T668")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_DateTime>, int>), TypeInfoPropertyName = "T669")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_DateTime[]>), TypeInfoPropertyName = "T670")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_DateTime[]>), TypeInfoPropertyName = "T671")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_DateTime[]>), TypeInfoPropertyName = "T672")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_DateTime[]>), TypeInfoPropertyName = "T673")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_DateTime[], int>), TypeInfoPropertyName = "T674")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_DateTime>>), TypeInfoPropertyName = "T675")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_DateTime>>), TypeInfoPropertyName = "T676")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_DateTime>>), TypeInfoPropertyName = "T677")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_DateTime>>), TypeInfoPropertyName = "T678")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_DateTime>, int>), TypeInfoPropertyName = "T679")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_DateTime>>), TypeInfoPropertyName = "T680")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_DateTime>>), TypeInfoPropertyName = "T681")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_DateTime>>), TypeInfoPropertyName = "T682")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_DateTime>>), TypeInfoPropertyName = "T683")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_DateTime>, int>), TypeInfoPropertyName = "T684")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_DateTime, int>>), TypeInfoPropertyName = "T685")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_DateTime, int>>), TypeInfoPropertyName = "T686")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_DateTime, int>>), TypeInfoPropertyName = "T687")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_DateTime, int>>), TypeInfoPropertyName = "T688")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_DateTime, int>, int>), TypeInfoPropertyName = "T689")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_DateTime>>), TypeInfoPropertyName = "T690")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_DateTime>>), TypeInfoPropertyName = "T691")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_DateTime>>), TypeInfoPropertyName = "T692")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_DateTime>>), TypeInfoPropertyName = "T693")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_DateTime>, int>), TypeInfoPropertyName = "T694")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_DateTime>), TypeInfoPropertyName = "T695")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_DateTime>), TypeInfoPropertyName = "T696")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_DateTime>), TypeInfoPropertyName = "T697")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_DateTime>), TypeInfoPropertyName = "T698")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_DateTime, int>), TypeInfoPropertyName = "T699")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_DateTime>), TypeInfoPropertyName = "T700")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_DateTime>), TypeInfoPropertyName = "T701")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_DateTime>), TypeInfoPropertyName = "T702")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_DateTime>), TypeInfoPropertyName = "T703")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_DateTime, int>), TypeInfoPropertyName = "T704")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_DateTime>>), TypeInfoPropertyName = "T705")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_DateTime>>), TypeInfoPropertyName = "T706")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_DateTime>>), TypeInfoPropertyName = "T707")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_DateTime>>), TypeInfoPropertyName = "T708")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_DateTime>, int>), TypeInfoPropertyName = "T709")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_DateTime>), TypeInfoPropertyName = "T710")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_DateTime>), TypeInfoPropertyName = "T711")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_DateTime>), TypeInfoPropertyName = "T712")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_DateTime>), TypeInfoPropertyName = "T713")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_DateTime, int>), TypeInfoPropertyName = "T714")]
-[JsonSerializable(typeof(V_record_struct_DateTimeOffset))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T715")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T716")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T717")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T718")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_DateTimeOffset, int>), TypeInfoPropertyName = "T719")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_DateTimeOffset?>), TypeInfoPropertyName = "T720")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_DateTimeOffset?>), TypeInfoPropertyName = "T721")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_DateTimeOffset?>), TypeInfoPropertyName = "T722")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_DateTimeOffset?>), TypeInfoPropertyName = "T723")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_DateTimeOffset?, int>), TypeInfoPropertyName = "T724")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T725")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T726")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T727")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T728")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_DateTimeOffset, int>), TypeInfoPropertyName = "T729")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T730")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T731")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T732")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T733")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_DateTimeOffset>, int>), TypeInfoPropertyName = "T734")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_DateTimeOffset[]>), TypeInfoPropertyName = "T735")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_DateTimeOffset[]>), TypeInfoPropertyName = "T736")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_DateTimeOffset[]>), TypeInfoPropertyName = "T737")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_DateTimeOffset[]>), TypeInfoPropertyName = "T738")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_DateTimeOffset[], int>), TypeInfoPropertyName = "T739")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T740")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T741")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T742")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T743")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_DateTimeOffset>, int>), TypeInfoPropertyName = "T744")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T745")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T746")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T747")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T748")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_DateTimeOffset>, int>), TypeInfoPropertyName = "T749")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_DateTimeOffset, int>>), TypeInfoPropertyName = "T750")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_DateTimeOffset, int>>), TypeInfoPropertyName = "T751")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_DateTimeOffset, int>>), TypeInfoPropertyName = "T752")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_DateTimeOffset, int>>), TypeInfoPropertyName = "T753")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_DateTimeOffset, int>, int>), TypeInfoPropertyName = "T754")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T755")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T756")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T757")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T758")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_DateTimeOffset>, int>), TypeInfoPropertyName = "T759")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T760")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T761")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T762")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T763")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_DateTimeOffset, int>), TypeInfoPropertyName = "T764")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T765")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T766")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T767")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T768")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_DateTimeOffset, int>), TypeInfoPropertyName = "T769")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T770")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T771")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T772")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_DateTimeOffset>>), TypeInfoPropertyName = "T773")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_DateTimeOffset>, int>), TypeInfoPropertyName = "T774")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T775")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T776")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T777")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_DateTimeOffset>), TypeInfoPropertyName = "T778")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_DateTimeOffset, int>), TypeInfoPropertyName = "T779")]
-[JsonSerializable(typeof(V_record_struct_DateOnly))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_DateOnly>), TypeInfoPropertyName = "T780")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_DateOnly>), TypeInfoPropertyName = "T781")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_DateOnly>), TypeInfoPropertyName = "T782")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_DateOnly>), TypeInfoPropertyName = "T783")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_DateOnly, int>), TypeInfoPropertyName = "T784")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_DateOnly?>), TypeInfoPropertyName = "T785")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_DateOnly?>), TypeInfoPropertyName = "T786")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_DateOnly?>), TypeInfoPropertyName = "T787")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_DateOnly?>), TypeInfoPropertyName = "T788")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_DateOnly?, int>), TypeInfoPropertyName = "T789")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_DateOnly>), TypeInfoPropertyName = "T790")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_DateOnly>), TypeInfoPropertyName = "T791")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_DateOnly>), TypeInfoPropertyName = "T792")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_DateOnly>), TypeInfoPropertyName = "T793")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_DateOnly, int>), TypeInfoPropertyName = "T794")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_DateOnly>>), TypeInfoPropertyName = "T795")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_DateOnly>>), TypeInfoPropertyName = "T796")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_DateOnly>>), TypeInfoPropertyName = "T797")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_DateOnly>>), TypeInfoPropertyName = "T798")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_DateOnly>, int>), TypeInfoPropertyName = "T799")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_DateOnly[]>), TypeInfoPropertyName = "T800")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_DateOnly[]>), TypeInfoPropertyName = "T801")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_DateOnly[]>), TypeInfoPropertyName = "T802")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_DateOnly[]>), TypeInfoPropertyName = "T803")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_DateOnly[], int>), TypeInfoPropertyName = "T804")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_DateOnly>>), TypeInfoPropertyName = "T805")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_DateOnly>>), TypeInfoPropertyName = "T806")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_DateOnly>>), TypeInfoPropertyName = "T807")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_DateOnly>>), TypeInfoPropertyName = "T808")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_DateOnly>, int>), TypeInfoPropertyName = "T809")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_DateOnly>>), TypeInfoPropertyName = "T810")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_DateOnly>>), TypeInfoPropertyName = "T811")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_DateOnly>>), TypeInfoPropertyName = "T812")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_DateOnly>>), TypeInfoPropertyName = "T813")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_DateOnly>, int>), TypeInfoPropertyName = "T814")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_DateOnly, int>>), TypeInfoPropertyName = "T815")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_DateOnly, int>>), TypeInfoPropertyName = "T816")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_DateOnly, int>>), TypeInfoPropertyName = "T817")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_DateOnly, int>>), TypeInfoPropertyName = "T818")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_DateOnly, int>, int>), TypeInfoPropertyName = "T819")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_DateOnly>>), TypeInfoPropertyName = "T820")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_DateOnly>>), TypeInfoPropertyName = "T821")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_DateOnly>>), TypeInfoPropertyName = "T822")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_DateOnly>>), TypeInfoPropertyName = "T823")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_DateOnly>, int>), TypeInfoPropertyName = "T824")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_DateOnly>), TypeInfoPropertyName = "T825")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_DateOnly>), TypeInfoPropertyName = "T826")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_DateOnly>), TypeInfoPropertyName = "T827")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_DateOnly>), TypeInfoPropertyName = "T828")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_DateOnly, int>), TypeInfoPropertyName = "T829")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_DateOnly>), TypeInfoPropertyName = "T830")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_DateOnly>), TypeInfoPropertyName = "T831")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_DateOnly>), TypeInfoPropertyName = "T832")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_DateOnly>), TypeInfoPropertyName = "T833")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_DateOnly, int>), TypeInfoPropertyName = "T834")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_DateOnly>>), TypeInfoPropertyName = "T835")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_DateOnly>>), TypeInfoPropertyName = "T836")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_DateOnly>>), TypeInfoPropertyName = "T837")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_DateOnly>>), TypeInfoPropertyName = "T838")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_DateOnly>, int>), TypeInfoPropertyName = "T839")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_DateOnly>), TypeInfoPropertyName = "T840")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_DateOnly>), TypeInfoPropertyName = "T841")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_DateOnly>), TypeInfoPropertyName = "T842")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_DateOnly>), TypeInfoPropertyName = "T843")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_DateOnly, int>), TypeInfoPropertyName = "T844")]
-[JsonSerializable(typeof(V_record_struct_TimeOnly))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_TimeOnly>), TypeInfoPropertyName = "T845")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_TimeOnly>), TypeInfoPropertyName = "T846")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_TimeOnly>), TypeInfoPropertyName = "T847")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_TimeOnly>), TypeInfoPropertyName = "T848")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_TimeOnly, int>), TypeInfoPropertyName = "T849")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_TimeOnly?>), TypeInfoPropertyName = "T850")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_TimeOnly?>), TypeInfoPropertyName = "T851")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_TimeOnly?>), TypeInfoPropertyName = "T852")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_TimeOnly?>), TypeInfoPropertyName = "T853")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_TimeOnly?, int>), TypeInfoPropertyName = "T854")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_TimeOnly>), TypeInfoPropertyName = "T855")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_TimeOnly>), TypeInfoPropertyName = "T856")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_TimeOnly>), TypeInfoPropertyName = "T857")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_TimeOnly>), TypeInfoPropertyName = "T858")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_TimeOnly, int>), TypeInfoPropertyName = "T859")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T860")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T861")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T862")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T863")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_TimeOnly>, int>), TypeInfoPropertyName = "T864")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_TimeOnly[]>), TypeInfoPropertyName = "T865")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_TimeOnly[]>), TypeInfoPropertyName = "T866")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_TimeOnly[]>), TypeInfoPropertyName = "T867")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_TimeOnly[]>), TypeInfoPropertyName = "T868")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_TimeOnly[], int>), TypeInfoPropertyName = "T869")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T870")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T871")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T872")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T873")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_TimeOnly>, int>), TypeInfoPropertyName = "T874")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T875")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T876")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T877")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T878")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_TimeOnly>, int>), TypeInfoPropertyName = "T879")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_TimeOnly, int>>), TypeInfoPropertyName = "T880")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_TimeOnly, int>>), TypeInfoPropertyName = "T881")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_TimeOnly, int>>), TypeInfoPropertyName = "T882")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_TimeOnly, int>>), TypeInfoPropertyName = "T883")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_TimeOnly, int>, int>), TypeInfoPropertyName = "T884")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T885")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T886")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T887")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T888")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_TimeOnly>, int>), TypeInfoPropertyName = "T889")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_TimeOnly>), TypeInfoPropertyName = "T890")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_TimeOnly>), TypeInfoPropertyName = "T891")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_TimeOnly>), TypeInfoPropertyName = "T892")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_TimeOnly>), TypeInfoPropertyName = "T893")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_TimeOnly, int>), TypeInfoPropertyName = "T894")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_TimeOnly>), TypeInfoPropertyName = "T895")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_TimeOnly>), TypeInfoPropertyName = "T896")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_TimeOnly>), TypeInfoPropertyName = "T897")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_TimeOnly>), TypeInfoPropertyName = "T898")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_TimeOnly, int>), TypeInfoPropertyName = "T899")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T900")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T901")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T902")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_TimeOnly>>), TypeInfoPropertyName = "T903")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_TimeOnly>, int>), TypeInfoPropertyName = "T904")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_TimeOnly>), TypeInfoPropertyName = "T905")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_TimeOnly>), TypeInfoPropertyName = "T906")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_TimeOnly>), TypeInfoPropertyName = "T907")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_TimeOnly>), TypeInfoPropertyName = "T908")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_TimeOnly, int>), TypeInfoPropertyName = "T909")]
-[JsonSerializable(typeof(V_record_struct_TimeSpan))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_TimeSpan>), TypeInfoPropertyName = "T910")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_TimeSpan>), TypeInfoPropertyName = "T911")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_TimeSpan>), TypeInfoPropertyName = "T912")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_TimeSpan>), TypeInfoPropertyName = "T913")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_TimeSpan, int>), TypeInfoPropertyName = "T914")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_TimeSpan?>), TypeInfoPropertyName = "T915")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_TimeSpan?>), TypeInfoPropertyName = "T916")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_TimeSpan?>), TypeInfoPropertyName = "T917")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_TimeSpan?>), TypeInfoPropertyName = "T918")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_TimeSpan?, int>), TypeInfoPropertyName = "T919")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_TimeSpan>), TypeInfoPropertyName = "T920")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_TimeSpan>), TypeInfoPropertyName = "T921")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_TimeSpan>), TypeInfoPropertyName = "T922")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_TimeSpan>), TypeInfoPropertyName = "T923")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_TimeSpan, int>), TypeInfoPropertyName = "T924")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T925")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T926")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T927")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T928")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_TimeSpan>, int>), TypeInfoPropertyName = "T929")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_TimeSpan[]>), TypeInfoPropertyName = "T930")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_TimeSpan[]>), TypeInfoPropertyName = "T931")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_TimeSpan[]>), TypeInfoPropertyName = "T932")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_TimeSpan[]>), TypeInfoPropertyName = "T933")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_TimeSpan[], int>), TypeInfoPropertyName = "T934")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T935")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T936")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T937")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T938")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_TimeSpan>, int>), TypeInfoPropertyName = "T939")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T940")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T941")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T942")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T943")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_TimeSpan>, int>), TypeInfoPropertyName = "T944")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_TimeSpan, int>>), TypeInfoPropertyName = "T945")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_TimeSpan, int>>), TypeInfoPropertyName = "T946")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_TimeSpan, int>>), TypeInfoPropertyName = "T947")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_TimeSpan, int>>), TypeInfoPropertyName = "T948")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_TimeSpan, int>, int>), TypeInfoPropertyName = "T949")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T950")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T951")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T952")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T953")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_TimeSpan>, int>), TypeInfoPropertyName = "T954")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_TimeSpan>), TypeInfoPropertyName = "T955")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_TimeSpan>), TypeInfoPropertyName = "T956")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_TimeSpan>), TypeInfoPropertyName = "T957")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_TimeSpan>), TypeInfoPropertyName = "T958")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_TimeSpan, int>), TypeInfoPropertyName = "T959")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_TimeSpan>), TypeInfoPropertyName = "T960")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_TimeSpan>), TypeInfoPropertyName = "T961")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_TimeSpan>), TypeInfoPropertyName = "T962")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_TimeSpan>), TypeInfoPropertyName = "T963")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_TimeSpan, int>), TypeInfoPropertyName = "T964")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T965")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T966")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T967")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_TimeSpan>>), TypeInfoPropertyName = "T968")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_TimeSpan>, int>), TypeInfoPropertyName = "T969")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_TimeSpan>), TypeInfoPropertyName = "T970")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_TimeSpan>), TypeInfoPropertyName = "T971")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_TimeSpan>), TypeInfoPropertyName = "T972")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_TimeSpan>), TypeInfoPropertyName = "T973")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_TimeSpan, int>), TypeInfoPropertyName = "T974")]
-[JsonSerializable(typeof(V_record_struct_enum))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_enum>), TypeInfoPropertyName = "T975")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_enum>), TypeInfoPropertyName = "T976")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_enum>), TypeInfoPropertyName = "T977")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_enum>), TypeInfoPropertyName = "T978")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_enum, int>), TypeInfoPropertyName = "T979")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_enum?>), TypeInfoPropertyName = "T980")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_enum?>), TypeInfoPropertyName = "T981")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_enum?>), TypeInfoPropertyName = "T982")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_enum?>), TypeInfoPropertyName = "T983")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_enum?, int>), TypeInfoPropertyName = "T984")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_enum>), TypeInfoPropertyName = "T985")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_enum>), TypeInfoPropertyName = "T986")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_enum>), TypeInfoPropertyName = "T987")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_enum>), TypeInfoPropertyName = "T988")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_enum, int>), TypeInfoPropertyName = "T989")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_enum>>), TypeInfoPropertyName = "T990")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_enum>>), TypeInfoPropertyName = "T991")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_enum>>), TypeInfoPropertyName = "T992")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_enum>>), TypeInfoPropertyName = "T993")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_enum>, int>), TypeInfoPropertyName = "T994")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_enum[]>), TypeInfoPropertyName = "T995")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_enum[]>), TypeInfoPropertyName = "T996")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_enum[]>), TypeInfoPropertyName = "T997")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_enum[]>), TypeInfoPropertyName = "T998")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_enum[], int>), TypeInfoPropertyName = "T999")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_enum>>), TypeInfoPropertyName = "T1000")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_enum>>), TypeInfoPropertyName = "T1001")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_enum>>), TypeInfoPropertyName = "T1002")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_enum>>), TypeInfoPropertyName = "T1003")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_enum>, int>), TypeInfoPropertyName = "T1004")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_enum>>), TypeInfoPropertyName = "T1005")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_enum>>), TypeInfoPropertyName = "T1006")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_enum>>), TypeInfoPropertyName = "T1007")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_enum>>), TypeInfoPropertyName = "T1008")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_enum>, int>), TypeInfoPropertyName = "T1009")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_enum, int>>), TypeInfoPropertyName = "T1010")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_enum, int>>), TypeInfoPropertyName = "T1011")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_enum, int>>), TypeInfoPropertyName = "T1012")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_enum, int>>), TypeInfoPropertyName = "T1013")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_enum, int>, int>), TypeInfoPropertyName = "T1014")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_enum>>), TypeInfoPropertyName = "T1015")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_enum>>), TypeInfoPropertyName = "T1016")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_enum>>), TypeInfoPropertyName = "T1017")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_enum>>), TypeInfoPropertyName = "T1018")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_enum>, int>), TypeInfoPropertyName = "T1019")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_enum>), TypeInfoPropertyName = "T1020")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_enum>), TypeInfoPropertyName = "T1021")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_enum>), TypeInfoPropertyName = "T1022")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_enum>), TypeInfoPropertyName = "T1023")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_enum, int>), TypeInfoPropertyName = "T1024")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_enum>), TypeInfoPropertyName = "T1025")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_enum>), TypeInfoPropertyName = "T1026")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_enum>), TypeInfoPropertyName = "T1027")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_enum>), TypeInfoPropertyName = "T1028")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_enum, int>), TypeInfoPropertyName = "T1029")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_enum>>), TypeInfoPropertyName = "T1030")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_enum>>), TypeInfoPropertyName = "T1031")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_enum>>), TypeInfoPropertyName = "T1032")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_enum>>), TypeInfoPropertyName = "T1033")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_enum>, int>), TypeInfoPropertyName = "T1034")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_enum>), TypeInfoPropertyName = "T1035")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_enum>), TypeInfoPropertyName = "T1036")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_enum>), TypeInfoPropertyName = "T1037")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_enum>), TypeInfoPropertyName = "T1038")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_enum, int>), TypeInfoPropertyName = "T1039")]
-[JsonSerializable(typeof(V_record_struct_flags_enum))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_flags_enum>), TypeInfoPropertyName = "T1040")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_flags_enum>), TypeInfoPropertyName = "T1041")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_flags_enum>), TypeInfoPropertyName = "T1042")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_flags_enum>), TypeInfoPropertyName = "T1043")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_flags_enum, int>), TypeInfoPropertyName = "T1044")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_flags_enum?>), TypeInfoPropertyName = "T1045")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_flags_enum?>), TypeInfoPropertyName = "T1046")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_flags_enum?>), TypeInfoPropertyName = "T1047")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_flags_enum?>), TypeInfoPropertyName = "T1048")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_flags_enum?, int>), TypeInfoPropertyName = "T1049")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_flags_enum>), TypeInfoPropertyName = "T1050")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_flags_enum>), TypeInfoPropertyName = "T1051")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_flags_enum>), TypeInfoPropertyName = "T1052")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_flags_enum>), TypeInfoPropertyName = "T1053")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_flags_enum, int>), TypeInfoPropertyName = "T1054")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1055")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1056")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1057")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1058")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_flags_enum>, int>), TypeInfoPropertyName = "T1059")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_flags_enum[]>), TypeInfoPropertyName = "T1060")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_flags_enum[]>), TypeInfoPropertyName = "T1061")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_flags_enum[]>), TypeInfoPropertyName = "T1062")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_flags_enum[]>), TypeInfoPropertyName = "T1063")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_flags_enum[], int>), TypeInfoPropertyName = "T1064")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1065")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1066")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1067")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1068")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_flags_enum>, int>), TypeInfoPropertyName = "T1069")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1070")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1071")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1072")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1073")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_flags_enum>, int>), TypeInfoPropertyName = "T1074")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_flags_enum, int>>), TypeInfoPropertyName = "T1075")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_flags_enum, int>>), TypeInfoPropertyName = "T1076")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_flags_enum, int>>), TypeInfoPropertyName = "T1077")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_flags_enum, int>>), TypeInfoPropertyName = "T1078")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_flags_enum, int>, int>), TypeInfoPropertyName = "T1079")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1080")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1081")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1082")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1083")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_flags_enum>, int>), TypeInfoPropertyName = "T1084")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_flags_enum>), TypeInfoPropertyName = "T1085")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_flags_enum>), TypeInfoPropertyName = "T1086")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_flags_enum>), TypeInfoPropertyName = "T1087")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_flags_enum>), TypeInfoPropertyName = "T1088")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_flags_enum, int>), TypeInfoPropertyName = "T1089")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_flags_enum>), TypeInfoPropertyName = "T1090")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_flags_enum>), TypeInfoPropertyName = "T1091")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_flags_enum>), TypeInfoPropertyName = "T1092")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_flags_enum>), TypeInfoPropertyName = "T1093")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_flags_enum, int>), TypeInfoPropertyName = "T1094")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1095")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1096")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1097")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_flags_enum>>), TypeInfoPropertyName = "T1098")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_flags_enum>, int>), TypeInfoPropertyName = "T1099")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_flags_enum>), TypeInfoPropertyName = "T1100")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_flags_enum>), TypeInfoPropertyName = "T1101")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_flags_enum>), TypeInfoPropertyName = "T1102")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_flags_enum>), TypeInfoPropertyName = "T1103")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_flags_enum, int>), TypeInfoPropertyName = "T1104")]
-[JsonSerializable(typeof(V_record_struct_Uri))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_Uri>), TypeInfoPropertyName = "T1105")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_Uri>), TypeInfoPropertyName = "T1106")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_Uri>), TypeInfoPropertyName = "T1107")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_Uri>), TypeInfoPropertyName = "T1108")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_Uri, int>), TypeInfoPropertyName = "T1109")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_Uri?>), TypeInfoPropertyName = "T1110")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_Uri?>), TypeInfoPropertyName = "T1111")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_Uri?>), TypeInfoPropertyName = "T1112")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_Uri?>), TypeInfoPropertyName = "T1113")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_Uri?, int>), TypeInfoPropertyName = "T1114")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_Uri>), TypeInfoPropertyName = "T1115")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_Uri>), TypeInfoPropertyName = "T1116")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_Uri>), TypeInfoPropertyName = "T1117")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_Uri>), TypeInfoPropertyName = "T1118")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_Uri, int>), TypeInfoPropertyName = "T1119")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_Uri>>), TypeInfoPropertyName = "T1120")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_Uri>>), TypeInfoPropertyName = "T1121")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_Uri>>), TypeInfoPropertyName = "T1122")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_Uri>>), TypeInfoPropertyName = "T1123")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_Uri>, int>), TypeInfoPropertyName = "T1124")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_Uri[]>), TypeInfoPropertyName = "T1125")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_Uri[]>), TypeInfoPropertyName = "T1126")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_Uri[]>), TypeInfoPropertyName = "T1127")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_Uri[]>), TypeInfoPropertyName = "T1128")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_Uri[], int>), TypeInfoPropertyName = "T1129")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_Uri>>), TypeInfoPropertyName = "T1130")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_Uri>>), TypeInfoPropertyName = "T1131")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_Uri>>), TypeInfoPropertyName = "T1132")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_Uri>>), TypeInfoPropertyName = "T1133")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_Uri>, int>), TypeInfoPropertyName = "T1134")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_Uri>>), TypeInfoPropertyName = "T1135")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_Uri>>), TypeInfoPropertyName = "T1136")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_Uri>>), TypeInfoPropertyName = "T1137")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_Uri>>), TypeInfoPropertyName = "T1138")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_Uri>, int>), TypeInfoPropertyName = "T1139")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_Uri, int>>), TypeInfoPropertyName = "T1140")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_Uri, int>>), TypeInfoPropertyName = "T1141")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_Uri, int>>), TypeInfoPropertyName = "T1142")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_Uri, int>>), TypeInfoPropertyName = "T1143")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_Uri, int>, int>), TypeInfoPropertyName = "T1144")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_Uri>>), TypeInfoPropertyName = "T1145")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_Uri>>), TypeInfoPropertyName = "T1146")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_Uri>>), TypeInfoPropertyName = "T1147")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_Uri>>), TypeInfoPropertyName = "T1148")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_Uri>, int>), TypeInfoPropertyName = "T1149")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_Uri>), TypeInfoPropertyName = "T1150")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_Uri>), TypeInfoPropertyName = "T1151")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_Uri>), TypeInfoPropertyName = "T1152")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_Uri>), TypeInfoPropertyName = "T1153")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_Uri, int>), TypeInfoPropertyName = "T1154")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_Uri>), TypeInfoPropertyName = "T1155")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_Uri>), TypeInfoPropertyName = "T1156")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_Uri>), TypeInfoPropertyName = "T1157")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_Uri>), TypeInfoPropertyName = "T1158")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_Uri, int>), TypeInfoPropertyName = "T1159")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_Uri>>), TypeInfoPropertyName = "T1160")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_Uri>>), TypeInfoPropertyName = "T1161")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_Uri>>), TypeInfoPropertyName = "T1162")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_Uri>>), TypeInfoPropertyName = "T1163")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_Uri>, int>), TypeInfoPropertyName = "T1164")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_Uri>), TypeInfoPropertyName = "T1165")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_Uri>), TypeInfoPropertyName = "T1166")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_Uri>), TypeInfoPropertyName = "T1167")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_Uri>), TypeInfoPropertyName = "T1168")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_Uri, int>), TypeInfoPropertyName = "T1169")]
-[JsonSerializable(typeof(V_record_struct_NodaTime_Instant))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1170")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1171")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1172")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1173")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_NodaTime_Instant, int>), TypeInfoPropertyName = "T1174")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T1175")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T1176")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T1177")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T1178")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_NodaTime_Instant?, int>), TypeInfoPropertyName = "T1179")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1180")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1181")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1182")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1183")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_NodaTime_Instant, int>), TypeInfoPropertyName = "T1184")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1185")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1186")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1187")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1188")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_NodaTime_Instant>, int>), TypeInfoPropertyName = "T1189")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_NodaTime_Instant[]>), TypeInfoPropertyName = "T1190")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_NodaTime_Instant[]>), TypeInfoPropertyName = "T1191")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_NodaTime_Instant[]>), TypeInfoPropertyName = "T1192")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_NodaTime_Instant[]>), TypeInfoPropertyName = "T1193")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_NodaTime_Instant[], int>), TypeInfoPropertyName = "T1194")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1195")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1196")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1197")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1198")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_NodaTime_Instant>, int>), TypeInfoPropertyName = "T1199")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1200")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1201")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1202")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1203")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_NodaTime_Instant>, int>), TypeInfoPropertyName = "T1204")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_NodaTime_Instant, int>>), TypeInfoPropertyName = "T1205")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_NodaTime_Instant, int>>), TypeInfoPropertyName = "T1206")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_NodaTime_Instant, int>>), TypeInfoPropertyName = "T1207")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_NodaTime_Instant, int>>), TypeInfoPropertyName = "T1208")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_NodaTime_Instant, int>, int>), TypeInfoPropertyName = "T1209")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1210")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1211")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1212")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1213")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_NodaTime_Instant>, int>), TypeInfoPropertyName = "T1214")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1215")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1216")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1217")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1218")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_NodaTime_Instant, int>), TypeInfoPropertyName = "T1219")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1220")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1221")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1222")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1223")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_NodaTime_Instant, int>), TypeInfoPropertyName = "T1224")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1225")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1226")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1227")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T1228")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_NodaTime_Instant>, int>), TypeInfoPropertyName = "T1229")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1230")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1231")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1232")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_NodaTime_Instant>), TypeInfoPropertyName = "T1233")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_NodaTime_Instant, int>), TypeInfoPropertyName = "T1234")]
-[JsonSerializable(typeof(V_record_struct_own_record_class))]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_own_record_class>), TypeInfoPropertyName = "T1235")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_own_record_class>), TypeInfoPropertyName = "T1236")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_own_record_class>), TypeInfoPropertyName = "T1237")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_own_record_class>), TypeInfoPropertyName = "T1238")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_own_record_class, int>), TypeInfoPropertyName = "T1239")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_own_record_class?>), TypeInfoPropertyName = "T1240")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_own_record_class?>), TypeInfoPropertyName = "T1241")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_own_record_class?>), TypeInfoPropertyName = "T1242")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_own_record_class?>), TypeInfoPropertyName = "T1243")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_own_record_class?, int>), TypeInfoPropertyName = "T1244")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_own_record_class>), TypeInfoPropertyName = "T1245")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_own_record_class>), TypeInfoPropertyName = "T1246")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_own_record_class>), TypeInfoPropertyName = "T1247")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_own_record_class>), TypeInfoPropertyName = "T1248")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_own_record_class, int>), TypeInfoPropertyName = "T1249")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1250")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1251")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1252")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1253")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_own_record_class>, int>), TypeInfoPropertyName = "T1254")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_own_record_class[]>), TypeInfoPropertyName = "T1255")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_own_record_class[]>), TypeInfoPropertyName = "T1256")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_own_record_class[]>), TypeInfoPropertyName = "T1257")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_own_record_class[]>), TypeInfoPropertyName = "T1258")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_own_record_class[], int>), TypeInfoPropertyName = "T1259")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1260")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1261")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1262")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1263")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_own_record_class>, int>), TypeInfoPropertyName = "T1264")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1265")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1266")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1267")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1268")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_own_record_class>, int>), TypeInfoPropertyName = "T1269")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_record_struct_own_record_class, int>>), TypeInfoPropertyName = "T1270")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_record_struct_own_record_class, int>>), TypeInfoPropertyName = "T1271")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_record_struct_own_record_class, int>>), TypeInfoPropertyName = "T1272")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_record_struct_own_record_class, int>>), TypeInfoPropertyName = "T1273")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_record_struct_own_record_class, int>, int>), TypeInfoPropertyName = "T1274")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1275")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1276")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1277")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1278")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_own_record_class>, int>), TypeInfoPropertyName = "T1279")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_own_record_class>), TypeInfoPropertyName = "T1280")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_own_record_class>), TypeInfoPropertyName = "T1281")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_own_record_class>), TypeInfoPropertyName = "T1282")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_own_record_class>), TypeInfoPropertyName = "T1283")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_own_record_class, int>), TypeInfoPropertyName = "T1284")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_own_record_class>), TypeInfoPropertyName = "T1285")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_own_record_class>), TypeInfoPropertyName = "T1286")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_own_record_class>), TypeInfoPropertyName = "T1287")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_own_record_class>), TypeInfoPropertyName = "T1288")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_own_record_class, int>), TypeInfoPropertyName = "T1289")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1290")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1291")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1292")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_record_struct_own_record_class>>), TypeInfoPropertyName = "T1293")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_record_struct_own_record_class>, int>), TypeInfoPropertyName = "T1294")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_record_struct_own_record_class>), TypeInfoPropertyName = "T1295")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_record_struct_own_record_class>), TypeInfoPropertyName = "T1296")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_record_struct_own_record_class>), TypeInfoPropertyName = "T1297")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_record_struct_own_record_class>), TypeInfoPropertyName = "T1298")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_record_struct_own_record_class, int>), TypeInfoPropertyName = "T1299")]
-[JsonSerializable(typeof(V_sealed_record_class_string))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_string>), TypeInfoPropertyName = "T1300")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_string>), TypeInfoPropertyName = "T1301")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_string>), TypeInfoPropertyName = "T1302")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_string>), TypeInfoPropertyName = "T1303")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_string, int>), TypeInfoPropertyName = "T1304")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_string>), TypeInfoPropertyName = "T1305")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_string>), TypeInfoPropertyName = "T1306")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_string>), TypeInfoPropertyName = "T1307")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_string>), TypeInfoPropertyName = "T1308")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_string, int>), TypeInfoPropertyName = "T1309")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_string>>), TypeInfoPropertyName = "T1310")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_string>>), TypeInfoPropertyName = "T1311")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_string>>), TypeInfoPropertyName = "T1312")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_string>>), TypeInfoPropertyName = "T1313")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_string>, int>), TypeInfoPropertyName = "T1314")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_string[]>), TypeInfoPropertyName = "T1315")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_string[]>), TypeInfoPropertyName = "T1316")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_string[]>), TypeInfoPropertyName = "T1317")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_string[]>), TypeInfoPropertyName = "T1318")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_string[], int>), TypeInfoPropertyName = "T1319")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_string>>), TypeInfoPropertyName = "T1320")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_string>>), TypeInfoPropertyName = "T1321")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_string>>), TypeInfoPropertyName = "T1322")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_string>>), TypeInfoPropertyName = "T1323")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_string>, int>), TypeInfoPropertyName = "T1324")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_string>>), TypeInfoPropertyName = "T1325")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_string>>), TypeInfoPropertyName = "T1326")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_string>>), TypeInfoPropertyName = "T1327")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_string>>), TypeInfoPropertyName = "T1328")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_string>, int>), TypeInfoPropertyName = "T1329")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_string, int>>), TypeInfoPropertyName = "T1330")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_string, int>>), TypeInfoPropertyName = "T1331")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_string, int>>), TypeInfoPropertyName = "T1332")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_string, int>>), TypeInfoPropertyName = "T1333")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_string, int>, int>), TypeInfoPropertyName = "T1334")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_string>>), TypeInfoPropertyName = "T1335")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_string>>), TypeInfoPropertyName = "T1336")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_string>>), TypeInfoPropertyName = "T1337")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_string>>), TypeInfoPropertyName = "T1338")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_string>, int>), TypeInfoPropertyName = "T1339")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_string>), TypeInfoPropertyName = "T1340")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_string>), TypeInfoPropertyName = "T1341")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_string>), TypeInfoPropertyName = "T1342")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_string>), TypeInfoPropertyName = "T1343")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_string, int>), TypeInfoPropertyName = "T1344")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_string>), TypeInfoPropertyName = "T1345")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_string>), TypeInfoPropertyName = "T1346")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_string>), TypeInfoPropertyName = "T1347")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_string>), TypeInfoPropertyName = "T1348")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_string, int>), TypeInfoPropertyName = "T1349")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_string>>), TypeInfoPropertyName = "T1350")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_string>>), TypeInfoPropertyName = "T1351")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_string>>), TypeInfoPropertyName = "T1352")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_string>>), TypeInfoPropertyName = "T1353")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_string>, int>), TypeInfoPropertyName = "T1354")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_string>), TypeInfoPropertyName = "T1355")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_string>), TypeInfoPropertyName = "T1356")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_string>), TypeInfoPropertyName = "T1357")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_string>), TypeInfoPropertyName = "T1358")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_string, int>), TypeInfoPropertyName = "T1359")]
-[JsonSerializable(typeof(V_sealed_record_class_Guid))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1360")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1361")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1362")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1363")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_Guid, int>), TypeInfoPropertyName = "T1364")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1365")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1366")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1367")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1368")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_Guid, int>), TypeInfoPropertyName = "T1369")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1370")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1371")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1372")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1373")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_Guid>, int>), TypeInfoPropertyName = "T1374")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_Guid[]>), TypeInfoPropertyName = "T1375")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_Guid[]>), TypeInfoPropertyName = "T1376")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_Guid[]>), TypeInfoPropertyName = "T1377")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_Guid[]>), TypeInfoPropertyName = "T1378")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_Guid[], int>), TypeInfoPropertyName = "T1379")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1380")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1381")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1382")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1383")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_Guid>, int>), TypeInfoPropertyName = "T1384")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1385")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1386")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1387")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1388")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_Guid>, int>), TypeInfoPropertyName = "T1389")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_Guid, int>>), TypeInfoPropertyName = "T1390")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_Guid, int>>), TypeInfoPropertyName = "T1391")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_Guid, int>>), TypeInfoPropertyName = "T1392")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_Guid, int>>), TypeInfoPropertyName = "T1393")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_Guid, int>, int>), TypeInfoPropertyName = "T1394")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1395")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1396")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1397")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1398")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_Guid>, int>), TypeInfoPropertyName = "T1399")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1400")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1401")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1402")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1403")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_Guid, int>), TypeInfoPropertyName = "T1404")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1405")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1406")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1407")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1408")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_Guid, int>), TypeInfoPropertyName = "T1409")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1410")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1411")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1412")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_Guid>>), TypeInfoPropertyName = "T1413")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_Guid>, int>), TypeInfoPropertyName = "T1414")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1415")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1416")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1417")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_Guid>), TypeInfoPropertyName = "T1418")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_Guid, int>), TypeInfoPropertyName = "T1419")]
-[JsonSerializable(typeof(V_sealed_record_class_int))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_int>), TypeInfoPropertyName = "T1420")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_int>), TypeInfoPropertyName = "T1421")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_int>), TypeInfoPropertyName = "T1422")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_int>), TypeInfoPropertyName = "T1423")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_int, int>), TypeInfoPropertyName = "T1424")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_int>), TypeInfoPropertyName = "T1425")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_int>), TypeInfoPropertyName = "T1426")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_int>), TypeInfoPropertyName = "T1427")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_int>), TypeInfoPropertyName = "T1428")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_int, int>), TypeInfoPropertyName = "T1429")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_int>>), TypeInfoPropertyName = "T1430")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_int>>), TypeInfoPropertyName = "T1431")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_int>>), TypeInfoPropertyName = "T1432")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_int>>), TypeInfoPropertyName = "T1433")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_int>, int>), TypeInfoPropertyName = "T1434")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_int[]>), TypeInfoPropertyName = "T1435")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_int[]>), TypeInfoPropertyName = "T1436")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_int[]>), TypeInfoPropertyName = "T1437")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_int[]>), TypeInfoPropertyName = "T1438")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_int[], int>), TypeInfoPropertyName = "T1439")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_int>>), TypeInfoPropertyName = "T1440")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_int>>), TypeInfoPropertyName = "T1441")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_int>>), TypeInfoPropertyName = "T1442")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_int>>), TypeInfoPropertyName = "T1443")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_int>, int>), TypeInfoPropertyName = "T1444")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_int>>), TypeInfoPropertyName = "T1445")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_int>>), TypeInfoPropertyName = "T1446")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_int>>), TypeInfoPropertyName = "T1447")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_int>>), TypeInfoPropertyName = "T1448")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_int>, int>), TypeInfoPropertyName = "T1449")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_int, int>>), TypeInfoPropertyName = "T1450")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_int, int>>), TypeInfoPropertyName = "T1451")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_int, int>>), TypeInfoPropertyName = "T1452")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_int, int>>), TypeInfoPropertyName = "T1453")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_int, int>, int>), TypeInfoPropertyName = "T1454")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_int>>), TypeInfoPropertyName = "T1455")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_int>>), TypeInfoPropertyName = "T1456")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_int>>), TypeInfoPropertyName = "T1457")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_int>>), TypeInfoPropertyName = "T1458")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_int>, int>), TypeInfoPropertyName = "T1459")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_int>), TypeInfoPropertyName = "T1460")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_int>), TypeInfoPropertyName = "T1461")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_int>), TypeInfoPropertyName = "T1462")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_int>), TypeInfoPropertyName = "T1463")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_int, int>), TypeInfoPropertyName = "T1464")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_int>), TypeInfoPropertyName = "T1465")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_int>), TypeInfoPropertyName = "T1466")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_int>), TypeInfoPropertyName = "T1467")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_int>), TypeInfoPropertyName = "T1468")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_int, int>), TypeInfoPropertyName = "T1469")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_int>>), TypeInfoPropertyName = "T1470")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_int>>), TypeInfoPropertyName = "T1471")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_int>>), TypeInfoPropertyName = "T1472")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_int>>), TypeInfoPropertyName = "T1473")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_int>, int>), TypeInfoPropertyName = "T1474")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_int>), TypeInfoPropertyName = "T1475")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_int>), TypeInfoPropertyName = "T1476")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_int>), TypeInfoPropertyName = "T1477")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_int>), TypeInfoPropertyName = "T1478")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_int, int>), TypeInfoPropertyName = "T1479")]
-[JsonSerializable(typeof(V_sealed_record_class_long))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_long>), TypeInfoPropertyName = "T1480")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_long>), TypeInfoPropertyName = "T1481")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_long>), TypeInfoPropertyName = "T1482")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_long>), TypeInfoPropertyName = "T1483")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_long, int>), TypeInfoPropertyName = "T1484")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_long>), TypeInfoPropertyName = "T1485")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_long>), TypeInfoPropertyName = "T1486")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_long>), TypeInfoPropertyName = "T1487")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_long>), TypeInfoPropertyName = "T1488")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_long, int>), TypeInfoPropertyName = "T1489")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_long>>), TypeInfoPropertyName = "T1490")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_long>>), TypeInfoPropertyName = "T1491")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_long>>), TypeInfoPropertyName = "T1492")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_long>>), TypeInfoPropertyName = "T1493")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_long>, int>), TypeInfoPropertyName = "T1494")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_long[]>), TypeInfoPropertyName = "T1495")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_long[]>), TypeInfoPropertyName = "T1496")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_long[]>), TypeInfoPropertyName = "T1497")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_long[]>), TypeInfoPropertyName = "T1498")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_long[], int>), TypeInfoPropertyName = "T1499")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_long>>), TypeInfoPropertyName = "T1500")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_long>>), TypeInfoPropertyName = "T1501")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_long>>), TypeInfoPropertyName = "T1502")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_long>>), TypeInfoPropertyName = "T1503")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_long>, int>), TypeInfoPropertyName = "T1504")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_long>>), TypeInfoPropertyName = "T1505")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_long>>), TypeInfoPropertyName = "T1506")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_long>>), TypeInfoPropertyName = "T1507")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_long>>), TypeInfoPropertyName = "T1508")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_long>, int>), TypeInfoPropertyName = "T1509")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_long, int>>), TypeInfoPropertyName = "T1510")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_long, int>>), TypeInfoPropertyName = "T1511")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_long, int>>), TypeInfoPropertyName = "T1512")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_long, int>>), TypeInfoPropertyName = "T1513")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_long, int>, int>), TypeInfoPropertyName = "T1514")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_long>>), TypeInfoPropertyName = "T1515")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_long>>), TypeInfoPropertyName = "T1516")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_long>>), TypeInfoPropertyName = "T1517")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_long>>), TypeInfoPropertyName = "T1518")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_long>, int>), TypeInfoPropertyName = "T1519")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_long>), TypeInfoPropertyName = "T1520")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_long>), TypeInfoPropertyName = "T1521")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_long>), TypeInfoPropertyName = "T1522")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_long>), TypeInfoPropertyName = "T1523")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_long, int>), TypeInfoPropertyName = "T1524")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_long>), TypeInfoPropertyName = "T1525")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_long>), TypeInfoPropertyName = "T1526")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_long>), TypeInfoPropertyName = "T1527")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_long>), TypeInfoPropertyName = "T1528")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_long, int>), TypeInfoPropertyName = "T1529")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_long>>), TypeInfoPropertyName = "T1530")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_long>>), TypeInfoPropertyName = "T1531")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_long>>), TypeInfoPropertyName = "T1532")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_long>>), TypeInfoPropertyName = "T1533")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_long>, int>), TypeInfoPropertyName = "T1534")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_long>), TypeInfoPropertyName = "T1535")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_long>), TypeInfoPropertyName = "T1536")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_long>), TypeInfoPropertyName = "T1537")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_long>), TypeInfoPropertyName = "T1538")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_long, int>), TypeInfoPropertyName = "T1539")]
-[JsonSerializable(typeof(V_sealed_record_class_byte))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_byte>), TypeInfoPropertyName = "T1540")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_byte>), TypeInfoPropertyName = "T1541")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_byte>), TypeInfoPropertyName = "T1542")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_byte>), TypeInfoPropertyName = "T1543")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_byte, int>), TypeInfoPropertyName = "T1544")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_byte>), TypeInfoPropertyName = "T1545")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_byte>), TypeInfoPropertyName = "T1546")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_byte>), TypeInfoPropertyName = "T1547")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_byte>), TypeInfoPropertyName = "T1548")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_byte, int>), TypeInfoPropertyName = "T1549")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1550")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1551")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1552")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1553")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_byte>, int>), TypeInfoPropertyName = "T1554")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_byte[]>), TypeInfoPropertyName = "T1555")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_byte[]>), TypeInfoPropertyName = "T1556")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_byte[]>), TypeInfoPropertyName = "T1557")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_byte[]>), TypeInfoPropertyName = "T1558")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_byte[], int>), TypeInfoPropertyName = "T1559")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1560")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1561")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1562")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1563")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_byte>, int>), TypeInfoPropertyName = "T1564")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1565")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1566")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1567")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1568")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_byte>, int>), TypeInfoPropertyName = "T1569")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_byte, int>>), TypeInfoPropertyName = "T1570")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_byte, int>>), TypeInfoPropertyName = "T1571")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_byte, int>>), TypeInfoPropertyName = "T1572")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_byte, int>>), TypeInfoPropertyName = "T1573")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_byte, int>, int>), TypeInfoPropertyName = "T1574")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1575")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1576")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1577")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1578")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_byte>, int>), TypeInfoPropertyName = "T1579")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_byte>), TypeInfoPropertyName = "T1580")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_byte>), TypeInfoPropertyName = "T1581")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_byte>), TypeInfoPropertyName = "T1582")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_byte>), TypeInfoPropertyName = "T1583")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_byte, int>), TypeInfoPropertyName = "T1584")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_byte>), TypeInfoPropertyName = "T1585")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_byte>), TypeInfoPropertyName = "T1586")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_byte>), TypeInfoPropertyName = "T1587")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_byte>), TypeInfoPropertyName = "T1588")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_byte, int>), TypeInfoPropertyName = "T1589")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1590")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1591")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1592")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_byte>>), TypeInfoPropertyName = "T1593")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_byte>, int>), TypeInfoPropertyName = "T1594")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_byte>), TypeInfoPropertyName = "T1595")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_byte>), TypeInfoPropertyName = "T1596")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_byte>), TypeInfoPropertyName = "T1597")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_byte>), TypeInfoPropertyName = "T1598")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_byte, int>), TypeInfoPropertyName = "T1599")]
-[JsonSerializable(typeof(V_sealed_record_class_ulong))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1600")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1601")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1602")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1603")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_ulong, int>), TypeInfoPropertyName = "T1604")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1605")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1606")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1607")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1608")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_ulong, int>), TypeInfoPropertyName = "T1609")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1610")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1611")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1612")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1613")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_ulong>, int>), TypeInfoPropertyName = "T1614")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_ulong[]>), TypeInfoPropertyName = "T1615")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_ulong[]>), TypeInfoPropertyName = "T1616")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_ulong[]>), TypeInfoPropertyName = "T1617")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_ulong[]>), TypeInfoPropertyName = "T1618")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_ulong[], int>), TypeInfoPropertyName = "T1619")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1620")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1621")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1622")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1623")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_ulong>, int>), TypeInfoPropertyName = "T1624")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1625")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1626")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1627")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1628")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_ulong>, int>), TypeInfoPropertyName = "T1629")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_ulong, int>>), TypeInfoPropertyName = "T1630")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_ulong, int>>), TypeInfoPropertyName = "T1631")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_ulong, int>>), TypeInfoPropertyName = "T1632")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_ulong, int>>), TypeInfoPropertyName = "T1633")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_ulong, int>, int>), TypeInfoPropertyName = "T1634")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1635")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1636")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1637")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1638")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_ulong>, int>), TypeInfoPropertyName = "T1639")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1640")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1641")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1642")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1643")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_ulong, int>), TypeInfoPropertyName = "T1644")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1645")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1646")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1647")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1648")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_ulong, int>), TypeInfoPropertyName = "T1649")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1650")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1651")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1652")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_ulong>>), TypeInfoPropertyName = "T1653")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_ulong>, int>), TypeInfoPropertyName = "T1654")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1655")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1656")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1657")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_ulong>), TypeInfoPropertyName = "T1658")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_ulong, int>), TypeInfoPropertyName = "T1659")]
-[JsonSerializable(typeof(V_sealed_record_class_decimal))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1660")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1661")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1662")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1663")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_decimal, int>), TypeInfoPropertyName = "T1664")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1665")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1666")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1667")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1668")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_decimal, int>), TypeInfoPropertyName = "T1669")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1670")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1671")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1672")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1673")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_decimal>, int>), TypeInfoPropertyName = "T1674")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_decimal[]>), TypeInfoPropertyName = "T1675")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_decimal[]>), TypeInfoPropertyName = "T1676")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_decimal[]>), TypeInfoPropertyName = "T1677")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_decimal[]>), TypeInfoPropertyName = "T1678")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_decimal[], int>), TypeInfoPropertyName = "T1679")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1680")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1681")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1682")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1683")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_decimal>, int>), TypeInfoPropertyName = "T1684")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1685")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1686")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1687")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1688")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_decimal>, int>), TypeInfoPropertyName = "T1689")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_decimal, int>>), TypeInfoPropertyName = "T1690")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_decimal, int>>), TypeInfoPropertyName = "T1691")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_decimal, int>>), TypeInfoPropertyName = "T1692")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_decimal, int>>), TypeInfoPropertyName = "T1693")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_decimal, int>, int>), TypeInfoPropertyName = "T1694")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1695")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1696")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1697")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1698")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_decimal>, int>), TypeInfoPropertyName = "T1699")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1700")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1701")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1702")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1703")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_decimal, int>), TypeInfoPropertyName = "T1704")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1705")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1706")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1707")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1708")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_decimal, int>), TypeInfoPropertyName = "T1709")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1710")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1711")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1712")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_decimal>>), TypeInfoPropertyName = "T1713")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_decimal>, int>), TypeInfoPropertyName = "T1714")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1715")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1716")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1717")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_decimal>), TypeInfoPropertyName = "T1718")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_decimal, int>), TypeInfoPropertyName = "T1719")]
-[JsonSerializable(typeof(V_sealed_record_class_double))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_double>), TypeInfoPropertyName = "T1720")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_double>), TypeInfoPropertyName = "T1721")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_double>), TypeInfoPropertyName = "T1722")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_double>), TypeInfoPropertyName = "T1723")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_double, int>), TypeInfoPropertyName = "T1724")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_double>), TypeInfoPropertyName = "T1725")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_double>), TypeInfoPropertyName = "T1726")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_double>), TypeInfoPropertyName = "T1727")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_double>), TypeInfoPropertyName = "T1728")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_double, int>), TypeInfoPropertyName = "T1729")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_double>>), TypeInfoPropertyName = "T1730")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_double>>), TypeInfoPropertyName = "T1731")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_double>>), TypeInfoPropertyName = "T1732")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_double>>), TypeInfoPropertyName = "T1733")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_double>, int>), TypeInfoPropertyName = "T1734")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_double[]>), TypeInfoPropertyName = "T1735")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_double[]>), TypeInfoPropertyName = "T1736")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_double[]>), TypeInfoPropertyName = "T1737")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_double[]>), TypeInfoPropertyName = "T1738")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_double[], int>), TypeInfoPropertyName = "T1739")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_double>>), TypeInfoPropertyName = "T1740")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_double>>), TypeInfoPropertyName = "T1741")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_double>>), TypeInfoPropertyName = "T1742")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_double>>), TypeInfoPropertyName = "T1743")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_double>, int>), TypeInfoPropertyName = "T1744")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_double>>), TypeInfoPropertyName = "T1745")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_double>>), TypeInfoPropertyName = "T1746")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_double>>), TypeInfoPropertyName = "T1747")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_double>>), TypeInfoPropertyName = "T1748")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_double>, int>), TypeInfoPropertyName = "T1749")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_double, int>>), TypeInfoPropertyName = "T1750")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_double, int>>), TypeInfoPropertyName = "T1751")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_double, int>>), TypeInfoPropertyName = "T1752")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_double, int>>), TypeInfoPropertyName = "T1753")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_double, int>, int>), TypeInfoPropertyName = "T1754")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_double>>), TypeInfoPropertyName = "T1755")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_double>>), TypeInfoPropertyName = "T1756")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_double>>), TypeInfoPropertyName = "T1757")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_double>>), TypeInfoPropertyName = "T1758")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_double>, int>), TypeInfoPropertyName = "T1759")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_double>), TypeInfoPropertyName = "T1760")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_double>), TypeInfoPropertyName = "T1761")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_double>), TypeInfoPropertyName = "T1762")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_double>), TypeInfoPropertyName = "T1763")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_double, int>), TypeInfoPropertyName = "T1764")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_double>), TypeInfoPropertyName = "T1765")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_double>), TypeInfoPropertyName = "T1766")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_double>), TypeInfoPropertyName = "T1767")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_double>), TypeInfoPropertyName = "T1768")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_double, int>), TypeInfoPropertyName = "T1769")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_double>>), TypeInfoPropertyName = "T1770")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_double>>), TypeInfoPropertyName = "T1771")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_double>>), TypeInfoPropertyName = "T1772")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_double>>), TypeInfoPropertyName = "T1773")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_double>, int>), TypeInfoPropertyName = "T1774")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_double>), TypeInfoPropertyName = "T1775")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_double>), TypeInfoPropertyName = "T1776")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_double>), TypeInfoPropertyName = "T1777")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_double>), TypeInfoPropertyName = "T1778")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_double, int>), TypeInfoPropertyName = "T1779")]
-[JsonSerializable(typeof(V_sealed_record_class_bool))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_bool>), TypeInfoPropertyName = "T1780")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_bool>), TypeInfoPropertyName = "T1781")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_bool>), TypeInfoPropertyName = "T1782")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_bool>), TypeInfoPropertyName = "T1783")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_bool, int>), TypeInfoPropertyName = "T1784")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_bool>), TypeInfoPropertyName = "T1785")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_bool>), TypeInfoPropertyName = "T1786")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_bool>), TypeInfoPropertyName = "T1787")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_bool>), TypeInfoPropertyName = "T1788")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_bool, int>), TypeInfoPropertyName = "T1789")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1790")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1791")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1792")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1793")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_bool>, int>), TypeInfoPropertyName = "T1794")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_bool[]>), TypeInfoPropertyName = "T1795")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_bool[]>), TypeInfoPropertyName = "T1796")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_bool[]>), TypeInfoPropertyName = "T1797")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_bool[]>), TypeInfoPropertyName = "T1798")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_bool[], int>), TypeInfoPropertyName = "T1799")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1800")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1801")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1802")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1803")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_bool>, int>), TypeInfoPropertyName = "T1804")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1805")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1806")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1807")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1808")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_bool>, int>), TypeInfoPropertyName = "T1809")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_bool, int>>), TypeInfoPropertyName = "T1810")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_bool, int>>), TypeInfoPropertyName = "T1811")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_bool, int>>), TypeInfoPropertyName = "T1812")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_bool, int>>), TypeInfoPropertyName = "T1813")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_bool, int>, int>), TypeInfoPropertyName = "T1814")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1815")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1816")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1817")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1818")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_bool>, int>), TypeInfoPropertyName = "T1819")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_bool>), TypeInfoPropertyName = "T1820")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_bool>), TypeInfoPropertyName = "T1821")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_bool>), TypeInfoPropertyName = "T1822")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_bool>), TypeInfoPropertyName = "T1823")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_bool, int>), TypeInfoPropertyName = "T1824")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_bool>), TypeInfoPropertyName = "T1825")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_bool>), TypeInfoPropertyName = "T1826")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_bool>), TypeInfoPropertyName = "T1827")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_bool>), TypeInfoPropertyName = "T1828")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_bool, int>), TypeInfoPropertyName = "T1829")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1830")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1831")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1832")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_bool>>), TypeInfoPropertyName = "T1833")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_bool>, int>), TypeInfoPropertyName = "T1834")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_bool>), TypeInfoPropertyName = "T1835")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_bool>), TypeInfoPropertyName = "T1836")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_bool>), TypeInfoPropertyName = "T1837")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_bool>), TypeInfoPropertyName = "T1838")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_bool, int>), TypeInfoPropertyName = "T1839")]
-[JsonSerializable(typeof(V_sealed_record_class_char))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_char>), TypeInfoPropertyName = "T1840")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_char>), TypeInfoPropertyName = "T1841")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_char>), TypeInfoPropertyName = "T1842")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_char>), TypeInfoPropertyName = "T1843")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_char, int>), TypeInfoPropertyName = "T1844")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_char>), TypeInfoPropertyName = "T1845")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_char>), TypeInfoPropertyName = "T1846")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_char>), TypeInfoPropertyName = "T1847")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_char>), TypeInfoPropertyName = "T1848")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_char, int>), TypeInfoPropertyName = "T1849")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_char>>), TypeInfoPropertyName = "T1850")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_char>>), TypeInfoPropertyName = "T1851")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_char>>), TypeInfoPropertyName = "T1852")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_char>>), TypeInfoPropertyName = "T1853")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_char>, int>), TypeInfoPropertyName = "T1854")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_char[]>), TypeInfoPropertyName = "T1855")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_char[]>), TypeInfoPropertyName = "T1856")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_char[]>), TypeInfoPropertyName = "T1857")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_char[]>), TypeInfoPropertyName = "T1858")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_char[], int>), TypeInfoPropertyName = "T1859")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_char>>), TypeInfoPropertyName = "T1860")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_char>>), TypeInfoPropertyName = "T1861")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_char>>), TypeInfoPropertyName = "T1862")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_char>>), TypeInfoPropertyName = "T1863")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_char>, int>), TypeInfoPropertyName = "T1864")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_char>>), TypeInfoPropertyName = "T1865")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_char>>), TypeInfoPropertyName = "T1866")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_char>>), TypeInfoPropertyName = "T1867")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_char>>), TypeInfoPropertyName = "T1868")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_char>, int>), TypeInfoPropertyName = "T1869")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_char, int>>), TypeInfoPropertyName = "T1870")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_char, int>>), TypeInfoPropertyName = "T1871")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_char, int>>), TypeInfoPropertyName = "T1872")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_char, int>>), TypeInfoPropertyName = "T1873")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_char, int>, int>), TypeInfoPropertyName = "T1874")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_char>>), TypeInfoPropertyName = "T1875")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_char>>), TypeInfoPropertyName = "T1876")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_char>>), TypeInfoPropertyName = "T1877")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_char>>), TypeInfoPropertyName = "T1878")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_char>, int>), TypeInfoPropertyName = "T1879")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_char>), TypeInfoPropertyName = "T1880")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_char>), TypeInfoPropertyName = "T1881")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_char>), TypeInfoPropertyName = "T1882")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_char>), TypeInfoPropertyName = "T1883")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_char, int>), TypeInfoPropertyName = "T1884")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_char>), TypeInfoPropertyName = "T1885")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_char>), TypeInfoPropertyName = "T1886")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_char>), TypeInfoPropertyName = "T1887")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_char>), TypeInfoPropertyName = "T1888")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_char, int>), TypeInfoPropertyName = "T1889")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_char>>), TypeInfoPropertyName = "T1890")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_char>>), TypeInfoPropertyName = "T1891")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_char>>), TypeInfoPropertyName = "T1892")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_char>>), TypeInfoPropertyName = "T1893")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_char>, int>), TypeInfoPropertyName = "T1894")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_char>), TypeInfoPropertyName = "T1895")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_char>), TypeInfoPropertyName = "T1896")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_char>), TypeInfoPropertyName = "T1897")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_char>), TypeInfoPropertyName = "T1898")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_char, int>), TypeInfoPropertyName = "T1899")]
-[JsonSerializable(typeof(V_sealed_record_class_DateTime))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1900")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1901")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1902")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1903")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_DateTime, int>), TypeInfoPropertyName = "T1904")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1905")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1906")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1907")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1908")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_DateTime, int>), TypeInfoPropertyName = "T1909")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1910")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1911")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1912")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1913")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_DateTime>, int>), TypeInfoPropertyName = "T1914")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_DateTime[]>), TypeInfoPropertyName = "T1915")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_DateTime[]>), TypeInfoPropertyName = "T1916")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_DateTime[]>), TypeInfoPropertyName = "T1917")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_DateTime[]>), TypeInfoPropertyName = "T1918")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_DateTime[], int>), TypeInfoPropertyName = "T1919")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1920")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1921")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1922")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1923")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_DateTime>, int>), TypeInfoPropertyName = "T1924")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1925")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1926")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1927")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1928")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_DateTime>, int>), TypeInfoPropertyName = "T1929")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_DateTime, int>>), TypeInfoPropertyName = "T1930")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_DateTime, int>>), TypeInfoPropertyName = "T1931")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_DateTime, int>>), TypeInfoPropertyName = "T1932")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_DateTime, int>>), TypeInfoPropertyName = "T1933")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_DateTime, int>, int>), TypeInfoPropertyName = "T1934")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1935")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1936")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1937")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1938")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_DateTime>, int>), TypeInfoPropertyName = "T1939")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1940")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1941")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1942")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1943")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_DateTime, int>), TypeInfoPropertyName = "T1944")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1945")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1946")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1947")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1948")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_DateTime, int>), TypeInfoPropertyName = "T1949")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1950")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1951")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1952")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_DateTime>>), TypeInfoPropertyName = "T1953")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_DateTime>, int>), TypeInfoPropertyName = "T1954")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1955")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1956")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1957")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_DateTime>), TypeInfoPropertyName = "T1958")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_DateTime, int>), TypeInfoPropertyName = "T1959")]
-[JsonSerializable(typeof(V_sealed_record_class_DateTimeOffset))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T1960")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T1961")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T1962")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T1963")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_DateTimeOffset, int>), TypeInfoPropertyName = "T1964")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T1965")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T1966")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T1967")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T1968")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_DateTimeOffset, int>), TypeInfoPropertyName = "T1969")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T1970")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T1971")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T1972")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T1973")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_DateTimeOffset>, int>), TypeInfoPropertyName = "T1974")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_DateTimeOffset[]>), TypeInfoPropertyName = "T1975")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_DateTimeOffset[]>), TypeInfoPropertyName = "T1976")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_DateTimeOffset[]>), TypeInfoPropertyName = "T1977")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_DateTimeOffset[]>), TypeInfoPropertyName = "T1978")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_DateTimeOffset[], int>), TypeInfoPropertyName = "T1979")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T1980")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T1981")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T1982")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T1983")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_DateTimeOffset>, int>), TypeInfoPropertyName = "T1984")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T1985")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T1986")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T1987")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T1988")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_DateTimeOffset>, int>), TypeInfoPropertyName = "T1989")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_DateTimeOffset, int>>), TypeInfoPropertyName = "T1990")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_DateTimeOffset, int>>), TypeInfoPropertyName = "T1991")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_DateTimeOffset, int>>), TypeInfoPropertyName = "T1992")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_DateTimeOffset, int>>), TypeInfoPropertyName = "T1993")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_DateTimeOffset, int>, int>), TypeInfoPropertyName = "T1994")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T1995")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T1996")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T1997")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T1998")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_DateTimeOffset>, int>), TypeInfoPropertyName = "T1999")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T2000")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T2001")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T2002")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T2003")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_DateTimeOffset, int>), TypeInfoPropertyName = "T2004")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T2005")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T2006")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T2007")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T2008")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_DateTimeOffset, int>), TypeInfoPropertyName = "T2009")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T2010")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T2011")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T2012")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_DateTimeOffset>>), TypeInfoPropertyName = "T2013")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_DateTimeOffset>, int>), TypeInfoPropertyName = "T2014")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T2015")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T2016")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T2017")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_DateTimeOffset>), TypeInfoPropertyName = "T2018")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_DateTimeOffset, int>), TypeInfoPropertyName = "T2019")]
-[JsonSerializable(typeof(V_sealed_record_class_DateOnly))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2020")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2021")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2022")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2023")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_DateOnly, int>), TypeInfoPropertyName = "T2024")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2025")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2026")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2027")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2028")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_DateOnly, int>), TypeInfoPropertyName = "T2029")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2030")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2031")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2032")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2033")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_DateOnly>, int>), TypeInfoPropertyName = "T2034")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_DateOnly[]>), TypeInfoPropertyName = "T2035")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_DateOnly[]>), TypeInfoPropertyName = "T2036")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_DateOnly[]>), TypeInfoPropertyName = "T2037")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_DateOnly[]>), TypeInfoPropertyName = "T2038")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_DateOnly[], int>), TypeInfoPropertyName = "T2039")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2040")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2041")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2042")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2043")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_DateOnly>, int>), TypeInfoPropertyName = "T2044")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2045")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2046")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2047")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2048")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_DateOnly>, int>), TypeInfoPropertyName = "T2049")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_DateOnly, int>>), TypeInfoPropertyName = "T2050")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_DateOnly, int>>), TypeInfoPropertyName = "T2051")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_DateOnly, int>>), TypeInfoPropertyName = "T2052")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_DateOnly, int>>), TypeInfoPropertyName = "T2053")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_DateOnly, int>, int>), TypeInfoPropertyName = "T2054")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2055")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2056")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2057")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2058")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_DateOnly>, int>), TypeInfoPropertyName = "T2059")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2060")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2061")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2062")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2063")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_DateOnly, int>), TypeInfoPropertyName = "T2064")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2065")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2066")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2067")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2068")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_DateOnly, int>), TypeInfoPropertyName = "T2069")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2070")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2071")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2072")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_DateOnly>>), TypeInfoPropertyName = "T2073")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_DateOnly>, int>), TypeInfoPropertyName = "T2074")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2075")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2076")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2077")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_DateOnly>), TypeInfoPropertyName = "T2078")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_DateOnly, int>), TypeInfoPropertyName = "T2079")]
-[JsonSerializable(typeof(V_sealed_record_class_TimeOnly))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2080")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2081")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2082")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2083")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_TimeOnly, int>), TypeInfoPropertyName = "T2084")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2085")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2086")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2087")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2088")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_TimeOnly, int>), TypeInfoPropertyName = "T2089")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2090")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2091")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2092")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2093")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_TimeOnly>, int>), TypeInfoPropertyName = "T2094")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_TimeOnly[]>), TypeInfoPropertyName = "T2095")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_TimeOnly[]>), TypeInfoPropertyName = "T2096")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_TimeOnly[]>), TypeInfoPropertyName = "T2097")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_TimeOnly[]>), TypeInfoPropertyName = "T2098")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_TimeOnly[], int>), TypeInfoPropertyName = "T2099")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2100")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2101")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2102")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2103")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_TimeOnly>, int>), TypeInfoPropertyName = "T2104")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2105")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2106")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2107")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2108")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_TimeOnly>, int>), TypeInfoPropertyName = "T2109")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_TimeOnly, int>>), TypeInfoPropertyName = "T2110")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_TimeOnly, int>>), TypeInfoPropertyName = "T2111")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_TimeOnly, int>>), TypeInfoPropertyName = "T2112")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_TimeOnly, int>>), TypeInfoPropertyName = "T2113")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_TimeOnly, int>, int>), TypeInfoPropertyName = "T2114")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2115")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2116")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2117")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2118")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_TimeOnly>, int>), TypeInfoPropertyName = "T2119")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2120")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2121")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2122")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2123")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_TimeOnly, int>), TypeInfoPropertyName = "T2124")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2125")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2126")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2127")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2128")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_TimeOnly, int>), TypeInfoPropertyName = "T2129")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2130")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2131")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2132")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_TimeOnly>>), TypeInfoPropertyName = "T2133")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_TimeOnly>, int>), TypeInfoPropertyName = "T2134")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2135")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2136")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2137")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_TimeOnly>), TypeInfoPropertyName = "T2138")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_TimeOnly, int>), TypeInfoPropertyName = "T2139")]
-[JsonSerializable(typeof(V_sealed_record_class_TimeSpan))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2140")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2141")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2142")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2143")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_TimeSpan, int>), TypeInfoPropertyName = "T2144")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2145")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2146")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2147")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2148")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_TimeSpan, int>), TypeInfoPropertyName = "T2149")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2150")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2151")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2152")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2153")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_TimeSpan>, int>), TypeInfoPropertyName = "T2154")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_TimeSpan[]>), TypeInfoPropertyName = "T2155")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_TimeSpan[]>), TypeInfoPropertyName = "T2156")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_TimeSpan[]>), TypeInfoPropertyName = "T2157")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_TimeSpan[]>), TypeInfoPropertyName = "T2158")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_TimeSpan[], int>), TypeInfoPropertyName = "T2159")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2160")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2161")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2162")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2163")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_TimeSpan>, int>), TypeInfoPropertyName = "T2164")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2165")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2166")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2167")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2168")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_TimeSpan>, int>), TypeInfoPropertyName = "T2169")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_TimeSpan, int>>), TypeInfoPropertyName = "T2170")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_TimeSpan, int>>), TypeInfoPropertyName = "T2171")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_TimeSpan, int>>), TypeInfoPropertyName = "T2172")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_TimeSpan, int>>), TypeInfoPropertyName = "T2173")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_TimeSpan, int>, int>), TypeInfoPropertyName = "T2174")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2175")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2176")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2177")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2178")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_TimeSpan>, int>), TypeInfoPropertyName = "T2179")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2180")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2181")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2182")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2183")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_TimeSpan, int>), TypeInfoPropertyName = "T2184")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2185")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2186")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2187")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2188")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_TimeSpan, int>), TypeInfoPropertyName = "T2189")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2190")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2191")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2192")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_TimeSpan>>), TypeInfoPropertyName = "T2193")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_TimeSpan>, int>), TypeInfoPropertyName = "T2194")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2195")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2196")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2197")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_TimeSpan>), TypeInfoPropertyName = "T2198")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_TimeSpan, int>), TypeInfoPropertyName = "T2199")]
-[JsonSerializable(typeof(V_sealed_record_class_enum))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_enum>), TypeInfoPropertyName = "T2200")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_enum>), TypeInfoPropertyName = "T2201")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_enum>), TypeInfoPropertyName = "T2202")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_enum>), TypeInfoPropertyName = "T2203")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_enum, int>), TypeInfoPropertyName = "T2204")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_enum>), TypeInfoPropertyName = "T2205")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_enum>), TypeInfoPropertyName = "T2206")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_enum>), TypeInfoPropertyName = "T2207")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_enum>), TypeInfoPropertyName = "T2208")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_enum, int>), TypeInfoPropertyName = "T2209")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2210")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2211")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2212")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2213")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_enum>, int>), TypeInfoPropertyName = "T2214")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_enum[]>), TypeInfoPropertyName = "T2215")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_enum[]>), TypeInfoPropertyName = "T2216")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_enum[]>), TypeInfoPropertyName = "T2217")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_enum[]>), TypeInfoPropertyName = "T2218")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_enum[], int>), TypeInfoPropertyName = "T2219")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2220")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2221")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2222")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2223")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_enum>, int>), TypeInfoPropertyName = "T2224")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2225")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2226")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2227")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2228")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_enum>, int>), TypeInfoPropertyName = "T2229")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_enum, int>>), TypeInfoPropertyName = "T2230")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_enum, int>>), TypeInfoPropertyName = "T2231")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_enum, int>>), TypeInfoPropertyName = "T2232")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_enum, int>>), TypeInfoPropertyName = "T2233")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_enum, int>, int>), TypeInfoPropertyName = "T2234")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2235")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2236")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2237")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2238")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_enum>, int>), TypeInfoPropertyName = "T2239")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_enum>), TypeInfoPropertyName = "T2240")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_enum>), TypeInfoPropertyName = "T2241")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_enum>), TypeInfoPropertyName = "T2242")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_enum>), TypeInfoPropertyName = "T2243")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_enum, int>), TypeInfoPropertyName = "T2244")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_enum>), TypeInfoPropertyName = "T2245")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_enum>), TypeInfoPropertyName = "T2246")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_enum>), TypeInfoPropertyName = "T2247")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_enum>), TypeInfoPropertyName = "T2248")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_enum, int>), TypeInfoPropertyName = "T2249")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2250")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2251")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2252")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_enum>>), TypeInfoPropertyName = "T2253")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_enum>, int>), TypeInfoPropertyName = "T2254")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_enum>), TypeInfoPropertyName = "T2255")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_enum>), TypeInfoPropertyName = "T2256")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_enum>), TypeInfoPropertyName = "T2257")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_enum>), TypeInfoPropertyName = "T2258")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_enum, int>), TypeInfoPropertyName = "T2259")]
-[JsonSerializable(typeof(V_sealed_record_class_flags_enum))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2260")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2261")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2262")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2263")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_flags_enum, int>), TypeInfoPropertyName = "T2264")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2265")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2266")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2267")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2268")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_flags_enum, int>), TypeInfoPropertyName = "T2269")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2270")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2271")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2272")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2273")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_flags_enum>, int>), TypeInfoPropertyName = "T2274")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_flags_enum[]>), TypeInfoPropertyName = "T2275")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_flags_enum[]>), TypeInfoPropertyName = "T2276")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_flags_enum[]>), TypeInfoPropertyName = "T2277")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_flags_enum[]>), TypeInfoPropertyName = "T2278")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_flags_enum[], int>), TypeInfoPropertyName = "T2279")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2280")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2281")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2282")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2283")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_flags_enum>, int>), TypeInfoPropertyName = "T2284")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2285")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2286")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2287")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2288")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_flags_enum>, int>), TypeInfoPropertyName = "T2289")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_flags_enum, int>>), TypeInfoPropertyName = "T2290")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_flags_enum, int>>), TypeInfoPropertyName = "T2291")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_flags_enum, int>>), TypeInfoPropertyName = "T2292")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_flags_enum, int>>), TypeInfoPropertyName = "T2293")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_flags_enum, int>, int>), TypeInfoPropertyName = "T2294")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2295")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2296")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2297")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2298")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_flags_enum>, int>), TypeInfoPropertyName = "T2299")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2300")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2301")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2302")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2303")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_flags_enum, int>), TypeInfoPropertyName = "T2304")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2305")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2306")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2307")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2308")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_flags_enum, int>), TypeInfoPropertyName = "T2309")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2310")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2311")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2312")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T2313")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_flags_enum>, int>), TypeInfoPropertyName = "T2314")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2315")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2316")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2317")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T2318")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_flags_enum, int>), TypeInfoPropertyName = "T2319")]
-[JsonSerializable(typeof(V_sealed_record_class_Uri))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2320")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2321")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2322")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2323")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_Uri, int>), TypeInfoPropertyName = "T2324")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2325")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2326")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2327")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2328")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_Uri, int>), TypeInfoPropertyName = "T2329")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2330")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2331")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2332")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2333")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_Uri>, int>), TypeInfoPropertyName = "T2334")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_Uri[]>), TypeInfoPropertyName = "T2335")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_Uri[]>), TypeInfoPropertyName = "T2336")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_Uri[]>), TypeInfoPropertyName = "T2337")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_Uri[]>), TypeInfoPropertyName = "T2338")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_Uri[], int>), TypeInfoPropertyName = "T2339")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2340")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2341")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2342")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2343")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_Uri>, int>), TypeInfoPropertyName = "T2344")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2345")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2346")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2347")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2348")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_Uri>, int>), TypeInfoPropertyName = "T2349")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_Uri, int>>), TypeInfoPropertyName = "T2350")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_Uri, int>>), TypeInfoPropertyName = "T2351")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_Uri, int>>), TypeInfoPropertyName = "T2352")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_Uri, int>>), TypeInfoPropertyName = "T2353")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_Uri, int>, int>), TypeInfoPropertyName = "T2354")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2355")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2356")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2357")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2358")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_Uri>, int>), TypeInfoPropertyName = "T2359")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2360")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2361")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2362")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2363")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_Uri, int>), TypeInfoPropertyName = "T2364")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2365")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2366")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2367")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2368")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_Uri, int>), TypeInfoPropertyName = "T2369")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2370")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2371")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2372")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_Uri>>), TypeInfoPropertyName = "T2373")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_Uri>, int>), TypeInfoPropertyName = "T2374")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2375")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2376")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2377")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_Uri>), TypeInfoPropertyName = "T2378")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_Uri, int>), TypeInfoPropertyName = "T2379")]
-[JsonSerializable(typeof(V_sealed_record_class_NodaTime_Instant))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2380")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2381")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2382")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2383")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_NodaTime_Instant, int>), TypeInfoPropertyName = "T2384")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2385")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2386")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2387")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2388")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_NodaTime_Instant, int>), TypeInfoPropertyName = "T2389")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2390")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2391")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2392")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2393")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_NodaTime_Instant>, int>), TypeInfoPropertyName = "T2394")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_NodaTime_Instant[]>), TypeInfoPropertyName = "T2395")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_NodaTime_Instant[]>), TypeInfoPropertyName = "T2396")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_NodaTime_Instant[]>), TypeInfoPropertyName = "T2397")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_NodaTime_Instant[]>), TypeInfoPropertyName = "T2398")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_NodaTime_Instant[], int>), TypeInfoPropertyName = "T2399")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2400")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2401")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2402")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2403")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_NodaTime_Instant>, int>), TypeInfoPropertyName = "T2404")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2405")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2406")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2407")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2408")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_NodaTime_Instant>, int>), TypeInfoPropertyName = "T2409")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_NodaTime_Instant, int>>), TypeInfoPropertyName = "T2410")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_NodaTime_Instant, int>>), TypeInfoPropertyName = "T2411")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_NodaTime_Instant, int>>), TypeInfoPropertyName = "T2412")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_NodaTime_Instant, int>>), TypeInfoPropertyName = "T2413")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_NodaTime_Instant, int>, int>), TypeInfoPropertyName = "T2414")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2415")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2416")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2417")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2418")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_NodaTime_Instant>, int>), TypeInfoPropertyName = "T2419")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2420")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2421")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2422")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2423")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_NodaTime_Instant, int>), TypeInfoPropertyName = "T2424")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2425")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2426")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2427")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2428")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_NodaTime_Instant, int>), TypeInfoPropertyName = "T2429")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2430")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2431")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2432")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_NodaTime_Instant>>), TypeInfoPropertyName = "T2433")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_NodaTime_Instant>, int>), TypeInfoPropertyName = "T2434")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2435")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2436")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2437")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_NodaTime_Instant>), TypeInfoPropertyName = "T2438")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_NodaTime_Instant, int>), TypeInfoPropertyName = "T2439")]
-[JsonSerializable(typeof(V_sealed_record_class_own_record_class))]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2440")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2441")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2442")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2443")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_own_record_class, int>), TypeInfoPropertyName = "T2444")]
-[JsonSerializable(typeof(Cn_class_F<V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2445")]
-[JsonSerializable(typeof(Cn_record_class_F<V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2446")]
-[JsonSerializable(typeof(Cn_struct_F<V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2447")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2448")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_sealed_record_class_own_record_class, int>), TypeInfoPropertyName = "T2449")]
-[JsonSerializable(typeof(Cn_class_P<List<V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2450")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2451")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2452")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2453")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_sealed_record_class_own_record_class>, int>), TypeInfoPropertyName = "T2454")]
-[JsonSerializable(typeof(Cn_class_P<V_sealed_record_class_own_record_class[]>), TypeInfoPropertyName = "T2455")]
-[JsonSerializable(typeof(Cn_record_class_P<V_sealed_record_class_own_record_class[]>), TypeInfoPropertyName = "T2456")]
-[JsonSerializable(typeof(Cn_struct_P<V_sealed_record_class_own_record_class[]>), TypeInfoPropertyName = "T2457")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_sealed_record_class_own_record_class[]>), TypeInfoPropertyName = "T2458")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_sealed_record_class_own_record_class[], int>), TypeInfoPropertyName = "T2459")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2460")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2461")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2462")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2463")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_sealed_record_class_own_record_class>, int>), TypeInfoPropertyName = "T2464")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2465")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2466")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2467")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2468")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_sealed_record_class_own_record_class>, int>), TypeInfoPropertyName = "T2469")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_sealed_record_class_own_record_class, int>>), TypeInfoPropertyName = "T2470")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_sealed_record_class_own_record_class, int>>), TypeInfoPropertyName = "T2471")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_sealed_record_class_own_record_class, int>>), TypeInfoPropertyName = "T2472")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_sealed_record_class_own_record_class, int>>), TypeInfoPropertyName = "T2473")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_sealed_record_class_own_record_class, int>, int>), TypeInfoPropertyName = "T2474")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2475")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2476")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2477")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2478")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_sealed_record_class_own_record_class>, int>), TypeInfoPropertyName = "T2479")]
-[JsonSerializable(typeof(Cn_class_C<V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2480")]
-[JsonSerializable(typeof(Cn_record_class_C<V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2481")]
-[JsonSerializable(typeof(Cn_struct_C<V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2482")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2483")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_sealed_record_class_own_record_class, int>), TypeInfoPropertyName = "T2484")]
-[JsonSerializable(typeof(Cn_class_R<V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2485")]
-[JsonSerializable(typeof(Cn_record_class_R<V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2486")]
-[JsonSerializable(typeof(Cn_struct_R<V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2487")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2488")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_sealed_record_class_own_record_class, int>), TypeInfoPropertyName = "T2489")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2490")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2491")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2492")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_sealed_record_class_own_record_class>>), TypeInfoPropertyName = "T2493")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_sealed_record_class_own_record_class>, int>), TypeInfoPropertyName = "T2494")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2495")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2496")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2497")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_sealed_record_class_own_record_class>), TypeInfoPropertyName = "T2498")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_sealed_record_class_own_record_class, int>), TypeInfoPropertyName = "T2499")]
-[JsonSerializable(typeof(V_validated_struct_string))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_string>), TypeInfoPropertyName = "T2500")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_string>), TypeInfoPropertyName = "T2501")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_string>), TypeInfoPropertyName = "T2502")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_string>), TypeInfoPropertyName = "T2503")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_string, int>), TypeInfoPropertyName = "T2504")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_string?>), TypeInfoPropertyName = "T2505")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_string?>), TypeInfoPropertyName = "T2506")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_string?>), TypeInfoPropertyName = "T2507")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_string?>), TypeInfoPropertyName = "T2508")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_string?, int>), TypeInfoPropertyName = "T2509")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_string>), TypeInfoPropertyName = "T2510")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_string>), TypeInfoPropertyName = "T2511")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_string>), TypeInfoPropertyName = "T2512")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_string>), TypeInfoPropertyName = "T2513")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_string, int>), TypeInfoPropertyName = "T2514")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_string>>), TypeInfoPropertyName = "T2515")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_string>>), TypeInfoPropertyName = "T2516")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_string>>), TypeInfoPropertyName = "T2517")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_string>>), TypeInfoPropertyName = "T2518")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_string>, int>), TypeInfoPropertyName = "T2519")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_string[]>), TypeInfoPropertyName = "T2520")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_string[]>), TypeInfoPropertyName = "T2521")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_string[]>), TypeInfoPropertyName = "T2522")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_string[]>), TypeInfoPropertyName = "T2523")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_string[], int>), TypeInfoPropertyName = "T2524")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_string>>), TypeInfoPropertyName = "T2525")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_string>>), TypeInfoPropertyName = "T2526")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_string>>), TypeInfoPropertyName = "T2527")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_string>>), TypeInfoPropertyName = "T2528")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_string>, int>), TypeInfoPropertyName = "T2529")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_string>>), TypeInfoPropertyName = "T2530")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_string>>), TypeInfoPropertyName = "T2531")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_string>>), TypeInfoPropertyName = "T2532")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_string>>), TypeInfoPropertyName = "T2533")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_string>, int>), TypeInfoPropertyName = "T2534")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_string, int>>), TypeInfoPropertyName = "T2535")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_string, int>>), TypeInfoPropertyName = "T2536")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_string, int>>), TypeInfoPropertyName = "T2537")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_string, int>>), TypeInfoPropertyName = "T2538")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_string, int>, int>), TypeInfoPropertyName = "T2539")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_string>>), TypeInfoPropertyName = "T2540")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_string>>), TypeInfoPropertyName = "T2541")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_string>>), TypeInfoPropertyName = "T2542")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_string>>), TypeInfoPropertyName = "T2543")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_string>, int>), TypeInfoPropertyName = "T2544")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_string>), TypeInfoPropertyName = "T2545")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_string>), TypeInfoPropertyName = "T2546")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_string>), TypeInfoPropertyName = "T2547")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_string>), TypeInfoPropertyName = "T2548")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_string, int>), TypeInfoPropertyName = "T2549")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_string>), TypeInfoPropertyName = "T2550")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_string>), TypeInfoPropertyName = "T2551")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_string>), TypeInfoPropertyName = "T2552")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_string>), TypeInfoPropertyName = "T2553")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_string, int>), TypeInfoPropertyName = "T2554")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_string>>), TypeInfoPropertyName = "T2555")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_string>>), TypeInfoPropertyName = "T2556")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_string>>), TypeInfoPropertyName = "T2557")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_string>>), TypeInfoPropertyName = "T2558")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_string>, int>), TypeInfoPropertyName = "T2559")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_string>), TypeInfoPropertyName = "T2560")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_string>), TypeInfoPropertyName = "T2561")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_string>), TypeInfoPropertyName = "T2562")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_string>), TypeInfoPropertyName = "T2563")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_string, int>), TypeInfoPropertyName = "T2564")]
-[JsonSerializable(typeof(V_validated_struct_Guid))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_Guid>), TypeInfoPropertyName = "T2565")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_Guid>), TypeInfoPropertyName = "T2566")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_Guid>), TypeInfoPropertyName = "T2567")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_Guid>), TypeInfoPropertyName = "T2568")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_Guid, int>), TypeInfoPropertyName = "T2569")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_Guid?>), TypeInfoPropertyName = "T2570")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_Guid?>), TypeInfoPropertyName = "T2571")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_Guid?>), TypeInfoPropertyName = "T2572")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_Guid?>), TypeInfoPropertyName = "T2573")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_Guid?, int>), TypeInfoPropertyName = "T2574")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_Guid>), TypeInfoPropertyName = "T2575")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_Guid>), TypeInfoPropertyName = "T2576")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_Guid>), TypeInfoPropertyName = "T2577")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_Guid>), TypeInfoPropertyName = "T2578")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_Guid, int>), TypeInfoPropertyName = "T2579")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_Guid>>), TypeInfoPropertyName = "T2580")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_Guid>>), TypeInfoPropertyName = "T2581")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_Guid>>), TypeInfoPropertyName = "T2582")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_Guid>>), TypeInfoPropertyName = "T2583")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_Guid>, int>), TypeInfoPropertyName = "T2584")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_Guid[]>), TypeInfoPropertyName = "T2585")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_Guid[]>), TypeInfoPropertyName = "T2586")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_Guid[]>), TypeInfoPropertyName = "T2587")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_Guid[]>), TypeInfoPropertyName = "T2588")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_Guid[], int>), TypeInfoPropertyName = "T2589")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_Guid>>), TypeInfoPropertyName = "T2590")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_Guid>>), TypeInfoPropertyName = "T2591")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_Guid>>), TypeInfoPropertyName = "T2592")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_Guid>>), TypeInfoPropertyName = "T2593")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_Guid>, int>), TypeInfoPropertyName = "T2594")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_Guid>>), TypeInfoPropertyName = "T2595")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_Guid>>), TypeInfoPropertyName = "T2596")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_Guid>>), TypeInfoPropertyName = "T2597")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_Guid>>), TypeInfoPropertyName = "T2598")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_Guid>, int>), TypeInfoPropertyName = "T2599")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_Guid, int>>), TypeInfoPropertyName = "T2600")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_Guid, int>>), TypeInfoPropertyName = "T2601")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_Guid, int>>), TypeInfoPropertyName = "T2602")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_Guid, int>>), TypeInfoPropertyName = "T2603")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_Guid, int>, int>), TypeInfoPropertyName = "T2604")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_Guid>>), TypeInfoPropertyName = "T2605")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_Guid>>), TypeInfoPropertyName = "T2606")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_Guid>>), TypeInfoPropertyName = "T2607")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_Guid>>), TypeInfoPropertyName = "T2608")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_Guid>, int>), TypeInfoPropertyName = "T2609")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_Guid>), TypeInfoPropertyName = "T2610")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_Guid>), TypeInfoPropertyName = "T2611")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_Guid>), TypeInfoPropertyName = "T2612")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_Guid>), TypeInfoPropertyName = "T2613")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_Guid, int>), TypeInfoPropertyName = "T2614")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_Guid>), TypeInfoPropertyName = "T2615")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_Guid>), TypeInfoPropertyName = "T2616")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_Guid>), TypeInfoPropertyName = "T2617")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_Guid>), TypeInfoPropertyName = "T2618")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_Guid, int>), TypeInfoPropertyName = "T2619")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_Guid>>), TypeInfoPropertyName = "T2620")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_Guid>>), TypeInfoPropertyName = "T2621")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_Guid>>), TypeInfoPropertyName = "T2622")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_Guid>>), TypeInfoPropertyName = "T2623")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_Guid>, int>), TypeInfoPropertyName = "T2624")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_Guid>), TypeInfoPropertyName = "T2625")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_Guid>), TypeInfoPropertyName = "T2626")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_Guid>), TypeInfoPropertyName = "T2627")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_Guid>), TypeInfoPropertyName = "T2628")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_Guid, int>), TypeInfoPropertyName = "T2629")]
-[JsonSerializable(typeof(V_validated_struct_int))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_int>), TypeInfoPropertyName = "T2630")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_int>), TypeInfoPropertyName = "T2631")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_int>), TypeInfoPropertyName = "T2632")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_int>), TypeInfoPropertyName = "T2633")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_int, int>), TypeInfoPropertyName = "T2634")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_int?>), TypeInfoPropertyName = "T2635")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_int?>), TypeInfoPropertyName = "T2636")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_int?>), TypeInfoPropertyName = "T2637")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_int?>), TypeInfoPropertyName = "T2638")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_int?, int>), TypeInfoPropertyName = "T2639")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_int>), TypeInfoPropertyName = "T2640")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_int>), TypeInfoPropertyName = "T2641")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_int>), TypeInfoPropertyName = "T2642")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_int>), TypeInfoPropertyName = "T2643")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_int, int>), TypeInfoPropertyName = "T2644")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_int>>), TypeInfoPropertyName = "T2645")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_int>>), TypeInfoPropertyName = "T2646")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_int>>), TypeInfoPropertyName = "T2647")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_int>>), TypeInfoPropertyName = "T2648")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_int>, int>), TypeInfoPropertyName = "T2649")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_int[]>), TypeInfoPropertyName = "T2650")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_int[]>), TypeInfoPropertyName = "T2651")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_int[]>), TypeInfoPropertyName = "T2652")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_int[]>), TypeInfoPropertyName = "T2653")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_int[], int>), TypeInfoPropertyName = "T2654")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_int>>), TypeInfoPropertyName = "T2655")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_int>>), TypeInfoPropertyName = "T2656")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_int>>), TypeInfoPropertyName = "T2657")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_int>>), TypeInfoPropertyName = "T2658")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_int>, int>), TypeInfoPropertyName = "T2659")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_int>>), TypeInfoPropertyName = "T2660")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_int>>), TypeInfoPropertyName = "T2661")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_int>>), TypeInfoPropertyName = "T2662")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_int>>), TypeInfoPropertyName = "T2663")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_int>, int>), TypeInfoPropertyName = "T2664")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_int, int>>), TypeInfoPropertyName = "T2665")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_int, int>>), TypeInfoPropertyName = "T2666")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_int, int>>), TypeInfoPropertyName = "T2667")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_int, int>>), TypeInfoPropertyName = "T2668")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_int, int>, int>), TypeInfoPropertyName = "T2669")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_int>>), TypeInfoPropertyName = "T2670")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_int>>), TypeInfoPropertyName = "T2671")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_int>>), TypeInfoPropertyName = "T2672")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_int>>), TypeInfoPropertyName = "T2673")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_int>, int>), TypeInfoPropertyName = "T2674")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_int>), TypeInfoPropertyName = "T2675")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_int>), TypeInfoPropertyName = "T2676")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_int>), TypeInfoPropertyName = "T2677")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_int>), TypeInfoPropertyName = "T2678")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_int, int>), TypeInfoPropertyName = "T2679")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_int>), TypeInfoPropertyName = "T2680")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_int>), TypeInfoPropertyName = "T2681")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_int>), TypeInfoPropertyName = "T2682")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_int>), TypeInfoPropertyName = "T2683")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_int, int>), TypeInfoPropertyName = "T2684")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_int>>), TypeInfoPropertyName = "T2685")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_int>>), TypeInfoPropertyName = "T2686")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_int>>), TypeInfoPropertyName = "T2687")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_int>>), TypeInfoPropertyName = "T2688")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_int>, int>), TypeInfoPropertyName = "T2689")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_int>), TypeInfoPropertyName = "T2690")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_int>), TypeInfoPropertyName = "T2691")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_int>), TypeInfoPropertyName = "T2692")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_int>), TypeInfoPropertyName = "T2693")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_int, int>), TypeInfoPropertyName = "T2694")]
-[JsonSerializable(typeof(V_validated_struct_long))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_long>), TypeInfoPropertyName = "T2695")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_long>), TypeInfoPropertyName = "T2696")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_long>), TypeInfoPropertyName = "T2697")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_long>), TypeInfoPropertyName = "T2698")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_long, int>), TypeInfoPropertyName = "T2699")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_long?>), TypeInfoPropertyName = "T2700")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_long?>), TypeInfoPropertyName = "T2701")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_long?>), TypeInfoPropertyName = "T2702")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_long?>), TypeInfoPropertyName = "T2703")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_long?, int>), TypeInfoPropertyName = "T2704")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_long>), TypeInfoPropertyName = "T2705")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_long>), TypeInfoPropertyName = "T2706")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_long>), TypeInfoPropertyName = "T2707")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_long>), TypeInfoPropertyName = "T2708")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_long, int>), TypeInfoPropertyName = "T2709")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_long>>), TypeInfoPropertyName = "T2710")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_long>>), TypeInfoPropertyName = "T2711")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_long>>), TypeInfoPropertyName = "T2712")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_long>>), TypeInfoPropertyName = "T2713")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_long>, int>), TypeInfoPropertyName = "T2714")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_long[]>), TypeInfoPropertyName = "T2715")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_long[]>), TypeInfoPropertyName = "T2716")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_long[]>), TypeInfoPropertyName = "T2717")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_long[]>), TypeInfoPropertyName = "T2718")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_long[], int>), TypeInfoPropertyName = "T2719")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_long>>), TypeInfoPropertyName = "T2720")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_long>>), TypeInfoPropertyName = "T2721")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_long>>), TypeInfoPropertyName = "T2722")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_long>>), TypeInfoPropertyName = "T2723")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_long>, int>), TypeInfoPropertyName = "T2724")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_long>>), TypeInfoPropertyName = "T2725")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_long>>), TypeInfoPropertyName = "T2726")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_long>>), TypeInfoPropertyName = "T2727")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_long>>), TypeInfoPropertyName = "T2728")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_long>, int>), TypeInfoPropertyName = "T2729")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_long, int>>), TypeInfoPropertyName = "T2730")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_long, int>>), TypeInfoPropertyName = "T2731")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_long, int>>), TypeInfoPropertyName = "T2732")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_long, int>>), TypeInfoPropertyName = "T2733")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_long, int>, int>), TypeInfoPropertyName = "T2734")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_long>>), TypeInfoPropertyName = "T2735")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_long>>), TypeInfoPropertyName = "T2736")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_long>>), TypeInfoPropertyName = "T2737")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_long>>), TypeInfoPropertyName = "T2738")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_long>, int>), TypeInfoPropertyName = "T2739")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_long>), TypeInfoPropertyName = "T2740")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_long>), TypeInfoPropertyName = "T2741")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_long>), TypeInfoPropertyName = "T2742")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_long>), TypeInfoPropertyName = "T2743")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_long, int>), TypeInfoPropertyName = "T2744")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_long>), TypeInfoPropertyName = "T2745")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_long>), TypeInfoPropertyName = "T2746")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_long>), TypeInfoPropertyName = "T2747")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_long>), TypeInfoPropertyName = "T2748")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_long, int>), TypeInfoPropertyName = "T2749")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_long>>), TypeInfoPropertyName = "T2750")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_long>>), TypeInfoPropertyName = "T2751")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_long>>), TypeInfoPropertyName = "T2752")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_long>>), TypeInfoPropertyName = "T2753")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_long>, int>), TypeInfoPropertyName = "T2754")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_long>), TypeInfoPropertyName = "T2755")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_long>), TypeInfoPropertyName = "T2756")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_long>), TypeInfoPropertyName = "T2757")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_long>), TypeInfoPropertyName = "T2758")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_long, int>), TypeInfoPropertyName = "T2759")]
-[JsonSerializable(typeof(V_validated_struct_byte))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_byte>), TypeInfoPropertyName = "T2760")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_byte>), TypeInfoPropertyName = "T2761")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_byte>), TypeInfoPropertyName = "T2762")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_byte>), TypeInfoPropertyName = "T2763")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_byte, int>), TypeInfoPropertyName = "T2764")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_byte?>), TypeInfoPropertyName = "T2765")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_byte?>), TypeInfoPropertyName = "T2766")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_byte?>), TypeInfoPropertyName = "T2767")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_byte?>), TypeInfoPropertyName = "T2768")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_byte?, int>), TypeInfoPropertyName = "T2769")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_byte>), TypeInfoPropertyName = "T2770")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_byte>), TypeInfoPropertyName = "T2771")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_byte>), TypeInfoPropertyName = "T2772")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_byte>), TypeInfoPropertyName = "T2773")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_byte, int>), TypeInfoPropertyName = "T2774")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_byte>>), TypeInfoPropertyName = "T2775")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_byte>>), TypeInfoPropertyName = "T2776")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_byte>>), TypeInfoPropertyName = "T2777")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_byte>>), TypeInfoPropertyName = "T2778")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_byte>, int>), TypeInfoPropertyName = "T2779")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_byte[]>), TypeInfoPropertyName = "T2780")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_byte[]>), TypeInfoPropertyName = "T2781")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_byte[]>), TypeInfoPropertyName = "T2782")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_byte[]>), TypeInfoPropertyName = "T2783")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_byte[], int>), TypeInfoPropertyName = "T2784")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_byte>>), TypeInfoPropertyName = "T2785")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_byte>>), TypeInfoPropertyName = "T2786")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_byte>>), TypeInfoPropertyName = "T2787")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_byte>>), TypeInfoPropertyName = "T2788")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_byte>, int>), TypeInfoPropertyName = "T2789")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_byte>>), TypeInfoPropertyName = "T2790")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_byte>>), TypeInfoPropertyName = "T2791")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_byte>>), TypeInfoPropertyName = "T2792")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_byte>>), TypeInfoPropertyName = "T2793")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_byte>, int>), TypeInfoPropertyName = "T2794")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_byte, int>>), TypeInfoPropertyName = "T2795")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_byte, int>>), TypeInfoPropertyName = "T2796")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_byte, int>>), TypeInfoPropertyName = "T2797")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_byte, int>>), TypeInfoPropertyName = "T2798")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_byte, int>, int>), TypeInfoPropertyName = "T2799")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_byte>>), TypeInfoPropertyName = "T2800")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_byte>>), TypeInfoPropertyName = "T2801")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_byte>>), TypeInfoPropertyName = "T2802")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_byte>>), TypeInfoPropertyName = "T2803")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_byte>, int>), TypeInfoPropertyName = "T2804")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_byte>), TypeInfoPropertyName = "T2805")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_byte>), TypeInfoPropertyName = "T2806")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_byte>), TypeInfoPropertyName = "T2807")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_byte>), TypeInfoPropertyName = "T2808")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_byte, int>), TypeInfoPropertyName = "T2809")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_byte>), TypeInfoPropertyName = "T2810")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_byte>), TypeInfoPropertyName = "T2811")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_byte>), TypeInfoPropertyName = "T2812")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_byte>), TypeInfoPropertyName = "T2813")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_byte, int>), TypeInfoPropertyName = "T2814")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_byte>>), TypeInfoPropertyName = "T2815")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_byte>>), TypeInfoPropertyName = "T2816")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_byte>>), TypeInfoPropertyName = "T2817")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_byte>>), TypeInfoPropertyName = "T2818")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_byte>, int>), TypeInfoPropertyName = "T2819")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_byte>), TypeInfoPropertyName = "T2820")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_byte>), TypeInfoPropertyName = "T2821")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_byte>), TypeInfoPropertyName = "T2822")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_byte>), TypeInfoPropertyName = "T2823")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_byte, int>), TypeInfoPropertyName = "T2824")]
-[JsonSerializable(typeof(V_validated_struct_ulong))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_ulong>), TypeInfoPropertyName = "T2825")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_ulong>), TypeInfoPropertyName = "T2826")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_ulong>), TypeInfoPropertyName = "T2827")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_ulong>), TypeInfoPropertyName = "T2828")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_ulong, int>), TypeInfoPropertyName = "T2829")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_ulong?>), TypeInfoPropertyName = "T2830")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_ulong?>), TypeInfoPropertyName = "T2831")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_ulong?>), TypeInfoPropertyName = "T2832")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_ulong?>), TypeInfoPropertyName = "T2833")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_ulong?, int>), TypeInfoPropertyName = "T2834")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_ulong>), TypeInfoPropertyName = "T2835")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_ulong>), TypeInfoPropertyName = "T2836")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_ulong>), TypeInfoPropertyName = "T2837")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_ulong>), TypeInfoPropertyName = "T2838")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_ulong, int>), TypeInfoPropertyName = "T2839")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_ulong>>), TypeInfoPropertyName = "T2840")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_ulong>>), TypeInfoPropertyName = "T2841")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_ulong>>), TypeInfoPropertyName = "T2842")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_ulong>>), TypeInfoPropertyName = "T2843")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_ulong>, int>), TypeInfoPropertyName = "T2844")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_ulong[]>), TypeInfoPropertyName = "T2845")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_ulong[]>), TypeInfoPropertyName = "T2846")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_ulong[]>), TypeInfoPropertyName = "T2847")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_ulong[]>), TypeInfoPropertyName = "T2848")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_ulong[], int>), TypeInfoPropertyName = "T2849")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_ulong>>), TypeInfoPropertyName = "T2850")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_ulong>>), TypeInfoPropertyName = "T2851")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_ulong>>), TypeInfoPropertyName = "T2852")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_ulong>>), TypeInfoPropertyName = "T2853")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_ulong>, int>), TypeInfoPropertyName = "T2854")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_ulong>>), TypeInfoPropertyName = "T2855")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_ulong>>), TypeInfoPropertyName = "T2856")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_ulong>>), TypeInfoPropertyName = "T2857")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_ulong>>), TypeInfoPropertyName = "T2858")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_ulong>, int>), TypeInfoPropertyName = "T2859")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_ulong, int>>), TypeInfoPropertyName = "T2860")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_ulong, int>>), TypeInfoPropertyName = "T2861")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_ulong, int>>), TypeInfoPropertyName = "T2862")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_ulong, int>>), TypeInfoPropertyName = "T2863")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_ulong, int>, int>), TypeInfoPropertyName = "T2864")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_ulong>>), TypeInfoPropertyName = "T2865")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_ulong>>), TypeInfoPropertyName = "T2866")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_ulong>>), TypeInfoPropertyName = "T2867")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_ulong>>), TypeInfoPropertyName = "T2868")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_ulong>, int>), TypeInfoPropertyName = "T2869")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_ulong>), TypeInfoPropertyName = "T2870")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_ulong>), TypeInfoPropertyName = "T2871")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_ulong>), TypeInfoPropertyName = "T2872")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_ulong>), TypeInfoPropertyName = "T2873")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_ulong, int>), TypeInfoPropertyName = "T2874")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_ulong>), TypeInfoPropertyName = "T2875")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_ulong>), TypeInfoPropertyName = "T2876")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_ulong>), TypeInfoPropertyName = "T2877")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_ulong>), TypeInfoPropertyName = "T2878")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_ulong, int>), TypeInfoPropertyName = "T2879")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_ulong>>), TypeInfoPropertyName = "T2880")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_ulong>>), TypeInfoPropertyName = "T2881")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_ulong>>), TypeInfoPropertyName = "T2882")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_ulong>>), TypeInfoPropertyName = "T2883")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_ulong>, int>), TypeInfoPropertyName = "T2884")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_ulong>), TypeInfoPropertyName = "T2885")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_ulong>), TypeInfoPropertyName = "T2886")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_ulong>), TypeInfoPropertyName = "T2887")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_ulong>), TypeInfoPropertyName = "T2888")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_ulong, int>), TypeInfoPropertyName = "T2889")]
-[JsonSerializable(typeof(V_validated_struct_decimal))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_decimal>), TypeInfoPropertyName = "T2890")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_decimal>), TypeInfoPropertyName = "T2891")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_decimal>), TypeInfoPropertyName = "T2892")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_decimal>), TypeInfoPropertyName = "T2893")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_decimal, int>), TypeInfoPropertyName = "T2894")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_decimal?>), TypeInfoPropertyName = "T2895")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_decimal?>), TypeInfoPropertyName = "T2896")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_decimal?>), TypeInfoPropertyName = "T2897")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_decimal?>), TypeInfoPropertyName = "T2898")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_decimal?, int>), TypeInfoPropertyName = "T2899")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_decimal>), TypeInfoPropertyName = "T2900")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_decimal>), TypeInfoPropertyName = "T2901")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_decimal>), TypeInfoPropertyName = "T2902")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_decimal>), TypeInfoPropertyName = "T2903")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_decimal, int>), TypeInfoPropertyName = "T2904")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_decimal>>), TypeInfoPropertyName = "T2905")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_decimal>>), TypeInfoPropertyName = "T2906")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_decimal>>), TypeInfoPropertyName = "T2907")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_decimal>>), TypeInfoPropertyName = "T2908")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_decimal>, int>), TypeInfoPropertyName = "T2909")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_decimal[]>), TypeInfoPropertyName = "T2910")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_decimal[]>), TypeInfoPropertyName = "T2911")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_decimal[]>), TypeInfoPropertyName = "T2912")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_decimal[]>), TypeInfoPropertyName = "T2913")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_decimal[], int>), TypeInfoPropertyName = "T2914")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_decimal>>), TypeInfoPropertyName = "T2915")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_decimal>>), TypeInfoPropertyName = "T2916")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_decimal>>), TypeInfoPropertyName = "T2917")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_decimal>>), TypeInfoPropertyName = "T2918")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_decimal>, int>), TypeInfoPropertyName = "T2919")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_decimal>>), TypeInfoPropertyName = "T2920")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_decimal>>), TypeInfoPropertyName = "T2921")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_decimal>>), TypeInfoPropertyName = "T2922")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_decimal>>), TypeInfoPropertyName = "T2923")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_decimal>, int>), TypeInfoPropertyName = "T2924")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_decimal, int>>), TypeInfoPropertyName = "T2925")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_decimal, int>>), TypeInfoPropertyName = "T2926")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_decimal, int>>), TypeInfoPropertyName = "T2927")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_decimal, int>>), TypeInfoPropertyName = "T2928")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_decimal, int>, int>), TypeInfoPropertyName = "T2929")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_decimal>>), TypeInfoPropertyName = "T2930")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_decimal>>), TypeInfoPropertyName = "T2931")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_decimal>>), TypeInfoPropertyName = "T2932")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_decimal>>), TypeInfoPropertyName = "T2933")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_decimal>, int>), TypeInfoPropertyName = "T2934")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_decimal>), TypeInfoPropertyName = "T2935")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_decimal>), TypeInfoPropertyName = "T2936")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_decimal>), TypeInfoPropertyName = "T2937")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_decimal>), TypeInfoPropertyName = "T2938")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_decimal, int>), TypeInfoPropertyName = "T2939")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_decimal>), TypeInfoPropertyName = "T2940")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_decimal>), TypeInfoPropertyName = "T2941")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_decimal>), TypeInfoPropertyName = "T2942")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_decimal>), TypeInfoPropertyName = "T2943")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_decimal, int>), TypeInfoPropertyName = "T2944")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_decimal>>), TypeInfoPropertyName = "T2945")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_decimal>>), TypeInfoPropertyName = "T2946")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_decimal>>), TypeInfoPropertyName = "T2947")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_decimal>>), TypeInfoPropertyName = "T2948")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_decimal>, int>), TypeInfoPropertyName = "T2949")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_decimal>), TypeInfoPropertyName = "T2950")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_decimal>), TypeInfoPropertyName = "T2951")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_decimal>), TypeInfoPropertyName = "T2952")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_decimal>), TypeInfoPropertyName = "T2953")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_decimal, int>), TypeInfoPropertyName = "T2954")]
-[JsonSerializable(typeof(V_validated_struct_double))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_double>), TypeInfoPropertyName = "T2955")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_double>), TypeInfoPropertyName = "T2956")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_double>), TypeInfoPropertyName = "T2957")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_double>), TypeInfoPropertyName = "T2958")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_double, int>), TypeInfoPropertyName = "T2959")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_double?>), TypeInfoPropertyName = "T2960")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_double?>), TypeInfoPropertyName = "T2961")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_double?>), TypeInfoPropertyName = "T2962")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_double?>), TypeInfoPropertyName = "T2963")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_double?, int>), TypeInfoPropertyName = "T2964")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_double>), TypeInfoPropertyName = "T2965")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_double>), TypeInfoPropertyName = "T2966")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_double>), TypeInfoPropertyName = "T2967")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_double>), TypeInfoPropertyName = "T2968")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_double, int>), TypeInfoPropertyName = "T2969")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_double>>), TypeInfoPropertyName = "T2970")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_double>>), TypeInfoPropertyName = "T2971")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_double>>), TypeInfoPropertyName = "T2972")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_double>>), TypeInfoPropertyName = "T2973")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_double>, int>), TypeInfoPropertyName = "T2974")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_double[]>), TypeInfoPropertyName = "T2975")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_double[]>), TypeInfoPropertyName = "T2976")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_double[]>), TypeInfoPropertyName = "T2977")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_double[]>), TypeInfoPropertyName = "T2978")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_double[], int>), TypeInfoPropertyName = "T2979")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_double>>), TypeInfoPropertyName = "T2980")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_double>>), TypeInfoPropertyName = "T2981")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_double>>), TypeInfoPropertyName = "T2982")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_double>>), TypeInfoPropertyName = "T2983")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_double>, int>), TypeInfoPropertyName = "T2984")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_double>>), TypeInfoPropertyName = "T2985")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_double>>), TypeInfoPropertyName = "T2986")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_double>>), TypeInfoPropertyName = "T2987")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_double>>), TypeInfoPropertyName = "T2988")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_double>, int>), TypeInfoPropertyName = "T2989")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_double, int>>), TypeInfoPropertyName = "T2990")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_double, int>>), TypeInfoPropertyName = "T2991")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_double, int>>), TypeInfoPropertyName = "T2992")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_double, int>>), TypeInfoPropertyName = "T2993")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_double, int>, int>), TypeInfoPropertyName = "T2994")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_double>>), TypeInfoPropertyName = "T2995")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_double>>), TypeInfoPropertyName = "T2996")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_double>>), TypeInfoPropertyName = "T2997")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_double>>), TypeInfoPropertyName = "T2998")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_double>, int>), TypeInfoPropertyName = "T2999")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_double>), TypeInfoPropertyName = "T3000")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_double>), TypeInfoPropertyName = "T3001")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_double>), TypeInfoPropertyName = "T3002")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_double>), TypeInfoPropertyName = "T3003")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_double, int>), TypeInfoPropertyName = "T3004")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_double>), TypeInfoPropertyName = "T3005")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_double>), TypeInfoPropertyName = "T3006")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_double>), TypeInfoPropertyName = "T3007")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_double>), TypeInfoPropertyName = "T3008")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_double, int>), TypeInfoPropertyName = "T3009")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_double>>), TypeInfoPropertyName = "T3010")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_double>>), TypeInfoPropertyName = "T3011")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_double>>), TypeInfoPropertyName = "T3012")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_double>>), TypeInfoPropertyName = "T3013")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_double>, int>), TypeInfoPropertyName = "T3014")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_double>), TypeInfoPropertyName = "T3015")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_double>), TypeInfoPropertyName = "T3016")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_double>), TypeInfoPropertyName = "T3017")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_double>), TypeInfoPropertyName = "T3018")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_double, int>), TypeInfoPropertyName = "T3019")]
-[JsonSerializable(typeof(V_validated_struct_bool))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_bool>), TypeInfoPropertyName = "T3020")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_bool>), TypeInfoPropertyName = "T3021")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_bool>), TypeInfoPropertyName = "T3022")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_bool>), TypeInfoPropertyName = "T3023")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_bool, int>), TypeInfoPropertyName = "T3024")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_bool?>), TypeInfoPropertyName = "T3025")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_bool?>), TypeInfoPropertyName = "T3026")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_bool?>), TypeInfoPropertyName = "T3027")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_bool?>), TypeInfoPropertyName = "T3028")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_bool?, int>), TypeInfoPropertyName = "T3029")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_bool>), TypeInfoPropertyName = "T3030")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_bool>), TypeInfoPropertyName = "T3031")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_bool>), TypeInfoPropertyName = "T3032")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_bool>), TypeInfoPropertyName = "T3033")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_bool, int>), TypeInfoPropertyName = "T3034")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_bool>>), TypeInfoPropertyName = "T3035")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_bool>>), TypeInfoPropertyName = "T3036")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_bool>>), TypeInfoPropertyName = "T3037")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_bool>>), TypeInfoPropertyName = "T3038")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_bool>, int>), TypeInfoPropertyName = "T3039")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_bool[]>), TypeInfoPropertyName = "T3040")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_bool[]>), TypeInfoPropertyName = "T3041")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_bool[]>), TypeInfoPropertyName = "T3042")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_bool[]>), TypeInfoPropertyName = "T3043")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_bool[], int>), TypeInfoPropertyName = "T3044")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_bool>>), TypeInfoPropertyName = "T3045")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_bool>>), TypeInfoPropertyName = "T3046")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_bool>>), TypeInfoPropertyName = "T3047")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_bool>>), TypeInfoPropertyName = "T3048")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_bool>, int>), TypeInfoPropertyName = "T3049")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_bool>>), TypeInfoPropertyName = "T3050")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_bool>>), TypeInfoPropertyName = "T3051")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_bool>>), TypeInfoPropertyName = "T3052")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_bool>>), TypeInfoPropertyName = "T3053")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_bool>, int>), TypeInfoPropertyName = "T3054")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_bool, int>>), TypeInfoPropertyName = "T3055")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_bool, int>>), TypeInfoPropertyName = "T3056")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_bool, int>>), TypeInfoPropertyName = "T3057")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_bool, int>>), TypeInfoPropertyName = "T3058")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_bool, int>, int>), TypeInfoPropertyName = "T3059")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_bool>>), TypeInfoPropertyName = "T3060")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_bool>>), TypeInfoPropertyName = "T3061")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_bool>>), TypeInfoPropertyName = "T3062")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_bool>>), TypeInfoPropertyName = "T3063")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_bool>, int>), TypeInfoPropertyName = "T3064")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_bool>), TypeInfoPropertyName = "T3065")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_bool>), TypeInfoPropertyName = "T3066")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_bool>), TypeInfoPropertyName = "T3067")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_bool>), TypeInfoPropertyName = "T3068")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_bool, int>), TypeInfoPropertyName = "T3069")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_bool>), TypeInfoPropertyName = "T3070")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_bool>), TypeInfoPropertyName = "T3071")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_bool>), TypeInfoPropertyName = "T3072")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_bool>), TypeInfoPropertyName = "T3073")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_bool, int>), TypeInfoPropertyName = "T3074")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_bool>>), TypeInfoPropertyName = "T3075")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_bool>>), TypeInfoPropertyName = "T3076")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_bool>>), TypeInfoPropertyName = "T3077")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_bool>>), TypeInfoPropertyName = "T3078")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_bool>, int>), TypeInfoPropertyName = "T3079")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_bool>), TypeInfoPropertyName = "T3080")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_bool>), TypeInfoPropertyName = "T3081")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_bool>), TypeInfoPropertyName = "T3082")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_bool>), TypeInfoPropertyName = "T3083")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_bool, int>), TypeInfoPropertyName = "T3084")]
-[JsonSerializable(typeof(V_validated_struct_char))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_char>), TypeInfoPropertyName = "T3085")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_char>), TypeInfoPropertyName = "T3086")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_char>), TypeInfoPropertyName = "T3087")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_char>), TypeInfoPropertyName = "T3088")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_char, int>), TypeInfoPropertyName = "T3089")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_char?>), TypeInfoPropertyName = "T3090")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_char?>), TypeInfoPropertyName = "T3091")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_char?>), TypeInfoPropertyName = "T3092")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_char?>), TypeInfoPropertyName = "T3093")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_char?, int>), TypeInfoPropertyName = "T3094")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_char>), TypeInfoPropertyName = "T3095")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_char>), TypeInfoPropertyName = "T3096")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_char>), TypeInfoPropertyName = "T3097")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_char>), TypeInfoPropertyName = "T3098")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_char, int>), TypeInfoPropertyName = "T3099")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_char>>), TypeInfoPropertyName = "T3100")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_char>>), TypeInfoPropertyName = "T3101")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_char>>), TypeInfoPropertyName = "T3102")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_char>>), TypeInfoPropertyName = "T3103")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_char>, int>), TypeInfoPropertyName = "T3104")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_char[]>), TypeInfoPropertyName = "T3105")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_char[]>), TypeInfoPropertyName = "T3106")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_char[]>), TypeInfoPropertyName = "T3107")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_char[]>), TypeInfoPropertyName = "T3108")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_char[], int>), TypeInfoPropertyName = "T3109")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_char>>), TypeInfoPropertyName = "T3110")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_char>>), TypeInfoPropertyName = "T3111")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_char>>), TypeInfoPropertyName = "T3112")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_char>>), TypeInfoPropertyName = "T3113")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_char>, int>), TypeInfoPropertyName = "T3114")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_char>>), TypeInfoPropertyName = "T3115")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_char>>), TypeInfoPropertyName = "T3116")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_char>>), TypeInfoPropertyName = "T3117")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_char>>), TypeInfoPropertyName = "T3118")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_char>, int>), TypeInfoPropertyName = "T3119")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_char, int>>), TypeInfoPropertyName = "T3120")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_char, int>>), TypeInfoPropertyName = "T3121")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_char, int>>), TypeInfoPropertyName = "T3122")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_char, int>>), TypeInfoPropertyName = "T3123")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_char, int>, int>), TypeInfoPropertyName = "T3124")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_char>>), TypeInfoPropertyName = "T3125")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_char>>), TypeInfoPropertyName = "T3126")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_char>>), TypeInfoPropertyName = "T3127")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_char>>), TypeInfoPropertyName = "T3128")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_char>, int>), TypeInfoPropertyName = "T3129")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_char>), TypeInfoPropertyName = "T3130")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_char>), TypeInfoPropertyName = "T3131")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_char>), TypeInfoPropertyName = "T3132")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_char>), TypeInfoPropertyName = "T3133")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_char, int>), TypeInfoPropertyName = "T3134")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_char>), TypeInfoPropertyName = "T3135")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_char>), TypeInfoPropertyName = "T3136")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_char>), TypeInfoPropertyName = "T3137")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_char>), TypeInfoPropertyName = "T3138")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_char, int>), TypeInfoPropertyName = "T3139")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_char>>), TypeInfoPropertyName = "T3140")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_char>>), TypeInfoPropertyName = "T3141")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_char>>), TypeInfoPropertyName = "T3142")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_char>>), TypeInfoPropertyName = "T3143")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_char>, int>), TypeInfoPropertyName = "T3144")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_char>), TypeInfoPropertyName = "T3145")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_char>), TypeInfoPropertyName = "T3146")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_char>), TypeInfoPropertyName = "T3147")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_char>), TypeInfoPropertyName = "T3148")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_char, int>), TypeInfoPropertyName = "T3149")]
-[JsonSerializable(typeof(V_validated_struct_DateTime))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_DateTime>), TypeInfoPropertyName = "T3150")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_DateTime>), TypeInfoPropertyName = "T3151")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_DateTime>), TypeInfoPropertyName = "T3152")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_DateTime>), TypeInfoPropertyName = "T3153")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_DateTime, int>), TypeInfoPropertyName = "T3154")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_DateTime?>), TypeInfoPropertyName = "T3155")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_DateTime?>), TypeInfoPropertyName = "T3156")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_DateTime?>), TypeInfoPropertyName = "T3157")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_DateTime?>), TypeInfoPropertyName = "T3158")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_DateTime?, int>), TypeInfoPropertyName = "T3159")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_DateTime>), TypeInfoPropertyName = "T3160")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_DateTime>), TypeInfoPropertyName = "T3161")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_DateTime>), TypeInfoPropertyName = "T3162")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_DateTime>), TypeInfoPropertyName = "T3163")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_DateTime, int>), TypeInfoPropertyName = "T3164")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3165")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3166")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3167")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3168")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_DateTime>, int>), TypeInfoPropertyName = "T3169")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_DateTime[]>), TypeInfoPropertyName = "T3170")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_DateTime[]>), TypeInfoPropertyName = "T3171")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_DateTime[]>), TypeInfoPropertyName = "T3172")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_DateTime[]>), TypeInfoPropertyName = "T3173")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_DateTime[], int>), TypeInfoPropertyName = "T3174")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3175")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3176")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3177")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3178")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_DateTime>, int>), TypeInfoPropertyName = "T3179")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3180")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3181")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3182")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3183")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_DateTime>, int>), TypeInfoPropertyName = "T3184")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_DateTime, int>>), TypeInfoPropertyName = "T3185")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_DateTime, int>>), TypeInfoPropertyName = "T3186")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_DateTime, int>>), TypeInfoPropertyName = "T3187")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_DateTime, int>>), TypeInfoPropertyName = "T3188")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_DateTime, int>, int>), TypeInfoPropertyName = "T3189")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3190")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3191")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3192")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3193")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_DateTime>, int>), TypeInfoPropertyName = "T3194")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_DateTime>), TypeInfoPropertyName = "T3195")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_DateTime>), TypeInfoPropertyName = "T3196")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_DateTime>), TypeInfoPropertyName = "T3197")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_DateTime>), TypeInfoPropertyName = "T3198")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_DateTime, int>), TypeInfoPropertyName = "T3199")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_DateTime>), TypeInfoPropertyName = "T3200")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_DateTime>), TypeInfoPropertyName = "T3201")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_DateTime>), TypeInfoPropertyName = "T3202")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_DateTime>), TypeInfoPropertyName = "T3203")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_DateTime, int>), TypeInfoPropertyName = "T3204")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3205")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3206")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3207")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_DateTime>>), TypeInfoPropertyName = "T3208")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_DateTime>, int>), TypeInfoPropertyName = "T3209")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_DateTime>), TypeInfoPropertyName = "T3210")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_DateTime>), TypeInfoPropertyName = "T3211")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_DateTime>), TypeInfoPropertyName = "T3212")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_DateTime>), TypeInfoPropertyName = "T3213")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_DateTime, int>), TypeInfoPropertyName = "T3214")]
-[JsonSerializable(typeof(V_validated_struct_DateTimeOffset))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3215")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3216")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3217")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3218")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_DateTimeOffset, int>), TypeInfoPropertyName = "T3219")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_DateTimeOffset?>), TypeInfoPropertyName = "T3220")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_DateTimeOffset?>), TypeInfoPropertyName = "T3221")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_DateTimeOffset?>), TypeInfoPropertyName = "T3222")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_DateTimeOffset?>), TypeInfoPropertyName = "T3223")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_DateTimeOffset?, int>), TypeInfoPropertyName = "T3224")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3225")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3226")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3227")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3228")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_DateTimeOffset, int>), TypeInfoPropertyName = "T3229")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3230")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3231")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3232")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3233")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_DateTimeOffset>, int>), TypeInfoPropertyName = "T3234")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_DateTimeOffset[]>), TypeInfoPropertyName = "T3235")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_DateTimeOffset[]>), TypeInfoPropertyName = "T3236")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_DateTimeOffset[]>), TypeInfoPropertyName = "T3237")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_DateTimeOffset[]>), TypeInfoPropertyName = "T3238")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_DateTimeOffset[], int>), TypeInfoPropertyName = "T3239")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3240")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3241")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3242")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3243")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_DateTimeOffset>, int>), TypeInfoPropertyName = "T3244")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3245")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3246")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3247")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3248")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_DateTimeOffset>, int>), TypeInfoPropertyName = "T3249")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_DateTimeOffset, int>>), TypeInfoPropertyName = "T3250")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_DateTimeOffset, int>>), TypeInfoPropertyName = "T3251")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_DateTimeOffset, int>>), TypeInfoPropertyName = "T3252")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_DateTimeOffset, int>>), TypeInfoPropertyName = "T3253")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_DateTimeOffset, int>, int>), TypeInfoPropertyName = "T3254")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3255")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3256")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3257")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3258")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_DateTimeOffset>, int>), TypeInfoPropertyName = "T3259")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3260")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3261")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3262")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3263")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_DateTimeOffset, int>), TypeInfoPropertyName = "T3264")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3265")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3266")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3267")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3268")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_DateTimeOffset, int>), TypeInfoPropertyName = "T3269")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3270")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3271")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3272")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_DateTimeOffset>>), TypeInfoPropertyName = "T3273")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_DateTimeOffset>, int>), TypeInfoPropertyName = "T3274")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3275")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3276")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3277")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_DateTimeOffset>), TypeInfoPropertyName = "T3278")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_DateTimeOffset, int>), TypeInfoPropertyName = "T3279")]
-[JsonSerializable(typeof(V_validated_struct_DateOnly))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3280")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3281")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3282")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3283")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_DateOnly, int>), TypeInfoPropertyName = "T3284")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_DateOnly?>), TypeInfoPropertyName = "T3285")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_DateOnly?>), TypeInfoPropertyName = "T3286")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_DateOnly?>), TypeInfoPropertyName = "T3287")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_DateOnly?>), TypeInfoPropertyName = "T3288")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_DateOnly?, int>), TypeInfoPropertyName = "T3289")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3290")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3291")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3292")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3293")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_DateOnly, int>), TypeInfoPropertyName = "T3294")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3295")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3296")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3297")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3298")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_DateOnly>, int>), TypeInfoPropertyName = "T3299")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_DateOnly[]>), TypeInfoPropertyName = "T3300")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_DateOnly[]>), TypeInfoPropertyName = "T3301")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_DateOnly[]>), TypeInfoPropertyName = "T3302")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_DateOnly[]>), TypeInfoPropertyName = "T3303")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_DateOnly[], int>), TypeInfoPropertyName = "T3304")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3305")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3306")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3307")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3308")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_DateOnly>, int>), TypeInfoPropertyName = "T3309")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3310")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3311")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3312")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3313")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_DateOnly>, int>), TypeInfoPropertyName = "T3314")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_DateOnly, int>>), TypeInfoPropertyName = "T3315")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_DateOnly, int>>), TypeInfoPropertyName = "T3316")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_DateOnly, int>>), TypeInfoPropertyName = "T3317")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_DateOnly, int>>), TypeInfoPropertyName = "T3318")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_DateOnly, int>, int>), TypeInfoPropertyName = "T3319")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3320")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3321")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3322")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3323")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_DateOnly>, int>), TypeInfoPropertyName = "T3324")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3325")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3326")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3327")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3328")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_DateOnly, int>), TypeInfoPropertyName = "T3329")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3330")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3331")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3332")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3333")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_DateOnly, int>), TypeInfoPropertyName = "T3334")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3335")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3336")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3337")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_DateOnly>>), TypeInfoPropertyName = "T3338")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_DateOnly>, int>), TypeInfoPropertyName = "T3339")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3340")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3341")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3342")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_DateOnly>), TypeInfoPropertyName = "T3343")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_DateOnly, int>), TypeInfoPropertyName = "T3344")]
-[JsonSerializable(typeof(V_validated_struct_TimeOnly))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3345")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3346")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3347")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3348")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_TimeOnly, int>), TypeInfoPropertyName = "T3349")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_TimeOnly?>), TypeInfoPropertyName = "T3350")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_TimeOnly?>), TypeInfoPropertyName = "T3351")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_TimeOnly?>), TypeInfoPropertyName = "T3352")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_TimeOnly?>), TypeInfoPropertyName = "T3353")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_TimeOnly?, int>), TypeInfoPropertyName = "T3354")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3355")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3356")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3357")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3358")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_TimeOnly, int>), TypeInfoPropertyName = "T3359")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3360")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3361")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3362")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3363")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_TimeOnly>, int>), TypeInfoPropertyName = "T3364")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_TimeOnly[]>), TypeInfoPropertyName = "T3365")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_TimeOnly[]>), TypeInfoPropertyName = "T3366")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_TimeOnly[]>), TypeInfoPropertyName = "T3367")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_TimeOnly[]>), TypeInfoPropertyName = "T3368")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_TimeOnly[], int>), TypeInfoPropertyName = "T3369")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3370")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3371")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3372")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3373")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_TimeOnly>, int>), TypeInfoPropertyName = "T3374")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3375")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3376")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3377")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3378")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_TimeOnly>, int>), TypeInfoPropertyName = "T3379")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_TimeOnly, int>>), TypeInfoPropertyName = "T3380")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_TimeOnly, int>>), TypeInfoPropertyName = "T3381")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_TimeOnly, int>>), TypeInfoPropertyName = "T3382")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_TimeOnly, int>>), TypeInfoPropertyName = "T3383")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_TimeOnly, int>, int>), TypeInfoPropertyName = "T3384")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3385")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3386")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3387")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3388")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_TimeOnly>, int>), TypeInfoPropertyName = "T3389")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3390")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3391")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3392")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3393")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_TimeOnly, int>), TypeInfoPropertyName = "T3394")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3395")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3396")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3397")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3398")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_TimeOnly, int>), TypeInfoPropertyName = "T3399")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3400")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3401")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3402")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_TimeOnly>>), TypeInfoPropertyName = "T3403")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_TimeOnly>, int>), TypeInfoPropertyName = "T3404")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3405")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3406")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3407")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_TimeOnly>), TypeInfoPropertyName = "T3408")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_TimeOnly, int>), TypeInfoPropertyName = "T3409")]
-[JsonSerializable(typeof(V_validated_struct_TimeSpan))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3410")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3411")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3412")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3413")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_TimeSpan, int>), TypeInfoPropertyName = "T3414")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_TimeSpan?>), TypeInfoPropertyName = "T3415")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_TimeSpan?>), TypeInfoPropertyName = "T3416")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_TimeSpan?>), TypeInfoPropertyName = "T3417")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_TimeSpan?>), TypeInfoPropertyName = "T3418")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_TimeSpan?, int>), TypeInfoPropertyName = "T3419")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3420")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3421")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3422")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3423")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_TimeSpan, int>), TypeInfoPropertyName = "T3424")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3425")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3426")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3427")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3428")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_TimeSpan>, int>), TypeInfoPropertyName = "T3429")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_TimeSpan[]>), TypeInfoPropertyName = "T3430")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_TimeSpan[]>), TypeInfoPropertyName = "T3431")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_TimeSpan[]>), TypeInfoPropertyName = "T3432")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_TimeSpan[]>), TypeInfoPropertyName = "T3433")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_TimeSpan[], int>), TypeInfoPropertyName = "T3434")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3435")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3436")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3437")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3438")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_TimeSpan>, int>), TypeInfoPropertyName = "T3439")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3440")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3441")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3442")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3443")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_TimeSpan>, int>), TypeInfoPropertyName = "T3444")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_TimeSpan, int>>), TypeInfoPropertyName = "T3445")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_TimeSpan, int>>), TypeInfoPropertyName = "T3446")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_TimeSpan, int>>), TypeInfoPropertyName = "T3447")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_TimeSpan, int>>), TypeInfoPropertyName = "T3448")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_TimeSpan, int>, int>), TypeInfoPropertyName = "T3449")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3450")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3451")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3452")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3453")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_TimeSpan>, int>), TypeInfoPropertyName = "T3454")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3455")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3456")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3457")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3458")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_TimeSpan, int>), TypeInfoPropertyName = "T3459")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3460")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3461")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3462")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3463")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_TimeSpan, int>), TypeInfoPropertyName = "T3464")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3465")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3466")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3467")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_TimeSpan>>), TypeInfoPropertyName = "T3468")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_TimeSpan>, int>), TypeInfoPropertyName = "T3469")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3470")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3471")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3472")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_TimeSpan>), TypeInfoPropertyName = "T3473")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_TimeSpan, int>), TypeInfoPropertyName = "T3474")]
-[JsonSerializable(typeof(V_validated_struct_enum))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_enum>), TypeInfoPropertyName = "T3475")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_enum>), TypeInfoPropertyName = "T3476")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_enum>), TypeInfoPropertyName = "T3477")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_enum>), TypeInfoPropertyName = "T3478")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_enum, int>), TypeInfoPropertyName = "T3479")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_enum?>), TypeInfoPropertyName = "T3480")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_enum?>), TypeInfoPropertyName = "T3481")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_enum?>), TypeInfoPropertyName = "T3482")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_enum?>), TypeInfoPropertyName = "T3483")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_enum?, int>), TypeInfoPropertyName = "T3484")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_enum>), TypeInfoPropertyName = "T3485")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_enum>), TypeInfoPropertyName = "T3486")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_enum>), TypeInfoPropertyName = "T3487")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_enum>), TypeInfoPropertyName = "T3488")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_enum, int>), TypeInfoPropertyName = "T3489")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_enum>>), TypeInfoPropertyName = "T3490")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_enum>>), TypeInfoPropertyName = "T3491")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_enum>>), TypeInfoPropertyName = "T3492")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_enum>>), TypeInfoPropertyName = "T3493")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_enum>, int>), TypeInfoPropertyName = "T3494")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_enum[]>), TypeInfoPropertyName = "T3495")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_enum[]>), TypeInfoPropertyName = "T3496")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_enum[]>), TypeInfoPropertyName = "T3497")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_enum[]>), TypeInfoPropertyName = "T3498")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_enum[], int>), TypeInfoPropertyName = "T3499")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_enum>>), TypeInfoPropertyName = "T3500")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_enum>>), TypeInfoPropertyName = "T3501")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_enum>>), TypeInfoPropertyName = "T3502")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_enum>>), TypeInfoPropertyName = "T3503")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_enum>, int>), TypeInfoPropertyName = "T3504")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_enum>>), TypeInfoPropertyName = "T3505")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_enum>>), TypeInfoPropertyName = "T3506")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_enum>>), TypeInfoPropertyName = "T3507")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_enum>>), TypeInfoPropertyName = "T3508")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_enum>, int>), TypeInfoPropertyName = "T3509")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_enum, int>>), TypeInfoPropertyName = "T3510")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_enum, int>>), TypeInfoPropertyName = "T3511")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_enum, int>>), TypeInfoPropertyName = "T3512")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_enum, int>>), TypeInfoPropertyName = "T3513")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_enum, int>, int>), TypeInfoPropertyName = "T3514")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_enum>>), TypeInfoPropertyName = "T3515")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_enum>>), TypeInfoPropertyName = "T3516")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_enum>>), TypeInfoPropertyName = "T3517")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_enum>>), TypeInfoPropertyName = "T3518")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_enum>, int>), TypeInfoPropertyName = "T3519")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_enum>), TypeInfoPropertyName = "T3520")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_enum>), TypeInfoPropertyName = "T3521")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_enum>), TypeInfoPropertyName = "T3522")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_enum>), TypeInfoPropertyName = "T3523")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_enum, int>), TypeInfoPropertyName = "T3524")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_enum>), TypeInfoPropertyName = "T3525")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_enum>), TypeInfoPropertyName = "T3526")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_enum>), TypeInfoPropertyName = "T3527")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_enum>), TypeInfoPropertyName = "T3528")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_enum, int>), TypeInfoPropertyName = "T3529")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_enum>>), TypeInfoPropertyName = "T3530")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_enum>>), TypeInfoPropertyName = "T3531")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_enum>>), TypeInfoPropertyName = "T3532")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_enum>>), TypeInfoPropertyName = "T3533")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_enum>, int>), TypeInfoPropertyName = "T3534")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_enum>), TypeInfoPropertyName = "T3535")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_enum>), TypeInfoPropertyName = "T3536")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_enum>), TypeInfoPropertyName = "T3537")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_enum>), TypeInfoPropertyName = "T3538")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_enum, int>), TypeInfoPropertyName = "T3539")]
-[JsonSerializable(typeof(V_validated_struct_flags_enum))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3540")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3541")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3542")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3543")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_flags_enum, int>), TypeInfoPropertyName = "T3544")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_flags_enum?>), TypeInfoPropertyName = "T3545")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_flags_enum?>), TypeInfoPropertyName = "T3546")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_flags_enum?>), TypeInfoPropertyName = "T3547")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_flags_enum?>), TypeInfoPropertyName = "T3548")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_flags_enum?, int>), TypeInfoPropertyName = "T3549")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3550")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3551")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3552")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3553")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_flags_enum, int>), TypeInfoPropertyName = "T3554")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3555")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3556")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3557")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3558")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_flags_enum>, int>), TypeInfoPropertyName = "T3559")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_flags_enum[]>), TypeInfoPropertyName = "T3560")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_flags_enum[]>), TypeInfoPropertyName = "T3561")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_flags_enum[]>), TypeInfoPropertyName = "T3562")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_flags_enum[]>), TypeInfoPropertyName = "T3563")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_flags_enum[], int>), TypeInfoPropertyName = "T3564")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3565")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3566")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3567")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3568")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_flags_enum>, int>), TypeInfoPropertyName = "T3569")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3570")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3571")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3572")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3573")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_flags_enum>, int>), TypeInfoPropertyName = "T3574")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_flags_enum, int>>), TypeInfoPropertyName = "T3575")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_flags_enum, int>>), TypeInfoPropertyName = "T3576")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_flags_enum, int>>), TypeInfoPropertyName = "T3577")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_flags_enum, int>>), TypeInfoPropertyName = "T3578")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_flags_enum, int>, int>), TypeInfoPropertyName = "T3579")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3580")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3581")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3582")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3583")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_flags_enum>, int>), TypeInfoPropertyName = "T3584")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3585")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3586")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3587")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3588")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_flags_enum, int>), TypeInfoPropertyName = "T3589")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3590")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3591")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3592")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3593")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_flags_enum, int>), TypeInfoPropertyName = "T3594")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3595")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3596")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3597")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_flags_enum>>), TypeInfoPropertyName = "T3598")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_flags_enum>, int>), TypeInfoPropertyName = "T3599")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3600")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3601")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3602")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_flags_enum>), TypeInfoPropertyName = "T3603")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_flags_enum, int>), TypeInfoPropertyName = "T3604")]
-[JsonSerializable(typeof(V_validated_struct_Uri))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_Uri>), TypeInfoPropertyName = "T3605")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_Uri>), TypeInfoPropertyName = "T3606")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_Uri>), TypeInfoPropertyName = "T3607")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_Uri>), TypeInfoPropertyName = "T3608")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_Uri, int>), TypeInfoPropertyName = "T3609")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_Uri?>), TypeInfoPropertyName = "T3610")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_Uri?>), TypeInfoPropertyName = "T3611")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_Uri?>), TypeInfoPropertyName = "T3612")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_Uri?>), TypeInfoPropertyName = "T3613")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_Uri?, int>), TypeInfoPropertyName = "T3614")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_Uri>), TypeInfoPropertyName = "T3615")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_Uri>), TypeInfoPropertyName = "T3616")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_Uri>), TypeInfoPropertyName = "T3617")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_Uri>), TypeInfoPropertyName = "T3618")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_Uri, int>), TypeInfoPropertyName = "T3619")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_Uri>>), TypeInfoPropertyName = "T3620")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_Uri>>), TypeInfoPropertyName = "T3621")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_Uri>>), TypeInfoPropertyName = "T3622")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_Uri>>), TypeInfoPropertyName = "T3623")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_Uri>, int>), TypeInfoPropertyName = "T3624")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_Uri[]>), TypeInfoPropertyName = "T3625")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_Uri[]>), TypeInfoPropertyName = "T3626")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_Uri[]>), TypeInfoPropertyName = "T3627")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_Uri[]>), TypeInfoPropertyName = "T3628")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_Uri[], int>), TypeInfoPropertyName = "T3629")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_Uri>>), TypeInfoPropertyName = "T3630")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_Uri>>), TypeInfoPropertyName = "T3631")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_Uri>>), TypeInfoPropertyName = "T3632")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_Uri>>), TypeInfoPropertyName = "T3633")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_Uri>, int>), TypeInfoPropertyName = "T3634")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_Uri>>), TypeInfoPropertyName = "T3635")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_Uri>>), TypeInfoPropertyName = "T3636")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_Uri>>), TypeInfoPropertyName = "T3637")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_Uri>>), TypeInfoPropertyName = "T3638")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_Uri>, int>), TypeInfoPropertyName = "T3639")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_Uri, int>>), TypeInfoPropertyName = "T3640")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_Uri, int>>), TypeInfoPropertyName = "T3641")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_Uri, int>>), TypeInfoPropertyName = "T3642")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_Uri, int>>), TypeInfoPropertyName = "T3643")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_Uri, int>, int>), TypeInfoPropertyName = "T3644")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_Uri>>), TypeInfoPropertyName = "T3645")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_Uri>>), TypeInfoPropertyName = "T3646")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_Uri>>), TypeInfoPropertyName = "T3647")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_Uri>>), TypeInfoPropertyName = "T3648")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_Uri>, int>), TypeInfoPropertyName = "T3649")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_Uri>), TypeInfoPropertyName = "T3650")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_Uri>), TypeInfoPropertyName = "T3651")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_Uri>), TypeInfoPropertyName = "T3652")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_Uri>), TypeInfoPropertyName = "T3653")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_Uri, int>), TypeInfoPropertyName = "T3654")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_Uri>), TypeInfoPropertyName = "T3655")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_Uri>), TypeInfoPropertyName = "T3656")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_Uri>), TypeInfoPropertyName = "T3657")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_Uri>), TypeInfoPropertyName = "T3658")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_Uri, int>), TypeInfoPropertyName = "T3659")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_Uri>>), TypeInfoPropertyName = "T3660")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_Uri>>), TypeInfoPropertyName = "T3661")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_Uri>>), TypeInfoPropertyName = "T3662")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_Uri>>), TypeInfoPropertyName = "T3663")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_Uri>, int>), TypeInfoPropertyName = "T3664")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_Uri>), TypeInfoPropertyName = "T3665")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_Uri>), TypeInfoPropertyName = "T3666")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_Uri>), TypeInfoPropertyName = "T3667")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_Uri>), TypeInfoPropertyName = "T3668")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_Uri, int>), TypeInfoPropertyName = "T3669")]
-[JsonSerializable(typeof(V_validated_struct_NodaTime_Instant))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3670")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3671")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3672")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3673")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_NodaTime_Instant, int>), TypeInfoPropertyName = "T3674")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T3675")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T3676")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T3677")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T3678")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_NodaTime_Instant?, int>), TypeInfoPropertyName = "T3679")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3680")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3681")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3682")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3683")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_NodaTime_Instant, int>), TypeInfoPropertyName = "T3684")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3685")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3686")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3687")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3688")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_NodaTime_Instant>, int>), TypeInfoPropertyName = "T3689")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_NodaTime_Instant[]>), TypeInfoPropertyName = "T3690")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_NodaTime_Instant[]>), TypeInfoPropertyName = "T3691")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_NodaTime_Instant[]>), TypeInfoPropertyName = "T3692")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_NodaTime_Instant[]>), TypeInfoPropertyName = "T3693")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_NodaTime_Instant[], int>), TypeInfoPropertyName = "T3694")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3695")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3696")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3697")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3698")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_NodaTime_Instant>, int>), TypeInfoPropertyName = "T3699")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3700")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3701")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3702")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3703")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_NodaTime_Instant>, int>), TypeInfoPropertyName = "T3704")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_NodaTime_Instant, int>>), TypeInfoPropertyName = "T3705")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_NodaTime_Instant, int>>), TypeInfoPropertyName = "T3706")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_NodaTime_Instant, int>>), TypeInfoPropertyName = "T3707")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_NodaTime_Instant, int>>), TypeInfoPropertyName = "T3708")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_NodaTime_Instant, int>, int>), TypeInfoPropertyName = "T3709")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3710")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3711")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3712")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3713")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_NodaTime_Instant>, int>), TypeInfoPropertyName = "T3714")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3715")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3716")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3717")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3718")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_NodaTime_Instant, int>), TypeInfoPropertyName = "T3719")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3720")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3721")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3722")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3723")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_NodaTime_Instant, int>), TypeInfoPropertyName = "T3724")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3725")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3726")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3727")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_NodaTime_Instant>>), TypeInfoPropertyName = "T3728")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_NodaTime_Instant>, int>), TypeInfoPropertyName = "T3729")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3730")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3731")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3732")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_NodaTime_Instant>), TypeInfoPropertyName = "T3733")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_NodaTime_Instant, int>), TypeInfoPropertyName = "T3734")]
-[JsonSerializable(typeof(V_validated_struct_own_record_class))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3735")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3736")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3737")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3738")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_own_record_class, int>), TypeInfoPropertyName = "T3739")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_own_record_class?>), TypeInfoPropertyName = "T3740")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_own_record_class?>), TypeInfoPropertyName = "T3741")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_own_record_class?>), TypeInfoPropertyName = "T3742")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_own_record_class?>), TypeInfoPropertyName = "T3743")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_own_record_class?, int>), TypeInfoPropertyName = "T3744")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3745")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3746")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3747")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3748")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_own_record_class, int>), TypeInfoPropertyName = "T3749")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3750")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3751")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3752")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3753")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_own_record_class>, int>), TypeInfoPropertyName = "T3754")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_own_record_class[]>), TypeInfoPropertyName = "T3755")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_own_record_class[]>), TypeInfoPropertyName = "T3756")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_own_record_class[]>), TypeInfoPropertyName = "T3757")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_own_record_class[]>), TypeInfoPropertyName = "T3758")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_own_record_class[], int>), TypeInfoPropertyName = "T3759")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3760")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3761")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3762")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3763")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_own_record_class>, int>), TypeInfoPropertyName = "T3764")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3765")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3766")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3767")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3768")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_own_record_class>, int>), TypeInfoPropertyName = "T3769")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_struct_own_record_class, int>>), TypeInfoPropertyName = "T3770")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_struct_own_record_class, int>>), TypeInfoPropertyName = "T3771")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_struct_own_record_class, int>>), TypeInfoPropertyName = "T3772")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_struct_own_record_class, int>>), TypeInfoPropertyName = "T3773")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_struct_own_record_class, int>, int>), TypeInfoPropertyName = "T3774")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3775")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3776")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3777")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3778")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_own_record_class>, int>), TypeInfoPropertyName = "T3779")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3780")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3781")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3782")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3783")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_own_record_class, int>), TypeInfoPropertyName = "T3784")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3785")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3786")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3787")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3788")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_own_record_class, int>), TypeInfoPropertyName = "T3789")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3790")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3791")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3792")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_struct_own_record_class>>), TypeInfoPropertyName = "T3793")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_struct_own_record_class>, int>), TypeInfoPropertyName = "T3794")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3795")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3796")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3797")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_struct_own_record_class>), TypeInfoPropertyName = "T3798")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_struct_own_record_class, int>), TypeInfoPropertyName = "T3799")]
-[JsonSerializable(typeof(V_validated_class_string))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_string>), TypeInfoPropertyName = "T3800")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_string>), TypeInfoPropertyName = "T3801")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_string>), TypeInfoPropertyName = "T3802")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_string>), TypeInfoPropertyName = "T3803")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_string, int>), TypeInfoPropertyName = "T3804")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_string>), TypeInfoPropertyName = "T3805")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_string>), TypeInfoPropertyName = "T3806")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_string>), TypeInfoPropertyName = "T3807")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_string>), TypeInfoPropertyName = "T3808")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_string, int>), TypeInfoPropertyName = "T3809")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_string>>), TypeInfoPropertyName = "T3810")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_string>>), TypeInfoPropertyName = "T3811")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_string>>), TypeInfoPropertyName = "T3812")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_string>>), TypeInfoPropertyName = "T3813")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_string>, int>), TypeInfoPropertyName = "T3814")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_string[]>), TypeInfoPropertyName = "T3815")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_string[]>), TypeInfoPropertyName = "T3816")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_string[]>), TypeInfoPropertyName = "T3817")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_string[]>), TypeInfoPropertyName = "T3818")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_string[], int>), TypeInfoPropertyName = "T3819")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_string>>), TypeInfoPropertyName = "T3820")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_string>>), TypeInfoPropertyName = "T3821")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_string>>), TypeInfoPropertyName = "T3822")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_string>>), TypeInfoPropertyName = "T3823")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_string>, int>), TypeInfoPropertyName = "T3824")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_string>>), TypeInfoPropertyName = "T3825")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_string>>), TypeInfoPropertyName = "T3826")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_string>>), TypeInfoPropertyName = "T3827")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_string>>), TypeInfoPropertyName = "T3828")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_string>, int>), TypeInfoPropertyName = "T3829")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_string, int>>), TypeInfoPropertyName = "T3830")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_string, int>>), TypeInfoPropertyName = "T3831")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_string, int>>), TypeInfoPropertyName = "T3832")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_string, int>>), TypeInfoPropertyName = "T3833")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_string, int>, int>), TypeInfoPropertyName = "T3834")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_string>>), TypeInfoPropertyName = "T3835")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_string>>), TypeInfoPropertyName = "T3836")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_string>>), TypeInfoPropertyName = "T3837")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_string>>), TypeInfoPropertyName = "T3838")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_string>, int>), TypeInfoPropertyName = "T3839")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_string>), TypeInfoPropertyName = "T3840")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_string>), TypeInfoPropertyName = "T3841")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_string>), TypeInfoPropertyName = "T3842")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_string>), TypeInfoPropertyName = "T3843")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_string, int>), TypeInfoPropertyName = "T3844")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_string>), TypeInfoPropertyName = "T3845")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_string>), TypeInfoPropertyName = "T3846")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_string>), TypeInfoPropertyName = "T3847")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_string>), TypeInfoPropertyName = "T3848")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_string, int>), TypeInfoPropertyName = "T3849")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_string>>), TypeInfoPropertyName = "T3850")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_string>>), TypeInfoPropertyName = "T3851")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_string>>), TypeInfoPropertyName = "T3852")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_string>>), TypeInfoPropertyName = "T3853")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_string>, int>), TypeInfoPropertyName = "T3854")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_string>), TypeInfoPropertyName = "T3855")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_string>), TypeInfoPropertyName = "T3856")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_string>), TypeInfoPropertyName = "T3857")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_string>), TypeInfoPropertyName = "T3858")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_string, int>), TypeInfoPropertyName = "T3859")]
-[JsonSerializable(typeof(V_validated_class_Guid))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_Guid>), TypeInfoPropertyName = "T3860")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_Guid>), TypeInfoPropertyName = "T3861")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_Guid>), TypeInfoPropertyName = "T3862")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_Guid>), TypeInfoPropertyName = "T3863")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_Guid, int>), TypeInfoPropertyName = "T3864")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_Guid>), TypeInfoPropertyName = "T3865")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_Guid>), TypeInfoPropertyName = "T3866")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_Guid>), TypeInfoPropertyName = "T3867")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_Guid>), TypeInfoPropertyName = "T3868")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_Guid, int>), TypeInfoPropertyName = "T3869")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_Guid>>), TypeInfoPropertyName = "T3870")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_Guid>>), TypeInfoPropertyName = "T3871")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_Guid>>), TypeInfoPropertyName = "T3872")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_Guid>>), TypeInfoPropertyName = "T3873")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_Guid>, int>), TypeInfoPropertyName = "T3874")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_Guid[]>), TypeInfoPropertyName = "T3875")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_Guid[]>), TypeInfoPropertyName = "T3876")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_Guid[]>), TypeInfoPropertyName = "T3877")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_Guid[]>), TypeInfoPropertyName = "T3878")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_Guid[], int>), TypeInfoPropertyName = "T3879")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_Guid>>), TypeInfoPropertyName = "T3880")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_Guid>>), TypeInfoPropertyName = "T3881")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_Guid>>), TypeInfoPropertyName = "T3882")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_Guid>>), TypeInfoPropertyName = "T3883")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_Guid>, int>), TypeInfoPropertyName = "T3884")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_Guid>>), TypeInfoPropertyName = "T3885")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_Guid>>), TypeInfoPropertyName = "T3886")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_Guid>>), TypeInfoPropertyName = "T3887")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_Guid>>), TypeInfoPropertyName = "T3888")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_Guid>, int>), TypeInfoPropertyName = "T3889")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_Guid, int>>), TypeInfoPropertyName = "T3890")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_Guid, int>>), TypeInfoPropertyName = "T3891")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_Guid, int>>), TypeInfoPropertyName = "T3892")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_Guid, int>>), TypeInfoPropertyName = "T3893")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_Guid, int>, int>), TypeInfoPropertyName = "T3894")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_Guid>>), TypeInfoPropertyName = "T3895")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_Guid>>), TypeInfoPropertyName = "T3896")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_Guid>>), TypeInfoPropertyName = "T3897")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_Guid>>), TypeInfoPropertyName = "T3898")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_Guid>, int>), TypeInfoPropertyName = "T3899")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_Guid>), TypeInfoPropertyName = "T3900")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_Guid>), TypeInfoPropertyName = "T3901")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_Guid>), TypeInfoPropertyName = "T3902")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_Guid>), TypeInfoPropertyName = "T3903")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_Guid, int>), TypeInfoPropertyName = "T3904")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_Guid>), TypeInfoPropertyName = "T3905")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_Guid>), TypeInfoPropertyName = "T3906")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_Guid>), TypeInfoPropertyName = "T3907")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_Guid>), TypeInfoPropertyName = "T3908")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_Guid, int>), TypeInfoPropertyName = "T3909")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_Guid>>), TypeInfoPropertyName = "T3910")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_Guid>>), TypeInfoPropertyName = "T3911")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_Guid>>), TypeInfoPropertyName = "T3912")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_Guid>>), TypeInfoPropertyName = "T3913")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_Guid>, int>), TypeInfoPropertyName = "T3914")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_Guid>), TypeInfoPropertyName = "T3915")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_Guid>), TypeInfoPropertyName = "T3916")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_Guid>), TypeInfoPropertyName = "T3917")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_Guid>), TypeInfoPropertyName = "T3918")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_Guid, int>), TypeInfoPropertyName = "T3919")]
-[JsonSerializable(typeof(V_validated_class_int))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_int>), TypeInfoPropertyName = "T3920")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_int>), TypeInfoPropertyName = "T3921")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_int>), TypeInfoPropertyName = "T3922")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_int>), TypeInfoPropertyName = "T3923")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_int, int>), TypeInfoPropertyName = "T3924")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_int>), TypeInfoPropertyName = "T3925")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_int>), TypeInfoPropertyName = "T3926")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_int>), TypeInfoPropertyName = "T3927")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_int>), TypeInfoPropertyName = "T3928")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_int, int>), TypeInfoPropertyName = "T3929")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_int>>), TypeInfoPropertyName = "T3930")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_int>>), TypeInfoPropertyName = "T3931")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_int>>), TypeInfoPropertyName = "T3932")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_int>>), TypeInfoPropertyName = "T3933")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_int>, int>), TypeInfoPropertyName = "T3934")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_int[]>), TypeInfoPropertyName = "T3935")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_int[]>), TypeInfoPropertyName = "T3936")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_int[]>), TypeInfoPropertyName = "T3937")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_int[]>), TypeInfoPropertyName = "T3938")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_int[], int>), TypeInfoPropertyName = "T3939")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_int>>), TypeInfoPropertyName = "T3940")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_int>>), TypeInfoPropertyName = "T3941")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_int>>), TypeInfoPropertyName = "T3942")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_int>>), TypeInfoPropertyName = "T3943")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_int>, int>), TypeInfoPropertyName = "T3944")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_int>>), TypeInfoPropertyName = "T3945")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_int>>), TypeInfoPropertyName = "T3946")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_int>>), TypeInfoPropertyName = "T3947")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_int>>), TypeInfoPropertyName = "T3948")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_int>, int>), TypeInfoPropertyName = "T3949")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_int, int>>), TypeInfoPropertyName = "T3950")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_int, int>>), TypeInfoPropertyName = "T3951")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_int, int>>), TypeInfoPropertyName = "T3952")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_int, int>>), TypeInfoPropertyName = "T3953")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_int, int>, int>), TypeInfoPropertyName = "T3954")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_int>>), TypeInfoPropertyName = "T3955")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_int>>), TypeInfoPropertyName = "T3956")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_int>>), TypeInfoPropertyName = "T3957")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_int>>), TypeInfoPropertyName = "T3958")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_int>, int>), TypeInfoPropertyName = "T3959")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_int>), TypeInfoPropertyName = "T3960")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_int>), TypeInfoPropertyName = "T3961")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_int>), TypeInfoPropertyName = "T3962")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_int>), TypeInfoPropertyName = "T3963")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_int, int>), TypeInfoPropertyName = "T3964")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_int>), TypeInfoPropertyName = "T3965")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_int>), TypeInfoPropertyName = "T3966")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_int>), TypeInfoPropertyName = "T3967")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_int>), TypeInfoPropertyName = "T3968")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_int, int>), TypeInfoPropertyName = "T3969")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_int>>), TypeInfoPropertyName = "T3970")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_int>>), TypeInfoPropertyName = "T3971")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_int>>), TypeInfoPropertyName = "T3972")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_int>>), TypeInfoPropertyName = "T3973")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_int>, int>), TypeInfoPropertyName = "T3974")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_int>), TypeInfoPropertyName = "T3975")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_int>), TypeInfoPropertyName = "T3976")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_int>), TypeInfoPropertyName = "T3977")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_int>), TypeInfoPropertyName = "T3978")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_int, int>), TypeInfoPropertyName = "T3979")]
-[JsonSerializable(typeof(V_validated_class_long))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_long>), TypeInfoPropertyName = "T3980")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_long>), TypeInfoPropertyName = "T3981")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_long>), TypeInfoPropertyName = "T3982")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_long>), TypeInfoPropertyName = "T3983")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_long, int>), TypeInfoPropertyName = "T3984")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_long>), TypeInfoPropertyName = "T3985")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_long>), TypeInfoPropertyName = "T3986")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_long>), TypeInfoPropertyName = "T3987")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_long>), TypeInfoPropertyName = "T3988")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_long, int>), TypeInfoPropertyName = "T3989")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_long>>), TypeInfoPropertyName = "T3990")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_long>>), TypeInfoPropertyName = "T3991")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_long>>), TypeInfoPropertyName = "T3992")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_long>>), TypeInfoPropertyName = "T3993")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_long>, int>), TypeInfoPropertyName = "T3994")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_long[]>), TypeInfoPropertyName = "T3995")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_long[]>), TypeInfoPropertyName = "T3996")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_long[]>), TypeInfoPropertyName = "T3997")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_long[]>), TypeInfoPropertyName = "T3998")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_long[], int>), TypeInfoPropertyName = "T3999")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_long>>), TypeInfoPropertyName = "T4000")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_long>>), TypeInfoPropertyName = "T4001")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_long>>), TypeInfoPropertyName = "T4002")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_long>>), TypeInfoPropertyName = "T4003")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_long>, int>), TypeInfoPropertyName = "T4004")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_long>>), TypeInfoPropertyName = "T4005")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_long>>), TypeInfoPropertyName = "T4006")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_long>>), TypeInfoPropertyName = "T4007")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_long>>), TypeInfoPropertyName = "T4008")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_long>, int>), TypeInfoPropertyName = "T4009")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_long, int>>), TypeInfoPropertyName = "T4010")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_long, int>>), TypeInfoPropertyName = "T4011")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_long, int>>), TypeInfoPropertyName = "T4012")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_long, int>>), TypeInfoPropertyName = "T4013")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_long, int>, int>), TypeInfoPropertyName = "T4014")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_long>>), TypeInfoPropertyName = "T4015")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_long>>), TypeInfoPropertyName = "T4016")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_long>>), TypeInfoPropertyName = "T4017")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_long>>), TypeInfoPropertyName = "T4018")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_long>, int>), TypeInfoPropertyName = "T4019")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_long>), TypeInfoPropertyName = "T4020")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_long>), TypeInfoPropertyName = "T4021")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_long>), TypeInfoPropertyName = "T4022")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_long>), TypeInfoPropertyName = "T4023")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_long, int>), TypeInfoPropertyName = "T4024")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_long>), TypeInfoPropertyName = "T4025")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_long>), TypeInfoPropertyName = "T4026")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_long>), TypeInfoPropertyName = "T4027")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_long>), TypeInfoPropertyName = "T4028")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_long, int>), TypeInfoPropertyName = "T4029")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_long>>), TypeInfoPropertyName = "T4030")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_long>>), TypeInfoPropertyName = "T4031")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_long>>), TypeInfoPropertyName = "T4032")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_long>>), TypeInfoPropertyName = "T4033")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_long>, int>), TypeInfoPropertyName = "T4034")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_long>), TypeInfoPropertyName = "T4035")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_long>), TypeInfoPropertyName = "T4036")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_long>), TypeInfoPropertyName = "T4037")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_long>), TypeInfoPropertyName = "T4038")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_long, int>), TypeInfoPropertyName = "T4039")]
-[JsonSerializable(typeof(V_validated_class_byte))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_byte>), TypeInfoPropertyName = "T4040")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_byte>), TypeInfoPropertyName = "T4041")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_byte>), TypeInfoPropertyName = "T4042")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_byte>), TypeInfoPropertyName = "T4043")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_byte, int>), TypeInfoPropertyName = "T4044")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_byte>), TypeInfoPropertyName = "T4045")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_byte>), TypeInfoPropertyName = "T4046")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_byte>), TypeInfoPropertyName = "T4047")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_byte>), TypeInfoPropertyName = "T4048")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_byte, int>), TypeInfoPropertyName = "T4049")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_byte>>), TypeInfoPropertyName = "T4050")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_byte>>), TypeInfoPropertyName = "T4051")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_byte>>), TypeInfoPropertyName = "T4052")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_byte>>), TypeInfoPropertyName = "T4053")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_byte>, int>), TypeInfoPropertyName = "T4054")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_byte[]>), TypeInfoPropertyName = "T4055")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_byte[]>), TypeInfoPropertyName = "T4056")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_byte[]>), TypeInfoPropertyName = "T4057")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_byte[]>), TypeInfoPropertyName = "T4058")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_byte[], int>), TypeInfoPropertyName = "T4059")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_byte>>), TypeInfoPropertyName = "T4060")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_byte>>), TypeInfoPropertyName = "T4061")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_byte>>), TypeInfoPropertyName = "T4062")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_byte>>), TypeInfoPropertyName = "T4063")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_byte>, int>), TypeInfoPropertyName = "T4064")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_byte>>), TypeInfoPropertyName = "T4065")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_byte>>), TypeInfoPropertyName = "T4066")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_byte>>), TypeInfoPropertyName = "T4067")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_byte>>), TypeInfoPropertyName = "T4068")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_byte>, int>), TypeInfoPropertyName = "T4069")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_byte, int>>), TypeInfoPropertyName = "T4070")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_byte, int>>), TypeInfoPropertyName = "T4071")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_byte, int>>), TypeInfoPropertyName = "T4072")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_byte, int>>), TypeInfoPropertyName = "T4073")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_byte, int>, int>), TypeInfoPropertyName = "T4074")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_byte>>), TypeInfoPropertyName = "T4075")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_byte>>), TypeInfoPropertyName = "T4076")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_byte>>), TypeInfoPropertyName = "T4077")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_byte>>), TypeInfoPropertyName = "T4078")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_byte>, int>), TypeInfoPropertyName = "T4079")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_byte>), TypeInfoPropertyName = "T4080")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_byte>), TypeInfoPropertyName = "T4081")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_byte>), TypeInfoPropertyName = "T4082")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_byte>), TypeInfoPropertyName = "T4083")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_byte, int>), TypeInfoPropertyName = "T4084")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_byte>), TypeInfoPropertyName = "T4085")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_byte>), TypeInfoPropertyName = "T4086")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_byte>), TypeInfoPropertyName = "T4087")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_byte>), TypeInfoPropertyName = "T4088")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_byte, int>), TypeInfoPropertyName = "T4089")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_byte>>), TypeInfoPropertyName = "T4090")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_byte>>), TypeInfoPropertyName = "T4091")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_byte>>), TypeInfoPropertyName = "T4092")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_byte>>), TypeInfoPropertyName = "T4093")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_byte>, int>), TypeInfoPropertyName = "T4094")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_byte>), TypeInfoPropertyName = "T4095")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_byte>), TypeInfoPropertyName = "T4096")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_byte>), TypeInfoPropertyName = "T4097")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_byte>), TypeInfoPropertyName = "T4098")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_byte, int>), TypeInfoPropertyName = "T4099")]
-[JsonSerializable(typeof(V_validated_class_ulong))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_ulong>), TypeInfoPropertyName = "T4100")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_ulong>), TypeInfoPropertyName = "T4101")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_ulong>), TypeInfoPropertyName = "T4102")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_ulong>), TypeInfoPropertyName = "T4103")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_ulong, int>), TypeInfoPropertyName = "T4104")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_ulong>), TypeInfoPropertyName = "T4105")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_ulong>), TypeInfoPropertyName = "T4106")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_ulong>), TypeInfoPropertyName = "T4107")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_ulong>), TypeInfoPropertyName = "T4108")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_ulong, int>), TypeInfoPropertyName = "T4109")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_ulong>>), TypeInfoPropertyName = "T4110")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_ulong>>), TypeInfoPropertyName = "T4111")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_ulong>>), TypeInfoPropertyName = "T4112")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_ulong>>), TypeInfoPropertyName = "T4113")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_ulong>, int>), TypeInfoPropertyName = "T4114")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_ulong[]>), TypeInfoPropertyName = "T4115")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_ulong[]>), TypeInfoPropertyName = "T4116")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_ulong[]>), TypeInfoPropertyName = "T4117")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_ulong[]>), TypeInfoPropertyName = "T4118")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_ulong[], int>), TypeInfoPropertyName = "T4119")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_ulong>>), TypeInfoPropertyName = "T4120")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_ulong>>), TypeInfoPropertyName = "T4121")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_ulong>>), TypeInfoPropertyName = "T4122")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_ulong>>), TypeInfoPropertyName = "T4123")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_ulong>, int>), TypeInfoPropertyName = "T4124")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_ulong>>), TypeInfoPropertyName = "T4125")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_ulong>>), TypeInfoPropertyName = "T4126")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_ulong>>), TypeInfoPropertyName = "T4127")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_ulong>>), TypeInfoPropertyName = "T4128")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_ulong>, int>), TypeInfoPropertyName = "T4129")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_ulong, int>>), TypeInfoPropertyName = "T4130")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_ulong, int>>), TypeInfoPropertyName = "T4131")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_ulong, int>>), TypeInfoPropertyName = "T4132")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_ulong, int>>), TypeInfoPropertyName = "T4133")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_ulong, int>, int>), TypeInfoPropertyName = "T4134")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_ulong>>), TypeInfoPropertyName = "T4135")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_ulong>>), TypeInfoPropertyName = "T4136")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_ulong>>), TypeInfoPropertyName = "T4137")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_ulong>>), TypeInfoPropertyName = "T4138")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_ulong>, int>), TypeInfoPropertyName = "T4139")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_ulong>), TypeInfoPropertyName = "T4140")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_ulong>), TypeInfoPropertyName = "T4141")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_ulong>), TypeInfoPropertyName = "T4142")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_ulong>), TypeInfoPropertyName = "T4143")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_ulong, int>), TypeInfoPropertyName = "T4144")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_ulong>), TypeInfoPropertyName = "T4145")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_ulong>), TypeInfoPropertyName = "T4146")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_ulong>), TypeInfoPropertyName = "T4147")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_ulong>), TypeInfoPropertyName = "T4148")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_ulong, int>), TypeInfoPropertyName = "T4149")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_ulong>>), TypeInfoPropertyName = "T4150")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_ulong>>), TypeInfoPropertyName = "T4151")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_ulong>>), TypeInfoPropertyName = "T4152")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_ulong>>), TypeInfoPropertyName = "T4153")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_ulong>, int>), TypeInfoPropertyName = "T4154")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_ulong>), TypeInfoPropertyName = "T4155")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_ulong>), TypeInfoPropertyName = "T4156")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_ulong>), TypeInfoPropertyName = "T4157")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_ulong>), TypeInfoPropertyName = "T4158")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_ulong, int>), TypeInfoPropertyName = "T4159")]
-[JsonSerializable(typeof(V_validated_class_decimal))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_decimal>), TypeInfoPropertyName = "T4160")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_decimal>), TypeInfoPropertyName = "T4161")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_decimal>), TypeInfoPropertyName = "T4162")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_decimal>), TypeInfoPropertyName = "T4163")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_decimal, int>), TypeInfoPropertyName = "T4164")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_decimal>), TypeInfoPropertyName = "T4165")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_decimal>), TypeInfoPropertyName = "T4166")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_decimal>), TypeInfoPropertyName = "T4167")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_decimal>), TypeInfoPropertyName = "T4168")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_decimal, int>), TypeInfoPropertyName = "T4169")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_decimal>>), TypeInfoPropertyName = "T4170")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_decimal>>), TypeInfoPropertyName = "T4171")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_decimal>>), TypeInfoPropertyName = "T4172")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_decimal>>), TypeInfoPropertyName = "T4173")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_decimal>, int>), TypeInfoPropertyName = "T4174")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_decimal[]>), TypeInfoPropertyName = "T4175")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_decimal[]>), TypeInfoPropertyName = "T4176")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_decimal[]>), TypeInfoPropertyName = "T4177")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_decimal[]>), TypeInfoPropertyName = "T4178")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_decimal[], int>), TypeInfoPropertyName = "T4179")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_decimal>>), TypeInfoPropertyName = "T4180")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_decimal>>), TypeInfoPropertyName = "T4181")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_decimal>>), TypeInfoPropertyName = "T4182")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_decimal>>), TypeInfoPropertyName = "T4183")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_decimal>, int>), TypeInfoPropertyName = "T4184")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_decimal>>), TypeInfoPropertyName = "T4185")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_decimal>>), TypeInfoPropertyName = "T4186")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_decimal>>), TypeInfoPropertyName = "T4187")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_decimal>>), TypeInfoPropertyName = "T4188")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_decimal>, int>), TypeInfoPropertyName = "T4189")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_decimal, int>>), TypeInfoPropertyName = "T4190")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_decimal, int>>), TypeInfoPropertyName = "T4191")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_decimal, int>>), TypeInfoPropertyName = "T4192")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_decimal, int>>), TypeInfoPropertyName = "T4193")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_decimal, int>, int>), TypeInfoPropertyName = "T4194")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_decimal>>), TypeInfoPropertyName = "T4195")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_decimal>>), TypeInfoPropertyName = "T4196")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_decimal>>), TypeInfoPropertyName = "T4197")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_decimal>>), TypeInfoPropertyName = "T4198")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_decimal>, int>), TypeInfoPropertyName = "T4199")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_decimal>), TypeInfoPropertyName = "T4200")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_decimal>), TypeInfoPropertyName = "T4201")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_decimal>), TypeInfoPropertyName = "T4202")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_decimal>), TypeInfoPropertyName = "T4203")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_decimal, int>), TypeInfoPropertyName = "T4204")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_decimal>), TypeInfoPropertyName = "T4205")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_decimal>), TypeInfoPropertyName = "T4206")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_decimal>), TypeInfoPropertyName = "T4207")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_decimal>), TypeInfoPropertyName = "T4208")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_decimal, int>), TypeInfoPropertyName = "T4209")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_decimal>>), TypeInfoPropertyName = "T4210")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_decimal>>), TypeInfoPropertyName = "T4211")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_decimal>>), TypeInfoPropertyName = "T4212")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_decimal>>), TypeInfoPropertyName = "T4213")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_decimal>, int>), TypeInfoPropertyName = "T4214")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_decimal>), TypeInfoPropertyName = "T4215")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_decimal>), TypeInfoPropertyName = "T4216")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_decimal>), TypeInfoPropertyName = "T4217")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_decimal>), TypeInfoPropertyName = "T4218")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_decimal, int>), TypeInfoPropertyName = "T4219")]
-[JsonSerializable(typeof(V_validated_class_double))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_double>), TypeInfoPropertyName = "T4220")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_double>), TypeInfoPropertyName = "T4221")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_double>), TypeInfoPropertyName = "T4222")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_double>), TypeInfoPropertyName = "T4223")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_double, int>), TypeInfoPropertyName = "T4224")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_double>), TypeInfoPropertyName = "T4225")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_double>), TypeInfoPropertyName = "T4226")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_double>), TypeInfoPropertyName = "T4227")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_double>), TypeInfoPropertyName = "T4228")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_double, int>), TypeInfoPropertyName = "T4229")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_double>>), TypeInfoPropertyName = "T4230")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_double>>), TypeInfoPropertyName = "T4231")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_double>>), TypeInfoPropertyName = "T4232")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_double>>), TypeInfoPropertyName = "T4233")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_double>, int>), TypeInfoPropertyName = "T4234")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_double[]>), TypeInfoPropertyName = "T4235")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_double[]>), TypeInfoPropertyName = "T4236")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_double[]>), TypeInfoPropertyName = "T4237")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_double[]>), TypeInfoPropertyName = "T4238")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_double[], int>), TypeInfoPropertyName = "T4239")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_double>>), TypeInfoPropertyName = "T4240")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_double>>), TypeInfoPropertyName = "T4241")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_double>>), TypeInfoPropertyName = "T4242")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_double>>), TypeInfoPropertyName = "T4243")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_double>, int>), TypeInfoPropertyName = "T4244")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_double>>), TypeInfoPropertyName = "T4245")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_double>>), TypeInfoPropertyName = "T4246")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_double>>), TypeInfoPropertyName = "T4247")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_double>>), TypeInfoPropertyName = "T4248")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_double>, int>), TypeInfoPropertyName = "T4249")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_double, int>>), TypeInfoPropertyName = "T4250")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_double, int>>), TypeInfoPropertyName = "T4251")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_double, int>>), TypeInfoPropertyName = "T4252")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_double, int>>), TypeInfoPropertyName = "T4253")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_double, int>, int>), TypeInfoPropertyName = "T4254")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_double>>), TypeInfoPropertyName = "T4255")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_double>>), TypeInfoPropertyName = "T4256")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_double>>), TypeInfoPropertyName = "T4257")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_double>>), TypeInfoPropertyName = "T4258")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_double>, int>), TypeInfoPropertyName = "T4259")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_double>), TypeInfoPropertyName = "T4260")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_double>), TypeInfoPropertyName = "T4261")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_double>), TypeInfoPropertyName = "T4262")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_double>), TypeInfoPropertyName = "T4263")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_double, int>), TypeInfoPropertyName = "T4264")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_double>), TypeInfoPropertyName = "T4265")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_double>), TypeInfoPropertyName = "T4266")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_double>), TypeInfoPropertyName = "T4267")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_double>), TypeInfoPropertyName = "T4268")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_double, int>), TypeInfoPropertyName = "T4269")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_double>>), TypeInfoPropertyName = "T4270")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_double>>), TypeInfoPropertyName = "T4271")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_double>>), TypeInfoPropertyName = "T4272")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_double>>), TypeInfoPropertyName = "T4273")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_double>, int>), TypeInfoPropertyName = "T4274")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_double>), TypeInfoPropertyName = "T4275")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_double>), TypeInfoPropertyName = "T4276")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_double>), TypeInfoPropertyName = "T4277")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_double>), TypeInfoPropertyName = "T4278")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_double, int>), TypeInfoPropertyName = "T4279")]
-[JsonSerializable(typeof(V_validated_class_bool))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_bool>), TypeInfoPropertyName = "T4280")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_bool>), TypeInfoPropertyName = "T4281")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_bool>), TypeInfoPropertyName = "T4282")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_bool>), TypeInfoPropertyName = "T4283")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_bool, int>), TypeInfoPropertyName = "T4284")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_bool>), TypeInfoPropertyName = "T4285")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_bool>), TypeInfoPropertyName = "T4286")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_bool>), TypeInfoPropertyName = "T4287")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_bool>), TypeInfoPropertyName = "T4288")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_bool, int>), TypeInfoPropertyName = "T4289")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_bool>>), TypeInfoPropertyName = "T4290")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_bool>>), TypeInfoPropertyName = "T4291")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_bool>>), TypeInfoPropertyName = "T4292")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_bool>>), TypeInfoPropertyName = "T4293")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_bool>, int>), TypeInfoPropertyName = "T4294")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_bool[]>), TypeInfoPropertyName = "T4295")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_bool[]>), TypeInfoPropertyName = "T4296")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_bool[]>), TypeInfoPropertyName = "T4297")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_bool[]>), TypeInfoPropertyName = "T4298")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_bool[], int>), TypeInfoPropertyName = "T4299")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_bool>>), TypeInfoPropertyName = "T4300")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_bool>>), TypeInfoPropertyName = "T4301")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_bool>>), TypeInfoPropertyName = "T4302")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_bool>>), TypeInfoPropertyName = "T4303")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_bool>, int>), TypeInfoPropertyName = "T4304")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_bool>>), TypeInfoPropertyName = "T4305")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_bool>>), TypeInfoPropertyName = "T4306")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_bool>>), TypeInfoPropertyName = "T4307")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_bool>>), TypeInfoPropertyName = "T4308")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_bool>, int>), TypeInfoPropertyName = "T4309")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_bool, int>>), TypeInfoPropertyName = "T4310")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_bool, int>>), TypeInfoPropertyName = "T4311")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_bool, int>>), TypeInfoPropertyName = "T4312")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_bool, int>>), TypeInfoPropertyName = "T4313")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_bool, int>, int>), TypeInfoPropertyName = "T4314")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_bool>>), TypeInfoPropertyName = "T4315")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_bool>>), TypeInfoPropertyName = "T4316")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_bool>>), TypeInfoPropertyName = "T4317")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_bool>>), TypeInfoPropertyName = "T4318")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_bool>, int>), TypeInfoPropertyName = "T4319")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_bool>), TypeInfoPropertyName = "T4320")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_bool>), TypeInfoPropertyName = "T4321")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_bool>), TypeInfoPropertyName = "T4322")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_bool>), TypeInfoPropertyName = "T4323")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_bool, int>), TypeInfoPropertyName = "T4324")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_bool>), TypeInfoPropertyName = "T4325")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_bool>), TypeInfoPropertyName = "T4326")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_bool>), TypeInfoPropertyName = "T4327")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_bool>), TypeInfoPropertyName = "T4328")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_bool, int>), TypeInfoPropertyName = "T4329")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_bool>>), TypeInfoPropertyName = "T4330")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_bool>>), TypeInfoPropertyName = "T4331")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_bool>>), TypeInfoPropertyName = "T4332")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_bool>>), TypeInfoPropertyName = "T4333")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_bool>, int>), TypeInfoPropertyName = "T4334")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_bool>), TypeInfoPropertyName = "T4335")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_bool>), TypeInfoPropertyName = "T4336")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_bool>), TypeInfoPropertyName = "T4337")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_bool>), TypeInfoPropertyName = "T4338")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_bool, int>), TypeInfoPropertyName = "T4339")]
-[JsonSerializable(typeof(V_validated_class_char))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_char>), TypeInfoPropertyName = "T4340")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_char>), TypeInfoPropertyName = "T4341")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_char>), TypeInfoPropertyName = "T4342")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_char>), TypeInfoPropertyName = "T4343")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_char, int>), TypeInfoPropertyName = "T4344")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_char>), TypeInfoPropertyName = "T4345")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_char>), TypeInfoPropertyName = "T4346")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_char>), TypeInfoPropertyName = "T4347")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_char>), TypeInfoPropertyName = "T4348")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_char, int>), TypeInfoPropertyName = "T4349")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_char>>), TypeInfoPropertyName = "T4350")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_char>>), TypeInfoPropertyName = "T4351")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_char>>), TypeInfoPropertyName = "T4352")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_char>>), TypeInfoPropertyName = "T4353")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_char>, int>), TypeInfoPropertyName = "T4354")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_char[]>), TypeInfoPropertyName = "T4355")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_char[]>), TypeInfoPropertyName = "T4356")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_char[]>), TypeInfoPropertyName = "T4357")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_char[]>), TypeInfoPropertyName = "T4358")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_char[], int>), TypeInfoPropertyName = "T4359")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_char>>), TypeInfoPropertyName = "T4360")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_char>>), TypeInfoPropertyName = "T4361")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_char>>), TypeInfoPropertyName = "T4362")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_char>>), TypeInfoPropertyName = "T4363")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_char>, int>), TypeInfoPropertyName = "T4364")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_char>>), TypeInfoPropertyName = "T4365")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_char>>), TypeInfoPropertyName = "T4366")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_char>>), TypeInfoPropertyName = "T4367")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_char>>), TypeInfoPropertyName = "T4368")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_char>, int>), TypeInfoPropertyName = "T4369")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_char, int>>), TypeInfoPropertyName = "T4370")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_char, int>>), TypeInfoPropertyName = "T4371")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_char, int>>), TypeInfoPropertyName = "T4372")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_char, int>>), TypeInfoPropertyName = "T4373")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_char, int>, int>), TypeInfoPropertyName = "T4374")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_char>>), TypeInfoPropertyName = "T4375")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_char>>), TypeInfoPropertyName = "T4376")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_char>>), TypeInfoPropertyName = "T4377")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_char>>), TypeInfoPropertyName = "T4378")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_char>, int>), TypeInfoPropertyName = "T4379")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_char>), TypeInfoPropertyName = "T4380")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_char>), TypeInfoPropertyName = "T4381")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_char>), TypeInfoPropertyName = "T4382")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_char>), TypeInfoPropertyName = "T4383")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_char, int>), TypeInfoPropertyName = "T4384")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_char>), TypeInfoPropertyName = "T4385")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_char>), TypeInfoPropertyName = "T4386")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_char>), TypeInfoPropertyName = "T4387")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_char>), TypeInfoPropertyName = "T4388")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_char, int>), TypeInfoPropertyName = "T4389")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_char>>), TypeInfoPropertyName = "T4390")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_char>>), TypeInfoPropertyName = "T4391")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_char>>), TypeInfoPropertyName = "T4392")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_char>>), TypeInfoPropertyName = "T4393")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_char>, int>), TypeInfoPropertyName = "T4394")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_char>), TypeInfoPropertyName = "T4395")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_char>), TypeInfoPropertyName = "T4396")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_char>), TypeInfoPropertyName = "T4397")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_char>), TypeInfoPropertyName = "T4398")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_char, int>), TypeInfoPropertyName = "T4399")]
-[JsonSerializable(typeof(V_validated_class_DateTime))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_DateTime>), TypeInfoPropertyName = "T4400")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_DateTime>), TypeInfoPropertyName = "T4401")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_DateTime>), TypeInfoPropertyName = "T4402")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_DateTime>), TypeInfoPropertyName = "T4403")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_DateTime, int>), TypeInfoPropertyName = "T4404")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_DateTime>), TypeInfoPropertyName = "T4405")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_DateTime>), TypeInfoPropertyName = "T4406")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_DateTime>), TypeInfoPropertyName = "T4407")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_DateTime>), TypeInfoPropertyName = "T4408")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_DateTime, int>), TypeInfoPropertyName = "T4409")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_DateTime>>), TypeInfoPropertyName = "T4410")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_DateTime>>), TypeInfoPropertyName = "T4411")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_DateTime>>), TypeInfoPropertyName = "T4412")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_DateTime>>), TypeInfoPropertyName = "T4413")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_DateTime>, int>), TypeInfoPropertyName = "T4414")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_DateTime[]>), TypeInfoPropertyName = "T4415")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_DateTime[]>), TypeInfoPropertyName = "T4416")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_DateTime[]>), TypeInfoPropertyName = "T4417")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_DateTime[]>), TypeInfoPropertyName = "T4418")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_DateTime[], int>), TypeInfoPropertyName = "T4419")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_DateTime>>), TypeInfoPropertyName = "T4420")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_DateTime>>), TypeInfoPropertyName = "T4421")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_DateTime>>), TypeInfoPropertyName = "T4422")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_DateTime>>), TypeInfoPropertyName = "T4423")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_DateTime>, int>), TypeInfoPropertyName = "T4424")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_DateTime>>), TypeInfoPropertyName = "T4425")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_DateTime>>), TypeInfoPropertyName = "T4426")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_DateTime>>), TypeInfoPropertyName = "T4427")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_DateTime>>), TypeInfoPropertyName = "T4428")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_DateTime>, int>), TypeInfoPropertyName = "T4429")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_DateTime, int>>), TypeInfoPropertyName = "T4430")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_DateTime, int>>), TypeInfoPropertyName = "T4431")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_DateTime, int>>), TypeInfoPropertyName = "T4432")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_DateTime, int>>), TypeInfoPropertyName = "T4433")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_DateTime, int>, int>), TypeInfoPropertyName = "T4434")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_DateTime>>), TypeInfoPropertyName = "T4435")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_DateTime>>), TypeInfoPropertyName = "T4436")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_DateTime>>), TypeInfoPropertyName = "T4437")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_DateTime>>), TypeInfoPropertyName = "T4438")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_DateTime>, int>), TypeInfoPropertyName = "T4439")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_DateTime>), TypeInfoPropertyName = "T4440")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_DateTime>), TypeInfoPropertyName = "T4441")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_DateTime>), TypeInfoPropertyName = "T4442")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_DateTime>), TypeInfoPropertyName = "T4443")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_DateTime, int>), TypeInfoPropertyName = "T4444")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_DateTime>), TypeInfoPropertyName = "T4445")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_DateTime>), TypeInfoPropertyName = "T4446")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_DateTime>), TypeInfoPropertyName = "T4447")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_DateTime>), TypeInfoPropertyName = "T4448")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_DateTime, int>), TypeInfoPropertyName = "T4449")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_DateTime>>), TypeInfoPropertyName = "T4450")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_DateTime>>), TypeInfoPropertyName = "T4451")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_DateTime>>), TypeInfoPropertyName = "T4452")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_DateTime>>), TypeInfoPropertyName = "T4453")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_DateTime>, int>), TypeInfoPropertyName = "T4454")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_DateTime>), TypeInfoPropertyName = "T4455")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_DateTime>), TypeInfoPropertyName = "T4456")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_DateTime>), TypeInfoPropertyName = "T4457")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_DateTime>), TypeInfoPropertyName = "T4458")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_DateTime, int>), TypeInfoPropertyName = "T4459")]
-[JsonSerializable(typeof(V_validated_class_DateTimeOffset))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4460")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4461")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4462")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4463")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_DateTimeOffset, int>), TypeInfoPropertyName = "T4464")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4465")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4466")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4467")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4468")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_DateTimeOffset, int>), TypeInfoPropertyName = "T4469")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4470")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4471")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4472")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4473")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_DateTimeOffset>, int>), TypeInfoPropertyName = "T4474")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_DateTimeOffset[]>), TypeInfoPropertyName = "T4475")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_DateTimeOffset[]>), TypeInfoPropertyName = "T4476")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_DateTimeOffset[]>), TypeInfoPropertyName = "T4477")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_DateTimeOffset[]>), TypeInfoPropertyName = "T4478")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_DateTimeOffset[], int>), TypeInfoPropertyName = "T4479")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4480")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4481")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4482")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4483")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_DateTimeOffset>, int>), TypeInfoPropertyName = "T4484")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4485")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4486")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4487")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4488")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_DateTimeOffset>, int>), TypeInfoPropertyName = "T4489")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_DateTimeOffset, int>>), TypeInfoPropertyName = "T4490")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_DateTimeOffset, int>>), TypeInfoPropertyName = "T4491")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_DateTimeOffset, int>>), TypeInfoPropertyName = "T4492")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_DateTimeOffset, int>>), TypeInfoPropertyName = "T4493")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_DateTimeOffset, int>, int>), TypeInfoPropertyName = "T4494")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4495")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4496")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4497")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4498")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_DateTimeOffset>, int>), TypeInfoPropertyName = "T4499")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4500")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4501")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4502")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4503")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_DateTimeOffset, int>), TypeInfoPropertyName = "T4504")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4505")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4506")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4507")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4508")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_DateTimeOffset, int>), TypeInfoPropertyName = "T4509")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4510")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4511")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4512")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_DateTimeOffset>>), TypeInfoPropertyName = "T4513")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_DateTimeOffset>, int>), TypeInfoPropertyName = "T4514")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4515")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4516")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4517")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_DateTimeOffset>), TypeInfoPropertyName = "T4518")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_DateTimeOffset, int>), TypeInfoPropertyName = "T4519")]
-[JsonSerializable(typeof(V_validated_class_DateOnly))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_DateOnly>), TypeInfoPropertyName = "T4520")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_DateOnly>), TypeInfoPropertyName = "T4521")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_DateOnly>), TypeInfoPropertyName = "T4522")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_DateOnly>), TypeInfoPropertyName = "T4523")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_DateOnly, int>), TypeInfoPropertyName = "T4524")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_DateOnly>), TypeInfoPropertyName = "T4525")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_DateOnly>), TypeInfoPropertyName = "T4526")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_DateOnly>), TypeInfoPropertyName = "T4527")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_DateOnly>), TypeInfoPropertyName = "T4528")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_DateOnly, int>), TypeInfoPropertyName = "T4529")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4530")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4531")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4532")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4533")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_DateOnly>, int>), TypeInfoPropertyName = "T4534")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_DateOnly[]>), TypeInfoPropertyName = "T4535")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_DateOnly[]>), TypeInfoPropertyName = "T4536")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_DateOnly[]>), TypeInfoPropertyName = "T4537")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_DateOnly[]>), TypeInfoPropertyName = "T4538")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_DateOnly[], int>), TypeInfoPropertyName = "T4539")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4540")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4541")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4542")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4543")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_DateOnly>, int>), TypeInfoPropertyName = "T4544")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4545")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4546")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4547")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4548")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_DateOnly>, int>), TypeInfoPropertyName = "T4549")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_DateOnly, int>>), TypeInfoPropertyName = "T4550")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_DateOnly, int>>), TypeInfoPropertyName = "T4551")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_DateOnly, int>>), TypeInfoPropertyName = "T4552")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_DateOnly, int>>), TypeInfoPropertyName = "T4553")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_DateOnly, int>, int>), TypeInfoPropertyName = "T4554")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4555")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4556")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4557")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4558")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_DateOnly>, int>), TypeInfoPropertyName = "T4559")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_DateOnly>), TypeInfoPropertyName = "T4560")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_DateOnly>), TypeInfoPropertyName = "T4561")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_DateOnly>), TypeInfoPropertyName = "T4562")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_DateOnly>), TypeInfoPropertyName = "T4563")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_DateOnly, int>), TypeInfoPropertyName = "T4564")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_DateOnly>), TypeInfoPropertyName = "T4565")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_DateOnly>), TypeInfoPropertyName = "T4566")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_DateOnly>), TypeInfoPropertyName = "T4567")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_DateOnly>), TypeInfoPropertyName = "T4568")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_DateOnly, int>), TypeInfoPropertyName = "T4569")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4570")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4571")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4572")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_DateOnly>>), TypeInfoPropertyName = "T4573")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_DateOnly>, int>), TypeInfoPropertyName = "T4574")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_DateOnly>), TypeInfoPropertyName = "T4575")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_DateOnly>), TypeInfoPropertyName = "T4576")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_DateOnly>), TypeInfoPropertyName = "T4577")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_DateOnly>), TypeInfoPropertyName = "T4578")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_DateOnly, int>), TypeInfoPropertyName = "T4579")]
-[JsonSerializable(typeof(V_validated_class_TimeOnly))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4580")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4581")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4582")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4583")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_TimeOnly, int>), TypeInfoPropertyName = "T4584")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4585")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4586")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4587")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4588")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_TimeOnly, int>), TypeInfoPropertyName = "T4589")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4590")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4591")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4592")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4593")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_TimeOnly>, int>), TypeInfoPropertyName = "T4594")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_TimeOnly[]>), TypeInfoPropertyName = "T4595")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_TimeOnly[]>), TypeInfoPropertyName = "T4596")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_TimeOnly[]>), TypeInfoPropertyName = "T4597")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_TimeOnly[]>), TypeInfoPropertyName = "T4598")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_TimeOnly[], int>), TypeInfoPropertyName = "T4599")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4600")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4601")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4602")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4603")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_TimeOnly>, int>), TypeInfoPropertyName = "T4604")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4605")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4606")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4607")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4608")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_TimeOnly>, int>), TypeInfoPropertyName = "T4609")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_TimeOnly, int>>), TypeInfoPropertyName = "T4610")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_TimeOnly, int>>), TypeInfoPropertyName = "T4611")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_TimeOnly, int>>), TypeInfoPropertyName = "T4612")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_TimeOnly, int>>), TypeInfoPropertyName = "T4613")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_TimeOnly, int>, int>), TypeInfoPropertyName = "T4614")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4615")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4616")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4617")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4618")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_TimeOnly>, int>), TypeInfoPropertyName = "T4619")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4620")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4621")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4622")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4623")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_TimeOnly, int>), TypeInfoPropertyName = "T4624")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4625")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4626")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4627")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4628")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_TimeOnly, int>), TypeInfoPropertyName = "T4629")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4630")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4631")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4632")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_TimeOnly>>), TypeInfoPropertyName = "T4633")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_TimeOnly>, int>), TypeInfoPropertyName = "T4634")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4635")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4636")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4637")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_TimeOnly>), TypeInfoPropertyName = "T4638")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_TimeOnly, int>), TypeInfoPropertyName = "T4639")]
-[JsonSerializable(typeof(V_validated_class_TimeSpan))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4640")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4641")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4642")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4643")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_TimeSpan, int>), TypeInfoPropertyName = "T4644")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4645")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4646")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4647")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4648")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_TimeSpan, int>), TypeInfoPropertyName = "T4649")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4650")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4651")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4652")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4653")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_TimeSpan>, int>), TypeInfoPropertyName = "T4654")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_TimeSpan[]>), TypeInfoPropertyName = "T4655")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_TimeSpan[]>), TypeInfoPropertyName = "T4656")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_TimeSpan[]>), TypeInfoPropertyName = "T4657")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_TimeSpan[]>), TypeInfoPropertyName = "T4658")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_TimeSpan[], int>), TypeInfoPropertyName = "T4659")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4660")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4661")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4662")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4663")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_TimeSpan>, int>), TypeInfoPropertyName = "T4664")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4665")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4666")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4667")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4668")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_TimeSpan>, int>), TypeInfoPropertyName = "T4669")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_TimeSpan, int>>), TypeInfoPropertyName = "T4670")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_TimeSpan, int>>), TypeInfoPropertyName = "T4671")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_TimeSpan, int>>), TypeInfoPropertyName = "T4672")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_TimeSpan, int>>), TypeInfoPropertyName = "T4673")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_TimeSpan, int>, int>), TypeInfoPropertyName = "T4674")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4675")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4676")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4677")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4678")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_TimeSpan>, int>), TypeInfoPropertyName = "T4679")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4680")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4681")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4682")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4683")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_TimeSpan, int>), TypeInfoPropertyName = "T4684")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4685")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4686")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4687")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4688")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_TimeSpan, int>), TypeInfoPropertyName = "T4689")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4690")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4691")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4692")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_TimeSpan>>), TypeInfoPropertyName = "T4693")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_TimeSpan>, int>), TypeInfoPropertyName = "T4694")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4695")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4696")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4697")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_TimeSpan>), TypeInfoPropertyName = "T4698")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_TimeSpan, int>), TypeInfoPropertyName = "T4699")]
-[JsonSerializable(typeof(V_validated_class_enum))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_enum>), TypeInfoPropertyName = "T4700")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_enum>), TypeInfoPropertyName = "T4701")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_enum>), TypeInfoPropertyName = "T4702")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_enum>), TypeInfoPropertyName = "T4703")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_enum, int>), TypeInfoPropertyName = "T4704")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_enum>), TypeInfoPropertyName = "T4705")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_enum>), TypeInfoPropertyName = "T4706")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_enum>), TypeInfoPropertyName = "T4707")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_enum>), TypeInfoPropertyName = "T4708")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_enum, int>), TypeInfoPropertyName = "T4709")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_enum>>), TypeInfoPropertyName = "T4710")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_enum>>), TypeInfoPropertyName = "T4711")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_enum>>), TypeInfoPropertyName = "T4712")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_enum>>), TypeInfoPropertyName = "T4713")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_enum>, int>), TypeInfoPropertyName = "T4714")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_enum[]>), TypeInfoPropertyName = "T4715")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_enum[]>), TypeInfoPropertyName = "T4716")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_enum[]>), TypeInfoPropertyName = "T4717")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_enum[]>), TypeInfoPropertyName = "T4718")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_enum[], int>), TypeInfoPropertyName = "T4719")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_enum>>), TypeInfoPropertyName = "T4720")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_enum>>), TypeInfoPropertyName = "T4721")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_enum>>), TypeInfoPropertyName = "T4722")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_enum>>), TypeInfoPropertyName = "T4723")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_enum>, int>), TypeInfoPropertyName = "T4724")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_enum>>), TypeInfoPropertyName = "T4725")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_enum>>), TypeInfoPropertyName = "T4726")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_enum>>), TypeInfoPropertyName = "T4727")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_enum>>), TypeInfoPropertyName = "T4728")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_enum>, int>), TypeInfoPropertyName = "T4729")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_enum, int>>), TypeInfoPropertyName = "T4730")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_enum, int>>), TypeInfoPropertyName = "T4731")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_enum, int>>), TypeInfoPropertyName = "T4732")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_enum, int>>), TypeInfoPropertyName = "T4733")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_enum, int>, int>), TypeInfoPropertyName = "T4734")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_enum>>), TypeInfoPropertyName = "T4735")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_enum>>), TypeInfoPropertyName = "T4736")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_enum>>), TypeInfoPropertyName = "T4737")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_enum>>), TypeInfoPropertyName = "T4738")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_enum>, int>), TypeInfoPropertyName = "T4739")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_enum>), TypeInfoPropertyName = "T4740")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_enum>), TypeInfoPropertyName = "T4741")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_enum>), TypeInfoPropertyName = "T4742")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_enum>), TypeInfoPropertyName = "T4743")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_enum, int>), TypeInfoPropertyName = "T4744")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_enum>), TypeInfoPropertyName = "T4745")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_enum>), TypeInfoPropertyName = "T4746")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_enum>), TypeInfoPropertyName = "T4747")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_enum>), TypeInfoPropertyName = "T4748")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_enum, int>), TypeInfoPropertyName = "T4749")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_enum>>), TypeInfoPropertyName = "T4750")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_enum>>), TypeInfoPropertyName = "T4751")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_enum>>), TypeInfoPropertyName = "T4752")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_enum>>), TypeInfoPropertyName = "T4753")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_enum>, int>), TypeInfoPropertyName = "T4754")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_enum>), TypeInfoPropertyName = "T4755")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_enum>), TypeInfoPropertyName = "T4756")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_enum>), TypeInfoPropertyName = "T4757")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_enum>), TypeInfoPropertyName = "T4758")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_enum, int>), TypeInfoPropertyName = "T4759")]
-[JsonSerializable(typeof(V_validated_class_flags_enum))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_flags_enum>), TypeInfoPropertyName = "T4760")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_flags_enum>), TypeInfoPropertyName = "T4761")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_flags_enum>), TypeInfoPropertyName = "T4762")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_flags_enum>), TypeInfoPropertyName = "T4763")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_flags_enum, int>), TypeInfoPropertyName = "T4764")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_flags_enum>), TypeInfoPropertyName = "T4765")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_flags_enum>), TypeInfoPropertyName = "T4766")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_flags_enum>), TypeInfoPropertyName = "T4767")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_flags_enum>), TypeInfoPropertyName = "T4768")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_flags_enum, int>), TypeInfoPropertyName = "T4769")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4770")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4771")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4772")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4773")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_flags_enum>, int>), TypeInfoPropertyName = "T4774")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_flags_enum[]>), TypeInfoPropertyName = "T4775")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_flags_enum[]>), TypeInfoPropertyName = "T4776")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_flags_enum[]>), TypeInfoPropertyName = "T4777")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_flags_enum[]>), TypeInfoPropertyName = "T4778")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_flags_enum[], int>), TypeInfoPropertyName = "T4779")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4780")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4781")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4782")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4783")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_flags_enum>, int>), TypeInfoPropertyName = "T4784")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4785")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4786")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4787")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4788")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_flags_enum>, int>), TypeInfoPropertyName = "T4789")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_flags_enum, int>>), TypeInfoPropertyName = "T4790")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_flags_enum, int>>), TypeInfoPropertyName = "T4791")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_flags_enum, int>>), TypeInfoPropertyName = "T4792")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_flags_enum, int>>), TypeInfoPropertyName = "T4793")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_flags_enum, int>, int>), TypeInfoPropertyName = "T4794")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4795")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4796")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4797")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4798")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_flags_enum>, int>), TypeInfoPropertyName = "T4799")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_flags_enum>), TypeInfoPropertyName = "T4800")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_flags_enum>), TypeInfoPropertyName = "T4801")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_flags_enum>), TypeInfoPropertyName = "T4802")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_flags_enum>), TypeInfoPropertyName = "T4803")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_flags_enum, int>), TypeInfoPropertyName = "T4804")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_flags_enum>), TypeInfoPropertyName = "T4805")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_flags_enum>), TypeInfoPropertyName = "T4806")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_flags_enum>), TypeInfoPropertyName = "T4807")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_flags_enum>), TypeInfoPropertyName = "T4808")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_flags_enum, int>), TypeInfoPropertyName = "T4809")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4810")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4811")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4812")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_flags_enum>>), TypeInfoPropertyName = "T4813")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_flags_enum>, int>), TypeInfoPropertyName = "T4814")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_flags_enum>), TypeInfoPropertyName = "T4815")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_flags_enum>), TypeInfoPropertyName = "T4816")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_flags_enum>), TypeInfoPropertyName = "T4817")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_flags_enum>), TypeInfoPropertyName = "T4818")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_flags_enum, int>), TypeInfoPropertyName = "T4819")]
-[JsonSerializable(typeof(V_validated_class_Uri))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_Uri>), TypeInfoPropertyName = "T4820")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_Uri>), TypeInfoPropertyName = "T4821")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_Uri>), TypeInfoPropertyName = "T4822")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_Uri>), TypeInfoPropertyName = "T4823")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_Uri, int>), TypeInfoPropertyName = "T4824")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_Uri>), TypeInfoPropertyName = "T4825")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_Uri>), TypeInfoPropertyName = "T4826")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_Uri>), TypeInfoPropertyName = "T4827")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_Uri>), TypeInfoPropertyName = "T4828")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_Uri, int>), TypeInfoPropertyName = "T4829")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_Uri>>), TypeInfoPropertyName = "T4830")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_Uri>>), TypeInfoPropertyName = "T4831")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_Uri>>), TypeInfoPropertyName = "T4832")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_Uri>>), TypeInfoPropertyName = "T4833")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_Uri>, int>), TypeInfoPropertyName = "T4834")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_Uri[]>), TypeInfoPropertyName = "T4835")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_Uri[]>), TypeInfoPropertyName = "T4836")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_Uri[]>), TypeInfoPropertyName = "T4837")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_Uri[]>), TypeInfoPropertyName = "T4838")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_Uri[], int>), TypeInfoPropertyName = "T4839")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_Uri>>), TypeInfoPropertyName = "T4840")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_Uri>>), TypeInfoPropertyName = "T4841")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_Uri>>), TypeInfoPropertyName = "T4842")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_Uri>>), TypeInfoPropertyName = "T4843")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_Uri>, int>), TypeInfoPropertyName = "T4844")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_Uri>>), TypeInfoPropertyName = "T4845")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_Uri>>), TypeInfoPropertyName = "T4846")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_Uri>>), TypeInfoPropertyName = "T4847")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_Uri>>), TypeInfoPropertyName = "T4848")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_Uri>, int>), TypeInfoPropertyName = "T4849")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_Uri, int>>), TypeInfoPropertyName = "T4850")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_Uri, int>>), TypeInfoPropertyName = "T4851")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_Uri, int>>), TypeInfoPropertyName = "T4852")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_Uri, int>>), TypeInfoPropertyName = "T4853")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_Uri, int>, int>), TypeInfoPropertyName = "T4854")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_Uri>>), TypeInfoPropertyName = "T4855")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_Uri>>), TypeInfoPropertyName = "T4856")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_Uri>>), TypeInfoPropertyName = "T4857")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_Uri>>), TypeInfoPropertyName = "T4858")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_Uri>, int>), TypeInfoPropertyName = "T4859")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_Uri>), TypeInfoPropertyName = "T4860")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_Uri>), TypeInfoPropertyName = "T4861")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_Uri>), TypeInfoPropertyName = "T4862")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_Uri>), TypeInfoPropertyName = "T4863")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_Uri, int>), TypeInfoPropertyName = "T4864")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_Uri>), TypeInfoPropertyName = "T4865")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_Uri>), TypeInfoPropertyName = "T4866")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_Uri>), TypeInfoPropertyName = "T4867")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_Uri>), TypeInfoPropertyName = "T4868")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_Uri, int>), TypeInfoPropertyName = "T4869")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_Uri>>), TypeInfoPropertyName = "T4870")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_Uri>>), TypeInfoPropertyName = "T4871")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_Uri>>), TypeInfoPropertyName = "T4872")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_Uri>>), TypeInfoPropertyName = "T4873")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_Uri>, int>), TypeInfoPropertyName = "T4874")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_Uri>), TypeInfoPropertyName = "T4875")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_Uri>), TypeInfoPropertyName = "T4876")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_Uri>), TypeInfoPropertyName = "T4877")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_Uri>), TypeInfoPropertyName = "T4878")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_Uri, int>), TypeInfoPropertyName = "T4879")]
-[JsonSerializable(typeof(V_validated_class_NodaTime_Instant))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4880")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4881")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4882")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4883")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_NodaTime_Instant, int>), TypeInfoPropertyName = "T4884")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4885")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4886")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4887")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4888")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_NodaTime_Instant, int>), TypeInfoPropertyName = "T4889")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4890")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4891")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4892")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4893")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_NodaTime_Instant>, int>), TypeInfoPropertyName = "T4894")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_NodaTime_Instant[]>), TypeInfoPropertyName = "T4895")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_NodaTime_Instant[]>), TypeInfoPropertyName = "T4896")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_NodaTime_Instant[]>), TypeInfoPropertyName = "T4897")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_NodaTime_Instant[]>), TypeInfoPropertyName = "T4898")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_NodaTime_Instant[], int>), TypeInfoPropertyName = "T4899")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4900")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4901")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4902")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4903")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_NodaTime_Instant>, int>), TypeInfoPropertyName = "T4904")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4905")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4906")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4907")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4908")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_NodaTime_Instant>, int>), TypeInfoPropertyName = "T4909")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_NodaTime_Instant, int>>), TypeInfoPropertyName = "T4910")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_NodaTime_Instant, int>>), TypeInfoPropertyName = "T4911")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_NodaTime_Instant, int>>), TypeInfoPropertyName = "T4912")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_NodaTime_Instant, int>>), TypeInfoPropertyName = "T4913")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_NodaTime_Instant, int>, int>), TypeInfoPropertyName = "T4914")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4915")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4916")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4917")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4918")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_NodaTime_Instant>, int>), TypeInfoPropertyName = "T4919")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4920")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4921")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4922")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4923")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_NodaTime_Instant, int>), TypeInfoPropertyName = "T4924")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4925")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4926")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4927")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4928")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_NodaTime_Instant, int>), TypeInfoPropertyName = "T4929")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4930")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4931")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4932")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_NodaTime_Instant>>), TypeInfoPropertyName = "T4933")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_NodaTime_Instant>, int>), TypeInfoPropertyName = "T4934")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4935")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4936")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4937")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_NodaTime_Instant>), TypeInfoPropertyName = "T4938")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_NodaTime_Instant, int>), TypeInfoPropertyName = "T4939")]
-[JsonSerializable(typeof(V_validated_class_own_record_class))]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_own_record_class>), TypeInfoPropertyName = "T4940")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_own_record_class>), TypeInfoPropertyName = "T4941")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_own_record_class>), TypeInfoPropertyName = "T4942")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_own_record_class>), TypeInfoPropertyName = "T4943")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_own_record_class, int>), TypeInfoPropertyName = "T4944")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_class_own_record_class>), TypeInfoPropertyName = "T4945")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_class_own_record_class>), TypeInfoPropertyName = "T4946")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_class_own_record_class>), TypeInfoPropertyName = "T4947")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_class_own_record_class>), TypeInfoPropertyName = "T4948")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_class_own_record_class, int>), TypeInfoPropertyName = "T4949")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4950")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4951")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4952")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4953")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_class_own_record_class>, int>), TypeInfoPropertyName = "T4954")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_class_own_record_class[]>), TypeInfoPropertyName = "T4955")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_class_own_record_class[]>), TypeInfoPropertyName = "T4956")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_class_own_record_class[]>), TypeInfoPropertyName = "T4957")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_class_own_record_class[]>), TypeInfoPropertyName = "T4958")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_class_own_record_class[], int>), TypeInfoPropertyName = "T4959")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4960")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4961")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4962")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4963")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_class_own_record_class>, int>), TypeInfoPropertyName = "T4964")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4965")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4966")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4967")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4968")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_class_own_record_class>, int>), TypeInfoPropertyName = "T4969")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<V_validated_class_own_record_class, int>>), TypeInfoPropertyName = "T4970")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<V_validated_class_own_record_class, int>>), TypeInfoPropertyName = "T4971")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<V_validated_class_own_record_class, int>>), TypeInfoPropertyName = "T4972")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<V_validated_class_own_record_class, int>>), TypeInfoPropertyName = "T4973")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<V_validated_class_own_record_class, int>, int>), TypeInfoPropertyName = "T4974")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4975")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4976")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4977")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4978")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_class_own_record_class>, int>), TypeInfoPropertyName = "T4979")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_class_own_record_class>), TypeInfoPropertyName = "T4980")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_class_own_record_class>), TypeInfoPropertyName = "T4981")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_class_own_record_class>), TypeInfoPropertyName = "T4982")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_class_own_record_class>), TypeInfoPropertyName = "T4983")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_class_own_record_class, int>), TypeInfoPropertyName = "T4984")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_class_own_record_class>), TypeInfoPropertyName = "T4985")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_class_own_record_class>), TypeInfoPropertyName = "T4986")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_class_own_record_class>), TypeInfoPropertyName = "T4987")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_class_own_record_class>), TypeInfoPropertyName = "T4988")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_class_own_record_class, int>), TypeInfoPropertyName = "T4989")]
-[JsonSerializable(typeof(Cn_class_P<Patch<V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4990")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4991")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4992")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<V_validated_class_own_record_class>>), TypeInfoPropertyName = "T4993")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<V_validated_class_own_record_class>, int>), TypeInfoPropertyName = "T4994")]
-[JsonSerializable(typeof(Cn_class_P<PB_V_validated_class_own_record_class>), TypeInfoPropertyName = "T4995")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_V_validated_class_own_record_class>), TypeInfoPropertyName = "T4996")]
-[JsonSerializable(typeof(Cn_struct_P<PB_V_validated_class_own_record_class>), TypeInfoPropertyName = "T4997")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_V_validated_class_own_record_class>), TypeInfoPropertyName = "T4998")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_V_validated_class_own_record_class, int>), TypeInfoPropertyName = "T4999")]
-[JsonSerializable(typeof(V_record_struct_string?), TypeInfoPropertyName = "T5000")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_string?>), TypeInfoPropertyName = "T5001")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_string?>), TypeInfoPropertyName = "T5002")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_string?>), TypeInfoPropertyName = "T5003")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_string?>), TypeInfoPropertyName = "T5004")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_string?, int>), TypeInfoPropertyName = "T5005")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_string?>>), TypeInfoPropertyName = "T5006")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_string?>>), TypeInfoPropertyName = "T5007")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_string?>>), TypeInfoPropertyName = "T5008")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_string?>>), TypeInfoPropertyName = "T5009")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_string?>, int>), TypeInfoPropertyName = "T5010")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_string?[]>), TypeInfoPropertyName = "T5011")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_string?[]>), TypeInfoPropertyName = "T5012")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_string?[]>), TypeInfoPropertyName = "T5013")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_string?[]>), TypeInfoPropertyName = "T5014")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_string?[], int>), TypeInfoPropertyName = "T5015")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_string?>>), TypeInfoPropertyName = "T5016")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_string?>>), TypeInfoPropertyName = "T5017")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_string?>>), TypeInfoPropertyName = "T5018")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_string?>>), TypeInfoPropertyName = "T5019")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_string?>, int>), TypeInfoPropertyName = "T5020")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_string?>>), TypeInfoPropertyName = "T5021")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_string?>>), TypeInfoPropertyName = "T5022")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_string?>>), TypeInfoPropertyName = "T5023")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_string?>>), TypeInfoPropertyName = "T5024")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_string?>, int>), TypeInfoPropertyName = "T5025")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_string?>>), TypeInfoPropertyName = "T5026")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_string?>>), TypeInfoPropertyName = "T5027")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_string?>>), TypeInfoPropertyName = "T5028")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_string?>>), TypeInfoPropertyName = "T5029")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_string?>, int>), TypeInfoPropertyName = "T5030")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_string?>), TypeInfoPropertyName = "T5031")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_string?>), TypeInfoPropertyName = "T5032")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_string?>), TypeInfoPropertyName = "T5033")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_string?>), TypeInfoPropertyName = "T5034")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_string?, int>), TypeInfoPropertyName = "T5035")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_string?>), TypeInfoPropertyName = "T5036")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_string?>), TypeInfoPropertyName = "T5037")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_string?>), TypeInfoPropertyName = "T5038")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_string?>), TypeInfoPropertyName = "T5039")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_string?, int>), TypeInfoPropertyName = "T5040")]
-[JsonSerializable(typeof(V_record_struct_Guid?), TypeInfoPropertyName = "T5041")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_Guid?>), TypeInfoPropertyName = "T5042")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_Guid?>), TypeInfoPropertyName = "T5043")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_Guid?>), TypeInfoPropertyName = "T5044")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_Guid?>), TypeInfoPropertyName = "T5045")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_Guid?, int>), TypeInfoPropertyName = "T5046")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_Guid?>>), TypeInfoPropertyName = "T5047")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_Guid?>>), TypeInfoPropertyName = "T5048")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_Guid?>>), TypeInfoPropertyName = "T5049")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_Guid?>>), TypeInfoPropertyName = "T5050")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_Guid?>, int>), TypeInfoPropertyName = "T5051")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_Guid?[]>), TypeInfoPropertyName = "T5052")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_Guid?[]>), TypeInfoPropertyName = "T5053")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_Guid?[]>), TypeInfoPropertyName = "T5054")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_Guid?[]>), TypeInfoPropertyName = "T5055")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_Guid?[], int>), TypeInfoPropertyName = "T5056")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_Guid?>>), TypeInfoPropertyName = "T5057")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_Guid?>>), TypeInfoPropertyName = "T5058")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_Guid?>>), TypeInfoPropertyName = "T5059")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_Guid?>>), TypeInfoPropertyName = "T5060")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_Guid?>, int>), TypeInfoPropertyName = "T5061")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_Guid?>>), TypeInfoPropertyName = "T5062")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_Guid?>>), TypeInfoPropertyName = "T5063")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_Guid?>>), TypeInfoPropertyName = "T5064")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_Guid?>>), TypeInfoPropertyName = "T5065")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_Guid?>, int>), TypeInfoPropertyName = "T5066")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_Guid?>>), TypeInfoPropertyName = "T5067")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_Guid?>>), TypeInfoPropertyName = "T5068")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_Guid?>>), TypeInfoPropertyName = "T5069")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_Guid?>>), TypeInfoPropertyName = "T5070")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_Guid?>, int>), TypeInfoPropertyName = "T5071")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_Guid?>), TypeInfoPropertyName = "T5072")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_Guid?>), TypeInfoPropertyName = "T5073")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_Guid?>), TypeInfoPropertyName = "T5074")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_Guid?>), TypeInfoPropertyName = "T5075")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_Guid?, int>), TypeInfoPropertyName = "T5076")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_Guid?>), TypeInfoPropertyName = "T5077")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_Guid?>), TypeInfoPropertyName = "T5078")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_Guid?>), TypeInfoPropertyName = "T5079")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_Guid?>), TypeInfoPropertyName = "T5080")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_Guid?, int>), TypeInfoPropertyName = "T5081")]
-[JsonSerializable(typeof(V_record_struct_int?), TypeInfoPropertyName = "T5082")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_int?>), TypeInfoPropertyName = "T5083")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_int?>), TypeInfoPropertyName = "T5084")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_int?>), TypeInfoPropertyName = "T5085")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_int?>), TypeInfoPropertyName = "T5086")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_int?, int>), TypeInfoPropertyName = "T5087")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_int?>>), TypeInfoPropertyName = "T5088")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_int?>>), TypeInfoPropertyName = "T5089")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_int?>>), TypeInfoPropertyName = "T5090")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_int?>>), TypeInfoPropertyName = "T5091")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_int?>, int>), TypeInfoPropertyName = "T5092")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_int?[]>), TypeInfoPropertyName = "T5093")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_int?[]>), TypeInfoPropertyName = "T5094")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_int?[]>), TypeInfoPropertyName = "T5095")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_int?[]>), TypeInfoPropertyName = "T5096")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_int?[], int>), TypeInfoPropertyName = "T5097")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_int?>>), TypeInfoPropertyName = "T5098")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_int?>>), TypeInfoPropertyName = "T5099")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_int?>>), TypeInfoPropertyName = "T5100")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_int?>>), TypeInfoPropertyName = "T5101")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_int?>, int>), TypeInfoPropertyName = "T5102")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_int?>>), TypeInfoPropertyName = "T5103")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_int?>>), TypeInfoPropertyName = "T5104")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_int?>>), TypeInfoPropertyName = "T5105")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_int?>>), TypeInfoPropertyName = "T5106")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_int?>, int>), TypeInfoPropertyName = "T5107")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_int?>>), TypeInfoPropertyName = "T5108")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_int?>>), TypeInfoPropertyName = "T5109")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_int?>>), TypeInfoPropertyName = "T5110")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_int?>>), TypeInfoPropertyName = "T5111")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_int?>, int>), TypeInfoPropertyName = "T5112")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_int?>), TypeInfoPropertyName = "T5113")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_int?>), TypeInfoPropertyName = "T5114")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_int?>), TypeInfoPropertyName = "T5115")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_int?>), TypeInfoPropertyName = "T5116")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_int?, int>), TypeInfoPropertyName = "T5117")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_int?>), TypeInfoPropertyName = "T5118")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_int?>), TypeInfoPropertyName = "T5119")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_int?>), TypeInfoPropertyName = "T5120")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_int?>), TypeInfoPropertyName = "T5121")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_int?, int>), TypeInfoPropertyName = "T5122")]
-[JsonSerializable(typeof(V_record_struct_long?), TypeInfoPropertyName = "T5123")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_long?>), TypeInfoPropertyName = "T5124")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_long?>), TypeInfoPropertyName = "T5125")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_long?>), TypeInfoPropertyName = "T5126")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_long?>), TypeInfoPropertyName = "T5127")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_long?, int>), TypeInfoPropertyName = "T5128")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_long?>>), TypeInfoPropertyName = "T5129")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_long?>>), TypeInfoPropertyName = "T5130")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_long?>>), TypeInfoPropertyName = "T5131")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_long?>>), TypeInfoPropertyName = "T5132")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_long?>, int>), TypeInfoPropertyName = "T5133")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_long?[]>), TypeInfoPropertyName = "T5134")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_long?[]>), TypeInfoPropertyName = "T5135")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_long?[]>), TypeInfoPropertyName = "T5136")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_long?[]>), TypeInfoPropertyName = "T5137")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_long?[], int>), TypeInfoPropertyName = "T5138")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_long?>>), TypeInfoPropertyName = "T5139")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_long?>>), TypeInfoPropertyName = "T5140")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_long?>>), TypeInfoPropertyName = "T5141")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_long?>>), TypeInfoPropertyName = "T5142")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_long?>, int>), TypeInfoPropertyName = "T5143")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_long?>>), TypeInfoPropertyName = "T5144")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_long?>>), TypeInfoPropertyName = "T5145")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_long?>>), TypeInfoPropertyName = "T5146")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_long?>>), TypeInfoPropertyName = "T5147")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_long?>, int>), TypeInfoPropertyName = "T5148")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_long?>>), TypeInfoPropertyName = "T5149")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_long?>>), TypeInfoPropertyName = "T5150")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_long?>>), TypeInfoPropertyName = "T5151")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_long?>>), TypeInfoPropertyName = "T5152")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_long?>, int>), TypeInfoPropertyName = "T5153")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_long?>), TypeInfoPropertyName = "T5154")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_long?>), TypeInfoPropertyName = "T5155")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_long?>), TypeInfoPropertyName = "T5156")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_long?>), TypeInfoPropertyName = "T5157")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_long?, int>), TypeInfoPropertyName = "T5158")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_long?>), TypeInfoPropertyName = "T5159")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_long?>), TypeInfoPropertyName = "T5160")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_long?>), TypeInfoPropertyName = "T5161")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_long?>), TypeInfoPropertyName = "T5162")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_long?, int>), TypeInfoPropertyName = "T5163")]
-[JsonSerializable(typeof(V_record_struct_byte?), TypeInfoPropertyName = "T5164")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_byte?>), TypeInfoPropertyName = "T5165")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_byte?>), TypeInfoPropertyName = "T5166")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_byte?>), TypeInfoPropertyName = "T5167")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_byte?>), TypeInfoPropertyName = "T5168")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_byte?, int>), TypeInfoPropertyName = "T5169")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_byte?>>), TypeInfoPropertyName = "T5170")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_byte?>>), TypeInfoPropertyName = "T5171")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_byte?>>), TypeInfoPropertyName = "T5172")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_byte?>>), TypeInfoPropertyName = "T5173")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_byte?>, int>), TypeInfoPropertyName = "T5174")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_byte?[]>), TypeInfoPropertyName = "T5175")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_byte?[]>), TypeInfoPropertyName = "T5176")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_byte?[]>), TypeInfoPropertyName = "T5177")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_byte?[]>), TypeInfoPropertyName = "T5178")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_byte?[], int>), TypeInfoPropertyName = "T5179")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_byte?>>), TypeInfoPropertyName = "T5180")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_byte?>>), TypeInfoPropertyName = "T5181")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_byte?>>), TypeInfoPropertyName = "T5182")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_byte?>>), TypeInfoPropertyName = "T5183")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_byte?>, int>), TypeInfoPropertyName = "T5184")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_byte?>>), TypeInfoPropertyName = "T5185")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_byte?>>), TypeInfoPropertyName = "T5186")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_byte?>>), TypeInfoPropertyName = "T5187")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_byte?>>), TypeInfoPropertyName = "T5188")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_byte?>, int>), TypeInfoPropertyName = "T5189")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_byte?>>), TypeInfoPropertyName = "T5190")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_byte?>>), TypeInfoPropertyName = "T5191")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_byte?>>), TypeInfoPropertyName = "T5192")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_byte?>>), TypeInfoPropertyName = "T5193")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_byte?>, int>), TypeInfoPropertyName = "T5194")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_byte?>), TypeInfoPropertyName = "T5195")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_byte?>), TypeInfoPropertyName = "T5196")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_byte?>), TypeInfoPropertyName = "T5197")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_byte?>), TypeInfoPropertyName = "T5198")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_byte?, int>), TypeInfoPropertyName = "T5199")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_byte?>), TypeInfoPropertyName = "T5200")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_byte?>), TypeInfoPropertyName = "T5201")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_byte?>), TypeInfoPropertyName = "T5202")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_byte?>), TypeInfoPropertyName = "T5203")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_byte?, int>), TypeInfoPropertyName = "T5204")]
-[JsonSerializable(typeof(V_record_struct_ulong?), TypeInfoPropertyName = "T5205")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_ulong?>), TypeInfoPropertyName = "T5206")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_ulong?>), TypeInfoPropertyName = "T5207")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_ulong?>), TypeInfoPropertyName = "T5208")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_ulong?>), TypeInfoPropertyName = "T5209")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_ulong?, int>), TypeInfoPropertyName = "T5210")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_ulong?>>), TypeInfoPropertyName = "T5211")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_ulong?>>), TypeInfoPropertyName = "T5212")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_ulong?>>), TypeInfoPropertyName = "T5213")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_ulong?>>), TypeInfoPropertyName = "T5214")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_ulong?>, int>), TypeInfoPropertyName = "T5215")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_ulong?[]>), TypeInfoPropertyName = "T5216")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_ulong?[]>), TypeInfoPropertyName = "T5217")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_ulong?[]>), TypeInfoPropertyName = "T5218")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_ulong?[]>), TypeInfoPropertyName = "T5219")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_ulong?[], int>), TypeInfoPropertyName = "T5220")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_ulong?>>), TypeInfoPropertyName = "T5221")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_ulong?>>), TypeInfoPropertyName = "T5222")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_ulong?>>), TypeInfoPropertyName = "T5223")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_ulong?>>), TypeInfoPropertyName = "T5224")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_ulong?>, int>), TypeInfoPropertyName = "T5225")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_ulong?>>), TypeInfoPropertyName = "T5226")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_ulong?>>), TypeInfoPropertyName = "T5227")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_ulong?>>), TypeInfoPropertyName = "T5228")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_ulong?>>), TypeInfoPropertyName = "T5229")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_ulong?>, int>), TypeInfoPropertyName = "T5230")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_ulong?>>), TypeInfoPropertyName = "T5231")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_ulong?>>), TypeInfoPropertyName = "T5232")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_ulong?>>), TypeInfoPropertyName = "T5233")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_ulong?>>), TypeInfoPropertyName = "T5234")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_ulong?>, int>), TypeInfoPropertyName = "T5235")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_ulong?>), TypeInfoPropertyName = "T5236")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_ulong?>), TypeInfoPropertyName = "T5237")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_ulong?>), TypeInfoPropertyName = "T5238")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_ulong?>), TypeInfoPropertyName = "T5239")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_ulong?, int>), TypeInfoPropertyName = "T5240")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_ulong?>), TypeInfoPropertyName = "T5241")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_ulong?>), TypeInfoPropertyName = "T5242")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_ulong?>), TypeInfoPropertyName = "T5243")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_ulong?>), TypeInfoPropertyName = "T5244")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_ulong?, int>), TypeInfoPropertyName = "T5245")]
-[JsonSerializable(typeof(V_record_struct_decimal?), TypeInfoPropertyName = "T5246")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_decimal?>), TypeInfoPropertyName = "T5247")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_decimal?>), TypeInfoPropertyName = "T5248")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_decimal?>), TypeInfoPropertyName = "T5249")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_decimal?>), TypeInfoPropertyName = "T5250")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_decimal?, int>), TypeInfoPropertyName = "T5251")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_decimal?>>), TypeInfoPropertyName = "T5252")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_decimal?>>), TypeInfoPropertyName = "T5253")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_decimal?>>), TypeInfoPropertyName = "T5254")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_decimal?>>), TypeInfoPropertyName = "T5255")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_decimal?>, int>), TypeInfoPropertyName = "T5256")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_decimal?[]>), TypeInfoPropertyName = "T5257")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_decimal?[]>), TypeInfoPropertyName = "T5258")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_decimal?[]>), TypeInfoPropertyName = "T5259")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_decimal?[]>), TypeInfoPropertyName = "T5260")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_decimal?[], int>), TypeInfoPropertyName = "T5261")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_decimal?>>), TypeInfoPropertyName = "T5262")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_decimal?>>), TypeInfoPropertyName = "T5263")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_decimal?>>), TypeInfoPropertyName = "T5264")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_decimal?>>), TypeInfoPropertyName = "T5265")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_decimal?>, int>), TypeInfoPropertyName = "T5266")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_decimal?>>), TypeInfoPropertyName = "T5267")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_decimal?>>), TypeInfoPropertyName = "T5268")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_decimal?>>), TypeInfoPropertyName = "T5269")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_decimal?>>), TypeInfoPropertyName = "T5270")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_decimal?>, int>), TypeInfoPropertyName = "T5271")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_decimal?>>), TypeInfoPropertyName = "T5272")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_decimal?>>), TypeInfoPropertyName = "T5273")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_decimal?>>), TypeInfoPropertyName = "T5274")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_decimal?>>), TypeInfoPropertyName = "T5275")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_decimal?>, int>), TypeInfoPropertyName = "T5276")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_decimal?>), TypeInfoPropertyName = "T5277")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_decimal?>), TypeInfoPropertyName = "T5278")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_decimal?>), TypeInfoPropertyName = "T5279")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_decimal?>), TypeInfoPropertyName = "T5280")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_decimal?, int>), TypeInfoPropertyName = "T5281")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_decimal?>), TypeInfoPropertyName = "T5282")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_decimal?>), TypeInfoPropertyName = "T5283")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_decimal?>), TypeInfoPropertyName = "T5284")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_decimal?>), TypeInfoPropertyName = "T5285")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_decimal?, int>), TypeInfoPropertyName = "T5286")]
-[JsonSerializable(typeof(V_record_struct_double?), TypeInfoPropertyName = "T5287")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_double?>), TypeInfoPropertyName = "T5288")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_double?>), TypeInfoPropertyName = "T5289")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_double?>), TypeInfoPropertyName = "T5290")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_double?>), TypeInfoPropertyName = "T5291")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_double?, int>), TypeInfoPropertyName = "T5292")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_double?>>), TypeInfoPropertyName = "T5293")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_double?>>), TypeInfoPropertyName = "T5294")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_double?>>), TypeInfoPropertyName = "T5295")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_double?>>), TypeInfoPropertyName = "T5296")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_double?>, int>), TypeInfoPropertyName = "T5297")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_double?[]>), TypeInfoPropertyName = "T5298")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_double?[]>), TypeInfoPropertyName = "T5299")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_double?[]>), TypeInfoPropertyName = "T5300")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_double?[]>), TypeInfoPropertyName = "T5301")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_double?[], int>), TypeInfoPropertyName = "T5302")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_double?>>), TypeInfoPropertyName = "T5303")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_double?>>), TypeInfoPropertyName = "T5304")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_double?>>), TypeInfoPropertyName = "T5305")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_double?>>), TypeInfoPropertyName = "T5306")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_double?>, int>), TypeInfoPropertyName = "T5307")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_double?>>), TypeInfoPropertyName = "T5308")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_double?>>), TypeInfoPropertyName = "T5309")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_double?>>), TypeInfoPropertyName = "T5310")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_double?>>), TypeInfoPropertyName = "T5311")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_double?>, int>), TypeInfoPropertyName = "T5312")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_double?>>), TypeInfoPropertyName = "T5313")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_double?>>), TypeInfoPropertyName = "T5314")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_double?>>), TypeInfoPropertyName = "T5315")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_double?>>), TypeInfoPropertyName = "T5316")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_double?>, int>), TypeInfoPropertyName = "T5317")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_double?>), TypeInfoPropertyName = "T5318")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_double?>), TypeInfoPropertyName = "T5319")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_double?>), TypeInfoPropertyName = "T5320")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_double?>), TypeInfoPropertyName = "T5321")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_double?, int>), TypeInfoPropertyName = "T5322")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_double?>), TypeInfoPropertyName = "T5323")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_double?>), TypeInfoPropertyName = "T5324")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_double?>), TypeInfoPropertyName = "T5325")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_double?>), TypeInfoPropertyName = "T5326")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_double?, int>), TypeInfoPropertyName = "T5327")]
-[JsonSerializable(typeof(V_record_struct_bool?), TypeInfoPropertyName = "T5328")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_bool?>), TypeInfoPropertyName = "T5329")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_bool?>), TypeInfoPropertyName = "T5330")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_bool?>), TypeInfoPropertyName = "T5331")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_bool?>), TypeInfoPropertyName = "T5332")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_bool?, int>), TypeInfoPropertyName = "T5333")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_bool?>>), TypeInfoPropertyName = "T5334")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_bool?>>), TypeInfoPropertyName = "T5335")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_bool?>>), TypeInfoPropertyName = "T5336")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_bool?>>), TypeInfoPropertyName = "T5337")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_bool?>, int>), TypeInfoPropertyName = "T5338")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_bool?[]>), TypeInfoPropertyName = "T5339")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_bool?[]>), TypeInfoPropertyName = "T5340")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_bool?[]>), TypeInfoPropertyName = "T5341")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_bool?[]>), TypeInfoPropertyName = "T5342")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_bool?[], int>), TypeInfoPropertyName = "T5343")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_bool?>>), TypeInfoPropertyName = "T5344")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_bool?>>), TypeInfoPropertyName = "T5345")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_bool?>>), TypeInfoPropertyName = "T5346")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_bool?>>), TypeInfoPropertyName = "T5347")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_bool?>, int>), TypeInfoPropertyName = "T5348")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_bool?>>), TypeInfoPropertyName = "T5349")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_bool?>>), TypeInfoPropertyName = "T5350")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_bool?>>), TypeInfoPropertyName = "T5351")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_bool?>>), TypeInfoPropertyName = "T5352")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_bool?>, int>), TypeInfoPropertyName = "T5353")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_bool?>>), TypeInfoPropertyName = "T5354")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_bool?>>), TypeInfoPropertyName = "T5355")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_bool?>>), TypeInfoPropertyName = "T5356")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_bool?>>), TypeInfoPropertyName = "T5357")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_bool?>, int>), TypeInfoPropertyName = "T5358")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_bool?>), TypeInfoPropertyName = "T5359")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_bool?>), TypeInfoPropertyName = "T5360")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_bool?>), TypeInfoPropertyName = "T5361")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_bool?>), TypeInfoPropertyName = "T5362")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_bool?, int>), TypeInfoPropertyName = "T5363")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_bool?>), TypeInfoPropertyName = "T5364")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_bool?>), TypeInfoPropertyName = "T5365")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_bool?>), TypeInfoPropertyName = "T5366")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_bool?>), TypeInfoPropertyName = "T5367")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_bool?, int>), TypeInfoPropertyName = "T5368")]
-[JsonSerializable(typeof(V_record_struct_char?), TypeInfoPropertyName = "T5369")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_char?>), TypeInfoPropertyName = "T5370")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_char?>), TypeInfoPropertyName = "T5371")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_char?>), TypeInfoPropertyName = "T5372")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_char?>), TypeInfoPropertyName = "T5373")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_char?, int>), TypeInfoPropertyName = "T5374")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_char?>>), TypeInfoPropertyName = "T5375")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_char?>>), TypeInfoPropertyName = "T5376")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_char?>>), TypeInfoPropertyName = "T5377")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_char?>>), TypeInfoPropertyName = "T5378")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_char?>, int>), TypeInfoPropertyName = "T5379")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_char?[]>), TypeInfoPropertyName = "T5380")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_char?[]>), TypeInfoPropertyName = "T5381")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_char?[]>), TypeInfoPropertyName = "T5382")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_char?[]>), TypeInfoPropertyName = "T5383")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_char?[], int>), TypeInfoPropertyName = "T5384")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_char?>>), TypeInfoPropertyName = "T5385")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_char?>>), TypeInfoPropertyName = "T5386")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_char?>>), TypeInfoPropertyName = "T5387")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_char?>>), TypeInfoPropertyName = "T5388")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_char?>, int>), TypeInfoPropertyName = "T5389")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_char?>>), TypeInfoPropertyName = "T5390")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_char?>>), TypeInfoPropertyName = "T5391")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_char?>>), TypeInfoPropertyName = "T5392")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_char?>>), TypeInfoPropertyName = "T5393")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_char?>, int>), TypeInfoPropertyName = "T5394")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_char?>>), TypeInfoPropertyName = "T5395")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_char?>>), TypeInfoPropertyName = "T5396")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_char?>>), TypeInfoPropertyName = "T5397")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_char?>>), TypeInfoPropertyName = "T5398")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_char?>, int>), TypeInfoPropertyName = "T5399")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_char?>), TypeInfoPropertyName = "T5400")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_char?>), TypeInfoPropertyName = "T5401")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_char?>), TypeInfoPropertyName = "T5402")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_char?>), TypeInfoPropertyName = "T5403")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_char?, int>), TypeInfoPropertyName = "T5404")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_char?>), TypeInfoPropertyName = "T5405")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_char?>), TypeInfoPropertyName = "T5406")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_char?>), TypeInfoPropertyName = "T5407")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_char?>), TypeInfoPropertyName = "T5408")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_char?, int>), TypeInfoPropertyName = "T5409")]
-[JsonSerializable(typeof(V_record_struct_DateTime?), TypeInfoPropertyName = "T5410")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_DateTime?>), TypeInfoPropertyName = "T5411")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_DateTime?>), TypeInfoPropertyName = "T5412")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_DateTime?>), TypeInfoPropertyName = "T5413")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_DateTime?>), TypeInfoPropertyName = "T5414")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_DateTime?, int>), TypeInfoPropertyName = "T5415")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_DateTime?>>), TypeInfoPropertyName = "T5416")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_DateTime?>>), TypeInfoPropertyName = "T5417")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_DateTime?>>), TypeInfoPropertyName = "T5418")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_DateTime?>>), TypeInfoPropertyName = "T5419")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_DateTime?>, int>), TypeInfoPropertyName = "T5420")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_DateTime?[]>), TypeInfoPropertyName = "T5421")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_DateTime?[]>), TypeInfoPropertyName = "T5422")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_DateTime?[]>), TypeInfoPropertyName = "T5423")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_DateTime?[]>), TypeInfoPropertyName = "T5424")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_DateTime?[], int>), TypeInfoPropertyName = "T5425")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_DateTime?>>), TypeInfoPropertyName = "T5426")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_DateTime?>>), TypeInfoPropertyName = "T5427")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_DateTime?>>), TypeInfoPropertyName = "T5428")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_DateTime?>>), TypeInfoPropertyName = "T5429")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_DateTime?>, int>), TypeInfoPropertyName = "T5430")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_DateTime?>>), TypeInfoPropertyName = "T5431")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_DateTime?>>), TypeInfoPropertyName = "T5432")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_DateTime?>>), TypeInfoPropertyName = "T5433")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_DateTime?>>), TypeInfoPropertyName = "T5434")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_DateTime?>, int>), TypeInfoPropertyName = "T5435")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_DateTime?>>), TypeInfoPropertyName = "T5436")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_DateTime?>>), TypeInfoPropertyName = "T5437")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_DateTime?>>), TypeInfoPropertyName = "T5438")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_DateTime?>>), TypeInfoPropertyName = "T5439")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_DateTime?>, int>), TypeInfoPropertyName = "T5440")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_DateTime?>), TypeInfoPropertyName = "T5441")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_DateTime?>), TypeInfoPropertyName = "T5442")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_DateTime?>), TypeInfoPropertyName = "T5443")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_DateTime?>), TypeInfoPropertyName = "T5444")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_DateTime?, int>), TypeInfoPropertyName = "T5445")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_DateTime?>), TypeInfoPropertyName = "T5446")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_DateTime?>), TypeInfoPropertyName = "T5447")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_DateTime?>), TypeInfoPropertyName = "T5448")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_DateTime?>), TypeInfoPropertyName = "T5449")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_DateTime?, int>), TypeInfoPropertyName = "T5450")]
-[JsonSerializable(typeof(V_record_struct_DateTimeOffset?), TypeInfoPropertyName = "T5451")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_DateTimeOffset?>), TypeInfoPropertyName = "T5452")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_DateTimeOffset?>), TypeInfoPropertyName = "T5453")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_DateTimeOffset?>), TypeInfoPropertyName = "T5454")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_DateTimeOffset?>), TypeInfoPropertyName = "T5455")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_DateTimeOffset?, int>), TypeInfoPropertyName = "T5456")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T5457")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T5458")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T5459")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T5460")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_DateTimeOffset?>, int>), TypeInfoPropertyName = "T5461")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_DateTimeOffset?[]>), TypeInfoPropertyName = "T5462")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_DateTimeOffset?[]>), TypeInfoPropertyName = "T5463")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_DateTimeOffset?[]>), TypeInfoPropertyName = "T5464")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_DateTimeOffset?[]>), TypeInfoPropertyName = "T5465")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_DateTimeOffset?[], int>), TypeInfoPropertyName = "T5466")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T5467")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T5468")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T5469")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T5470")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_DateTimeOffset?>, int>), TypeInfoPropertyName = "T5471")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T5472")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T5473")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T5474")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T5475")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_DateTimeOffset?>, int>), TypeInfoPropertyName = "T5476")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T5477")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T5478")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T5479")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T5480")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_DateTimeOffset?>, int>), TypeInfoPropertyName = "T5481")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_DateTimeOffset?>), TypeInfoPropertyName = "T5482")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_DateTimeOffset?>), TypeInfoPropertyName = "T5483")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_DateTimeOffset?>), TypeInfoPropertyName = "T5484")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_DateTimeOffset?>), TypeInfoPropertyName = "T5485")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_DateTimeOffset?, int>), TypeInfoPropertyName = "T5486")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_DateTimeOffset?>), TypeInfoPropertyName = "T5487")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_DateTimeOffset?>), TypeInfoPropertyName = "T5488")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_DateTimeOffset?>), TypeInfoPropertyName = "T5489")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_DateTimeOffset?>), TypeInfoPropertyName = "T5490")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_DateTimeOffset?, int>), TypeInfoPropertyName = "T5491")]
-[JsonSerializable(typeof(V_record_struct_DateOnly?), TypeInfoPropertyName = "T5492")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_DateOnly?>), TypeInfoPropertyName = "T5493")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_DateOnly?>), TypeInfoPropertyName = "T5494")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_DateOnly?>), TypeInfoPropertyName = "T5495")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_DateOnly?>), TypeInfoPropertyName = "T5496")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_DateOnly?, int>), TypeInfoPropertyName = "T5497")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_DateOnly?>>), TypeInfoPropertyName = "T5498")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_DateOnly?>>), TypeInfoPropertyName = "T5499")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_DateOnly?>>), TypeInfoPropertyName = "T5500")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_DateOnly?>>), TypeInfoPropertyName = "T5501")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_DateOnly?>, int>), TypeInfoPropertyName = "T5502")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_DateOnly?[]>), TypeInfoPropertyName = "T5503")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_DateOnly?[]>), TypeInfoPropertyName = "T5504")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_DateOnly?[]>), TypeInfoPropertyName = "T5505")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_DateOnly?[]>), TypeInfoPropertyName = "T5506")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_DateOnly?[], int>), TypeInfoPropertyName = "T5507")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_DateOnly?>>), TypeInfoPropertyName = "T5508")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_DateOnly?>>), TypeInfoPropertyName = "T5509")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_DateOnly?>>), TypeInfoPropertyName = "T5510")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_DateOnly?>>), TypeInfoPropertyName = "T5511")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_DateOnly?>, int>), TypeInfoPropertyName = "T5512")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_DateOnly?>>), TypeInfoPropertyName = "T5513")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_DateOnly?>>), TypeInfoPropertyName = "T5514")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_DateOnly?>>), TypeInfoPropertyName = "T5515")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_DateOnly?>>), TypeInfoPropertyName = "T5516")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_DateOnly?>, int>), TypeInfoPropertyName = "T5517")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_DateOnly?>>), TypeInfoPropertyName = "T5518")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_DateOnly?>>), TypeInfoPropertyName = "T5519")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_DateOnly?>>), TypeInfoPropertyName = "T5520")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_DateOnly?>>), TypeInfoPropertyName = "T5521")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_DateOnly?>, int>), TypeInfoPropertyName = "T5522")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_DateOnly?>), TypeInfoPropertyName = "T5523")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_DateOnly?>), TypeInfoPropertyName = "T5524")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_DateOnly?>), TypeInfoPropertyName = "T5525")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_DateOnly?>), TypeInfoPropertyName = "T5526")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_DateOnly?, int>), TypeInfoPropertyName = "T5527")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_DateOnly?>), TypeInfoPropertyName = "T5528")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_DateOnly?>), TypeInfoPropertyName = "T5529")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_DateOnly?>), TypeInfoPropertyName = "T5530")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_DateOnly?>), TypeInfoPropertyName = "T5531")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_DateOnly?, int>), TypeInfoPropertyName = "T5532")]
-[JsonSerializable(typeof(V_record_struct_TimeOnly?), TypeInfoPropertyName = "T5533")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_TimeOnly?>), TypeInfoPropertyName = "T5534")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_TimeOnly?>), TypeInfoPropertyName = "T5535")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_TimeOnly?>), TypeInfoPropertyName = "T5536")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_TimeOnly?>), TypeInfoPropertyName = "T5537")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_TimeOnly?, int>), TypeInfoPropertyName = "T5538")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_TimeOnly?>>), TypeInfoPropertyName = "T5539")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_TimeOnly?>>), TypeInfoPropertyName = "T5540")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_TimeOnly?>>), TypeInfoPropertyName = "T5541")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_TimeOnly?>>), TypeInfoPropertyName = "T5542")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_TimeOnly?>, int>), TypeInfoPropertyName = "T5543")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_TimeOnly?[]>), TypeInfoPropertyName = "T5544")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_TimeOnly?[]>), TypeInfoPropertyName = "T5545")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_TimeOnly?[]>), TypeInfoPropertyName = "T5546")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_TimeOnly?[]>), TypeInfoPropertyName = "T5547")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_TimeOnly?[], int>), TypeInfoPropertyName = "T5548")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_TimeOnly?>>), TypeInfoPropertyName = "T5549")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_TimeOnly?>>), TypeInfoPropertyName = "T5550")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_TimeOnly?>>), TypeInfoPropertyName = "T5551")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_TimeOnly?>>), TypeInfoPropertyName = "T5552")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_TimeOnly?>, int>), TypeInfoPropertyName = "T5553")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_TimeOnly?>>), TypeInfoPropertyName = "T5554")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_TimeOnly?>>), TypeInfoPropertyName = "T5555")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_TimeOnly?>>), TypeInfoPropertyName = "T5556")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_TimeOnly?>>), TypeInfoPropertyName = "T5557")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_TimeOnly?>, int>), TypeInfoPropertyName = "T5558")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_TimeOnly?>>), TypeInfoPropertyName = "T5559")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_TimeOnly?>>), TypeInfoPropertyName = "T5560")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_TimeOnly?>>), TypeInfoPropertyName = "T5561")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_TimeOnly?>>), TypeInfoPropertyName = "T5562")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_TimeOnly?>, int>), TypeInfoPropertyName = "T5563")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_TimeOnly?>), TypeInfoPropertyName = "T5564")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_TimeOnly?>), TypeInfoPropertyName = "T5565")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_TimeOnly?>), TypeInfoPropertyName = "T5566")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_TimeOnly?>), TypeInfoPropertyName = "T5567")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_TimeOnly?, int>), TypeInfoPropertyName = "T5568")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_TimeOnly?>), TypeInfoPropertyName = "T5569")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_TimeOnly?>), TypeInfoPropertyName = "T5570")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_TimeOnly?>), TypeInfoPropertyName = "T5571")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_TimeOnly?>), TypeInfoPropertyName = "T5572")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_TimeOnly?, int>), TypeInfoPropertyName = "T5573")]
-[JsonSerializable(typeof(V_record_struct_TimeSpan?), TypeInfoPropertyName = "T5574")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_TimeSpan?>), TypeInfoPropertyName = "T5575")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_TimeSpan?>), TypeInfoPropertyName = "T5576")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_TimeSpan?>), TypeInfoPropertyName = "T5577")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_TimeSpan?>), TypeInfoPropertyName = "T5578")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_TimeSpan?, int>), TypeInfoPropertyName = "T5579")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_TimeSpan?>>), TypeInfoPropertyName = "T5580")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_TimeSpan?>>), TypeInfoPropertyName = "T5581")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_TimeSpan?>>), TypeInfoPropertyName = "T5582")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_TimeSpan?>>), TypeInfoPropertyName = "T5583")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_TimeSpan?>, int>), TypeInfoPropertyName = "T5584")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_TimeSpan?[]>), TypeInfoPropertyName = "T5585")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_TimeSpan?[]>), TypeInfoPropertyName = "T5586")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_TimeSpan?[]>), TypeInfoPropertyName = "T5587")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_TimeSpan?[]>), TypeInfoPropertyName = "T5588")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_TimeSpan?[], int>), TypeInfoPropertyName = "T5589")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_TimeSpan?>>), TypeInfoPropertyName = "T5590")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_TimeSpan?>>), TypeInfoPropertyName = "T5591")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_TimeSpan?>>), TypeInfoPropertyName = "T5592")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_TimeSpan?>>), TypeInfoPropertyName = "T5593")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_TimeSpan?>, int>), TypeInfoPropertyName = "T5594")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_TimeSpan?>>), TypeInfoPropertyName = "T5595")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_TimeSpan?>>), TypeInfoPropertyName = "T5596")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_TimeSpan?>>), TypeInfoPropertyName = "T5597")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_TimeSpan?>>), TypeInfoPropertyName = "T5598")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_TimeSpan?>, int>), TypeInfoPropertyName = "T5599")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_TimeSpan?>>), TypeInfoPropertyName = "T5600")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_TimeSpan?>>), TypeInfoPropertyName = "T5601")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_TimeSpan?>>), TypeInfoPropertyName = "T5602")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_TimeSpan?>>), TypeInfoPropertyName = "T5603")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_TimeSpan?>, int>), TypeInfoPropertyName = "T5604")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_TimeSpan?>), TypeInfoPropertyName = "T5605")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_TimeSpan?>), TypeInfoPropertyName = "T5606")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_TimeSpan?>), TypeInfoPropertyName = "T5607")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_TimeSpan?>), TypeInfoPropertyName = "T5608")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_TimeSpan?, int>), TypeInfoPropertyName = "T5609")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_TimeSpan?>), TypeInfoPropertyName = "T5610")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_TimeSpan?>), TypeInfoPropertyName = "T5611")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_TimeSpan?>), TypeInfoPropertyName = "T5612")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_TimeSpan?>), TypeInfoPropertyName = "T5613")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_TimeSpan?, int>), TypeInfoPropertyName = "T5614")]
-[JsonSerializable(typeof(V_record_struct_enum?), TypeInfoPropertyName = "T5615")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_enum?>), TypeInfoPropertyName = "T5616")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_enum?>), TypeInfoPropertyName = "T5617")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_enum?>), TypeInfoPropertyName = "T5618")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_enum?>), TypeInfoPropertyName = "T5619")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_enum?, int>), TypeInfoPropertyName = "T5620")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_enum?>>), TypeInfoPropertyName = "T5621")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_enum?>>), TypeInfoPropertyName = "T5622")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_enum?>>), TypeInfoPropertyName = "T5623")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_enum?>>), TypeInfoPropertyName = "T5624")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_enum?>, int>), TypeInfoPropertyName = "T5625")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_enum?[]>), TypeInfoPropertyName = "T5626")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_enum?[]>), TypeInfoPropertyName = "T5627")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_enum?[]>), TypeInfoPropertyName = "T5628")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_enum?[]>), TypeInfoPropertyName = "T5629")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_enum?[], int>), TypeInfoPropertyName = "T5630")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_enum?>>), TypeInfoPropertyName = "T5631")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_enum?>>), TypeInfoPropertyName = "T5632")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_enum?>>), TypeInfoPropertyName = "T5633")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_enum?>>), TypeInfoPropertyName = "T5634")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_enum?>, int>), TypeInfoPropertyName = "T5635")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_enum?>>), TypeInfoPropertyName = "T5636")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_enum?>>), TypeInfoPropertyName = "T5637")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_enum?>>), TypeInfoPropertyName = "T5638")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_enum?>>), TypeInfoPropertyName = "T5639")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_enum?>, int>), TypeInfoPropertyName = "T5640")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_enum?>>), TypeInfoPropertyName = "T5641")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_enum?>>), TypeInfoPropertyName = "T5642")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_enum?>>), TypeInfoPropertyName = "T5643")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_enum?>>), TypeInfoPropertyName = "T5644")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_enum?>, int>), TypeInfoPropertyName = "T5645")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_enum?>), TypeInfoPropertyName = "T5646")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_enum?>), TypeInfoPropertyName = "T5647")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_enum?>), TypeInfoPropertyName = "T5648")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_enum?>), TypeInfoPropertyName = "T5649")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_enum?, int>), TypeInfoPropertyName = "T5650")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_enum?>), TypeInfoPropertyName = "T5651")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_enum?>), TypeInfoPropertyName = "T5652")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_enum?>), TypeInfoPropertyName = "T5653")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_enum?>), TypeInfoPropertyName = "T5654")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_enum?, int>), TypeInfoPropertyName = "T5655")]
-[JsonSerializable(typeof(V_record_struct_flags_enum?), TypeInfoPropertyName = "T5656")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_flags_enum?>), TypeInfoPropertyName = "T5657")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_flags_enum?>), TypeInfoPropertyName = "T5658")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_flags_enum?>), TypeInfoPropertyName = "T5659")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_flags_enum?>), TypeInfoPropertyName = "T5660")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_flags_enum?, int>), TypeInfoPropertyName = "T5661")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_flags_enum?>>), TypeInfoPropertyName = "T5662")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_flags_enum?>>), TypeInfoPropertyName = "T5663")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_flags_enum?>>), TypeInfoPropertyName = "T5664")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_flags_enum?>>), TypeInfoPropertyName = "T5665")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_flags_enum?>, int>), TypeInfoPropertyName = "T5666")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_flags_enum?[]>), TypeInfoPropertyName = "T5667")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_flags_enum?[]>), TypeInfoPropertyName = "T5668")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_flags_enum?[]>), TypeInfoPropertyName = "T5669")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_flags_enum?[]>), TypeInfoPropertyName = "T5670")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_flags_enum?[], int>), TypeInfoPropertyName = "T5671")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_flags_enum?>>), TypeInfoPropertyName = "T5672")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_flags_enum?>>), TypeInfoPropertyName = "T5673")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_flags_enum?>>), TypeInfoPropertyName = "T5674")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_flags_enum?>>), TypeInfoPropertyName = "T5675")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_flags_enum?>, int>), TypeInfoPropertyName = "T5676")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_flags_enum?>>), TypeInfoPropertyName = "T5677")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_flags_enum?>>), TypeInfoPropertyName = "T5678")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_flags_enum?>>), TypeInfoPropertyName = "T5679")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_flags_enum?>>), TypeInfoPropertyName = "T5680")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_flags_enum?>, int>), TypeInfoPropertyName = "T5681")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_flags_enum?>>), TypeInfoPropertyName = "T5682")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_flags_enum?>>), TypeInfoPropertyName = "T5683")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_flags_enum?>>), TypeInfoPropertyName = "T5684")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_flags_enum?>>), TypeInfoPropertyName = "T5685")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_flags_enum?>, int>), TypeInfoPropertyName = "T5686")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_flags_enum?>), TypeInfoPropertyName = "T5687")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_flags_enum?>), TypeInfoPropertyName = "T5688")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_flags_enum?>), TypeInfoPropertyName = "T5689")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_flags_enum?>), TypeInfoPropertyName = "T5690")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_flags_enum?, int>), TypeInfoPropertyName = "T5691")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_flags_enum?>), TypeInfoPropertyName = "T5692")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_flags_enum?>), TypeInfoPropertyName = "T5693")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_flags_enum?>), TypeInfoPropertyName = "T5694")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_flags_enum?>), TypeInfoPropertyName = "T5695")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_flags_enum?, int>), TypeInfoPropertyName = "T5696")]
-[JsonSerializable(typeof(V_record_struct_Uri?), TypeInfoPropertyName = "T5697")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_Uri?>), TypeInfoPropertyName = "T5698")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_Uri?>), TypeInfoPropertyName = "T5699")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_Uri?>), TypeInfoPropertyName = "T5700")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_Uri?>), TypeInfoPropertyName = "T5701")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_Uri?, int>), TypeInfoPropertyName = "T5702")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_Uri?>>), TypeInfoPropertyName = "T5703")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_Uri?>>), TypeInfoPropertyName = "T5704")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_Uri?>>), TypeInfoPropertyName = "T5705")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_Uri?>>), TypeInfoPropertyName = "T5706")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_Uri?>, int>), TypeInfoPropertyName = "T5707")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_Uri?[]>), TypeInfoPropertyName = "T5708")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_Uri?[]>), TypeInfoPropertyName = "T5709")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_Uri?[]>), TypeInfoPropertyName = "T5710")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_Uri?[]>), TypeInfoPropertyName = "T5711")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_Uri?[], int>), TypeInfoPropertyName = "T5712")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_Uri?>>), TypeInfoPropertyName = "T5713")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_Uri?>>), TypeInfoPropertyName = "T5714")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_Uri?>>), TypeInfoPropertyName = "T5715")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_Uri?>>), TypeInfoPropertyName = "T5716")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_Uri?>, int>), TypeInfoPropertyName = "T5717")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_Uri?>>), TypeInfoPropertyName = "T5718")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_Uri?>>), TypeInfoPropertyName = "T5719")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_Uri?>>), TypeInfoPropertyName = "T5720")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_Uri?>>), TypeInfoPropertyName = "T5721")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_Uri?>, int>), TypeInfoPropertyName = "T5722")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_Uri?>>), TypeInfoPropertyName = "T5723")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_Uri?>>), TypeInfoPropertyName = "T5724")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_Uri?>>), TypeInfoPropertyName = "T5725")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_Uri?>>), TypeInfoPropertyName = "T5726")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_Uri?>, int>), TypeInfoPropertyName = "T5727")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_Uri?>), TypeInfoPropertyName = "T5728")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_Uri?>), TypeInfoPropertyName = "T5729")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_Uri?>), TypeInfoPropertyName = "T5730")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_Uri?>), TypeInfoPropertyName = "T5731")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_Uri?, int>), TypeInfoPropertyName = "T5732")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_Uri?>), TypeInfoPropertyName = "T5733")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_Uri?>), TypeInfoPropertyName = "T5734")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_Uri?>), TypeInfoPropertyName = "T5735")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_Uri?>), TypeInfoPropertyName = "T5736")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_Uri?, int>), TypeInfoPropertyName = "T5737")]
-[JsonSerializable(typeof(V_record_struct_NodaTime_Instant?), TypeInfoPropertyName = "T5738")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T5739")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T5740")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T5741")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T5742")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_NodaTime_Instant?, int>), TypeInfoPropertyName = "T5743")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T5744")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T5745")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T5746")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T5747")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_NodaTime_Instant?>, int>), TypeInfoPropertyName = "T5748")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_NodaTime_Instant?[]>), TypeInfoPropertyName = "T5749")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_NodaTime_Instant?[]>), TypeInfoPropertyName = "T5750")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_NodaTime_Instant?[]>), TypeInfoPropertyName = "T5751")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_NodaTime_Instant?[]>), TypeInfoPropertyName = "T5752")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_NodaTime_Instant?[], int>), TypeInfoPropertyName = "T5753")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T5754")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T5755")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T5756")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T5757")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_NodaTime_Instant?>, int>), TypeInfoPropertyName = "T5758")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T5759")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T5760")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T5761")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T5762")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_NodaTime_Instant?>, int>), TypeInfoPropertyName = "T5763")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T5764")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T5765")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T5766")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T5767")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_NodaTime_Instant?>, int>), TypeInfoPropertyName = "T5768")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T5769")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T5770")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T5771")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T5772")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_NodaTime_Instant?, int>), TypeInfoPropertyName = "T5773")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T5774")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T5775")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T5776")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T5777")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_NodaTime_Instant?, int>), TypeInfoPropertyName = "T5778")]
-[JsonSerializable(typeof(V_record_struct_own_record_class?), TypeInfoPropertyName = "T5779")]
-[JsonSerializable(typeof(Cn_class_F<V_record_struct_own_record_class?>), TypeInfoPropertyName = "T5780")]
-[JsonSerializable(typeof(Cn_record_class_F<V_record_struct_own_record_class?>), TypeInfoPropertyName = "T5781")]
-[JsonSerializable(typeof(Cn_struct_F<V_record_struct_own_record_class?>), TypeInfoPropertyName = "T5782")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_record_struct_own_record_class?>), TypeInfoPropertyName = "T5783")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_record_struct_own_record_class?, int>), TypeInfoPropertyName = "T5784")]
-[JsonSerializable(typeof(Cn_class_P<List<V_record_struct_own_record_class?>>), TypeInfoPropertyName = "T5785")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_record_struct_own_record_class?>>), TypeInfoPropertyName = "T5786")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_record_struct_own_record_class?>>), TypeInfoPropertyName = "T5787")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_record_struct_own_record_class?>>), TypeInfoPropertyName = "T5788")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_record_struct_own_record_class?>, int>), TypeInfoPropertyName = "T5789")]
-[JsonSerializable(typeof(Cn_class_P<V_record_struct_own_record_class?[]>), TypeInfoPropertyName = "T5790")]
-[JsonSerializable(typeof(Cn_record_class_P<V_record_struct_own_record_class?[]>), TypeInfoPropertyName = "T5791")]
-[JsonSerializable(typeof(Cn_struct_P<V_record_struct_own_record_class?[]>), TypeInfoPropertyName = "T5792")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_record_struct_own_record_class?[]>), TypeInfoPropertyName = "T5793")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_record_struct_own_record_class?[], int>), TypeInfoPropertyName = "T5794")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_record_struct_own_record_class?>>), TypeInfoPropertyName = "T5795")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_record_struct_own_record_class?>>), TypeInfoPropertyName = "T5796")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_record_struct_own_record_class?>>), TypeInfoPropertyName = "T5797")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_record_struct_own_record_class?>>), TypeInfoPropertyName = "T5798")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_record_struct_own_record_class?>, int>), TypeInfoPropertyName = "T5799")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_record_struct_own_record_class?>>), TypeInfoPropertyName = "T5800")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_record_struct_own_record_class?>>), TypeInfoPropertyName = "T5801")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_record_struct_own_record_class?>>), TypeInfoPropertyName = "T5802")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_record_struct_own_record_class?>>), TypeInfoPropertyName = "T5803")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_record_struct_own_record_class?>, int>), TypeInfoPropertyName = "T5804")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_record_struct_own_record_class?>>), TypeInfoPropertyName = "T5805")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_record_struct_own_record_class?>>), TypeInfoPropertyName = "T5806")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_record_struct_own_record_class?>>), TypeInfoPropertyName = "T5807")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_record_struct_own_record_class?>>), TypeInfoPropertyName = "T5808")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_record_struct_own_record_class?>, int>), TypeInfoPropertyName = "T5809")]
-[JsonSerializable(typeof(Cn_class_C<V_record_struct_own_record_class?>), TypeInfoPropertyName = "T5810")]
-[JsonSerializable(typeof(Cn_record_class_C<V_record_struct_own_record_class?>), TypeInfoPropertyName = "T5811")]
-[JsonSerializable(typeof(Cn_struct_C<V_record_struct_own_record_class?>), TypeInfoPropertyName = "T5812")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_record_struct_own_record_class?>), TypeInfoPropertyName = "T5813")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_record_struct_own_record_class?, int>), TypeInfoPropertyName = "T5814")]
-[JsonSerializable(typeof(Cn_class_R<V_record_struct_own_record_class?>), TypeInfoPropertyName = "T5815")]
-[JsonSerializable(typeof(Cn_record_class_R<V_record_struct_own_record_class?>), TypeInfoPropertyName = "T5816")]
-[JsonSerializable(typeof(Cn_struct_R<V_record_struct_own_record_class?>), TypeInfoPropertyName = "T5817")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_record_struct_own_record_class?>), TypeInfoPropertyName = "T5818")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_record_struct_own_record_class?, int>), TypeInfoPropertyName = "T5819")]
-[JsonSerializable(typeof(V_validated_struct_string?), TypeInfoPropertyName = "T5820")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_string?>), TypeInfoPropertyName = "T5821")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_string?>), TypeInfoPropertyName = "T5822")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_string?>), TypeInfoPropertyName = "T5823")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_string?>), TypeInfoPropertyName = "T5824")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_string?, int>), TypeInfoPropertyName = "T5825")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_string?>>), TypeInfoPropertyName = "T5826")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_string?>>), TypeInfoPropertyName = "T5827")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_string?>>), TypeInfoPropertyName = "T5828")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_string?>>), TypeInfoPropertyName = "T5829")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_string?>, int>), TypeInfoPropertyName = "T5830")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_string?[]>), TypeInfoPropertyName = "T5831")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_string?[]>), TypeInfoPropertyName = "T5832")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_string?[]>), TypeInfoPropertyName = "T5833")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_string?[]>), TypeInfoPropertyName = "T5834")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_string?[], int>), TypeInfoPropertyName = "T5835")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_string?>>), TypeInfoPropertyName = "T5836")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_string?>>), TypeInfoPropertyName = "T5837")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_string?>>), TypeInfoPropertyName = "T5838")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_string?>>), TypeInfoPropertyName = "T5839")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_string?>, int>), TypeInfoPropertyName = "T5840")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_string?>>), TypeInfoPropertyName = "T5841")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_string?>>), TypeInfoPropertyName = "T5842")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_string?>>), TypeInfoPropertyName = "T5843")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_string?>>), TypeInfoPropertyName = "T5844")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_string?>, int>), TypeInfoPropertyName = "T5845")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_string?>>), TypeInfoPropertyName = "T5846")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_string?>>), TypeInfoPropertyName = "T5847")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_string?>>), TypeInfoPropertyName = "T5848")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_string?>>), TypeInfoPropertyName = "T5849")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_string?>, int>), TypeInfoPropertyName = "T5850")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_string?>), TypeInfoPropertyName = "T5851")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_string?>), TypeInfoPropertyName = "T5852")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_string?>), TypeInfoPropertyName = "T5853")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_string?>), TypeInfoPropertyName = "T5854")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_string?, int>), TypeInfoPropertyName = "T5855")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_string?>), TypeInfoPropertyName = "T5856")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_string?>), TypeInfoPropertyName = "T5857")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_string?>), TypeInfoPropertyName = "T5858")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_string?>), TypeInfoPropertyName = "T5859")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_string?, int>), TypeInfoPropertyName = "T5860")]
-[JsonSerializable(typeof(V_validated_struct_Guid?), TypeInfoPropertyName = "T5861")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_Guid?>), TypeInfoPropertyName = "T5862")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_Guid?>), TypeInfoPropertyName = "T5863")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_Guid?>), TypeInfoPropertyName = "T5864")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_Guid?>), TypeInfoPropertyName = "T5865")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_Guid?, int>), TypeInfoPropertyName = "T5866")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_Guid?>>), TypeInfoPropertyName = "T5867")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_Guid?>>), TypeInfoPropertyName = "T5868")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_Guid?>>), TypeInfoPropertyName = "T5869")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_Guid?>>), TypeInfoPropertyName = "T5870")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_Guid?>, int>), TypeInfoPropertyName = "T5871")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_Guid?[]>), TypeInfoPropertyName = "T5872")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_Guid?[]>), TypeInfoPropertyName = "T5873")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_Guid?[]>), TypeInfoPropertyName = "T5874")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_Guid?[]>), TypeInfoPropertyName = "T5875")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_Guid?[], int>), TypeInfoPropertyName = "T5876")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_Guid?>>), TypeInfoPropertyName = "T5877")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_Guid?>>), TypeInfoPropertyName = "T5878")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_Guid?>>), TypeInfoPropertyName = "T5879")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_Guid?>>), TypeInfoPropertyName = "T5880")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_Guid?>, int>), TypeInfoPropertyName = "T5881")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_Guid?>>), TypeInfoPropertyName = "T5882")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_Guid?>>), TypeInfoPropertyName = "T5883")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_Guid?>>), TypeInfoPropertyName = "T5884")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_Guid?>>), TypeInfoPropertyName = "T5885")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_Guid?>, int>), TypeInfoPropertyName = "T5886")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_Guid?>>), TypeInfoPropertyName = "T5887")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_Guid?>>), TypeInfoPropertyName = "T5888")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_Guid?>>), TypeInfoPropertyName = "T5889")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_Guid?>>), TypeInfoPropertyName = "T5890")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_Guid?>, int>), TypeInfoPropertyName = "T5891")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_Guid?>), TypeInfoPropertyName = "T5892")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_Guid?>), TypeInfoPropertyName = "T5893")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_Guid?>), TypeInfoPropertyName = "T5894")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_Guid?>), TypeInfoPropertyName = "T5895")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_Guid?, int>), TypeInfoPropertyName = "T5896")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_Guid?>), TypeInfoPropertyName = "T5897")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_Guid?>), TypeInfoPropertyName = "T5898")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_Guid?>), TypeInfoPropertyName = "T5899")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_Guid?>), TypeInfoPropertyName = "T5900")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_Guid?, int>), TypeInfoPropertyName = "T5901")]
-[JsonSerializable(typeof(V_validated_struct_int?), TypeInfoPropertyName = "T5902")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_int?>), TypeInfoPropertyName = "T5903")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_int?>), TypeInfoPropertyName = "T5904")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_int?>), TypeInfoPropertyName = "T5905")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_int?>), TypeInfoPropertyName = "T5906")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_int?, int>), TypeInfoPropertyName = "T5907")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_int?>>), TypeInfoPropertyName = "T5908")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_int?>>), TypeInfoPropertyName = "T5909")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_int?>>), TypeInfoPropertyName = "T5910")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_int?>>), TypeInfoPropertyName = "T5911")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_int?>, int>), TypeInfoPropertyName = "T5912")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_int?[]>), TypeInfoPropertyName = "T5913")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_int?[]>), TypeInfoPropertyName = "T5914")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_int?[]>), TypeInfoPropertyName = "T5915")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_int?[]>), TypeInfoPropertyName = "T5916")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_int?[], int>), TypeInfoPropertyName = "T5917")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_int?>>), TypeInfoPropertyName = "T5918")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_int?>>), TypeInfoPropertyName = "T5919")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_int?>>), TypeInfoPropertyName = "T5920")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_int?>>), TypeInfoPropertyName = "T5921")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_int?>, int>), TypeInfoPropertyName = "T5922")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_int?>>), TypeInfoPropertyName = "T5923")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_int?>>), TypeInfoPropertyName = "T5924")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_int?>>), TypeInfoPropertyName = "T5925")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_int?>>), TypeInfoPropertyName = "T5926")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_int?>, int>), TypeInfoPropertyName = "T5927")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_int?>>), TypeInfoPropertyName = "T5928")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_int?>>), TypeInfoPropertyName = "T5929")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_int?>>), TypeInfoPropertyName = "T5930")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_int?>>), TypeInfoPropertyName = "T5931")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_int?>, int>), TypeInfoPropertyName = "T5932")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_int?>), TypeInfoPropertyName = "T5933")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_int?>), TypeInfoPropertyName = "T5934")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_int?>), TypeInfoPropertyName = "T5935")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_int?>), TypeInfoPropertyName = "T5936")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_int?, int>), TypeInfoPropertyName = "T5937")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_int?>), TypeInfoPropertyName = "T5938")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_int?>), TypeInfoPropertyName = "T5939")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_int?>), TypeInfoPropertyName = "T5940")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_int?>), TypeInfoPropertyName = "T5941")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_int?, int>), TypeInfoPropertyName = "T5942")]
-[JsonSerializable(typeof(V_validated_struct_long?), TypeInfoPropertyName = "T5943")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_long?>), TypeInfoPropertyName = "T5944")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_long?>), TypeInfoPropertyName = "T5945")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_long?>), TypeInfoPropertyName = "T5946")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_long?>), TypeInfoPropertyName = "T5947")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_long?, int>), TypeInfoPropertyName = "T5948")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_long?>>), TypeInfoPropertyName = "T5949")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_long?>>), TypeInfoPropertyName = "T5950")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_long?>>), TypeInfoPropertyName = "T5951")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_long?>>), TypeInfoPropertyName = "T5952")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_long?>, int>), TypeInfoPropertyName = "T5953")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_long?[]>), TypeInfoPropertyName = "T5954")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_long?[]>), TypeInfoPropertyName = "T5955")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_long?[]>), TypeInfoPropertyName = "T5956")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_long?[]>), TypeInfoPropertyName = "T5957")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_long?[], int>), TypeInfoPropertyName = "T5958")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_long?>>), TypeInfoPropertyName = "T5959")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_long?>>), TypeInfoPropertyName = "T5960")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_long?>>), TypeInfoPropertyName = "T5961")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_long?>>), TypeInfoPropertyName = "T5962")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_long?>, int>), TypeInfoPropertyName = "T5963")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_long?>>), TypeInfoPropertyName = "T5964")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_long?>>), TypeInfoPropertyName = "T5965")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_long?>>), TypeInfoPropertyName = "T5966")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_long?>>), TypeInfoPropertyName = "T5967")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_long?>, int>), TypeInfoPropertyName = "T5968")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_long?>>), TypeInfoPropertyName = "T5969")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_long?>>), TypeInfoPropertyName = "T5970")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_long?>>), TypeInfoPropertyName = "T5971")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_long?>>), TypeInfoPropertyName = "T5972")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_long?>, int>), TypeInfoPropertyName = "T5973")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_long?>), TypeInfoPropertyName = "T5974")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_long?>), TypeInfoPropertyName = "T5975")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_long?>), TypeInfoPropertyName = "T5976")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_long?>), TypeInfoPropertyName = "T5977")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_long?, int>), TypeInfoPropertyName = "T5978")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_long?>), TypeInfoPropertyName = "T5979")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_long?>), TypeInfoPropertyName = "T5980")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_long?>), TypeInfoPropertyName = "T5981")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_long?>), TypeInfoPropertyName = "T5982")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_long?, int>), TypeInfoPropertyName = "T5983")]
-[JsonSerializable(typeof(V_validated_struct_byte?), TypeInfoPropertyName = "T5984")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_byte?>), TypeInfoPropertyName = "T5985")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_byte?>), TypeInfoPropertyName = "T5986")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_byte?>), TypeInfoPropertyName = "T5987")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_byte?>), TypeInfoPropertyName = "T5988")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_byte?, int>), TypeInfoPropertyName = "T5989")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_byte?>>), TypeInfoPropertyName = "T5990")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_byte?>>), TypeInfoPropertyName = "T5991")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_byte?>>), TypeInfoPropertyName = "T5992")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_byte?>>), TypeInfoPropertyName = "T5993")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_byte?>, int>), TypeInfoPropertyName = "T5994")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_byte?[]>), TypeInfoPropertyName = "T5995")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_byte?[]>), TypeInfoPropertyName = "T5996")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_byte?[]>), TypeInfoPropertyName = "T5997")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_byte?[]>), TypeInfoPropertyName = "T5998")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_byte?[], int>), TypeInfoPropertyName = "T5999")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_byte?>>), TypeInfoPropertyName = "T6000")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_byte?>>), TypeInfoPropertyName = "T6001")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_byte?>>), TypeInfoPropertyName = "T6002")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_byte?>>), TypeInfoPropertyName = "T6003")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_byte?>, int>), TypeInfoPropertyName = "T6004")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_byte?>>), TypeInfoPropertyName = "T6005")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_byte?>>), TypeInfoPropertyName = "T6006")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_byte?>>), TypeInfoPropertyName = "T6007")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_byte?>>), TypeInfoPropertyName = "T6008")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_byte?>, int>), TypeInfoPropertyName = "T6009")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_byte?>>), TypeInfoPropertyName = "T6010")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_byte?>>), TypeInfoPropertyName = "T6011")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_byte?>>), TypeInfoPropertyName = "T6012")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_byte?>>), TypeInfoPropertyName = "T6013")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_byte?>, int>), TypeInfoPropertyName = "T6014")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_byte?>), TypeInfoPropertyName = "T6015")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_byte?>), TypeInfoPropertyName = "T6016")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_byte?>), TypeInfoPropertyName = "T6017")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_byte?>), TypeInfoPropertyName = "T6018")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_byte?, int>), TypeInfoPropertyName = "T6019")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_byte?>), TypeInfoPropertyName = "T6020")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_byte?>), TypeInfoPropertyName = "T6021")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_byte?>), TypeInfoPropertyName = "T6022")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_byte?>), TypeInfoPropertyName = "T6023")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_byte?, int>), TypeInfoPropertyName = "T6024")]
-[JsonSerializable(typeof(V_validated_struct_ulong?), TypeInfoPropertyName = "T6025")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_ulong?>), TypeInfoPropertyName = "T6026")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_ulong?>), TypeInfoPropertyName = "T6027")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_ulong?>), TypeInfoPropertyName = "T6028")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_ulong?>), TypeInfoPropertyName = "T6029")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_ulong?, int>), TypeInfoPropertyName = "T6030")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_ulong?>>), TypeInfoPropertyName = "T6031")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_ulong?>>), TypeInfoPropertyName = "T6032")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_ulong?>>), TypeInfoPropertyName = "T6033")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_ulong?>>), TypeInfoPropertyName = "T6034")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_ulong?>, int>), TypeInfoPropertyName = "T6035")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_ulong?[]>), TypeInfoPropertyName = "T6036")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_ulong?[]>), TypeInfoPropertyName = "T6037")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_ulong?[]>), TypeInfoPropertyName = "T6038")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_ulong?[]>), TypeInfoPropertyName = "T6039")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_ulong?[], int>), TypeInfoPropertyName = "T6040")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_ulong?>>), TypeInfoPropertyName = "T6041")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_ulong?>>), TypeInfoPropertyName = "T6042")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_ulong?>>), TypeInfoPropertyName = "T6043")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_ulong?>>), TypeInfoPropertyName = "T6044")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_ulong?>, int>), TypeInfoPropertyName = "T6045")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_ulong?>>), TypeInfoPropertyName = "T6046")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_ulong?>>), TypeInfoPropertyName = "T6047")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_ulong?>>), TypeInfoPropertyName = "T6048")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_ulong?>>), TypeInfoPropertyName = "T6049")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_ulong?>, int>), TypeInfoPropertyName = "T6050")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_ulong?>>), TypeInfoPropertyName = "T6051")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_ulong?>>), TypeInfoPropertyName = "T6052")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_ulong?>>), TypeInfoPropertyName = "T6053")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_ulong?>>), TypeInfoPropertyName = "T6054")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_ulong?>, int>), TypeInfoPropertyName = "T6055")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_ulong?>), TypeInfoPropertyName = "T6056")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_ulong?>), TypeInfoPropertyName = "T6057")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_ulong?>), TypeInfoPropertyName = "T6058")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_ulong?>), TypeInfoPropertyName = "T6059")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_ulong?, int>), TypeInfoPropertyName = "T6060")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_ulong?>), TypeInfoPropertyName = "T6061")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_ulong?>), TypeInfoPropertyName = "T6062")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_ulong?>), TypeInfoPropertyName = "T6063")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_ulong?>), TypeInfoPropertyName = "T6064")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_ulong?, int>), TypeInfoPropertyName = "T6065")]
-[JsonSerializable(typeof(V_validated_struct_decimal?), TypeInfoPropertyName = "T6066")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_decimal?>), TypeInfoPropertyName = "T6067")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_decimal?>), TypeInfoPropertyName = "T6068")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_decimal?>), TypeInfoPropertyName = "T6069")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_decimal?>), TypeInfoPropertyName = "T6070")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_decimal?, int>), TypeInfoPropertyName = "T6071")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_decimal?>>), TypeInfoPropertyName = "T6072")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_decimal?>>), TypeInfoPropertyName = "T6073")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_decimal?>>), TypeInfoPropertyName = "T6074")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_decimal?>>), TypeInfoPropertyName = "T6075")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_decimal?>, int>), TypeInfoPropertyName = "T6076")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_decimal?[]>), TypeInfoPropertyName = "T6077")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_decimal?[]>), TypeInfoPropertyName = "T6078")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_decimal?[]>), TypeInfoPropertyName = "T6079")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_decimal?[]>), TypeInfoPropertyName = "T6080")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_decimal?[], int>), TypeInfoPropertyName = "T6081")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_decimal?>>), TypeInfoPropertyName = "T6082")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_decimal?>>), TypeInfoPropertyName = "T6083")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_decimal?>>), TypeInfoPropertyName = "T6084")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_decimal?>>), TypeInfoPropertyName = "T6085")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_decimal?>, int>), TypeInfoPropertyName = "T6086")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_decimal?>>), TypeInfoPropertyName = "T6087")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_decimal?>>), TypeInfoPropertyName = "T6088")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_decimal?>>), TypeInfoPropertyName = "T6089")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_decimal?>>), TypeInfoPropertyName = "T6090")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_decimal?>, int>), TypeInfoPropertyName = "T6091")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_decimal?>>), TypeInfoPropertyName = "T6092")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_decimal?>>), TypeInfoPropertyName = "T6093")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_decimal?>>), TypeInfoPropertyName = "T6094")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_decimal?>>), TypeInfoPropertyName = "T6095")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_decimal?>, int>), TypeInfoPropertyName = "T6096")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_decimal?>), TypeInfoPropertyName = "T6097")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_decimal?>), TypeInfoPropertyName = "T6098")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_decimal?>), TypeInfoPropertyName = "T6099")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_decimal?>), TypeInfoPropertyName = "T6100")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_decimal?, int>), TypeInfoPropertyName = "T6101")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_decimal?>), TypeInfoPropertyName = "T6102")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_decimal?>), TypeInfoPropertyName = "T6103")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_decimal?>), TypeInfoPropertyName = "T6104")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_decimal?>), TypeInfoPropertyName = "T6105")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_decimal?, int>), TypeInfoPropertyName = "T6106")]
-[JsonSerializable(typeof(V_validated_struct_double?), TypeInfoPropertyName = "T6107")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_double?>), TypeInfoPropertyName = "T6108")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_double?>), TypeInfoPropertyName = "T6109")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_double?>), TypeInfoPropertyName = "T6110")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_double?>), TypeInfoPropertyName = "T6111")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_double?, int>), TypeInfoPropertyName = "T6112")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_double?>>), TypeInfoPropertyName = "T6113")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_double?>>), TypeInfoPropertyName = "T6114")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_double?>>), TypeInfoPropertyName = "T6115")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_double?>>), TypeInfoPropertyName = "T6116")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_double?>, int>), TypeInfoPropertyName = "T6117")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_double?[]>), TypeInfoPropertyName = "T6118")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_double?[]>), TypeInfoPropertyName = "T6119")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_double?[]>), TypeInfoPropertyName = "T6120")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_double?[]>), TypeInfoPropertyName = "T6121")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_double?[], int>), TypeInfoPropertyName = "T6122")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_double?>>), TypeInfoPropertyName = "T6123")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_double?>>), TypeInfoPropertyName = "T6124")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_double?>>), TypeInfoPropertyName = "T6125")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_double?>>), TypeInfoPropertyName = "T6126")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_double?>, int>), TypeInfoPropertyName = "T6127")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_double?>>), TypeInfoPropertyName = "T6128")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_double?>>), TypeInfoPropertyName = "T6129")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_double?>>), TypeInfoPropertyName = "T6130")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_double?>>), TypeInfoPropertyName = "T6131")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_double?>, int>), TypeInfoPropertyName = "T6132")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_double?>>), TypeInfoPropertyName = "T6133")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_double?>>), TypeInfoPropertyName = "T6134")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_double?>>), TypeInfoPropertyName = "T6135")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_double?>>), TypeInfoPropertyName = "T6136")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_double?>, int>), TypeInfoPropertyName = "T6137")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_double?>), TypeInfoPropertyName = "T6138")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_double?>), TypeInfoPropertyName = "T6139")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_double?>), TypeInfoPropertyName = "T6140")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_double?>), TypeInfoPropertyName = "T6141")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_double?, int>), TypeInfoPropertyName = "T6142")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_double?>), TypeInfoPropertyName = "T6143")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_double?>), TypeInfoPropertyName = "T6144")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_double?>), TypeInfoPropertyName = "T6145")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_double?>), TypeInfoPropertyName = "T6146")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_double?, int>), TypeInfoPropertyName = "T6147")]
-[JsonSerializable(typeof(V_validated_struct_bool?), TypeInfoPropertyName = "T6148")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_bool?>), TypeInfoPropertyName = "T6149")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_bool?>), TypeInfoPropertyName = "T6150")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_bool?>), TypeInfoPropertyName = "T6151")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_bool?>), TypeInfoPropertyName = "T6152")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_bool?, int>), TypeInfoPropertyName = "T6153")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_bool?>>), TypeInfoPropertyName = "T6154")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_bool?>>), TypeInfoPropertyName = "T6155")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_bool?>>), TypeInfoPropertyName = "T6156")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_bool?>>), TypeInfoPropertyName = "T6157")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_bool?>, int>), TypeInfoPropertyName = "T6158")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_bool?[]>), TypeInfoPropertyName = "T6159")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_bool?[]>), TypeInfoPropertyName = "T6160")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_bool?[]>), TypeInfoPropertyName = "T6161")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_bool?[]>), TypeInfoPropertyName = "T6162")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_bool?[], int>), TypeInfoPropertyName = "T6163")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_bool?>>), TypeInfoPropertyName = "T6164")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_bool?>>), TypeInfoPropertyName = "T6165")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_bool?>>), TypeInfoPropertyName = "T6166")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_bool?>>), TypeInfoPropertyName = "T6167")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_bool?>, int>), TypeInfoPropertyName = "T6168")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_bool?>>), TypeInfoPropertyName = "T6169")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_bool?>>), TypeInfoPropertyName = "T6170")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_bool?>>), TypeInfoPropertyName = "T6171")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_bool?>>), TypeInfoPropertyName = "T6172")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_bool?>, int>), TypeInfoPropertyName = "T6173")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_bool?>>), TypeInfoPropertyName = "T6174")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_bool?>>), TypeInfoPropertyName = "T6175")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_bool?>>), TypeInfoPropertyName = "T6176")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_bool?>>), TypeInfoPropertyName = "T6177")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_bool?>, int>), TypeInfoPropertyName = "T6178")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_bool?>), TypeInfoPropertyName = "T6179")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_bool?>), TypeInfoPropertyName = "T6180")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_bool?>), TypeInfoPropertyName = "T6181")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_bool?>), TypeInfoPropertyName = "T6182")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_bool?, int>), TypeInfoPropertyName = "T6183")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_bool?>), TypeInfoPropertyName = "T6184")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_bool?>), TypeInfoPropertyName = "T6185")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_bool?>), TypeInfoPropertyName = "T6186")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_bool?>), TypeInfoPropertyName = "T6187")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_bool?, int>), TypeInfoPropertyName = "T6188")]
-[JsonSerializable(typeof(V_validated_struct_char?), TypeInfoPropertyName = "T6189")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_char?>), TypeInfoPropertyName = "T6190")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_char?>), TypeInfoPropertyName = "T6191")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_char?>), TypeInfoPropertyName = "T6192")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_char?>), TypeInfoPropertyName = "T6193")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_char?, int>), TypeInfoPropertyName = "T6194")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_char?>>), TypeInfoPropertyName = "T6195")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_char?>>), TypeInfoPropertyName = "T6196")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_char?>>), TypeInfoPropertyName = "T6197")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_char?>>), TypeInfoPropertyName = "T6198")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_char?>, int>), TypeInfoPropertyName = "T6199")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_char?[]>), TypeInfoPropertyName = "T6200")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_char?[]>), TypeInfoPropertyName = "T6201")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_char?[]>), TypeInfoPropertyName = "T6202")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_char?[]>), TypeInfoPropertyName = "T6203")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_char?[], int>), TypeInfoPropertyName = "T6204")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_char?>>), TypeInfoPropertyName = "T6205")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_char?>>), TypeInfoPropertyName = "T6206")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_char?>>), TypeInfoPropertyName = "T6207")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_char?>>), TypeInfoPropertyName = "T6208")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_char?>, int>), TypeInfoPropertyName = "T6209")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_char?>>), TypeInfoPropertyName = "T6210")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_char?>>), TypeInfoPropertyName = "T6211")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_char?>>), TypeInfoPropertyName = "T6212")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_char?>>), TypeInfoPropertyName = "T6213")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_char?>, int>), TypeInfoPropertyName = "T6214")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_char?>>), TypeInfoPropertyName = "T6215")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_char?>>), TypeInfoPropertyName = "T6216")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_char?>>), TypeInfoPropertyName = "T6217")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_char?>>), TypeInfoPropertyName = "T6218")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_char?>, int>), TypeInfoPropertyName = "T6219")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_char?>), TypeInfoPropertyName = "T6220")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_char?>), TypeInfoPropertyName = "T6221")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_char?>), TypeInfoPropertyName = "T6222")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_char?>), TypeInfoPropertyName = "T6223")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_char?, int>), TypeInfoPropertyName = "T6224")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_char?>), TypeInfoPropertyName = "T6225")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_char?>), TypeInfoPropertyName = "T6226")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_char?>), TypeInfoPropertyName = "T6227")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_char?>), TypeInfoPropertyName = "T6228")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_char?, int>), TypeInfoPropertyName = "T6229")]
-[JsonSerializable(typeof(V_validated_struct_DateTime?), TypeInfoPropertyName = "T6230")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_DateTime?>), TypeInfoPropertyName = "T6231")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_DateTime?>), TypeInfoPropertyName = "T6232")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_DateTime?>), TypeInfoPropertyName = "T6233")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_DateTime?>), TypeInfoPropertyName = "T6234")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_DateTime?, int>), TypeInfoPropertyName = "T6235")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_DateTime?>>), TypeInfoPropertyName = "T6236")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_DateTime?>>), TypeInfoPropertyName = "T6237")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_DateTime?>>), TypeInfoPropertyName = "T6238")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_DateTime?>>), TypeInfoPropertyName = "T6239")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_DateTime?>, int>), TypeInfoPropertyName = "T6240")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_DateTime?[]>), TypeInfoPropertyName = "T6241")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_DateTime?[]>), TypeInfoPropertyName = "T6242")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_DateTime?[]>), TypeInfoPropertyName = "T6243")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_DateTime?[]>), TypeInfoPropertyName = "T6244")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_DateTime?[], int>), TypeInfoPropertyName = "T6245")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_DateTime?>>), TypeInfoPropertyName = "T6246")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_DateTime?>>), TypeInfoPropertyName = "T6247")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_DateTime?>>), TypeInfoPropertyName = "T6248")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_DateTime?>>), TypeInfoPropertyName = "T6249")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_DateTime?>, int>), TypeInfoPropertyName = "T6250")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_DateTime?>>), TypeInfoPropertyName = "T6251")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_DateTime?>>), TypeInfoPropertyName = "T6252")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_DateTime?>>), TypeInfoPropertyName = "T6253")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_DateTime?>>), TypeInfoPropertyName = "T6254")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_DateTime?>, int>), TypeInfoPropertyName = "T6255")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_DateTime?>>), TypeInfoPropertyName = "T6256")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_DateTime?>>), TypeInfoPropertyName = "T6257")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_DateTime?>>), TypeInfoPropertyName = "T6258")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_DateTime?>>), TypeInfoPropertyName = "T6259")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_DateTime?>, int>), TypeInfoPropertyName = "T6260")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_DateTime?>), TypeInfoPropertyName = "T6261")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_DateTime?>), TypeInfoPropertyName = "T6262")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_DateTime?>), TypeInfoPropertyName = "T6263")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_DateTime?>), TypeInfoPropertyName = "T6264")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_DateTime?, int>), TypeInfoPropertyName = "T6265")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_DateTime?>), TypeInfoPropertyName = "T6266")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_DateTime?>), TypeInfoPropertyName = "T6267")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_DateTime?>), TypeInfoPropertyName = "T6268")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_DateTime?>), TypeInfoPropertyName = "T6269")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_DateTime?, int>), TypeInfoPropertyName = "T6270")]
-[JsonSerializable(typeof(V_validated_struct_DateTimeOffset?), TypeInfoPropertyName = "T6271")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_DateTimeOffset?>), TypeInfoPropertyName = "T6272")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_DateTimeOffset?>), TypeInfoPropertyName = "T6273")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_DateTimeOffset?>), TypeInfoPropertyName = "T6274")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_DateTimeOffset?>), TypeInfoPropertyName = "T6275")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_DateTimeOffset?, int>), TypeInfoPropertyName = "T6276")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T6277")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T6278")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T6279")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T6280")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_DateTimeOffset?>, int>), TypeInfoPropertyName = "T6281")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_DateTimeOffset?[]>), TypeInfoPropertyName = "T6282")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_DateTimeOffset?[]>), TypeInfoPropertyName = "T6283")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_DateTimeOffset?[]>), TypeInfoPropertyName = "T6284")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_DateTimeOffset?[]>), TypeInfoPropertyName = "T6285")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_DateTimeOffset?[], int>), TypeInfoPropertyName = "T6286")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T6287")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T6288")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T6289")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T6290")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_DateTimeOffset?>, int>), TypeInfoPropertyName = "T6291")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T6292")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T6293")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T6294")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T6295")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_DateTimeOffset?>, int>), TypeInfoPropertyName = "T6296")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T6297")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T6298")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T6299")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_DateTimeOffset?>>), TypeInfoPropertyName = "T6300")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_DateTimeOffset?>, int>), TypeInfoPropertyName = "T6301")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_DateTimeOffset?>), TypeInfoPropertyName = "T6302")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_DateTimeOffset?>), TypeInfoPropertyName = "T6303")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_DateTimeOffset?>), TypeInfoPropertyName = "T6304")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_DateTimeOffset?>), TypeInfoPropertyName = "T6305")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_DateTimeOffset?, int>), TypeInfoPropertyName = "T6306")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_DateTimeOffset?>), TypeInfoPropertyName = "T6307")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_DateTimeOffset?>), TypeInfoPropertyName = "T6308")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_DateTimeOffset?>), TypeInfoPropertyName = "T6309")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_DateTimeOffset?>), TypeInfoPropertyName = "T6310")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_DateTimeOffset?, int>), TypeInfoPropertyName = "T6311")]
-[JsonSerializable(typeof(V_validated_struct_DateOnly?), TypeInfoPropertyName = "T6312")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_DateOnly?>), TypeInfoPropertyName = "T6313")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_DateOnly?>), TypeInfoPropertyName = "T6314")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_DateOnly?>), TypeInfoPropertyName = "T6315")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_DateOnly?>), TypeInfoPropertyName = "T6316")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_DateOnly?, int>), TypeInfoPropertyName = "T6317")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_DateOnly?>>), TypeInfoPropertyName = "T6318")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_DateOnly?>>), TypeInfoPropertyName = "T6319")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_DateOnly?>>), TypeInfoPropertyName = "T6320")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_DateOnly?>>), TypeInfoPropertyName = "T6321")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_DateOnly?>, int>), TypeInfoPropertyName = "T6322")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_DateOnly?[]>), TypeInfoPropertyName = "T6323")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_DateOnly?[]>), TypeInfoPropertyName = "T6324")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_DateOnly?[]>), TypeInfoPropertyName = "T6325")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_DateOnly?[]>), TypeInfoPropertyName = "T6326")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_DateOnly?[], int>), TypeInfoPropertyName = "T6327")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_DateOnly?>>), TypeInfoPropertyName = "T6328")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_DateOnly?>>), TypeInfoPropertyName = "T6329")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_DateOnly?>>), TypeInfoPropertyName = "T6330")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_DateOnly?>>), TypeInfoPropertyName = "T6331")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_DateOnly?>, int>), TypeInfoPropertyName = "T6332")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_DateOnly?>>), TypeInfoPropertyName = "T6333")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_DateOnly?>>), TypeInfoPropertyName = "T6334")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_DateOnly?>>), TypeInfoPropertyName = "T6335")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_DateOnly?>>), TypeInfoPropertyName = "T6336")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_DateOnly?>, int>), TypeInfoPropertyName = "T6337")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_DateOnly?>>), TypeInfoPropertyName = "T6338")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_DateOnly?>>), TypeInfoPropertyName = "T6339")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_DateOnly?>>), TypeInfoPropertyName = "T6340")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_DateOnly?>>), TypeInfoPropertyName = "T6341")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_DateOnly?>, int>), TypeInfoPropertyName = "T6342")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_DateOnly?>), TypeInfoPropertyName = "T6343")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_DateOnly?>), TypeInfoPropertyName = "T6344")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_DateOnly?>), TypeInfoPropertyName = "T6345")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_DateOnly?>), TypeInfoPropertyName = "T6346")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_DateOnly?, int>), TypeInfoPropertyName = "T6347")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_DateOnly?>), TypeInfoPropertyName = "T6348")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_DateOnly?>), TypeInfoPropertyName = "T6349")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_DateOnly?>), TypeInfoPropertyName = "T6350")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_DateOnly?>), TypeInfoPropertyName = "T6351")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_DateOnly?, int>), TypeInfoPropertyName = "T6352")]
-[JsonSerializable(typeof(V_validated_struct_TimeOnly?), TypeInfoPropertyName = "T6353")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_TimeOnly?>), TypeInfoPropertyName = "T6354")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_TimeOnly?>), TypeInfoPropertyName = "T6355")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_TimeOnly?>), TypeInfoPropertyName = "T6356")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_TimeOnly?>), TypeInfoPropertyName = "T6357")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_TimeOnly?, int>), TypeInfoPropertyName = "T6358")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_TimeOnly?>>), TypeInfoPropertyName = "T6359")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_TimeOnly?>>), TypeInfoPropertyName = "T6360")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_TimeOnly?>>), TypeInfoPropertyName = "T6361")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_TimeOnly?>>), TypeInfoPropertyName = "T6362")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_TimeOnly?>, int>), TypeInfoPropertyName = "T6363")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_TimeOnly?[]>), TypeInfoPropertyName = "T6364")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_TimeOnly?[]>), TypeInfoPropertyName = "T6365")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_TimeOnly?[]>), TypeInfoPropertyName = "T6366")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_TimeOnly?[]>), TypeInfoPropertyName = "T6367")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_TimeOnly?[], int>), TypeInfoPropertyName = "T6368")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_TimeOnly?>>), TypeInfoPropertyName = "T6369")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_TimeOnly?>>), TypeInfoPropertyName = "T6370")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_TimeOnly?>>), TypeInfoPropertyName = "T6371")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_TimeOnly?>>), TypeInfoPropertyName = "T6372")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_TimeOnly?>, int>), TypeInfoPropertyName = "T6373")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_TimeOnly?>>), TypeInfoPropertyName = "T6374")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_TimeOnly?>>), TypeInfoPropertyName = "T6375")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_TimeOnly?>>), TypeInfoPropertyName = "T6376")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_TimeOnly?>>), TypeInfoPropertyName = "T6377")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_TimeOnly?>, int>), TypeInfoPropertyName = "T6378")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_TimeOnly?>>), TypeInfoPropertyName = "T6379")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_TimeOnly?>>), TypeInfoPropertyName = "T6380")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_TimeOnly?>>), TypeInfoPropertyName = "T6381")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_TimeOnly?>>), TypeInfoPropertyName = "T6382")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_TimeOnly?>, int>), TypeInfoPropertyName = "T6383")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_TimeOnly?>), TypeInfoPropertyName = "T6384")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_TimeOnly?>), TypeInfoPropertyName = "T6385")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_TimeOnly?>), TypeInfoPropertyName = "T6386")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_TimeOnly?>), TypeInfoPropertyName = "T6387")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_TimeOnly?, int>), TypeInfoPropertyName = "T6388")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_TimeOnly?>), TypeInfoPropertyName = "T6389")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_TimeOnly?>), TypeInfoPropertyName = "T6390")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_TimeOnly?>), TypeInfoPropertyName = "T6391")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_TimeOnly?>), TypeInfoPropertyName = "T6392")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_TimeOnly?, int>), TypeInfoPropertyName = "T6393")]
-[JsonSerializable(typeof(V_validated_struct_TimeSpan?), TypeInfoPropertyName = "T6394")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_TimeSpan?>), TypeInfoPropertyName = "T6395")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_TimeSpan?>), TypeInfoPropertyName = "T6396")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_TimeSpan?>), TypeInfoPropertyName = "T6397")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_TimeSpan?>), TypeInfoPropertyName = "T6398")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_TimeSpan?, int>), TypeInfoPropertyName = "T6399")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_TimeSpan?>>), TypeInfoPropertyName = "T6400")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_TimeSpan?>>), TypeInfoPropertyName = "T6401")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_TimeSpan?>>), TypeInfoPropertyName = "T6402")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_TimeSpan?>>), TypeInfoPropertyName = "T6403")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_TimeSpan?>, int>), TypeInfoPropertyName = "T6404")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_TimeSpan?[]>), TypeInfoPropertyName = "T6405")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_TimeSpan?[]>), TypeInfoPropertyName = "T6406")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_TimeSpan?[]>), TypeInfoPropertyName = "T6407")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_TimeSpan?[]>), TypeInfoPropertyName = "T6408")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_TimeSpan?[], int>), TypeInfoPropertyName = "T6409")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_TimeSpan?>>), TypeInfoPropertyName = "T6410")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_TimeSpan?>>), TypeInfoPropertyName = "T6411")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_TimeSpan?>>), TypeInfoPropertyName = "T6412")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_TimeSpan?>>), TypeInfoPropertyName = "T6413")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_TimeSpan?>, int>), TypeInfoPropertyName = "T6414")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_TimeSpan?>>), TypeInfoPropertyName = "T6415")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_TimeSpan?>>), TypeInfoPropertyName = "T6416")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_TimeSpan?>>), TypeInfoPropertyName = "T6417")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_TimeSpan?>>), TypeInfoPropertyName = "T6418")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_TimeSpan?>, int>), TypeInfoPropertyName = "T6419")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_TimeSpan?>>), TypeInfoPropertyName = "T6420")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_TimeSpan?>>), TypeInfoPropertyName = "T6421")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_TimeSpan?>>), TypeInfoPropertyName = "T6422")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_TimeSpan?>>), TypeInfoPropertyName = "T6423")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_TimeSpan?>, int>), TypeInfoPropertyName = "T6424")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_TimeSpan?>), TypeInfoPropertyName = "T6425")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_TimeSpan?>), TypeInfoPropertyName = "T6426")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_TimeSpan?>), TypeInfoPropertyName = "T6427")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_TimeSpan?>), TypeInfoPropertyName = "T6428")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_TimeSpan?, int>), TypeInfoPropertyName = "T6429")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_TimeSpan?>), TypeInfoPropertyName = "T6430")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_TimeSpan?>), TypeInfoPropertyName = "T6431")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_TimeSpan?>), TypeInfoPropertyName = "T6432")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_TimeSpan?>), TypeInfoPropertyName = "T6433")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_TimeSpan?, int>), TypeInfoPropertyName = "T6434")]
-[JsonSerializable(typeof(V_validated_struct_enum?), TypeInfoPropertyName = "T6435")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_enum?>), TypeInfoPropertyName = "T6436")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_enum?>), TypeInfoPropertyName = "T6437")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_enum?>), TypeInfoPropertyName = "T6438")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_enum?>), TypeInfoPropertyName = "T6439")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_enum?, int>), TypeInfoPropertyName = "T6440")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_enum?>>), TypeInfoPropertyName = "T6441")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_enum?>>), TypeInfoPropertyName = "T6442")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_enum?>>), TypeInfoPropertyName = "T6443")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_enum?>>), TypeInfoPropertyName = "T6444")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_enum?>, int>), TypeInfoPropertyName = "T6445")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_enum?[]>), TypeInfoPropertyName = "T6446")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_enum?[]>), TypeInfoPropertyName = "T6447")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_enum?[]>), TypeInfoPropertyName = "T6448")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_enum?[]>), TypeInfoPropertyName = "T6449")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_enum?[], int>), TypeInfoPropertyName = "T6450")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_enum?>>), TypeInfoPropertyName = "T6451")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_enum?>>), TypeInfoPropertyName = "T6452")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_enum?>>), TypeInfoPropertyName = "T6453")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_enum?>>), TypeInfoPropertyName = "T6454")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_enum?>, int>), TypeInfoPropertyName = "T6455")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_enum?>>), TypeInfoPropertyName = "T6456")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_enum?>>), TypeInfoPropertyName = "T6457")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_enum?>>), TypeInfoPropertyName = "T6458")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_enum?>>), TypeInfoPropertyName = "T6459")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_enum?>, int>), TypeInfoPropertyName = "T6460")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_enum?>>), TypeInfoPropertyName = "T6461")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_enum?>>), TypeInfoPropertyName = "T6462")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_enum?>>), TypeInfoPropertyName = "T6463")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_enum?>>), TypeInfoPropertyName = "T6464")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_enum?>, int>), TypeInfoPropertyName = "T6465")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_enum?>), TypeInfoPropertyName = "T6466")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_enum?>), TypeInfoPropertyName = "T6467")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_enum?>), TypeInfoPropertyName = "T6468")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_enum?>), TypeInfoPropertyName = "T6469")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_enum?, int>), TypeInfoPropertyName = "T6470")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_enum?>), TypeInfoPropertyName = "T6471")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_enum?>), TypeInfoPropertyName = "T6472")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_enum?>), TypeInfoPropertyName = "T6473")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_enum?>), TypeInfoPropertyName = "T6474")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_enum?, int>), TypeInfoPropertyName = "T6475")]
-[JsonSerializable(typeof(V_validated_struct_flags_enum?), TypeInfoPropertyName = "T6476")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_flags_enum?>), TypeInfoPropertyName = "T6477")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_flags_enum?>), TypeInfoPropertyName = "T6478")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_flags_enum?>), TypeInfoPropertyName = "T6479")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_flags_enum?>), TypeInfoPropertyName = "T6480")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_flags_enum?, int>), TypeInfoPropertyName = "T6481")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_flags_enum?>>), TypeInfoPropertyName = "T6482")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_flags_enum?>>), TypeInfoPropertyName = "T6483")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_flags_enum?>>), TypeInfoPropertyName = "T6484")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_flags_enum?>>), TypeInfoPropertyName = "T6485")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_flags_enum?>, int>), TypeInfoPropertyName = "T6486")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_flags_enum?[]>), TypeInfoPropertyName = "T6487")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_flags_enum?[]>), TypeInfoPropertyName = "T6488")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_flags_enum?[]>), TypeInfoPropertyName = "T6489")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_flags_enum?[]>), TypeInfoPropertyName = "T6490")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_flags_enum?[], int>), TypeInfoPropertyName = "T6491")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_flags_enum?>>), TypeInfoPropertyName = "T6492")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_flags_enum?>>), TypeInfoPropertyName = "T6493")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_flags_enum?>>), TypeInfoPropertyName = "T6494")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_flags_enum?>>), TypeInfoPropertyName = "T6495")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_flags_enum?>, int>), TypeInfoPropertyName = "T6496")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_flags_enum?>>), TypeInfoPropertyName = "T6497")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_flags_enum?>>), TypeInfoPropertyName = "T6498")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_flags_enum?>>), TypeInfoPropertyName = "T6499")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_flags_enum?>>), TypeInfoPropertyName = "T6500")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_flags_enum?>, int>), TypeInfoPropertyName = "T6501")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_flags_enum?>>), TypeInfoPropertyName = "T6502")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_flags_enum?>>), TypeInfoPropertyName = "T6503")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_flags_enum?>>), TypeInfoPropertyName = "T6504")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_flags_enum?>>), TypeInfoPropertyName = "T6505")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_flags_enum?>, int>), TypeInfoPropertyName = "T6506")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_flags_enum?>), TypeInfoPropertyName = "T6507")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_flags_enum?>), TypeInfoPropertyName = "T6508")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_flags_enum?>), TypeInfoPropertyName = "T6509")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_flags_enum?>), TypeInfoPropertyName = "T6510")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_flags_enum?, int>), TypeInfoPropertyName = "T6511")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_flags_enum?>), TypeInfoPropertyName = "T6512")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_flags_enum?>), TypeInfoPropertyName = "T6513")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_flags_enum?>), TypeInfoPropertyName = "T6514")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_flags_enum?>), TypeInfoPropertyName = "T6515")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_flags_enum?, int>), TypeInfoPropertyName = "T6516")]
-[JsonSerializable(typeof(V_validated_struct_Uri?), TypeInfoPropertyName = "T6517")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_Uri?>), TypeInfoPropertyName = "T6518")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_Uri?>), TypeInfoPropertyName = "T6519")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_Uri?>), TypeInfoPropertyName = "T6520")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_Uri?>), TypeInfoPropertyName = "T6521")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_Uri?, int>), TypeInfoPropertyName = "T6522")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_Uri?>>), TypeInfoPropertyName = "T6523")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_Uri?>>), TypeInfoPropertyName = "T6524")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_Uri?>>), TypeInfoPropertyName = "T6525")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_Uri?>>), TypeInfoPropertyName = "T6526")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_Uri?>, int>), TypeInfoPropertyName = "T6527")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_Uri?[]>), TypeInfoPropertyName = "T6528")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_Uri?[]>), TypeInfoPropertyName = "T6529")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_Uri?[]>), TypeInfoPropertyName = "T6530")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_Uri?[]>), TypeInfoPropertyName = "T6531")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_Uri?[], int>), TypeInfoPropertyName = "T6532")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_Uri?>>), TypeInfoPropertyName = "T6533")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_Uri?>>), TypeInfoPropertyName = "T6534")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_Uri?>>), TypeInfoPropertyName = "T6535")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_Uri?>>), TypeInfoPropertyName = "T6536")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_Uri?>, int>), TypeInfoPropertyName = "T6537")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_Uri?>>), TypeInfoPropertyName = "T6538")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_Uri?>>), TypeInfoPropertyName = "T6539")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_Uri?>>), TypeInfoPropertyName = "T6540")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_Uri?>>), TypeInfoPropertyName = "T6541")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_Uri?>, int>), TypeInfoPropertyName = "T6542")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_Uri?>>), TypeInfoPropertyName = "T6543")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_Uri?>>), TypeInfoPropertyName = "T6544")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_Uri?>>), TypeInfoPropertyName = "T6545")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_Uri?>>), TypeInfoPropertyName = "T6546")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_Uri?>, int>), TypeInfoPropertyName = "T6547")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_Uri?>), TypeInfoPropertyName = "T6548")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_Uri?>), TypeInfoPropertyName = "T6549")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_Uri?>), TypeInfoPropertyName = "T6550")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_Uri?>), TypeInfoPropertyName = "T6551")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_Uri?, int>), TypeInfoPropertyName = "T6552")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_Uri?>), TypeInfoPropertyName = "T6553")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_Uri?>), TypeInfoPropertyName = "T6554")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_Uri?>), TypeInfoPropertyName = "T6555")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_Uri?>), TypeInfoPropertyName = "T6556")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_Uri?, int>), TypeInfoPropertyName = "T6557")]
-[JsonSerializable(typeof(V_validated_struct_NodaTime_Instant?), TypeInfoPropertyName = "T6558")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T6559")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T6560")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T6561")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T6562")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_NodaTime_Instant?, int>), TypeInfoPropertyName = "T6563")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T6564")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T6565")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T6566")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T6567")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_NodaTime_Instant?>, int>), TypeInfoPropertyName = "T6568")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_NodaTime_Instant?[]>), TypeInfoPropertyName = "T6569")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_NodaTime_Instant?[]>), TypeInfoPropertyName = "T6570")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_NodaTime_Instant?[]>), TypeInfoPropertyName = "T6571")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_NodaTime_Instant?[]>), TypeInfoPropertyName = "T6572")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_NodaTime_Instant?[], int>), TypeInfoPropertyName = "T6573")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T6574")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T6575")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T6576")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T6577")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_NodaTime_Instant?>, int>), TypeInfoPropertyName = "T6578")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T6579")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T6580")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T6581")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T6582")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_NodaTime_Instant?>, int>), TypeInfoPropertyName = "T6583")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T6584")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T6585")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T6586")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_NodaTime_Instant?>>), TypeInfoPropertyName = "T6587")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_NodaTime_Instant?>, int>), TypeInfoPropertyName = "T6588")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T6589")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T6590")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T6591")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T6592")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_NodaTime_Instant?, int>), TypeInfoPropertyName = "T6593")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T6594")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T6595")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T6596")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_NodaTime_Instant?>), TypeInfoPropertyName = "T6597")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_NodaTime_Instant?, int>), TypeInfoPropertyName = "T6598")]
-[JsonSerializable(typeof(V_validated_struct_own_record_class?), TypeInfoPropertyName = "T6599")]
-[JsonSerializable(typeof(Cn_class_F<V_validated_struct_own_record_class?>), TypeInfoPropertyName = "T6600")]
-[JsonSerializable(typeof(Cn_record_class_F<V_validated_struct_own_record_class?>), TypeInfoPropertyName = "T6601")]
-[JsonSerializable(typeof(Cn_struct_F<V_validated_struct_own_record_class?>), TypeInfoPropertyName = "T6602")]
-[JsonSerializable(typeof(Cn_record_struct_F<V_validated_struct_own_record_class?>), TypeInfoPropertyName = "T6603")]
-[JsonSerializable(typeof(Cn_generic_type_F<V_validated_struct_own_record_class?, int>), TypeInfoPropertyName = "T6604")]
-[JsonSerializable(typeof(Cn_class_P<List<V_validated_struct_own_record_class?>>), TypeInfoPropertyName = "T6605")]
-[JsonSerializable(typeof(Cn_record_class_P<List<V_validated_struct_own_record_class?>>), TypeInfoPropertyName = "T6606")]
-[JsonSerializable(typeof(Cn_struct_P<List<V_validated_struct_own_record_class?>>), TypeInfoPropertyName = "T6607")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<V_validated_struct_own_record_class?>>), TypeInfoPropertyName = "T6608")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<V_validated_struct_own_record_class?>, int>), TypeInfoPropertyName = "T6609")]
-[JsonSerializable(typeof(Cn_class_P<V_validated_struct_own_record_class?[]>), TypeInfoPropertyName = "T6610")]
-[JsonSerializable(typeof(Cn_record_class_P<V_validated_struct_own_record_class?[]>), TypeInfoPropertyName = "T6611")]
-[JsonSerializable(typeof(Cn_struct_P<V_validated_struct_own_record_class?[]>), TypeInfoPropertyName = "T6612")]
-[JsonSerializable(typeof(Cn_record_struct_P<V_validated_struct_own_record_class?[]>), TypeInfoPropertyName = "T6613")]
-[JsonSerializable(typeof(Cn_generic_type_P<V_validated_struct_own_record_class?[], int>), TypeInfoPropertyName = "T6614")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<V_validated_struct_own_record_class?>>), TypeInfoPropertyName = "T6615")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<V_validated_struct_own_record_class?>>), TypeInfoPropertyName = "T6616")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<V_validated_struct_own_record_class?>>), TypeInfoPropertyName = "T6617")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<V_validated_struct_own_record_class?>>), TypeInfoPropertyName = "T6618")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<V_validated_struct_own_record_class?>, int>), TypeInfoPropertyName = "T6619")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<V_validated_struct_own_record_class?>>), TypeInfoPropertyName = "T6620")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<V_validated_struct_own_record_class?>>), TypeInfoPropertyName = "T6621")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<V_validated_struct_own_record_class?>>), TypeInfoPropertyName = "T6622")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<V_validated_struct_own_record_class?>>), TypeInfoPropertyName = "T6623")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<V_validated_struct_own_record_class?>, int>), TypeInfoPropertyName = "T6624")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, V_validated_struct_own_record_class?>>), TypeInfoPropertyName = "T6625")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, V_validated_struct_own_record_class?>>), TypeInfoPropertyName = "T6626")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, V_validated_struct_own_record_class?>>), TypeInfoPropertyName = "T6627")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, V_validated_struct_own_record_class?>>), TypeInfoPropertyName = "T6628")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, V_validated_struct_own_record_class?>, int>), TypeInfoPropertyName = "T6629")]
-[JsonSerializable(typeof(Cn_class_C<V_validated_struct_own_record_class?>), TypeInfoPropertyName = "T6630")]
-[JsonSerializable(typeof(Cn_record_class_C<V_validated_struct_own_record_class?>), TypeInfoPropertyName = "T6631")]
-[JsonSerializable(typeof(Cn_struct_C<V_validated_struct_own_record_class?>), TypeInfoPropertyName = "T6632")]
-[JsonSerializable(typeof(Cn_record_struct_C<V_validated_struct_own_record_class?>), TypeInfoPropertyName = "T6633")]
-[JsonSerializable(typeof(Cn_generic_type_C<V_validated_struct_own_record_class?, int>), TypeInfoPropertyName = "T6634")]
-[JsonSerializable(typeof(Cn_class_R<V_validated_struct_own_record_class?>), TypeInfoPropertyName = "T6635")]
-[JsonSerializable(typeof(Cn_record_class_R<V_validated_struct_own_record_class?>), TypeInfoPropertyName = "T6636")]
-[JsonSerializable(typeof(Cn_struct_R<V_validated_struct_own_record_class?>), TypeInfoPropertyName = "T6637")]
-[JsonSerializable(typeof(Cn_record_struct_R<V_validated_struct_own_record_class?>), TypeInfoPropertyName = "T6638")]
-[JsonSerializable(typeof(Cn_generic_type_R<V_validated_struct_own_record_class?, int>), TypeInfoPropertyName = "T6639")]
-[JsonSerializable(typeof(PSet))]
-[JsonSerializable(typeof(Cn_class_P<PSet>), TypeInfoPropertyName = "T6640")]
-[JsonSerializable(typeof(Cn_record_class_P<PSet>), TypeInfoPropertyName = "T6641")]
-[JsonSerializable(typeof(Cn_struct_P<PSet>), TypeInfoPropertyName = "T6642")]
-[JsonSerializable(typeof(Cn_record_struct_P<PSet>), TypeInfoPropertyName = "T6643")]
-[JsonSerializable(typeof(Cn_generic_type_P<PSet, int>), TypeInfoPropertyName = "T6644")]
-[JsonSerializable(typeof(Cn_class_F<PSet>), TypeInfoPropertyName = "T6645")]
-[JsonSerializable(typeof(Cn_record_class_F<PSet>), TypeInfoPropertyName = "T6646")]
-[JsonSerializable(typeof(Cn_struct_F<PSet>), TypeInfoPropertyName = "T6647")]
-[JsonSerializable(typeof(Cn_record_struct_F<PSet>), TypeInfoPropertyName = "T6648")]
-[JsonSerializable(typeof(Cn_generic_type_F<PSet, int>), TypeInfoPropertyName = "T6649")]
-[JsonSerializable(typeof(Cn_class_P<List<PSet>>), TypeInfoPropertyName = "T6650")]
-[JsonSerializable(typeof(Cn_record_class_P<List<PSet>>), TypeInfoPropertyName = "T6651")]
-[JsonSerializable(typeof(Cn_struct_P<List<PSet>>), TypeInfoPropertyName = "T6652")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<PSet>>), TypeInfoPropertyName = "T6653")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<PSet>, int>), TypeInfoPropertyName = "T6654")]
-[JsonSerializable(typeof(Cn_class_P<PSet[]>), TypeInfoPropertyName = "T6655")]
-[JsonSerializable(typeof(Cn_record_class_P<PSet[]>), TypeInfoPropertyName = "T6656")]
-[JsonSerializable(typeof(Cn_struct_P<PSet[]>), TypeInfoPropertyName = "T6657")]
-[JsonSerializable(typeof(Cn_record_struct_P<PSet[]>), TypeInfoPropertyName = "T6658")]
-[JsonSerializable(typeof(Cn_generic_type_P<PSet[], int>), TypeInfoPropertyName = "T6659")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<PSet>>), TypeInfoPropertyName = "T6660")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<PSet>>), TypeInfoPropertyName = "T6661")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<PSet>>), TypeInfoPropertyName = "T6662")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<PSet>>), TypeInfoPropertyName = "T6663")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<PSet>, int>), TypeInfoPropertyName = "T6664")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<PSet>>), TypeInfoPropertyName = "T6665")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<PSet>>), TypeInfoPropertyName = "T6666")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<PSet>>), TypeInfoPropertyName = "T6667")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<PSet>>), TypeInfoPropertyName = "T6668")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<PSet>, int>), TypeInfoPropertyName = "T6669")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<PSet, int>>), TypeInfoPropertyName = "T6670")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<PSet, int>>), TypeInfoPropertyName = "T6671")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<PSet, int>>), TypeInfoPropertyName = "T6672")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<PSet, int>>), TypeInfoPropertyName = "T6673")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<PSet, int>, int>), TypeInfoPropertyName = "T6674")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, PSet>>), TypeInfoPropertyName = "T6675")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, PSet>>), TypeInfoPropertyName = "T6676")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, PSet>>), TypeInfoPropertyName = "T6677")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, PSet>>), TypeInfoPropertyName = "T6678")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, PSet>, int>), TypeInfoPropertyName = "T6679")]
-[JsonSerializable(typeof(Cn_class_C<PSet>), TypeInfoPropertyName = "T6680")]
-[JsonSerializable(typeof(Cn_record_class_C<PSet>), TypeInfoPropertyName = "T6681")]
-[JsonSerializable(typeof(Cn_struct_C<PSet>), TypeInfoPropertyName = "T6682")]
-[JsonSerializable(typeof(Cn_record_struct_C<PSet>), TypeInfoPropertyName = "T6683")]
-[JsonSerializable(typeof(Cn_generic_type_C<PSet, int>), TypeInfoPropertyName = "T6684")]
-[JsonSerializable(typeof(Cn_class_R<PSet>), TypeInfoPropertyName = "T6685")]
-[JsonSerializable(typeof(Cn_record_class_R<PSet>), TypeInfoPropertyName = "T6686")]
-[JsonSerializable(typeof(Cn_struct_R<PSet>), TypeInfoPropertyName = "T6687")]
-[JsonSerializable(typeof(Cn_record_struct_R<PSet>), TypeInfoPropertyName = "T6688")]
-[JsonSerializable(typeof(Cn_generic_type_R<PSet, int>), TypeInfoPropertyName = "T6689")]
-[JsonSerializable(typeof(Cn_class_P<Patch<PSet>>), TypeInfoPropertyName = "T6690")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<PSet>>), TypeInfoPropertyName = "T6691")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<PSet>>), TypeInfoPropertyName = "T6692")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<PSet>>), TypeInfoPropertyName = "T6693")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<PSet>, int>), TypeInfoPropertyName = "T6694")]
-[JsonSerializable(typeof(Cn_class_P<PB_PSet>), TypeInfoPropertyName = "T6695")]
-[JsonSerializable(typeof(Cn_record_class_P<PB_PSet>), TypeInfoPropertyName = "T6696")]
-[JsonSerializable(typeof(Cn_struct_P<PB_PSet>), TypeInfoPropertyName = "T6697")]
-[JsonSerializable(typeof(Cn_record_struct_P<PB_PSet>), TypeInfoPropertyName = "T6698")]
-[JsonSerializable(typeof(Cn_generic_type_P<PB_PSet, int>), TypeInfoPropertyName = "T6699")]
-[JsonSerializable(typeof(string))]
-[JsonSerializable(typeof(Cn_class_P<string>), TypeInfoPropertyName = "T6700")]
-[JsonSerializable(typeof(Cn_record_class_P<string>), TypeInfoPropertyName = "T6701")]
-[JsonSerializable(typeof(Cn_struct_P<string>), TypeInfoPropertyName = "T6702")]
-[JsonSerializable(typeof(Cn_record_struct_P<string>), TypeInfoPropertyName = "T6703")]
-[JsonSerializable(typeof(Cn_generic_type_P<string, int>), TypeInfoPropertyName = "T6704")]
-[JsonSerializable(typeof(Cn_class_F<string>), TypeInfoPropertyName = "T6705")]
-[JsonSerializable(typeof(Cn_record_class_F<string>), TypeInfoPropertyName = "T6706")]
-[JsonSerializable(typeof(Cn_struct_F<string>), TypeInfoPropertyName = "T6707")]
-[JsonSerializable(typeof(Cn_record_struct_F<string>), TypeInfoPropertyName = "T6708")]
-[JsonSerializable(typeof(Cn_generic_type_F<string, int>), TypeInfoPropertyName = "T6709")]
-[JsonSerializable(typeof(Cn_class_P<List<string>>), TypeInfoPropertyName = "T6710")]
-[JsonSerializable(typeof(Cn_record_class_P<List<string>>), TypeInfoPropertyName = "T6711")]
-[JsonSerializable(typeof(Cn_struct_P<List<string>>), TypeInfoPropertyName = "T6712")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<string>>), TypeInfoPropertyName = "T6713")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<string>, int>), TypeInfoPropertyName = "T6714")]
-[JsonSerializable(typeof(Cn_class_P<string[]>), TypeInfoPropertyName = "T6715")]
-[JsonSerializable(typeof(Cn_record_class_P<string[]>), TypeInfoPropertyName = "T6716")]
-[JsonSerializable(typeof(Cn_struct_P<string[]>), TypeInfoPropertyName = "T6717")]
-[JsonSerializable(typeof(Cn_record_struct_P<string[]>), TypeInfoPropertyName = "T6718")]
-[JsonSerializable(typeof(Cn_generic_type_P<string[], int>), TypeInfoPropertyName = "T6719")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<string>>), TypeInfoPropertyName = "T6720")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<string>>), TypeInfoPropertyName = "T6721")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<string>>), TypeInfoPropertyName = "T6722")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<string>>), TypeInfoPropertyName = "T6723")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<string>, int>), TypeInfoPropertyName = "T6724")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<string>>), TypeInfoPropertyName = "T6725")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<string>>), TypeInfoPropertyName = "T6726")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<string>>), TypeInfoPropertyName = "T6727")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<string>>), TypeInfoPropertyName = "T6728")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<string>, int>), TypeInfoPropertyName = "T6729")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, int>>), TypeInfoPropertyName = "T6730")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, int>>), TypeInfoPropertyName = "T6731")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, int>>), TypeInfoPropertyName = "T6732")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, int>>), TypeInfoPropertyName = "T6733")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, int>, int>), TypeInfoPropertyName = "T6734")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, string>>), TypeInfoPropertyName = "T6735")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, string>>), TypeInfoPropertyName = "T6736")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, string>>), TypeInfoPropertyName = "T6737")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, string>>), TypeInfoPropertyName = "T6738")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, string>, int>), TypeInfoPropertyName = "T6739")]
-[JsonSerializable(typeof(Cn_class_C<string>), TypeInfoPropertyName = "T6740")]
-[JsonSerializable(typeof(Cn_record_class_C<string>), TypeInfoPropertyName = "T6741")]
-[JsonSerializable(typeof(Cn_struct_C<string>), TypeInfoPropertyName = "T6742")]
-[JsonSerializable(typeof(Cn_record_struct_C<string>), TypeInfoPropertyName = "T6743")]
-[JsonSerializable(typeof(Cn_generic_type_C<string, int>), TypeInfoPropertyName = "T6744")]
-[JsonSerializable(typeof(Cn_class_R<string>), TypeInfoPropertyName = "T6745")]
-[JsonSerializable(typeof(Cn_record_class_R<string>), TypeInfoPropertyName = "T6746")]
-[JsonSerializable(typeof(Cn_struct_R<string>), TypeInfoPropertyName = "T6747")]
-[JsonSerializable(typeof(Cn_record_struct_R<string>), TypeInfoPropertyName = "T6748")]
-[JsonSerializable(typeof(Cn_generic_type_R<string, int>), TypeInfoPropertyName = "T6749")]
-[JsonSerializable(typeof(Cn_class_P<Patch<string>>), TypeInfoPropertyName = "T6750")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<string>>), TypeInfoPropertyName = "T6751")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<string>>), TypeInfoPropertyName = "T6752")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<string>>), TypeInfoPropertyName = "T6753")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<string>, int>), TypeInfoPropertyName = "T6754")]
-[JsonSerializable(typeof(Cn_class_P<PBP_string>), TypeInfoPropertyName = "T6755")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_string>), TypeInfoPropertyName = "T6756")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_string>), TypeInfoPropertyName = "T6757")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_string>), TypeInfoPropertyName = "T6758")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_string, int>), TypeInfoPropertyName = "T6759")]
-[JsonSerializable(typeof(Guid))]
-[JsonSerializable(typeof(Cn_class_P<Guid>), TypeInfoPropertyName = "T6760")]
-[JsonSerializable(typeof(Cn_record_class_P<Guid>), TypeInfoPropertyName = "T6761")]
-[JsonSerializable(typeof(Cn_struct_P<Guid>), TypeInfoPropertyName = "T6762")]
-[JsonSerializable(typeof(Cn_record_struct_P<Guid>), TypeInfoPropertyName = "T6763")]
-[JsonSerializable(typeof(Cn_generic_type_P<Guid, int>), TypeInfoPropertyName = "T6764")]
-[JsonSerializable(typeof(Cn_class_P<Guid?>), TypeInfoPropertyName = "T6765")]
-[JsonSerializable(typeof(Cn_record_class_P<Guid?>), TypeInfoPropertyName = "T6766")]
-[JsonSerializable(typeof(Cn_struct_P<Guid?>), TypeInfoPropertyName = "T6767")]
-[JsonSerializable(typeof(Cn_record_struct_P<Guid?>), TypeInfoPropertyName = "T6768")]
-[JsonSerializable(typeof(Cn_generic_type_P<Guid?, int>), TypeInfoPropertyName = "T6769")]
-[JsonSerializable(typeof(Cn_class_F<Guid>), TypeInfoPropertyName = "T6770")]
-[JsonSerializable(typeof(Cn_record_class_F<Guid>), TypeInfoPropertyName = "T6771")]
-[JsonSerializable(typeof(Cn_struct_F<Guid>), TypeInfoPropertyName = "T6772")]
-[JsonSerializable(typeof(Cn_record_struct_F<Guid>), TypeInfoPropertyName = "T6773")]
-[JsonSerializable(typeof(Cn_generic_type_F<Guid, int>), TypeInfoPropertyName = "T6774")]
-[JsonSerializable(typeof(Cn_class_P<List<Guid>>), TypeInfoPropertyName = "T6775")]
-[JsonSerializable(typeof(Cn_record_class_P<List<Guid>>), TypeInfoPropertyName = "T6776")]
-[JsonSerializable(typeof(Cn_struct_P<List<Guid>>), TypeInfoPropertyName = "T6777")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<Guid>>), TypeInfoPropertyName = "T6778")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<Guid>, int>), TypeInfoPropertyName = "T6779")]
-[JsonSerializable(typeof(Cn_class_P<Guid[]>), TypeInfoPropertyName = "T6780")]
-[JsonSerializable(typeof(Cn_record_class_P<Guid[]>), TypeInfoPropertyName = "T6781")]
-[JsonSerializable(typeof(Cn_struct_P<Guid[]>), TypeInfoPropertyName = "T6782")]
-[JsonSerializable(typeof(Cn_record_struct_P<Guid[]>), TypeInfoPropertyName = "T6783")]
-[JsonSerializable(typeof(Cn_generic_type_P<Guid[], int>), TypeInfoPropertyName = "T6784")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<Guid>>), TypeInfoPropertyName = "T6785")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<Guid>>), TypeInfoPropertyName = "T6786")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<Guid>>), TypeInfoPropertyName = "T6787")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<Guid>>), TypeInfoPropertyName = "T6788")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<Guid>, int>), TypeInfoPropertyName = "T6789")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<Guid>>), TypeInfoPropertyName = "T6790")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<Guid>>), TypeInfoPropertyName = "T6791")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<Guid>>), TypeInfoPropertyName = "T6792")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<Guid>>), TypeInfoPropertyName = "T6793")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<Guid>, int>), TypeInfoPropertyName = "T6794")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<Guid, int>>), TypeInfoPropertyName = "T6795")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<Guid, int>>), TypeInfoPropertyName = "T6796")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<Guid, int>>), TypeInfoPropertyName = "T6797")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<Guid, int>>), TypeInfoPropertyName = "T6798")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<Guid, int>, int>), TypeInfoPropertyName = "T6799")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, Guid>>), TypeInfoPropertyName = "T6800")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, Guid>>), TypeInfoPropertyName = "T6801")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, Guid>>), TypeInfoPropertyName = "T6802")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, Guid>>), TypeInfoPropertyName = "T6803")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, Guid>, int>), TypeInfoPropertyName = "T6804")]
-[JsonSerializable(typeof(Cn_class_C<Guid>), TypeInfoPropertyName = "T6805")]
-[JsonSerializable(typeof(Cn_record_class_C<Guid>), TypeInfoPropertyName = "T6806")]
-[JsonSerializable(typeof(Cn_struct_C<Guid>), TypeInfoPropertyName = "T6807")]
-[JsonSerializable(typeof(Cn_record_struct_C<Guid>), TypeInfoPropertyName = "T6808")]
-[JsonSerializable(typeof(Cn_generic_type_C<Guid, int>), TypeInfoPropertyName = "T6809")]
-[JsonSerializable(typeof(Cn_class_R<Guid>), TypeInfoPropertyName = "T6810")]
-[JsonSerializable(typeof(Cn_record_class_R<Guid>), TypeInfoPropertyName = "T6811")]
-[JsonSerializable(typeof(Cn_struct_R<Guid>), TypeInfoPropertyName = "T6812")]
-[JsonSerializable(typeof(Cn_record_struct_R<Guid>), TypeInfoPropertyName = "T6813")]
-[JsonSerializable(typeof(Cn_generic_type_R<Guid, int>), TypeInfoPropertyName = "T6814")]
-[JsonSerializable(typeof(Cn_class_P<Patch<Guid>>), TypeInfoPropertyName = "T6815")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<Guid>>), TypeInfoPropertyName = "T6816")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<Guid>>), TypeInfoPropertyName = "T6817")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<Guid>>), TypeInfoPropertyName = "T6818")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<Guid>, int>), TypeInfoPropertyName = "T6819")]
-[JsonSerializable(typeof(Cn_class_P<PBP_Guid>), TypeInfoPropertyName = "T6820")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_Guid>), TypeInfoPropertyName = "T6821")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_Guid>), TypeInfoPropertyName = "T6822")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_Guid>), TypeInfoPropertyName = "T6823")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_Guid, int>), TypeInfoPropertyName = "T6824")]
-[JsonSerializable(typeof(int))]
-[JsonSerializable(typeof(Cn_class_P<int>), TypeInfoPropertyName = "T6825")]
-[JsonSerializable(typeof(Cn_record_class_P<int>), TypeInfoPropertyName = "T6826")]
-[JsonSerializable(typeof(Cn_struct_P<int>), TypeInfoPropertyName = "T6827")]
-[JsonSerializable(typeof(Cn_record_struct_P<int>), TypeInfoPropertyName = "T6828")]
-[JsonSerializable(typeof(Cn_generic_type_P<int, int>), TypeInfoPropertyName = "T6829")]
-[JsonSerializable(typeof(Cn_class_P<int?>), TypeInfoPropertyName = "T6830")]
-[JsonSerializable(typeof(Cn_record_class_P<int?>), TypeInfoPropertyName = "T6831")]
-[JsonSerializable(typeof(Cn_struct_P<int?>), TypeInfoPropertyName = "T6832")]
-[JsonSerializable(typeof(Cn_record_struct_P<int?>), TypeInfoPropertyName = "T6833")]
-[JsonSerializable(typeof(Cn_generic_type_P<int?, int>), TypeInfoPropertyName = "T6834")]
-[JsonSerializable(typeof(Cn_class_F<int>), TypeInfoPropertyName = "T6835")]
-[JsonSerializable(typeof(Cn_record_class_F<int>), TypeInfoPropertyName = "T6836")]
-[JsonSerializable(typeof(Cn_struct_F<int>), TypeInfoPropertyName = "T6837")]
-[JsonSerializable(typeof(Cn_record_struct_F<int>), TypeInfoPropertyName = "T6838")]
-[JsonSerializable(typeof(Cn_generic_type_F<int, int>), TypeInfoPropertyName = "T6839")]
-[JsonSerializable(typeof(Cn_class_P<List<int>>), TypeInfoPropertyName = "T6840")]
-[JsonSerializable(typeof(Cn_record_class_P<List<int>>), TypeInfoPropertyName = "T6841")]
-[JsonSerializable(typeof(Cn_struct_P<List<int>>), TypeInfoPropertyName = "T6842")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<int>>), TypeInfoPropertyName = "T6843")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<int>, int>), TypeInfoPropertyName = "T6844")]
-[JsonSerializable(typeof(Cn_class_P<int[]>), TypeInfoPropertyName = "T6845")]
-[JsonSerializable(typeof(Cn_record_class_P<int[]>), TypeInfoPropertyName = "T6846")]
-[JsonSerializable(typeof(Cn_struct_P<int[]>), TypeInfoPropertyName = "T6847")]
-[JsonSerializable(typeof(Cn_record_struct_P<int[]>), TypeInfoPropertyName = "T6848")]
-[JsonSerializable(typeof(Cn_generic_type_P<int[], int>), TypeInfoPropertyName = "T6849")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<int>>), TypeInfoPropertyName = "T6850")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<int>>), TypeInfoPropertyName = "T6851")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<int>>), TypeInfoPropertyName = "T6852")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<int>>), TypeInfoPropertyName = "T6853")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<int>, int>), TypeInfoPropertyName = "T6854")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<int>>), TypeInfoPropertyName = "T6855")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<int>>), TypeInfoPropertyName = "T6856")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<int>>), TypeInfoPropertyName = "T6857")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<int>>), TypeInfoPropertyName = "T6858")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<int>, int>), TypeInfoPropertyName = "T6859")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<int, int>>), TypeInfoPropertyName = "T6860")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<int, int>>), TypeInfoPropertyName = "T6861")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<int, int>>), TypeInfoPropertyName = "T6862")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<int, int>>), TypeInfoPropertyName = "T6863")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<int, int>, int>), TypeInfoPropertyName = "T6864")]
-[JsonSerializable(typeof(Cn_class_C<int>), TypeInfoPropertyName = "T6865")]
-[JsonSerializable(typeof(Cn_record_class_C<int>), TypeInfoPropertyName = "T6866")]
-[JsonSerializable(typeof(Cn_struct_C<int>), TypeInfoPropertyName = "T6867")]
-[JsonSerializable(typeof(Cn_record_struct_C<int>), TypeInfoPropertyName = "T6868")]
-[JsonSerializable(typeof(Cn_generic_type_C<int, int>), TypeInfoPropertyName = "T6869")]
-[JsonSerializable(typeof(Cn_class_R<int>), TypeInfoPropertyName = "T6870")]
-[JsonSerializable(typeof(Cn_record_class_R<int>), TypeInfoPropertyName = "T6871")]
-[JsonSerializable(typeof(Cn_struct_R<int>), TypeInfoPropertyName = "T6872")]
-[JsonSerializable(typeof(Cn_record_struct_R<int>), TypeInfoPropertyName = "T6873")]
-[JsonSerializable(typeof(Cn_generic_type_R<int, int>), TypeInfoPropertyName = "T6874")]
-[JsonSerializable(typeof(Cn_class_P<Patch<int>>), TypeInfoPropertyName = "T6875")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<int>>), TypeInfoPropertyName = "T6876")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<int>>), TypeInfoPropertyName = "T6877")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<int>>), TypeInfoPropertyName = "T6878")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<int>, int>), TypeInfoPropertyName = "T6879")]
-[JsonSerializable(typeof(Cn_class_P<PBP_int>), TypeInfoPropertyName = "T6880")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_int>), TypeInfoPropertyName = "T6881")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_int>), TypeInfoPropertyName = "T6882")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_int>), TypeInfoPropertyName = "T6883")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_int, int>), TypeInfoPropertyName = "T6884")]
-[JsonSerializable(typeof(long))]
-[JsonSerializable(typeof(Cn_class_P<long>), TypeInfoPropertyName = "T6885")]
-[JsonSerializable(typeof(Cn_record_class_P<long>), TypeInfoPropertyName = "T6886")]
-[JsonSerializable(typeof(Cn_struct_P<long>), TypeInfoPropertyName = "T6887")]
-[JsonSerializable(typeof(Cn_record_struct_P<long>), TypeInfoPropertyName = "T6888")]
-[JsonSerializable(typeof(Cn_generic_type_P<long, int>), TypeInfoPropertyName = "T6889")]
-[JsonSerializable(typeof(Cn_class_P<long?>), TypeInfoPropertyName = "T6890")]
-[JsonSerializable(typeof(Cn_record_class_P<long?>), TypeInfoPropertyName = "T6891")]
-[JsonSerializable(typeof(Cn_struct_P<long?>), TypeInfoPropertyName = "T6892")]
-[JsonSerializable(typeof(Cn_record_struct_P<long?>), TypeInfoPropertyName = "T6893")]
-[JsonSerializable(typeof(Cn_generic_type_P<long?, int>), TypeInfoPropertyName = "T6894")]
-[JsonSerializable(typeof(Cn_class_F<long>), TypeInfoPropertyName = "T6895")]
-[JsonSerializable(typeof(Cn_record_class_F<long>), TypeInfoPropertyName = "T6896")]
-[JsonSerializable(typeof(Cn_struct_F<long>), TypeInfoPropertyName = "T6897")]
-[JsonSerializable(typeof(Cn_record_struct_F<long>), TypeInfoPropertyName = "T6898")]
-[JsonSerializable(typeof(Cn_generic_type_F<long, int>), TypeInfoPropertyName = "T6899")]
-[JsonSerializable(typeof(Cn_class_P<List<long>>), TypeInfoPropertyName = "T6900")]
-[JsonSerializable(typeof(Cn_record_class_P<List<long>>), TypeInfoPropertyName = "T6901")]
-[JsonSerializable(typeof(Cn_struct_P<List<long>>), TypeInfoPropertyName = "T6902")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<long>>), TypeInfoPropertyName = "T6903")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<long>, int>), TypeInfoPropertyName = "T6904")]
-[JsonSerializable(typeof(Cn_class_P<long[]>), TypeInfoPropertyName = "T6905")]
-[JsonSerializable(typeof(Cn_record_class_P<long[]>), TypeInfoPropertyName = "T6906")]
-[JsonSerializable(typeof(Cn_struct_P<long[]>), TypeInfoPropertyName = "T6907")]
-[JsonSerializable(typeof(Cn_record_struct_P<long[]>), TypeInfoPropertyName = "T6908")]
-[JsonSerializable(typeof(Cn_generic_type_P<long[], int>), TypeInfoPropertyName = "T6909")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<long>>), TypeInfoPropertyName = "T6910")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<long>>), TypeInfoPropertyName = "T6911")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<long>>), TypeInfoPropertyName = "T6912")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<long>>), TypeInfoPropertyName = "T6913")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<long>, int>), TypeInfoPropertyName = "T6914")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<long>>), TypeInfoPropertyName = "T6915")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<long>>), TypeInfoPropertyName = "T6916")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<long>>), TypeInfoPropertyName = "T6917")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<long>>), TypeInfoPropertyName = "T6918")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<long>, int>), TypeInfoPropertyName = "T6919")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<long, int>>), TypeInfoPropertyName = "T6920")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<long, int>>), TypeInfoPropertyName = "T6921")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<long, int>>), TypeInfoPropertyName = "T6922")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<long, int>>), TypeInfoPropertyName = "T6923")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<long, int>, int>), TypeInfoPropertyName = "T6924")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, long>>), TypeInfoPropertyName = "T6925")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, long>>), TypeInfoPropertyName = "T6926")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, long>>), TypeInfoPropertyName = "T6927")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, long>>), TypeInfoPropertyName = "T6928")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, long>, int>), TypeInfoPropertyName = "T6929")]
-[JsonSerializable(typeof(Cn_class_C<long>), TypeInfoPropertyName = "T6930")]
-[JsonSerializable(typeof(Cn_record_class_C<long>), TypeInfoPropertyName = "T6931")]
-[JsonSerializable(typeof(Cn_struct_C<long>), TypeInfoPropertyName = "T6932")]
-[JsonSerializable(typeof(Cn_record_struct_C<long>), TypeInfoPropertyName = "T6933")]
-[JsonSerializable(typeof(Cn_generic_type_C<long, int>), TypeInfoPropertyName = "T6934")]
-[JsonSerializable(typeof(Cn_class_R<long>), TypeInfoPropertyName = "T6935")]
-[JsonSerializable(typeof(Cn_record_class_R<long>), TypeInfoPropertyName = "T6936")]
-[JsonSerializable(typeof(Cn_struct_R<long>), TypeInfoPropertyName = "T6937")]
-[JsonSerializable(typeof(Cn_record_struct_R<long>), TypeInfoPropertyName = "T6938")]
-[JsonSerializable(typeof(Cn_generic_type_R<long, int>), TypeInfoPropertyName = "T6939")]
-[JsonSerializable(typeof(Cn_class_P<Patch<long>>), TypeInfoPropertyName = "T6940")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<long>>), TypeInfoPropertyName = "T6941")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<long>>), TypeInfoPropertyName = "T6942")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<long>>), TypeInfoPropertyName = "T6943")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<long>, int>), TypeInfoPropertyName = "T6944")]
-[JsonSerializable(typeof(Cn_class_P<PBP_long>), TypeInfoPropertyName = "T6945")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_long>), TypeInfoPropertyName = "T6946")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_long>), TypeInfoPropertyName = "T6947")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_long>), TypeInfoPropertyName = "T6948")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_long, int>), TypeInfoPropertyName = "T6949")]
-[JsonSerializable(typeof(byte))]
-[JsonSerializable(typeof(Cn_class_P<byte>), TypeInfoPropertyName = "T6950")]
-[JsonSerializable(typeof(Cn_record_class_P<byte>), TypeInfoPropertyName = "T6951")]
-[JsonSerializable(typeof(Cn_struct_P<byte>), TypeInfoPropertyName = "T6952")]
-[JsonSerializable(typeof(Cn_record_struct_P<byte>), TypeInfoPropertyName = "T6953")]
-[JsonSerializable(typeof(Cn_generic_type_P<byte, int>), TypeInfoPropertyName = "T6954")]
-[JsonSerializable(typeof(Cn_class_P<byte?>), TypeInfoPropertyName = "T6955")]
-[JsonSerializable(typeof(Cn_record_class_P<byte?>), TypeInfoPropertyName = "T6956")]
-[JsonSerializable(typeof(Cn_struct_P<byte?>), TypeInfoPropertyName = "T6957")]
-[JsonSerializable(typeof(Cn_record_struct_P<byte?>), TypeInfoPropertyName = "T6958")]
-[JsonSerializable(typeof(Cn_generic_type_P<byte?, int>), TypeInfoPropertyName = "T6959")]
-[JsonSerializable(typeof(Cn_class_F<byte>), TypeInfoPropertyName = "T6960")]
-[JsonSerializable(typeof(Cn_record_class_F<byte>), TypeInfoPropertyName = "T6961")]
-[JsonSerializable(typeof(Cn_struct_F<byte>), TypeInfoPropertyName = "T6962")]
-[JsonSerializable(typeof(Cn_record_struct_F<byte>), TypeInfoPropertyName = "T6963")]
-[JsonSerializable(typeof(Cn_generic_type_F<byte, int>), TypeInfoPropertyName = "T6964")]
-[JsonSerializable(typeof(Cn_class_P<List<byte>>), TypeInfoPropertyName = "T6965")]
-[JsonSerializable(typeof(Cn_record_class_P<List<byte>>), TypeInfoPropertyName = "T6966")]
-[JsonSerializable(typeof(Cn_struct_P<List<byte>>), TypeInfoPropertyName = "T6967")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<byte>>), TypeInfoPropertyName = "T6968")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<byte>, int>), TypeInfoPropertyName = "T6969")]
-[JsonSerializable(typeof(Cn_class_P<byte[]>), TypeInfoPropertyName = "T6970")]
-[JsonSerializable(typeof(Cn_record_class_P<byte[]>), TypeInfoPropertyName = "T6971")]
-[JsonSerializable(typeof(Cn_struct_P<byte[]>), TypeInfoPropertyName = "T6972")]
-[JsonSerializable(typeof(Cn_record_struct_P<byte[]>), TypeInfoPropertyName = "T6973")]
-[JsonSerializable(typeof(Cn_generic_type_P<byte[], int>), TypeInfoPropertyName = "T6974")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<byte>>), TypeInfoPropertyName = "T6975")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<byte>>), TypeInfoPropertyName = "T6976")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<byte>>), TypeInfoPropertyName = "T6977")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<byte>>), TypeInfoPropertyName = "T6978")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<byte>, int>), TypeInfoPropertyName = "T6979")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<byte>>), TypeInfoPropertyName = "T6980")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<byte>>), TypeInfoPropertyName = "T6981")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<byte>>), TypeInfoPropertyName = "T6982")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<byte>>), TypeInfoPropertyName = "T6983")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<byte>, int>), TypeInfoPropertyName = "T6984")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<byte, int>>), TypeInfoPropertyName = "T6985")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<byte, int>>), TypeInfoPropertyName = "T6986")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<byte, int>>), TypeInfoPropertyName = "T6987")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<byte, int>>), TypeInfoPropertyName = "T6988")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<byte, int>, int>), TypeInfoPropertyName = "T6989")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, byte>>), TypeInfoPropertyName = "T6990")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, byte>>), TypeInfoPropertyName = "T6991")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, byte>>), TypeInfoPropertyName = "T6992")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, byte>>), TypeInfoPropertyName = "T6993")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, byte>, int>), TypeInfoPropertyName = "T6994")]
-[JsonSerializable(typeof(Cn_class_C<byte>), TypeInfoPropertyName = "T6995")]
-[JsonSerializable(typeof(Cn_record_class_C<byte>), TypeInfoPropertyName = "T6996")]
-[JsonSerializable(typeof(Cn_struct_C<byte>), TypeInfoPropertyName = "T6997")]
-[JsonSerializable(typeof(Cn_record_struct_C<byte>), TypeInfoPropertyName = "T6998")]
-[JsonSerializable(typeof(Cn_generic_type_C<byte, int>), TypeInfoPropertyName = "T6999")]
-[JsonSerializable(typeof(Cn_class_R<byte>), TypeInfoPropertyName = "T7000")]
-[JsonSerializable(typeof(Cn_record_class_R<byte>), TypeInfoPropertyName = "T7001")]
-[JsonSerializable(typeof(Cn_struct_R<byte>), TypeInfoPropertyName = "T7002")]
-[JsonSerializable(typeof(Cn_record_struct_R<byte>), TypeInfoPropertyName = "T7003")]
-[JsonSerializable(typeof(Cn_generic_type_R<byte, int>), TypeInfoPropertyName = "T7004")]
-[JsonSerializable(typeof(Cn_class_P<Patch<byte>>), TypeInfoPropertyName = "T7005")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<byte>>), TypeInfoPropertyName = "T7006")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<byte>>), TypeInfoPropertyName = "T7007")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<byte>>), TypeInfoPropertyName = "T7008")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<byte>, int>), TypeInfoPropertyName = "T7009")]
-[JsonSerializable(typeof(Cn_class_P<PBP_byte>), TypeInfoPropertyName = "T7010")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_byte>), TypeInfoPropertyName = "T7011")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_byte>), TypeInfoPropertyName = "T7012")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_byte>), TypeInfoPropertyName = "T7013")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_byte, int>), TypeInfoPropertyName = "T7014")]
-[JsonSerializable(typeof(ulong))]
-[JsonSerializable(typeof(Cn_class_P<ulong>), TypeInfoPropertyName = "T7015")]
-[JsonSerializable(typeof(Cn_record_class_P<ulong>), TypeInfoPropertyName = "T7016")]
-[JsonSerializable(typeof(Cn_struct_P<ulong>), TypeInfoPropertyName = "T7017")]
-[JsonSerializable(typeof(Cn_record_struct_P<ulong>), TypeInfoPropertyName = "T7018")]
-[JsonSerializable(typeof(Cn_generic_type_P<ulong, int>), TypeInfoPropertyName = "T7019")]
-[JsonSerializable(typeof(Cn_class_P<ulong?>), TypeInfoPropertyName = "T7020")]
-[JsonSerializable(typeof(Cn_record_class_P<ulong?>), TypeInfoPropertyName = "T7021")]
-[JsonSerializable(typeof(Cn_struct_P<ulong?>), TypeInfoPropertyName = "T7022")]
-[JsonSerializable(typeof(Cn_record_struct_P<ulong?>), TypeInfoPropertyName = "T7023")]
-[JsonSerializable(typeof(Cn_generic_type_P<ulong?, int>), TypeInfoPropertyName = "T7024")]
-[JsonSerializable(typeof(Cn_class_F<ulong>), TypeInfoPropertyName = "T7025")]
-[JsonSerializable(typeof(Cn_record_class_F<ulong>), TypeInfoPropertyName = "T7026")]
-[JsonSerializable(typeof(Cn_struct_F<ulong>), TypeInfoPropertyName = "T7027")]
-[JsonSerializable(typeof(Cn_record_struct_F<ulong>), TypeInfoPropertyName = "T7028")]
-[JsonSerializable(typeof(Cn_generic_type_F<ulong, int>), TypeInfoPropertyName = "T7029")]
-[JsonSerializable(typeof(Cn_class_P<List<ulong>>), TypeInfoPropertyName = "T7030")]
-[JsonSerializable(typeof(Cn_record_class_P<List<ulong>>), TypeInfoPropertyName = "T7031")]
-[JsonSerializable(typeof(Cn_struct_P<List<ulong>>), TypeInfoPropertyName = "T7032")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<ulong>>), TypeInfoPropertyName = "T7033")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<ulong>, int>), TypeInfoPropertyName = "T7034")]
-[JsonSerializable(typeof(Cn_class_P<ulong[]>), TypeInfoPropertyName = "T7035")]
-[JsonSerializable(typeof(Cn_record_class_P<ulong[]>), TypeInfoPropertyName = "T7036")]
-[JsonSerializable(typeof(Cn_struct_P<ulong[]>), TypeInfoPropertyName = "T7037")]
-[JsonSerializable(typeof(Cn_record_struct_P<ulong[]>), TypeInfoPropertyName = "T7038")]
-[JsonSerializable(typeof(Cn_generic_type_P<ulong[], int>), TypeInfoPropertyName = "T7039")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<ulong>>), TypeInfoPropertyName = "T7040")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<ulong>>), TypeInfoPropertyName = "T7041")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<ulong>>), TypeInfoPropertyName = "T7042")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<ulong>>), TypeInfoPropertyName = "T7043")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<ulong>, int>), TypeInfoPropertyName = "T7044")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<ulong>>), TypeInfoPropertyName = "T7045")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<ulong>>), TypeInfoPropertyName = "T7046")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<ulong>>), TypeInfoPropertyName = "T7047")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<ulong>>), TypeInfoPropertyName = "T7048")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<ulong>, int>), TypeInfoPropertyName = "T7049")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<ulong, int>>), TypeInfoPropertyName = "T7050")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<ulong, int>>), TypeInfoPropertyName = "T7051")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<ulong, int>>), TypeInfoPropertyName = "T7052")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<ulong, int>>), TypeInfoPropertyName = "T7053")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<ulong, int>, int>), TypeInfoPropertyName = "T7054")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, ulong>>), TypeInfoPropertyName = "T7055")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, ulong>>), TypeInfoPropertyName = "T7056")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, ulong>>), TypeInfoPropertyName = "T7057")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, ulong>>), TypeInfoPropertyName = "T7058")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, ulong>, int>), TypeInfoPropertyName = "T7059")]
-[JsonSerializable(typeof(Cn_class_C<ulong>), TypeInfoPropertyName = "T7060")]
-[JsonSerializable(typeof(Cn_record_class_C<ulong>), TypeInfoPropertyName = "T7061")]
-[JsonSerializable(typeof(Cn_struct_C<ulong>), TypeInfoPropertyName = "T7062")]
-[JsonSerializable(typeof(Cn_record_struct_C<ulong>), TypeInfoPropertyName = "T7063")]
-[JsonSerializable(typeof(Cn_generic_type_C<ulong, int>), TypeInfoPropertyName = "T7064")]
-[JsonSerializable(typeof(Cn_class_R<ulong>), TypeInfoPropertyName = "T7065")]
-[JsonSerializable(typeof(Cn_record_class_R<ulong>), TypeInfoPropertyName = "T7066")]
-[JsonSerializable(typeof(Cn_struct_R<ulong>), TypeInfoPropertyName = "T7067")]
-[JsonSerializable(typeof(Cn_record_struct_R<ulong>), TypeInfoPropertyName = "T7068")]
-[JsonSerializable(typeof(Cn_generic_type_R<ulong, int>), TypeInfoPropertyName = "T7069")]
-[JsonSerializable(typeof(Cn_class_P<Patch<ulong>>), TypeInfoPropertyName = "T7070")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<ulong>>), TypeInfoPropertyName = "T7071")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<ulong>>), TypeInfoPropertyName = "T7072")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<ulong>>), TypeInfoPropertyName = "T7073")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<ulong>, int>), TypeInfoPropertyName = "T7074")]
-[JsonSerializable(typeof(Cn_class_P<PBP_ulong>), TypeInfoPropertyName = "T7075")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_ulong>), TypeInfoPropertyName = "T7076")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_ulong>), TypeInfoPropertyName = "T7077")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_ulong>), TypeInfoPropertyName = "T7078")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_ulong, int>), TypeInfoPropertyName = "T7079")]
-[JsonSerializable(typeof(decimal))]
-[JsonSerializable(typeof(Cn_class_P<decimal>), TypeInfoPropertyName = "T7080")]
-[JsonSerializable(typeof(Cn_record_class_P<decimal>), TypeInfoPropertyName = "T7081")]
-[JsonSerializable(typeof(Cn_struct_P<decimal>), TypeInfoPropertyName = "T7082")]
-[JsonSerializable(typeof(Cn_record_struct_P<decimal>), TypeInfoPropertyName = "T7083")]
-[JsonSerializable(typeof(Cn_generic_type_P<decimal, int>), TypeInfoPropertyName = "T7084")]
-[JsonSerializable(typeof(Cn_class_P<decimal?>), TypeInfoPropertyName = "T7085")]
-[JsonSerializable(typeof(Cn_record_class_P<decimal?>), TypeInfoPropertyName = "T7086")]
-[JsonSerializable(typeof(Cn_struct_P<decimal?>), TypeInfoPropertyName = "T7087")]
-[JsonSerializable(typeof(Cn_record_struct_P<decimal?>), TypeInfoPropertyName = "T7088")]
-[JsonSerializable(typeof(Cn_generic_type_P<decimal?, int>), TypeInfoPropertyName = "T7089")]
-[JsonSerializable(typeof(Cn_class_F<decimal>), TypeInfoPropertyName = "T7090")]
-[JsonSerializable(typeof(Cn_record_class_F<decimal>), TypeInfoPropertyName = "T7091")]
-[JsonSerializable(typeof(Cn_struct_F<decimal>), TypeInfoPropertyName = "T7092")]
-[JsonSerializable(typeof(Cn_record_struct_F<decimal>), TypeInfoPropertyName = "T7093")]
-[JsonSerializable(typeof(Cn_generic_type_F<decimal, int>), TypeInfoPropertyName = "T7094")]
-[JsonSerializable(typeof(Cn_class_P<List<decimal>>), TypeInfoPropertyName = "T7095")]
-[JsonSerializable(typeof(Cn_record_class_P<List<decimal>>), TypeInfoPropertyName = "T7096")]
-[JsonSerializable(typeof(Cn_struct_P<List<decimal>>), TypeInfoPropertyName = "T7097")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<decimal>>), TypeInfoPropertyName = "T7098")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<decimal>, int>), TypeInfoPropertyName = "T7099")]
-[JsonSerializable(typeof(Cn_class_P<decimal[]>), TypeInfoPropertyName = "T7100")]
-[JsonSerializable(typeof(Cn_record_class_P<decimal[]>), TypeInfoPropertyName = "T7101")]
-[JsonSerializable(typeof(Cn_struct_P<decimal[]>), TypeInfoPropertyName = "T7102")]
-[JsonSerializable(typeof(Cn_record_struct_P<decimal[]>), TypeInfoPropertyName = "T7103")]
-[JsonSerializable(typeof(Cn_generic_type_P<decimal[], int>), TypeInfoPropertyName = "T7104")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<decimal>>), TypeInfoPropertyName = "T7105")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<decimal>>), TypeInfoPropertyName = "T7106")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<decimal>>), TypeInfoPropertyName = "T7107")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<decimal>>), TypeInfoPropertyName = "T7108")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<decimal>, int>), TypeInfoPropertyName = "T7109")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<decimal>>), TypeInfoPropertyName = "T7110")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<decimal>>), TypeInfoPropertyName = "T7111")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<decimal>>), TypeInfoPropertyName = "T7112")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<decimal>>), TypeInfoPropertyName = "T7113")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<decimal>, int>), TypeInfoPropertyName = "T7114")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<decimal, int>>), TypeInfoPropertyName = "T7115")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<decimal, int>>), TypeInfoPropertyName = "T7116")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<decimal, int>>), TypeInfoPropertyName = "T7117")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<decimal, int>>), TypeInfoPropertyName = "T7118")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<decimal, int>, int>), TypeInfoPropertyName = "T7119")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, decimal>>), TypeInfoPropertyName = "T7120")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, decimal>>), TypeInfoPropertyName = "T7121")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, decimal>>), TypeInfoPropertyName = "T7122")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, decimal>>), TypeInfoPropertyName = "T7123")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, decimal>, int>), TypeInfoPropertyName = "T7124")]
-[JsonSerializable(typeof(Cn_class_C<decimal>), TypeInfoPropertyName = "T7125")]
-[JsonSerializable(typeof(Cn_record_class_C<decimal>), TypeInfoPropertyName = "T7126")]
-[JsonSerializable(typeof(Cn_struct_C<decimal>), TypeInfoPropertyName = "T7127")]
-[JsonSerializable(typeof(Cn_record_struct_C<decimal>), TypeInfoPropertyName = "T7128")]
-[JsonSerializable(typeof(Cn_generic_type_C<decimal, int>), TypeInfoPropertyName = "T7129")]
-[JsonSerializable(typeof(Cn_class_R<decimal>), TypeInfoPropertyName = "T7130")]
-[JsonSerializable(typeof(Cn_record_class_R<decimal>), TypeInfoPropertyName = "T7131")]
-[JsonSerializable(typeof(Cn_struct_R<decimal>), TypeInfoPropertyName = "T7132")]
-[JsonSerializable(typeof(Cn_record_struct_R<decimal>), TypeInfoPropertyName = "T7133")]
-[JsonSerializable(typeof(Cn_generic_type_R<decimal, int>), TypeInfoPropertyName = "T7134")]
-[JsonSerializable(typeof(Cn_class_P<Patch<decimal>>), TypeInfoPropertyName = "T7135")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<decimal>>), TypeInfoPropertyName = "T7136")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<decimal>>), TypeInfoPropertyName = "T7137")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<decimal>>), TypeInfoPropertyName = "T7138")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<decimal>, int>), TypeInfoPropertyName = "T7139")]
-[JsonSerializable(typeof(Cn_class_P<PBP_decimal>), TypeInfoPropertyName = "T7140")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_decimal>), TypeInfoPropertyName = "T7141")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_decimal>), TypeInfoPropertyName = "T7142")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_decimal>), TypeInfoPropertyName = "T7143")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_decimal, int>), TypeInfoPropertyName = "T7144")]
-[JsonSerializable(typeof(double))]
-[JsonSerializable(typeof(Cn_class_P<double>), TypeInfoPropertyName = "T7145")]
-[JsonSerializable(typeof(Cn_record_class_P<double>), TypeInfoPropertyName = "T7146")]
-[JsonSerializable(typeof(Cn_struct_P<double>), TypeInfoPropertyName = "T7147")]
-[JsonSerializable(typeof(Cn_record_struct_P<double>), TypeInfoPropertyName = "T7148")]
-[JsonSerializable(typeof(Cn_generic_type_P<double, int>), TypeInfoPropertyName = "T7149")]
-[JsonSerializable(typeof(Cn_class_P<double?>), TypeInfoPropertyName = "T7150")]
-[JsonSerializable(typeof(Cn_record_class_P<double?>), TypeInfoPropertyName = "T7151")]
-[JsonSerializable(typeof(Cn_struct_P<double?>), TypeInfoPropertyName = "T7152")]
-[JsonSerializable(typeof(Cn_record_struct_P<double?>), TypeInfoPropertyName = "T7153")]
-[JsonSerializable(typeof(Cn_generic_type_P<double?, int>), TypeInfoPropertyName = "T7154")]
-[JsonSerializable(typeof(Cn_class_F<double>), TypeInfoPropertyName = "T7155")]
-[JsonSerializable(typeof(Cn_record_class_F<double>), TypeInfoPropertyName = "T7156")]
-[JsonSerializable(typeof(Cn_struct_F<double>), TypeInfoPropertyName = "T7157")]
-[JsonSerializable(typeof(Cn_record_struct_F<double>), TypeInfoPropertyName = "T7158")]
-[JsonSerializable(typeof(Cn_generic_type_F<double, int>), TypeInfoPropertyName = "T7159")]
-[JsonSerializable(typeof(Cn_class_P<List<double>>), TypeInfoPropertyName = "T7160")]
-[JsonSerializable(typeof(Cn_record_class_P<List<double>>), TypeInfoPropertyName = "T7161")]
-[JsonSerializable(typeof(Cn_struct_P<List<double>>), TypeInfoPropertyName = "T7162")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<double>>), TypeInfoPropertyName = "T7163")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<double>, int>), TypeInfoPropertyName = "T7164")]
-[JsonSerializable(typeof(Cn_class_P<double[]>), TypeInfoPropertyName = "T7165")]
-[JsonSerializable(typeof(Cn_record_class_P<double[]>), TypeInfoPropertyName = "T7166")]
-[JsonSerializable(typeof(Cn_struct_P<double[]>), TypeInfoPropertyName = "T7167")]
-[JsonSerializable(typeof(Cn_record_struct_P<double[]>), TypeInfoPropertyName = "T7168")]
-[JsonSerializable(typeof(Cn_generic_type_P<double[], int>), TypeInfoPropertyName = "T7169")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<double>>), TypeInfoPropertyName = "T7170")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<double>>), TypeInfoPropertyName = "T7171")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<double>>), TypeInfoPropertyName = "T7172")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<double>>), TypeInfoPropertyName = "T7173")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<double>, int>), TypeInfoPropertyName = "T7174")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<double>>), TypeInfoPropertyName = "T7175")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<double>>), TypeInfoPropertyName = "T7176")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<double>>), TypeInfoPropertyName = "T7177")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<double>>), TypeInfoPropertyName = "T7178")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<double>, int>), TypeInfoPropertyName = "T7179")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<double, int>>), TypeInfoPropertyName = "T7180")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<double, int>>), TypeInfoPropertyName = "T7181")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<double, int>>), TypeInfoPropertyName = "T7182")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<double, int>>), TypeInfoPropertyName = "T7183")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<double, int>, int>), TypeInfoPropertyName = "T7184")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, double>>), TypeInfoPropertyName = "T7185")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, double>>), TypeInfoPropertyName = "T7186")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, double>>), TypeInfoPropertyName = "T7187")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, double>>), TypeInfoPropertyName = "T7188")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, double>, int>), TypeInfoPropertyName = "T7189")]
-[JsonSerializable(typeof(Cn_class_C<double>), TypeInfoPropertyName = "T7190")]
-[JsonSerializable(typeof(Cn_record_class_C<double>), TypeInfoPropertyName = "T7191")]
-[JsonSerializable(typeof(Cn_struct_C<double>), TypeInfoPropertyName = "T7192")]
-[JsonSerializable(typeof(Cn_record_struct_C<double>), TypeInfoPropertyName = "T7193")]
-[JsonSerializable(typeof(Cn_generic_type_C<double, int>), TypeInfoPropertyName = "T7194")]
-[JsonSerializable(typeof(Cn_class_R<double>), TypeInfoPropertyName = "T7195")]
-[JsonSerializable(typeof(Cn_record_class_R<double>), TypeInfoPropertyName = "T7196")]
-[JsonSerializable(typeof(Cn_struct_R<double>), TypeInfoPropertyName = "T7197")]
-[JsonSerializable(typeof(Cn_record_struct_R<double>), TypeInfoPropertyName = "T7198")]
-[JsonSerializable(typeof(Cn_generic_type_R<double, int>), TypeInfoPropertyName = "T7199")]
-[JsonSerializable(typeof(Cn_class_P<Patch<double>>), TypeInfoPropertyName = "T7200")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<double>>), TypeInfoPropertyName = "T7201")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<double>>), TypeInfoPropertyName = "T7202")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<double>>), TypeInfoPropertyName = "T7203")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<double>, int>), TypeInfoPropertyName = "T7204")]
-[JsonSerializable(typeof(Cn_class_P<PBP_double>), TypeInfoPropertyName = "T7205")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_double>), TypeInfoPropertyName = "T7206")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_double>), TypeInfoPropertyName = "T7207")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_double>), TypeInfoPropertyName = "T7208")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_double, int>), TypeInfoPropertyName = "T7209")]
-[JsonSerializable(typeof(bool))]
-[JsonSerializable(typeof(Cn_class_P<bool>), TypeInfoPropertyName = "T7210")]
-[JsonSerializable(typeof(Cn_record_class_P<bool>), TypeInfoPropertyName = "T7211")]
-[JsonSerializable(typeof(Cn_struct_P<bool>), TypeInfoPropertyName = "T7212")]
-[JsonSerializable(typeof(Cn_record_struct_P<bool>), TypeInfoPropertyName = "T7213")]
-[JsonSerializable(typeof(Cn_generic_type_P<bool, int>), TypeInfoPropertyName = "T7214")]
-[JsonSerializable(typeof(Cn_class_P<bool?>), TypeInfoPropertyName = "T7215")]
-[JsonSerializable(typeof(Cn_record_class_P<bool?>), TypeInfoPropertyName = "T7216")]
-[JsonSerializable(typeof(Cn_struct_P<bool?>), TypeInfoPropertyName = "T7217")]
-[JsonSerializable(typeof(Cn_record_struct_P<bool?>), TypeInfoPropertyName = "T7218")]
-[JsonSerializable(typeof(Cn_generic_type_P<bool?, int>), TypeInfoPropertyName = "T7219")]
-[JsonSerializable(typeof(Cn_class_F<bool>), TypeInfoPropertyName = "T7220")]
-[JsonSerializable(typeof(Cn_record_class_F<bool>), TypeInfoPropertyName = "T7221")]
-[JsonSerializable(typeof(Cn_struct_F<bool>), TypeInfoPropertyName = "T7222")]
-[JsonSerializable(typeof(Cn_record_struct_F<bool>), TypeInfoPropertyName = "T7223")]
-[JsonSerializable(typeof(Cn_generic_type_F<bool, int>), TypeInfoPropertyName = "T7224")]
-[JsonSerializable(typeof(Cn_class_P<List<bool>>), TypeInfoPropertyName = "T7225")]
-[JsonSerializable(typeof(Cn_record_class_P<List<bool>>), TypeInfoPropertyName = "T7226")]
-[JsonSerializable(typeof(Cn_struct_P<List<bool>>), TypeInfoPropertyName = "T7227")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<bool>>), TypeInfoPropertyName = "T7228")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<bool>, int>), TypeInfoPropertyName = "T7229")]
-[JsonSerializable(typeof(Cn_class_P<bool[]>), TypeInfoPropertyName = "T7230")]
-[JsonSerializable(typeof(Cn_record_class_P<bool[]>), TypeInfoPropertyName = "T7231")]
-[JsonSerializable(typeof(Cn_struct_P<bool[]>), TypeInfoPropertyName = "T7232")]
-[JsonSerializable(typeof(Cn_record_struct_P<bool[]>), TypeInfoPropertyName = "T7233")]
-[JsonSerializable(typeof(Cn_generic_type_P<bool[], int>), TypeInfoPropertyName = "T7234")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<bool>>), TypeInfoPropertyName = "T7235")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<bool>>), TypeInfoPropertyName = "T7236")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<bool>>), TypeInfoPropertyName = "T7237")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<bool>>), TypeInfoPropertyName = "T7238")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<bool>, int>), TypeInfoPropertyName = "T7239")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<bool>>), TypeInfoPropertyName = "T7240")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<bool>>), TypeInfoPropertyName = "T7241")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<bool>>), TypeInfoPropertyName = "T7242")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<bool>>), TypeInfoPropertyName = "T7243")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<bool>, int>), TypeInfoPropertyName = "T7244")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<bool, int>>), TypeInfoPropertyName = "T7245")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<bool, int>>), TypeInfoPropertyName = "T7246")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<bool, int>>), TypeInfoPropertyName = "T7247")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<bool, int>>), TypeInfoPropertyName = "T7248")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<bool, int>, int>), TypeInfoPropertyName = "T7249")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, bool>>), TypeInfoPropertyName = "T7250")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, bool>>), TypeInfoPropertyName = "T7251")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, bool>>), TypeInfoPropertyName = "T7252")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, bool>>), TypeInfoPropertyName = "T7253")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, bool>, int>), TypeInfoPropertyName = "T7254")]
-[JsonSerializable(typeof(Cn_class_C<bool>), TypeInfoPropertyName = "T7255")]
-[JsonSerializable(typeof(Cn_record_class_C<bool>), TypeInfoPropertyName = "T7256")]
-[JsonSerializable(typeof(Cn_struct_C<bool>), TypeInfoPropertyName = "T7257")]
-[JsonSerializable(typeof(Cn_record_struct_C<bool>), TypeInfoPropertyName = "T7258")]
-[JsonSerializable(typeof(Cn_generic_type_C<bool, int>), TypeInfoPropertyName = "T7259")]
-[JsonSerializable(typeof(Cn_class_R<bool>), TypeInfoPropertyName = "T7260")]
-[JsonSerializable(typeof(Cn_record_class_R<bool>), TypeInfoPropertyName = "T7261")]
-[JsonSerializable(typeof(Cn_struct_R<bool>), TypeInfoPropertyName = "T7262")]
-[JsonSerializable(typeof(Cn_record_struct_R<bool>), TypeInfoPropertyName = "T7263")]
-[JsonSerializable(typeof(Cn_generic_type_R<bool, int>), TypeInfoPropertyName = "T7264")]
-[JsonSerializable(typeof(Cn_class_P<Patch<bool>>), TypeInfoPropertyName = "T7265")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<bool>>), TypeInfoPropertyName = "T7266")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<bool>>), TypeInfoPropertyName = "T7267")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<bool>>), TypeInfoPropertyName = "T7268")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<bool>, int>), TypeInfoPropertyName = "T7269")]
-[JsonSerializable(typeof(Cn_class_P<PBP_bool>), TypeInfoPropertyName = "T7270")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_bool>), TypeInfoPropertyName = "T7271")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_bool>), TypeInfoPropertyName = "T7272")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_bool>), TypeInfoPropertyName = "T7273")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_bool, int>), TypeInfoPropertyName = "T7274")]
-[JsonSerializable(typeof(char))]
-[JsonSerializable(typeof(Cn_class_P<char>), TypeInfoPropertyName = "T7275")]
-[JsonSerializable(typeof(Cn_record_class_P<char>), TypeInfoPropertyName = "T7276")]
-[JsonSerializable(typeof(Cn_struct_P<char>), TypeInfoPropertyName = "T7277")]
-[JsonSerializable(typeof(Cn_record_struct_P<char>), TypeInfoPropertyName = "T7278")]
-[JsonSerializable(typeof(Cn_generic_type_P<char, int>), TypeInfoPropertyName = "T7279")]
-[JsonSerializable(typeof(Cn_class_P<char?>), TypeInfoPropertyName = "T7280")]
-[JsonSerializable(typeof(Cn_record_class_P<char?>), TypeInfoPropertyName = "T7281")]
-[JsonSerializable(typeof(Cn_struct_P<char?>), TypeInfoPropertyName = "T7282")]
-[JsonSerializable(typeof(Cn_record_struct_P<char?>), TypeInfoPropertyName = "T7283")]
-[JsonSerializable(typeof(Cn_generic_type_P<char?, int>), TypeInfoPropertyName = "T7284")]
-[JsonSerializable(typeof(Cn_class_F<char>), TypeInfoPropertyName = "T7285")]
-[JsonSerializable(typeof(Cn_record_class_F<char>), TypeInfoPropertyName = "T7286")]
-[JsonSerializable(typeof(Cn_struct_F<char>), TypeInfoPropertyName = "T7287")]
-[JsonSerializable(typeof(Cn_record_struct_F<char>), TypeInfoPropertyName = "T7288")]
-[JsonSerializable(typeof(Cn_generic_type_F<char, int>), TypeInfoPropertyName = "T7289")]
-[JsonSerializable(typeof(Cn_class_P<List<char>>), TypeInfoPropertyName = "T7290")]
-[JsonSerializable(typeof(Cn_record_class_P<List<char>>), TypeInfoPropertyName = "T7291")]
-[JsonSerializable(typeof(Cn_struct_P<List<char>>), TypeInfoPropertyName = "T7292")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<char>>), TypeInfoPropertyName = "T7293")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<char>, int>), TypeInfoPropertyName = "T7294")]
-[JsonSerializable(typeof(Cn_class_P<char[]>), TypeInfoPropertyName = "T7295")]
-[JsonSerializable(typeof(Cn_record_class_P<char[]>), TypeInfoPropertyName = "T7296")]
-[JsonSerializable(typeof(Cn_struct_P<char[]>), TypeInfoPropertyName = "T7297")]
-[JsonSerializable(typeof(Cn_record_struct_P<char[]>), TypeInfoPropertyName = "T7298")]
-[JsonSerializable(typeof(Cn_generic_type_P<char[], int>), TypeInfoPropertyName = "T7299")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<char>>), TypeInfoPropertyName = "T7300")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<char>>), TypeInfoPropertyName = "T7301")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<char>>), TypeInfoPropertyName = "T7302")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<char>>), TypeInfoPropertyName = "T7303")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<char>, int>), TypeInfoPropertyName = "T7304")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<char>>), TypeInfoPropertyName = "T7305")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<char>>), TypeInfoPropertyName = "T7306")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<char>>), TypeInfoPropertyName = "T7307")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<char>>), TypeInfoPropertyName = "T7308")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<char>, int>), TypeInfoPropertyName = "T7309")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<char, int>>), TypeInfoPropertyName = "T7310")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<char, int>>), TypeInfoPropertyName = "T7311")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<char, int>>), TypeInfoPropertyName = "T7312")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<char, int>>), TypeInfoPropertyName = "T7313")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<char, int>, int>), TypeInfoPropertyName = "T7314")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, char>>), TypeInfoPropertyName = "T7315")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, char>>), TypeInfoPropertyName = "T7316")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, char>>), TypeInfoPropertyName = "T7317")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, char>>), TypeInfoPropertyName = "T7318")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, char>, int>), TypeInfoPropertyName = "T7319")]
-[JsonSerializable(typeof(Cn_class_C<char>), TypeInfoPropertyName = "T7320")]
-[JsonSerializable(typeof(Cn_record_class_C<char>), TypeInfoPropertyName = "T7321")]
-[JsonSerializable(typeof(Cn_struct_C<char>), TypeInfoPropertyName = "T7322")]
-[JsonSerializable(typeof(Cn_record_struct_C<char>), TypeInfoPropertyName = "T7323")]
-[JsonSerializable(typeof(Cn_generic_type_C<char, int>), TypeInfoPropertyName = "T7324")]
-[JsonSerializable(typeof(Cn_class_R<char>), TypeInfoPropertyName = "T7325")]
-[JsonSerializable(typeof(Cn_record_class_R<char>), TypeInfoPropertyName = "T7326")]
-[JsonSerializable(typeof(Cn_struct_R<char>), TypeInfoPropertyName = "T7327")]
-[JsonSerializable(typeof(Cn_record_struct_R<char>), TypeInfoPropertyName = "T7328")]
-[JsonSerializable(typeof(Cn_generic_type_R<char, int>), TypeInfoPropertyName = "T7329")]
-[JsonSerializable(typeof(Cn_class_P<Patch<char>>), TypeInfoPropertyName = "T7330")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<char>>), TypeInfoPropertyName = "T7331")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<char>>), TypeInfoPropertyName = "T7332")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<char>>), TypeInfoPropertyName = "T7333")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<char>, int>), TypeInfoPropertyName = "T7334")]
-[JsonSerializable(typeof(Cn_class_P<PBP_char>), TypeInfoPropertyName = "T7335")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_char>), TypeInfoPropertyName = "T7336")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_char>), TypeInfoPropertyName = "T7337")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_char>), TypeInfoPropertyName = "T7338")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_char, int>), TypeInfoPropertyName = "T7339")]
-[JsonSerializable(typeof(DateTime))]
-[JsonSerializable(typeof(Cn_class_P<DateTime>), TypeInfoPropertyName = "T7340")]
-[JsonSerializable(typeof(Cn_record_class_P<DateTime>), TypeInfoPropertyName = "T7341")]
-[JsonSerializable(typeof(Cn_struct_P<DateTime>), TypeInfoPropertyName = "T7342")]
-[JsonSerializable(typeof(Cn_record_struct_P<DateTime>), TypeInfoPropertyName = "T7343")]
-[JsonSerializable(typeof(Cn_generic_type_P<DateTime, int>), TypeInfoPropertyName = "T7344")]
-[JsonSerializable(typeof(Cn_class_P<DateTime?>), TypeInfoPropertyName = "T7345")]
-[JsonSerializable(typeof(Cn_record_class_P<DateTime?>), TypeInfoPropertyName = "T7346")]
-[JsonSerializable(typeof(Cn_struct_P<DateTime?>), TypeInfoPropertyName = "T7347")]
-[JsonSerializable(typeof(Cn_record_struct_P<DateTime?>), TypeInfoPropertyName = "T7348")]
-[JsonSerializable(typeof(Cn_generic_type_P<DateTime?, int>), TypeInfoPropertyName = "T7349")]
-[JsonSerializable(typeof(Cn_class_F<DateTime>), TypeInfoPropertyName = "T7350")]
-[JsonSerializable(typeof(Cn_record_class_F<DateTime>), TypeInfoPropertyName = "T7351")]
-[JsonSerializable(typeof(Cn_struct_F<DateTime>), TypeInfoPropertyName = "T7352")]
-[JsonSerializable(typeof(Cn_record_struct_F<DateTime>), TypeInfoPropertyName = "T7353")]
-[JsonSerializable(typeof(Cn_generic_type_F<DateTime, int>), TypeInfoPropertyName = "T7354")]
-[JsonSerializable(typeof(Cn_class_P<List<DateTime>>), TypeInfoPropertyName = "T7355")]
-[JsonSerializable(typeof(Cn_record_class_P<List<DateTime>>), TypeInfoPropertyName = "T7356")]
-[JsonSerializable(typeof(Cn_struct_P<List<DateTime>>), TypeInfoPropertyName = "T7357")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<DateTime>>), TypeInfoPropertyName = "T7358")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<DateTime>, int>), TypeInfoPropertyName = "T7359")]
-[JsonSerializable(typeof(Cn_class_P<DateTime[]>), TypeInfoPropertyName = "T7360")]
-[JsonSerializable(typeof(Cn_record_class_P<DateTime[]>), TypeInfoPropertyName = "T7361")]
-[JsonSerializable(typeof(Cn_struct_P<DateTime[]>), TypeInfoPropertyName = "T7362")]
-[JsonSerializable(typeof(Cn_record_struct_P<DateTime[]>), TypeInfoPropertyName = "T7363")]
-[JsonSerializable(typeof(Cn_generic_type_P<DateTime[], int>), TypeInfoPropertyName = "T7364")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<DateTime>>), TypeInfoPropertyName = "T7365")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<DateTime>>), TypeInfoPropertyName = "T7366")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<DateTime>>), TypeInfoPropertyName = "T7367")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<DateTime>>), TypeInfoPropertyName = "T7368")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<DateTime>, int>), TypeInfoPropertyName = "T7369")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<DateTime>>), TypeInfoPropertyName = "T7370")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<DateTime>>), TypeInfoPropertyName = "T7371")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<DateTime>>), TypeInfoPropertyName = "T7372")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<DateTime>>), TypeInfoPropertyName = "T7373")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<DateTime>, int>), TypeInfoPropertyName = "T7374")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<DateTime, int>>), TypeInfoPropertyName = "T7375")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<DateTime, int>>), TypeInfoPropertyName = "T7376")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<DateTime, int>>), TypeInfoPropertyName = "T7377")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<DateTime, int>>), TypeInfoPropertyName = "T7378")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<DateTime, int>, int>), TypeInfoPropertyName = "T7379")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, DateTime>>), TypeInfoPropertyName = "T7380")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, DateTime>>), TypeInfoPropertyName = "T7381")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, DateTime>>), TypeInfoPropertyName = "T7382")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, DateTime>>), TypeInfoPropertyName = "T7383")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, DateTime>, int>), TypeInfoPropertyName = "T7384")]
-[JsonSerializable(typeof(Cn_class_C<DateTime>), TypeInfoPropertyName = "T7385")]
-[JsonSerializable(typeof(Cn_record_class_C<DateTime>), TypeInfoPropertyName = "T7386")]
-[JsonSerializable(typeof(Cn_struct_C<DateTime>), TypeInfoPropertyName = "T7387")]
-[JsonSerializable(typeof(Cn_record_struct_C<DateTime>), TypeInfoPropertyName = "T7388")]
-[JsonSerializable(typeof(Cn_generic_type_C<DateTime, int>), TypeInfoPropertyName = "T7389")]
-[JsonSerializable(typeof(Cn_class_R<DateTime>), TypeInfoPropertyName = "T7390")]
-[JsonSerializable(typeof(Cn_record_class_R<DateTime>), TypeInfoPropertyName = "T7391")]
-[JsonSerializable(typeof(Cn_struct_R<DateTime>), TypeInfoPropertyName = "T7392")]
-[JsonSerializable(typeof(Cn_record_struct_R<DateTime>), TypeInfoPropertyName = "T7393")]
-[JsonSerializable(typeof(Cn_generic_type_R<DateTime, int>), TypeInfoPropertyName = "T7394")]
-[JsonSerializable(typeof(Cn_class_P<Patch<DateTime>>), TypeInfoPropertyName = "T7395")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<DateTime>>), TypeInfoPropertyName = "T7396")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<DateTime>>), TypeInfoPropertyName = "T7397")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<DateTime>>), TypeInfoPropertyName = "T7398")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<DateTime>, int>), TypeInfoPropertyName = "T7399")]
-[JsonSerializable(typeof(Cn_class_P<PBP_DateTime>), TypeInfoPropertyName = "T7400")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_DateTime>), TypeInfoPropertyName = "T7401")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_DateTime>), TypeInfoPropertyName = "T7402")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_DateTime>), TypeInfoPropertyName = "T7403")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_DateTime, int>), TypeInfoPropertyName = "T7404")]
-[JsonSerializable(typeof(DateTimeOffset))]
-[JsonSerializable(typeof(Cn_class_P<DateTimeOffset>), TypeInfoPropertyName = "T7405")]
-[JsonSerializable(typeof(Cn_record_class_P<DateTimeOffset>), TypeInfoPropertyName = "T7406")]
-[JsonSerializable(typeof(Cn_struct_P<DateTimeOffset>), TypeInfoPropertyName = "T7407")]
-[JsonSerializable(typeof(Cn_record_struct_P<DateTimeOffset>), TypeInfoPropertyName = "T7408")]
-[JsonSerializable(typeof(Cn_generic_type_P<DateTimeOffset, int>), TypeInfoPropertyName = "T7409")]
-[JsonSerializable(typeof(Cn_class_P<DateTimeOffset?>), TypeInfoPropertyName = "T7410")]
-[JsonSerializable(typeof(Cn_record_class_P<DateTimeOffset?>), TypeInfoPropertyName = "T7411")]
-[JsonSerializable(typeof(Cn_struct_P<DateTimeOffset?>), TypeInfoPropertyName = "T7412")]
-[JsonSerializable(typeof(Cn_record_struct_P<DateTimeOffset?>), TypeInfoPropertyName = "T7413")]
-[JsonSerializable(typeof(Cn_generic_type_P<DateTimeOffset?, int>), TypeInfoPropertyName = "T7414")]
-[JsonSerializable(typeof(Cn_class_F<DateTimeOffset>), TypeInfoPropertyName = "T7415")]
-[JsonSerializable(typeof(Cn_record_class_F<DateTimeOffset>), TypeInfoPropertyName = "T7416")]
-[JsonSerializable(typeof(Cn_struct_F<DateTimeOffset>), TypeInfoPropertyName = "T7417")]
-[JsonSerializable(typeof(Cn_record_struct_F<DateTimeOffset>), TypeInfoPropertyName = "T7418")]
-[JsonSerializable(typeof(Cn_generic_type_F<DateTimeOffset, int>), TypeInfoPropertyName = "T7419")]
-[JsonSerializable(typeof(Cn_class_P<List<DateTimeOffset>>), TypeInfoPropertyName = "T7420")]
-[JsonSerializable(typeof(Cn_record_class_P<List<DateTimeOffset>>), TypeInfoPropertyName = "T7421")]
-[JsonSerializable(typeof(Cn_struct_P<List<DateTimeOffset>>), TypeInfoPropertyName = "T7422")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<DateTimeOffset>>), TypeInfoPropertyName = "T7423")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<DateTimeOffset>, int>), TypeInfoPropertyName = "T7424")]
-[JsonSerializable(typeof(Cn_class_P<DateTimeOffset[]>), TypeInfoPropertyName = "T7425")]
-[JsonSerializable(typeof(Cn_record_class_P<DateTimeOffset[]>), TypeInfoPropertyName = "T7426")]
-[JsonSerializable(typeof(Cn_struct_P<DateTimeOffset[]>), TypeInfoPropertyName = "T7427")]
-[JsonSerializable(typeof(Cn_record_struct_P<DateTimeOffset[]>), TypeInfoPropertyName = "T7428")]
-[JsonSerializable(typeof(Cn_generic_type_P<DateTimeOffset[], int>), TypeInfoPropertyName = "T7429")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<DateTimeOffset>>), TypeInfoPropertyName = "T7430")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<DateTimeOffset>>), TypeInfoPropertyName = "T7431")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<DateTimeOffset>>), TypeInfoPropertyName = "T7432")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<DateTimeOffset>>), TypeInfoPropertyName = "T7433")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<DateTimeOffset>, int>), TypeInfoPropertyName = "T7434")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<DateTimeOffset>>), TypeInfoPropertyName = "T7435")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<DateTimeOffset>>), TypeInfoPropertyName = "T7436")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<DateTimeOffset>>), TypeInfoPropertyName = "T7437")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<DateTimeOffset>>), TypeInfoPropertyName = "T7438")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<DateTimeOffset>, int>), TypeInfoPropertyName = "T7439")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<DateTimeOffset, int>>), TypeInfoPropertyName = "T7440")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<DateTimeOffset, int>>), TypeInfoPropertyName = "T7441")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<DateTimeOffset, int>>), TypeInfoPropertyName = "T7442")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<DateTimeOffset, int>>), TypeInfoPropertyName = "T7443")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<DateTimeOffset, int>, int>), TypeInfoPropertyName = "T7444")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, DateTimeOffset>>), TypeInfoPropertyName = "T7445")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, DateTimeOffset>>), TypeInfoPropertyName = "T7446")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, DateTimeOffset>>), TypeInfoPropertyName = "T7447")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, DateTimeOffset>>), TypeInfoPropertyName = "T7448")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, DateTimeOffset>, int>), TypeInfoPropertyName = "T7449")]
-[JsonSerializable(typeof(Cn_class_C<DateTimeOffset>), TypeInfoPropertyName = "T7450")]
-[JsonSerializable(typeof(Cn_record_class_C<DateTimeOffset>), TypeInfoPropertyName = "T7451")]
-[JsonSerializable(typeof(Cn_struct_C<DateTimeOffset>), TypeInfoPropertyName = "T7452")]
-[JsonSerializable(typeof(Cn_record_struct_C<DateTimeOffset>), TypeInfoPropertyName = "T7453")]
-[JsonSerializable(typeof(Cn_generic_type_C<DateTimeOffset, int>), TypeInfoPropertyName = "T7454")]
-[JsonSerializable(typeof(Cn_class_R<DateTimeOffset>), TypeInfoPropertyName = "T7455")]
-[JsonSerializable(typeof(Cn_record_class_R<DateTimeOffset>), TypeInfoPropertyName = "T7456")]
-[JsonSerializable(typeof(Cn_struct_R<DateTimeOffset>), TypeInfoPropertyName = "T7457")]
-[JsonSerializable(typeof(Cn_record_struct_R<DateTimeOffset>), TypeInfoPropertyName = "T7458")]
-[JsonSerializable(typeof(Cn_generic_type_R<DateTimeOffset, int>), TypeInfoPropertyName = "T7459")]
-[JsonSerializable(typeof(Cn_class_P<Patch<DateTimeOffset>>), TypeInfoPropertyName = "T7460")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<DateTimeOffset>>), TypeInfoPropertyName = "T7461")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<DateTimeOffset>>), TypeInfoPropertyName = "T7462")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<DateTimeOffset>>), TypeInfoPropertyName = "T7463")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<DateTimeOffset>, int>), TypeInfoPropertyName = "T7464")]
-[JsonSerializable(typeof(Cn_class_P<PBP_DateTimeOffset>), TypeInfoPropertyName = "T7465")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_DateTimeOffset>), TypeInfoPropertyName = "T7466")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_DateTimeOffset>), TypeInfoPropertyName = "T7467")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_DateTimeOffset>), TypeInfoPropertyName = "T7468")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_DateTimeOffset, int>), TypeInfoPropertyName = "T7469")]
-[JsonSerializable(typeof(DateOnly))]
-[JsonSerializable(typeof(Cn_class_P<DateOnly>), TypeInfoPropertyName = "T7470")]
-[JsonSerializable(typeof(Cn_record_class_P<DateOnly>), TypeInfoPropertyName = "T7471")]
-[JsonSerializable(typeof(Cn_struct_P<DateOnly>), TypeInfoPropertyName = "T7472")]
-[JsonSerializable(typeof(Cn_record_struct_P<DateOnly>), TypeInfoPropertyName = "T7473")]
-[JsonSerializable(typeof(Cn_generic_type_P<DateOnly, int>), TypeInfoPropertyName = "T7474")]
-[JsonSerializable(typeof(Cn_class_P<DateOnly?>), TypeInfoPropertyName = "T7475")]
-[JsonSerializable(typeof(Cn_record_class_P<DateOnly?>), TypeInfoPropertyName = "T7476")]
-[JsonSerializable(typeof(Cn_struct_P<DateOnly?>), TypeInfoPropertyName = "T7477")]
-[JsonSerializable(typeof(Cn_record_struct_P<DateOnly?>), TypeInfoPropertyName = "T7478")]
-[JsonSerializable(typeof(Cn_generic_type_P<DateOnly?, int>), TypeInfoPropertyName = "T7479")]
-[JsonSerializable(typeof(Cn_class_F<DateOnly>), TypeInfoPropertyName = "T7480")]
-[JsonSerializable(typeof(Cn_record_class_F<DateOnly>), TypeInfoPropertyName = "T7481")]
-[JsonSerializable(typeof(Cn_struct_F<DateOnly>), TypeInfoPropertyName = "T7482")]
-[JsonSerializable(typeof(Cn_record_struct_F<DateOnly>), TypeInfoPropertyName = "T7483")]
-[JsonSerializable(typeof(Cn_generic_type_F<DateOnly, int>), TypeInfoPropertyName = "T7484")]
-[JsonSerializable(typeof(Cn_class_P<List<DateOnly>>), TypeInfoPropertyName = "T7485")]
-[JsonSerializable(typeof(Cn_record_class_P<List<DateOnly>>), TypeInfoPropertyName = "T7486")]
-[JsonSerializable(typeof(Cn_struct_P<List<DateOnly>>), TypeInfoPropertyName = "T7487")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<DateOnly>>), TypeInfoPropertyName = "T7488")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<DateOnly>, int>), TypeInfoPropertyName = "T7489")]
-[JsonSerializable(typeof(Cn_class_P<DateOnly[]>), TypeInfoPropertyName = "T7490")]
-[JsonSerializable(typeof(Cn_record_class_P<DateOnly[]>), TypeInfoPropertyName = "T7491")]
-[JsonSerializable(typeof(Cn_struct_P<DateOnly[]>), TypeInfoPropertyName = "T7492")]
-[JsonSerializable(typeof(Cn_record_struct_P<DateOnly[]>), TypeInfoPropertyName = "T7493")]
-[JsonSerializable(typeof(Cn_generic_type_P<DateOnly[], int>), TypeInfoPropertyName = "T7494")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<DateOnly>>), TypeInfoPropertyName = "T7495")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<DateOnly>>), TypeInfoPropertyName = "T7496")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<DateOnly>>), TypeInfoPropertyName = "T7497")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<DateOnly>>), TypeInfoPropertyName = "T7498")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<DateOnly>, int>), TypeInfoPropertyName = "T7499")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<DateOnly>>), TypeInfoPropertyName = "T7500")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<DateOnly>>), TypeInfoPropertyName = "T7501")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<DateOnly>>), TypeInfoPropertyName = "T7502")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<DateOnly>>), TypeInfoPropertyName = "T7503")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<DateOnly>, int>), TypeInfoPropertyName = "T7504")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<DateOnly, int>>), TypeInfoPropertyName = "T7505")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<DateOnly, int>>), TypeInfoPropertyName = "T7506")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<DateOnly, int>>), TypeInfoPropertyName = "T7507")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<DateOnly, int>>), TypeInfoPropertyName = "T7508")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<DateOnly, int>, int>), TypeInfoPropertyName = "T7509")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, DateOnly>>), TypeInfoPropertyName = "T7510")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, DateOnly>>), TypeInfoPropertyName = "T7511")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, DateOnly>>), TypeInfoPropertyName = "T7512")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, DateOnly>>), TypeInfoPropertyName = "T7513")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, DateOnly>, int>), TypeInfoPropertyName = "T7514")]
-[JsonSerializable(typeof(Cn_class_C<DateOnly>), TypeInfoPropertyName = "T7515")]
-[JsonSerializable(typeof(Cn_record_class_C<DateOnly>), TypeInfoPropertyName = "T7516")]
-[JsonSerializable(typeof(Cn_struct_C<DateOnly>), TypeInfoPropertyName = "T7517")]
-[JsonSerializable(typeof(Cn_record_struct_C<DateOnly>), TypeInfoPropertyName = "T7518")]
-[JsonSerializable(typeof(Cn_generic_type_C<DateOnly, int>), TypeInfoPropertyName = "T7519")]
-[JsonSerializable(typeof(Cn_class_R<DateOnly>), TypeInfoPropertyName = "T7520")]
-[JsonSerializable(typeof(Cn_record_class_R<DateOnly>), TypeInfoPropertyName = "T7521")]
-[JsonSerializable(typeof(Cn_struct_R<DateOnly>), TypeInfoPropertyName = "T7522")]
-[JsonSerializable(typeof(Cn_record_struct_R<DateOnly>), TypeInfoPropertyName = "T7523")]
-[JsonSerializable(typeof(Cn_generic_type_R<DateOnly, int>), TypeInfoPropertyName = "T7524")]
-[JsonSerializable(typeof(Cn_class_P<Patch<DateOnly>>), TypeInfoPropertyName = "T7525")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<DateOnly>>), TypeInfoPropertyName = "T7526")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<DateOnly>>), TypeInfoPropertyName = "T7527")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<DateOnly>>), TypeInfoPropertyName = "T7528")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<DateOnly>, int>), TypeInfoPropertyName = "T7529")]
-[JsonSerializable(typeof(Cn_class_P<PBP_DateOnly>), TypeInfoPropertyName = "T7530")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_DateOnly>), TypeInfoPropertyName = "T7531")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_DateOnly>), TypeInfoPropertyName = "T7532")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_DateOnly>), TypeInfoPropertyName = "T7533")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_DateOnly, int>), TypeInfoPropertyName = "T7534")]
-[JsonSerializable(typeof(TimeOnly))]
-[JsonSerializable(typeof(Cn_class_P<TimeOnly>), TypeInfoPropertyName = "T7535")]
-[JsonSerializable(typeof(Cn_record_class_P<TimeOnly>), TypeInfoPropertyName = "T7536")]
-[JsonSerializable(typeof(Cn_struct_P<TimeOnly>), TypeInfoPropertyName = "T7537")]
-[JsonSerializable(typeof(Cn_record_struct_P<TimeOnly>), TypeInfoPropertyName = "T7538")]
-[JsonSerializable(typeof(Cn_generic_type_P<TimeOnly, int>), TypeInfoPropertyName = "T7539")]
-[JsonSerializable(typeof(Cn_class_P<TimeOnly?>), TypeInfoPropertyName = "T7540")]
-[JsonSerializable(typeof(Cn_record_class_P<TimeOnly?>), TypeInfoPropertyName = "T7541")]
-[JsonSerializable(typeof(Cn_struct_P<TimeOnly?>), TypeInfoPropertyName = "T7542")]
-[JsonSerializable(typeof(Cn_record_struct_P<TimeOnly?>), TypeInfoPropertyName = "T7543")]
-[JsonSerializable(typeof(Cn_generic_type_P<TimeOnly?, int>), TypeInfoPropertyName = "T7544")]
-[JsonSerializable(typeof(Cn_class_F<TimeOnly>), TypeInfoPropertyName = "T7545")]
-[JsonSerializable(typeof(Cn_record_class_F<TimeOnly>), TypeInfoPropertyName = "T7546")]
-[JsonSerializable(typeof(Cn_struct_F<TimeOnly>), TypeInfoPropertyName = "T7547")]
-[JsonSerializable(typeof(Cn_record_struct_F<TimeOnly>), TypeInfoPropertyName = "T7548")]
-[JsonSerializable(typeof(Cn_generic_type_F<TimeOnly, int>), TypeInfoPropertyName = "T7549")]
-[JsonSerializable(typeof(Cn_class_P<List<TimeOnly>>), TypeInfoPropertyName = "T7550")]
-[JsonSerializable(typeof(Cn_record_class_P<List<TimeOnly>>), TypeInfoPropertyName = "T7551")]
-[JsonSerializable(typeof(Cn_struct_P<List<TimeOnly>>), TypeInfoPropertyName = "T7552")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<TimeOnly>>), TypeInfoPropertyName = "T7553")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<TimeOnly>, int>), TypeInfoPropertyName = "T7554")]
-[JsonSerializable(typeof(Cn_class_P<TimeOnly[]>), TypeInfoPropertyName = "T7555")]
-[JsonSerializable(typeof(Cn_record_class_P<TimeOnly[]>), TypeInfoPropertyName = "T7556")]
-[JsonSerializable(typeof(Cn_struct_P<TimeOnly[]>), TypeInfoPropertyName = "T7557")]
-[JsonSerializable(typeof(Cn_record_struct_P<TimeOnly[]>), TypeInfoPropertyName = "T7558")]
-[JsonSerializable(typeof(Cn_generic_type_P<TimeOnly[], int>), TypeInfoPropertyName = "T7559")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<TimeOnly>>), TypeInfoPropertyName = "T7560")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<TimeOnly>>), TypeInfoPropertyName = "T7561")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<TimeOnly>>), TypeInfoPropertyName = "T7562")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<TimeOnly>>), TypeInfoPropertyName = "T7563")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<TimeOnly>, int>), TypeInfoPropertyName = "T7564")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<TimeOnly>>), TypeInfoPropertyName = "T7565")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<TimeOnly>>), TypeInfoPropertyName = "T7566")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<TimeOnly>>), TypeInfoPropertyName = "T7567")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<TimeOnly>>), TypeInfoPropertyName = "T7568")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<TimeOnly>, int>), TypeInfoPropertyName = "T7569")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<TimeOnly, int>>), TypeInfoPropertyName = "T7570")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<TimeOnly, int>>), TypeInfoPropertyName = "T7571")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<TimeOnly, int>>), TypeInfoPropertyName = "T7572")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<TimeOnly, int>>), TypeInfoPropertyName = "T7573")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<TimeOnly, int>, int>), TypeInfoPropertyName = "T7574")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, TimeOnly>>), TypeInfoPropertyName = "T7575")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, TimeOnly>>), TypeInfoPropertyName = "T7576")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, TimeOnly>>), TypeInfoPropertyName = "T7577")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, TimeOnly>>), TypeInfoPropertyName = "T7578")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, TimeOnly>, int>), TypeInfoPropertyName = "T7579")]
-[JsonSerializable(typeof(Cn_class_C<TimeOnly>), TypeInfoPropertyName = "T7580")]
-[JsonSerializable(typeof(Cn_record_class_C<TimeOnly>), TypeInfoPropertyName = "T7581")]
-[JsonSerializable(typeof(Cn_struct_C<TimeOnly>), TypeInfoPropertyName = "T7582")]
-[JsonSerializable(typeof(Cn_record_struct_C<TimeOnly>), TypeInfoPropertyName = "T7583")]
-[JsonSerializable(typeof(Cn_generic_type_C<TimeOnly, int>), TypeInfoPropertyName = "T7584")]
-[JsonSerializable(typeof(Cn_class_R<TimeOnly>), TypeInfoPropertyName = "T7585")]
-[JsonSerializable(typeof(Cn_record_class_R<TimeOnly>), TypeInfoPropertyName = "T7586")]
-[JsonSerializable(typeof(Cn_struct_R<TimeOnly>), TypeInfoPropertyName = "T7587")]
-[JsonSerializable(typeof(Cn_record_struct_R<TimeOnly>), TypeInfoPropertyName = "T7588")]
-[JsonSerializable(typeof(Cn_generic_type_R<TimeOnly, int>), TypeInfoPropertyName = "T7589")]
-[JsonSerializable(typeof(Cn_class_P<Patch<TimeOnly>>), TypeInfoPropertyName = "T7590")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<TimeOnly>>), TypeInfoPropertyName = "T7591")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<TimeOnly>>), TypeInfoPropertyName = "T7592")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<TimeOnly>>), TypeInfoPropertyName = "T7593")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<TimeOnly>, int>), TypeInfoPropertyName = "T7594")]
-[JsonSerializable(typeof(Cn_class_P<PBP_TimeOnly>), TypeInfoPropertyName = "T7595")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_TimeOnly>), TypeInfoPropertyName = "T7596")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_TimeOnly>), TypeInfoPropertyName = "T7597")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_TimeOnly>), TypeInfoPropertyName = "T7598")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_TimeOnly, int>), TypeInfoPropertyName = "T7599")]
-[JsonSerializable(typeof(TimeSpan))]
-[JsonSerializable(typeof(Cn_class_P<TimeSpan>), TypeInfoPropertyName = "T7600")]
-[JsonSerializable(typeof(Cn_record_class_P<TimeSpan>), TypeInfoPropertyName = "T7601")]
-[JsonSerializable(typeof(Cn_struct_P<TimeSpan>), TypeInfoPropertyName = "T7602")]
-[JsonSerializable(typeof(Cn_record_struct_P<TimeSpan>), TypeInfoPropertyName = "T7603")]
-[JsonSerializable(typeof(Cn_generic_type_P<TimeSpan, int>), TypeInfoPropertyName = "T7604")]
-[JsonSerializable(typeof(Cn_class_P<TimeSpan?>), TypeInfoPropertyName = "T7605")]
-[JsonSerializable(typeof(Cn_record_class_P<TimeSpan?>), TypeInfoPropertyName = "T7606")]
-[JsonSerializable(typeof(Cn_struct_P<TimeSpan?>), TypeInfoPropertyName = "T7607")]
-[JsonSerializable(typeof(Cn_record_struct_P<TimeSpan?>), TypeInfoPropertyName = "T7608")]
-[JsonSerializable(typeof(Cn_generic_type_P<TimeSpan?, int>), TypeInfoPropertyName = "T7609")]
-[JsonSerializable(typeof(Cn_class_F<TimeSpan>), TypeInfoPropertyName = "T7610")]
-[JsonSerializable(typeof(Cn_record_class_F<TimeSpan>), TypeInfoPropertyName = "T7611")]
-[JsonSerializable(typeof(Cn_struct_F<TimeSpan>), TypeInfoPropertyName = "T7612")]
-[JsonSerializable(typeof(Cn_record_struct_F<TimeSpan>), TypeInfoPropertyName = "T7613")]
-[JsonSerializable(typeof(Cn_generic_type_F<TimeSpan, int>), TypeInfoPropertyName = "T7614")]
-[JsonSerializable(typeof(Cn_class_P<List<TimeSpan>>), TypeInfoPropertyName = "T7615")]
-[JsonSerializable(typeof(Cn_record_class_P<List<TimeSpan>>), TypeInfoPropertyName = "T7616")]
-[JsonSerializable(typeof(Cn_struct_P<List<TimeSpan>>), TypeInfoPropertyName = "T7617")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<TimeSpan>>), TypeInfoPropertyName = "T7618")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<TimeSpan>, int>), TypeInfoPropertyName = "T7619")]
-[JsonSerializable(typeof(Cn_class_P<TimeSpan[]>), TypeInfoPropertyName = "T7620")]
-[JsonSerializable(typeof(Cn_record_class_P<TimeSpan[]>), TypeInfoPropertyName = "T7621")]
-[JsonSerializable(typeof(Cn_struct_P<TimeSpan[]>), TypeInfoPropertyName = "T7622")]
-[JsonSerializable(typeof(Cn_record_struct_P<TimeSpan[]>), TypeInfoPropertyName = "T7623")]
-[JsonSerializable(typeof(Cn_generic_type_P<TimeSpan[], int>), TypeInfoPropertyName = "T7624")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<TimeSpan>>), TypeInfoPropertyName = "T7625")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<TimeSpan>>), TypeInfoPropertyName = "T7626")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<TimeSpan>>), TypeInfoPropertyName = "T7627")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<TimeSpan>>), TypeInfoPropertyName = "T7628")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<TimeSpan>, int>), TypeInfoPropertyName = "T7629")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<TimeSpan>>), TypeInfoPropertyName = "T7630")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<TimeSpan>>), TypeInfoPropertyName = "T7631")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<TimeSpan>>), TypeInfoPropertyName = "T7632")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<TimeSpan>>), TypeInfoPropertyName = "T7633")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<TimeSpan>, int>), TypeInfoPropertyName = "T7634")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<TimeSpan, int>>), TypeInfoPropertyName = "T7635")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<TimeSpan, int>>), TypeInfoPropertyName = "T7636")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<TimeSpan, int>>), TypeInfoPropertyName = "T7637")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<TimeSpan, int>>), TypeInfoPropertyName = "T7638")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<TimeSpan, int>, int>), TypeInfoPropertyName = "T7639")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, TimeSpan>>), TypeInfoPropertyName = "T7640")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, TimeSpan>>), TypeInfoPropertyName = "T7641")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, TimeSpan>>), TypeInfoPropertyName = "T7642")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, TimeSpan>>), TypeInfoPropertyName = "T7643")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, TimeSpan>, int>), TypeInfoPropertyName = "T7644")]
-[JsonSerializable(typeof(Cn_class_C<TimeSpan>), TypeInfoPropertyName = "T7645")]
-[JsonSerializable(typeof(Cn_record_class_C<TimeSpan>), TypeInfoPropertyName = "T7646")]
-[JsonSerializable(typeof(Cn_struct_C<TimeSpan>), TypeInfoPropertyName = "T7647")]
-[JsonSerializable(typeof(Cn_record_struct_C<TimeSpan>), TypeInfoPropertyName = "T7648")]
-[JsonSerializable(typeof(Cn_generic_type_C<TimeSpan, int>), TypeInfoPropertyName = "T7649")]
-[JsonSerializable(typeof(Cn_class_R<TimeSpan>), TypeInfoPropertyName = "T7650")]
-[JsonSerializable(typeof(Cn_record_class_R<TimeSpan>), TypeInfoPropertyName = "T7651")]
-[JsonSerializable(typeof(Cn_struct_R<TimeSpan>), TypeInfoPropertyName = "T7652")]
-[JsonSerializable(typeof(Cn_record_struct_R<TimeSpan>), TypeInfoPropertyName = "T7653")]
-[JsonSerializable(typeof(Cn_generic_type_R<TimeSpan, int>), TypeInfoPropertyName = "T7654")]
-[JsonSerializable(typeof(Cn_class_P<Patch<TimeSpan>>), TypeInfoPropertyName = "T7655")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<TimeSpan>>), TypeInfoPropertyName = "T7656")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<TimeSpan>>), TypeInfoPropertyName = "T7657")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<TimeSpan>>), TypeInfoPropertyName = "T7658")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<TimeSpan>, int>), TypeInfoPropertyName = "T7659")]
-[JsonSerializable(typeof(Cn_class_P<PBP_TimeSpan>), TypeInfoPropertyName = "T7660")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_TimeSpan>), TypeInfoPropertyName = "T7661")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_TimeSpan>), TypeInfoPropertyName = "T7662")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_TimeSpan>), TypeInfoPropertyName = "T7663")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_TimeSpan, int>), TypeInfoPropertyName = "T7664")]
-[JsonSerializable(typeof(PEnum))]
-[JsonSerializable(typeof(Cn_class_P<PEnum>), TypeInfoPropertyName = "T7665")]
-[JsonSerializable(typeof(Cn_record_class_P<PEnum>), TypeInfoPropertyName = "T7666")]
-[JsonSerializable(typeof(Cn_struct_P<PEnum>), TypeInfoPropertyName = "T7667")]
-[JsonSerializable(typeof(Cn_record_struct_P<PEnum>), TypeInfoPropertyName = "T7668")]
-[JsonSerializable(typeof(Cn_generic_type_P<PEnum, int>), TypeInfoPropertyName = "T7669")]
-[JsonSerializable(typeof(Cn_class_P<PEnum?>), TypeInfoPropertyName = "T7670")]
-[JsonSerializable(typeof(Cn_record_class_P<PEnum?>), TypeInfoPropertyName = "T7671")]
-[JsonSerializable(typeof(Cn_struct_P<PEnum?>), TypeInfoPropertyName = "T7672")]
-[JsonSerializable(typeof(Cn_record_struct_P<PEnum?>), TypeInfoPropertyName = "T7673")]
-[JsonSerializable(typeof(Cn_generic_type_P<PEnum?, int>), TypeInfoPropertyName = "T7674")]
-[JsonSerializable(typeof(Cn_class_F<PEnum>), TypeInfoPropertyName = "T7675")]
-[JsonSerializable(typeof(Cn_record_class_F<PEnum>), TypeInfoPropertyName = "T7676")]
-[JsonSerializable(typeof(Cn_struct_F<PEnum>), TypeInfoPropertyName = "T7677")]
-[JsonSerializable(typeof(Cn_record_struct_F<PEnum>), TypeInfoPropertyName = "T7678")]
-[JsonSerializable(typeof(Cn_generic_type_F<PEnum, int>), TypeInfoPropertyName = "T7679")]
-[JsonSerializable(typeof(Cn_class_P<List<PEnum>>), TypeInfoPropertyName = "T7680")]
-[JsonSerializable(typeof(Cn_record_class_P<List<PEnum>>), TypeInfoPropertyName = "T7681")]
-[JsonSerializable(typeof(Cn_struct_P<List<PEnum>>), TypeInfoPropertyName = "T7682")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<PEnum>>), TypeInfoPropertyName = "T7683")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<PEnum>, int>), TypeInfoPropertyName = "T7684")]
-[JsonSerializable(typeof(Cn_class_P<PEnum[]>), TypeInfoPropertyName = "T7685")]
-[JsonSerializable(typeof(Cn_record_class_P<PEnum[]>), TypeInfoPropertyName = "T7686")]
-[JsonSerializable(typeof(Cn_struct_P<PEnum[]>), TypeInfoPropertyName = "T7687")]
-[JsonSerializable(typeof(Cn_record_struct_P<PEnum[]>), TypeInfoPropertyName = "T7688")]
-[JsonSerializable(typeof(Cn_generic_type_P<PEnum[], int>), TypeInfoPropertyName = "T7689")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<PEnum>>), TypeInfoPropertyName = "T7690")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<PEnum>>), TypeInfoPropertyName = "T7691")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<PEnum>>), TypeInfoPropertyName = "T7692")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<PEnum>>), TypeInfoPropertyName = "T7693")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<PEnum>, int>), TypeInfoPropertyName = "T7694")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<PEnum>>), TypeInfoPropertyName = "T7695")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<PEnum>>), TypeInfoPropertyName = "T7696")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<PEnum>>), TypeInfoPropertyName = "T7697")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<PEnum>>), TypeInfoPropertyName = "T7698")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<PEnum>, int>), TypeInfoPropertyName = "T7699")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<PEnum, int>>), TypeInfoPropertyName = "T7700")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<PEnum, int>>), TypeInfoPropertyName = "T7701")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<PEnum, int>>), TypeInfoPropertyName = "T7702")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<PEnum, int>>), TypeInfoPropertyName = "T7703")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<PEnum, int>, int>), TypeInfoPropertyName = "T7704")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, PEnum>>), TypeInfoPropertyName = "T7705")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, PEnum>>), TypeInfoPropertyName = "T7706")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, PEnum>>), TypeInfoPropertyName = "T7707")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, PEnum>>), TypeInfoPropertyName = "T7708")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, PEnum>, int>), TypeInfoPropertyName = "T7709")]
-[JsonSerializable(typeof(Cn_class_C<PEnum>), TypeInfoPropertyName = "T7710")]
-[JsonSerializable(typeof(Cn_record_class_C<PEnum>), TypeInfoPropertyName = "T7711")]
-[JsonSerializable(typeof(Cn_struct_C<PEnum>), TypeInfoPropertyName = "T7712")]
-[JsonSerializable(typeof(Cn_record_struct_C<PEnum>), TypeInfoPropertyName = "T7713")]
-[JsonSerializable(typeof(Cn_generic_type_C<PEnum, int>), TypeInfoPropertyName = "T7714")]
-[JsonSerializable(typeof(Cn_class_R<PEnum>), TypeInfoPropertyName = "T7715")]
-[JsonSerializable(typeof(Cn_record_class_R<PEnum>), TypeInfoPropertyName = "T7716")]
-[JsonSerializable(typeof(Cn_struct_R<PEnum>), TypeInfoPropertyName = "T7717")]
-[JsonSerializable(typeof(Cn_record_struct_R<PEnum>), TypeInfoPropertyName = "T7718")]
-[JsonSerializable(typeof(Cn_generic_type_R<PEnum, int>), TypeInfoPropertyName = "T7719")]
-[JsonSerializable(typeof(Cn_class_P<Patch<PEnum>>), TypeInfoPropertyName = "T7720")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<PEnum>>), TypeInfoPropertyName = "T7721")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<PEnum>>), TypeInfoPropertyName = "T7722")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<PEnum>>), TypeInfoPropertyName = "T7723")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<PEnum>, int>), TypeInfoPropertyName = "T7724")]
-[JsonSerializable(typeof(Cn_class_P<PBP_enum>), TypeInfoPropertyName = "T7725")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_enum>), TypeInfoPropertyName = "T7726")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_enum>), TypeInfoPropertyName = "T7727")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_enum>), TypeInfoPropertyName = "T7728")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_enum, int>), TypeInfoPropertyName = "T7729")]
-[JsonSerializable(typeof(PFlags))]
-[JsonSerializable(typeof(Cn_class_P<PFlags>), TypeInfoPropertyName = "T7730")]
-[JsonSerializable(typeof(Cn_record_class_P<PFlags>), TypeInfoPropertyName = "T7731")]
-[JsonSerializable(typeof(Cn_struct_P<PFlags>), TypeInfoPropertyName = "T7732")]
-[JsonSerializable(typeof(Cn_record_struct_P<PFlags>), TypeInfoPropertyName = "T7733")]
-[JsonSerializable(typeof(Cn_generic_type_P<PFlags, int>), TypeInfoPropertyName = "T7734")]
-[JsonSerializable(typeof(Cn_class_P<PFlags?>), TypeInfoPropertyName = "T7735")]
-[JsonSerializable(typeof(Cn_record_class_P<PFlags?>), TypeInfoPropertyName = "T7736")]
-[JsonSerializable(typeof(Cn_struct_P<PFlags?>), TypeInfoPropertyName = "T7737")]
-[JsonSerializable(typeof(Cn_record_struct_P<PFlags?>), TypeInfoPropertyName = "T7738")]
-[JsonSerializable(typeof(Cn_generic_type_P<PFlags?, int>), TypeInfoPropertyName = "T7739")]
-[JsonSerializable(typeof(Cn_class_F<PFlags>), TypeInfoPropertyName = "T7740")]
-[JsonSerializable(typeof(Cn_record_class_F<PFlags>), TypeInfoPropertyName = "T7741")]
-[JsonSerializable(typeof(Cn_struct_F<PFlags>), TypeInfoPropertyName = "T7742")]
-[JsonSerializable(typeof(Cn_record_struct_F<PFlags>), TypeInfoPropertyName = "T7743")]
-[JsonSerializable(typeof(Cn_generic_type_F<PFlags, int>), TypeInfoPropertyName = "T7744")]
-[JsonSerializable(typeof(Cn_class_P<List<PFlags>>), TypeInfoPropertyName = "T7745")]
-[JsonSerializable(typeof(Cn_record_class_P<List<PFlags>>), TypeInfoPropertyName = "T7746")]
-[JsonSerializable(typeof(Cn_struct_P<List<PFlags>>), TypeInfoPropertyName = "T7747")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<PFlags>>), TypeInfoPropertyName = "T7748")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<PFlags>, int>), TypeInfoPropertyName = "T7749")]
-[JsonSerializable(typeof(Cn_class_P<PFlags[]>), TypeInfoPropertyName = "T7750")]
-[JsonSerializable(typeof(Cn_record_class_P<PFlags[]>), TypeInfoPropertyName = "T7751")]
-[JsonSerializable(typeof(Cn_struct_P<PFlags[]>), TypeInfoPropertyName = "T7752")]
-[JsonSerializable(typeof(Cn_record_struct_P<PFlags[]>), TypeInfoPropertyName = "T7753")]
-[JsonSerializable(typeof(Cn_generic_type_P<PFlags[], int>), TypeInfoPropertyName = "T7754")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<PFlags>>), TypeInfoPropertyName = "T7755")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<PFlags>>), TypeInfoPropertyName = "T7756")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<PFlags>>), TypeInfoPropertyName = "T7757")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<PFlags>>), TypeInfoPropertyName = "T7758")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<PFlags>, int>), TypeInfoPropertyName = "T7759")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<PFlags>>), TypeInfoPropertyName = "T7760")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<PFlags>>), TypeInfoPropertyName = "T7761")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<PFlags>>), TypeInfoPropertyName = "T7762")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<PFlags>>), TypeInfoPropertyName = "T7763")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<PFlags>, int>), TypeInfoPropertyName = "T7764")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<PFlags, int>>), TypeInfoPropertyName = "T7765")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<PFlags, int>>), TypeInfoPropertyName = "T7766")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<PFlags, int>>), TypeInfoPropertyName = "T7767")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<PFlags, int>>), TypeInfoPropertyName = "T7768")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<PFlags, int>, int>), TypeInfoPropertyName = "T7769")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, PFlags>>), TypeInfoPropertyName = "T7770")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, PFlags>>), TypeInfoPropertyName = "T7771")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, PFlags>>), TypeInfoPropertyName = "T7772")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, PFlags>>), TypeInfoPropertyName = "T7773")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, PFlags>, int>), TypeInfoPropertyName = "T7774")]
-[JsonSerializable(typeof(Cn_class_C<PFlags>), TypeInfoPropertyName = "T7775")]
-[JsonSerializable(typeof(Cn_record_class_C<PFlags>), TypeInfoPropertyName = "T7776")]
-[JsonSerializable(typeof(Cn_struct_C<PFlags>), TypeInfoPropertyName = "T7777")]
-[JsonSerializable(typeof(Cn_record_struct_C<PFlags>), TypeInfoPropertyName = "T7778")]
-[JsonSerializable(typeof(Cn_generic_type_C<PFlags, int>), TypeInfoPropertyName = "T7779")]
-[JsonSerializable(typeof(Cn_class_R<PFlags>), TypeInfoPropertyName = "T7780")]
-[JsonSerializable(typeof(Cn_record_class_R<PFlags>), TypeInfoPropertyName = "T7781")]
-[JsonSerializable(typeof(Cn_struct_R<PFlags>), TypeInfoPropertyName = "T7782")]
-[JsonSerializable(typeof(Cn_record_struct_R<PFlags>), TypeInfoPropertyName = "T7783")]
-[JsonSerializable(typeof(Cn_generic_type_R<PFlags, int>), TypeInfoPropertyName = "T7784")]
-[JsonSerializable(typeof(Cn_class_P<Patch<PFlags>>), TypeInfoPropertyName = "T7785")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<PFlags>>), TypeInfoPropertyName = "T7786")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<PFlags>>), TypeInfoPropertyName = "T7787")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<PFlags>>), TypeInfoPropertyName = "T7788")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<PFlags>, int>), TypeInfoPropertyName = "T7789")]
-[JsonSerializable(typeof(Cn_class_P<PBP_flags_enum>), TypeInfoPropertyName = "T7790")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_flags_enum>), TypeInfoPropertyName = "T7791")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_flags_enum>), TypeInfoPropertyName = "T7792")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_flags_enum>), TypeInfoPropertyName = "T7793")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_flags_enum, int>), TypeInfoPropertyName = "T7794")]
-[JsonSerializable(typeof(Uri))]
-[JsonSerializable(typeof(Cn_class_P<Uri>), TypeInfoPropertyName = "T7795")]
-[JsonSerializable(typeof(Cn_record_class_P<Uri>), TypeInfoPropertyName = "T7796")]
-[JsonSerializable(typeof(Cn_struct_P<Uri>), TypeInfoPropertyName = "T7797")]
-[JsonSerializable(typeof(Cn_record_struct_P<Uri>), TypeInfoPropertyName = "T7798")]
-[JsonSerializable(typeof(Cn_generic_type_P<Uri, int>), TypeInfoPropertyName = "T7799")]
-[JsonSerializable(typeof(Cn_class_F<Uri>), TypeInfoPropertyName = "T7800")]
-[JsonSerializable(typeof(Cn_record_class_F<Uri>), TypeInfoPropertyName = "T7801")]
-[JsonSerializable(typeof(Cn_struct_F<Uri>), TypeInfoPropertyName = "T7802")]
-[JsonSerializable(typeof(Cn_record_struct_F<Uri>), TypeInfoPropertyName = "T7803")]
-[JsonSerializable(typeof(Cn_generic_type_F<Uri, int>), TypeInfoPropertyName = "T7804")]
-[JsonSerializable(typeof(Cn_class_P<List<Uri>>), TypeInfoPropertyName = "T7805")]
-[JsonSerializable(typeof(Cn_record_class_P<List<Uri>>), TypeInfoPropertyName = "T7806")]
-[JsonSerializable(typeof(Cn_struct_P<List<Uri>>), TypeInfoPropertyName = "T7807")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<Uri>>), TypeInfoPropertyName = "T7808")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<Uri>, int>), TypeInfoPropertyName = "T7809")]
-[JsonSerializable(typeof(Cn_class_P<Uri[]>), TypeInfoPropertyName = "T7810")]
-[JsonSerializable(typeof(Cn_record_class_P<Uri[]>), TypeInfoPropertyName = "T7811")]
-[JsonSerializable(typeof(Cn_struct_P<Uri[]>), TypeInfoPropertyName = "T7812")]
-[JsonSerializable(typeof(Cn_record_struct_P<Uri[]>), TypeInfoPropertyName = "T7813")]
-[JsonSerializable(typeof(Cn_generic_type_P<Uri[], int>), TypeInfoPropertyName = "T7814")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<Uri>>), TypeInfoPropertyName = "T7815")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<Uri>>), TypeInfoPropertyName = "T7816")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<Uri>>), TypeInfoPropertyName = "T7817")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<Uri>>), TypeInfoPropertyName = "T7818")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<Uri>, int>), TypeInfoPropertyName = "T7819")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<Uri>>), TypeInfoPropertyName = "T7820")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<Uri>>), TypeInfoPropertyName = "T7821")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<Uri>>), TypeInfoPropertyName = "T7822")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<Uri>>), TypeInfoPropertyName = "T7823")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<Uri>, int>), TypeInfoPropertyName = "T7824")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<Uri, int>>), TypeInfoPropertyName = "T7825")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<Uri, int>>), TypeInfoPropertyName = "T7826")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<Uri, int>>), TypeInfoPropertyName = "T7827")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<Uri, int>>), TypeInfoPropertyName = "T7828")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<Uri, int>, int>), TypeInfoPropertyName = "T7829")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, Uri>>), TypeInfoPropertyName = "T7830")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, Uri>>), TypeInfoPropertyName = "T7831")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, Uri>>), TypeInfoPropertyName = "T7832")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, Uri>>), TypeInfoPropertyName = "T7833")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, Uri>, int>), TypeInfoPropertyName = "T7834")]
-[JsonSerializable(typeof(Cn_class_C<Uri>), TypeInfoPropertyName = "T7835")]
-[JsonSerializable(typeof(Cn_record_class_C<Uri>), TypeInfoPropertyName = "T7836")]
-[JsonSerializable(typeof(Cn_struct_C<Uri>), TypeInfoPropertyName = "T7837")]
-[JsonSerializable(typeof(Cn_record_struct_C<Uri>), TypeInfoPropertyName = "T7838")]
-[JsonSerializable(typeof(Cn_generic_type_C<Uri, int>), TypeInfoPropertyName = "T7839")]
-[JsonSerializable(typeof(Cn_class_R<Uri>), TypeInfoPropertyName = "T7840")]
-[JsonSerializable(typeof(Cn_record_class_R<Uri>), TypeInfoPropertyName = "T7841")]
-[JsonSerializable(typeof(Cn_struct_R<Uri>), TypeInfoPropertyName = "T7842")]
-[JsonSerializable(typeof(Cn_record_struct_R<Uri>), TypeInfoPropertyName = "T7843")]
-[JsonSerializable(typeof(Cn_generic_type_R<Uri, int>), TypeInfoPropertyName = "T7844")]
-[JsonSerializable(typeof(Cn_class_P<Patch<Uri>>), TypeInfoPropertyName = "T7845")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<Uri>>), TypeInfoPropertyName = "T7846")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<Uri>>), TypeInfoPropertyName = "T7847")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<Uri>>), TypeInfoPropertyName = "T7848")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<Uri>, int>), TypeInfoPropertyName = "T7849")]
-[JsonSerializable(typeof(Cn_class_P<PBP_Uri>), TypeInfoPropertyName = "T7850")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_Uri>), TypeInfoPropertyName = "T7851")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_Uri>), TypeInfoPropertyName = "T7852")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_Uri>), TypeInfoPropertyName = "T7853")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_Uri, int>), TypeInfoPropertyName = "T7854")]
-[JsonSerializable(typeof(global::NodaTime.Instant))]
-[JsonSerializable(typeof(Cn_class_P<global::NodaTime.Instant>), TypeInfoPropertyName = "T7855")]
-[JsonSerializable(typeof(Cn_record_class_P<global::NodaTime.Instant>), TypeInfoPropertyName = "T7856")]
-[JsonSerializable(typeof(Cn_struct_P<global::NodaTime.Instant>), TypeInfoPropertyName = "T7857")]
-[JsonSerializable(typeof(Cn_record_struct_P<global::NodaTime.Instant>), TypeInfoPropertyName = "T7858")]
-[JsonSerializable(typeof(Cn_generic_type_P<global::NodaTime.Instant, int>), TypeInfoPropertyName = "T7859")]
-[JsonSerializable(typeof(Cn_class_P<global::NodaTime.Instant?>), TypeInfoPropertyName = "T7860")]
-[JsonSerializable(typeof(Cn_record_class_P<global::NodaTime.Instant?>), TypeInfoPropertyName = "T7861")]
-[JsonSerializable(typeof(Cn_struct_P<global::NodaTime.Instant?>), TypeInfoPropertyName = "T7862")]
-[JsonSerializable(typeof(Cn_record_struct_P<global::NodaTime.Instant?>), TypeInfoPropertyName = "T7863")]
-[JsonSerializable(typeof(Cn_generic_type_P<global::NodaTime.Instant?, int>), TypeInfoPropertyName = "T7864")]
-[JsonSerializable(typeof(Cn_class_F<global::NodaTime.Instant>), TypeInfoPropertyName = "T7865")]
-[JsonSerializable(typeof(Cn_record_class_F<global::NodaTime.Instant>), TypeInfoPropertyName = "T7866")]
-[JsonSerializable(typeof(Cn_struct_F<global::NodaTime.Instant>), TypeInfoPropertyName = "T7867")]
-[JsonSerializable(typeof(Cn_record_struct_F<global::NodaTime.Instant>), TypeInfoPropertyName = "T7868")]
-[JsonSerializable(typeof(Cn_generic_type_F<global::NodaTime.Instant, int>), TypeInfoPropertyName = "T7869")]
-[JsonSerializable(typeof(Cn_class_P<List<global::NodaTime.Instant>>), TypeInfoPropertyName = "T7870")]
-[JsonSerializable(typeof(Cn_record_class_P<List<global::NodaTime.Instant>>), TypeInfoPropertyName = "T7871")]
-[JsonSerializable(typeof(Cn_struct_P<List<global::NodaTime.Instant>>), TypeInfoPropertyName = "T7872")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<global::NodaTime.Instant>>), TypeInfoPropertyName = "T7873")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<global::NodaTime.Instant>, int>), TypeInfoPropertyName = "T7874")]
-[JsonSerializable(typeof(Cn_class_P<global::NodaTime.Instant[]>), TypeInfoPropertyName = "T7875")]
-[JsonSerializable(typeof(Cn_record_class_P<global::NodaTime.Instant[]>), TypeInfoPropertyName = "T7876")]
-[JsonSerializable(typeof(Cn_struct_P<global::NodaTime.Instant[]>), TypeInfoPropertyName = "T7877")]
-[JsonSerializable(typeof(Cn_record_struct_P<global::NodaTime.Instant[]>), TypeInfoPropertyName = "T7878")]
-[JsonSerializable(typeof(Cn_generic_type_P<global::NodaTime.Instant[], int>), TypeInfoPropertyName = "T7879")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<global::NodaTime.Instant>>), TypeInfoPropertyName = "T7880")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<global::NodaTime.Instant>>), TypeInfoPropertyName = "T7881")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<global::NodaTime.Instant>>), TypeInfoPropertyName = "T7882")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<global::NodaTime.Instant>>), TypeInfoPropertyName = "T7883")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<global::NodaTime.Instant>, int>), TypeInfoPropertyName = "T7884")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<global::NodaTime.Instant>>), TypeInfoPropertyName = "T7885")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<global::NodaTime.Instant>>), TypeInfoPropertyName = "T7886")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<global::NodaTime.Instant>>), TypeInfoPropertyName = "T7887")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<global::NodaTime.Instant>>), TypeInfoPropertyName = "T7888")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<global::NodaTime.Instant>, int>), TypeInfoPropertyName = "T7889")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<global::NodaTime.Instant, int>>), TypeInfoPropertyName = "T7890")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<global::NodaTime.Instant, int>>), TypeInfoPropertyName = "T7891")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<global::NodaTime.Instant, int>>), TypeInfoPropertyName = "T7892")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<global::NodaTime.Instant, int>>), TypeInfoPropertyName = "T7893")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<global::NodaTime.Instant, int>, int>), TypeInfoPropertyName = "T7894")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, global::NodaTime.Instant>>), TypeInfoPropertyName = "T7895")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, global::NodaTime.Instant>>), TypeInfoPropertyName = "T7896")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, global::NodaTime.Instant>>), TypeInfoPropertyName = "T7897")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, global::NodaTime.Instant>>), TypeInfoPropertyName = "T7898")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, global::NodaTime.Instant>, int>), TypeInfoPropertyName = "T7899")]
-[JsonSerializable(typeof(Cn_class_C<global::NodaTime.Instant>), TypeInfoPropertyName = "T7900")]
-[JsonSerializable(typeof(Cn_record_class_C<global::NodaTime.Instant>), TypeInfoPropertyName = "T7901")]
-[JsonSerializable(typeof(Cn_struct_C<global::NodaTime.Instant>), TypeInfoPropertyName = "T7902")]
-[JsonSerializable(typeof(Cn_record_struct_C<global::NodaTime.Instant>), TypeInfoPropertyName = "T7903")]
-[JsonSerializable(typeof(Cn_generic_type_C<global::NodaTime.Instant, int>), TypeInfoPropertyName = "T7904")]
-[JsonSerializable(typeof(Cn_class_R<global::NodaTime.Instant>), TypeInfoPropertyName = "T7905")]
-[JsonSerializable(typeof(Cn_record_class_R<global::NodaTime.Instant>), TypeInfoPropertyName = "T7906")]
-[JsonSerializable(typeof(Cn_struct_R<global::NodaTime.Instant>), TypeInfoPropertyName = "T7907")]
-[JsonSerializable(typeof(Cn_record_struct_R<global::NodaTime.Instant>), TypeInfoPropertyName = "T7908")]
-[JsonSerializable(typeof(Cn_generic_type_R<global::NodaTime.Instant, int>), TypeInfoPropertyName = "T7909")]
-[JsonSerializable(typeof(Cn_class_P<Patch<global::NodaTime.Instant>>), TypeInfoPropertyName = "T7910")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<global::NodaTime.Instant>>), TypeInfoPropertyName = "T7911")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<global::NodaTime.Instant>>), TypeInfoPropertyName = "T7912")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<global::NodaTime.Instant>>), TypeInfoPropertyName = "T7913")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<global::NodaTime.Instant>, int>), TypeInfoPropertyName = "T7914")]
-[JsonSerializable(typeof(Cn_class_P<PBP_NodaTime_Instant>), TypeInfoPropertyName = "T7915")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_NodaTime_Instant>), TypeInfoPropertyName = "T7916")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_NodaTime_Instant>), TypeInfoPropertyName = "T7917")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_NodaTime_Instant>), TypeInfoPropertyName = "T7918")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_NodaTime_Instant, int>), TypeInfoPropertyName = "T7919")]
-[JsonSerializable(typeof(PRec))]
-[JsonSerializable(typeof(Cn_class_P<PRec>), TypeInfoPropertyName = "T7920")]
-[JsonSerializable(typeof(Cn_record_class_P<PRec>), TypeInfoPropertyName = "T7921")]
-[JsonSerializable(typeof(Cn_struct_P<PRec>), TypeInfoPropertyName = "T7922")]
-[JsonSerializable(typeof(Cn_record_struct_P<PRec>), TypeInfoPropertyName = "T7923")]
-[JsonSerializable(typeof(Cn_generic_type_P<PRec, int>), TypeInfoPropertyName = "T7924")]
-[JsonSerializable(typeof(Cn_class_F<PRec>), TypeInfoPropertyName = "T7925")]
-[JsonSerializable(typeof(Cn_record_class_F<PRec>), TypeInfoPropertyName = "T7926")]
-[JsonSerializable(typeof(Cn_struct_F<PRec>), TypeInfoPropertyName = "T7927")]
-[JsonSerializable(typeof(Cn_record_struct_F<PRec>), TypeInfoPropertyName = "T7928")]
-[JsonSerializable(typeof(Cn_generic_type_F<PRec, int>), TypeInfoPropertyName = "T7929")]
-[JsonSerializable(typeof(Cn_class_P<List<PRec>>), TypeInfoPropertyName = "T7930")]
-[JsonSerializable(typeof(Cn_record_class_P<List<PRec>>), TypeInfoPropertyName = "T7931")]
-[JsonSerializable(typeof(Cn_struct_P<List<PRec>>), TypeInfoPropertyName = "T7932")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<PRec>>), TypeInfoPropertyName = "T7933")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<PRec>, int>), TypeInfoPropertyName = "T7934")]
-[JsonSerializable(typeof(Cn_class_P<PRec[]>), TypeInfoPropertyName = "T7935")]
-[JsonSerializable(typeof(Cn_record_class_P<PRec[]>), TypeInfoPropertyName = "T7936")]
-[JsonSerializable(typeof(Cn_struct_P<PRec[]>), TypeInfoPropertyName = "T7937")]
-[JsonSerializable(typeof(Cn_record_struct_P<PRec[]>), TypeInfoPropertyName = "T7938")]
-[JsonSerializable(typeof(Cn_generic_type_P<PRec[], int>), TypeInfoPropertyName = "T7939")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<PRec>>), TypeInfoPropertyName = "T7940")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<PRec>>), TypeInfoPropertyName = "T7941")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<PRec>>), TypeInfoPropertyName = "T7942")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<PRec>>), TypeInfoPropertyName = "T7943")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<PRec>, int>), TypeInfoPropertyName = "T7944")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<PRec>>), TypeInfoPropertyName = "T7945")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<PRec>>), TypeInfoPropertyName = "T7946")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<PRec>>), TypeInfoPropertyName = "T7947")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<PRec>>), TypeInfoPropertyName = "T7948")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<PRec>, int>), TypeInfoPropertyName = "T7949")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<PRec, int>>), TypeInfoPropertyName = "T7950")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<PRec, int>>), TypeInfoPropertyName = "T7951")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<PRec, int>>), TypeInfoPropertyName = "T7952")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<PRec, int>>), TypeInfoPropertyName = "T7953")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<PRec, int>, int>), TypeInfoPropertyName = "T7954")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, PRec>>), TypeInfoPropertyName = "T7955")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, PRec>>), TypeInfoPropertyName = "T7956")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, PRec>>), TypeInfoPropertyName = "T7957")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, PRec>>), TypeInfoPropertyName = "T7958")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, PRec>, int>), TypeInfoPropertyName = "T7959")]
-[JsonSerializable(typeof(Cn_class_C<PRec>), TypeInfoPropertyName = "T7960")]
-[JsonSerializable(typeof(Cn_record_class_C<PRec>), TypeInfoPropertyName = "T7961")]
-[JsonSerializable(typeof(Cn_struct_C<PRec>), TypeInfoPropertyName = "T7962")]
-[JsonSerializable(typeof(Cn_record_struct_C<PRec>), TypeInfoPropertyName = "T7963")]
-[JsonSerializable(typeof(Cn_generic_type_C<PRec, int>), TypeInfoPropertyName = "T7964")]
-[JsonSerializable(typeof(Cn_class_R<PRec>), TypeInfoPropertyName = "T7965")]
-[JsonSerializable(typeof(Cn_record_class_R<PRec>), TypeInfoPropertyName = "T7966")]
-[JsonSerializable(typeof(Cn_struct_R<PRec>), TypeInfoPropertyName = "T7967")]
-[JsonSerializable(typeof(Cn_record_struct_R<PRec>), TypeInfoPropertyName = "T7968")]
-[JsonSerializable(typeof(Cn_generic_type_R<PRec, int>), TypeInfoPropertyName = "T7969")]
-[JsonSerializable(typeof(Cn_class_P<Patch<PRec>>), TypeInfoPropertyName = "T7970")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<PRec>>), TypeInfoPropertyName = "T7971")]
-[JsonSerializable(typeof(Cn_struct_P<Patch<PRec>>), TypeInfoPropertyName = "T7972")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<PRec>>), TypeInfoPropertyName = "T7973")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<PRec>, int>), TypeInfoPropertyName = "T7974")]
-[JsonSerializable(typeof(Cn_class_P<PBP_own_record_class>), TypeInfoPropertyName = "T7975")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_own_record_class>), TypeInfoPropertyName = "T7976")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_own_record_class>), TypeInfoPropertyName = "T7977")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_own_record_class>), TypeInfoPropertyName = "T7978")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_own_record_class, int>), TypeInfoPropertyName = "T7979")]
-[JsonSerializable(typeof(Guid?), TypeInfoPropertyName = "T7980")]
-[JsonSerializable(typeof(Cn_class_F<Guid?>), TypeInfoPropertyName = "T7981")]
-[JsonSerializable(typeof(Cn_record_class_F<Guid?>), TypeInfoPropertyName = "T7982")]
-[JsonSerializable(typeof(Cn_struct_F<Guid?>), TypeInfoPropertyName = "T7983")]
-[JsonSerializable(typeof(Cn_record_struct_F<Guid?>), TypeInfoPropertyName = "T7984")]
-[JsonSerializable(typeof(Cn_generic_type_F<Guid?, int>), TypeInfoPropertyName = "T7985")]
-[JsonSerializable(typeof(Cn_class_P<List<Guid?>>), TypeInfoPropertyName = "T7986")]
-[JsonSerializable(typeof(Cn_record_class_P<List<Guid?>>), TypeInfoPropertyName = "T7987")]
-[JsonSerializable(typeof(Cn_struct_P<List<Guid?>>), TypeInfoPropertyName = "T7988")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<Guid?>>), TypeInfoPropertyName = "T7989")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<Guid?>, int>), TypeInfoPropertyName = "T7990")]
-[JsonSerializable(typeof(Cn_class_P<Guid?[]>), TypeInfoPropertyName = "T7991")]
-[JsonSerializable(typeof(Cn_record_class_P<Guid?[]>), TypeInfoPropertyName = "T7992")]
-[JsonSerializable(typeof(Cn_struct_P<Guid?[]>), TypeInfoPropertyName = "T7993")]
-[JsonSerializable(typeof(Cn_record_struct_P<Guid?[]>), TypeInfoPropertyName = "T7994")]
-[JsonSerializable(typeof(Cn_generic_type_P<Guid?[], int>), TypeInfoPropertyName = "T7995")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<Guid?>>), TypeInfoPropertyName = "T7996")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<Guid?>>), TypeInfoPropertyName = "T7997")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<Guid?>>), TypeInfoPropertyName = "T7998")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<Guid?>>), TypeInfoPropertyName = "T7999")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<Guid?>, int>), TypeInfoPropertyName = "T8000")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<Guid?>>), TypeInfoPropertyName = "T8001")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<Guid?>>), TypeInfoPropertyName = "T8002")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<Guid?>>), TypeInfoPropertyName = "T8003")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<Guid?>>), TypeInfoPropertyName = "T8004")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<Guid?>, int>), TypeInfoPropertyName = "T8005")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, Guid?>>), TypeInfoPropertyName = "T8006")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, Guid?>>), TypeInfoPropertyName = "T8007")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, Guid?>>), TypeInfoPropertyName = "T8008")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, Guid?>>), TypeInfoPropertyName = "T8009")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, Guid?>, int>), TypeInfoPropertyName = "T8010")]
-[JsonSerializable(typeof(Cn_class_C<Guid?>), TypeInfoPropertyName = "T8011")]
-[JsonSerializable(typeof(Cn_record_class_C<Guid?>), TypeInfoPropertyName = "T8012")]
-[JsonSerializable(typeof(Cn_struct_C<Guid?>), TypeInfoPropertyName = "T8013")]
-[JsonSerializable(typeof(Cn_record_struct_C<Guid?>), TypeInfoPropertyName = "T8014")]
-[JsonSerializable(typeof(Cn_generic_type_C<Guid?, int>), TypeInfoPropertyName = "T8015")]
-[JsonSerializable(typeof(Cn_class_R<Guid?>), TypeInfoPropertyName = "T8016")]
-[JsonSerializable(typeof(Cn_record_class_R<Guid?>), TypeInfoPropertyName = "T8017")]
-[JsonSerializable(typeof(Cn_struct_R<Guid?>), TypeInfoPropertyName = "T8018")]
-[JsonSerializable(typeof(Cn_record_struct_R<Guid?>), TypeInfoPropertyName = "T8019")]
-[JsonSerializable(typeof(Cn_generic_type_R<Guid?, int>), TypeInfoPropertyName = "T8020")]
-[JsonSerializable(typeof(Cn_class_P<PBP_Guid_N>), TypeInfoPropertyName = "T8021")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_Guid_N>), TypeInfoPropertyName = "T8022")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_Guid_N>), TypeInfoPropertyName = "T8023")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_Guid_N>), TypeInfoPropertyName = "T8024")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_Guid_N, int>), TypeInfoPropertyName = "T8025")]
-[JsonSerializable(typeof(int?), TypeInfoPropertyName = "T8026")]
-[JsonSerializable(typeof(Cn_class_F<int?>), TypeInfoPropertyName = "T8027")]
-[JsonSerializable(typeof(Cn_record_class_F<int?>), TypeInfoPropertyName = "T8028")]
-[JsonSerializable(typeof(Cn_struct_F<int?>), TypeInfoPropertyName = "T8029")]
-[JsonSerializable(typeof(Cn_record_struct_F<int?>), TypeInfoPropertyName = "T8030")]
-[JsonSerializable(typeof(Cn_generic_type_F<int?, int>), TypeInfoPropertyName = "T8031")]
-[JsonSerializable(typeof(Cn_class_P<List<int?>>), TypeInfoPropertyName = "T8032")]
-[JsonSerializable(typeof(Cn_record_class_P<List<int?>>), TypeInfoPropertyName = "T8033")]
-[JsonSerializable(typeof(Cn_struct_P<List<int?>>), TypeInfoPropertyName = "T8034")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<int?>>), TypeInfoPropertyName = "T8035")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<int?>, int>), TypeInfoPropertyName = "T8036")]
-[JsonSerializable(typeof(Cn_class_P<int?[]>), TypeInfoPropertyName = "T8037")]
-[JsonSerializable(typeof(Cn_record_class_P<int?[]>), TypeInfoPropertyName = "T8038")]
-[JsonSerializable(typeof(Cn_struct_P<int?[]>), TypeInfoPropertyName = "T8039")]
-[JsonSerializable(typeof(Cn_record_struct_P<int?[]>), TypeInfoPropertyName = "T8040")]
-[JsonSerializable(typeof(Cn_generic_type_P<int?[], int>), TypeInfoPropertyName = "T8041")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<int?>>), TypeInfoPropertyName = "T8042")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<int?>>), TypeInfoPropertyName = "T8043")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<int?>>), TypeInfoPropertyName = "T8044")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<int?>>), TypeInfoPropertyName = "T8045")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<int?>, int>), TypeInfoPropertyName = "T8046")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<int?>>), TypeInfoPropertyName = "T8047")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<int?>>), TypeInfoPropertyName = "T8048")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<int?>>), TypeInfoPropertyName = "T8049")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<int?>>), TypeInfoPropertyName = "T8050")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<int?>, int>), TypeInfoPropertyName = "T8051")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, int?>>), TypeInfoPropertyName = "T8052")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, int?>>), TypeInfoPropertyName = "T8053")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, int?>>), TypeInfoPropertyName = "T8054")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, int?>>), TypeInfoPropertyName = "T8055")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, int?>, int>), TypeInfoPropertyName = "T8056")]
-[JsonSerializable(typeof(Cn_class_C<int?>), TypeInfoPropertyName = "T8057")]
-[JsonSerializable(typeof(Cn_record_class_C<int?>), TypeInfoPropertyName = "T8058")]
-[JsonSerializable(typeof(Cn_struct_C<int?>), TypeInfoPropertyName = "T8059")]
-[JsonSerializable(typeof(Cn_record_struct_C<int?>), TypeInfoPropertyName = "T8060")]
-[JsonSerializable(typeof(Cn_generic_type_C<int?, int>), TypeInfoPropertyName = "T8061")]
-[JsonSerializable(typeof(Cn_class_R<int?>), TypeInfoPropertyName = "T8062")]
-[JsonSerializable(typeof(Cn_record_class_R<int?>), TypeInfoPropertyName = "T8063")]
-[JsonSerializable(typeof(Cn_struct_R<int?>), TypeInfoPropertyName = "T8064")]
-[JsonSerializable(typeof(Cn_record_struct_R<int?>), TypeInfoPropertyName = "T8065")]
-[JsonSerializable(typeof(Cn_generic_type_R<int?, int>), TypeInfoPropertyName = "T8066")]
-[JsonSerializable(typeof(Cn_class_P<PBP_int_N>), TypeInfoPropertyName = "T8067")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_int_N>), TypeInfoPropertyName = "T8068")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_int_N>), TypeInfoPropertyName = "T8069")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_int_N>), TypeInfoPropertyName = "T8070")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_int_N, int>), TypeInfoPropertyName = "T8071")]
-[JsonSerializable(typeof(long?), TypeInfoPropertyName = "T8072")]
-[JsonSerializable(typeof(Cn_class_F<long?>), TypeInfoPropertyName = "T8073")]
-[JsonSerializable(typeof(Cn_record_class_F<long?>), TypeInfoPropertyName = "T8074")]
-[JsonSerializable(typeof(Cn_struct_F<long?>), TypeInfoPropertyName = "T8075")]
-[JsonSerializable(typeof(Cn_record_struct_F<long?>), TypeInfoPropertyName = "T8076")]
-[JsonSerializable(typeof(Cn_generic_type_F<long?, int>), TypeInfoPropertyName = "T8077")]
-[JsonSerializable(typeof(Cn_class_P<List<long?>>), TypeInfoPropertyName = "T8078")]
-[JsonSerializable(typeof(Cn_record_class_P<List<long?>>), TypeInfoPropertyName = "T8079")]
-[JsonSerializable(typeof(Cn_struct_P<List<long?>>), TypeInfoPropertyName = "T8080")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<long?>>), TypeInfoPropertyName = "T8081")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<long?>, int>), TypeInfoPropertyName = "T8082")]
-[JsonSerializable(typeof(Cn_class_P<long?[]>), TypeInfoPropertyName = "T8083")]
-[JsonSerializable(typeof(Cn_record_class_P<long?[]>), TypeInfoPropertyName = "T8084")]
-[JsonSerializable(typeof(Cn_struct_P<long?[]>), TypeInfoPropertyName = "T8085")]
-[JsonSerializable(typeof(Cn_record_struct_P<long?[]>), TypeInfoPropertyName = "T8086")]
-[JsonSerializable(typeof(Cn_generic_type_P<long?[], int>), TypeInfoPropertyName = "T8087")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<long?>>), TypeInfoPropertyName = "T8088")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<long?>>), TypeInfoPropertyName = "T8089")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<long?>>), TypeInfoPropertyName = "T8090")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<long?>>), TypeInfoPropertyName = "T8091")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<long?>, int>), TypeInfoPropertyName = "T8092")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<long?>>), TypeInfoPropertyName = "T8093")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<long?>>), TypeInfoPropertyName = "T8094")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<long?>>), TypeInfoPropertyName = "T8095")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<long?>>), TypeInfoPropertyName = "T8096")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<long?>, int>), TypeInfoPropertyName = "T8097")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, long?>>), TypeInfoPropertyName = "T8098")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, long?>>), TypeInfoPropertyName = "T8099")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, long?>>), TypeInfoPropertyName = "T8100")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, long?>>), TypeInfoPropertyName = "T8101")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, long?>, int>), TypeInfoPropertyName = "T8102")]
-[JsonSerializable(typeof(Cn_class_C<long?>), TypeInfoPropertyName = "T8103")]
-[JsonSerializable(typeof(Cn_record_class_C<long?>), TypeInfoPropertyName = "T8104")]
-[JsonSerializable(typeof(Cn_struct_C<long?>), TypeInfoPropertyName = "T8105")]
-[JsonSerializable(typeof(Cn_record_struct_C<long?>), TypeInfoPropertyName = "T8106")]
-[JsonSerializable(typeof(Cn_generic_type_C<long?, int>), TypeInfoPropertyName = "T8107")]
-[JsonSerializable(typeof(Cn_class_R<long?>), TypeInfoPropertyName = "T8108")]
-[JsonSerializable(typeof(Cn_record_class_R<long?>), TypeInfoPropertyName = "T8109")]
-[JsonSerializable(typeof(Cn_struct_R<long?>), TypeInfoPropertyName = "T8110")]
-[JsonSerializable(typeof(Cn_record_struct_R<long?>), TypeInfoPropertyName = "T8111")]
-[JsonSerializable(typeof(Cn_generic_type_R<long?, int>), TypeInfoPropertyName = "T8112")]
-[JsonSerializable(typeof(Cn_class_P<PBP_long_N>), TypeInfoPropertyName = "T8113")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_long_N>), TypeInfoPropertyName = "T8114")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_long_N>), TypeInfoPropertyName = "T8115")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_long_N>), TypeInfoPropertyName = "T8116")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_long_N, int>), TypeInfoPropertyName = "T8117")]
-[JsonSerializable(typeof(byte?), TypeInfoPropertyName = "T8118")]
-[JsonSerializable(typeof(Cn_class_F<byte?>), TypeInfoPropertyName = "T8119")]
-[JsonSerializable(typeof(Cn_record_class_F<byte?>), TypeInfoPropertyName = "T8120")]
-[JsonSerializable(typeof(Cn_struct_F<byte?>), TypeInfoPropertyName = "T8121")]
-[JsonSerializable(typeof(Cn_record_struct_F<byte?>), TypeInfoPropertyName = "T8122")]
-[JsonSerializable(typeof(Cn_generic_type_F<byte?, int>), TypeInfoPropertyName = "T8123")]
-[JsonSerializable(typeof(Cn_class_P<List<byte?>>), TypeInfoPropertyName = "T8124")]
-[JsonSerializable(typeof(Cn_record_class_P<List<byte?>>), TypeInfoPropertyName = "T8125")]
-[JsonSerializable(typeof(Cn_struct_P<List<byte?>>), TypeInfoPropertyName = "T8126")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<byte?>>), TypeInfoPropertyName = "T8127")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<byte?>, int>), TypeInfoPropertyName = "T8128")]
-[JsonSerializable(typeof(Cn_class_P<byte?[]>), TypeInfoPropertyName = "T8129")]
-[JsonSerializable(typeof(Cn_record_class_P<byte?[]>), TypeInfoPropertyName = "T8130")]
-[JsonSerializable(typeof(Cn_struct_P<byte?[]>), TypeInfoPropertyName = "T8131")]
-[JsonSerializable(typeof(Cn_record_struct_P<byte?[]>), TypeInfoPropertyName = "T8132")]
-[JsonSerializable(typeof(Cn_generic_type_P<byte?[], int>), TypeInfoPropertyName = "T8133")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<byte?>>), TypeInfoPropertyName = "T8134")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<byte?>>), TypeInfoPropertyName = "T8135")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<byte?>>), TypeInfoPropertyName = "T8136")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<byte?>>), TypeInfoPropertyName = "T8137")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<byte?>, int>), TypeInfoPropertyName = "T8138")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<byte?>>), TypeInfoPropertyName = "T8139")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<byte?>>), TypeInfoPropertyName = "T8140")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<byte?>>), TypeInfoPropertyName = "T8141")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<byte?>>), TypeInfoPropertyName = "T8142")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<byte?>, int>), TypeInfoPropertyName = "T8143")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, byte?>>), TypeInfoPropertyName = "T8144")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, byte?>>), TypeInfoPropertyName = "T8145")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, byte?>>), TypeInfoPropertyName = "T8146")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, byte?>>), TypeInfoPropertyName = "T8147")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, byte?>, int>), TypeInfoPropertyName = "T8148")]
-[JsonSerializable(typeof(Cn_class_C<byte?>), TypeInfoPropertyName = "T8149")]
-[JsonSerializable(typeof(Cn_record_class_C<byte?>), TypeInfoPropertyName = "T8150")]
-[JsonSerializable(typeof(Cn_struct_C<byte?>), TypeInfoPropertyName = "T8151")]
-[JsonSerializable(typeof(Cn_record_struct_C<byte?>), TypeInfoPropertyName = "T8152")]
-[JsonSerializable(typeof(Cn_generic_type_C<byte?, int>), TypeInfoPropertyName = "T8153")]
-[JsonSerializable(typeof(Cn_class_R<byte?>), TypeInfoPropertyName = "T8154")]
-[JsonSerializable(typeof(Cn_record_class_R<byte?>), TypeInfoPropertyName = "T8155")]
-[JsonSerializable(typeof(Cn_struct_R<byte?>), TypeInfoPropertyName = "T8156")]
-[JsonSerializable(typeof(Cn_record_struct_R<byte?>), TypeInfoPropertyName = "T8157")]
-[JsonSerializable(typeof(Cn_generic_type_R<byte?, int>), TypeInfoPropertyName = "T8158")]
-[JsonSerializable(typeof(Cn_class_P<PBP_byte_N>), TypeInfoPropertyName = "T8159")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_byte_N>), TypeInfoPropertyName = "T8160")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_byte_N>), TypeInfoPropertyName = "T8161")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_byte_N>), TypeInfoPropertyName = "T8162")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_byte_N, int>), TypeInfoPropertyName = "T8163")]
-[JsonSerializable(typeof(ulong?), TypeInfoPropertyName = "T8164")]
-[JsonSerializable(typeof(Cn_class_F<ulong?>), TypeInfoPropertyName = "T8165")]
-[JsonSerializable(typeof(Cn_record_class_F<ulong?>), TypeInfoPropertyName = "T8166")]
-[JsonSerializable(typeof(Cn_struct_F<ulong?>), TypeInfoPropertyName = "T8167")]
-[JsonSerializable(typeof(Cn_record_struct_F<ulong?>), TypeInfoPropertyName = "T8168")]
-[JsonSerializable(typeof(Cn_generic_type_F<ulong?, int>), TypeInfoPropertyName = "T8169")]
-[JsonSerializable(typeof(Cn_class_P<List<ulong?>>), TypeInfoPropertyName = "T8170")]
-[JsonSerializable(typeof(Cn_record_class_P<List<ulong?>>), TypeInfoPropertyName = "T8171")]
-[JsonSerializable(typeof(Cn_struct_P<List<ulong?>>), TypeInfoPropertyName = "T8172")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<ulong?>>), TypeInfoPropertyName = "T8173")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<ulong?>, int>), TypeInfoPropertyName = "T8174")]
-[JsonSerializable(typeof(Cn_class_P<ulong?[]>), TypeInfoPropertyName = "T8175")]
-[JsonSerializable(typeof(Cn_record_class_P<ulong?[]>), TypeInfoPropertyName = "T8176")]
-[JsonSerializable(typeof(Cn_struct_P<ulong?[]>), TypeInfoPropertyName = "T8177")]
-[JsonSerializable(typeof(Cn_record_struct_P<ulong?[]>), TypeInfoPropertyName = "T8178")]
-[JsonSerializable(typeof(Cn_generic_type_P<ulong?[], int>), TypeInfoPropertyName = "T8179")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<ulong?>>), TypeInfoPropertyName = "T8180")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<ulong?>>), TypeInfoPropertyName = "T8181")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<ulong?>>), TypeInfoPropertyName = "T8182")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<ulong?>>), TypeInfoPropertyName = "T8183")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<ulong?>, int>), TypeInfoPropertyName = "T8184")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<ulong?>>), TypeInfoPropertyName = "T8185")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<ulong?>>), TypeInfoPropertyName = "T8186")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<ulong?>>), TypeInfoPropertyName = "T8187")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<ulong?>>), TypeInfoPropertyName = "T8188")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<ulong?>, int>), TypeInfoPropertyName = "T8189")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, ulong?>>), TypeInfoPropertyName = "T8190")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, ulong?>>), TypeInfoPropertyName = "T8191")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, ulong?>>), TypeInfoPropertyName = "T8192")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, ulong?>>), TypeInfoPropertyName = "T8193")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, ulong?>, int>), TypeInfoPropertyName = "T8194")]
-[JsonSerializable(typeof(Cn_class_C<ulong?>), TypeInfoPropertyName = "T8195")]
-[JsonSerializable(typeof(Cn_record_class_C<ulong?>), TypeInfoPropertyName = "T8196")]
-[JsonSerializable(typeof(Cn_struct_C<ulong?>), TypeInfoPropertyName = "T8197")]
-[JsonSerializable(typeof(Cn_record_struct_C<ulong?>), TypeInfoPropertyName = "T8198")]
-[JsonSerializable(typeof(Cn_generic_type_C<ulong?, int>), TypeInfoPropertyName = "T8199")]
-[JsonSerializable(typeof(Cn_class_R<ulong?>), TypeInfoPropertyName = "T8200")]
-[JsonSerializable(typeof(Cn_record_class_R<ulong?>), TypeInfoPropertyName = "T8201")]
-[JsonSerializable(typeof(Cn_struct_R<ulong?>), TypeInfoPropertyName = "T8202")]
-[JsonSerializable(typeof(Cn_record_struct_R<ulong?>), TypeInfoPropertyName = "T8203")]
-[JsonSerializable(typeof(Cn_generic_type_R<ulong?, int>), TypeInfoPropertyName = "T8204")]
-[JsonSerializable(typeof(Cn_class_P<PBP_ulong_N>), TypeInfoPropertyName = "T8205")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_ulong_N>), TypeInfoPropertyName = "T8206")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_ulong_N>), TypeInfoPropertyName = "T8207")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_ulong_N>), TypeInfoPropertyName = "T8208")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_ulong_N, int>), TypeInfoPropertyName = "T8209")]
-[JsonSerializable(typeof(decimal?), TypeInfoPropertyName = "T8210")]
-[JsonSerializable(typeof(Cn_class_F<decimal?>), TypeInfoPropertyName = "T8211")]
-[JsonSerializable(typeof(Cn_record_class_F<decimal?>), TypeInfoPropertyName = "T8212")]
-[JsonSerializable(typeof(Cn_struct_F<decimal?>), TypeInfoPropertyName = "T8213")]
-[JsonSerializable(typeof(Cn_record_struct_F<decimal?>), TypeInfoPropertyName = "T8214")]
-[JsonSerializable(typeof(Cn_generic_type_F<decimal?, int>), TypeInfoPropertyName = "T8215")]
-[JsonSerializable(typeof(Cn_class_P<List<decimal?>>), TypeInfoPropertyName = "T8216")]
-[JsonSerializable(typeof(Cn_record_class_P<List<decimal?>>), TypeInfoPropertyName = "T8217")]
-[JsonSerializable(typeof(Cn_struct_P<List<decimal?>>), TypeInfoPropertyName = "T8218")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<decimal?>>), TypeInfoPropertyName = "T8219")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<decimal?>, int>), TypeInfoPropertyName = "T8220")]
-[JsonSerializable(typeof(Cn_class_P<decimal?[]>), TypeInfoPropertyName = "T8221")]
-[JsonSerializable(typeof(Cn_record_class_P<decimal?[]>), TypeInfoPropertyName = "T8222")]
-[JsonSerializable(typeof(Cn_struct_P<decimal?[]>), TypeInfoPropertyName = "T8223")]
-[JsonSerializable(typeof(Cn_record_struct_P<decimal?[]>), TypeInfoPropertyName = "T8224")]
-[JsonSerializable(typeof(Cn_generic_type_P<decimal?[], int>), TypeInfoPropertyName = "T8225")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<decimal?>>), TypeInfoPropertyName = "T8226")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<decimal?>>), TypeInfoPropertyName = "T8227")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<decimal?>>), TypeInfoPropertyName = "T8228")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<decimal?>>), TypeInfoPropertyName = "T8229")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<decimal?>, int>), TypeInfoPropertyName = "T8230")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<decimal?>>), TypeInfoPropertyName = "T8231")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<decimal?>>), TypeInfoPropertyName = "T8232")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<decimal?>>), TypeInfoPropertyName = "T8233")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<decimal?>>), TypeInfoPropertyName = "T8234")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<decimal?>, int>), TypeInfoPropertyName = "T8235")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, decimal?>>), TypeInfoPropertyName = "T8236")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, decimal?>>), TypeInfoPropertyName = "T8237")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, decimal?>>), TypeInfoPropertyName = "T8238")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, decimal?>>), TypeInfoPropertyName = "T8239")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, decimal?>, int>), TypeInfoPropertyName = "T8240")]
-[JsonSerializable(typeof(Cn_class_C<decimal?>), TypeInfoPropertyName = "T8241")]
-[JsonSerializable(typeof(Cn_record_class_C<decimal?>), TypeInfoPropertyName = "T8242")]
-[JsonSerializable(typeof(Cn_struct_C<decimal?>), TypeInfoPropertyName = "T8243")]
-[JsonSerializable(typeof(Cn_record_struct_C<decimal?>), TypeInfoPropertyName = "T8244")]
-[JsonSerializable(typeof(Cn_generic_type_C<decimal?, int>), TypeInfoPropertyName = "T8245")]
-[JsonSerializable(typeof(Cn_class_R<decimal?>), TypeInfoPropertyName = "T8246")]
-[JsonSerializable(typeof(Cn_record_class_R<decimal?>), TypeInfoPropertyName = "T8247")]
-[JsonSerializable(typeof(Cn_struct_R<decimal?>), TypeInfoPropertyName = "T8248")]
-[JsonSerializable(typeof(Cn_record_struct_R<decimal?>), TypeInfoPropertyName = "T8249")]
-[JsonSerializable(typeof(Cn_generic_type_R<decimal?, int>), TypeInfoPropertyName = "T8250")]
-[JsonSerializable(typeof(Cn_class_P<PBP_decimal_N>), TypeInfoPropertyName = "T8251")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_decimal_N>), TypeInfoPropertyName = "T8252")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_decimal_N>), TypeInfoPropertyName = "T8253")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_decimal_N>), TypeInfoPropertyName = "T8254")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_decimal_N, int>), TypeInfoPropertyName = "T8255")]
-[JsonSerializable(typeof(double?), TypeInfoPropertyName = "T8256")]
-[JsonSerializable(typeof(Cn_class_F<double?>), TypeInfoPropertyName = "T8257")]
-[JsonSerializable(typeof(Cn_record_class_F<double?>), TypeInfoPropertyName = "T8258")]
-[JsonSerializable(typeof(Cn_struct_F<double?>), TypeInfoPropertyName = "T8259")]
-[JsonSerializable(typeof(Cn_record_struct_F<double?>), TypeInfoPropertyName = "T8260")]
-[JsonSerializable(typeof(Cn_generic_type_F<double?, int>), TypeInfoPropertyName = "T8261")]
-[JsonSerializable(typeof(Cn_class_P<List<double?>>), TypeInfoPropertyName = "T8262")]
-[JsonSerializable(typeof(Cn_record_class_P<List<double?>>), TypeInfoPropertyName = "T8263")]
-[JsonSerializable(typeof(Cn_struct_P<List<double?>>), TypeInfoPropertyName = "T8264")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<double?>>), TypeInfoPropertyName = "T8265")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<double?>, int>), TypeInfoPropertyName = "T8266")]
-[JsonSerializable(typeof(Cn_class_P<double?[]>), TypeInfoPropertyName = "T8267")]
-[JsonSerializable(typeof(Cn_record_class_P<double?[]>), TypeInfoPropertyName = "T8268")]
-[JsonSerializable(typeof(Cn_struct_P<double?[]>), TypeInfoPropertyName = "T8269")]
-[JsonSerializable(typeof(Cn_record_struct_P<double?[]>), TypeInfoPropertyName = "T8270")]
-[JsonSerializable(typeof(Cn_generic_type_P<double?[], int>), TypeInfoPropertyName = "T8271")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<double?>>), TypeInfoPropertyName = "T8272")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<double?>>), TypeInfoPropertyName = "T8273")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<double?>>), TypeInfoPropertyName = "T8274")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<double?>>), TypeInfoPropertyName = "T8275")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<double?>, int>), TypeInfoPropertyName = "T8276")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<double?>>), TypeInfoPropertyName = "T8277")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<double?>>), TypeInfoPropertyName = "T8278")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<double?>>), TypeInfoPropertyName = "T8279")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<double?>>), TypeInfoPropertyName = "T8280")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<double?>, int>), TypeInfoPropertyName = "T8281")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, double?>>), TypeInfoPropertyName = "T8282")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, double?>>), TypeInfoPropertyName = "T8283")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, double?>>), TypeInfoPropertyName = "T8284")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, double?>>), TypeInfoPropertyName = "T8285")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, double?>, int>), TypeInfoPropertyName = "T8286")]
-[JsonSerializable(typeof(Cn_class_C<double?>), TypeInfoPropertyName = "T8287")]
-[JsonSerializable(typeof(Cn_record_class_C<double?>), TypeInfoPropertyName = "T8288")]
-[JsonSerializable(typeof(Cn_struct_C<double?>), TypeInfoPropertyName = "T8289")]
-[JsonSerializable(typeof(Cn_record_struct_C<double?>), TypeInfoPropertyName = "T8290")]
-[JsonSerializable(typeof(Cn_generic_type_C<double?, int>), TypeInfoPropertyName = "T8291")]
-[JsonSerializable(typeof(Cn_class_R<double?>), TypeInfoPropertyName = "T8292")]
-[JsonSerializable(typeof(Cn_record_class_R<double?>), TypeInfoPropertyName = "T8293")]
-[JsonSerializable(typeof(Cn_struct_R<double?>), TypeInfoPropertyName = "T8294")]
-[JsonSerializable(typeof(Cn_record_struct_R<double?>), TypeInfoPropertyName = "T8295")]
-[JsonSerializable(typeof(Cn_generic_type_R<double?, int>), TypeInfoPropertyName = "T8296")]
-[JsonSerializable(typeof(Cn_class_P<PBP_double_N>), TypeInfoPropertyName = "T8297")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_double_N>), TypeInfoPropertyName = "T8298")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_double_N>), TypeInfoPropertyName = "T8299")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_double_N>), TypeInfoPropertyName = "T8300")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_double_N, int>), TypeInfoPropertyName = "T8301")]
-[JsonSerializable(typeof(bool?), TypeInfoPropertyName = "T8302")]
-[JsonSerializable(typeof(Cn_class_F<bool?>), TypeInfoPropertyName = "T8303")]
-[JsonSerializable(typeof(Cn_record_class_F<bool?>), TypeInfoPropertyName = "T8304")]
-[JsonSerializable(typeof(Cn_struct_F<bool?>), TypeInfoPropertyName = "T8305")]
-[JsonSerializable(typeof(Cn_record_struct_F<bool?>), TypeInfoPropertyName = "T8306")]
-[JsonSerializable(typeof(Cn_generic_type_F<bool?, int>), TypeInfoPropertyName = "T8307")]
-[JsonSerializable(typeof(Cn_class_P<List<bool?>>), TypeInfoPropertyName = "T8308")]
-[JsonSerializable(typeof(Cn_record_class_P<List<bool?>>), TypeInfoPropertyName = "T8309")]
-[JsonSerializable(typeof(Cn_struct_P<List<bool?>>), TypeInfoPropertyName = "T8310")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<bool?>>), TypeInfoPropertyName = "T8311")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<bool?>, int>), TypeInfoPropertyName = "T8312")]
-[JsonSerializable(typeof(Cn_class_P<bool?[]>), TypeInfoPropertyName = "T8313")]
-[JsonSerializable(typeof(Cn_record_class_P<bool?[]>), TypeInfoPropertyName = "T8314")]
-[JsonSerializable(typeof(Cn_struct_P<bool?[]>), TypeInfoPropertyName = "T8315")]
-[JsonSerializable(typeof(Cn_record_struct_P<bool?[]>), TypeInfoPropertyName = "T8316")]
-[JsonSerializable(typeof(Cn_generic_type_P<bool?[], int>), TypeInfoPropertyName = "T8317")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<bool?>>), TypeInfoPropertyName = "T8318")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<bool?>>), TypeInfoPropertyName = "T8319")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<bool?>>), TypeInfoPropertyName = "T8320")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<bool?>>), TypeInfoPropertyName = "T8321")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<bool?>, int>), TypeInfoPropertyName = "T8322")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<bool?>>), TypeInfoPropertyName = "T8323")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<bool?>>), TypeInfoPropertyName = "T8324")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<bool?>>), TypeInfoPropertyName = "T8325")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<bool?>>), TypeInfoPropertyName = "T8326")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<bool?>, int>), TypeInfoPropertyName = "T8327")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, bool?>>), TypeInfoPropertyName = "T8328")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, bool?>>), TypeInfoPropertyName = "T8329")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, bool?>>), TypeInfoPropertyName = "T8330")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, bool?>>), TypeInfoPropertyName = "T8331")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, bool?>, int>), TypeInfoPropertyName = "T8332")]
-[JsonSerializable(typeof(Cn_class_C<bool?>), TypeInfoPropertyName = "T8333")]
-[JsonSerializable(typeof(Cn_record_class_C<bool?>), TypeInfoPropertyName = "T8334")]
-[JsonSerializable(typeof(Cn_struct_C<bool?>), TypeInfoPropertyName = "T8335")]
-[JsonSerializable(typeof(Cn_record_struct_C<bool?>), TypeInfoPropertyName = "T8336")]
-[JsonSerializable(typeof(Cn_generic_type_C<bool?, int>), TypeInfoPropertyName = "T8337")]
-[JsonSerializable(typeof(Cn_class_R<bool?>), TypeInfoPropertyName = "T8338")]
-[JsonSerializable(typeof(Cn_record_class_R<bool?>), TypeInfoPropertyName = "T8339")]
-[JsonSerializable(typeof(Cn_struct_R<bool?>), TypeInfoPropertyName = "T8340")]
-[JsonSerializable(typeof(Cn_record_struct_R<bool?>), TypeInfoPropertyName = "T8341")]
-[JsonSerializable(typeof(Cn_generic_type_R<bool?, int>), TypeInfoPropertyName = "T8342")]
-[JsonSerializable(typeof(Cn_class_P<PBP_bool_N>), TypeInfoPropertyName = "T8343")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_bool_N>), TypeInfoPropertyName = "T8344")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_bool_N>), TypeInfoPropertyName = "T8345")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_bool_N>), TypeInfoPropertyName = "T8346")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_bool_N, int>), TypeInfoPropertyName = "T8347")]
-[JsonSerializable(typeof(char?), TypeInfoPropertyName = "T8348")]
-[JsonSerializable(typeof(Cn_class_F<char?>), TypeInfoPropertyName = "T8349")]
-[JsonSerializable(typeof(Cn_record_class_F<char?>), TypeInfoPropertyName = "T8350")]
-[JsonSerializable(typeof(Cn_struct_F<char?>), TypeInfoPropertyName = "T8351")]
-[JsonSerializable(typeof(Cn_record_struct_F<char?>), TypeInfoPropertyName = "T8352")]
-[JsonSerializable(typeof(Cn_generic_type_F<char?, int>), TypeInfoPropertyName = "T8353")]
-[JsonSerializable(typeof(Cn_class_P<List<char?>>), TypeInfoPropertyName = "T8354")]
-[JsonSerializable(typeof(Cn_record_class_P<List<char?>>), TypeInfoPropertyName = "T8355")]
-[JsonSerializable(typeof(Cn_struct_P<List<char?>>), TypeInfoPropertyName = "T8356")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<char?>>), TypeInfoPropertyName = "T8357")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<char?>, int>), TypeInfoPropertyName = "T8358")]
-[JsonSerializable(typeof(Cn_class_P<char?[]>), TypeInfoPropertyName = "T8359")]
-[JsonSerializable(typeof(Cn_record_class_P<char?[]>), TypeInfoPropertyName = "T8360")]
-[JsonSerializable(typeof(Cn_struct_P<char?[]>), TypeInfoPropertyName = "T8361")]
-[JsonSerializable(typeof(Cn_record_struct_P<char?[]>), TypeInfoPropertyName = "T8362")]
-[JsonSerializable(typeof(Cn_generic_type_P<char?[], int>), TypeInfoPropertyName = "T8363")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<char?>>), TypeInfoPropertyName = "T8364")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<char?>>), TypeInfoPropertyName = "T8365")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<char?>>), TypeInfoPropertyName = "T8366")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<char?>>), TypeInfoPropertyName = "T8367")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<char?>, int>), TypeInfoPropertyName = "T8368")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<char?>>), TypeInfoPropertyName = "T8369")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<char?>>), TypeInfoPropertyName = "T8370")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<char?>>), TypeInfoPropertyName = "T8371")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<char?>>), TypeInfoPropertyName = "T8372")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<char?>, int>), TypeInfoPropertyName = "T8373")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, char?>>), TypeInfoPropertyName = "T8374")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, char?>>), TypeInfoPropertyName = "T8375")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, char?>>), TypeInfoPropertyName = "T8376")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, char?>>), TypeInfoPropertyName = "T8377")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, char?>, int>), TypeInfoPropertyName = "T8378")]
-[JsonSerializable(typeof(Cn_class_C<char?>), TypeInfoPropertyName = "T8379")]
-[JsonSerializable(typeof(Cn_record_class_C<char?>), TypeInfoPropertyName = "T8380")]
-[JsonSerializable(typeof(Cn_struct_C<char?>), TypeInfoPropertyName = "T8381")]
-[JsonSerializable(typeof(Cn_record_struct_C<char?>), TypeInfoPropertyName = "T8382")]
-[JsonSerializable(typeof(Cn_generic_type_C<char?, int>), TypeInfoPropertyName = "T8383")]
-[JsonSerializable(typeof(Cn_class_R<char?>), TypeInfoPropertyName = "T8384")]
-[JsonSerializable(typeof(Cn_record_class_R<char?>), TypeInfoPropertyName = "T8385")]
-[JsonSerializable(typeof(Cn_struct_R<char?>), TypeInfoPropertyName = "T8386")]
-[JsonSerializable(typeof(Cn_record_struct_R<char?>), TypeInfoPropertyName = "T8387")]
-[JsonSerializable(typeof(Cn_generic_type_R<char?, int>), TypeInfoPropertyName = "T8388")]
-[JsonSerializable(typeof(Cn_class_P<PBP_char_N>), TypeInfoPropertyName = "T8389")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_char_N>), TypeInfoPropertyName = "T8390")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_char_N>), TypeInfoPropertyName = "T8391")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_char_N>), TypeInfoPropertyName = "T8392")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_char_N, int>), TypeInfoPropertyName = "T8393")]
-[JsonSerializable(typeof(DateTime?), TypeInfoPropertyName = "T8394")]
-[JsonSerializable(typeof(Cn_class_F<DateTime?>), TypeInfoPropertyName = "T8395")]
-[JsonSerializable(typeof(Cn_record_class_F<DateTime?>), TypeInfoPropertyName = "T8396")]
-[JsonSerializable(typeof(Cn_struct_F<DateTime?>), TypeInfoPropertyName = "T8397")]
-[JsonSerializable(typeof(Cn_record_struct_F<DateTime?>), TypeInfoPropertyName = "T8398")]
-[JsonSerializable(typeof(Cn_generic_type_F<DateTime?, int>), TypeInfoPropertyName = "T8399")]
-[JsonSerializable(typeof(Cn_class_P<List<DateTime?>>), TypeInfoPropertyName = "T8400")]
-[JsonSerializable(typeof(Cn_record_class_P<List<DateTime?>>), TypeInfoPropertyName = "T8401")]
-[JsonSerializable(typeof(Cn_struct_P<List<DateTime?>>), TypeInfoPropertyName = "T8402")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<DateTime?>>), TypeInfoPropertyName = "T8403")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<DateTime?>, int>), TypeInfoPropertyName = "T8404")]
-[JsonSerializable(typeof(Cn_class_P<DateTime?[]>), TypeInfoPropertyName = "T8405")]
-[JsonSerializable(typeof(Cn_record_class_P<DateTime?[]>), TypeInfoPropertyName = "T8406")]
-[JsonSerializable(typeof(Cn_struct_P<DateTime?[]>), TypeInfoPropertyName = "T8407")]
-[JsonSerializable(typeof(Cn_record_struct_P<DateTime?[]>), TypeInfoPropertyName = "T8408")]
-[JsonSerializable(typeof(Cn_generic_type_P<DateTime?[], int>), TypeInfoPropertyName = "T8409")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<DateTime?>>), TypeInfoPropertyName = "T8410")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<DateTime?>>), TypeInfoPropertyName = "T8411")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<DateTime?>>), TypeInfoPropertyName = "T8412")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<DateTime?>>), TypeInfoPropertyName = "T8413")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<DateTime?>, int>), TypeInfoPropertyName = "T8414")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<DateTime?>>), TypeInfoPropertyName = "T8415")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<DateTime?>>), TypeInfoPropertyName = "T8416")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<DateTime?>>), TypeInfoPropertyName = "T8417")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<DateTime?>>), TypeInfoPropertyName = "T8418")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<DateTime?>, int>), TypeInfoPropertyName = "T8419")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, DateTime?>>), TypeInfoPropertyName = "T8420")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, DateTime?>>), TypeInfoPropertyName = "T8421")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, DateTime?>>), TypeInfoPropertyName = "T8422")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, DateTime?>>), TypeInfoPropertyName = "T8423")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, DateTime?>, int>), TypeInfoPropertyName = "T8424")]
-[JsonSerializable(typeof(Cn_class_C<DateTime?>), TypeInfoPropertyName = "T8425")]
-[JsonSerializable(typeof(Cn_record_class_C<DateTime?>), TypeInfoPropertyName = "T8426")]
-[JsonSerializable(typeof(Cn_struct_C<DateTime?>), TypeInfoPropertyName = "T8427")]
-[JsonSerializable(typeof(Cn_record_struct_C<DateTime?>), TypeInfoPropertyName = "T8428")]
-[JsonSerializable(typeof(Cn_generic_type_C<DateTime?, int>), TypeInfoPropertyName = "T8429")]
-[JsonSerializable(typeof(Cn_class_R<DateTime?>), TypeInfoPropertyName = "T8430")]
-[JsonSerializable(typeof(Cn_record_class_R<DateTime?>), TypeInfoPropertyName = "T8431")]
-[JsonSerializable(typeof(Cn_struct_R<DateTime?>), TypeInfoPropertyName = "T8432")]
-[JsonSerializable(typeof(Cn_record_struct_R<DateTime?>), TypeInfoPropertyName = "T8433")]
-[JsonSerializable(typeof(Cn_generic_type_R<DateTime?, int>), TypeInfoPropertyName = "T8434")]
-[JsonSerializable(typeof(Cn_class_P<PBP_DateTime_N>), TypeInfoPropertyName = "T8435")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_DateTime_N>), TypeInfoPropertyName = "T8436")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_DateTime_N>), TypeInfoPropertyName = "T8437")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_DateTime_N>), TypeInfoPropertyName = "T8438")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_DateTime_N, int>), TypeInfoPropertyName = "T8439")]
-[JsonSerializable(typeof(DateTimeOffset?), TypeInfoPropertyName = "T8440")]
-[JsonSerializable(typeof(Cn_class_F<DateTimeOffset?>), TypeInfoPropertyName = "T8441")]
-[JsonSerializable(typeof(Cn_record_class_F<DateTimeOffset?>), TypeInfoPropertyName = "T8442")]
-[JsonSerializable(typeof(Cn_struct_F<DateTimeOffset?>), TypeInfoPropertyName = "T8443")]
-[JsonSerializable(typeof(Cn_record_struct_F<DateTimeOffset?>), TypeInfoPropertyName = "T8444")]
-[JsonSerializable(typeof(Cn_generic_type_F<DateTimeOffset?, int>), TypeInfoPropertyName = "T8445")]
-[JsonSerializable(typeof(Cn_class_P<List<DateTimeOffset?>>), TypeInfoPropertyName = "T8446")]
-[JsonSerializable(typeof(Cn_record_class_P<List<DateTimeOffset?>>), TypeInfoPropertyName = "T8447")]
-[JsonSerializable(typeof(Cn_struct_P<List<DateTimeOffset?>>), TypeInfoPropertyName = "T8448")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<DateTimeOffset?>>), TypeInfoPropertyName = "T8449")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<DateTimeOffset?>, int>), TypeInfoPropertyName = "T8450")]
-[JsonSerializable(typeof(Cn_class_P<DateTimeOffset?[]>), TypeInfoPropertyName = "T8451")]
-[JsonSerializable(typeof(Cn_record_class_P<DateTimeOffset?[]>), TypeInfoPropertyName = "T8452")]
-[JsonSerializable(typeof(Cn_struct_P<DateTimeOffset?[]>), TypeInfoPropertyName = "T8453")]
-[JsonSerializable(typeof(Cn_record_struct_P<DateTimeOffset?[]>), TypeInfoPropertyName = "T8454")]
-[JsonSerializable(typeof(Cn_generic_type_P<DateTimeOffset?[], int>), TypeInfoPropertyName = "T8455")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<DateTimeOffset?>>), TypeInfoPropertyName = "T8456")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<DateTimeOffset?>>), TypeInfoPropertyName = "T8457")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<DateTimeOffset?>>), TypeInfoPropertyName = "T8458")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<DateTimeOffset?>>), TypeInfoPropertyName = "T8459")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<DateTimeOffset?>, int>), TypeInfoPropertyName = "T8460")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<DateTimeOffset?>>), TypeInfoPropertyName = "T8461")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<DateTimeOffset?>>), TypeInfoPropertyName = "T8462")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<DateTimeOffset?>>), TypeInfoPropertyName = "T8463")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<DateTimeOffset?>>), TypeInfoPropertyName = "T8464")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<DateTimeOffset?>, int>), TypeInfoPropertyName = "T8465")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, DateTimeOffset?>>), TypeInfoPropertyName = "T8466")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, DateTimeOffset?>>), TypeInfoPropertyName = "T8467")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, DateTimeOffset?>>), TypeInfoPropertyName = "T8468")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, DateTimeOffset?>>), TypeInfoPropertyName = "T8469")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, DateTimeOffset?>, int>), TypeInfoPropertyName = "T8470")]
-[JsonSerializable(typeof(Cn_class_C<DateTimeOffset?>), TypeInfoPropertyName = "T8471")]
-[JsonSerializable(typeof(Cn_record_class_C<DateTimeOffset?>), TypeInfoPropertyName = "T8472")]
-[JsonSerializable(typeof(Cn_struct_C<DateTimeOffset?>), TypeInfoPropertyName = "T8473")]
-[JsonSerializable(typeof(Cn_record_struct_C<DateTimeOffset?>), TypeInfoPropertyName = "T8474")]
-[JsonSerializable(typeof(Cn_generic_type_C<DateTimeOffset?, int>), TypeInfoPropertyName = "T8475")]
-[JsonSerializable(typeof(Cn_class_R<DateTimeOffset?>), TypeInfoPropertyName = "T8476")]
-[JsonSerializable(typeof(Cn_record_class_R<DateTimeOffset?>), TypeInfoPropertyName = "T8477")]
-[JsonSerializable(typeof(Cn_struct_R<DateTimeOffset?>), TypeInfoPropertyName = "T8478")]
-[JsonSerializable(typeof(Cn_record_struct_R<DateTimeOffset?>), TypeInfoPropertyName = "T8479")]
-[JsonSerializable(typeof(Cn_generic_type_R<DateTimeOffset?, int>), TypeInfoPropertyName = "T8480")]
-[JsonSerializable(typeof(Cn_class_P<PBP_DateTimeOffset_N>), TypeInfoPropertyName = "T8481")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_DateTimeOffset_N>), TypeInfoPropertyName = "T8482")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_DateTimeOffset_N>), TypeInfoPropertyName = "T8483")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_DateTimeOffset_N>), TypeInfoPropertyName = "T8484")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_DateTimeOffset_N, int>), TypeInfoPropertyName = "T8485")]
-[JsonSerializable(typeof(DateOnly?), TypeInfoPropertyName = "T8486")]
-[JsonSerializable(typeof(Cn_class_F<DateOnly?>), TypeInfoPropertyName = "T8487")]
-[JsonSerializable(typeof(Cn_record_class_F<DateOnly?>), TypeInfoPropertyName = "T8488")]
-[JsonSerializable(typeof(Cn_struct_F<DateOnly?>), TypeInfoPropertyName = "T8489")]
-[JsonSerializable(typeof(Cn_record_struct_F<DateOnly?>), TypeInfoPropertyName = "T8490")]
-[JsonSerializable(typeof(Cn_generic_type_F<DateOnly?, int>), TypeInfoPropertyName = "T8491")]
-[JsonSerializable(typeof(Cn_class_P<List<DateOnly?>>), TypeInfoPropertyName = "T8492")]
-[JsonSerializable(typeof(Cn_record_class_P<List<DateOnly?>>), TypeInfoPropertyName = "T8493")]
-[JsonSerializable(typeof(Cn_struct_P<List<DateOnly?>>), TypeInfoPropertyName = "T8494")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<DateOnly?>>), TypeInfoPropertyName = "T8495")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<DateOnly?>, int>), TypeInfoPropertyName = "T8496")]
-[JsonSerializable(typeof(Cn_class_P<DateOnly?[]>), TypeInfoPropertyName = "T8497")]
-[JsonSerializable(typeof(Cn_record_class_P<DateOnly?[]>), TypeInfoPropertyName = "T8498")]
-[JsonSerializable(typeof(Cn_struct_P<DateOnly?[]>), TypeInfoPropertyName = "T8499")]
-[JsonSerializable(typeof(Cn_record_struct_P<DateOnly?[]>), TypeInfoPropertyName = "T8500")]
-[JsonSerializable(typeof(Cn_generic_type_P<DateOnly?[], int>), TypeInfoPropertyName = "T8501")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<DateOnly?>>), TypeInfoPropertyName = "T8502")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<DateOnly?>>), TypeInfoPropertyName = "T8503")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<DateOnly?>>), TypeInfoPropertyName = "T8504")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<DateOnly?>>), TypeInfoPropertyName = "T8505")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<DateOnly?>, int>), TypeInfoPropertyName = "T8506")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<DateOnly?>>), TypeInfoPropertyName = "T8507")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<DateOnly?>>), TypeInfoPropertyName = "T8508")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<DateOnly?>>), TypeInfoPropertyName = "T8509")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<DateOnly?>>), TypeInfoPropertyName = "T8510")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<DateOnly?>, int>), TypeInfoPropertyName = "T8511")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, DateOnly?>>), TypeInfoPropertyName = "T8512")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, DateOnly?>>), TypeInfoPropertyName = "T8513")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, DateOnly?>>), TypeInfoPropertyName = "T8514")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, DateOnly?>>), TypeInfoPropertyName = "T8515")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, DateOnly?>, int>), TypeInfoPropertyName = "T8516")]
-[JsonSerializable(typeof(Cn_class_C<DateOnly?>), TypeInfoPropertyName = "T8517")]
-[JsonSerializable(typeof(Cn_record_class_C<DateOnly?>), TypeInfoPropertyName = "T8518")]
-[JsonSerializable(typeof(Cn_struct_C<DateOnly?>), TypeInfoPropertyName = "T8519")]
-[JsonSerializable(typeof(Cn_record_struct_C<DateOnly?>), TypeInfoPropertyName = "T8520")]
-[JsonSerializable(typeof(Cn_generic_type_C<DateOnly?, int>), TypeInfoPropertyName = "T8521")]
-[JsonSerializable(typeof(Cn_class_R<DateOnly?>), TypeInfoPropertyName = "T8522")]
-[JsonSerializable(typeof(Cn_record_class_R<DateOnly?>), TypeInfoPropertyName = "T8523")]
-[JsonSerializable(typeof(Cn_struct_R<DateOnly?>), TypeInfoPropertyName = "T8524")]
-[JsonSerializable(typeof(Cn_record_struct_R<DateOnly?>), TypeInfoPropertyName = "T8525")]
-[JsonSerializable(typeof(Cn_generic_type_R<DateOnly?, int>), TypeInfoPropertyName = "T8526")]
-[JsonSerializable(typeof(Cn_class_P<PBP_DateOnly_N>), TypeInfoPropertyName = "T8527")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_DateOnly_N>), TypeInfoPropertyName = "T8528")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_DateOnly_N>), TypeInfoPropertyName = "T8529")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_DateOnly_N>), TypeInfoPropertyName = "T8530")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_DateOnly_N, int>), TypeInfoPropertyName = "T8531")]
-[JsonSerializable(typeof(TimeOnly?), TypeInfoPropertyName = "T8532")]
-[JsonSerializable(typeof(Cn_class_F<TimeOnly?>), TypeInfoPropertyName = "T8533")]
-[JsonSerializable(typeof(Cn_record_class_F<TimeOnly?>), TypeInfoPropertyName = "T8534")]
-[JsonSerializable(typeof(Cn_struct_F<TimeOnly?>), TypeInfoPropertyName = "T8535")]
-[JsonSerializable(typeof(Cn_record_struct_F<TimeOnly?>), TypeInfoPropertyName = "T8536")]
-[JsonSerializable(typeof(Cn_generic_type_F<TimeOnly?, int>), TypeInfoPropertyName = "T8537")]
-[JsonSerializable(typeof(Cn_class_P<List<TimeOnly?>>), TypeInfoPropertyName = "T8538")]
-[JsonSerializable(typeof(Cn_record_class_P<List<TimeOnly?>>), TypeInfoPropertyName = "T8539")]
-[JsonSerializable(typeof(Cn_struct_P<List<TimeOnly?>>), TypeInfoPropertyName = "T8540")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<TimeOnly?>>), TypeInfoPropertyName = "T8541")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<TimeOnly?>, int>), TypeInfoPropertyName = "T8542")]
-[JsonSerializable(typeof(Cn_class_P<TimeOnly?[]>), TypeInfoPropertyName = "T8543")]
-[JsonSerializable(typeof(Cn_record_class_P<TimeOnly?[]>), TypeInfoPropertyName = "T8544")]
-[JsonSerializable(typeof(Cn_struct_P<TimeOnly?[]>), TypeInfoPropertyName = "T8545")]
-[JsonSerializable(typeof(Cn_record_struct_P<TimeOnly?[]>), TypeInfoPropertyName = "T8546")]
-[JsonSerializable(typeof(Cn_generic_type_P<TimeOnly?[], int>), TypeInfoPropertyName = "T8547")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<TimeOnly?>>), TypeInfoPropertyName = "T8548")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<TimeOnly?>>), TypeInfoPropertyName = "T8549")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<TimeOnly?>>), TypeInfoPropertyName = "T8550")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<TimeOnly?>>), TypeInfoPropertyName = "T8551")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<TimeOnly?>, int>), TypeInfoPropertyName = "T8552")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<TimeOnly?>>), TypeInfoPropertyName = "T8553")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<TimeOnly?>>), TypeInfoPropertyName = "T8554")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<TimeOnly?>>), TypeInfoPropertyName = "T8555")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<TimeOnly?>>), TypeInfoPropertyName = "T8556")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<TimeOnly?>, int>), TypeInfoPropertyName = "T8557")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, TimeOnly?>>), TypeInfoPropertyName = "T8558")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, TimeOnly?>>), TypeInfoPropertyName = "T8559")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, TimeOnly?>>), TypeInfoPropertyName = "T8560")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, TimeOnly?>>), TypeInfoPropertyName = "T8561")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, TimeOnly?>, int>), TypeInfoPropertyName = "T8562")]
-[JsonSerializable(typeof(Cn_class_C<TimeOnly?>), TypeInfoPropertyName = "T8563")]
-[JsonSerializable(typeof(Cn_record_class_C<TimeOnly?>), TypeInfoPropertyName = "T8564")]
-[JsonSerializable(typeof(Cn_struct_C<TimeOnly?>), TypeInfoPropertyName = "T8565")]
-[JsonSerializable(typeof(Cn_record_struct_C<TimeOnly?>), TypeInfoPropertyName = "T8566")]
-[JsonSerializable(typeof(Cn_generic_type_C<TimeOnly?, int>), TypeInfoPropertyName = "T8567")]
-[JsonSerializable(typeof(Cn_class_R<TimeOnly?>), TypeInfoPropertyName = "T8568")]
-[JsonSerializable(typeof(Cn_record_class_R<TimeOnly?>), TypeInfoPropertyName = "T8569")]
-[JsonSerializable(typeof(Cn_struct_R<TimeOnly?>), TypeInfoPropertyName = "T8570")]
-[JsonSerializable(typeof(Cn_record_struct_R<TimeOnly?>), TypeInfoPropertyName = "T8571")]
-[JsonSerializable(typeof(Cn_generic_type_R<TimeOnly?, int>), TypeInfoPropertyName = "T8572")]
-[JsonSerializable(typeof(Cn_class_P<PBP_TimeOnly_N>), TypeInfoPropertyName = "T8573")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_TimeOnly_N>), TypeInfoPropertyName = "T8574")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_TimeOnly_N>), TypeInfoPropertyName = "T8575")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_TimeOnly_N>), TypeInfoPropertyName = "T8576")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_TimeOnly_N, int>), TypeInfoPropertyName = "T8577")]
-[JsonSerializable(typeof(TimeSpan?), TypeInfoPropertyName = "T8578")]
-[JsonSerializable(typeof(Cn_class_F<TimeSpan?>), TypeInfoPropertyName = "T8579")]
-[JsonSerializable(typeof(Cn_record_class_F<TimeSpan?>), TypeInfoPropertyName = "T8580")]
-[JsonSerializable(typeof(Cn_struct_F<TimeSpan?>), TypeInfoPropertyName = "T8581")]
-[JsonSerializable(typeof(Cn_record_struct_F<TimeSpan?>), TypeInfoPropertyName = "T8582")]
-[JsonSerializable(typeof(Cn_generic_type_F<TimeSpan?, int>), TypeInfoPropertyName = "T8583")]
-[JsonSerializable(typeof(Cn_class_P<List<TimeSpan?>>), TypeInfoPropertyName = "T8584")]
-[JsonSerializable(typeof(Cn_record_class_P<List<TimeSpan?>>), TypeInfoPropertyName = "T8585")]
-[JsonSerializable(typeof(Cn_struct_P<List<TimeSpan?>>), TypeInfoPropertyName = "T8586")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<TimeSpan?>>), TypeInfoPropertyName = "T8587")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<TimeSpan?>, int>), TypeInfoPropertyName = "T8588")]
-[JsonSerializable(typeof(Cn_class_P<TimeSpan?[]>), TypeInfoPropertyName = "T8589")]
-[JsonSerializable(typeof(Cn_record_class_P<TimeSpan?[]>), TypeInfoPropertyName = "T8590")]
-[JsonSerializable(typeof(Cn_struct_P<TimeSpan?[]>), TypeInfoPropertyName = "T8591")]
-[JsonSerializable(typeof(Cn_record_struct_P<TimeSpan?[]>), TypeInfoPropertyName = "T8592")]
-[JsonSerializable(typeof(Cn_generic_type_P<TimeSpan?[], int>), TypeInfoPropertyName = "T8593")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<TimeSpan?>>), TypeInfoPropertyName = "T8594")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<TimeSpan?>>), TypeInfoPropertyName = "T8595")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<TimeSpan?>>), TypeInfoPropertyName = "T8596")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<TimeSpan?>>), TypeInfoPropertyName = "T8597")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<TimeSpan?>, int>), TypeInfoPropertyName = "T8598")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<TimeSpan?>>), TypeInfoPropertyName = "T8599")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<TimeSpan?>>), TypeInfoPropertyName = "T8600")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<TimeSpan?>>), TypeInfoPropertyName = "T8601")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<TimeSpan?>>), TypeInfoPropertyName = "T8602")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<TimeSpan?>, int>), TypeInfoPropertyName = "T8603")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, TimeSpan?>>), TypeInfoPropertyName = "T8604")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, TimeSpan?>>), TypeInfoPropertyName = "T8605")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, TimeSpan?>>), TypeInfoPropertyName = "T8606")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, TimeSpan?>>), TypeInfoPropertyName = "T8607")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, TimeSpan?>, int>), TypeInfoPropertyName = "T8608")]
-[JsonSerializable(typeof(Cn_class_C<TimeSpan?>), TypeInfoPropertyName = "T8609")]
-[JsonSerializable(typeof(Cn_record_class_C<TimeSpan?>), TypeInfoPropertyName = "T8610")]
-[JsonSerializable(typeof(Cn_struct_C<TimeSpan?>), TypeInfoPropertyName = "T8611")]
-[JsonSerializable(typeof(Cn_record_struct_C<TimeSpan?>), TypeInfoPropertyName = "T8612")]
-[JsonSerializable(typeof(Cn_generic_type_C<TimeSpan?, int>), TypeInfoPropertyName = "T8613")]
-[JsonSerializable(typeof(Cn_class_R<TimeSpan?>), TypeInfoPropertyName = "T8614")]
-[JsonSerializable(typeof(Cn_record_class_R<TimeSpan?>), TypeInfoPropertyName = "T8615")]
-[JsonSerializable(typeof(Cn_struct_R<TimeSpan?>), TypeInfoPropertyName = "T8616")]
-[JsonSerializable(typeof(Cn_record_struct_R<TimeSpan?>), TypeInfoPropertyName = "T8617")]
-[JsonSerializable(typeof(Cn_generic_type_R<TimeSpan?, int>), TypeInfoPropertyName = "T8618")]
-[JsonSerializable(typeof(Cn_class_P<PBP_TimeSpan_N>), TypeInfoPropertyName = "T8619")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_TimeSpan_N>), TypeInfoPropertyName = "T8620")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_TimeSpan_N>), TypeInfoPropertyName = "T8621")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_TimeSpan_N>), TypeInfoPropertyName = "T8622")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_TimeSpan_N, int>), TypeInfoPropertyName = "T8623")]
-[JsonSerializable(typeof(PEnum?), TypeInfoPropertyName = "T8624")]
-[JsonSerializable(typeof(Cn_class_F<PEnum?>), TypeInfoPropertyName = "T8625")]
-[JsonSerializable(typeof(Cn_record_class_F<PEnum?>), TypeInfoPropertyName = "T8626")]
-[JsonSerializable(typeof(Cn_struct_F<PEnum?>), TypeInfoPropertyName = "T8627")]
-[JsonSerializable(typeof(Cn_record_struct_F<PEnum?>), TypeInfoPropertyName = "T8628")]
-[JsonSerializable(typeof(Cn_generic_type_F<PEnum?, int>), TypeInfoPropertyName = "T8629")]
-[JsonSerializable(typeof(Cn_class_P<List<PEnum?>>), TypeInfoPropertyName = "T8630")]
-[JsonSerializable(typeof(Cn_record_class_P<List<PEnum?>>), TypeInfoPropertyName = "T8631")]
-[JsonSerializable(typeof(Cn_struct_P<List<PEnum?>>), TypeInfoPropertyName = "T8632")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<PEnum?>>), TypeInfoPropertyName = "T8633")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<PEnum?>, int>), TypeInfoPropertyName = "T8634")]
-[JsonSerializable(typeof(Cn_class_P<PEnum?[]>), TypeInfoPropertyName = "T8635")]
-[JsonSerializable(typeof(Cn_record_class_P<PEnum?[]>), TypeInfoPropertyName = "T8636")]
-[JsonSerializable(typeof(Cn_struct_P<PEnum?[]>), TypeInfoPropertyName = "T8637")]
-[JsonSerializable(typeof(Cn_record_struct_P<PEnum?[]>), TypeInfoPropertyName = "T8638")]
-[JsonSerializable(typeof(Cn_generic_type_P<PEnum?[], int>), TypeInfoPropertyName = "T8639")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<PEnum?>>), TypeInfoPropertyName = "T8640")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<PEnum?>>), TypeInfoPropertyName = "T8641")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<PEnum?>>), TypeInfoPropertyName = "T8642")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<PEnum?>>), TypeInfoPropertyName = "T8643")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<PEnum?>, int>), TypeInfoPropertyName = "T8644")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<PEnum?>>), TypeInfoPropertyName = "T8645")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<PEnum?>>), TypeInfoPropertyName = "T8646")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<PEnum?>>), TypeInfoPropertyName = "T8647")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<PEnum?>>), TypeInfoPropertyName = "T8648")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<PEnum?>, int>), TypeInfoPropertyName = "T8649")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, PEnum?>>), TypeInfoPropertyName = "T8650")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, PEnum?>>), TypeInfoPropertyName = "T8651")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, PEnum?>>), TypeInfoPropertyName = "T8652")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, PEnum?>>), TypeInfoPropertyName = "T8653")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, PEnum?>, int>), TypeInfoPropertyName = "T8654")]
-[JsonSerializable(typeof(Cn_class_C<PEnum?>), TypeInfoPropertyName = "T8655")]
-[JsonSerializable(typeof(Cn_record_class_C<PEnum?>), TypeInfoPropertyName = "T8656")]
-[JsonSerializable(typeof(Cn_struct_C<PEnum?>), TypeInfoPropertyName = "T8657")]
-[JsonSerializable(typeof(Cn_record_struct_C<PEnum?>), TypeInfoPropertyName = "T8658")]
-[JsonSerializable(typeof(Cn_generic_type_C<PEnum?, int>), TypeInfoPropertyName = "T8659")]
-[JsonSerializable(typeof(Cn_class_R<PEnum?>), TypeInfoPropertyName = "T8660")]
-[JsonSerializable(typeof(Cn_record_class_R<PEnum?>), TypeInfoPropertyName = "T8661")]
-[JsonSerializable(typeof(Cn_struct_R<PEnum?>), TypeInfoPropertyName = "T8662")]
-[JsonSerializable(typeof(Cn_record_struct_R<PEnum?>), TypeInfoPropertyName = "T8663")]
-[JsonSerializable(typeof(Cn_generic_type_R<PEnum?, int>), TypeInfoPropertyName = "T8664")]
-[JsonSerializable(typeof(Cn_class_P<PBP_enum_N>), TypeInfoPropertyName = "T8665")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_enum_N>), TypeInfoPropertyName = "T8666")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_enum_N>), TypeInfoPropertyName = "T8667")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_enum_N>), TypeInfoPropertyName = "T8668")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_enum_N, int>), TypeInfoPropertyName = "T8669")]
-[JsonSerializable(typeof(PFlags?), TypeInfoPropertyName = "T8670")]
-[JsonSerializable(typeof(Cn_class_F<PFlags?>), TypeInfoPropertyName = "T8671")]
-[JsonSerializable(typeof(Cn_record_class_F<PFlags?>), TypeInfoPropertyName = "T8672")]
-[JsonSerializable(typeof(Cn_struct_F<PFlags?>), TypeInfoPropertyName = "T8673")]
-[JsonSerializable(typeof(Cn_record_struct_F<PFlags?>), TypeInfoPropertyName = "T8674")]
-[JsonSerializable(typeof(Cn_generic_type_F<PFlags?, int>), TypeInfoPropertyName = "T8675")]
-[JsonSerializable(typeof(Cn_class_P<List<PFlags?>>), TypeInfoPropertyName = "T8676")]
-[JsonSerializable(typeof(Cn_record_class_P<List<PFlags?>>), TypeInfoPropertyName = "T8677")]
-[JsonSerializable(typeof(Cn_struct_P<List<PFlags?>>), TypeInfoPropertyName = "T8678")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<PFlags?>>), TypeInfoPropertyName = "T8679")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<PFlags?>, int>), TypeInfoPropertyName = "T8680")]
-[JsonSerializable(typeof(Cn_class_P<PFlags?[]>), TypeInfoPropertyName = "T8681")]
-[JsonSerializable(typeof(Cn_record_class_P<PFlags?[]>), TypeInfoPropertyName = "T8682")]
-[JsonSerializable(typeof(Cn_struct_P<PFlags?[]>), TypeInfoPropertyName = "T8683")]
-[JsonSerializable(typeof(Cn_record_struct_P<PFlags?[]>), TypeInfoPropertyName = "T8684")]
-[JsonSerializable(typeof(Cn_generic_type_P<PFlags?[], int>), TypeInfoPropertyName = "T8685")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<PFlags?>>), TypeInfoPropertyName = "T8686")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<PFlags?>>), TypeInfoPropertyName = "T8687")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<PFlags?>>), TypeInfoPropertyName = "T8688")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<PFlags?>>), TypeInfoPropertyName = "T8689")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<PFlags?>, int>), TypeInfoPropertyName = "T8690")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<PFlags?>>), TypeInfoPropertyName = "T8691")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<PFlags?>>), TypeInfoPropertyName = "T8692")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<PFlags?>>), TypeInfoPropertyName = "T8693")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<PFlags?>>), TypeInfoPropertyName = "T8694")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<PFlags?>, int>), TypeInfoPropertyName = "T8695")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, PFlags?>>), TypeInfoPropertyName = "T8696")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, PFlags?>>), TypeInfoPropertyName = "T8697")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, PFlags?>>), TypeInfoPropertyName = "T8698")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, PFlags?>>), TypeInfoPropertyName = "T8699")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, PFlags?>, int>), TypeInfoPropertyName = "T8700")]
-[JsonSerializable(typeof(Cn_class_C<PFlags?>), TypeInfoPropertyName = "T8701")]
-[JsonSerializable(typeof(Cn_record_class_C<PFlags?>), TypeInfoPropertyName = "T8702")]
-[JsonSerializable(typeof(Cn_struct_C<PFlags?>), TypeInfoPropertyName = "T8703")]
-[JsonSerializable(typeof(Cn_record_struct_C<PFlags?>), TypeInfoPropertyName = "T8704")]
-[JsonSerializable(typeof(Cn_generic_type_C<PFlags?, int>), TypeInfoPropertyName = "T8705")]
-[JsonSerializable(typeof(Cn_class_R<PFlags?>), TypeInfoPropertyName = "T8706")]
-[JsonSerializable(typeof(Cn_record_class_R<PFlags?>), TypeInfoPropertyName = "T8707")]
-[JsonSerializable(typeof(Cn_struct_R<PFlags?>), TypeInfoPropertyName = "T8708")]
-[JsonSerializable(typeof(Cn_record_struct_R<PFlags?>), TypeInfoPropertyName = "T8709")]
-[JsonSerializable(typeof(Cn_generic_type_R<PFlags?, int>), TypeInfoPropertyName = "T8710")]
-[JsonSerializable(typeof(Cn_class_P<PBP_flags_enum_N>), TypeInfoPropertyName = "T8711")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_flags_enum_N>), TypeInfoPropertyName = "T8712")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_flags_enum_N>), TypeInfoPropertyName = "T8713")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_flags_enum_N>), TypeInfoPropertyName = "T8714")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_flags_enum_N, int>), TypeInfoPropertyName = "T8715")]
-[JsonSerializable(typeof(global::NodaTime.Instant?), TypeInfoPropertyName = "T8716")]
-[JsonSerializable(typeof(Cn_class_F<global::NodaTime.Instant?>), TypeInfoPropertyName = "T8717")]
-[JsonSerializable(typeof(Cn_record_class_F<global::NodaTime.Instant?>), TypeInfoPropertyName = "T8718")]
-[JsonSerializable(typeof(Cn_struct_F<global::NodaTime.Instant?>), TypeInfoPropertyName = "T8719")]
-[JsonSerializable(typeof(Cn_record_struct_F<global::NodaTime.Instant?>), TypeInfoPropertyName = "T8720")]
-[JsonSerializable(typeof(Cn_generic_type_F<global::NodaTime.Instant?, int>), TypeInfoPropertyName = "T8721")]
-[JsonSerializable(typeof(Cn_class_P<List<global::NodaTime.Instant?>>), TypeInfoPropertyName = "T8722")]
-[JsonSerializable(typeof(Cn_record_class_P<List<global::NodaTime.Instant?>>), TypeInfoPropertyName = "T8723")]
-[JsonSerializable(typeof(Cn_struct_P<List<global::NodaTime.Instant?>>), TypeInfoPropertyName = "T8724")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<global::NodaTime.Instant?>>), TypeInfoPropertyName = "T8725")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<global::NodaTime.Instant?>, int>), TypeInfoPropertyName = "T8726")]
-[JsonSerializable(typeof(Cn_class_P<global::NodaTime.Instant?[]>), TypeInfoPropertyName = "T8727")]
-[JsonSerializable(typeof(Cn_record_class_P<global::NodaTime.Instant?[]>), TypeInfoPropertyName = "T8728")]
-[JsonSerializable(typeof(Cn_struct_P<global::NodaTime.Instant?[]>), TypeInfoPropertyName = "T8729")]
-[JsonSerializable(typeof(Cn_record_struct_P<global::NodaTime.Instant?[]>), TypeInfoPropertyName = "T8730")]
-[JsonSerializable(typeof(Cn_generic_type_P<global::NodaTime.Instant?[], int>), TypeInfoPropertyName = "T8731")]
-[JsonSerializable(typeof(Cn_class_P<ImmutableArray<global::NodaTime.Instant?>>), TypeInfoPropertyName = "T8732")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<global::NodaTime.Instant?>>), TypeInfoPropertyName = "T8733")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<global::NodaTime.Instant?>>), TypeInfoPropertyName = "T8734")]
-[JsonSerializable(typeof(Cn_record_struct_P<ImmutableArray<global::NodaTime.Instant?>>), TypeInfoPropertyName = "T8735")]
-[JsonSerializable(typeof(Cn_generic_type_P<ImmutableArray<global::NodaTime.Instant?>, int>), TypeInfoPropertyName = "T8736")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<global::NodaTime.Instant?>>), TypeInfoPropertyName = "T8737")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<global::NodaTime.Instant?>>), TypeInfoPropertyName = "T8738")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<global::NodaTime.Instant?>>), TypeInfoPropertyName = "T8739")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<global::NodaTime.Instant?>>), TypeInfoPropertyName = "T8740")]
-[JsonSerializable(typeof(Cn_generic_type_P<IReadOnlyList<global::NodaTime.Instant?>, int>), TypeInfoPropertyName = "T8741")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, global::NodaTime.Instant?>>), TypeInfoPropertyName = "T8742")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<string, global::NodaTime.Instant?>>), TypeInfoPropertyName = "T8743")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, global::NodaTime.Instant?>>), TypeInfoPropertyName = "T8744")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, global::NodaTime.Instant?>>), TypeInfoPropertyName = "T8745")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, global::NodaTime.Instant?>, int>), TypeInfoPropertyName = "T8746")]
-[JsonSerializable(typeof(Cn_class_C<global::NodaTime.Instant?>), TypeInfoPropertyName = "T8747")]
-[JsonSerializable(typeof(Cn_record_class_C<global::NodaTime.Instant?>), TypeInfoPropertyName = "T8748")]
-[JsonSerializable(typeof(Cn_struct_C<global::NodaTime.Instant?>), TypeInfoPropertyName = "T8749")]
-[JsonSerializable(typeof(Cn_record_struct_C<global::NodaTime.Instant?>), TypeInfoPropertyName = "T8750")]
-[JsonSerializable(typeof(Cn_generic_type_C<global::NodaTime.Instant?, int>), TypeInfoPropertyName = "T8751")]
-[JsonSerializable(typeof(Cn_class_R<global::NodaTime.Instant?>), TypeInfoPropertyName = "T8752")]
-[JsonSerializable(typeof(Cn_record_class_R<global::NodaTime.Instant?>), TypeInfoPropertyName = "T8753")]
-[JsonSerializable(typeof(Cn_struct_R<global::NodaTime.Instant?>), TypeInfoPropertyName = "T8754")]
-[JsonSerializable(typeof(Cn_record_struct_R<global::NodaTime.Instant?>), TypeInfoPropertyName = "T8755")]
-[JsonSerializable(typeof(Cn_generic_type_R<global::NodaTime.Instant?, int>), TypeInfoPropertyName = "T8756")]
-[JsonSerializable(typeof(Cn_class_P<PBP_NodaTime_Instant_N>), TypeInfoPropertyName = "T8757")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_NodaTime_Instant_N>), TypeInfoPropertyName = "T8758")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_NodaTime_Instant_N>), TypeInfoPropertyName = "T8759")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_NodaTime_Instant_N>), TypeInfoPropertyName = "T8760")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_NodaTime_Instant_N, int>), TypeInfoPropertyName = "T8761")]
-[JsonSerializable(typeof(Cn_class_P<PBP_string_>), TypeInfoPropertyName = "T8762")]
-[JsonSerializable(typeof(Cn_record_class_P<PBP_string_>), TypeInfoPropertyName = "T8763")]
-[JsonSerializable(typeof(Cn_struct_P<PBP_string_>), TypeInfoPropertyName = "T8764")]
-[JsonSerializable(typeof(Cn_record_struct_P<PBP_string_>), TypeInfoPropertyName = "T8765")]
-[JsonSerializable(typeof(Cn_generic_type_P<PBP_string_, int>), TypeInfoPropertyName = "T8766")]
-[JsonSerializable(typeof(Cn_class_P<List<Option<V_validated_struct_TimeSpan>>>), TypeInfoPropertyName = "T8767")]
-[JsonSerializable(typeof(Cn_record_struct_F<Option<V_record_struct_DateTime>>), TypeInfoPropertyName = "T8768")]
-[JsonSerializable(typeof(Cn_record_class_P<Result<V_sealed_record_class_bool>[]>), TypeInfoPropertyName = "T8769")]
-[JsonSerializable(typeof(Cn_struct_P<Result<V_record_struct_DateTimeOffset, ShapeFault>>), TypeInfoPropertyName = "T8770")]
-[JsonSerializable(typeof(Cn_record_class_P<global::Probes.Json.L06PB_PSet_RTE>), TypeInfoPropertyName = "T8771")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<Result<V_sealed_record_class_string, ShapeFault>>, int>), TypeInfoPropertyName = "T8772")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, Result<V_validated_class_char, ShapeFault>>>), TypeInfoPropertyName = "T8773")]
-[JsonSerializable(typeof(Result<V_validated_struct_byte, ShapeFault>), TypeInfoPropertyName = "T8774")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<Result<V_record_struct_double, ShapeFault>>>), TypeInfoPropertyName = "T8775")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<Option<V_sealed_record_class_enum>>>), TypeInfoPropertyName = "T8776")]
-[JsonSerializable(typeof(Cn_record_class_C<Result<V_record_struct_DateOnly, ShapeFault>>), TypeInfoPropertyName = "T8777")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<Result<V_record_struct_flags_enum, ShapeFault>>>), TypeInfoPropertyName = "T8778")]
-[JsonSerializable(typeof(Cn_class_P<Option<PSet>[]>), TypeInfoPropertyName = "T8779")]
-[JsonSerializable(typeof(Cn_struct_R<Option<V_sealed_record_class_int>>), TypeInfoPropertyName = "T8780")]
-[JsonSerializable(typeof(Cn_record_class_P<Dictionary<Result<PSet>, int>>), TypeInfoPropertyName = "T8781")]
-[JsonSerializable(typeof(Cn_record_class_P<Result<V_record_struct_decimal, ShapeFault>?>), TypeInfoPropertyName = "T8782")]
-[JsonSerializable(typeof(Cn_generic_type_P<global::Probes.Json.L06PB_V_record_struct_long_RTE, int>), TypeInfoPropertyName = "T8783")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<Result<V_validated_struct_ulong, ShapeFault>>>), TypeInfoPropertyName = "T8784")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<Result<V_validated_class_Uri>>>), TypeInfoPropertyName = "T8785")]
-[JsonSerializable(typeof(Cn_struct_P<List<Result<V_sealed_record_class_DateOnly, ShapeFault>>>), TypeInfoPropertyName = "T8786")]
-[JsonSerializable(typeof(Cn_class_P<Patch<Result<V_sealed_record_class_NodaTime_Instant>>>), TypeInfoPropertyName = "T8787")]
-[JsonSerializable(typeof(Cn_record_class_P<IReadOnlyList<Result<V_validated_struct_flags_enum>>>), TypeInfoPropertyName = "T8788")]
-[JsonSerializable(typeof(Result<V_record_struct_ulong>), TypeInfoPropertyName = "T8789")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, Result<V_validated_class_double>>>), TypeInfoPropertyName = "T8790")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<Result<V_validated_class_int, ShapeFault>>>), TypeInfoPropertyName = "T8791")]
-[JsonSerializable(typeof(Cn_record_struct_F<Result<V_validated_class_byte, ShapeFault>>), TypeInfoPropertyName = "T8792")]
-[JsonSerializable(typeof(Cn_record_class_P<Result<V_record_struct_Guid, ShapeFault>[]>), TypeInfoPropertyName = "T8793")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<Result<V_sealed_record_class_char>>>), TypeInfoPropertyName = "T8794")]
-[JsonSerializable(typeof(Cn_record_class_P<Result<V_validated_struct_double, ShapeFault>[]>), TypeInfoPropertyName = "T8795")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<Option<V_validated_struct_long>>>), TypeInfoPropertyName = "T8796")]
-[JsonSerializable(typeof(Cn_struct_C<Result<V_validated_struct_enum, ShapeFault>>), TypeInfoPropertyName = "T8797")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<string, Result<V_validated_struct_decimal>>>), TypeInfoPropertyName = "T8798")]
-[JsonSerializable(typeof(Cn_struct_C<Option<V_validated_struct_string>>), TypeInfoPropertyName = "T8799")]
-[JsonSerializable(typeof(Cn_generic_type_P<Result<V_validated_struct_flags_enum, ShapeFault>?, int>), TypeInfoPropertyName = "T8800")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<Result<V_validated_struct_int, ShapeFault>>>), TypeInfoPropertyName = "T8801")]
-[JsonSerializable(typeof(Result<V_sealed_record_class_TimeOnly, ShapeFault>), TypeInfoPropertyName = "T8802")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, Option<PSet>>>), TypeInfoPropertyName = "T8803")]
-[JsonSerializable(typeof(Result<V_validated_class_Guid, ShapeFault>), TypeInfoPropertyName = "T8804")]
-[JsonSerializable(typeof(Cn_record_struct_F<Result<V_validated_struct_DateTimeOffset, ShapeFault>>), TypeInfoPropertyName = "T8805")]
-[JsonSerializable(typeof(Cn_class_P<Dictionary<Result<V_validated_class_NodaTime_Instant, ShapeFault>, int>>), TypeInfoPropertyName = "T8806")]
-[JsonSerializable(typeof(Cn_record_struct_F<Result<V_validated_class_long, ShapeFault>>), TypeInfoPropertyName = "T8807")]
-[JsonSerializable(typeof(Cn_class_R<Result<V_validated_class_flags_enum, ShapeFault>>), TypeInfoPropertyName = "T8808")]
-[JsonSerializable(typeof(Result<V_validated_class_string, ShapeFault>), TypeInfoPropertyName = "T8809")]
-[JsonSerializable(typeof(Cn_record_class_P<Patch<Result<V_validated_class_own_record_class, ShapeFault>>>), TypeInfoPropertyName = "T8810")]
-[JsonSerializable(typeof(Cn_class_P<global::Probes.Json.L06PB_V_validated_struct_TimeOnly_RTE>), TypeInfoPropertyName = "T8811")]
-[JsonSerializable(typeof(Cn_generic_type_P<global::Probes.Json.L06PB_V_validated_class_char_RTE, int>), TypeInfoPropertyName = "T8812")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<Option<V_sealed_record_class_byte>>>), TypeInfoPropertyName = "T8813")]
-[JsonSerializable(typeof(Cn_record_struct_P<IReadOnlyList<Result<V_record_struct_DateOnly, ShapeFault>>>), TypeInfoPropertyName = "T8814")]
-[JsonSerializable(typeof(Cn_class_P<global::Probes.Json.L06PB_V_sealed_record_class_int_RE>), TypeInfoPropertyName = "T8815")]
-[JsonSerializable(typeof(Cn_class_P<List<Result<V_record_struct_bool, ShapeFault>>>), TypeInfoPropertyName = "T8816")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<Option<V_sealed_record_class_Guid>, int>>), TypeInfoPropertyName = "T8817")]
-[JsonSerializable(typeof(Cn_struct_R<Result<V_validated_class_ulong, ShapeFault>>), TypeInfoPropertyName = "T8818")]
-[JsonSerializable(typeof(Cn_record_class_P<Result<V_validated_class_own_record_class>[]>), TypeInfoPropertyName = "T8819")]
-[JsonSerializable(typeof(Result<V_sealed_record_class_flags_enum>), TypeInfoPropertyName = "T8820")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<Option<V_validated_struct_char>>>), TypeInfoPropertyName = "T8821")]
-[JsonSerializable(typeof(Cn_record_struct_C<Result<V_sealed_record_class_own_record_class, ShapeFault>>), TypeInfoPropertyName = "T8822")]
-[JsonSerializable(typeof(Cn_class_C<Result<V_record_struct_Uri, ShapeFault>>), TypeInfoPropertyName = "T8823")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<Option<V_validated_class_DateOnly>>>), TypeInfoPropertyName = "T8824")]
-[JsonSerializable(typeof(Cn_record_class_P<Result<V_validated_class_DateTime, ShapeFault>[]>), TypeInfoPropertyName = "T8825")]
-[JsonSerializable(typeof(Result<V_record_struct_int, ShapeFault>), TypeInfoPropertyName = "T8826")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<Result<V_validated_class_ulong, ShapeFault>>>), TypeInfoPropertyName = "T8827")]
-[JsonSerializable(typeof(Cn_record_struct_P<Result<V_validated_struct_ulong, ShapeFault>?>), TypeInfoPropertyName = "T8828")]
-[JsonSerializable(typeof(Cn_class_P<IReadOnlyList<Result<V_record_struct_TimeSpan>>>), TypeInfoPropertyName = "T8829")]
-[JsonSerializable(typeof(Cn_struct_P<List<Result<V_validated_class_Uri, ShapeFault>>>), TypeInfoPropertyName = "T8830")]
-[JsonSerializable(typeof(Cn_struct_P<Result<V_sealed_record_class_DateOnly, ShapeFault>[]>), TypeInfoPropertyName = "T8831")]
-[JsonSerializable(typeof(Cn_record_struct_F<Result<V_validated_class_int, ShapeFault>>), TypeInfoPropertyName = "T8832")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<Result<V_sealed_record_class_ulong>>, int>), TypeInfoPropertyName = "T8833")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<Option<V_record_struct_long>, int>>), TypeInfoPropertyName = "T8834")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<Result<V_sealed_record_class_Uri, ShapeFault>, int>, int>), TypeInfoPropertyName = "T8835")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<Result<V_sealed_record_class_int>, int>>), TypeInfoPropertyName = "T8836")]
-[JsonSerializable(typeof(Cn_record_struct_P<global::Probes.Json.L06PB_V_validated_class_enum_O>), TypeInfoPropertyName = "T8837")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<string, Result<V_validated_class_DateOnly>>>), TypeInfoPropertyName = "T8838")]
-[JsonSerializable(typeof(Cn_record_struct_P<Result<V_record_struct_bool, ShapeFault>>), TypeInfoPropertyName = "T8839")]
-[JsonSerializable(typeof(Cn_record_class_P<Result<V_validated_class_bool>?>), TypeInfoPropertyName = "T8840")]
-[JsonSerializable(typeof(Cn_record_struct_P<List<Result<V_validated_struct_flags_enum, ShapeFault>>>), TypeInfoPropertyName = "T8841")]
-[JsonSerializable(typeof(Cn_class_P<Option<V_validated_struct_int>?>), TypeInfoPropertyName = "T8842")]
-[JsonSerializable(typeof(Cn_record_struct_P<global::Probes.Json.L06PB_V_validated_struct_DateTimeOffset_O>), TypeInfoPropertyName = "T8843")]
-[JsonSerializable(typeof(Cn_class_P<global::Probes.Json.L06PB_PSet_RTE>), TypeInfoPropertyName = "T8844")]
-[JsonSerializable(typeof(Cn_record_struct_C<Result<V_record_struct_flags_enum, ShapeFault>>), TypeInfoPropertyName = "T8845")]
-[JsonSerializable(typeof(Cn_record_struct_P<Dictionary<Result<V_validated_class_char, ShapeFault>, int>>), TypeInfoPropertyName = "T8846")]
-[JsonSerializable(typeof(Cn_generic_type_F<Result<V_validated_class_DateOnly, ShapeFault>, int>), TypeInfoPropertyName = "T8847")]
-[JsonSerializable(typeof(Result<PSet, ShapeFault>), TypeInfoPropertyName = "T8848")]
-[JsonSerializable(typeof(Cn_struct_C<Result<PSet>>), TypeInfoPropertyName = "T8849")]
-[JsonSerializable(typeof(Cn_generic_type_P<List<Result<V_record_struct_DateTime, ShapeFault>>, int>), TypeInfoPropertyName = "T8850")]
-[JsonSerializable(typeof(Cn_record_struct_P<global::Probes.Json.L06PB_V_record_struct_byte_RE>), TypeInfoPropertyName = "T8851")]
-[JsonSerializable(typeof(Cn_struct_P<ImmutableArray<Option<V_sealed_record_class_TimeSpan>>>), TypeInfoPropertyName = "T8852")]
-[JsonSerializable(typeof(Cn_class_R<Result<V_record_struct_NodaTime_Instant, ShapeFault>>), TypeInfoPropertyName = "T8853")]
-[JsonSerializable(typeof(Cn_struct_R<Option<V_validated_class_byte>>), TypeInfoPropertyName = "T8854")]
-[JsonSerializable(typeof(Cn_struct_P<Option<V_validated_struct_char>>), TypeInfoPropertyName = "T8855")]
-[JsonSerializable(typeof(Cn_record_class_P<Result<V_record_struct_string, ShapeFault>>), TypeInfoPropertyName = "T8856")]
-[JsonSerializable(typeof(Cn_record_struct_R<Option<V_validated_struct_long>>), TypeInfoPropertyName = "T8857")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<Result<V_validated_struct_DateOnly, ShapeFault>>>), TypeInfoPropertyName = "T8858")]
-[JsonSerializable(typeof(Cn_record_class_P<ImmutableArray<Result<V_validated_class_ulong, ShapeFault>>>), TypeInfoPropertyName = "T8859")]
-[JsonSerializable(typeof(Cn_record_struct_P<Patch<Result<V_record_struct_Uri, ShapeFault>>>), TypeInfoPropertyName = "T8860")]
-[JsonSerializable(typeof(Result<V_validated_struct_char, ShapeFault>), TypeInfoPropertyName = "T8861")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<string, Result<V_validated_struct_Uri, ShapeFault>>>), TypeInfoPropertyName = "T8862")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<Result<V_validated_struct_DateTimeOffset, ShapeFault>>, int>), TypeInfoPropertyName = "T8863")]
-[JsonSerializable(typeof(Cn_struct_P<Result<V_record_struct_TimeOnly, ShapeFault>>), TypeInfoPropertyName = "T8864")]
-[JsonSerializable(typeof(Cn_generic_type_P<Dictionary<string, Result<V_validated_class_TimeSpan, ShapeFault>>, int>), TypeInfoPropertyName = "T8865")]
-[JsonSerializable(typeof(Cn_record_struct_F<Result<V_sealed_record_class_char, ShapeFault>>), TypeInfoPropertyName = "T8866")]
-[JsonSerializable(typeof(Cn_struct_P<Dictionary<Option<V_validated_class_own_record_class>, int>>), TypeInfoPropertyName = "T8867")]
-[JsonSerializable(typeof(Cn_record_class_P<List<Result<PSet>>>), TypeInfoPropertyName = "T8868")]
-[JsonSerializable(typeof(Cn_class_F<Result<V_sealed_record_class_flags_enum>>), TypeInfoPropertyName = "T8869")]
-[JsonSerializable(typeof(Cn_record_struct_F<Option<V_record_struct_int>>), TypeInfoPropertyName = "T8870")]
-[JsonSerializable(typeof(Cn_struct_P<IReadOnlyList<Result<V_record_struct_DateTime, ShapeFault>>>), TypeInfoPropertyName = "T8871")]
-[JsonSerializable(typeof(Cn_generic_type_P<Patch<Result<V_record_struct_double, ShapeFault>>, int>), TypeInfoPropertyName = "T8872")]
-[JsonSerializable(typeof(Cn_record_struct_F<Result<V_record_struct_string, ShapeFault>>), TypeInfoPropertyName = "T8873")]
-public partial class ProbeContext : JsonSerializerContext { }
diff --git a/tools/probe/corpus/harness/ShrinkProbe.cs b/tools/probe/corpus/harness/ShrinkProbe.cs
deleted file mode 100644
index 24b32853..00000000
--- a/tools/probe/corpus/harness/ShrinkProbe.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Debug aid: PROBE_SHRINK="rowsfile:idx:check" shrinks a failing row by resetting axes; writes /tmp/shrink.txt. check = baseline.
-using Probes.Shapes;
-namespace Probes;
-public sealed class ShrinkProbe
-{
-    [Fact]
-    public async Task Shrink()
-    {
-        var spec = Environment.GetEnvironmentVariable("PROBE_SHRINK"); if (spec is null) return;
-        var p = spec.Split(':');
-        Func<Row, Task<string?>> check = p[2] switch
-        {
-            "baseline" => x => HttpBaseline.Run(x, Registry.Of(x)),
-            _ => ShrinkChecks.For(p[2]) ?? throw new ArgumentException(p[2]),
-        };
-        var sb = new System.Text.StringBuilder();
-        foreach (var idx in p[1].Split(','))
-        {
-            try
-            {
-                var (s, f) = await Shrinker.Shrink(Rows.Get(p[0], int.Parse(idx)), check);
-                sb.AppendLine($"#{idx} SHRUNK: {s}\n      FAILURE: {f.Replace("\n", " | ")}");
-            }
-            catch (Exception ex) { sb.AppendLine($"#{idx} (no shrink: {ex.Message})"); }
-        }
-        File.WriteAllText("/tmp/shrink.txt", sb.ToString());
-    }
-}
-public static class ShrinkChecks
-{
-    public static readonly Dictionary<string, Func<Row, Task<string?>>> All = new();
-    public static Func<Row, Task<string?>>? For(string name) => All.TryGetValue(name, out var f) ? f : null;
-}
diff --git a/tools/probe/corpus/harness/Sides.cs b/tools/probe/corpus/harness/Sides.cs
deleted file mode 100644
index aedc9f05..00000000
--- a/tools/probe/corpus/harness/Sides.cs
+++ /dev/null
@@ -1,317 +0,0 @@
-// The three-sided differential: the rules every comparison of a value object with its wrapped twin follows, in one place. A comparison
-// has three sides:
-//   (1) the wrapped twin without TypeKit: for http a host without AddTypeKit() and without TypeKit's JSON converters
-//       (HostCfg.WithoutTypeKit); in process, the twin under the application's options less TypeKit's converters (WithoutTypeKit);
-//   (2) the wrapped twin with TypeKit, as the row configures it;
-//   (3) the value object.
-// Side (1) is read from a fact's fixture where one covers the row's configuration (Fact, FactFixture), and the check's baseline is then
-// Baseline.Fact("KB-NNN"); otherwise it is measured, and the baseline is Baseline.Framework. A configuration measured here that no fact
-// covers and that decides rows is pinned as a fact with its test and fixture (design/knowledge), never as a note key.
-// The rules:
-//   - (1) and (3) refuse alike, at the same operation and stage with the same exception type and the same HTTP status: the framework
-//     refuses, and the check ends expected-refusal against side (1)'s baseline (NoteKeys.FrameworkRefuses). No message is compared: the
-//     stage is what an exception's properties say (a JsonException's Path), never its text.
-//   - (1) answers and (3) refuses, or (1) refuses and (3) answers: a violation, unless a sentence makes the difference intended, cited by
-//     the check (a not-promised entry of the claim, or the docs section a calibration cites).
-//   - (2) differs from (1): a violation, "TypeKit changed the wrapped type's behaviour" (Interferes). (2) and (3) agreeing on a wrong answer
-//     is why side (1) runs on every row of a claim whose obligations promise non-interference (NonInterference).
-//   - Elsewhere side (1) runs lazily, only where (2) and (3) disagree or refuse.
-using System.Text.Json;
-using System.Text.Json.Nodes;
-using System.Text.Json.Serialization;
-using System.Text.Json.Serialization.Metadata;
-using CodoMetis.TypeKit.Facts;
-namespace Probes.Shapes;
-
-public static class Sides
-{
-    /// <summary>
-    /// One side's answer to one operation: the text it gave, or the exception it threw or the status it answered with. A side read from a
-    /// fixture has no exception object, only the type the fixture names (<see cref="Refusal"/>).
-    /// </summary>
-    public sealed record Answer(string Operation, string? Value, Exception? Thrown = null, int? Status = null, string? FixtureRefusal = null)
-    {
-        public bool Refused => Thrown is not null || FixtureRefusal is not null || Status is { } s && s is not (>= 200 and < 300);
-        /// <summary>The refusal's exception type, by its full name; null for an answer or a refusal by status alone.</summary>
-        public string? Refusal => Thrown?.GetType().FullName ?? FixtureRefusal;
-        /// <summary>
-        /// Where the refusal was met, from the exception's properties and never from its message: the JSON path a JsonException names. A side
-        /// read from a fixture has none: the settings its answer covers (the depth a value is written at) say where.
-        /// </summary>
-        public string? Stage => FixtureRefusal is not null ? null : Thrown is JsonException j ? j.Path ?? "" : "";
-        public override string ToString() =>
-            Refused ? $"{Operation} refused ({string.Join(" ", new[] { Thrown?.GetType().Name ?? FixtureRefusal, Status?.ToString() }.Where(x => x is not null))}{(Stage is { Length: > 0 } at ? " at " + at : "")})"
-                    : $"{Operation} {Cut(Value)}";
-    }
-
-    /// <summary>(1) and (3) refuse alike: at the same operation and stage, with the same exception type and the same status. No message is compared.</summary>
-    public static bool Alike(Answer one, Answer three) =>
-        one.Refused && three.Refused && one.Operation == three.Operation && one.Refusal == three.Refusal && one.Status == three.Status
-        && (one.Stage is null || SameStage(one.Stage, three.Stage!));
-
-    /// <summary>
-    /// Two refusals' stages are the same: the same JSON path, or, where one side writes or reads its value through a nested call of the
-    /// serializer, whose path starts at that value (a value object over a class the serializer walks), the other's path ending in it.
-    /// </summary>
-    static bool SameStage(string a, string b) =>
-        a == b || (b.Length > 1 && b[0] == '$' && a.EndsWith(b[1..], StringComparison.Ordinal)) || (a.Length > 1 && a[0] == '$' && b.EndsWith(a[1..], StringComparison.Ordinal));
-
-    /// <summary>
-    /// (2) is not (1): TypeKit changed what the wrapped type does. The failure, or null where the two are the same answer: the same text, or
-    /// a refusal alike (a refusal's body, such as a problem's trace id, is not compared).
-    /// </summary>
-    public static string? Interferes(Answer one, Answer two) =>
-        one.Refused == two.Refused && one.Refusal == two.Refusal && one.Status == two.Status && one.Stage == two.Stage && (one.Refused || one.Value == two.Value) ? null
-        : $"{two.Operation}: TypeKit changed the wrapped type's behaviour: without TypeKit {one}, with it {two}";
-
-    /// <summary>
-    /// Ends a check whose sides (1) and (3) refuse alike: the framework's refusal, an expected refusal that earns nothing. The check runs
-    /// against side (1)'s baseline, which its caller chose (<see cref="Side.Baseline"/>).
-    /// </summary>
-    public static string? Refuses(Check c, Side one, Answer three)
-    {
-        c.Note(NoteKeys.FrameworkRefuses, $"{three}, {one.Source}");
-        return null;
-    }
-
-    /// <summary>
-    /// One check of the differential. Where side (1) refuses alike with (3) (<paramref name="framework"/>), the check is the framework's
-    /// refusal, against side (1)'s baseline; otherwise <paramref name="body"/> compares, against <paramref name="against"/>, once (2) is held
-    /// to (1) where side (1) ran (<paramref name="one"/>, <paramref name="two"/>).
-    /// </summary>
-    public static string? Check(Row r, string obligation, Baseline against, Side? framework, Answer three, Answer? one, Answer? two, Func<Check, string?> body) =>
-        framework is not null && Alike(framework.Answer, three)
-            ? r.Check(obligation, framework.Baseline, c => Refuses(c, framework, three))
-            : r.Check(obligation, against, c => (one is not null && two is not null ? Interferes(one, two) : null) ?? body(c));
-
-    /// <summary>The asynchronous form of <see cref="Check(Row, string, Baseline, Side?, Answer, Answer?, Answer?, Func{Check, string?})"/>.</summary>
-    public static Task<string?> Check(Row r, string obligation, Baseline against, Side? framework, Answer three, Answer? one, Answer? two, Func<Check, Task<string?>> body) =>
-        framework is not null && Alike(framework.Answer, three)
-            ? Task.FromResult(r.Check(obligation, framework.Baseline, c => Refuses(c, framework, three)))
-            : r.Check(obligation, against, async c => (one is not null && two is not null ? Interferes(one, two) : null) ?? await body(c));
-
-    /// <summary>
-    /// Side (1) where the value object refused (<paramref name="three"/>), as the framework's: the twin without TypeKit refusing alike
-    /// (<paramref name="one"/>), or, where the twin answered, a converter's value under the row's depth limit (<see cref="WrittenByAConverter"/>).
-    /// Null where the framework does not refuse alike, and the check compares.
-    /// </summary>
-    public static Side? Framework(Row r, Entry e, Held twin, JsonSerializerOptions oneOptions, Answer one, Answer three)
-    {
-        if (!three.Refused) return null;
-        if (one.Refused) return Alike(one, three) ? Measured(one, "the twin under the application's options, less TypeKit's converters") : null;
-        return WrittenByAConverter(r, e, twin, oneOptions, three) is { } s && Alike(s.Answer, three) ? s : null;
-    }
-
-    /// <summary>Side (1) as a check uses it: its answer, the baseline it stands for, and where it came from.</summary>
-    public sealed record Side(Answer Answer, Baseline Baseline, string Source);
-
-    /// <summary>Side (1) measured: the framework without TypeKit, run in the same row.</summary>
-    public static Side Measured(Answer a, string how) => new(a, Baseline.Framework, "measured: " + how);
-
-    // ---- the twin
-
-    /// <summary>
-    /// The twin and the value object at the row's position in its containing type, each around its sample: the one place where both sides
-    /// of a two-sided comparison are built, and where the precondition of every such comparison is held, that the twin and the value object
-    /// hold the same shape (Equivalence.Shapes: the twin stands where the value object stands, at its nullability). A mismatch is a harness
-    /// error, never a pass: it throws, and the check or row that asked ends as one.
-    /// </summary>
-    public static (Held Twin, Held Vo) Twins(string position, string containing, Entry e, object plain, object vo)
-    {
-        var hp = Pos.Build(position, containing, e, false, plain);
-        var hv = Pos.Build(position, containing, e, true, vo);
-        if (Equivalence.Shapes(hp.Declared, hv.Declared, e) is { } why) throw new InputsNotEquivalent(why);
-        return (hp, hv);
-    }
-
-    /// <summary>The twin and the value object do not hold the same shape: the harness built a comparison that compares nothing.</summary>
-    public sealed class InputsNotEquivalent(string why) : Exception("inputs not equivalent: " + why);
-
-    // ---- which obligations promise non-interference
-
-    /// <summary>
-    /// The obligations whose sentence promises that the value object leaves the wrapped type as ASP.NET or System.Text.Json have it ("as the
-    /// underlying type's", "the one ASP.NET Core publishes for the underlying type", "unaffected"), read from each claim's obligations in
-    /// claims.json. Side (1) runs on every row that checks one of them. C12's parameter-keeps-aspnet and C01's covers-every-decimal already
-    /// compare with the framework without TypeKit's converters on every row (SchemaClaim's Baseline.Framework, DecimalSpelling's serializer's
-    /// own decimal); the text claims compare with the wrapped type's own text, which TypeKit adds nothing to.
-    /// </summary>
-    static readonly Dictionary<string, string[]> NonInterference = new()
-    {
-        ["C21-openapi-schema-parity"] = ["the-underlying-types-schema", "nullable-admits-null-as-the-wrapped-does", "container-elements", "dictionary-key", "every-document-version"],
-        ["L01-json-bytes"] = ["the-underlying-types-json", "as-a-dictionary-key-too", "read-as-the-underlying-type-reads"],
-        ["C10-preserve-guard"] = ["value-converters-unaffected", "own-converters-unaffected", "ignore-cycles-unaffected"],
-    };
-
-    /// <summary>Whether side (1) runs on every row for this obligation of the row's claim, not only where (2) and (3) disagree or refuse.</summary>
-    public static bool Unconditional(Row r, string obligation) =>
-        r.Claim is { } claim && NonInterference.TryGetValue(claim, out var obligations) && obligations.Contains(obligation);
-
-    /// <summary>
-    /// Whether a type is or holds one of TypeKit's own (a Patch, an Option), through its type arguments and element type: a twin that holds
-    /// one has no side without TypeKit.
-    /// </summary>
-    public static bool HoldsTypeKit(Type t) =>
-        t.Assembly == typeof(CodoMetis.TypeKit.ValueObjects.StoredJsonConverterFactory).Assembly
-        || (t.IsArray && HoldsTypeKit(t.GetElementType()!))
-        || (t.IsGenericType && t.GetGenericArguments().Any(HoldsTypeKit));
-
-    // ---- side (1) in process: the twin under the application's options, less TypeKit's converters
-
-    /// <summary>The application's options less what TypeKit adds to them: its converters (StoredJsonConverterFactory, the decimal converters), told by their assembly.</summary>
-    public static JsonSerializerOptions WithoutTypeKit(JsonSerializerOptions o)
-    {
-        var one = new JsonSerializerOptions(o);
-        DropTypeKit(one);
-        return one;
-    }
-
-    /// <summary>Removes TypeKit's converters from options in place: a host's side (1) (HostCfg.WithoutTypeKit).</summary>
-    public static void DropTypeKit(JsonSerializerOptions o)
-    {
-        var typeKit = typeof(CodoMetis.TypeKit.ValueObjects.StoredJsonConverterFactory).Assembly;
-        foreach (var x in o.Converters.Where(x => x.GetType().Assembly == typeKit).ToList()) o.Converters.Remove(x);
-    }
-
-    /// <summary>A side's write of a held shape.</summary>
-    public static Answer Write(Held h, JsonSerializerOptions o, string operation = "write")
-    {
-        try { return new(operation, JsonSerializer.Serialize(h.Value, h.Declared, o)); }
-        catch (Exception x) { return new(operation, null, x); }
-    }
-
-    /// <summary>A side's read of a text into a held shape, and what it read written again: a refusal of the write back is the operation "write back".</summary>
-    public static Answer Read(string text, Held h, JsonSerializerOptions o, string operation = "read")
-    {
-        object? v;
-        try { v = JsonSerializer.Deserialize(text, h.Declared, o); }
-        catch (Exception x) { return new(operation, null, x); }
-        try { return new(operation, v is null ? "null" : JsonSerializer.Serialize(v, h.Declared, o)); }
-        catch (Exception x) { return new("write back", null, x); }
-    }
-
-    // ---- side (1) of a value a converter writes, under a depth limit (KB-040)
-
-    /// <summary>
-    /// Side (1) where the value object, which its converter writes, refused a write that the twin, which the serializer's own converter writes,
-    /// answered, under the row's json.MaxDepth: System.Text.Json charges a converter's value a level against the limit (KB-040), so the
-    /// framework's side for a converter-written value is a converter of the application's for the wrapped type, without TypeKit. Read from
-    /// KB-040's fixture where an answer covers the row's depth limit and the depth the value is written at, else measured with that
-    /// converter in the same row. Null where the row sets no depth limit, (3) refused no write, or the depth cannot be read.
-    /// </summary>
-    public static Side? WrittenByAConverter(Row r, Entry e, Held twin, JsonSerializerOptions one, Answer three)
-    {
-        if (r.Get("json.MaxDepth") is null or "default" || three.Thrown is null || three.Operation is not ("write" or "write back")) return null;
-        if (ConverterDepth(e, twin, one) is not { } depth) { r.Log.AppendLine(Why = $"side (1) of a converter's value: no depth read for {Make.Held(e.Plain).Name} ({Unread})"); return null; }
-        var settings = Settings(r, ("written-by", "a-converter"), ("writer-depth", depth.ToString(System.Globalization.CultureInfo.InvariantCulture)));
-        if (Covered(r, "KB-040", settings) is { Kind: FactAnswer.Exception } answer)
-            return new(new(three.Operation, null, FixtureRefusal: (string?)answer.Value["type"]), Baseline.Fact("KB-040"),
-                       $"KB-040 {answer.Id}: a converter's value at depth {depth} under MaxDepth {r["json.MaxDepth"]}");
-        var measured = ByAConverter(e, twin, one, three.Operation);
-        Why = $"side (1) of a converter's value at depth {depth}: no KB-040 answer covers it, measured {measured?.ToString() ?? "nothing"}";
-        return measured is null ? null : Measured(measured, $"the twin written by a converter of the application's at depth {depth}");
-    }
-
-    /// <summary>The writer's depth where the serializer hands the wrapped value to a converter, read by one that records it, without a limit.</summary>
-    static int? ConverterDepth(Entry e, Held twin, JsonSerializerOptions one)
-    {
-        try
-        {
-            var open = new JsonSerializerOptions(one) { MaxDepth = 64 };
-            var serializers = new JsonSerializerOptions(open);
-            var converter = (IRecordsDepth)Activator.CreateInstance(typeof(PassThrough<>).MakeGenericType(Make.Held(e.Plain)), serializers)!;
-            open.Converters.Insert(0, (JsonConverter)converter);
-            JsonSerializer.Serialize(twin.Value, twin.Declared, open);
-            Unread = converter.Depth >= 0 ? null : "no value handed to the converter";
-            return converter.Depth >= 0 ? converter.Depth : null;
-        }
-        catch (Exception x) { Unread = x.GetType().Name + ": " + Cut(x.Message); return null; }   // the twin is not written with a converter of the application's here: no depth to read
-    }
-    [ThreadStatic] static string? Unread;
-    /// <summary>Why the last <see cref="WrittenByAConverter"/> on this thread gave no fixture's side, for a failure to name.</summary>
-    [ThreadStatic] public static string? Why;
-
-    /// <summary>The twin written (and, for a write back, read and written again) by a converter of the application's that writes as the serializer does.</summary>
-    static Answer? ByAConverter(Entry e, Held twin, JsonSerializerOptions one, string operation)
-    {
-        try
-        {
-            var with = new JsonSerializerOptions(one);
-            with.Converters.Insert(0, (JsonConverter)Activator.CreateInstance(typeof(PassThrough<>).MakeGenericType(Make.Held(e.Plain)), new JsonSerializerOptions(one))!);
-            return Write(twin, with, operation);
-        }
-        catch (Exception) { return null; }
-    }
-
-    interface IRecordsDepth { int Depth { get; } }
-
-    /// <summary>A converter of the application's for the wrapped type, without TypeKit: it writes and reads through the serializer's own contract for it, and records the writer's depth.</summary>
-    sealed class PassThrough<T>(JsonSerializerOptions serializers) : JsonConverter<T>, IRecordsDepth where T : notnull
-    {
-        // options a host or a row built without a resolver get the serializer's default one, as JsonSerializer gives them on first use
-        readonly JsonTypeInfo<T> info = (JsonTypeInfo<T>)Resolving(serializers).GetTypeInfo(typeof(T));
-        static JsonSerializerOptions Resolving(JsonSerializerOptions o) { o.TypeInfoResolver ??= new DefaultJsonTypeInfoResolver(); return o; }
-        public int Depth { get; private set; } = -1;
-        public override T? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => JsonSerializer.Deserialize(ref reader, info);
-        public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options) { Depth = Math.Max(Depth, writer.CurrentDepth); JsonSerializer.Serialize(writer, value, info); }
-        public override T ReadAsPropertyName(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => ((JsonConverter<T>)info.Converter).ReadAsPropertyName(ref reader, typeToConvert, serializers);
-        public override void WriteAsPropertyName(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
-        { Depth = Math.Max(Depth, writer.CurrentDepth); ((JsonConverter<T>)info.Converter).WriteAsPropertyName(writer, value, serializers); }
-    }
-
-    // ---- facts' fixtures
-
-    static readonly Dictionary<string, FactFixture?> Fixtures = new();
-
-    /// <summary>
-    /// A fact's fixture as side (1), as FactFixture's rule says: only a fixture the fact's entry names on its <c>fixture:</c> line, read from the
-    /// repository (the Facts project's test/CodoMetis.TypeKit.Facts, found by walking up to CodoMetis.TypeKit.slnx), never written. Null where
-    /// the fact names none. Whether `docs-query check` is clean is CI's to hold: the harness does not run it.
-    /// </summary>
-    public static FactFixture? Fact(string id)
-    {
-        lock (Fixtures)
-        {
-            if (Fixtures.TryGetValue(id, out var known)) return known;
-            var root = new DirectoryInfo(AppContext.BaseDirectory);
-            while (root is not null && !File.Exists(Path.Combine(root.FullName, "CodoMetis.TypeKit.slnx"))) root = root.Parent;
-            FactFixture? fixture = null;
-            if (root is not null)
-            {
-                var file = FactFixture.FileName(id);
-                var entry = Directory.EnumerateFiles(Path.Combine(root.FullName, "design", "knowledge"), id + "-*.md").FirstOrDefault();
-                // the entry's frontmatter, between its first two "---" lines, names the fixture
-                var named = entry is not null && File.ReadLines(entry).Skip(1).TakeWhile(l => l != "---")
-                    .Any(l => l.Trim() == $"fixture: test/CodoMetis.TypeKit.Facts/{file}");
-                var path = Path.Combine(root.FullName, "test", "CodoMetis.TypeKit.Facts", file);
-                if (named && File.Exists(path)) fixture = FactFixture.Load(path);
-            }
-            return Fixtures[id] = fixture;
-        }
-    }
-
-    /// <summary>
-    /// The row's settings as a fixture's answers name them: every axis at the value that applied (a substitution's, else the row's), unread,
-    /// and the settings the harness measured (<paramref name="measured"/>), such as the depth a value is written at. The caller marks read
-    /// the axes of the answer that covers them (<see cref="Covered"/>).
-    /// </summary>
-    public static Dictionary<string, string> Settings(Row r, params (string Key, string Value)[] measured)
-    {
-        var s = new Dictionary<string, string>(StringComparer.Ordinal);
-        Dictionary<string, string> applied;
-        lock (r.Ev) applied = new(r.Ev.Applied);
-        foreach (var (axis, value) in r.Values) s[axis] = applied.TryGetValue(axis, out var a) ? a : value;
-        foreach (var (key, value) in measured) s[key] = value;
-        return s;
-    }
-
-    /// <summary>The answer of a fact's fixture that covers the row's settings, its axes then read for the running check; null where none does.</summary>
-    public static FactAnswer? Covered(Row r, string fact, Dictionary<string, string> settings)
-    {
-        if (Fact(fact)?.For(settings) is not { } answer) return null;
-        foreach (var axis in answer.When.Keys) _ = r.Get(axis);
-        return answer;
-    }
-
-    static string Cut(string? s) => s is null ? "(null)" : s.Length > 160 ? s[..160] + "..." : s;
-}
diff --git a/tools/probe/corpus/harness/TextRow.cs b/tools/probe/corpus/harness/TextRow.cs
deleted file mode 100644
index a2df1d53..00000000
--- a/tools/probe/corpus/harness/TextRow.cs
+++ /dev/null
@@ -1,664 +0,0 @@
-// Shared text surface of the harness: applies a row's text.entry x text.culture x process.converter-lookup to a value object (by reflection over the
-// generated members), and the three text claims' checks (L02 no-quote, L03 one-rule, L04 round-trip) which also run the row's JSON half.
-using System.ComponentModel;
-using System.Globalization;
-using System.Reflection;
-using System.Text.Json;
-using CodoMetis.TypeKit;
-namespace Probes.Shapes;
-
-public sealed record Out(bool NotApplicable, bool Ok, object? Value, Exception? Ex, string? Text)
-{
-    public static Out NA => new(true, false, null, null, null);
-}
-
-public static class TextOps
-{
-    public const string Secret = "S3CR3T-xyz";
-    public static object? PI<V>(string s) where V : IParsable<V> => V.Parse(s, null);
-    public static object? PS<V>(string s) where V : ISpanParsable<V> => V.Parse(s.AsSpan(), null);
-    public static string FS<V>(V v, int size, out bool ok, out int written) where V : ISpanFormattable
-    { Span<char> buf = new char[size]; ok = v.TryFormat(buf, out written, default, null); return new string(buf[..written]); }
-
-    public static bool Implements(Type open, Type t) => t.GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == open);
-    public static bool Lossy(Entry e) => e.Wrapped is "TimeOnly" or "DateTime" or "DateTimeOffset";
-    public static string? Fmt(Entry e) => Lossy(e) ? "O" : null;
-
-    public static void Prepare(Row r, Entry e)
-    {
-        var c = r["text.culture"];
-        try { CultureInfo.CurrentCulture = c switch { "de-DE" => new("de-DE"), "tr-TR" => new("tr-TR"), "ar-SA" => new("ar-SA"), _ => CultureInfo.InvariantCulture }; }
-        catch (CultureNotFoundException) { CultureInfo.CurrentCulture = CultureInfo.InvariantCulture; r.Substituted("text.culture", "globalization-invariant", "culture unavailable in this process"); }
-        CultureInfo.CurrentUICulture = CultureInfo.CurrentCulture;
-        bool gi; try { gi = new CultureInfo("de-DE").NumberFormat.NumberDecimalSeparator == "."; } catch (CultureNotFoundException) { gi = true; }
-        if (c == "globalization-invariant" && !gi) r.Substituted("text.culture", "invariant", "the process is not in globalization-invariant mode");
-        if (c != "globalization-invariant" && gi) r.Substituted("text.culture", "globalization-invariant", "the process is in globalization-invariant mode");
-        if (r["process.converter-lookup"] == "wrapped-type-converter-looked-up-first") _ = TypeDescriptor.GetConverter(Make.Held(e.Plain));
-    }
-
-    static Out Unwrap(Func<Out> f)
-    {
-        try { return f(); }
-        catch (TargetInvocationException t) { return new(false, false, null, t.InnerException, null); }
-        catch (Exception ex) { return new(false, false, null, ex, null); }
-    }
-
-    /// <summary>Plain text of a wrapped value the way the value object formats it (invariant), used as the sample's text.</summary>
-    public static string PlainText(Entry e, object plain) => plain is IFormattable f ? f.ToString(Fmt(e), CultureInfo.InvariantCulture) : plain.ToString()!;
-
-    /// <summary>The value object reads text: a generated Parse(string, IFormatProvider), or a closed set's Parse(string) by name.</summary>
-    public static bool HasText(Entry e) => e.Vo.GetMethod("Parse", [typeof(string), typeof(IFormatProvider)]) is not null || ByName(e, "Parse", [typeof(string)]) is not null;
-    /// <summary>A closed set's own Parse and TryParse, by name and ordinal (Generators README#matching-parsing-and-binding): the provider means nothing to a name.</summary>
-    static MethodInfo? ByName(Entry e, string name, Type[] parameters) => e.Kind == "closed-set" ? e.Vo.GetMethod(name, parameters) : null;
-
-    public static Out Read(Entry e, string entry, string text) => Unwrap(() =>
-    {
-        switch (entry)
-        {
-            case "Parse":
-            {
-                var m = e.Vo.GetMethod("Parse", [typeof(string), typeof(IFormatProvider)]);
-                if (m is not null) return new(false, true, m.Invoke(null, [text, null]), null, null);
-                return ByName(e, "Parse", [typeof(string)]) is { } n ? new(false, true, n.Invoke(null, [text]), null, null) : Out.NA;
-            }
-            case "TryParse":
-            {
-                var m = e.Vo.GetMethod("TryParse", [typeof(string), typeof(IFormatProvider), e.Vo.MakeByRefType()]);
-                if (m is not null) { var a = new object?[] { text, null, null }; var ok = (bool)m.Invoke(null, a)!; return new(false, ok, a[2], null, null); }
-                if (ByName(e, "TryParse", [typeof(string), e.Vo.MakeByRefType()]) is not { } n) return Out.NA;
-                var b = new object?[] { text, null }; var found = (bool)n.Invoke(null, b)!;
-                return new(false, found, b[1], null, null);
-            }
-            case "IParsable":
-            {
-                if (!Implements(typeof(IParsable<>), e.Vo)) return Out.NA;
-                return new(false, true, typeof(TextOps).GetMethod(nameof(PI))!.MakeGenericMethod(e.Vo).Invoke(null, [text]), null, null);
-            }
-            case "ISpanParsable":
-            {
-                if (!Implements(typeof(ISpanParsable<>), e.Vo)) return Out.NA;
-                return new(false, true, typeof(TextOps).GetMethod(nameof(PS))!.MakeGenericMethod(e.Vo).Invoke(null, [text]), null, null);
-            }
-            case "type-converter":
-            {
-                var c = TypeDescriptor.GetConverter(e.Vo); if (!c.CanConvertFrom(typeof(string))) return Out.NA;
-                return new(false, true, c.ConvertFrom(null, null, text), null, null);
-            }
-            default: return Out.NA;
-        }
-    });
-
-    /// <summary>The text the entry writes for the value object (null = entry writes no text).</summary>
-    public static Out Write(Entry e, string entry, object vo) => Unwrap(() =>
-    {
-        switch (entry)
-        {
-            case "type-converter":
-            {
-                var c = TypeDescriptor.GetConverter(e.Vo); if (!c.CanConvertTo(typeof(string))) return Out.NA;
-                return new(false, true, null, null, c.ConvertTo(null, null, vo, typeof(string)) as string);
-            }
-            case "ToString-format": return vo is IFormattable f ? new(false, true, null, null, f.ToString(Fmt(e), null)) : Out.NA;
-            case "TryFormat-short-span":
-            {
-                if (vo is not ISpanFormattable) return Out.NA;
-                var m = typeof(TextOps).GetMethod(nameof(FS))!.MakeGenericMethod(e.Vo);
-                var big = new object?[] { vo, 4096, null, null }; var t = (string)m.Invoke(null, big)!;
-                return new(false, (bool)big[2]!, null, null, t);
-            }
-            default: return new(false, true, null, null, Fmt(e) is { } fm && vo is IFormattable g ? g.ToString(fm, null) : vo.ToString());
-        }
-    });
-
-    public static bool ValidatedKind(Entry e) => e.Kind.StartsWith("validated");
-
-    /// <summary>TryFrom (validated) or From (otherwise) on the wrapped value: Ok + value, or NotApplicable.</summary>
-    public static Out TryFrom(Entry e, object plain) => Unwrap(() =>
-    {
-        if (e.Kind == "closed-set") return Out.NA;
-        if (ValidatedKind(e))
-        {
-            var m = e.Vo.GetMethod("TryFrom", [Make.Held(e.Plain)]); if (m is null) return Out.NA;
-            var opt = m.Invoke(null, [plain])!; var g = opt.GetType().GetMethod("TryGetValue")!;
-            var a = new object?[] { null }; var ok = (bool)g.Invoke(opt, a)!; return new(false, ok, a[0], null, null);
-        }
-        return new(false, true, Make.Vo(e, plain), null, null);
-    });
-}
-
-public static class TextClaims
-{
-    static readonly string[] Entries = ["Parse", "TryParse", "TryFrom", "type-converter", "IParsable", "ISpanParsable", "ToString-format", "TryFormat-short-span"];
-    static bool Reads(string entry) => entry is "Parse" or "TryParse" or "IParsable" or "ISpanParsable" or "type-converter";
-
-    static bool WrappedLosesItToo(Entry e, object plain)
-    {
-        var parse = Make.Held(e.Plain).GetMethod("Parse", [typeof(string), typeof(IFormatProvider)]);
-        if (parse is null) return false;
-        try { return !Equals(parse.Invoke(null, [Convert.ToString(plain), null]), plain); }
-        catch (TargetInvocationException) { return true; }
-    }
-
-    static bool Same(Entry e, object? a, object? b) => a is not null && b is not null && (a.Equals(b) || (e.Wrapped == "DateTime" && ((DateTime)Make.Unwrap(e, a)).ToUniversalTime() == ((DateTime)Make.Unwrap(e, b)).ToUniversalTime()));
-
-    /// <summary>
-    /// Why a generated text entry is missing, where a document says it is not generated: a closed set's surface is its own (Generators
-    /// README#closed-sets), no parsing is generated over a type that cannot be parsed, and no span parsing over a type that has none
-    /// (#what-is-generated). Each is declared in claims.json too; null where nothing says it is missing.
-    /// </summary>
-    static string? Missing(Entry e, string entry)
-    {
-        if (e.Kind == "closed-set") return entry is "TryFrom" or "ISpanParsable" or "ToString-format" or "TryFormat-short-span" ? "closed-set" : null;
-        if (!TextOps.HasText(e) && entry is not ("ToString-format" or "TryFormat-short-span" or "TryFrom")) return "not-parsable";
-        if (entry == "ISpanParsable" && e.Wrapped is "Uri" or "enum" or "flags-enum" or "NodaTime.Instant") return "no-span-parsing";
-        return null;
-    }
-    /// <summary>The check does not apply: the entry <see cref="Missing"/> names is not generated, cited by the sentence that says so.</summary>
-    static string? NotGenerated(Check c, Entry e, string entry) => Missing(e, entry) switch
-    {
-        "closed-set" => c.Inapplicable(Cite.Docs("src/CodoMetis.TypeKit.Generators/README.md#closed-sets"), entry),
-        _ => c.Inapplicable(Cite.Docs("src/CodoMetis.TypeKit.Generators/README.md#what-is-generated"), entry),
-    };
-
-    // ---- L04: write then read gives back the value; text half and JSON half
-    /// <summary>
-    /// L04's checks: the generated ToString() is the wrapped type's invariant text whatever the culture (invariant-whatever-the-culture);
-    /// the row's writing entry writes the same (the-type-converter-writes-the-same); that text, or TryFrom's value, reads back as the same
-    /// value wherever the wrapped type's own does (text-reads-back); and the JSON half, the value object's own document read back and the
-    /// row's changed input refused with a JsonException naming the value object (json-refusal-is-a-json-exception). Every check runs;
-    /// returns the first failure.
-    /// </summary>
-    public static string? RoundTrip(Row r, Entry e)
-    {
-        TextOps.Prepare(r, e);
-        var entry = r["text.entry"]; var plain = e.Valid(); var vo = Make.Vo(e, plain);
-        var fails = new List<string?>();
-        if (entry == "TryFrom")
-            fails.Add(r.Check("text-reads-back", Baseline.RoundTrip, c =>
-            {
-                var t = TextOps.TryFrom(e, plain);
-                if (t.NotApplicable) return Missing(e, entry) is not null ? NotGenerated(c, e, entry) : "TryFrom is not generated for the value object";
-                if (!t.Ok || !Same(e, t.Value, vo)) return $"TryFrom(valid) gave ok={t.Ok} value={t.Value}, expected {vo}";
-                c.Note(NoteKeys.Compared, "TryFrom(valid)");
-                return null;
-            }));
-        else
-        {
-            var invariant = TextOps.PlainText(e, plain);
-            var w0 = TextOps.Write(e, "ToString", vo);
-            fails.Add(r.Check("invariant-whatever-the-culture", Baseline.Twin, c =>
-            {
-                if (w0.Ex is not null) return $"ToString(): threw {w0.Ex.GetType().Name}: {w0.Ex.Message}";
-                if (w0.Text != invariant) return $"ToString(): text '{w0.Text}' differs from the wrapped type's invariant text '{invariant}' under culture {c["text.culture"]}";
-                c.Note(NoteKeys.Compared, $"ToString() under {c["text.culture"]}");
-                return null;
-            }));
-            var writes = entry is "ToString-format" or "TryFormat-short-span" or "type-converter";
-            var w = writes ? TextOps.Write(e, entry, vo) : w0;
-            if (writes)
-                fails.Add(r.Check("the-type-converter-writes-the-same", Baseline.Twin, c =>
-                {
-                    if (w.NotApplicable)
-                    {
-                        if (Missing(e, entry) is not null) return NotGenerated(c, e, entry);
-                        // TryFormat is generated where the wrapped type has it (ValueObjectFormattableAspect); the wrapped type has none either
-                        if (entry == "TryFormat-short-span" && !typeof(ISpanFormattable).IsAssignableFrom(Make.Held(e.Plain)))
-                            return c.Inconclusive($"no TryFormat: the wrapped {Make.Held(e.Plain).Name} has no ISpanFormattable either");
-                        return $"{entry}: the value object writes no text where the wrapped {Make.Held(e.Plain).Name} does";
-                    }
-                    if (w.Ex is not null) return $"{entry}: writing text threw {w.Ex.GetType().Name}: {w.Ex.Message}";
-                    var text = w.Text!;
-                    var wantText = entry is "TryFormat-short-span" or "type-converter" ? (plain is IFormattable pf ? pf.ToString(null, CultureInfo.InvariantCulture) : plain.ToString()!) : invariant;
-                    if (text != wantText) return $"{entry}: text '{text}' differs from the wrapped type's invariant text '{wantText}' under culture {c["text.culture"]}";
-                    if (entry == "TryFormat-short-span")
-                    {
-                        var args = new object?[] { vo, 1, null, null };
-                        try
-                        {
-                            typeof(TextOps).GetMethod(nameof(TextOps.FS))!.MakeGenericMethod(e.Vo).Invoke(null, args);
-                            if (text.Length > 1 && (bool)args[2]!) return $"TryFormat into a 1-char span said it fit text of {text.Length} chars";
-                            if (text.Length > 1 && (int)args[3]! != 0) return "TryFormat wrote chars into a too-short span and still returned false";
-                        }
-                        catch (TargetInvocationException t) { return $"TryFormat into a short span threw {t.InnerException!.GetType().Name}"; }
-                    }
-                    c.Note(NoteKeys.Compared, $"{entry} under {c["text.culture"]}");
-                    return null;
-                }));
-            fails.Add(r.Check("text-reads-back", Baseline.RoundTrip, c =>
-            {
-                var readEntry = entry is "ToString-format" or "TryFormat-short-span" ? "Parse" : entry;
-                if (Missing(e, entry) is not null) return NotGenerated(c, e, entry);
-                if (Missing(e, readEntry) is not null) return NotGenerated(c, e, readEntry);
-                if (w.NotApplicable || w.Ex is not null || w.Text is null) return c.Inconclusive($"{entry}: no text written to read back, judged by the-type-converter-writes-the-same");
-                // claims.json declares it: not-promised dates-and-times-lose-detail-as-text
-                if (entry == "type-converter" && TextOps.Lossy(e)) return c.Inapplicable(Cite.NotPromised("dates-and-times-lose-detail-as-text"), entry);
-                var text = w.Text;
-                var back = TextOps.Read(e, readEntry, text);
-                if (back.NotApplicable) return $"{readEntry}: the value object has no {readEntry} to read its own text '{text}' back";
-                if (back.Ex is not null) return $"{readEntry}: reading back '{text}' threw {back.Ex.GetType().Name}: {back.Ex.Message}";
-                if (!back.Ok) return $"{readEntry}: could not read back its own text '{text}'";
-                if (!Same(e, back.Value, vo))
-                {
-                    // Differential: the value object only has to round-trip where its wrapped type does
-                    // (TimeOnly.ToString() under the invariant culture prints HH:mm and drops the seconds).
-                    if (!WrappedLosesItToo(e, plain)) return $"{readEntry}: '{text}' read back as {back.Value}, expected {vo}";
-                    if (TextOps.Lossy(e)) return c.Inapplicable(Cite.NotPromised("dates-and-times-lose-detail-as-text"), $"{readEntry}: the wrapped type's own text does not read back either");
-                    return c.Inapplicable(Cite.Docs("src/CodoMetis.TypeKit.Generators/README.md#parsing-and-formatting"), $"{readEntry}: the wrapped type's own text does not read back either");   // "wherever the underlying type's own does"
-                }
-                c.Note(NoteKeys.Compared, $"{readEntry} read back '{text}'");
-                return null;
-            }));
-        }
-        fails.AddRange(JsonRoundTrip(r, e));
-        return fails.FirstOrDefault(f => f is not null);
-    }
-
-    /// <summary>
-    /// L04's JSON half, json-refusal-is-a-json-exception: the value object's own document reads back as written (the round trip the
-    /// refusal is measured from), and the row's changed input is read or refused with a JsonException, at the root naming the value object
-    /// and carrying no inner exception ("Input it can't read throws a JsonException naming the value object and the underlying type").
-    /// Three-sided (Sides): where the value object (3) refuses, the twin without TypeKit's converters (1) refusing alike is the framework's
-    /// refusal, and so is a converter's value refused under the row's depth limit (KB-040).
-    /// </summary>
-    static List<string?> JsonRoundTrip(Row r, Entry e)
-    {
-        const string Obligation = "json-refusal-is-a-json-exception";
-        var o = JsonRow.Apply(r, e).Options!;
-        var one = Sides.WithoutTypeKit(o);
-        var pos = r["shape.position"]; var con = r.Get("shape.containing") ?? "class";
-        var plain = e.Valid(); var vo = Make.Vo(e, plain);
-        var (hp, hv) = Sides.Twins(pos, con, e, plain, vo);
-        var w3 = Sides.Write(hv, o); var jv = w3.Value;
-        bool Guarded(Exception? x, Check c) => c.Is("json.ReferenceHandler", "Preserve") && e.Wrapped == "own-record-class" && x is NotSupportedException;
-        var fails = new List<string?>();
-        // the round trip: the value object's write, then its own document read back and written again; side (1) where it refuses
-        Sides.Answer w2 = Sides.Write(hp, o), three, two, first;
-        if (w3.Refused) { three = w3; two = w2; first = Sides.Write(hp, one); }
-        else
-        {
-            three = Sides.Read(jv!, hv, o);
-            two = w2.Value is { } jp ? Sides.Read(jp, hp, o) : w2;
-            first = Sides.Write(hp, one) is { Value: { } j1 } ? Sides.Read(j1, hp, one) : Sides.Write(hp, one);
-        }
-        var lazy = three.Refused || two.Refused;
-        fails.Add(Sides.Check(r, Obligation, Baseline.RoundTrip, lazy ? Sides.Framework(r, e, hp, one, first, three) : null, three, lazy ? first : null, lazy ? two : null, c =>
-        {
-            if (w3.Refused)
-            {
-                if (w2.Refused) return c.Inconclusive($"write: both refuse, not alike: the wrapped type {w2}, the value object {w3}");
-                if (Guarded(w3.Thrown, c)) return c.Refused(Cite.Docs("src/CodoMetis.TypeKit.Generators/README.md#json"), "write");
-                return $"serializing threw {w3.Thrown!.GetType().Name} where the wrapped type did not: {w3.Thrown.Message}";
-            }
-            if (three.Refused)
-            {
-                if (Guarded(three.Thrown, c)) return c.Refused(Cite.Docs("src/CodoMetis.TypeKit.Generators/README.md#json"), "read back");
-                // the wrapped twin does not read its own document back under these options either, not alike: nothing to compare
-                if (two.Refused) return c.Inconclusive($"read back: the wrapped type does not read its own document back under these options either, not alike: {two}, the value object {three}");
-                return $"own JSON {Cut(jv)} did not read back: {three.Thrown!.GetType().Name}: {Cut(three.Thrown.Message)}";
-            }
-            if (three.Value != jv)
-            {
-                // under Preserve the serializer numbers references per call: the twin's document read back and written again, alike
-                if (c.Is("json.ReferenceHandler", "Preserve") && w2.Value is { } tj && two.Value != tj)
-                    return c.Inconclusive($"JSON round trip: written again it differs, for the wrapped type alike ({Cut(tj)} / {Cut(two.Value)})");
-                return $"JSON round trip differs: wrote {Cut(jv)}, read and wrote {Cut(three.Value)}";
-            }
-            c.Note(NoteKeys.Compared, "JSON round trip");
-            return null;
-        }));
-        // a changed input must be read or refused with a JsonException (never another type)
-        var input = r["input.json"];
-        if (input != "valid" && jv is not null)
-        {
-            var text = JsonParity.InputFor(input, e, o, jv, pos);
-            var i3 = new Sides.Answer("read", null, Thrown(() => JsonSerializer.Deserialize(text, hv.Declared, o)));
-            // side (1) where the value object refuses with another exception than a JsonException: the twin without TypeKit, reading the same text
-            Sides.Answer? i1 = i3.Thrown is not null and not JsonException ? new("read", null, Thrown(() => JsonSerializer.Deserialize(text, hp.Declared, one))) : null;
-            var framework = i1 is not null && Sides.Alike(i1, i3) && !r.Is("json.Converters", "own-for-value-object") ? Sides.Measured(i1, "the twin reading the same text, less TypeKit's converters") : null;
-            fails.Add(Sides.Check(r, Obligation, Baseline.Refusal, framework, i3, null, null, c =>
-            {
-                // "Your own converter wins": the application's converter reads the value object, so what it throws is its own. It shares the
-                // obligation with the round trip above, which runs under it, so it is decided here, not declared in claims.json.
-                if (c.Is("json.Converters", "own-for-value-object")) return c.Inapplicable(Cite.Docs("src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says"), "input " + input);
-                if (text == jv) return c.Inconclusive($"input {input}: no place for it in {Cut(jv)}");
-                if (i3.Thrown is { } ex2 and not JsonException)
-                {
-                    if (Guarded(ex2, c)) return c.Refused(Cite.Docs("src/CodoMetis.TypeKit.Generators/README.md#json"), "input " + input);
-                    if (i1 is { Refused: true }) return c.Inconclusive($"input {input}: both refuse, not alike: the wrapped type {i1}, the value object {i3}");
-                    return $"input {input}: {ex2.GetType().Name} instead of JsonException: {Cut(ex2.Message)}"
-                        + (ex2.InnerException is { } inner ? $" / inner {inner.GetType().FullName}: {Cut(inner.Message)} @ {Cut(inner.StackTrace?.Split('\n').FirstOrDefault()?.Trim() ?? "")}" : "");
-                }
-                if (RootRefusal(e, o, input) is { } refusal) return refusal;
-                c.Note(NoteKeys.Compared, $"input {input}: {(i3.Thrown is null ? "read" : "a JsonException")}");
-                return null;
-            }));
-        }
-        return fails;
-    }
-
-    static Exception? Thrown(Action a) { try { a(); return null; } catch (Exception x) { return x; } }
-
-    /// <summary>
-    /// The changed input read at the root, where no container stands between the serializer and the generated converter: a
-    /// JsonException the value object throws there names it and carries no inner exception, "Input it can't read throws a
-    /// JsonException naming the value object and the underlying type" (Generators README#json).
-    /// </summary>
-    static string? RootRefusal(Entry e, JsonSerializerOptions o, string input)
-    {
-        var vt = Make.Held(e.Vo);
-        string root;
-        try { root = JsonSerializer.Serialize(Make.Vo(e, e.Valid()), vt, o); } catch { return null; }   // a root the options refuse to write is judged above
-        var text = JsonParity.InputFor(input, e, o, root, "root");
-        if (text == root) return null;
-        try { JsonSerializer.Deserialize(text, vt, o); return null; }
-        catch (JsonException x)
-        {
-            if (x.InnerException is { } i) return $"input {input} at the root: the JsonException carries an inner {i.GetType().Name}: {Cut(x.Message)}\n  text={Cut(text)}";
-            if (!x.Message.Contains(vt.Name, StringComparison.Ordinal)) return $"input {input} at the root: the JsonException does not name {vt.Name}: {Cut(x.Message)}\n  text={Cut(text)}";
-            return null;
-        }
-        catch (Exception) { return null; }   // another exception type is judged above, at the row's position
-    }
-    internal static string Cut(string? s) => s is null ? "(null)" : s.Length > 160 ? s[..160] + "..." : s;
-
-    // ---- L02: a rejection never repeats the input
-    /// <summary>How often a text holds the input: L02's claim is about the text of a refusal, so this is the check, never an excuse.</summary>
-    static int Occurrences(string text, string needle)
-    {
-        var n = 0;
-        for (var i = text.IndexOf(needle, StringComparison.Ordinal); i >= 0; i = text.IndexOf(needle, i + needle.Length, StringComparison.Ordinal)) n++;
-        return n;
-    }
-
-    /// <summary>
-    /// L02's checks: a parsing entry's refusal of a secret, or of the text Create refuses, neither quotes it (parsing-never-repeats, a
-    /// FormatException where it is not the type converter's) nor carries an inner exception that does (no-inner-that-quotes); and a JSON
-    /// read of the secret, or of the row's changed input, where the wrapped value stands in the document refuses without quoting it, but
-    /// for the dictionary key System.Text.Json puts in the Path (json-never-repeats). Every check runs; returns the first failure.
-    /// </summary>
-    public static string? NoQuote(Row r, Entry e)
-    {
-        TextOps.Prepare(r, e);
-        var entry = r["text.entry"]; var plain = e.Valid();
-        var texts = new List<string> { TextOps.Secret };
-        if (TextOps.ValidatedKind(e) && e.Refused() is { } rf) texts.Add(TextOps.PlainText(e, rf));
-        var fails = new List<string?>();
-        if (Reads(entry))
-        {
-            var outs = texts.Select(t => (Text: t, Out: TextOps.Read(e, entry, t))).ToList();
-            string? Absent(Check c) => Missing(e, entry) is not null ? NotGenerated(c, e, entry) : $"{entry}: the value object does not read text through it";
-            fails.Add(r.Check("parsing-never-repeats", Baseline.Refusal, c =>
-            {
-                if (outs.Any(x => x.Out.NotApplicable)) return Absent(c);
-                var refused = 0;
-                foreach (var (t, o) in outs)
-                {
-                    if (o.Ex is null) { if (!o.Ok) refused++; continue; }   // TryParse answers false: a refusal with nothing to quote
-                    refused++;
-                    if (entry == "TryParse") return $"TryParse threw {o.Ex.GetType().Name} on '{t}': {Cut(o.Ex.Message)}";
-                    if (o.Ex.Message.Contains(t)) return $"{entry}: {o.Ex.GetType().Name} quotes the input: {Cut(o.Ex.Message)}";
-                    if (entry != "type-converter" && o.Ex is not FormatException) return $"{entry}: refusal of '{t}' is {o.Ex.GetType().Name}, not FormatException: {Cut(o.Ex.Message)}";
-                }
-                if (refused == 0) return c.Inconclusive($"{entry}: every text read, none refused: nothing to quote");
-                c.Note(NoteKeys.Compared, $"{entry}: {refused} refused without the text");
-                return null;
-            }));
-            fails.Add(r.Check("no-inner-that-quotes", Baseline.Refusal, c =>
-            {
-                if (outs.Any(x => x.Out.NotApplicable)) return Absent(c);
-                var thrown = 0;
-                foreach (var (t, o) in outs)
-                {
-                    if (o.Ex is null) continue;
-                    thrown++;
-                    if (o.Ex.InnerException is { } inner && inner.Message.Contains(t)) return $"{entry}: inner {inner.GetType().Name} quotes the input";
-                    if (o.Ex.InnerException is not null && entry != "type-converter") return $"{entry}: refusal of '{t}' carries an inner {o.Ex.InnerException.GetType().Name}";
-                    if (entry == "type-converter" && o.Ex.InnerException is not null) c.Note(NoteKeys.ConverterWrapsInner);
-                }
-                if (thrown == 0) return c.Inconclusive($"{entry}: no text refused with an exception: no inner to look at");
-                c.Note(NoteKeys.Compared, $"{entry}: {thrown} refusals without a quoting inner");
-                return null;
-            }));
-        }
-        // JSON half
-        var opts = JsonRow.Apply(r, e).Options!;
-        var one = Sides.WithoutTypeKit(opts);
-        var pos = r["shape.position"]; var con = r.Get("shape.containing") ?? "class";
-        var (hp, hv) = Sides.Twins(pos, con, e, plain, Make.Vo(e, plain));
-        var input = r["input.json"];
-        fails.Add(r.Check("json-never-repeats", Baseline.Refusal, c =>
-        {
-            // the application's own converter owns the message; claims.json declares it
-            if (c.Get("json.Converters") is "own-for-wrapped" or "own-for-value-object") return c.Inapplicable(Cite.NotPromised("the-applications-own-converter"));
-            string? doc = null, sample;
-            try { doc = JsonSerializer.Serialize(hv.Value, hv.Declared, opts); }
-            catch (Exception vx)
-            {
-                // the value object's document is the wrapped type's (L01): where it cannot be written, the twin's places the input
-                try { doc = JsonSerializer.Serialize(hp.Value, hp.Declared, opts); }
-                catch (Exception px) { return c.Inconclusive($"the options refuse the shape, for the wrapped type too: {vx.GetType().Name} / {px.GetType().Name}"); }
-            }
-            try { sample = JsonSerializer.Serialize(Make.Unwrap(e, Make.Vo(e, plain)), e.Plain, opts); }
-            catch (Exception sx) { return c.Inconclusive("the wrapped value alone is not written under these options: " + sx.GetType().Name); }
-            var at = doc.IndexOf(sample, StringComparison.Ordinal);
-            var variants = new List<(string Text, string Needle)>();
-            if (at >= 0) variants.Add((doc[..at] + "\"" + TextOps.Secret + "\"" + doc[(at + sample.Length)..], TextOps.Secret));
-            else if (pos == "dictionary-key" && Probes.Json.Jx.Tokens(doc).FirstOrDefault(t => t.Type == JsonTokenType.PropertyName && t.Text == sample.Trim('"')) is { } key)
-                // a key is a property name, the wrapped value's text without its quotes: the secret goes there
-                variants.Add((Probes.Json.Jx.Rewrite(doc, [key], _ => "\"" + TextOps.Secret + "\""), TextOps.Secret));
-            if (input != "valid" && at >= 0)
-            {
-                var text = JsonParity.InputFor(input, e, opts, doc, pos);
-                var x = text.Length - doc.Length + sample.Length;
-                if (x > 0 && text != doc) { var lit = text.Substring(at, x).Trim('"'); if (lit.Length >= 6 && lit.Length < 60 && lit.All(ch => !char.IsPunctuation(ch) || ch is '-' or ':' or '.')) variants.Add((text, lit)); }
-            }
-            if (variants.Count == 0) return c.Inconclusive($"the wrapped value has no place in {Cut(doc)}: the options leave it out");
-            var rejected = 0; var inPaths = new List<string>();
-            string? Read(string text, string needle)
-            {
-                try { JsonSerializer.Deserialize(text, hv.Declared, opts); }
-                catch (Exception ex)
-                {
-                    rejected++;
-                    // System.Text.Json puts a rejected dictionary key in the JsonException's Path (not-promised a-rejected-dictionary-key-in-the-path):
-                    // the Path is read as the exception's property, and the message must hold the input no more often than its Path does
-                    var inPath = ex is JsonException { Path: { } path } ? Occurrences(path, needle) : 0;
-                    if (Occurrences(ex.Message, needle) > inPath) return $"JSON read: {ex.GetType().Name} quotes the input: {Cut(ex.Message)}" + (pos == "dictionary-key" ? " [dictionary-key]" : "");
-                    if (ex.InnerException is { } inner && inner.Message.Contains(needle)) return $"JSON read: inner {inner.GetType().Name} quotes the input";
-                    // side (1): the twin without TypeKit's converters, reading the same text, shows the serializer's own inner and Path
-                    var twin = Thrown(() => JsonSerializer.Deserialize(text, hp.Declared, one));
-                    if (ex.InnerException is not null && ex is JsonException && !(ex.InnerException is JsonException) && twin?.InnerException is null) return $"JSON read: refusal carries inner {ex.InnerException.GetType().Name}: {Cut(ex.InnerException.Message)}";
-                    if (inPath > 0) inPaths.Add(twin is JsonException { Path: { } tp } && Occurrences(tp, needle) > 0 ? "the key in the Path, the wrapped type's alike" : "the key in the Path, as not-promised a-rejected-dictionary-key-in-the-path says");
-                }
-                return null;
-            }
-            foreach (var (text, needle) in variants)
-                if (Read(text, needle) is { } quoted) return quoted;
-            // A wrapped type that reads every string (a string, a Uri) refuses none of these: what a client sends that it cannot read is a value
-            // of another kind, and an array holding the secret where the wrapped value stands is one (a key is a property name, never an array).
-            if (rejected == 0 && at >= 0 && pos != "dictionary-key"
-                && Read(doc[..at] + "[\"" + TextOps.Secret + "\"]" + doc[(at + sample.Length)..], TextOps.Secret) is { } quotedInArray) return quotedInArray;
-            if (rejected == 0) return c.Inconclusive("every JSON input read, none refused: nothing to quote");
-            c.Note(NoteKeys.Compared, $"JSON read: {rejected} refused without the input" + (inPaths.Count > 0 ? ", " + string.Join(", ", inPaths.Distinct()) : ""));
-            return null;
-        }));
-        return fails.FirstOrDefault(f => f is not null);
-    }
-
-    // ---- L03: one set of rules: every entry runs Create and reports its fault
-    /// <summary>
-    /// L03's checks: TryFrom (tryfrom-runs-create) and the parsing entries (parsing-runs-create) refuse the value Create refuses and accept
-    /// a valid one, the JSON converter reads back what it writes and refuses what Create refuses (json-runs-create), and every refusal,
-    /// FromKnownGood's, the FormatException and the JsonException, names the fault (refusals-name-the-fault). A value object without Create
-    /// is held to accepting the valid value. Every check runs; returns the first failure.
-    /// </summary>
-    public static string? OneRule(Row r, Entry e)
-    {
-        TextOps.Prepare(r, e);
-        var entry = r["text.entry"]; var plain = e.Valid();
-        var fails = new List<string?>();
-        var validated = TextOps.ValidatedKind(e) && e.Refused() is not null;
-        if (!validated)
-        {
-            // no Create: the valid value passes every entry
-            if (entry == "TryFrom")
-                fails.Add(r.Check("tryfrom-runs-create", Baseline.RoundTrip, c =>
-                {
-                    var t = TextOps.TryFrom(e, plain);
-                    if (t.NotApplicable) return Missing(e, entry) is not null ? NotGenerated(c, e, entry) : "TryFrom is not generated for the value object";
-                    if (!t.Ok || t.Ex is not null) return "TryFrom(valid) refused on a value object with no rule";
-                    c.Note(NoteKeys.Compared, "TryFrom(valid), no rule"); return null;
-                }));
-            else if (Reads(entry))
-                fails.Add(r.Check("parsing-runs-create", Baseline.RoundTrip, c =>
-                {
-                    if (Missing(e, entry) is not null) return NotGenerated(c, e, entry);
-                    var o = TextOps.Read(e, entry, TextOps.PlainText(e, plain));
-                    if (o.NotApplicable) return $"{entry}: the value object does not read text through it";
-                    if (o.Ex is not null || !o.Ok) return $"{entry}: valid text refused: {o.Ex?.GetType().Name} {Cut(o.Ex?.Message)}";
-                    c.Note(NoteKeys.Compared, $"{entry}(valid), no rule"); return null;
-                }));
-            fails.AddRange(JsonOneRule(r, e, false));
-            return fails.FirstOrDefault(f => f is not null);
-        }
-        var refusedValue = e.Refused()!;
-        var rtext = TextOps.PlainText(e, refusedValue);
-        if (entry == "TryFrom")
-        {
-            fails.Add(r.Check("tryfrom-runs-create", Baseline.Refusal, c =>
-            {
-                var t = TextOps.TryFrom(e, refusedValue); if (t.Ex is not null) return "TryFrom threw " + t.Ex.GetType().Name; if (t.Ok) return "TryFrom accepted the value Create refuses";
-                c.Note(NoteKeys.Compared, "TryFrom refused"); return null;
-            }));
-            fails.Add(r.Check("refusals-name-the-fault", Baseline.Refusal, c =>
-            {
-                var kg = Unwrap(() => e.Vo.GetMethod("FromKnownGood")!.Invoke(null, [refusedValue, null]));
-                if (kg is not { } kex) return "FromKnownGood accepted the value Create refuses"; if (!kex.Message.Contains("Refused")) return "FromKnownGood does not name the fault: " + Cut(kex.Message);
-                c.Note(NoteKeys.Compared, "FromKnownGood names the fault"); return null;
-            }));
-        }
-        else if (Reads(entry))
-        {
-            var o = Missing(e, entry) is null ? TextOps.Read(e, entry, rtext) : Out.NA;
-            fails.Add(r.Check("parsing-runs-create", Baseline.Refusal, c =>
-            {
-                if (Missing(e, entry) is not null) return NotGenerated(c, e, entry);
-                if (o.NotApplicable) return $"{entry}: the value object does not read text through it";
-                if (entry == "TryParse") { if (o.Ex is not null) return "TryParse threw " + o.Ex.GetType().Name; if (o.Ok) return "TryParse accepted text Create refuses"; }
-                else if (o.Ex is null) return $"{entry} accepted '{rtext}' that Create refuses";
-                c.Note(NoteKeys.Compared, $"{entry} refused"); return null;
-            }));
-            if (entry != "TryParse")
-                fails.Add(r.Check("refusals-name-the-fault", Baseline.Refusal, c =>
-                {
-                    if (Missing(e, entry) is not null) return NotGenerated(c, e, entry);
-                    if (o.NotApplicable || o.Ex is null) return c.Inconclusive($"{entry}: no refusal to name the fault, judged by parsing-runs-create");
-                    if (!o.Ex.Message.Contains("Refused")) return $"{entry}: refusal does not name the fault ({o.Ex.GetType().Name}): {Cut(o.Ex.Message)}";
-                    if (entry != "type-converter" && o.Ex is not FormatException) return $"{entry}: refusal is {o.Ex.GetType().Name}, not FormatException";
-                    c.Note(NoteKeys.Compared, $"{entry}: the {o.Ex.GetType().Name} names the fault"); return null;
-                }));
-        }
-        fails.AddRange(JsonOneRule(r, e, true));
-        return fails.FirstOrDefault(f => f is not null);
-    }
-    static Exception? Unwrap(Func<object?> f) { try { f(); return null; } catch (TargetInvocationException t) { return t.InnerException; } catch (Exception ex) { return ex; } }
-
-    /// <summary>
-    /// The JSON half of "one set of rules", on every row under the row's options: the value object reads back what it writes, and a
-    /// validated one refuses the value Create refuses, where the wrapped type reads it, with a JsonException naming the fault. The two
-    /// named paths are checked as what they are: an application's own converter for the value object takes precedence (it reads its
-    /// own spelling back), and StoredJsonConverterFactory reads the refused value without validation (README, "Only two paths skip
-    /// validation"). Three-sided (Sides): where the value object (3) refuses, the twin without TypeKit's converters (1) refusing alike is
-    /// the framework's refusal, the check an expected refusal against it, and so is a converter's value under a depth limit (KB-040).
-    /// </summary>
-    static List<string?> JsonOneRule(Row r, Entry e, bool validated)
-    {
-        const string Obligation = "json-runs-create";
-        var o = JsonRow.Apply(r, e).Options!;
-        var one = Sides.WithoutTypeKit(o);
-        var pos = r["shape.position"]; var con = r.Get("shape.containing") ?? "class"; var plain = e.Valid();
-        var (hp, hv) = Sides.Twins(pos, con, e, plain, Make.Vo(e, plain));
-        bool Guarded(Exception x) => r.Is("json.ReferenceHandler", "Preserve") && e.Wrapped == "own-record-class" && x is NotSupportedException;
-        var w2 = Sides.Write(hp, o); var w3 = Sides.Write(hv, o);
-        var (jp, xp) = (w2.Value, w2.Thrown); var (jv, xv) = (w3.Value, w3.Thrown);
-        var fails = new List<string?>();
-        // 1. the valid value reads back as written: the write, then the value object's own document read back; side (1) where (3) refuses
-        Sides.Answer three = w3, two = w2, first = Sides.Write(hp, one);
-        if (!w3.Refused)
-        {
-            three = Sides.Read(jv!, hv, o);
-            two = jp is null ? w2 : Sides.Read(jp, hp, o);
-            first = first.Value is { } j1 ? Sides.Read(j1, hp, one) : first;
-        }
-        var framework = three.Refused ? Sides.Framework(r, e, hp, one, first, three) : null;
-        // Why the value object's own document has nothing to compare under the row's options, or null where it reads back: the refused
-        // value is then not told apart from a document the options do not let it read, and step 2 has nothing to check either.
-        string? nothing = framework is not null && Sides.Alike(framework.Answer, three) ? "the framework refuses it: " + three : null;
-        fails.Add(Sides.Check(r, Obligation, Baseline.RoundTrip, framework, three, three.Refused || two.Refused ? first : null, three.Refused || two.Refused ? two : null, c =>
-        {
-            if (xp is not null && xv is not null) { nothing = "write"; return c.Inconclusive($"JSON write: both refuse, not alike: the wrapped type {w2}, the value object {w3}"); }
-            if (xp is not null) { nothing = "the wrapped type is not written"; return c.Inconclusive("JSON write: the wrapped type is not written under these options, the value object is: JSON parity (L01) judges it"); }
-            if (xv is not null)
-            {
-                if (Guarded(xv)) { nothing = "the Preserve guard refuses the value object"; return c.Refused(Cite.Docs("src/CodoMetis.TypeKit.Generators/README.md#json"), "write"); }
-                return $"JSON: the value object is not written where the wrapped type is ({xv.GetType().Name}: {Cut(xv.Message)})";
-            }
-            if (three.Refused)
-            {
-                if (two.Refused) { nothing = "read back"; return c.Inconclusive($"JSON read back: both refuse, not alike: the wrapped type {two}, the value object {three}"); }
-                return $"JSON: the value object does not read back what it writes ({three.Thrown!.GetType().Name}: {Cut(three.Thrown.Message)}): {Cut(jv)}";
-            }
-            if (three.Value != jv) return $"JSON: read back as {Cut(three.Value)}, written as {Cut(jv)}";
-            if (c.Is("json.Converters", "own-for-value-object")) c.Note(NoteKeys.OwnVo, "the application's converter takes precedence and reads its own spelling");
-            else c.Note(NoteKeys.Compared, "JSON read back");
-            return null;
-        }));
-        if (!validated || jp is null) return fails;
-        // 2. the value Create refuses, placed where the wrapped value stands in the wrapped type's document
-        var text = JsonParity.InputFor("refused-by-create", e, o, jp, pos);
-        var xr = Thrown(() => JsonSerializer.Deserialize(text, hv.Declared, o));
-        var r1 = new Sides.Answer("read", null, Thrown(() => JsonSerializer.Deserialize(text, hp.Declared, one)));
-        var twinReads = Thrown(() => JsonSerializer.Deserialize(text, hp.Declared, o)) is null;   // the wrapped type reads the refused value's document: only then is a refusal Create's
-        var r3 = new Sides.Answer("read", null, xr);
-        var stored = r.Is("json.Converters", "StoredJsonConverterFactory");
-        var ownVo = r.Is("json.Converters", "own-for-value-object");
-        // the twin without TypeKit refuses the refused value's document alike: the serializer's refusal, before Create
-        var refusedAlike = !twinReads && !ownVo && Sides.Alike(r1, r3) ? Sides.Measured(r1, "the twin reading the same text, less TypeKit's converters") : null;
-        fails.Add(Sides.Check(r, Obligation, stored ? Baseline.Docs("README.md#what-typekit-guarantees") : Baseline.Refusal, refusedAlike, r3, null, null, c =>
-        {
-            // "Your own converter wins": the generated converter does not run, so no Create; the round trip above runs under it, which
-            // shares the obligation, so it is decided here, not declared in claims.json
-            if (ownVo) return c.Inapplicable(Cite.Docs("src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says"), "the refused value");
-            if (xr is not null && Guarded(xr)) return c.Refused(Cite.Docs("src/CodoMetis.TypeKit.Generators/README.md#json"), "the refused value");
-            if (nothing is not null) return c.Inconclusive($"the refused value: the value object's own document has nothing to compare under these options ({nothing})");
-            if (text == jp) return c.Inconclusive($"the refused value has no place in {Cut(jp)} at {pos}");
-            if (!twinReads)
-            {
-                if (xr is null) return $"JSON read accepted text the wrapped type refuses: {Cut(text)}";
-                return c.Inconclusive($"the refused value's JSON: both refuse, not alike: the wrapped type {r1}, the value object {r3}");
-            }
-            if (stored)
-            {
-                // "Only two paths skip validation, and both are named": StoredJsonConverterFactory reads the stored value without Create
-                if (xr is not null) return $"StoredJsonConverterFactory refused a value Create refuses ({xr.GetType().Name}): it reads stored JSON without validation";
-                c.Note(NoteKeys.StoredFactoryReadUnvalidated); return null;   // not-promised stored-json-skips-validation
-            }
-            if (xr is null) return $"JSON read accepted the value Create refuses: {Cut(text)}";
-            if (xr is not JsonException)
-            {
-                if (Guarded(xr)) return c.Refused(Cite.Docs("src/CodoMetis.TypeKit.Generators/README.md#json"), "the refused value");
-                return $"JSON refusal is {xr.GetType().Name}, not JsonException: {Cut(xr.Message)}";
-            }
-            c.Note(NoteKeys.Compared, "the refused value refused");
-            return null;
-        }));
-        if (xr is JsonException && twinReads && !stored && nothing is null && !ownVo && text != jp)
-            fails.Add(r.Check("refusals-name-the-fault", Baseline.Refusal, c =>
-            {
-                if (!xr.Message.Contains("Refused")) return $"JsonException does not name the fault: {Cut(xr.Message)}\n  text={Cut(text)} (the wrapped type reads it; its own document {Cut(jp)})";
-                c.Note(NoteKeys.Compared, "the JsonException names the fault");
-                return null;
-            }));
-        return fails;
-    }
-}
diff --git a/tools/probe/corpus/harness/TextShrink.cs b/tools/probe/corpus/harness/TextShrink.cs
deleted file mode 100644
index 9c584519..00000000
--- a/tools/probe/corpus/harness/TextShrink.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Registers the text claims' checks with the shrinker (ShrinkProbe check names L02, L03, L04).
-using System.Runtime.CompilerServices;
-using Probes.Shapes;
-namespace Probes;
-public static class TextShrinkInit
-{
-    [ModuleInitializer]
-    public static void Init()
-    {
-        ShrinkChecks.All["L04"] = r => Task.FromResult(TextClaims.RoundTrip(r, Registry.Of(r)));
-        ShrinkChecks.All["L02"] = r => Task.FromResult(TextClaims.NoQuote(r, Registry.Of(r)));
-        ShrinkChecks.All["L03"] = r => Task.FromResult(TextClaims.OneRule(r, Registry.Of(r)));
-    }
-}
diff --git a/tools/probe/corpus/probes/C01DecimalSpellingProbe.cs b/tools/probe/corpus/probes/C01DecimalSpellingProbe.cs
deleted file mode 100644
index d34c3fee..00000000
--- a/tools/probe/corpus/probes/C01DecimalSpellingProbe.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Claim C01-decimal-spelling (docs/json.md#decimals-in-one-spelling): both decimal converters write one spelling per value, the smallest
-// scale, as a number or a string, for every decimal: nullable ones, dictionary keys and every value object over a decimal; both read a
-// number or a string holding one and keep its scale. The check is Probes.Json.DecimalSpelling.
-using Probes.Json;
-using Probes.Shapes;
-namespace Probes;
-public sealed class C01DecimalSpellingProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("C01DecimalSpellingProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, r => Task.FromResult(DecimalSpelling.Check(r)));
-}
diff --git a/tools/probe/corpus/probes/C02OptionalTextProbe.cs b/tools/probe/corpus/probes/C02OptionalTextProbe.cs
deleted file mode 100644
index 30419505..00000000
--- a/tools/probe/corpus/probes/C02OptionalTextProbe.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-// Claim C02-optional-text (docs/text.md#required-and-optional): "For a required field, Blank is an error. For an optional one, a blank means 'no value', and AsOptionalText() and AsOptionalIdentifier() return a Result<Option<string>, TextFault>. Hidden is an error in both cases. A null string is Blank."
-// Oracle: claim + differential (AsOptionalX is AsX with Blank turned into None). Expected: blank input (null, empty, spaces, tab/newline, no-break space) -> required Error(Blank), optional Success(None);
-// ZWSP-only or word+ZWSP -> Error(Hidden) in both; a word -> Some/Success of the word. In globalization-invariant mode AsText/AsOptionalText throw PlatformNotSupportedException (documented, a refusal).
-#pragma warning disable xUnit1051
-using System.ComponentModel;
-using System.Globalization;
-using CodoMetis.TypeKit;
-using Probes.Shapes;
-namespace Probes;
-public sealed class C02OptionalTextProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("C02OptionalTextProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, r => Task.FromResult(Check(r)));
-
-    static string? Input(string k) => k switch
-    {
-        "null" => null, "empty" => "", "spaces" => "   ", "tab-newline" => "\t\r\n ", "word" => "word", "word+ZWSP" => "word\u200B",
-        "nbsp-only" => "\u00A0\u00A0", "ZWSP-only" => "\u200B", _ => throw new ArgumentException(k),
-    };
-
-    static string? Check(Row r)
-    {
-        var c = r["text.culture"];
-        try { CultureInfo.CurrentCulture = c switch { "de-DE" => new("de-DE"), "tr-TR" => new("tr-TR"), "ar-SA" => new("ar-SA"), _ => CultureInfo.InvariantCulture }; }
-        catch (CultureNotFoundException) { CultureInfo.CurrentCulture = CultureInfo.InvariantCulture; r.Substituted("text.culture", "globalization-invariant", "culture unavailable in this process"); }
-        bool gi; try { gi = new CultureInfo("de-DE").NumberFormat.NumberDecimalSeparator == "."; } catch (CultureNotFoundException) { gi = true; }
-        if (c == "globalization-invariant" && !gi) r.Substituted("text.culture", "invariant", "the process is not in globalization-invariant mode");
-        if (c != "globalization-invariant" && gi) r.Substituted("text.culture", "globalization-invariant", "the process is in globalization-invariant mode");
-        if (r["process.converter-lookup"] == "wrapped-type-converter-looked-up-first") _ = TypeDescriptor.GetConverter(typeof(string));
-
-        var entry = r["entry"]; var kind = r["input"]; var s = Input(kind);
-        var expected = kind switch { "word" => "ok", "word+ZWSP" or "ZWSP-only" => "Hidden", _ => "Blank" };
-        // AsText/AsOptionalText refuse in globalization-invariant mode (not-promised as-text-refused-in-globalization-invariant-mode): the row runs on the identifier counterpart, and the refusal itself is checked without credit.
-        if (gi && entry is "AsText" or "AsOptionalText") // (a normal process runs these rows as they are, under the invariant culture)
-        {
-            var refused = false;
-            try { _ = entry == "AsText" ? s.AsText() : (object)s.AsOptionalText(); } catch (PlatformNotSupportedException) { refused = true; }
-            if (!refused) return $"{entry} did not throw in globalization-invariant mode (documented PlatformNotSupportedException)";
-            entry = entry == "AsText" ? "AsIdentifier" : "AsOptionalIdentifier";
-            r.Substituted("entry", entry, "AsText/AsOptionalText refuse in globalization-invariant mode");
-        }
-        var optional = entry.StartsWith("AsOptional");
-        var text = entry.EndsWith("Text");
-        string got, want;
-        if (optional)
-        {
-            var res = text ? s.AsOptionalText() : s.AsOptionalIdentifier();
-            got = res.Match(o => o.Match(v => "Some:" + v, () => "None"), f => "Error:" + f);
-            want = expected switch { "ok" => "Some:word", "Blank" => "None", _ => "Error:Hidden" };
-        }
-        else
-        {
-            var res = text ? s.AsText() : s.AsIdentifier();
-            got = res.Match(v => "ok:" + v, f => "Error:" + f);
-            want = expected switch { "ok" => "ok:word", _ => "Error:" + expected };
-        }
-        // The obligation the input selects: a hidden character is an error in both; a blank is an error for a required field and no value
-        // for an optional one, and a null is a blank too. A word is checked as the blank obligations' control: it is no blank, in either.
-        var obligations = new List<string> { expected == "Hidden" ? "hidden-is-an-error-in-both" : optional ? "optional-blank-is-no-value" : "required-blank-is-an-error" };
-        if (kind == "null") obligations.Add("null-is-blank");
-        string? fail = null;
-        foreach (var obligation in obligations)
-        {
-            var f = r.Check(obligation, Baseline.Docs("docs/text.md#required-and-optional"), c =>
-            {
-                if (got != want) return $"{entry}({kind}) = {got}; expected {want}";
-                c.Note(NoteKeys.Compared, $"{entry}({kind}) = {got}");
-                return null;
-            });
-            fail ??= f;
-        }
-        return fail;
-    }
-}
diff --git a/tools/probe/corpus/probes/C04WithoutFaultsProbe.cs b/tools/probe/corpus/probes/C04WithoutFaultsProbe.cs
deleted file mode 100644
index d050b5b1..00000000
--- a/tools/probe/corpus/probes/C04WithoutFaultsProbe.cs
+++ /dev/null
@@ -1,68 +0,0 @@
-// Claim C04-without-faults (AspNetCore README#leaving-out-what-a-route-cannot-answer): "The operation then lists no status and no problem
-// type for a member left out. It lists no response for a status that no remaining member is mapped to." "Reporting a member left out
-// anyway throws an InvalidOperationException naming the endpoint and the member". "If a group gives NotFound a status and one endpoint
-// inside leaves NotFound out, that endpoint drops it, and the group's other endpoints keep the status." "These stop the host from starting
-// ... a status that every endpoint it's set on leaves out (... on a group whose endpoints all leave the member out)".
-// scope: who leaves HFault.Down (503, mapped to nothing else) out: one endpoint or action beside a sibling that keeps it; a route group or
-// MapControllers()'s builder (README: "A route group or a controller says it for its endpoints"; "Any convention builder that covers several
-// endpoints works the same"); a controller class beside a sibling controller. combined: a wider scope also gives Down 507 (a group, the
-// controller class, or MapControllers()'s builder). With scope=group the 507's whole scope leaves Down out, so the host must not start.
-// Oracle: FaultClaim (README rules over the declarations); the other members (Missing, Clash) answer as mapped. A check per obligation:
-//   doc-omits-left-out: every endpoint's operation (statuses, order, problem schema, problem types);
-//   reporting-left-out-throws: reporting the member left out throws naming the endpoint and the member, against the refusal; and, outside
-//   the rows of narrows-wider-status, what the other members answer, which the README sets against "a status the document doesn't list";
-//   narrows-wider-status (scope endpoint or controller, combined): what every member but the one left out answers, the kept 507 among
-//   them, and which statuses each operation lists;
-//   left-out-everywhere-stops-start (scope group, combined): the host's refusal, naming HFault.Down and 507, the row's one check.
-using Probes.Faults;
-using Probes.Shapes;
-namespace Probes;
-public sealed class C04WithoutFaultsProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("C04WithoutFaultsProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run("C04", idx, r => FaultClaim.Run(r, Spec(r)), probe);
-
-    static readonly Decl Out = new("HFault", "Down", 0), Status = new("HFault", "Down", 507);
-    public static Spec Spec(Probes.Shapes.Row r)
-    {
-        var combined = r["combined"] == "with-WithFaultStatus-on-group";
-        var narrows = combined && r["scope"] is "endpoint" or "controller";
-        var s = new Spec
-        {
-            Errors = [FxErr.E("Missing"), FxErr.E("Clash"), FxErr.E("Down")],
-            Against = Baseline.Docs("src/CodoMetis.TypeKit.AspNetCore/README.md#leaving-out-what-a-route-cannot-answer"),
-            Refusals = ["reporting-left-out-throws", "left-out-everywhere-stops-start"],
-            Of = (aspect, _) => aspect switch
-            {
-                Aspect.Start => ["left-out-everywhere-stops-start"],
-                Aspect.LeftOut => ["reporting-left-out-throws"],
-                Aspect.DocListed when narrows => ["doc-omits-left-out", "narrows-wider-status"],
-                Aspect.DocListed or Aspect.DocOrder or Aspect.DocDescribes or Aspect.DocTypes => ["doc-omits-left-out"],
-                _ => [narrows ? "narrows-wider-status" : "reporting-left-out-throws"],
-            },
-        };
-        switch (r["scope"])
-        {
-            case "endpoint":
-                s.Minimal = combined
-                    ? new MGrp("/fx", [], [new MGrp("/ep", [Status], [], [new MEp("wo", [Out]), new MEp("keep", [])])], [])
-                    : new MGrp("/fx", [], [], [new MEp("ep/wo", [Out]), new MEp("ep/keep", [])]);
-                s.Controllers = [combined ? "C04EpS" : "C04Ep"];
-                break;
-            case "group":
-                s.Minimal = combined
-                    ? new MGrp("/fx", [], [new MGrp("/gr", [Status], [new MGrp("/in", [Out], [], [new MEp("a", []), new MEp("b", [])])], [])], [])
-                    : new MGrp("/fx", [], [new MGrp("/gr", [Out], [], [new MEp("a", []), new MEp("b", [])])], [new MEp("keep", [])]);
-                s.Controllers = ["C04Gr"];
-                s.Builder = combined ? [Status, Out] : [Out];
-                if (combined) s.Refused = ["HFault.Down", "507"];
-                break;
-            default:   // controller: MVC only (scope=controller x http.host minimal, route-group excluded in claims.json)
-                s.Controllers = ["C04CtWo", "C04CtKeep"];
-                s.Builder = combined ? [Status] : [];
-                break;
-        }
-        return s;
-    }
-}
diff --git a/tools/probe/corpus/probes/C06FaultKindsProbe.cs b/tools/probe/corpus/probes/C06FaultKindsProbe.cs
deleted file mode 100644
index 6b7fea30..00000000
--- a/tools/probe/corpus/probes/C06FaultKindsProbe.cs
+++ /dev/null
@@ -1,53 +0,0 @@
-// Claim C06-fault-kinds (AspNetCore README#a-closed-set-as-the-fault-type): "builder.Services.AddFaultResponses<AccountFault>(); // every member
-// by its kind"; "The kind gives the status": PreconditionFailed 412, Malformed 400, Invalid 422, Unavailable 503; "A member without one
-// [a description] has no detail."; "The description becomes the problem's detail"; "A member must have a kind. A member whose kind is
-// default, which is no kind, fails this call." The member of the row's kind (HFault.Stale, Garbled, Bad, Down, none with a description) and
-// HFault.Missing (described "Missing.") are reported on a minimal endpoint and an MVC action; the operation lists its kind's status among
-// every member's, with no problem type (the mapping by kind gives none). The fault sets are mapped per set (AddFaultResponses<HFault>(),
-// <GFault>(), <KFault>()). Oracle: FaultClaim; and AddFaultResponses<FxNoKind>() refused, naming its member of no kind. A check per obligation:
-//   kind-gives-status: each member's status, fault and type, and the operation (statuses, order, problem schema, problem types);
-//   description-as-detail: HFault.Missing's detail is its description; no-description-no-detail: the row's member has none;
-//   member-must-have-kind: AddFaultResponses<FxNoKind>() refused, against the refusal, in every row.
-using CodoMetis.TypeKit.AspNetCore;
-using Microsoft.Extensions.DependencyInjection;
-using Probes.Faults;
-using Probes.Shapes;
-namespace Probes;
-public sealed class C06FaultKindsProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("C06FaultKindsProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run("C06", idx, Check, probe);
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        var noKind = r.Check("member-must-have-kind", Baseline.Refusal, _ => NoKindRefused());
-        var answered = await FaultClaim.Run(r, Spec(r));
-        return noKind ?? answered;
-    }
-
-    /// <summary>"A member must have a kind. A member whose kind is default, which is no kind, fails this call."</summary>
-    static string? NoKindRefused()
-    {
-        try { new ServiceCollection().AddFaultResponses<FxNoKind>(); }
-        catch (ArgumentException ex)
-        {
-            if (!ex.Message.Contains("FxNoKind.Blank", StringComparison.Ordinal)) return $"AddFaultResponses<FxNoKind>() refused, but not with an ArgumentException naming FxNoKind.Blank: {ex.GetType().Name}: {ex.Message}";
-            return null;
-        }
-        catch (Exception ex) { return $"AddFaultResponses<FxNoKind>() refused, but not with an ArgumentException naming FxNoKind.Blank: {ex.GetType().Name}: {ex.Message}"; }
-        return "AddFaultResponses<FxNoKind>() took FxNoKind.Blank, a member of no kind";
-    }
-
-    public static Spec Spec(Probes.Shapes.Row r) => new()
-    {
-        Minimal = new MGrp("/c6", [], [], [new MEp("k", [])]),
-        Controllers = ["C06K"],
-        Typed = false,
-        Against = Baseline.Docs("src/CodoMetis.TypeKit.AspNetCore/README.md#a-closed-set-as-the-fault-type"),
-        Of = (aspect, m) => aspect == Aspect.Detail
-            ? [m?.Q == "HFault.Missing" ? "description-as-detail" : "no-description-no-detail"]
-            : ["kind-gives-status"],
-        Errors = [FxErr.E(r["kind"] switch { "PreconditionFailed" => "Stale", "Malformed" => "Garbled", "Invalid" => "Bad", _ => "Down" }), FxErr.E("Missing")],
-    };
-}
diff --git a/tools/probe/corpus/probes/C07BlanketMappingProbe.cs b/tools/probe/corpus/probes/C07BlanketMappingProbe.cs
deleted file mode 100644
index 2b1fc3fd..00000000
--- a/tools/probe/corpus/probes/C07BlanketMappingProbe.cs
+++ /dev/null
@@ -1,84 +0,0 @@
-// Claim C07-fault-responses-blanket (AspNetCore README#every-fault-set-at-once): "builder.Services.AddFaultResponses(); // every fault set an
-// endpoint answers with, by its kind"; "The mapping can be your own. It reads each member's kind and description through IFault"; "A set
-// mapped on its own keeps its mapping."; "An enum still needs a mapping of its own ... the host doesn't start while an endpoint answers with
-// one that's unmapped."; "A member with no kind stops the start, and so does one the mapping throws for or gives a status that isn't an
-// error. That's the same as AddFaultResponses<TSet>() failing."
-// mapping: AddFaultResponses() by kind, or AddFaultResponses(fault => FaultResponse.For(fault.Kind).WithType(...)) (README's example), which
-// throws for FxThrows and answers FxStatus with 302. set: what the row's endpoints answer with beside HFault (and GFault/KFault, by http.response):
-// nothing more (fault-set); HFault mapped on its own (own-mapped-set: own statuses and types); or one more endpoint answering an unmapped
-// enum, a set with a member of no kind, or a set the mapping refuses. Under by-kind no mapping for every set throws or gives a non-error
-// status, so there the refusing set's own AddFaultResponses<TSet>() does, which the README names as the same failure.
-// Oracle: FaultClaim (wire and document per member, as mapped), and the refusals as the README states them. BaseProbe runs the HTTP
-// payload calibration over the same rows. A check per obligation: by-kind or own-mapping (the row's mapping) for what every member answers
-// and every operation lists; own-set-keeps-mapping (set own-mapped-set) for HFault's answers, mapped on their own, and the operations;
-// enum-needs-own-mapping, member-without-kind-stops-start and mapping-refusal-stops-start (their sets) for the host's refusal, the row's
-// one check, against the refusal.
-using Probes.Faults;
-using Probes.Shapes;
-using CodoMetis.TypeKit.AspNetCore;
-using Microsoft.Extensions.DependencyInjection;
-namespace Probes;
-public sealed class C07BlanketMappingProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("C07BlanketMappingProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run("C07", idx, r => FaultClaim.Run(r, Spec(r)), probe);
-
-    /// <summary>HFault mapped on its own (set=own-mapped-set): a status and a problem type of its own per member.</summary>
-    static readonly Dictionary<string, int> Own = new() { ["Missing"] = 410, ["Clash"] = 409, ["Bad"] = 422, ["Denied"] = 451, ["Down"] = 503, ["Stale"] = 428, ["Garbled"] = 400 };
-    static string OwnType(string member) => "https://own.example/" + member;
-
-    public static Spec Spec(Probes.Shapes.Row r)
-    {
-        var own = r["mapping"] == "own-IFault-mapping";
-        var set = r["set"];
-        var mapping = own ? "own-mapping" : "by-kind";
-        var refusal = set switch
-        {
-            "enum-unmapped" => "enum-needs-own-mapping", "member-without-kind" => "member-without-kind-stops-start",
-            "mapping-throws" or "status-not-error" => "mapping-refusal-stops-start", _ => null,
-        };
-        var s = new Spec
-        {
-            Minimal = new MGrp("/c7", [], [], [new MEp("k", [])]),
-            Controllers = ["C06K"],
-            Errors = [.. Enumerable.Range(1, FxErr.H.Length)],
-            Mapping = own ? "none" : "by-kind",
-            Typed = own,
-            Extra = b => FxSets.Map(b, set),
-            ExtraControllers = FxSets.Controllers(set),
-            Against = Baseline.Docs("src/CodoMetis.TypeKit.AspNetCore/README.md#every-fault-set-at-once"),
-            Refusals = refusal is null ? [] : [refusal],
-            Of = (aspect, m) => aspect == Aspect.Start ? [refusal ?? mapping]
-                : set != "own-mapped-set" ? [mapping]
-                : m is null ? [mapping, "own-set-keeps-mapping"]
-                : m.Type == "HFault" ? ["own-set-keeps-mapping"] : [mapping],
-        };
-        s.Services = sv =>
-        {
-            if (own)
-                sv.AddFaultResponses(fault => fault is FxThrows ? throw new FxMappingRefused()
-                                            : fault is FxStatus ? 302
-                                            : FaultResponse.For(fault.Kind).WithType(new Uri(FaultClaim.TypeOf(fault.Kind.ToString()))));
-            if (set == "own-mapped-set")
-                sv.AddFaultResponses<HFault>(fault => FaultResponse.Status(Own[fault.ToString()]).WithType(new Uri(OwnType(fault.ToString()))));
-            if (!own && set == "mapping-throws") sv.AddFaultResponses<FxThrows>(_ => throw new FxMappingRefused());
-            if (!own && set == "status-not-error") sv.AddFaultResponses<FxStatus>(_ => 302);
-        };
-        if (set == "own-mapped-set")
-            s.Map = m => m.Type == "HFault" ? (Own[m.Name], OwnType(m.Name)) : (m.Status, own ? FaultClaim.TypeOf(m.Kind) : null);
-        s.RefusedAs = set switch
-        {
-            "enum-unmapped" => ex => ex is InvalidOperationException && ex.Message.Contains("FxEnum", StringComparison.Ordinal)
-                ? null : $"host refused to start, but not with an InvalidOperationException naming FxEnum: {ex.GetType().Name}: {ex.Message}",
-            "member-without-kind" => ex => ex is ArgumentException && (own || ex.Message.Contains("FxNoKind.Blank", StringComparison.Ordinal))
-                ? null : $"host refused to start, but not with an ArgumentException{(own ? "" : " naming FxNoKind.Blank")}: {ex.GetType().Name}: {ex.Message}",
-            "mapping-throws" => ex => ex is FxMappingRefused || ex.InnerException is FxMappingRefused
-                ? null : $"host refused to start, but not with the mapping's own exception: {ex.GetType().Name}: {ex.Message}",
-            "status-not-error" => ex => ex is ArgumentException && ex.Message.Contains("302", StringComparison.Ordinal)
-                ? null : $"host refused to start, but not with an ArgumentException naming 302: {ex.GetType().Name}: {ex.Message}",
-            _ => null,
-        };
-        return s;
-    }
-}
diff --git a/tools/probe/corpus/probes/C08SameNameWarningProbe.cs b/tools/probe/corpus/probes/C08SameNameWarningProbe.cs
deleted file mode 100644
index 9f008d48..00000000
--- a/tools/probe/corpus/probes/C08SameNameWarningProbe.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Claim C08-same-name-warning (src/CodoMetis.TypeKit.AspNetCore/README.md#faults-of-several-types, Keep names distinct). Its checks, one per obligation, are SchemaChecks.C08 in harness/SchemaClaim.cs.
-using Probes.Schema;
-using Probes.Shapes;
-namespace Probes;
-public sealed class C08SameNameWarningProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("C08SameNameWarningProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, SchemaChecks.C08);
-}
diff --git a/tools/probe/corpus/probes/C09BaseRecordEqualityProbe.cs b/tools/probe/corpus/probes/C09BaseRecordEqualityProbe.cs
deleted file mode 100644
index b1e977c2..00000000
--- a/tools/probe/corpus/probes/C09BaseRecordEqualityProbe.cs
+++ /dev/null
@@ -1,119 +0,0 @@
-// Claim C09-base-record-equality (CHANGELOG.md 2.1.0, Fixed): "Over a base record, a value object's equality is its wrapped value's,
-// in a collection of the base too, whatever equality the base declares." With Generators README#equality: "the generated Equals(TSelf)
-// and GetHashCode() compare the underlying value alone, and never call the base's ... The value object implements each base's
-// IEquatable<TBase> again (IReimplementedEquatable<TBase>), so a collection of the base compares it the way the value object does."
-// Oracle: claim, differential against the wrapped type's EqualityComparer. Each row's value object (harness/C09Shapes.g.cs, generated
-// from this claim's rows) is of shape.kind over shape.wrapped at shape.site, over a chain of base records (shape.inheritance) whose
-// topmost declares base-equality by reference. Two value objects over equal wrapped values (distinct instances where the wrapped type is
-// a class) are equal, ==, of one hash code and IEquatable-equal, one over another value is not; and the collection (HashSet,
-// Dictionary key, Distinct) of the value object and of every base in its chain holds two of the three.
-using System.Reflection;
-using Probes.Build;
-using NoteKeys = Probes.Shapes.NoteKeys;
-using Probes.Build.C09;
-namespace Probes;
-
-public sealed class C09BaseRecordEqualityProbe
-{
-    const string RowsFile = "C09BaseRecordEqualityProbe"; // the probe's own rows
-
-    public static TheoryData<string, int> Data() => Probes.Shapes.Rows.Data(RowsFile);
-
-    [Theory, MemberData(nameof(Data))]
-    public Task Probe(string probe, int idx) => Probes.Shapes.Rec.Run(probe, idx, r => Task.FromResult(Check(r)));
-
-    /// <summary>A sample, an equal one that is another instance where the type is a class, and another value.</summary>
-    static (object A, object Same, object Other) Values(string wrapped) => wrapped switch
-    {
-        "string" => ("alpha", new string(['a', 'l', 'p', 'h', 'a']), "beta"),
-        "Guid" => (Guid.Parse("11111111-1111-1111-1111-111111111111"), Guid.Parse("11111111-1111-1111-1111-111111111111"), Guid.Parse("22222222-2222-2222-2222-222222222222")),
-        "int" => (42, 42, 43), "long" => (4200000000L, 4200000000L, 7L), "byte" => ((byte)7, (byte)7, (byte)8), "ulong" => (4200000000UL, 4200000000UL, 1UL),
-        "decimal" => (7.80m, 7.80m, 7.81m), "double" => (1.5, 1.5, 2.5), "bool" => (true, true, false), "char" => ('a', 'a', 'b'),
-        "DateTime" => (new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Utc), new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Utc), new DateTime(2026, 10, 16, 8, 30, 0, DateTimeKind.Utc)),
-        "DateTimeOffset" => (new DateTimeOffset(2026, 10, 15, 8, 30, 0, TimeSpan.Zero), new DateTimeOffset(2026, 10, 15, 8, 30, 0, TimeSpan.Zero), new DateTimeOffset(2026, 10, 16, 8, 30, 0, TimeSpan.Zero)),
-        "DateOnly" => (new DateOnly(2026, 10, 15), new DateOnly(2026, 10, 15), new DateOnly(2026, 10, 16)),
-        "TimeOnly" => (new TimeOnly(8, 30), new TimeOnly(8, 30), new TimeOnly(9, 30)),
-        "TimeSpan" => (TimeSpan.FromMinutes(90), TimeSpan.FromMinutes(90), TimeSpan.FromMinutes(91)),
-        "enum" => (Probes.Shapes.PEnum.A, Probes.Shapes.PEnum.A, Probes.Shapes.PEnum.B),
-        "flags-enum" => (Probes.Shapes.PFlags.P, Probes.Shapes.PFlags.P, Probes.Shapes.PFlags.Q),
-        "Uri" => (new Uri("https://example.org/a"), new Uri("https://example.org/a"), new Uri("https://example.org/b")),
-        "NodaTime.Instant" => (NodaTime.Instant.FromUnixTimeSeconds(1_700_000_000), NodaTime.Instant.FromUnixTimeSeconds(1_700_000_000), NodaTime.Instant.FromUnixTimeSeconds(1_700_000_001)),
-        "own-record-class" => (new Probes.Shapes.PRec { A = "a", B = 1 }, new Probes.Shapes.PRec { A = "a", B = 1 }, new Probes.Shapes.PRec { A = "b", B = 2 }),
-        _ => throw new ArgumentException(wrapped),
-    };
-
-    static string? Check(Probes.Shapes.Row r)
-    {
-        var c = C09Table.Cases.SingleOrDefault(x => x.Index == r.Index);
-        if (c is null || c.Key != Decls.Key(RowsFile, r.Index))
-        { r.Outcome("harness-error", "C09Shapes.g.cs was generated from other rows: regenerate it with the rows"); return null; }
-        foreach (var (axis, value) in c.Substituted) r.Substituted(axis, value, "the declaration cannot exist as the row asks (excluded in claims.json)");
-        _ = r["shape.kind"]; _ = r["shape.site"]; _ = r["shape.inheritance"]; _ = r["base-equality"];
-        var wrapped = r["shape.wrapped"]; var collection = r["collection"];
-
-        var (a, same, other) = Values(wrapped);
-        if (!a.GetType().IsValueType && ReferenceEquals(a, same)) { r.Outcome("harness-error", "the equal sample is the same instance"); return null; }
-        var comparer = typeof(EqualityComparer<>).MakeGenericType(a.GetType()).GetProperty("Default")!.GetValue(null)!;
-        var eq = comparer.GetType().GetMethod("Equals", [a.GetType(), a.GetType()])!;
-        if (!(bool)eq.Invoke(comparer, [a, same])! || (bool)eq.Invoke(comparer, [a, other])!) { r.Outcome("harness-error", "the samples do not compare as intended under the wrapped type's equality"); return null; }
-
-        var va = c.Make(a); var vb = c.Make(same); var vc = c.Make(other);
-        var baseline = Probes.Shapes.Baseline.Twin;   // the wrapped type's EqualityComparer, which the samples were checked against
-        var f1 = r.Check("equal-by-the-wrapped-value", baseline, k =>
-        {
-            var fails = new List<string>();
-            if (!va.Equals(vb)) fails.Add("Equals(object) is false for equal wrapped values");
-            if (va.Equals(vc)) fails.Add("Equals(object) is true for different wrapped values");
-            if (va.GetHashCode() != vb.GetHashCode()) fails.Add("equal value objects have different hash codes");
-            var op = c.Vo.GetMethod("op_Equality", BindingFlags.Public | BindingFlags.Static, [c.Vo, c.Vo]);
-            if (op is null) fails.Add("no operator ==");
-            else if (!(bool)op.Invoke(null, [va, vb])!) fails.Add("== is false for equal wrapped values");
-            if (Held(c.Vo, collection, va, vb, vc) is { } f) fails.Add($"the value object: {f}");
-            if (fails.Count > 0) return string.Join("; ", fails);
-            k.Note(NoteKeys.Compared, $"the value object, against EqualityComparer<{a.GetType().Name}>");
-            return null;
-        });
-        var f2 = r.Check("in-a-collection-of-the-base", baseline, k =>
-        {
-            if (c.Bases.Length == 0) return k.Inconclusive("no base record in the chain: claims.json excludes the row's pairs");
-            var fails = new List<string>();
-            foreach (var t in c.Bases)
-                if (Held(t, collection, va, vb, vc) is { } f) fails.Add($"the base {t.Name}: {f}");
-            if (fails.Count > 0) return string.Join("; ", fails);
-            k.Note(NoteKeys.Compared, $"{c.Bases.Length} base type(s), against EqualityComparer<{a.GetType().Name}>");
-            return null;
-        });
-        return f1 ?? f2;
-    }
-
-    static string? Held(Type t, string collection, object a, object b, object c) =>
-        (string?)typeof(C09BaseRecordEqualityProbe).GetMethod(nameof(Collect), BindingFlags.NonPublic | BindingFlags.Static)!.MakeGenericMethod(t).Invoke(null, [collection, a, b, c]);
-
-    /// <summary>Three values held as <typeparamref name="T"/>, two of them equal: the collection holds two, and IEquatable agrees.</summary>
-    static string? Collect<T>(string collection, object a, object b, object c) where T : notnull
-    {
-        T x = (T)a, y = (T)b, z = (T)c;
-        if (x is IEquatable<T> e && (!e.Equals(y) || e.Equals(z))) return $"IEquatable<{typeof(T).Name}> answers {e.Equals(y)} for equal and {e.Equals(z)} for different values";
-        switch (collection)
-        {
-            case "HashSet":
-            {
-                var set = new HashSet<T> { x, y, z };
-                return set.Count == 2 ? null : $"a HashSet<{typeof(T).Name}> holds {set.Count} of two equal and one other";
-            }
-            case "Dictionary-key":
-            {
-                var d = new Dictionary<T, int>();
-                var first = d.TryAdd(x, 1); var second = d.TryAdd(y, 2); var third = d.TryAdd(z, 3);
-                if (!first || second || !third) return $"a Dictionary<{typeof(T).Name}, int> took the keys {first}, {second}, {third}";
-                return d.TryGetValue(y, out var found) && found == 1 ? null : $"a Dictionary<{typeof(T).Name}, int> does not find the equal key";
-            }
-            case "Distinct":
-            {
-                var n = new[] { x, y, z }.Distinct().Count();
-                return n == 2 ? null : $"Distinct over {typeof(T).Name} keeps {n} of two equal and one other";
-            }
-            default: throw new ArgumentException("collection " + collection);
-        }
-    }
-}
diff --git a/tools/probe/corpus/probes/C10PreserveGuardProbe.cs b/tools/probe/corpus/probes/C10PreserveGuardProbe.cs
deleted file mode 100644
index 35f5ffc9..00000000
--- a/tools/probe/corpus/probes/C10PreserveGuardProbe.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Claim C10-preserve-guard (src/CodoMetis.TypeKit.Generators/README.md#json): under ReferenceHandler.Preserve a value object over a type the
-// serializer walks as an object throws NotSupportedException in both directions, never writing an $id twice; everything else is unaffected.
-// The check is Probes.Json.PreserveGuard.
-using Probes.Json;
-using Probes.Shapes;
-namespace Probes;
-public sealed class C10PreserveGuardProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("C10PreserveGuardProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, r => Task.FromResult(PreserveGuard.Check(r)));
-}
diff --git a/tools/probe/corpus/probes/C11ParseShapesBuildProbe.cs b/tools/probe/corpus/probes/C11ParseShapesBuildProbe.cs
deleted file mode 100644
index 7a05c281..00000000
--- a/tools/probe/corpus/probes/C11ParseShapesBuildProbe.cs
+++ /dev/null
@@ -1,197 +0,0 @@
-// Claim C11-parse-shapes-build (CHANGELOG.md 2.1.0, Fixed): "A wrapped type's `Parse` whose result can't be assigned to it, or that
-// takes its text by `ref`, or an abstract class's string constructor, no longer breaks the build; the value object has no parsing."
-// With Generators README "What you can wrap" ("Parsing where it can be parsed") and "What is generated" (TryFrom for IValidatedValue,
-// the [TypeConverter] when parsing is generated, ToString() the underlying type's own text under the invariant culture).
-// Obligations (claims.json), each with a check below and a seed of its own in the registry entry (decision 104), the row's parse-shape
-// selecting one:
-//   implicit-result: "A wrapped type's `Parse` whose result can't be assigned to it"
-//   ref-text: "or that takes its text by `ref`"
-//   abstract-string-constructor: "or an abstract class's string constructor, no longer breaks the build; the value object has no parsing."
-//   parsing-where-it-can-be-parsed (ordinary): "`IParsable`/`ISpanParsable`/`IUtf8SpanParsable`, formatting in the invariant culture"
-//   (the 2.0.0 entry of the same file: what the fix must leave to a type that parses)
-// Each row's value object (harness/C11Shapes.g.cs, generated from this claim's rows) is of shape.kind at shape.site with
-// shape.inheritance, over the parse shape's own class (implicit-result: Parse returns an int; ref-text: Parse or the string constructor
-// takes the text by ref; abstract-string-ctor) or, for ordinary, over shape.wrapped. That it is in this assembly is the build half.
-// Under text.culture and process.converter-lookup, the row's text.entry is then checked:
-//   a parse shape's obligation, against the CHANGELOG's sentence (Baseline.Docs): no Parse, TryParse, IParsable, ISpanParsable or
-//   string type converter, while TryFrom (validated) and formatting work, and the same declaration over the nearest type that parses
-//   (its control) parses;
-//   parsing-where-it-can-be-parsed, against the catalogue's top-level value object of the same kind over the same wrapped type
-//   (Probes.Shapes.Registry, Baseline.Twin): the entry exists exactly where the catalogue's does and wherever the wrapped type parses,
-//   ISpanParsable included, and gives the catalogue's result.
-using System.ComponentModel;
-using System.Globalization;
-using System.Reflection;
-using Probes.Build;
-using Probes.Build.C11;
-using Probes.Shapes;
-namespace Probes;
-
-public sealed class C11ParseShapesBuildProbe
-{
-    const string RowsFile = "C11ParseShapesBuildProbe"; // the probe's own rows
-
-    public static TheoryData<string, int> Data() => Rows.Data(RowsFile);
-
-    [Theory, MemberData(nameof(Data))]
-    public Task Probe(string probe, int idx) => Rec.Run(probe, idx, r => Task.FromResult(Check(r)));
-
-    static readonly string[] ParseEntries = ["Parse", "TryParse", "IParsable", "ISpanParsable", "type-converter"];
-
-    static string? Check(Probes.Shapes.Row r)
-    {
-        var c = C11Table.Cases.SingleOrDefault(x => x.Index == r.Index);
-        if (c is null || c.Key != Decls.Key(RowsFile, r.Index))
-        { r.Outcome("harness-error", "C11Shapes.g.cs was generated from other rows: regenerate it with the rows"); return null; }
-        foreach (var (axis, value) in c.Substituted) r.Substituted(axis, value, "the declaration cannot exist as the row asks (excluded in claims.json)");
-        _ = r["shape.kind"]; _ = r["shape.site"]; _ = r["shape.inheritance"];
-        var shape = r["parse-shape"]; var entry = r["text.entry"];
-        var ordinary = shape == "ordinary";
-        var wrapped = ordinary ? r["shape.wrapped"] : null;
-        object sample = shape switch
-        {
-            "ordinary" => Registry.Get("record-struct", wrapped!).Valid(),
-            "implicit-result" => new C11ParsesToInt(),
-            "ref-text" => c.Wrapped == typeof(C11ParsesByRef) ? new C11ParsesByRef() : C11ConstructedByRef.Sample(),
-            "abstract-string-ctor" => new C11ConcreteText("abstract-text"),
-            _ => throw new ArgumentException(shape),
-        };
-        if (!c.Wrapped.IsInstanceOfType(sample)) { r.Outcome("harness-error", $"the sample is no {c.Wrapped.Name}"); return null; }
-        var e = new Entry(c.Kind, wrapped ?? shape, c.Vo, c.Wrapped, () => sample, () => null, typeof(object), typeof(object), typeof(object), typeof(object));
-        TextOps.Prepare(r, e);
-        string? Holds(object vo) => Equals(Make.Unwrap(e, vo), sample) ? null : "the value object does not hold the value it was made from";
-        if (ordinary)
-            return r.Check("parsing-where-it-can-be-parsed", Baseline.Twin, _ => { var vo = Make.Vo(e, sample); return Holds(vo) ?? Ordinary(r, e, entry, wrapped!, sample, vo); });
-        var obligation = shape switch
-        {
-            "implicit-result" => "implicit-result",
-            "ref-text" => "ref-text",
-            "abstract-string-ctor" => "abstract-string-constructor",
-            _ => throw new ArgumentException(shape),
-        };
-        return r.Check(obligation, Baseline.Docs("CHANGELOG.md#2.1.0-fixed"), _ => { var vo = Make.Vo(e, sample); return Holds(vo) ?? NoParsing(r, e, entry, sample, vo) ?? Control(c); });
-    }
-
-    /// <summary>
-    /// The parse shape's control, the same declaration over the nearest type that parses: it has IParsable, and Parse gives back the text
-    /// it was given. Without it a generator that took parsing from every class would pass the shapes.
-    /// </summary>
-    static string? Control(C11Case c)
-    {
-        if (c.Control is null) throw new InvalidOperationException($"row {c.Index} has no control");
-        if (!TextOps.Implements(typeof(IParsable<>), c.Control)) return $"the control over {c.ControlWrapped!.Name}, which can be parsed, has no IParsable";
-        var parse = c.Control.GetMethod("Parse", [typeof(string), typeof(IFormatProvider)]);
-        if (parse is null) return $"the control over {c.ControlWrapped!.Name} has no Parse(string, IFormatProvider)";
-        object? parsed;
-        try { parsed = parse.Invoke(null, ["control-text", null]); }
-        catch (TargetInvocationException t) { return $"the control's Parse threw {t.InnerException!.GetType().Name}: {t.InnerException.Message}"; }
-        var value = c.Control.GetProperty("Value")!.GetValue(parsed);
-        return value?.ToString() == "control-text" ? null : $"the control's Parse gave back '{value}', not 'control-text'";
-    }
-
-    static bool Has(Type t, string name) => t.GetMethods(BindingFlags.Public | BindingFlags.Static).Any(m => m.Name == name);
-
-    static string? NoParsing(Probes.Shapes.Row r, Entry e, string entry, object sample, object vo)
-    {
-        var t = e.Vo;
-        // The baseline every row checks: no member of parsing at all.
-        var parsing = new List<string>();
-        if (Has(t, "Parse")) parsing.Add("Parse");
-        if (Has(t, "TryParse")) parsing.Add("TryParse");
-        if (TextOps.Implements(typeof(IParsable<>), t)) parsing.Add("IParsable");
-        if (TextOps.Implements(typeof(ISpanParsable<>), t)) parsing.Add("ISpanParsable");
-        if (TextOps.Implements(typeof(IUtf8SpanParsable<>), t)) parsing.Add("IUtf8SpanParsable");
-        if (t.GetCustomAttribute<TypeConverterAttribute>() is not null || TypeDescriptor.GetConverter(t).CanConvertFrom(typeof(string))) parsing.Add("a type converter from string");
-        if (parsing.Count > 0) return $"the value object over a {r["parse-shape"]} type has parsing: {string.Join(", ", parsing)}";
-        var text = sample.ToString()!;
-        switch (entry)
-        {
-            case "Parse" or "TryParse" or "IParsable" or "ISpanParsable" or "type-converter":
-            {
-                var o = TextOps.Read(e, entry, text);
-                if (!o.NotApplicable) return $"{entry} reads text on a value object documented to have no parsing";
-                break;
-            }
-            case "TryFrom":
-            {
-                var o = TextOps.TryFrom(e, sample);
-                if (TextOps.ValidatedKind(e))
-                {
-                    if (o.NotApplicable) return "a validated value object has no TryFrom";
-                    if (o.Ex is not null || !o.Ok || !Equals(Make.Unwrap(e, o.Value!), sample)) return $"TryFrom(valid) gave ok={o.Ok} {o.Ex?.GetType().Name}";
-                }
-                else if (Has(e.Vo, "TryFrom")) return "a plain value object has a TryFrom";
-                break;
-            }
-            case "ToString-format":
-            {
-                if (vo.ToString() != text) return $"ToString() is '{vo}', the wrapped value's own text is '{text}'";
-                if (vo is IFormattable f && f.ToString(null, CultureInfo.InvariantCulture) != text) return $"IFormattable.ToString is '{f.ToString(null, CultureInfo.InvariantCulture)}', expected '{text}'";
-                break;
-            }
-            case "TryFormat-short-span":
-            {
-                if (vo.ToString() != text) return $"ToString() is '{vo}', the wrapped value's own text is '{text}'";
-                if (vo is ISpanFormattable)
-                {
-                    var full = new object?[] { vo, 4096, null, null };
-                    var written = (string)typeof(TextOps).GetMethod(nameof(TextOps.FS))!.MakeGenericMethod(e.Vo).Invoke(null, full)!;
-                    if (!(bool)full[2]! || written != text) return $"TryFormat wrote '{written}' (ok={full[2]}), the wrapped value's text is '{text}'";
-                    var shortArgs = new object?[] { vo, Math.Max(0, text.Length - 1), null, null };
-                    typeof(TextOps).GetMethod(nameof(TextOps.FS))!.MakeGenericMethod(e.Vo).Invoke(null, shortArgs);
-                    if ((bool)shortArgs[2]!) return $"TryFormat into a span of {text.Length - 1} said '{text}' fit";
-                }
-                break;
-            }
-            default: throw new ArgumentException("text.entry " + entry);
-        }
-        r.Note(NoteKeys.Compared, $"no parsing; {entry}; the control parses");
-        return null;
-    }
-
-    static string? Ordinary(Probes.Shapes.Row r, Entry e, string entry, string wrapped, object sample, object vo)
-    {
-        var reference = Registry.Get(e.Kind, wrapped);
-        var refVo = Make.Vo(reference, sample);
-        string? Same(Out mine, Out theirs, Entry me, Entry them, string what)
-        {
-            if (mine.NotApplicable != theirs.NotApplicable) return $"{what}: {(mine.NotApplicable ? "absent" : "present")} here, {(theirs.NotApplicable ? "absent" : "present")} on the catalogue's top-level value object";
-            if (mine.NotApplicable) return null;
-            if ((mine.Ex is null) != (theirs.Ex is null) || mine.Ex?.GetType() != theirs.Ex?.GetType())
-                return $"{what}: {(mine.Ex is null ? "no exception" : mine.Ex.GetType().Name + ": " + mine.Ex.Message)} here, {(theirs.Ex is null ? "no exception" : theirs.Ex.GetType().Name)} on the catalogue's";
-            if (mine.Ok != theirs.Ok) return $"{what}: ok={mine.Ok} here, {theirs.Ok} on the catalogue's";
-            if (mine.Text != theirs.Text) return $"{what}: '{mine.Text}' here, '{theirs.Text}' on the catalogue's";
-            if (mine.Value is not null && theirs.Value is not null && !Equals(Make.Unwrap(me, mine.Value), Make.Unwrap(them, theirs.Value)))
-                return $"{what}: {Make.Unwrap(me, mine.Value)} here, {Make.Unwrap(them, theirs.Value)} on the catalogue's";
-            return null;
-        }
-        string? fail;
-        if (ParseEntries.Contains(entry))
-        {
-            var text = TextOps.PlainText(reference, sample);
-            var mine = TextOps.Read(e, entry, text);
-            if (mine.NotApplicable && wrapped != "own-record-class")
-                return $"{entry}: the value object over {wrapped}, which parses, has no {entry}";
-            fail = Same(mine, TextOps.Read(reference, entry, text), e, reference, entry);
-        }
-        else if (entry == "TryFrom")
-        {
-            var mine = TextOps.TryFrom(e, sample);
-            if (TextOps.ValidatedKind(e) && (mine.NotApplicable || !mine.Ok)) return "TryFrom(valid) on a validated value object gave no value";
-            fail = Same(mine, TextOps.TryFrom(reference, sample), e, reference, "TryFrom");
-        }
-        else
-        {
-            fail = Same(TextOps.Write(e, entry, vo), TextOps.Write(reference, entry, refVo), e, reference, entry);
-            if (fail is null && entry == "TryFormat-short-span" && vo is ISpanFormattable)
-            {
-                var text = TextOps.Write(e, entry, vo).Text ?? "";
-                var shortArgs = new object?[] { vo, Math.Max(0, text.Length - 1), null, null };
-                typeof(TextOps).GetMethod(nameof(TextOps.FS))!.MakeGenericMethod(e.Vo).Invoke(null, shortArgs);
-                if (text.Length > 0 && (bool)shortArgs[2]!) fail = $"TryFormat into a span of {text.Length - 1} said '{text}' fit";
-            }
-        }
-        if (fail is null) r.Note(NoteKeys.Compared, $"{entry} against the catalogue's {e.Kind} over {wrapped}");
-        return fail;
-    }
-}
diff --git a/tools/probe/corpus/probes/C12DescribedConverterProbe.cs b/tools/probe/corpus/probes/C12DescribedConverterProbe.cs
deleted file mode 100644
index 6e25d05f..00000000
--- a/tools/probe/corpus/probes/C12DescribedConverterProbe.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Claim C12-described-converter (docs/json.md#describing-what-a-converter-writes and the AspNetCore README's A described type). Its checks, one per obligation, are SchemaChecks.C12 in harness/SchemaClaim.cs.
-using Probes.Schema;
-using Probes.Shapes;
-namespace Probes;
-public sealed class C12DescribedConverterProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("C12DescribedConverterProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, SchemaChecks.C12);
-}
diff --git a/tools/probe/corpus/probes/C13PatchRequiredProbe.cs b/tools/probe/corpus/probes/C13PatchRequiredProbe.cs
deleted file mode 100644
index 26197cae..00000000
--- a/tools/probe/corpus/probes/C13PatchRequiredProbe.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Claim C13-patch-required (docs/merge-patches.md#required-constructor-parameters). Its checks, one per obligation, are SchemaChecks.C13 in harness/SchemaClaim.cs.
-using Probes.Schema;
-using Probes.Shapes;
-namespace Probes;
-public sealed class C13PatchRequiredProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("C13PatchRequiredProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, SchemaChecks.C13);
-}
diff --git a/tools/probe/corpus/probes/C14DeclaredProblemProbe.cs b/tools/probe/corpus/probes/C14DeclaredProblemProbe.cs
deleted file mode 100644
index e8a53d2a..00000000
--- a/tools/probe/corpus/probes/C14DeclaredProblemProbe.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Claim C14-declared-problem (CHANGELOG 2.1.0 Fixed): "OpenAPI: a problem response an endpoint declares itself (ProducesProblem,
-// [ProducesResponseType]) describes fault, and names its problem types." and "an operation with fault responses lists every status ascending,
-// the ones its endpoint declares itself among them". declared: the endpoint declares a 404 problem itself, a status HFault.Missing answers:
-// minimal .ProducesProblem(404) / MVC [ProducesResponseType<ProblemDetails>(404, "application/problem+json")] (what ProducesProblem declares),
-// [ProducesResponseType<ProblemDetails>(404)] on the lambda or the action, or nothing (the control). The mapping gives a problem type per kind.
-// Oracle: FaultClaim: the 404's schema describes fault and rule, its description names https://p.example/NotFound, the statuses ascending.
-// A check per obligation: declared-describes-fault (the problem schemas' fault and rule), declared-names-types (the problem types the
-// descriptions name, and what each member answers), ascending-with-declared (which statuses each operation lists, and their order), and in
-// the rows of [ProducesResponseType<ProblemDetails>(404)] application-json-declared (its schema and its problem types). declared=none is the
-// control: the same checks, where the endpoint declares nothing. Not checked here: that application/json keeps its media type.
-using Probes.Faults;
-using Probes.Shapes;
-namespace Probes;
-public sealed class C14DeclaredProblemProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("C14DeclaredProblemProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run("C14", idx, r => FaultClaim.Run(r, Spec(r)), probe);
-
-    public static Spec Spec(Probes.Shapes.Row r)
-    {
-        var (ep, ctl) = r["declared"] switch
-        {
-            "ProducesProblem" => (new MEp("d", [], [404], "pp"), "C14Pp"),
-            "ProducesResponseType" => (new MEp("d", [], [404], "prt"), "C14Prt"),
-            _ => (new MEp("d", []), "C14None"),
-        };
-        var json = r["declared"] == "ProducesResponseType";
-        return new Spec
-        {
-            Minimal = new MGrp("/c14", [], [], [ep]), Controllers = [ctl], Errors = [FxErr.E("Missing"), FxErr.E("Clash")],
-            Against = Baseline.Docs("CHANGELOG.md#2.1.0-fixed"),
-            Of = (aspect, _) => aspect switch
-            {
-                Aspect.DocDescribes => json ? ["declared-describes-fault", "application-json-declared"] : ["declared-describes-fault"],
-                Aspect.DocTypes => json ? ["declared-names-types", "application-json-declared"] : ["declared-names-types"],
-                Aspect.DocListed or Aspect.DocOrder => ["ascending-with-declared"],
-                _ => ["declared-names-types"],
-            },
-        };
-    }
-}
diff --git a/tools/probe/corpus/probes/C15MvcFaultStatusDocProbe.cs b/tools/probe/corpus/probes/C15MvcFaultStatusDocProbe.cs
deleted file mode 100644
index d4e3b0aa..00000000
--- a/tools/probe/corpus/probes/C15MvcFaultStatusDocProbe.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-// Claim C15-mvc-fault-status-doc (CHANGELOG 2.1.0 Fixed): "OpenAPI: a WithFaultStatus on the builder MapControllers() returns reaches the
-// document, as it reached the response." Each MVC setter, with a status (HFault.Denied 451) or a member left out (HFault.Down): what
-// MapControllers()'s builder, an action's attribute and a controller's attribute declare reaches the document as it reaches the response.
-// Precedence (README "A status per endpoint"): "ASP.NET puts the metadata of MapControllers()'s builder after every attribute, so a status
-// set there wins over an action's own"; "an action's over its controller's": an action with its own Denied 452 sits beside each scope.
-// Minimal hosts take the equivalent of each setter (README: "Any convention builder that covers several endpoints works the same"):
-// MapControllers()'s builder = a group over every endpoint, an action = the endpoint, a controller = a group beside a sibling endpoint;
-// there "An endpoint's own wins over its group's". Oracle: FaultClaim. A check per obligation: status-per-scope (kind status-only) or
-// without-faults-leaves-doc (kind WithoutFaults) for what every member answers, the member left out throwing, and every operation; and,
-// where MapControllers()'s builder sets it, builder-reaches-doc for the operations too.
-using Probes.Faults;
-using Probes.Shapes;
-namespace Probes;
-public sealed class C15MvcFaultStatusDocProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("C15MvcFaultStatusDocProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run("C15", idx, r => FaultClaim.Run(r, Spec(r)), probe);
-
-    static readonly Decl Own = new("HFault", "Denied", 452);
-    public static Spec Spec(Probes.Shapes.Row r)
-    {
-        var statusOnly = r["kind"] == "status-only";
-        var set = statusOnly ? new Decl("HFault", "Denied", 451) : new Decl("HFault", "Down", 0);
-        var kind = statusOnly ? "status-per-scope" : "without-faults-leaves-doc";
-        var builder = r["setter"] == "MapControllers().WithFaultStatus";
-        var s = new Spec
-        {
-            Errors = [FxErr.E("Missing"), FxErr.E("Denied"), FxErr.E("Down")],
-            Against = Baseline.Docs("CHANGELOG.md#2.1.0-fixed"),
-            Of = (aspect, _) => builder && Aspect.Doc.Contains(aspect) ? [kind, "builder-reaches-doc"] : [kind],
-        };
-        switch (r["setter"])
-        {
-            case "MapControllers().WithFaultStatus":
-                s.Minimal = new MGrp("/c15", [set], [], [new MEp("s/a", []), new MEp("s/p", [Own])]);
-                s.Controllers = ["C15M"];
-                s.Builder = [set];
-                break;
-            case "action-attribute":
-                s.Minimal = new MGrp("/c15", [], [], [new MEp("s/a", [set]), new MEp("s/k", [])]);
-                s.Controllers = [statusOnly ? "C15AS" : "C15AW"];
-                break;
-            default:   // controller-attribute
-                s.Minimal = new MGrp("/c15", [], [new MGrp("/g", [set], [], [new MEp("s/a", []), new MEp("s/p", [Own])])], [new MEp("s/k", [])]);
-                s.Controllers = [statusOnly ? "C15CS" : "C15CW", "C15K"];
-                break;
-        }
-        return s;
-    }
-}
diff --git a/tools/probe/corpus/probes/C16OptionsAgreementProbe.cs b/tools/probe/corpus/probes/C16OptionsAgreementProbe.cs
deleted file mode 100644
index dbe824c1..00000000
--- a/tools/probe/corpus/probes/C16OptionsAgreementProbe.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Claim C16-options-agreement (src/CodoMetis.TypeKit.AspNetCore/README.md#what-the-document-says, Register the same on both option sets). Its checks, one per obligation, are SchemaChecks.C16 in harness/SchemaClaim.cs.
-using Probes.Schema;
-using Probes.Shapes;
-namespace Probes;
-public sealed class C16OptionsAgreementProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("C16OptionsAgreementProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, SchemaChecks.C16);
-}
diff --git a/tools/probe/corpus/probes/C17Cmtk0014Probe.cs b/tools/probe/corpus/probes/C17Cmtk0014Probe.cs
deleted file mode 100644
index 629484f6..00000000
--- a/tools/probe/corpus/probes/C17Cmtk0014Probe.cs
+++ /dev/null
@@ -1,261 +0,0 @@
-// Claim C17-cmtk0014 (src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0014): "A FaultKind or a ConstructorAccessibility that names
-// no member: a cast, default(FaultKind), a zero, or a folded constant" is reported (Warning), and "Both are reported where the value
-// is written". The documented cases: `[RequireParameterlessConstructor((ConstructorAccessibility)7)]` and a fault set's member
-// `new(default)`, beside `new(FaultKind.Conflict)`, a member, which is silent; "a default that is a member is silent"
-// (ConstructorAccessibility.Public is 0).
-// Obligations (claims.json), each with a check below and a seed of its own in the registry entry (decision 104), the row's value
-// and site selecting them:
-//   a-cast-naming-no-member (value (FaultKind)9): "A `FaultKind` or a `ConstructorAccessibility` that names no member: a cast"
-//   default-and-zero (value default): "`default(FaultKind)`, a zero"
-//   constructor-accessibility-too (value (FaultKind)9, site attribute-argument): "[RequireParameterlessConstructor((ConstructorAccessibility)7)]   // CMTK0014: no member, read as public"
-//   reported-where-written (value (FaultKind)9 or default): "Both are reported where the value is written:"
-//   a-member-is-silent (value valid): "public static readonly ImportFault Duplicate = new(FaultKind.Conflict);"
-// Oracle: the README's section (Baseline.Docs). Each row writes the value (value axis) in the written form (site axis) at every place
-// its shape axes describe, each place marked: in the declaration of shape.kind over shape.wrapped at shape.site (a fault set's member
-// for closed-set, a static member of a value object otherwise), in the topmost base of its shape.inheritance chain and in an explicit
-// interface member, in a member of a shape.containing type at shape.position, and in a declaration of shape.refused-kind (which
-// compiles here, with no generators; the two kinds that do not are excluded). An attribute-argument row also writes the documented
-// RequireParameterlessConstructor case. One compilation per row, and every check judges its share of it:
-//   a-cast-naming-no-member, default-and-zero: each FaultKind place of an undefined value is reported once, at or around the value,
-//   naming FaultKind (default-and-zero also judges RequireParameterlessConstructor's default, Public, silent);
-//   constructor-accessibility-too: RequireParameterlessConstructor's (ConstructorAccessibility)9 is reported, naming its enum;
-//   reported-where-written: every report sits at the value's own span, and none outside every place;
-//   a-member-is-silent: no place of a value that names a member is reported, and nothing is reported anywhere.
-using Probes.Build;
-using Probes.Shapes;
-namespace Probes;
-
-public sealed class C17Cmtk0014Probe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("C17Cmtk0014Probe");
-
-    [Theory, MemberData(nameof(Data))]
-    public Task Probe(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    sealed class Places(string value, string site)
-    {
-        int n;
-        public readonly HashSet<string> Expected = new();
-        public readonly List<string> Labels = new();
-        public bool Undefined => value != "valid";
-
-        string Label() { var l = "p" + n++; Labels.Add(l); if (Undefined) Expected.Add(l); return l; }
-
-        string Value(bool targetTyped) => (site, value) switch
-        {
-            ("cast", "(FaultKind)9") => "(FaultKind)9",
-            ("cast", "default") => "(FaultKind)0",
-            ("cast", "valid") => "(FaultKind)2",
-            ("default-literal", _) => targetTyped ? "default" : "default(FaultKind)",
-            ("attribute-argument", "(FaultKind)9") => "(FaultKind)9",
-            ("attribute-argument", "default") => "default",
-            ("attribute-argument", "valid") => "FaultKind.Conflict",
-            _ => throw new ArgumentException($"{site} {value}"),
-        };
-
-        /// <summary>The expression for a place (marked unless the value goes into the attribute), and the attribute to put on its member.</summary>
-        public (string E, string Attr) Place(bool targetTyped = true)
-        {
-            var l = Label();
-            return site == "attribute-argument"
-                ? ("FaultKind.NotFound", $"[ProbeKind({{|#{l}:{Value(true)}|}})] ")
-                : ($"{{|#{l}:{Value(targetTyped)}|}}", "");
-        }
-
-        /// <summary>RequireParameterlessConstructor's argument: (ConstructorAccessibility)9 is reported, default (Public) and a member are not.</summary>
-        public string Accessibility()
-        {
-            var l = "ca" + n++; Labels.Add(l);
-            if (value == "(FaultKind)9") Expected.Add(l);
-            var v = value switch { "(FaultKind)9" => "(ConstructorAccessibility)9", "default" => "default", _ => "ConstructorAccessibility.Internal" };
-            return $"{{|#{l}:{v}|}}";
-        }
-    }
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        var value = r["value"]; var site = r["site"];
-        if (site == "default-literal" && value != "default")
-        {
-            r.Substituted("site", "cast", "a default literal is the value 0, so it cannot spell this value (excluded pair)");
-            site = "cast";
-        }
-        var kind = r["shape.kind"]; var inheritance = r["shape.inheritance"];
-        if (Src.IsStructKind(kind) && inheritance is not ("none" or "explicit-interface-member"))
-        {
-            r.Substituted("shape.inheritance", "none", "a record struct has no base type (excluded pair)");
-            inheritance = "none";
-        }
-        var p = new Places(value, site);
-        var id = r.Index.ToString();
-        var body = new System.Text.StringBuilder();
-
-        // The declaration of shape.kind over shape.wrapped, with its base chain and explicit member.
-        var depth = inheritance switch { "base-depth-1" or "base-explicit-IEquatable" => 1, "base-depth-2" => 2, "base-depth-3" => 3, _ => 0 };
-        var record = kind != "closed-set";
-        for (var d = depth; d >= 1; d--)
-        {
-            var name = $"DB{id}_{d}"; var parent = d == depth ? "" : $" : DB{id}_{d + 1}";
-            var equatable = d == 1 && inheritance == "base-explicit-IEquatable";
-            if (equatable) parent = parent.Length == 0 ? $" : IEquatable<{name}>" : parent + $", IEquatable<{name}>";
-            var members = d == depth ? Member(p.Place(), "BK") : "";
-            if (equatable) members += $"\n    bool IEquatable<{name}>.Equals({name}? other) => ReferenceEquals(this, other);";
-            body.AppendLine($"public abstract {(record ? "record" : "class")} {name}{parent}\n{{\n    {members}\n}}");
-        }
-        var explicitMember = inheritance == "explicit-interface-member";
-        var mark = explicitMember ? $", IMark{id}" : "";
-        if (explicitMember) body.AppendLine($"public interface IMark{id} {{ FaultKind Mark(); }}");
-        var baseList = depth > 0 ? $"DB{id}_1, " : "";
-        string Explicit() { if (!explicitMember) return ""; var (e, a) = p.Place(); return $"\n    {a}FaultKind IMark{id}.Mark() => {e};"; }
-        if (kind == "closed-set")
-        {
-            var (e, a) = p.Place();
-            body.AppendLine($$"""
-                public sealed partial class D{{id}} : {{baseList}}IFaultSet<D{{id}}>{{mark}}
-                {
-                    public static readonly D{{id}} A = new(FaultKind.NotFound);
-                    {{a}}public static readonly D{{id}} M = new({{e}});
-                    private D{{id}}(FaultKind kind) => Kind = kind;
-                    public FaultKind Kind { get; }
-                    public string Name => "";
-                    public string QualifiedName => "";
-                    public static IReadOnlyList<D{{id}}> All => [A, M];
-                    public static bool TryParse(string? name, out D{{id}} member) { member = A; return true; }{{Explicit()}}
-                }
-                """);
-        }
-        else
-        {
-            var w = Src.Wrapped(r["shape.wrapped"], id);
-            var head = kind switch
-            {
-                "record-struct" => $"public readonly partial record struct D{id} : IValue<{w}>{mark}",
-                "sealed-record-class" => $"public sealed partial record D{id} : {baseList}IValue<{w}>{mark}",
-                "validated-struct" => $"public readonly partial record struct D{id} : IValidatedValue<D{id}, {w}, DF{id}>{mark}",
-                "validated-class" => $"public sealed partial record D{id} : {baseList}IValidatedValue<D{id}, {w}, DF{id}>{mark}",
-                _ => throw new ArgumentException(kind),
-            };
-            var create = kind.StartsWith("validated") ? $"\n    public static Result<D{id}, DF{id}> Create({w} value) => Result.Error(DF{id}.No);" : "";
-            body.AppendLine($"public enum DF{id} {{ No }}");
-            body.AppendLine($"{head}\n{{\n    {Member(p.Place(), "K")}{create}{Explicit()}\n}}");
-        }
-
-        // shape.refused-kind: refused by the generators, an ordinary declaration to the compiler. The two kinds that are not (a closed
-        // set named as a generated member, CS0535; a hand-written operator ==, CS0111) are excluded in claims.json, and a row the
-        // covering array fills with one runs over object instead.
-        var refused = r["shape.refused-kind"];
-        if (refused is "closed-set-named-as-generated-member (CMTK1021)" or "equality-operator (CMTK1011)")
-        {
-            r.Substituted("shape.refused-kind", "over-object (CMTK1005)", "it does not compile without the generators (excluded pair)");
-            refused = "over-object (CMTK1005)";
-        }
-        var rm = Member(p.Place(), "RK");
-        body.AppendLine(refused switch
-        {
-            "unsealed-record-class (CMTK1006)" => $"public partial record R{id} : IValue<string> {{ {rm} }}",
-            "over-value-object (CMTK1005)" => $"public readonly partial record struct RIn{id} : IValue<int>;\npublic sealed partial record R{id} : IValue<RIn{id}> {{ {rm} }}",
-            "generic-wrapped (CMTK1005)" => $"public readonly partial record struct R{id} : IValue<List<int>> {{ {rm} }}",
-            "abstract (CMTK1005)" => $"public abstract partial record R{id} : IValue<string> {{ {rm} }}",
-            "over-object (CMTK1005)" => $"public sealed partial record R{id} : IValue<object> {{ {rm} }}",
-            "over-System.Enum (CMTK1005)" => $"public readonly partial record struct R{id} : IValue<System.Enum> {{ {rm} }}",
-            "named-as-generated-member (CMTK1005)" => $"public readonly partial record struct {Refusals.ValueObjectNames[r.Index % Refusals.ValueObjectNames.Length]} : IValue<int> {{ {rm} }}",
-            _ => throw new ArgumentException(refused),
-        });
-
-        // shape.containing at shape.position.
-        body.AppendLine(Container(r["shape.containing"], r["shape.position"], $"C{id}", p));
-
-        if (site == "attribute-argument")
-            body.AppendLine($"[RequireParameterlessConstructor({p.Accessibility()})] public interface IPlug{id} {{ }}");
-
-        var source = Src.Usings + Src.WrappedDeclarations(id) +
-            "[AttributeUsage(AttributeTargets.All, AllowMultiple = true)] public sealed class ProbeKindAttribute(FaultKind kind) : Attribute { public FaultKind Kind { get; } = kind; }\n" +
-            Src.AtSite(r["shape.site"], id, body.ToString());
-        var run = await Rz.Analyze("CMTK0014", [("Row" + id + ".cs", source)]);
-        if (run.Errors.Count > 0) { r.Outcome("harness-error", "the probe's source does not compile: " + run.ErrorText()); return null; }
-        if (run.AnalyzerFailures.Count > 0) return "the analyzer failed: " + string.Join("; ", run.AnalyzerFailures.Select(f => f.GetMessage()));
-
-        // Every check the row's value selects runs, so a seed that breaks one obligation is seen by its own check whatever the others find.
-        var readme = Baseline.Docs("src/CodoMetis.TypeKit.Analyzers/README.md#cmtk0014");
-        var kinds = p.Labels.Where(l => l.StartsWith('p')).ToList();
-        var accessibilities = p.Labels.Where(l => l.StartsWith("ca", StringComparison.Ordinal)).ToList();
-        var failures = new List<string?>();
-        switch (value)
-        {
-            case "(FaultKind)9":
-                failures.Add(r.Check("a-cast-naming-no-member", readme, c => Judged(c, Rz.Reported(run, kinds, p.Expected, Names), $"{kinds.Count} FaultKind places reported")));
-                if (site == "attribute-argument")
-                    failures.Add(r.Check("constructor-accessibility-too", readme, c => Judged(c, Rz.Reported(run, accessibilities, p.Expected, Names), "RequireParameterlessConstructor's (ConstructorAccessibility)9 reported")));
-                failures.Add(r.Check("reported-where-written", readme, c => Judged(c, Rz.WhereWritten(run, p.Expected), $"{p.Expected.Count} reports at the value")));
-                break;
-            case "default":
-                failures.Add(r.Check("default-and-zero", readme, c => Judged(c, Rz.Reported(run, p.Labels, p.Expected, Names), $"{kinds.Count} FaultKind places reported, {accessibilities.Count} default ConstructorAccessibility silent")));
-                failures.Add(r.Check("reported-where-written", readme, c => Judged(c, Rz.WhereWritten(run, p.Expected), $"{p.Expected.Count} reports at the value")));
-                break;
-            case "valid":
-                failures.Add(r.Check("a-member-is-silent", readme, c => Judged(c, Rz.Reported(run, p.Labels, p.Expected) ?? Rz.WhereWritten(run, p.Expected), $"{p.Labels.Count} places silent")));
-                break;
-            default: throw new ArgumentException("value " + value);
-        }
-        return failures.FirstOrDefault(f => f is not null);
-    }
-
-    static string? Judged(Probes.Shapes.Check c, string? failure, string compared)
-    {
-        if (failure is null) c.Note(NoteKeys.Compared, compared);
-        return failure;
-    }
-
-    /// <summary>A report names the enum of the place it is at: FaultKind, or ConstructorAccessibility for RequireParameterlessConstructor's.</summary>
-    static string? Names(Microsoft.CodeAnalysis.Diagnostic d, Mark m)
-    {
-        var type = m.Label.StartsWith("ca", StringComparison.Ordinal) ? "ConstructorAccessibility" : "FaultKind";
-        return d.GetMessage().Contains($"names no member of {type}") ? null : $"the report does not name {type}: {d.GetMessage()}";
-    }
-
-    static string Member((string E, string Attr) place, string name) => $"{place.Attr}public static FaultKind {name} => {place.E};";
-
-    /// <summary>shape.containing holding the value at shape.position; static members, so a struct needs no constructor.</summary>
-    static string Container(string containing, string position, string name, Places p)
-    {
-        var self = Src.ContainerSelf(containing, name);
-        if (position == "record-ctor-parameter")
-        {
-            var (e, a) = p.Place();
-            var record = containing is "record-class" or "record-struct";
-            var parameter = record ? $"({a}FaultKind K = {e})" : $"({a}FaultKind k = {e})";
-            return Src.ContainerHead(containing, name, parameter) + (record ? ";" : " { public FaultKind K => k; }");
-        }
-        string member;
-        if (position == "required-init")
-        {
-            var (e, a) = p.Place();
-            member = $"{a}public required FaultKind K {{ get; init; }}\n    public static {self} Make() => new() {{ K = {e} }};";
-        }
-        else if (position == "polymorphic-derived-property")
-        {
-            var (e, a) = p.Place();
-            member = $"public abstract class PB {{ public abstract FaultKind K {{ get; }} }}\n    public sealed class PD : PB {{ {a}public override FaultKind K => {e}; }}";
-        }
-        else
-        {
-            var (e, a) = p.Place(targetTyped: position != "nullable-property");
-            member = a + position switch
-            {
-                "root" => $"public static FaultKind Root() => {e};",
-                "property" => $"public static FaultKind P {{ get; }} = {e};",
-                "nullable-property" => $"public static FaultKind? N {{ get; }} = {e};",
-                "field" => $"public static readonly FaultKind F = {e};",
-                "list-element" => $"public static readonly List<FaultKind> L = [{e}];",
-                "array-element" => $"public static readonly FaultKind[] A = [{e}];",
-                "immutable-array-element" => $"public static readonly ImmutableArray<FaultKind> I = [{e}];",
-                "read-only-list-element" => $"public static readonly IReadOnlyList<FaultKind> R = [{e}];",
-                "dictionary-key" => $"public static readonly Dictionary<FaultKind, int> D = new() {{ [{e}] = 1 }};",
-                "dictionary-value" => $"public static readonly Dictionary<int, FaultKind> D = new() {{ [1] = {e} }};",
-                "in-patch" => $"public static Patch<FaultKind> Pa => Patch.Value<FaultKind>({e});",
-                _ => throw new ArgumentException("shape.position " + position),
-            };
-        }
-        return $"{Src.ContainerHead(containing, name)}\n{{\n    {member}\n}}";
-    }
-}
diff --git a/tools/probe/corpus/probes/C18Cmtk1023Probe.cs b/tools/probe/corpus/probes/C18Cmtk1023Probe.cs
deleted file mode 100644
index 6be2d049..00000000
--- a/tools/probe/corpus/probes/C18Cmtk1023Probe.cs
+++ /dev/null
@@ -1,245 +0,0 @@
-// Claim C18-cmtk1023 (src/CodoMetis.TypeKit.Generators/README.md#build-errors): "CMTK1023 | A warning, and the value object is
-// generated. A base record declares `Equals(TBase)`, `GetHashCode()` or `IEquatable<TBase>.Equals`, which the generated equality, the
-// underlying value's, doesn't call." With README#equality: "a hand-written `Equals(TBase)`, `GetHashCode()` or `IEquatable<TBase>.Equals`
-// on a base record isn't used, and a warning names it (CMTK1023)".
-// Obligations (claims.json), each with a check below and a seed of its own in the registry entry (decision 104); every row runs all three:
-//   names-each-base-member: "So a hand-written `Equals(TBase)`, `GetHashCode()` or `IEquatable<TBase>.Equals` on a base record isn't used, and a warning names it (CMTK1023)."
-//   a-warning-and-generated: "A warning, and the value object is generated."
-//   generated-equality-never-calls-the-base: "Over a base record, the generated `Equals(TSelf)` and `GetHashCode()` compare the underlying value alone, and never call the base's."
-// Oracle: the README's sentences (Baseline.Docs) for what the build reports, the wrapped values (Baseline.Twin) for equality. One
-// consumer build (Probes.Build.Consumer) holds every row's declaration in a file of its own: a value object of shape.kind over
-// shape.wrapped at shape.site, over a chain of base records (shape.inheritance: the base-member on the topmost of 1, 2 or 3 bases, or on
-// the direct base beside an explicit IEquatable of its own or an explicit member of another interface), used at shape.position of a
-// shape.containing type.
-//   names-each-base-member: the file reports CMTK1023 once, for that value object, naming each equality member its bases declare and
-//   nothing else;
-//   a-warning-and-generated: the file reports no error, CMTK1023 is a warning, and the value object is generated (its From or TryFrom
-//   is in the built assembly);
-//   generated-equality-never-calls-the-base: in this process, the half of the sentence a run can show: over a base that declares the
-//   base-member by reference, the generated equality is the underlying value's (one value object per base-member, built by this
-//   project's own weaving). It reads base-member alone, since the row's shape is not what it runs.
-// The row's settings are read inside the checks that run them (the consumer's two), from the rows file's copy of the row.
-using Probes.Build;
-using Baseline = Probes.Shapes.Baseline;
-using NoteKeys = Probes.Shapes.NoteKeys;
-namespace Probes;
-
-#pragma warning disable CMTK1023, CS8851 // the bases' own equality is the point; CS8851: the Equals base has no GetHashCode, on purpose
-public enum C18TwinFault { No }
-public abstract record C18EqualsBase { public virtual bool Equals(C18EqualsBase? other) => ReferenceEquals(this, other); }
-public abstract record C18HashBase { public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this); }
-public abstract record C18EquatableBase : IEquatable<C18EquatableBase> { bool IEquatable<C18EquatableBase>.Equals(C18EquatableBase? other) => ReferenceEquals(this, other); }
-public sealed partial record C18EqualsTwin : C18EqualsBase, CodoMetis.TypeKit.ValueObjects.IValidatedValue<C18EqualsTwin, int, C18TwinFault>
-{ public static CodoMetis.TypeKit.Result<C18EqualsTwin, C18TwinFault> Create(int value) => new C18EqualsTwin(value); }
-public sealed partial record C18HashTwin : C18HashBase, CodoMetis.TypeKit.ValueObjects.IValidatedValue<C18HashTwin, int, C18TwinFault>
-{ public static CodoMetis.TypeKit.Result<C18HashTwin, C18TwinFault> Create(int value) => new C18HashTwin(value); }
-public sealed partial record C18EquatableTwin : C18EquatableBase, CodoMetis.TypeKit.ValueObjects.IValidatedValue<C18EquatableTwin, int, C18TwinFault>
-{ public static CodoMetis.TypeKit.Result<C18EquatableTwin, C18TwinFault> Create(int value) => new C18EquatableTwin(value); }
-#pragma warning restore CMTK1023, CS8851
-
-public sealed class C18Cmtk1023Probe
-{
-    const string RowsFile = "C18Cmtk1023Probe"; // the probe's own rows
-
-    public static TheoryData<string, int> Data() => Probes.Shapes.Rows.Data(RowsFile);
-
-    [Theory, MemberData(nameof(Data))]
-    public Task Probe(string probe, int idx) => Probes.Shapes.Rec.Run(probe, idx, Check);
-
-    /// <summary>A row as it is declared: the excluded values it carries replaced by the nearest that exists, each named.</summary>
-    sealed record Shape(string Kind, string Site, string Inheritance, string Wrapped, string Member, string Containing, string Position, List<(string Axis, string Value, string Why)> Substituted);
-
-    static Shape Of(Probes.Shapes.Row r)
-    {
-        var subs = new List<(string, string, string)>();
-        var kind = r["shape.kind"];
-        if (kind is not ("sealed-record-class" or "validated-class")) { subs.Add(("shape.kind", "sealed-record-class", "a record struct or a closed set has no base record (excluded)")); kind = "sealed-record-class"; }
-        var site = r["shape.site"];
-        if (site == "in-generic-type") { subs.Add(("shape.site", "nested-in-class", "a value object in a generic type is CMTK1005 (excluded)")); site = "nested-in-class"; }
-        var inheritance = r["shape.inheritance"];
-        if (inheritance == "none") { subs.Add(("shape.inheritance", "base-depth-1", "with no base there is no base member (excluded)")); inheritance = "base-depth-1"; }
-        return new(kind, site, inheritance, r["shape.wrapped"], r["base-member"], r["shape.containing"], r["shape.position"], subs);
-    }
-
-    static int Depth(string inheritance) => inheritance switch { "base-depth-2" => 2, "base-depth-3" => 3, _ => 1 };
-
-    /// <summary>The members CMTK1023 must name, as fragments of its message: the base-member, and the direct base's explicit IEquatable.</summary>
-    static List<string> Named(Shape s, string id)
-    {
-        var q = Nesting(s, id);
-        var top = $"{q}B{id}_{Depth(s.Inheritance)}";
-        var named = new List<string>
-        {
-            s.Member switch
-            {
-                "Equals" => $"{top}.Equals({top}?)",
-                "GetHashCode" => $"{top}.GetHashCode()",
-                "IEquatable" => $"IEquatable<{top}>.Equals({top}?)",
-                _ => throw new ArgumentException(s.Member),
-            },
-        };
-        if (s.Inheritance == "base-explicit-IEquatable" && s.Member != "IEquatable") named.Add($"IEquatable<{q}B{id}_1>.Equals({q}B{id}_1?)");
-        return named;
-    }
-
-    static string Source(Shape s, string id)
-    {
-        var depth = Depth(s.Inheritance);
-        var body = new System.Text.StringBuilder();
-        if (s.Inheritance == "explicit-interface-member") body.AppendLine($"public interface IMark{id} {{ int Mark(); }}");
-        for (var d = depth; d >= 1; d--)
-        {
-            var name = $"B{id}_{d}";
-            var interfaces = new List<string>();
-            var members = new List<string>();
-            if (d == depth)
-                switch (s.Member)
-                {
-                    case "Equals": members.Add($"public virtual bool Equals({name}? other) => ReferenceEquals(this, other);"); break;
-                    case "GetHashCode": members.Add("public override int GetHashCode() => 0;"); break;
-                    case "IEquatable": interfaces.Add($"IEquatable<{name}>"); members.Add($"bool IEquatable<{name}>.Equals({name}? other) => ReferenceEquals(this, other);"); break;
-                }
-            if (d == 1 && s.Inheritance == "base-explicit-IEquatable" && s.Member != "IEquatable")
-            { interfaces.Add($"IEquatable<{name}>"); members.Add($"bool IEquatable<{name}>.Equals({name}? other) => ReferenceEquals(this, other);"); }
-            if (d == 1 && s.Inheritance == "explicit-interface-member") { interfaces.Add($"IMark{id}"); members.Add($"int IMark{id}.Mark() => 0;"); }
-            var parents = (d == depth ? new List<string>() : [$"B{id}_{d + 1}"]).Concat(interfaces).ToList();
-            body.AppendLine($"public abstract record {name}{(parents.Count > 0 ? " : " + string.Join(", ", parents) : "")} {{ {string.Join(" ", members)} }}");
-        }
-        var w = Src.Wrapped(s.Wrapped, id);
-        body.AppendLine(s.Kind == "validated-class"
-            ? $"public enum VF{id} {{ No }}\npublic sealed partial record V{id} : B{id}_1, IValidatedValue<V{id}, {w}, VF{id}>\n{{\n    public static Result<V{id}, VF{id}> Create({w} value) => new V{id}(value);\n}}"
-            : $"public sealed partial record V{id} : B{id}_1, IValue<{w}>;");
-        body.AppendLine(Container(s.Containing, s.Position, $"C{id}", $"V{id}"));
-        return Src.Usings + $"namespace C18R{id};\n" + Src.WrappedDeclarations(id) + Src.AtSite(s.Site, id, body.ToString()) + "\n";
-    }
-
-    /// <summary>shape.containing using the value object at shape.position; no initializers, so a struct needs no constructor.</summary>
-    static string Container(string containing, string position, string name, string v)
-    {
-        if (position == "record-ctor-parameter")
-        {
-            var record = containing is "record-class" or "record-struct";
-            return Src.ContainerHead(containing, name, record ? $"({v} K)" : $"({v} k)") + (record ? ";" : $" {{ public {v} K => k; }}");
-        }
-        var member = position switch
-        {
-            "root" => $"public static {v}? Root() => null;",
-            "property" => $"public {v}? P {{ get; set; }}",
-            "nullable-property" => $"public {v}? N {{ get; set; }}",
-            "field" => $"public {v}? F;",
-            "list-element" => $"public List<{v}>? L {{ get; set; }}",
-            "array-element" => $"public {v}[]? A {{ get; set; }}",
-            "immutable-array-element" => $"public ImmutableArray<{v}> I {{ get; set; }}",
-            "read-only-list-element" => $"public IReadOnlyList<{v}>? R {{ get; set; }}",
-            "dictionary-key" => $"public Dictionary<{v}, int>? D {{ get; set; }}",
-            "dictionary-value" => $"public Dictionary<int, {v}>? D {{ get; set; }}",
-            "required-init" => $"public required {v} K {{ get; init; }}",
-            "in-patch" => $"public Patch<{v}> Pa {{ get; set; }}",
-            "polymorphic-derived-property" => $"public abstract class PB {{ }}\n    public sealed class PD : PB {{ public {v}? K {{ get; set; }} }}",
-            _ => throw new ArgumentException("shape.position " + position),
-        };
-        return $"{Src.ContainerHead(containing, name)}\n{{\n    {member}\n}}";
-    }
-
-    /// <summary>The site's nesting as the diagnostic writes a type: its containing types, dotted.</summary>
-    static string Nesting(Shape s, string id) => s.Site switch
-    {
-        "top-level" => "", "nested-in-class" or "nested-in-struct" => $"O{id}.", "nested-two-levels" => $"O{id}.P{id}.", _ => throw new ArgumentException(s.Site),
-    };
-
-    /// <summary>The value object's metadata name: the row's namespace, then the site's nesting.</summary>
-    static string MetadataName(Shape s, string id) => $"C18R{id}." + s.Site switch
-    {
-        "top-level" => "", "nested-in-class" or "nested-in-struct" => $"O{id}+", "nested-two-levels" => $"O{id}+P{id}+", _ => throw new ArgumentException(s.Site),
-    } + $"V{id}";
-
-    /// <summary>
-    /// Two value objects holding 42 over a base declaring the member by reference, and one holding 43: equal, of one hash, and unequal,
-    /// as the wrapped values 42, 42 and 43 are.
-    /// </summary>
-    static string? Twin(string member)
-    {
-        (object A, object B, object C, object BaseA, object BaseB) v = member switch
-        {
-            "Equals" => (C18EqualsTwin.FromKnownGood(42), C18EqualsTwin.FromKnownGood(42), C18EqualsTwin.FromKnownGood(43), (C18EqualsBase)C18EqualsTwin.FromKnownGood(42), (C18EqualsBase)C18EqualsTwin.FromKnownGood(42)),
-            "GetHashCode" => (C18HashTwin.FromKnownGood(42), C18HashTwin.FromKnownGood(42), C18HashTwin.FromKnownGood(43), C18HashTwin.FromKnownGood(42), C18HashTwin.FromKnownGood(42)),
-            "IEquatable" => (C18EquatableTwin.FromKnownGood(42), C18EquatableTwin.FromKnownGood(42), C18EquatableTwin.FromKnownGood(43), C18EquatableTwin.FromKnownGood(42), C18EquatableTwin.FromKnownGood(42)),
-            _ => throw new ArgumentException(member),
-        };
-        int a = 42, b = 42, c = 43;
-        if (v.A.Equals(v.B) != a.Equals(b) || (v.A.GetHashCode() == v.B.GetHashCode()) != (a.GetHashCode() == b.GetHashCode()))
-            return $"over a base declaring {member} by reference, two value objects holding 42 are unequal or hash apart: the generated equality called the base's";
-        if (v.A.Equals(v.C) != a.Equals(c)) return $"over a base declaring {member}, value objects holding 42 and 43 are equal";
-        if (member == "IEquatable" && ((IEquatable<C18EquatableBase>)v.BaseA).Equals((C18EquatableBase)v.BaseB) != a.Equals(b)) return "the base's explicit IEquatable<TBase> compares two value objects holding 42 by reference";
-        return null;
-    }
-
-    static Task<ConsumerOutcome> Built() => Consumer.Build(RowsFile, () =>
-        Probes.Shapes.Rows.Load(RowsFile).ToDictionary(row => $"R{row.Index}.cs", row => Source(Of(row), row.Index.ToString())));
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        // The row as the rows file holds it, read without marking the run's row: each check marks what it ran.
-        var s = Of(Probes.Shapes.Rows.Get(RowsFile, r.Index));
-        var id = r.Index.ToString();
-        var build = await Built();
-        var file = $"R{id}.cs";
-        var mine = build.In(file).ToList();
-        var errors = mine.Where(d => d.Severity == "error").ToList();
-        if (errors.Any(e => e.Id.StartsWith("CS")))
-        { r.Outcome("harness-error", "the probe's declaration does not compile: " + string.Join("; ", errors.Select(e => $"{e.Id} {e.Message}"))); return null; }
-        var reported = mine.Where(d => d.Id == "CMTK1023").ToList();
-
-        // Every check runs, so a seed that breaks one obligation is seen by its own check whatever the others find.
-        var named = r.Check("names-each-base-member", Baseline.Docs("src/CodoMetis.TypeKit.Generators/README.md#equality"), c => { Ran(c, s); return NamesEach(c, s, id, file, reported); });
-        var generated = r.Check("a-warning-and-generated", Baseline.Docs("src/CodoMetis.TypeKit.Generators/README.md#build-errors"), c => { Ran(c, s); return WarningAndGenerated(c, s, id, build, errors, reported); });
-        var equality = r.Check("generated-equality-never-calls-the-base", Baseline.Twin, c => Equality(c));
-        return named ?? generated ?? equality;
-    }
-
-    /// <summary>Marks the axes the consumer's declaration was written from read for <paramref name="c"/>, at the value that ran.</summary>
-    static void Ran(Probes.Shapes.Check c, Shape s)
-    {
-        foreach (var axis in (string[])["shape.kind", "shape.site", "shape.inheritance", "shape.wrapped", "base-member", "shape.containing", "shape.position"]) _ = c[axis];
-        foreach (var (axis, value, why) in s.Substituted) c.Substituted(axis, value, why);
-    }
-
-    static string? NamesEach(Probes.Shapes.Check c, Shape s, string id, string file, List<BuildDiagnostic> reported)
-    {
-        if (reported.Count != 1) return $"CMTK1023 reported {reported.Count} times in {file}, expected once";
-        var d = reported[0];
-        if (!d.Message.StartsWith($"'{Nesting(s, id)}V{id}' inherits ", StringComparison.Ordinal))
-            return "CMTK1023 does not name the value object: " + d.Message;
-        var named = Named(s, id);
-        foreach (var name in named)
-            if (!d.Message.Contains(name, StringComparison.Ordinal)) return $"CMTK1023 does not name {name}: {d.Message}";
-        var count = System.Text.RegularExpressions.Regex.Matches(d.Message, " in its base type ").Count;
-        if (count != named.Count) return $"CMTK1023 names {count} members, the bases declare {named.Count} ({string.Join(", ", named)}): {d.Message}";
-        if (d.Message.Contains("Mark", StringComparison.Ordinal)) return "CMTK1023 names the explicit member of another interface: " + d.Message;
-        c.Note(NoteKeys.Compared, $"{named.Count} members named");
-        return null;
-    }
-
-    static string? WarningAndGenerated(Probes.Shapes.Check c, Shape s, string id, ConsumerOutcome build, List<BuildDiagnostic> errors, List<BuildDiagnostic> reported)
-    {
-        if (errors.Count > 0) return "the value object is not generated: " + string.Join("; ", errors.Select(e => $"{e.Id} {e.Message}"));
-        if (reported.Count == 0) return "no CMTK1023 warning: the build reports none for the value object";
-        if (reported.FirstOrDefault(d => d.Severity != "warning") is { } other) return $"CMTK1023 is reported as {other.Severity}, documented a warning";
-        if (build.Methods.Count == 0)
-        { c.Outcome("harness-error", $"the consumer built no assembly (exit {build.ExitCode}): " + string.Join("; ", build.Diagnostics.Where(x => x.Severity == "error").Take(3).Select(x => $"{Path.GetFileName(x.File)} {x.Id} {x.Message}"))); return null; }
-        var type = MetadataName(s, id);
-        if (!build.Methods.TryGetValue(type, out var methods)) { c.Outcome("harness-error", $"no type {type} in the consumer"); return null; }
-        var entry = s.Kind == "validated-class" ? "TryFrom" : "From";
-        if (!methods.Contains(entry)) return $"the value object is not generated: {type} has no {entry} ({string.Join(", ", methods.Order())})";
-        c.Note(NoteKeys.Compared, $"a warning, and {type} has {entry}");
-        return null;
-    }
-
-    static string? Equality(Probes.Shapes.Check c)
-    {
-        var member = c["base-member"];
-        if (Twin(member) is { } twin) return twin;
-        c.Note(NoteKeys.Compared, $"over a base declaring {member}, equality is the wrapped value's");
-        return null;
-    }
-}
diff --git a/tools/probe/corpus/probes/C19Cmtk0010KindsProbe.cs b/tools/probe/corpus/probes/C19Cmtk0010KindsProbe.cs
deleted file mode 100644
index 349e1ea1..00000000
--- a/tools/probe/corpus/probes/C19Cmtk0010KindsProbe.cs
+++ /dev/null
@@ -1,504 +0,0 @@
-// Claim C19-cmtk0010-kinds (docs/type-constraints.md#the-kind-of-a-type-argument, with its "Two parameters apart" and the list of
-// what the rule checks): [Interface], [Unsealed], [ValueObject], [ClosedSet], [FlagsEnum], [ReadOnlyStruct], [Distinct] and [Unrelated]
-// reject the kinds the page's table names, CMTK0010 (Error), "at the methods the compiler calls for you: a foreach's GetEnumerator, an
-// await's GetAwaiter, a Deconstruct (in var (a, b) = x, a foreach, or a pattern like x is (1, 2)), and a collection expression's Add or
-// builder method ... every other attribute is [checked]", and at a call; "An inferred one is reported at the call ... the foreach's
-// collection, the await, the deconstruction, the pattern or the collection expression"; a pair's breach "once, at the later argument".
-// Obligations (claims.json), each with a check below and a seed of its own in the registry entry (decision 104), the row's attribute
-// selecting one of the first four and a site other than a call the fifth:
-//   interface-and-unsealed, value-object-and-closed-set, flags-enum-and-read-only-struct (attribute): the page's sentences on the pairs
-//   of kinds; a-pair-once-at-the-later-argument (Distinct, Unrelated): "A breach is reported once, at the later argument.";
-//   methods-the-compiler-calls (site foreach, await, Deconstruct, collection-expression): "**Methods the compiler calls for you:** ..."
-// Oracle: the page (Baseline.Docs): its table ("Accepts") over what each argument is, and its list of what the rule checks. Each row
-// compiles, with the CMTK0010 analyzer:
-//  - the catalogue (test/CodoMetis.TypeKit.Analyzers.Tests/Variants: TypeArgumentSites' subjects, its calls with written and inferred
-//    arguments and its uses of the row's site, TypeArgumentKinds' candidates), with one argument that breaks the attribute and one that
-//    meets it (a pair attribute: subjects of two parameters at the same sites), plus a collection expression's builder method, which
-//    the catalogue has no use of;
-//  - the row's shapes as arguments at the same calls and sites: the value object or closed set of shape.kind over shape.wrapped at
-//    shape.site, its base and its explicit interface (shape.inheritance), the wrapped type itself, and a declaration of
-//    shape.refused-kind (one that compiles without the generators; the two that do not are excluded); each use hosted in a member of
-//    shape.containing at shape.position.
-// The attribute's check judges the calls: every breaking use reported exactly once at its span, no meeting one, nothing anywhere else.
-// The methods' check judges the uses at the row's site against each argument's call with inferred arguments in the same compilation:
-// reported once at its span where that call is reported, silent where it is silent; so a kind the rule misjudges fails the attribute's
-// check alone, and a site the rule does not check fails the methods' check alone.
-using Probes.Build;
-using Baseline = Probes.Shapes.Baseline;
-using NoteKeys = Probes.Shapes.NoteKeys;
-using CodoMetis.TypeKit.Analyzers.Tests.Variants;
-namespace Probes;
-
-public sealed class C19Cmtk0010KindsProbe
-{
-    const string RowsFile = "C19Cmtk0010KindsProbe"; // the probe's own rows
-
-    public static TheoryData<string, int> Data() => Probes.Shapes.Rows.Data(RowsFile);
-
-    [Theory, MemberData(nameof(Data))]
-    public Task Probe(string probe, int idx) => Probes.Shapes.Rec.Run(probe, idx, Check);
-
-    /// <summary>What a type is, as the page's table reads it.</summary>
-    sealed record Facts(bool Interface = false, bool Class = false, bool Sealed = false, bool Struct = false, bool ReadOnly = false, bool Enum = false, bool Flags = false, bool ValueObject = false, bool ClosedSet = false);
-
-    /// <summary>The table's "Accepts" column.</summary>
-    static bool Accepts(string attribute, Facts f) => attribute switch
-    {
-        "Interface" => f.Interface,                                   // an interface
-        "Unsealed" => f.Class && !f.Sealed,                           // a class or record class that can be derived from, abstract included
-        "ValueObject" => f.ValueObject && !f.Interface,               // a struct or class that implements IValue<T> for any T
-        "ClosedSet" => f.ClosedSet,                                   // a type that implements IClosedSet<TSelf>
-        "FlagsEnum" => f.Enum && f.Flags,                             // an enum marked [Flags]
-        "ReadOnlyStruct" => f.Struct && f.ReadOnly && !f.Enum,        // a readonly struct or readonly record struct, the primitives included
-        _ => throw new ArgumentException(attribute),
-    };
-
-    static Facts OfKind(string kind) => kind switch
-    {
-        "record-struct" or "validated-struct" => new(Struct: true, ReadOnly: true, Sealed: true, ValueObject: true),
-        "sealed-record-class" or "validated-class" => new(Class: true, Sealed: true, ValueObject: true),
-        "closed-set" => new(Class: true, Sealed: true, ClosedSet: true),
-        _ => throw new ArgumentException(kind),
-    };
-
-    static Facts OfRefused(string refused) => refused switch
-    {
-        "unsealed-record-class (CMTK1006)" => new(Class: true, ValueObject: true),
-        "over-value-object (CMTK1005)" => new(Class: true, Sealed: true, ValueObject: true),
-        "generic-wrapped (CMTK1005)" => new(Struct: true, ReadOnly: true, Sealed: true, ValueObject: true),
-        "abstract (CMTK1005)" => new(Class: true, ValueObject: true),
-        "over-object (CMTK1005)" => new(Class: true, Sealed: true, ValueObject: true),
-        "over-System.Enum (CMTK1005)" => new(Struct: true, ReadOnly: true, Sealed: true, ValueObject: true),
-        "named-as-generated-member (CMTK1005)" => new(Struct: true, ReadOnly: true, Sealed: true, ValueObject: true),
-        _ => throw new ArgumentException(refused),
-    };
-
-    static readonly Dictionary<string, Type> Runtime = new()
-    {
-        ["string"] = typeof(string), ["Guid"] = typeof(Guid), ["int"] = typeof(int), ["long"] = typeof(long), ["byte"] = typeof(byte), ["ulong"] = typeof(ulong),
-        ["decimal"] = typeof(decimal), ["double"] = typeof(double), ["bool"] = typeof(bool), ["char"] = typeof(char), ["DateTime"] = typeof(DateTime),
-        ["DateTimeOffset"] = typeof(DateTimeOffset), ["DateOnly"] = typeof(DateOnly), ["TimeOnly"] = typeof(TimeOnly), ["TimeSpan"] = typeof(TimeSpan),
-        ["Uri"] = typeof(Uri), ["NodaTime.Instant"] = typeof(NodaTime.Instant),
-    };
-
-    /// <summary>The wrapped type: the ones declared in the row's source by what they are declared as, the framework's by reflection.</summary>
-    static Facts OfWrapped(string wrapped)
-    {
-        switch (wrapped)
-        {
-            case "enum": return new(Enum: true, Struct: true, Sealed: true);
-            case "flags-enum": return new(Enum: true, Flags: true, Struct: true, Sealed: true);
-            case "own-record-class": return new(Class: true, Sealed: true);
-        }
-        var t = Runtime[wrapped];
-        // A library for netstandard2.0 (NodaTime) carries its own IsReadOnlyAttribute, so it is read by its full name.
-        var readOnly = t.IsValueType && t.GetCustomAttributesData().Any(a => a.AttributeType.FullName == "System.Runtime.CompilerServices.IsReadOnlyAttribute");
-        return new(Class: t.IsClass, Sealed: t.IsSealed, Struct: t.IsValueType, ReadOnly: readOnly || t.IsPrimitive || t == typeof(decimal));
-    }
-
-    static readonly string[] Pair = ["Distinct", "Unrelated"];
-
-    /// <summary>The catalogue's uses of the claim's site value.</summary>
-    static string[] CatalogueSites(string site) => site switch
-    {
-        "call" => ["a call with written arguments", "a call with inferred arguments"],
-        "foreach" => ["a foreach's GetEnumerator"],
-        "await" => ["an await's GetAwaiter"],
-        "Deconstruct" => ["a deconstruction", "a positional pattern"],
-        "collection-expression" => ["a collection expression's Add"],
-        _ => throw new ArgumentException(site),
-    };
-
-    /// <summary>A builder for a collection expression, the "or builder" the page names; one parameter and two.</summary>
-    const string Builders =
-        """
-        public static class ProbeBuilders
-        {
-            public static Built<T> Create<{C} T>(ReadOnlySpan<T> items) => new();
-        }
-        [System.Runtime.CompilerServices.CollectionBuilder(typeof(ProbeBuilders), nameof(ProbeBuilders.Create))]
-        public sealed class Built<T> : IEnumerable<T>
-        {
-            public IEnumerator<T> GetEnumerator() => throw new NotSupportedException();
-            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
-        }
-
-        """;
-
-    /// <summary>The catalogue's sites with two constrained parameters, for [Distinct] and [Unrelated].</summary>
-    const string PairSubjects =
-        """
-        public static class PairRunner { public static void Run<{C} T1, {C} T2>(T1 first, T2 second) { } }
-        public sealed class Bag2<T1, T2> { }
-        public sealed class Heap2<T1, T2> : IEnumerable<T1>
-        {
-            public IEnumerator<T1> GetEnumerator() => throw new NotSupportedException();
-            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
-        }
-        public static class PairPatterns
-        {
-            public static Cursor<T1> GetEnumerator<{C} T1, {C} T2>(this Bag2<T1, T2> bag) => default;
-            public static Waiter<T1> GetAwaiter<{C} T1, {C} T2>(this Bag2<T1, T2> bag) => default;
-            public static void Deconstruct<{C} T1, {C} T2>(this Bag2<T1, T2> bag, out int first, out int second) => (first, second) = (0, 0);
-            public static void Add<{C} T1, {C} T2>(this Heap2<T1, T2> heap, T1 item) { }
-        }
-        public static class PairBuilders
-        {
-            public static Built2<T1, T2> Create<{C} T1, {C} T2>(ReadOnlySpan<T1> items) => new();
-        }
-        [System.Runtime.CompilerServices.CollectionBuilder(typeof(PairBuilders), nameof(PairBuilders.Create))]
-        public sealed class Built2<T1, T2> : IEnumerable<T1>
-        {
-            public IEnumerator<T1> GetEnumerator() => throw new NotSupportedException();
-            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
-        }
-        public delegate System.Threading.Tasks.Task GoP<TF, TS>(TF x, TS y, Bag2<TF, TS> bag2);
-        public delegate System.Threading.Tasks.Task GoD<TG>(TG a, Holder? holder, Bag<TG> bag, Crate<TG> crate, object o);
-
-        """;
-
-    /// <summary>The statements of a pair site: x and y of the two arguments, bag2 of both. {F} and {S} are the arguments.</summary>
-    static string[] PairStatements(string site) => site switch
-    {
-        "call" => ["PairRunner.Run<{F}, {|#0:{S}|}>(x, y);", "{|#0:PairRunner.Run(x, y)|};"],
-        "foreach" => ["foreach (var item in {|#0:bag2|}) { }"],
-        "await" => ["_ = {|#0:await bag2|};"],
-        "Deconstruct" => ["{|#0:var (p, q) = bag2|};", "_ = bag2 is {|#0:(1, 2)|};"],
-        "collection-expression" => ["Heap2<{F}, {S}> heap = {|#0:[x]|};", "Built2<{F}, {S}> built = {|#0:[x]|};"],
-        _ => throw new ArgumentException(site),
-    };
-
-    sealed class Uses
-    {
-        int n;
-        public readonly HashSet<string> Expected = new();
-        public readonly List<string> All = new();
-        /// <summary>The uses at a call, written or inferred: what the attribute's check judges.</summary>
-        public readonly HashSet<string> Calls = new();
-        /// <summary>Each argument's call with inferred arguments, the baseline of its uses at the row's site.</summary>
-        public readonly Dictionary<string, string> InferredCall = new();
-        /// <summary>The uses at the row's site when it is not a call, each with its argument: what the methods' check judges.</summary>
-        public readonly Dictionary<string, string> AtSite = new();
-        public readonly System.Text.StringBuilder Core = new();
-        /// <summary>Relabels a statement's {|#0:…|} with a label of its own; its breaking or meeting is recorded.</summary>
-        public string Label(string statements, bool breaking) => Label(statements, breaking, out _);
-        string Label(string statements, bool breaking, out string l)
-        {
-            l = "u" + n++; All.Add(l); if (breaking) Expected.Add(l);
-            return statements.Replace("{|#0:", "{|#" + l + ":");
-        }
-        /// <summary>A use at a call of <paramref name="argument"/>, the inferred one its uses at the site are compared with.</summary>
-        public string Call(string statements, bool breaking, string argument, bool inferred)
-        {
-            var s = Label(statements, breaking, out var l);
-            Calls.Add(l);
-            if (inferred) InferredCall[argument] = l;
-            return s;
-        }
-        /// <summary>A use of <paramref name="argument"/> at the row's site, a method the compiler calls.</summary>
-        public string Site(string statements, bool breaking, string argument)
-        {
-            var s = Label(statements, breaking, out var l);
-            AtSite[l] = argument;
-            return s;
-        }
-        public int Next => n++;
-    }
-
-    static (string Prefix, string Suffix) BodyFrame()
-    {
-        var t = TypeArgumentSites.Body("\u0001");
-        var at = t.IndexOf('\u0001');
-        return (t[..at], t[(at + 1)..]);
-    }
-
-    static string StatementsOf(string siteName)
-    {
-        var use = TypeArgumentSites.All.Single(s => s.Name == siteName).Use;
-        var (prefix, suffix) = BodyFrame();
-        if (!use.StartsWith(prefix, StringComparison.Ordinal) || !use.EndsWith(suffix, StringComparison.Ordinal))
-            throw new InvalidOperationException($"the catalogue's use '{siteName}' is not written through TypeArgumentSites.Body");
-        return use[prefix.Length..^suffix.Length];
-    }
-
-    const string Inferred = "a call with inferred arguments";
-
-    /// <summary>The obligation of each attribute's row (claims.json).</summary>
-    static readonly Dictionary<string, string> ObligationOf = new()
-    {
-        ["Interface"] = "interface-and-unsealed", ["Unsealed"] = "interface-and-unsealed",
-        ["ValueObject"] = "value-object-and-closed-set", ["ClosedSet"] = "value-object-and-closed-set",
-        ["FlagsEnum"] = "flags-enum-and-read-only-struct", ["ReadOnlyStruct"] = "flags-enum-and-read-only-struct",
-        ["Distinct"] = "a-pair-once-at-the-later-argument", ["Unrelated"] = "a-pair-once-at-the-later-argument",
-    };
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        // The row as the rows file holds it, read without marking the run's row: each check marks the axes it ran, so the attribute's
-        // check, judged at the calls, is credited with the row's site only where the site is a call.
-        var row = Probes.Shapes.Rows.Get(RowsFile, r.Index);
-        var read = new List<string>();
-        var substituted = new List<(string Axis, string Value, string Why)>();
-        string Read(string axis) { read.Add(axis); return row[axis]; }
-
-        var attribute = Read("attribute"); var site = Read("site");
-        var pair = Pair.Contains(attribute);
-        var constraint = $"[{attribute}]";
-        var uses = new Uses();
-        var id = r.Index.ToString();
-        var atCall = site == "call";
-
-        // The catalogue, with an argument that breaks the attribute and one that meets it, each used at a call, written and inferred,
-        // and, where the row's site is not a call, at the site.
-        if (!pair)
-        {
-            var (breaking, meeting) = attribute switch
-            {
-                "Interface" => ("OrderHandler", "IHandler"),
-                "Unsealed" => ("OrderHandler", "Handler"),
-                "ValueObject" => ("Guid", "Id"),
-                "ClosedSet" => ("Id", "Palette"),
-                "FlagsEnum" => ("Shade", "Rights"),
-                "ReadOnlyStruct" => ("Mutable", "Frozen"),
-                _ => throw new ArgumentException(attribute),
-            };
-            var k = 0;
-            foreach (var (arg, breaks) in new[] { (breaking, true), (meeting, false) })
-            {
-                var argument = "catalogue:" + arg;
-                string Use(string use) => use.Replace("{A}", arg).Replace("public static class Use", $"public static class Use{k++}");
-                foreach (var name in CatalogueSites("call"))
-                    uses.Core.AppendLine(uses.Call(Use(TypeArgumentSites.All.Single(s => s.Name == name).Use), breaks, argument, name == Inferred));
-                if (atCall) continue;
-                foreach (var name in CatalogueSites(site))
-                    uses.Core.AppendLine(uses.Site(Use(TypeArgumentSites.All.Single(s => s.Name == name).Use), breaks, argument));
-                if (site == "collection-expression")
-                    uses.Core.AppendLine(uses.Site(Use(TypeArgumentSites.Body("Built<{A}> built = {|#0:[a]|};")), breaks, argument));
-            }
-        }
-        else
-        {
-            // [Unrelated] also keeps a type and its base apart; [Distinct] only one type twice.
-            var cases = new List<(string F, string S, bool Breaks)> { ("int", "string", false), ("Placed", "Placed", true), ("Handler", "OrderHandler", attribute == "Unrelated") };
-            var k = 0;
-            foreach (var (f, s, breaks) in cases)
-            {
-                var argument = $"catalogue:{f},{s}";
-                var calls = PairStatements("call");
-                for (var i = 0; i < calls.Length; i++)
-                    uses.Core.AppendLine(uses.Call(PairHost("root", "class", $"Pair{k++}", f, s, calls[i]), breaks, argument, inferred: i == 1));
-                if (atCall) continue;
-                foreach (var statement in PairStatements(site))
-                    uses.Core.AppendLine(uses.Site(PairHost("root", "class", $"Pair{k++}", f, s, statement), breaks, argument));
-            }
-        }
-
-        // The row's shapes.
-        var kind = Read("shape.kind"); var inheritance = Read("shape.inheritance");
-        if (Src.IsStructKind(kind) && inheritance is not ("none" or "explicit-interface-member"))
-        {
-            substituted.Add(("shape.inheritance", "none", "a record struct has no base type (excluded pair)"));
-            inheritance = "none";
-        }
-        var depth = inheritance switch { "base-depth-1" or "base-explicit-IEquatable" => 1, "base-depth-2" => 2, "base-depth-3" => 3, _ => 0 };
-        var decl = new System.Text.StringBuilder();
-        var record = kind != "closed-set";
-        for (var d = depth; d >= 1; d--)
-        {
-            var name = $"DB{id}_{d}"; var parent = d == depth ? "" : $" : DB{id}_{d + 1}";
-            var equatable = d == 1 && inheritance == "base-explicit-IEquatable";
-            if (equatable) parent = parent.Length == 0 ? $" : IEquatable<{name}>" : parent + $", IEquatable<{name}>";
-            decl.AppendLine($"public abstract {(record ? "record" : "class")} {name}{parent} {{ {(equatable ? $"bool IEquatable<{name}>.Equals({name}? other) => ReferenceEquals(this, other);" : "")} }}");
-        }
-        var explicitMember = inheritance == "explicit-interface-member";
-        var mark = explicitMember ? $", IMark{id}" : "";
-        var markMember = explicitMember ? $" int IMark{id}.Mark() => 0;" : "";
-        if (explicitMember) decl.AppendLine($"public interface IMark{id} {{ int Mark(); }}");
-        var baseList = depth > 0 ? $"DB{id}_1, " : "";
-        string? wrapped = null;
-        if (kind == "closed-set")
-            decl.AppendLine($$"""
-                public sealed partial class D{{id}} : {{baseList}}IClosedSet<D{{id}}>{{mark}}
-                {
-                    public static readonly D{{id}} A = new();
-                    public string Name => "";
-                    public string QualifiedName => "";
-                    public static IReadOnlyList<D{{id}}> All => [A];
-                    public static bool TryParse(string? name, out D{{id}} member) { member = A; return true; }{{markMember}}
-                }
-                """);
-        else
-        {
-            wrapped = Read("shape.wrapped");
-            var w = Src.Wrapped(wrapped, id);
-            decl.AppendLine($"public enum DF{id} {{ No }}");
-            decl.AppendLine(kind switch
-            {
-                "record-struct" => $"public readonly partial record struct D{id} : IValue<{w}>{mark} {{{markMember} }}",
-                "sealed-record-class" => $"public sealed partial record D{id} : {baseList}IValue<{w}>{mark} {{{markMember} }}",
-                "validated-struct" => $"public readonly partial record struct D{id} : IValidatedValue<D{id}, {w}, DF{id}>{mark} {{ public static Result<D{id}, DF{id}> Create({w} value) => Result.Error(DF{id}.No);{markMember} }}",
-                "validated-class" => $"public sealed partial record D{id} : {baseList}IValidatedValue<D{id}, {w}, DF{id}>{mark} {{ public static Result<D{id}, DF{id}> Create({w} value) => Result.Error(DF{id}.No);{markMember} }}",
-                _ => throw new ArgumentException(kind),
-            });
-        }
-        // shape.refused-kind: refused by the generators, an ordinary declaration to the compiler. The two kinds that are not (a closed
-        // set named as a generated member, CS0535; a hand-written operator ==, CS0111) are excluded in claims.json, and a row the
-        // covering array fills with one runs over object instead.
-        var refused = Read("shape.refused-kind");
-        if (refused is "closed-set-named-as-generated-member (CMTK1021)" or "equality-operator (CMTK1011)")
-        {
-            substituted.Add(("shape.refused-kind", "over-object (CMTK1005)", "it does not compile without the generators (excluded pair)"));
-            refused = "over-object (CMTK1005)";
-        }
-        var rName = refused == "named-as-generated-member (CMTK1005)" ? Refusals.ValueObjectNames[r.Index % Refusals.ValueObjectNames.Length] : $"R{id}";
-        decl.AppendLine(refused switch
-        {
-            "unsealed-record-class (CMTK1006)" => $"public partial record R{id} : IValue<string>;",
-            "over-value-object (CMTK1005)" => $"public readonly partial record struct RIn{id} : IValue<int>;\npublic sealed partial record R{id} : IValue<RIn{id}>;",
-            "generic-wrapped (CMTK1005)" => $"public readonly partial record struct R{id} : IValue<List<int>>;",
-            "abstract (CMTK1005)" => $"public abstract partial record R{id} : IValue<string>;",
-            "over-object (CMTK1005)" => $"public sealed partial record R{id} : IValue<object>;",
-            "over-System.Enum (CMTK1005)" => $"public readonly partial record struct R{id} : IValue<System.Enum>;",
-            "named-as-generated-member (CMTK1005)" => $"public readonly partial record struct {rName} : IValue<int>;",
-            _ => throw new ArgumentException(refused),
-        });
-
-        var containing = Read("shape.containing"); var position = Read("shape.position");
-        var dFacts = OfKind(kind);
-        if (!pair)
-        {
-            var arguments = new List<(string Type, bool Breaks)> { ($"D{id}", !Accepts(attribute, dFacts)), (rName, !Accepts(attribute, OfRefused(refused))) };
-            if (depth > 0) arguments.Add(($"DB{id}_{depth}", !Accepts(attribute, new Facts(Class: true))));
-            if (explicitMember) arguments.Add(($"IMark{id}", !Accepts(attribute, new Facts(Interface: true))));
-            if (wrapped is not null) arguments.Add((Src.Wrapped(wrapped, id), !Accepts(attribute, OfWrapped(wrapped))));
-            foreach (var (type, breaks) in arguments)
-            {
-                var argument = "shape:" + type;
-                foreach (var name in CatalogueSites("call"))
-                    decl.AppendLine(uses.Call(Host(position, containing, $"C{id}_{uses.Next}", type, StatementsOf(name)), breaks, argument, name == Inferred));
-                if (atCall) continue;
-                foreach (var name in CatalogueSites(site))
-                    decl.AppendLine(uses.Site(Host(position, containing, $"C{id}_{uses.Next}", type, StatementsOf(name)), breaks, argument));
-                if (site == "collection-expression")
-                    decl.AppendLine(uses.Site(Host(position, containing, $"C{id}_{uses.Next}", type, "Built<{A}> built = {|#0:[a]|};"), breaks, argument));
-            }
-        }
-        else
-        {
-            var other = depth > 0 ? $"DB{id}_{depth}" : explicitMember ? $"IMark{id}" : wrapped is not null ? Src.Wrapped(wrapped, id) : "int";
-            var related = depth > 0 || explicitMember;   // a base and a derived type, an interface and an implementer
-            var cases = new List<(string F, string S, bool Breaks)>
-            {
-                ($"D{id}", $"D{id}", true),                                   // one type twice
-                (other, $"D{id}", related && attribute == "Unrelated"),
-                (rName, rName, true),
-                (rName, $"D{id}", false),
-            };
-            foreach (var (f, s, breaks) in cases)
-            {
-                var argument = $"shape:{f},{s}";
-                var calls = PairStatements("call");
-                for (var i = 0; i < calls.Length; i++)
-                    decl.AppendLine(uses.Call(PairHost(position, containing, $"C{id}_{uses.Next}", f, s, calls[i]), breaks, argument, inferred: i == 1));
-                if (atCall) continue;
-                foreach (var statement in PairStatements(site))
-                    decl.AppendLine(uses.Site(PairHost(position, containing, $"C{id}_{uses.Next}", f, s, statement), breaks, argument));
-            }
-        }
-
-        var shapes = Src.Usings + Src.WrappedDeclarations(id) + Src.AtSite(Read("shape.site"), id, decl.ToString());
-        var subjects = TypeArgumentSites.Subjects.Replace("{C}", pair ? "" : constraint);
-        var run = await Rz.Analyze("CMTK0010",
-        [
-            ("Candidates.cs", TypeArgumentKinds.Candidates), ("Subjects.cs", subjects),
-            ("Builders.cs", Src.Usings + Builders.Replace("{C}", pair ? "" : constraint) + PairSubjects.Replace("{C}", pair ? constraint : "")),
-            ("Core.cs", Src.Usings + uses.Core), ("Shapes.cs", shapes),
-        ]);
-        if (run.Errors.Count > 0) { r.Outcome("harness-error", "the probe's source does not compile: " + run.ErrorText()); return null; }
-        if (run.AnalyzerFailures.Count > 0) return "the analyzer failed: " + string.Join("; ", run.AnalyzerFailures.Select(f => f.GetMessage()));
-
-        void Ran(Probes.Shapes.Check c, bool withSite)
-        {
-            foreach (var axis in read) if (withSite || axis != "site") _ = c[axis];
-            foreach (var (axis, value, why) in substituted) c.Substituted(axis, value, why);
-        }
-
-        // The attribute's obligation, judged at the calls: each breaking argument reported once at its span, each meeting one silent, and
-        // nothing reported outside every use. Where the row's site is a call, that is every use of the row.
-        var page = pair ? "docs/type-constraints.md#two-parameters-apart" : "docs/type-constraints.md#the-kind-of-a-type-argument";
-        var kinds = r.Check(ObligationOf[attribute], Baseline.Docs(page), c =>
-        {
-            Ran(c, withSite: atCall);
-            var fail = Rz.Agree(run, uses.Expected, m => uses.Calls.Contains(m.Label), outside: true);
-            if (fail is null) c.Note(NoteKeys.Compared, $"{uses.Calls.Count} uses at a call, {uses.Calls.Count(uses.Expected.Contains)} expected reported");
-            return fail;
-        });
-        if (atCall) return kinds;
-
-        // The methods the compiler calls, judged against each argument's own call with inferred arguments in the same compilation: a use
-        // at the row's site is reported once at its span where that call is reported, and is silent where it is silent.
-        var methods = r.Check("methods-the-compiler-calls", Baseline.Docs("docs/type-constraints.md#constrain-a-type-parameter"), c =>
-        {
-            Ran(c, withSite: true);
-            var marks = run.Marks.ToDictionary(m => m.Label);
-            var expected = uses.AtSite.Where(u => Rz.At(run, marks[uses.InferredCall[u.Value]]).Count > 0).Select(u => u.Key).ToHashSet();
-            var fail = Rz.Agree(run, expected, m => uses.AtSite.ContainsKey(m.Label), outside: false);
-            if (fail is null) c.Note(NoteKeys.Compared, $"{uses.AtSite.Count} uses at a {site}, {expected.Count} reported as their inferred calls are");
-            return fail;
-        });
-        return kinds ?? methods;
-    }
-    /// <summary>
-    /// A member of shape.containing at shape.position holding <paramref name="statements"/> in the catalogue's frame: a, holder,
-    /// bag, crate and o of the argument {A}. A struct is given no instance initializer and no lambda over this.
-    /// </summary>
-    static string Host(string position, string containing, string name, string argument, string statements)
-    {
-        statements = statements.Replace("{A}", argument);
-        var type = $"GoD<{argument}>";
-        string Lambda(string head = "(a, holder, bag, crate, o)", string prelude = "") => $"async {head} => {{ {prelude}{statements} await Task.CompletedTask; }}";
-        return Member(position, containing, name, type,
-            $"public static async Task Root({argument} a, Holder? holder, Bag<{argument}> bag, Crate<{argument}> crate, object o) {{ {statements} await Task.CompletedTask; }}",
-            Lambda(), $"Bag<{argument}> bag0", Lambda("(a, holder, bagX, crate, o)", "var bag = b0; "));
-    }
-
-    /// <summary>The pair sites' statements, with x, y and bag2 of the two arguments, as <see cref="Host"/> holds them.</summary>
-    static string PairHost(string position, string containing, string name, string first, string second, string statement)
-    {
-        var statements = statement.Replace("{F}", first).Replace("{S}", second);
-        var type = $"GoP<{first}, {second}>";
-        string Lambda(string head = "(x, y, bag2)", string prelude = "") => $"async {head} => {{ {prelude}{statements} await Task.CompletedTask; }}";
-        return Member(position, containing, name, type,
-            $"public static async Task Root({first} x, {second} y, Bag2<{first}, {second}> bag2) {{ {statements} await Task.CompletedTask; }}",
-            Lambda(), $"Bag2<{first}, {second}> bag0", Lambda("(x, y, bag2X)", "var bag2 = b0; "));
-    }
-
-    static string Member(string position, string containing, string name, string type, string root, string lambda, string primaryParameter, string primaryLambda)
-    {
-        var self = Src.ContainerSelf(containing, name);
-        if (position == "record-ctor-parameter")
-        {
-            var record = containing is "record-class" or "record-struct";
-            return Src.ContainerHead(containing, name, $"({primaryParameter})") +
-                $"\n{{\n    public {type} G {{ get {{ var b0 = {primaryParameter.Split(' ')[^1]}; return {primaryLambda}; }} }}\n}}";
-        }
-        var member = position switch
-        {
-            "root" => root,
-            "property" => $"public static {type} P => {lambda};",
-            "nullable-property" => $"public static {type}? N => {lambda};",
-            "field" => $"public static readonly {type} F = {lambda};",
-            "list-element" => $"public static readonly List<{type}> L = [{lambda}];",
-            "array-element" => $"public static readonly {type}[] A = [{lambda}];",
-            "immutable-array-element" => $"public static readonly ImmutableArray<{type}> I = [{lambda}];",
-            "read-only-list-element" => $"public static readonly IReadOnlyList<{type}> R = [{lambda}];",
-            "dictionary-key" => $"public static readonly Dictionary<{type}, int> D = new() {{ [{lambda}] = 1 }};",
-            "dictionary-value" => $"public static readonly Dictionary<int, {type}> D = new() {{ [1] = {lambda} }};",
-            "required-init" => $"public required {type} K {{ get; init; }}\n    public static {self} Make() => new() {{ K = {lambda} }};",
-            "in-patch" => $"public static Patch<{type}> Pa => Patch.Value<{type}>({lambda});",
-            "polymorphic-derived-property" => $"public abstract class PB {{ public abstract {type} K {{ get; }} }}\n    public sealed class PD : PB {{ public override {type} K => {lambda}; }}",
-            _ => throw new ArgumentException("shape.position " + position),
-        };
-        return $"{Src.ContainerHead(containing, name)}\n{{\n    {member}\n}}";
-    }
-}
diff --git a/tools/probe/corpus/probes/C20ShouldHoldProbe.cs b/tools/probe/corpus/probes/C20ShouldHoldProbe.cs
deleted file mode 100644
index f84da364..00000000
--- a/tools/probe/corpus/probes/C20ShouldHoldProbe.cs
+++ /dev/null
@@ -1,182 +0,0 @@
-// Claim C20-testing-shouldhold (src/CodoMetis.TypeKit.Testing/README.md): "ShouldHold(reason) fails unless the fault holds that reason, whichever of its types the reason belongs to. It hands back the Fault<TFault> with its detail and rule intact."
-// "An uninitialized result fails every assertion." "A failure says what the outcome was" and "never prints a value".
-// Oracle: claim. Held reason (with a detail and a rule) -> returns the Fault<TW> with Reason/Detail/Rule intact; wrong reason (same type other value, or a fault of another type) -> TypeKitAssertionException naming the fault it holds; default composed fault -> TypeKitAssertionException "uninitialized".
-#pragma warning disable xUnit1051, CMTK0014, CMTK0010 // CMTK0010: TW is a run-time-chosen type, distinct from the fixed Alt enums by construction
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.Testing;
-using Probes.Shapes;
-namespace Probes;
-public enum C20Alt1 { A, B }
-public enum C20Alt2 { A, B }
-public enum C20RuleKind { Strict }
-public enum C20WEnum { One, Two }
-[Flags] public enum C20WFlags { None = 0, X = 1, Y = 2 }
-public sealed record C20Own(int N);
-public sealed class C20ShouldHoldProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("C20ShouldHoldProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    static Task<string?> Check(Row r) => r["shape.wrapped"] switch
-    {
-        "string" => Go(r, "a", "b"), "Guid" => Go(r, Guid.Empty, Guid.NewGuid()), "int" => Go(r, 1, 2), "long" => Go(r, 1L, 2L), "byte" => Go<byte>(r, 1, 2),
-        "ulong" => Go<ulong>(r, 1, 2), "decimal" => Go(r, 1.5m, 2.5m), "double" => Go(r, 1.5, 2.5), "bool" => Go(r, true, false), "char" => Go(r, 'a', 'b'),
-        "DateTime" => Go(r, new DateTime(2026, 1, 1), new DateTime(2026, 1, 2)), "DateTimeOffset" => Go(r, new DateTimeOffset(2026, 1, 1, 0, 0, 0, TimeSpan.Zero), new DateTimeOffset(2026, 1, 2, 0, 0, 0, TimeSpan.Zero)),
-        "DateOnly" => Go(r, new DateOnly(2026, 1, 1), new DateOnly(2026, 1, 2)), "TimeOnly" => Go(r, new TimeOnly(1, 0), new TimeOnly(2, 0)), "TimeSpan" => Go(r, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2)),
-        "enum" => Go(r, C20WEnum.One, C20WEnum.Two), "flags-enum" => Go(r, C20WFlags.X, C20WFlags.Y), "Uri" => Go(r, new Uri("http://a/"), new Uri("http://b/")),
-        "NodaTime.Instant" => Go(r, NodaTime.Instant.FromUnixTimeSeconds(1), NodaTime.Instant.FromUnixTimeSeconds(2)), "own-record-class" => Go(r, new C20Own(1), new C20Own(2)),
-        var w => throw new ArgumentException(w),
-    };
-
-    static async Task<string?> Go<TW>(Row r, TW a, TW b) where TW : notnull
-    {
-        var arity = r["arity"]; var first = r["set"] == "first"; var wrong = r["wrong-reason"] == "yes";
-        if (arity == "2")
-            return first ? await Run<TW, Fault<TW, C20Alt1>>(r, a, b, x => Fault<TW, C20Alt1>.Of(Held(x)), f => f.ShouldHold(a), f => f.ShouldHold(b), Fault<TW, C20Alt1>.Of(C20Alt1.A), f => f.ShouldHold(C20Alt1.A))
-                          : await Run<TW, Fault<C20Alt1, TW>>(r, a, b, x => Fault<C20Alt1, TW>.Of(Held(x)), f => f.ShouldHold(a), f => f.ShouldHold(b), Fault<C20Alt1, TW>.Of(C20Alt1.A), f => f.ShouldHold(C20Alt1.A));
-        return first ? await Run<TW, Fault<TW, C20Alt1, C20Alt2>>(r, a, b, x => Fault<TW, C20Alt1, C20Alt2>.Of(Held(x)), f => f.ShouldHold(a), f => f.ShouldHold(b), Fault<TW, C20Alt1, C20Alt2>.Of(C20Alt2.A), f => f.ShouldHold(C20Alt2.A))
-                      : await Run<TW, Fault<C20Alt1, C20Alt2, TW>>(r, a, b, x => Fault<C20Alt1, C20Alt2, TW>.Of(Held(x)), f => f.ShouldHold(a), f => f.ShouldHold(b), Fault<C20Alt1, C20Alt2, TW>.Of(C20Alt1.A), f => f.ShouldHold(C20Alt1.A));
-    }
-
-    const string Detail = "probe-detail";
-
-    /// <summary>The fault a row holds: its reason with a detail and a rule, which ShouldHold hands back intact.</summary>
-    static Fault<TW> Held<TW>(TW reason) where TW : notnull => Fault.Of(reason, Detail).WithRule(C20RuleKind.Strict);
-
-    static async Task<string?> Run<TW, TC>(Row r, TW a, TW b, Func<TW, TC> make, Func<TC, Fault<TW>> holdA, Func<TC, Fault<TW>> holdB, TC foreign, Func<TC, object> holdForeignSet)
-        where TW : notnull where TC : struct
-    {
-        var wrong = r["wrong-reason"] == "yes";
-        // the held fault: with wrong-reason=yes the carrier holds a fault of ANOTHER type (foreign) and the test asks for TW's reason a
-        TC held = wrong ? foreign : make(a);
-        var op = r["or.operation"]; var shape = r["or.shape"];
-        TC? got = await Carry(r, held, op, shape);
-        if (got is null) { r.Outcome("harness-error", $"the carrier gave no fault back ({shape}, {op})"); return null; }
-        var composed = got.Value;
-        Fault<TW>? hand = null; Exception? thrown = null;
-        try { hand = holdA(composed); } catch (Exception ex) { thrown = ex; }
-        var docs = Baseline.Docs("src/CodoMetis.TypeKit.Testing/README.md");
-        if (op == "default-instance")
-            return r.Check("uninitialized-fails", docs, c =>
-            {
-                if (thrown is not TypeKitAssertionException u || !u.Message.Contains("uninitialized")) return $"default composed fault: ShouldHold gave {thrown?.GetType().Name ?? "no exception"} {thrown?.Message}; expected TypeKitAssertionException 'uninitialized'";
-                c.Note(NoteKeys.Compared, "uninitialized: TypeKitAssertionException");
-                return null;
-            });
-        if (wrong)
-        {
-            // the carrier holds a fault of another type, and the test asks for TW's reason a
-            var w1 = r.Check("fails-unless-it-holds-that-reason", docs, c =>
-            {
-                if (thrown is not TypeKitAssertionException) return $"ShouldHold({a}) on a fault of another type gave {(thrown is null ? "a result: " + hand : thrown.GetType().Name)}; expected TypeKitAssertionException";
-                // same type other value
-                try { holdB(composed); return "ShouldHold(other value) passed on a fault of another type"; } catch (TypeKitAssertionException) { }
-                c.Note(NoteKeys.Compared, "fails for a reason it does not hold");
-                return null;
-            });
-            var w2 = r.Check("a-failure-says-the-outcome", docs, c =>
-            {
-                if (thrown is not TypeKitAssertionException e) return c.Inconclusive("no assertion failed to say anything: judged by fails-unless-it-holds-that-reason");
-                if (!e.Message.Contains("Expected the fault") || e.Message.Contains("UNEXPECTED")) return "message: " + e.Message;
-                // the outcome: the fault the composed fault holds, as ShouldHold of its own reason hands it back
-                string outcome;
-                try { outcome = holdForeignSet(composed).ToString()!; } catch (Exception ex) { return c.Inconclusive("the held fault is not handed back by its own reason, judged by whichever-of-its-types: " + ex.GetType().Name); }
-                if (!e.Message.Contains(outcome)) return $"the failure does not say what the outcome was ({outcome}): {e.Message}";
-                c.Note(NoteKeys.Compared, "the failure names " + outcome);
-                return null;
-            });
-            var w3 = r.Check("whichever-of-its-types", docs, c =>
-            {
-                // the held reason itself is still reachable by its own type
-                try { holdForeignSet(composed); } catch (Exception ex) { return "ShouldHold(own reason) threw " + ex.GetType().Name + ": " + ex.Message; }
-                c.Note(NoteKeys.Compared, "the held fault's own reason, whichever of its types");
-                return null;
-            });
-            return w1 ?? w2 ?? w3;
-        }
-        var f1 = r.Check("whichever-of-its-types", docs, c =>
-        {
-            if (thrown is not null) return $"ShouldHold({a}) on a fault holding it threw {thrown.GetType().Name}: {thrown.Message}";
-            if (!EqualityComparer<TW>.Default.Equals(hand!.Value.Reason, a)) return $"returned fault has reason {hand.Value.Reason}, expected {a}";
-            c.Note(NoteKeys.Compared, $"the reason of the {r["set"]} of {r["arity"]} types");
-            return null;
-        });
-        var f2 = r.Check("hands-back-detail-and-rule", docs, c =>
-        {
-            if (thrown is not null || hand is null) return c.Inconclusive("nothing handed back: judged by whichever-of-its-types");
-            var want = Held(a);
-            if (hand.Value.Detail != want.Detail || hand.Value.Rule != want.Rule) return $"returned fault has detail '{hand.Value.Detail}' and rule '{hand.Value.Rule}', expected '{want.Detail}' and '{want.Rule}'";
-            c.Note(NoteKeys.Compared, "detail and rule intact");
-            return null;
-        });
-        var f3 = r.Check("fails-unless-it-holds-that-reason", docs, c =>
-        {
-            try { holdB(composed); return "ShouldHold(other value of the same type) passed"; } catch (TypeKitAssertionException) { }
-            c.Note(NoteKeys.Compared, "fails for another value of the reason's type");
-            return null;
-        });
-        return f1 ?? f2 ?? f3;
-    }
-
-    // Carries the fault through the carrier and the operation, then extracts it with the Testing assertions. null = the combination has no such operation (noted inapplicable).
-    static async Task<TC?> Carry<TC>(Row r, TC fault, string op, string shape) where TC : struct
-    {
-        if (op == "default-instance") return default(TC);
-        // Operations the carrier has no member for run as Match, so the carrier's other pairs earn credit: Option has no Result.Catch (Catch returns a Result); Result<E> has no Select/SelectMany (query syntax) and no FirstOrNone (Option-only).
-        if ((shape == "Option" && op == "Result.Catch") || (shape == "Result-E" && op is "query-syntax" or "FirstOrNone"))
-        {
-            // One of the two pairs of the row cannot be earned; alternate which axis runs at a value that exists, so the carrier's and the operation's pairs both get credit across rows.
-            if (r.Index % 2 == 0) { r.Substituted("or.operation", "Match", $"{op} has no member on {shape}"); op = "Match"; }
-            else { r.Substituted("or.shape", "Result-T-E", $"{op} has no member on {shape}"); shape = "Result-T-E"; }
-        }
-        Result<int, TC> res = Result.Error(fault);
-        switch (shape)
-        {
-            case "Result-T-E" or "Task-of-Result" or "ValueTask-of-Result":
-                switch (op)
-                {
-                    case "Match": res = res.Match<Result<int, TC>>(v => v, e => Result.Error(e)); break;
-                    case "Bind-Map-chain": res = Result<int, TC>.Success(1).Bind(_ => res).Map(x => x + 1); break;
-                    case "query-syntax": res = from x in res select x + 1; break;
-                    case "Sequence-Transpose": { var seq = new[] { res }.Sequence(); var e = seq.ShouldBeError(); res = Result.Error(e); break; }
-                    case "Result.Catch": res = Result.Catch<int>((Func<int>)(() => throw new InvalidOperationException())).MapError(_ => fault); break;
-                    case "FirstOrNone": { var o = new[] { fault }.FirstOrNone(); res = Result.Error(o.ShouldBeSome()); break; }
-                    case "after-await-elsewhere": await Task.Yield(); res = await Task.Run(() => res).ConfigureAwait(false); break;
-                    default: throw new ArgumentException(op);
-                }
-                if (shape == "Task-of-Result") return await Task.FromResult(res).ConfigureAwait(false) is var t ? t.ShouldBeError() : null;
-                if (shape == "ValueTask-of-Result") return (await new ValueTask<Result<int, TC>>(res)).ShouldBeError();
-                return res.ShouldBeError();
-            case "Result-E":
-            {
-                Result<TC> re = Result.Error(fault);
-                switch (op)
-                {
-                    case "Match": re = re.Match<Result<TC>>(() => Result<TC>.Success(), e => Result.Error(e)); break;
-                    case "Bind-Map-chain": re = Result<TC>.Success().Bind(() => re); break;
-                    case "Sequence-Transpose": re = new[] { re }.Sequence(); break;
-                    case "Result.Catch": re = Result.Catch((Action)(() => throw new InvalidOperationException())).MapError(_ => fault); break;
-                    case "after-await-elsewhere": await Task.Yield(); re = await Task.Run(() => re).ConfigureAwait(false); break;
-                    default: throw new ArgumentException(op + " on Result-E: the row's operation is substituted above where the carrier has none");
-                }
-                return re.ShouldBeError();
-            }
-            default: // Option: the fault as the content of a Some
-            {
-                var opt = Option.Some(fault);
-                switch (op)
-                {
-                    case "Match": opt = opt.Match(v => Option.Some(v), () => Option.None<TC>()); break;
-                    case "Bind-Map-chain": opt = Option.Some(1).SelectMany(_ => opt); break;
-                    case "query-syntax": opt = from x in opt select x; break;
-                    case "FirstOrNone": opt = new[] { fault }.FirstOrNone(); break;
-                    case "Sequence-Transpose": { var back = Option.Some<Result<int, TC>>(Result.Error(fault)).Transpose().ShouldBeError(); opt = Option.Some(back); break; }
-                    case "after-await-elsewhere": await Task.Yield(); opt = await Task.Run(() => opt).ConfigureAwait(false); break;
-                    default: throw new ArgumentException(op + " on Option: the row's operation is substituted above where the carrier has none");
-                }
-                return opt.ShouldBeSome();
-            }
-        }
-    }
-}
diff --git a/tools/probe/corpus/probes/C21OpenapiSchemaParityProbe.cs b/tools/probe/corpus/probes/C21OpenapiSchemaParityProbe.cs
deleted file mode 100644
index 9a3f3e57..00000000
--- a/tools/probe/corpus/probes/C21OpenapiSchemaParityProbe.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Claim C21-openapi-schema-parity (README.md#what-you-get), surfaces http, json, family http.
-// Obligations (claims.json), each a check of its own (Row.Check) in the rows its axes select, and each with a seed of its own in the
-// registry entry (decision 104); the-underlying-types-schema is checked where no other obligation's axes apply:
-//   the-underlying-types-schema: "The JSON, the database column and the OpenAPI schema are the same as the underlying type's."
-//   nullable-admits-null-as-the-wrapped-does (http.nullability=nullable): "Its OpenAPI schema is the one ASP.NET Core publishes for the underlying type."
-//   container-elements (a list's, an array's, a read-only list's, an immutable array's element, a dictionary's value): the same sentence.
-//   dictionary-key (shape.position=dictionary-key): the same sentence.
-//   every-document-version (openapi.OpenApiVersion OpenApi2_0, OpenApi3_0; the default is 3.1): the same sentence.
-// Oracle: differential (HttpBaseline.Schema, the schema half BaseProbe used to run). On the shared host under the row's options, every
-// operation that takes or returns the row's shape with the value object (the minimal schema endpoint, the minimal and the MVC binding
-// endpoint of the row's http.binding) has the parameters, request body and 200 response of its twin with the wrapped type, every
-// reference resolved, so a component compares by its content. Only the schemas are compared, never whether a parameter is required;
-// a class value object is compared with the wrapped type's Nullable<T>, and where nullability is spelled two ways the markers go
-// (schema:* notes). Not promised: a closed set (a string enum), excluded from the rows; and a converter of the application's own for
-// the value object or the wrapped type, declared inapplicable on every obligation (claims.json), so no row is generated with one.
-// Expected: no failure for any row; a document ASP.NET alone refuses the same way has nothing to compare. A difference a not-promised entry
-// names ends its check as that citation (Cite.NotPromised), and a nullable class value object without a nullable twin as inconclusive.
-using Probes.Shapes;
-namespace Probes;
-public sealed class C21OpenapiSchemaParityProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("C21OpenapiSchemaParityProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    static readonly string[] Containers = ["list-element", "array-element", "immutable-array-element", "read-only-list-element", "dictionary-value"];
-
-    /// <summary>The obligations whose axes the row has, each checked by the same comparison against the wrapped twin.</summary>
-    static IEnumerable<string> Obligations(Row r)
-    {
-        var any = false;
-        if (r.Is("http.nullability", "nullable")) { any = true; yield return "nullable-admits-null-as-the-wrapped-does"; }
-        if (Containers.Contains(r["shape.position"])) { any = true; yield return "container-elements"; }
-        if (r.Is("shape.position", "dictionary-key")) { any = true; yield return "dictionary-key"; }
-        if (r["openapi.OpenApiVersion"] is "OpenApi2_0" or "OpenApi3_0") { any = true; yield return "every-document-version"; }
-        if (!any) yield return "the-underlying-types-schema";
-    }
-
-    /// <summary>Every obligation the row selects is checked, on one host, so a seed is seen by its own obligation's check whatever the others find.</summary>
-    static Task<string?> Check(Row r) => HttpBaseline.Schema(r, Registry.Of(r), Obligations(r).ToList());
-}
diff --git a/tools/probe/corpus/probes/C22GeneratorRefusalsProbe.cs b/tools/probe/corpus/probes/C22GeneratorRefusalsProbe.cs
deleted file mode 100644
index 749b1cfe..00000000
--- a/tools/probe/corpus/probes/C22GeneratorRefusalsProbe.cs
+++ /dev/null
@@ -1,103 +0,0 @@
-// Claim C22-generator-refusals (src/CodoMetis.TypeKit.Generators/README.md#build-errors), surfaces generation, analyzers, family build.
-// Obligations (claims.json), each with a check below and a seed of its own in the registry entry (decision 104):
-//   no-type-half-generated: "A declaration that can't be generated fails the build, so no type is left half-generated."
-//   every-error-links-the-table: "Every error ends with a link to this table."
-//   unsealed-record-class: "A record class not declared `sealed`."
-//   over-value-object: "or a value object (itself included). Wrap what the other value object wraps instead."
-//   generic-wrapped: "A generic underlying type, a tuple included, fails the build (CMTK1005)."
-//   abstract: "An abstract type with a value-object marker. It would get no member, and a value held as it, of a type derived from it, would have no `Value` and be written as `{}`."
-//   over-object: "or wrapping `object`, `System.Enum`, an array, a pointer, a nullable type, a generic type (a tuple included) or a value object (itself included)."
-//   over-system-enum: "or wrapping `object`, `System.Enum`, an array, a pointer, a nullable type, a generic type (a tuple included) or a value object (itself included)."
-//   named-as-generated-member: "named `Value` or as another member the generators add (`From`, `TryFrom`, `FromKnownGood`, `Revalidate`, `Parse`, `TryParse`, `TryFormat`, `MinValue`, `MaxValue`, `CompareTo`)"
-//   closed-set-named-as-generated-member: "a set itself named as one of them (a member can't have the name of its type)"
-//   equality-operator: "So a hand-written `Equals(TSelf)`, `GetHashCode()`, `IEquatable<TSelf>.Equals`, or `operator ==` or `!=` between two of the type, fails the build (CMTK1011)."
-// Oracle: the refusal (Baseline.Refusal). Each row's file of a consumer build (harness/BuildRefusals.cs: the SDK build of a throwaway
-// project in a child process, as C18 and BuildOutcomeTests build, since Metalama runs only there) declares the row's shape.refused-kind as
-// a value object or a closed set of shape.kind at shape.site, over shape.inheritance and shape.wrapped, and beside it a control: the same
-// declaration without what is refused. Three consumers, since a compiler error in one file hid the generators' errors in the others
-// (e4b751c): the value objects, whose files hold no compiler error; the closed sets, whose refusal leaves IClosedSet's members
-// unimplemented (CS0535, as BuildOutcomeTests allows); and the equality operators, which C# itself reports as CS0111. Per row:
-//   the refusal's own obligation: an error of the README's id that names the type, and beside it no Metalama error (an aspect that
-//   failed, or generated code that does not compile) and no compiler error but the documented one;
-//   no-type-half-generated: the build failed, the type's file reports an error, and in Metalama's transformed source the type is as it
-//   was written: no base type, no member and no {Name}Extensions companion added;
-//   every-error-links-the-table: every CMTK1xxx error of the file ends with ". See <the README's #build-errors>", and the README has
-//   the heading.
-// A refused kind the harness does not declare, one the README's table no longer lists, and a control the generators refuse or do not
-// generate are harness errors: the row would show nothing about a refusal the README states.
-using Probes.Build;
-using Probes.Shapes;
-namespace Probes;
-public sealed class C22GeneratorRefusalsProbe
-{
-    const string RowsFile = "C22GeneratorRefusalsProbe"; // the probe's own rows
-
-    public static TheoryData<string, int> Data() => Rows.Data(RowsFile);
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    static Task<RefusalOutcome> Built(string group) => Refusals.Build($"{RowsFile}/{group}", () =>
-        Rows.Load(RowsFile).Select(Refusals.Declare).Where(d => d.Refusal.Group == group).ToDictionary(d => d.File, d => d.Source));
-
-    static async Task<string?> Check(Row r)
-    {
-        var d = Refusals.Declare(r);
-        var build = await Built(d.Refusal.Group);
-        var mine = build.In(d.File).ToList();
-
-        // What would make the row show nothing: no transformed source, a compiler error elsewhere that hides this file's, a control
-        // that is refused or not generated.
-        if (build.Transformed.Count == 0)
-        { r.Outcome("harness-error", $"the consumer wrote no transformed source (exit {build.ExitCode}): " + Errors(build.Diagnostics.Where(x => x.Severity == "error").Take(3))); return null; }
-        var hiding = build.Diagnostics.Where(x => x.Severity == "error" && x.Id.StartsWith("CS", StringComparison.Ordinal)
-                                                 && !d.Refusal.Companions.Contains(x.Id) && Path.GetFileName(x.File) != d.File).ToList();
-        if (hiding.Count > 0)
-        { r.Outcome("harness-error", "a compiler error in another file hides the generators' errors in this one (e4b751c): " + Errors(hiding.Take(3))); return null; }
-        var control = d.Display[..^d.Name.Length] + d.Control;
-        if (mine.Where(x => x.Severity == "error" && x.Message.Contains($"'{control}'", StringComparison.Ordinal)).ToList() is { Count: > 0 } refusedControl)
-        { r.Outcome("harness-error", $"the control {control} is refused, so the row shows nothing about {d.Refusal.Kind}: " + Errors(refusedControl)); return null; }
-        if (Refusals.Added(build, d, d.Control) is null)
-        { r.Outcome("harness-error", $"the control {control} is not generated, so the row shows nothing about {d.Refusal.Kind}"); return null; }
-
-        // Every check runs, so a seed that breaks one obligation is seen by its own check whatever the others find.
-        var named = r.Check(d.Refusal.Obligation, Baseline.Refusal, c => RefusedByName(c, d, mine));
-        var whole = r.Check("no-type-half-generated", Baseline.Refusal, c => NotHalfGenerated(c, d, build, mine));
-        var linked = r.Check("every-error-links-the-table", Baseline.Docs("src/CodoMetis.TypeKit.Generators/README.md#build-errors"), c => Linked(c, mine));
-        return named ?? whole ?? linked;
-    }
-
-    static string Errors(IEnumerable<BuildDiagnostic> errors) => string.Join("; ", errors.Select(e => $"{Path.GetFileName(e.File)} {e.Id} {e.Message}"));
-
-    static string? RefusedByName(Probes.Shapes.Check c, RefusedDeclaration d, List<BuildDiagnostic> mine)
-    {
-        var errors = mine.Where(e => e.Severity == "error").ToList();
-        if (!errors.Any(e => e.Id == d.Refusal.Id && e.Message.StartsWith($"'{d.Display}'", StringComparison.Ordinal)))
-            return $"{d.Display} ({d.Refusal.Kind}) is not refused with {d.Refusal.Id} by name: " + (errors.Count == 0 ? "its file reports no error" : Errors(errors));
-        if (errors.Where(e => e.Id.StartsWith("LAMA", StringComparison.Ordinal)).ToList() is { Count: > 0 } aspect)
-            return $"beside {d.Refusal.Id}, an aspect failed on the declaration or generated code that does not compile: " + Errors(aspect);
-        if (errors.Where(e => e.Id.StartsWith("CS", StringComparison.Ordinal) && !d.Refusal.Companions.Contains(e.Id)).ToList() is { Count: > 0 } compiler)
-            return $"beside {d.Refusal.Id}, compiler errors the README does not name: " + Errors(compiler);
-        c.Note(NoteKeys.Compared, $"{d.Refusal.Id} names {d.Display}");
-        return null;
-    }
-
-    static string? NotHalfGenerated(Probes.Shapes.Check c, RefusedDeclaration d, RefusalOutcome build, List<BuildDiagnostic> mine)
-    {
-        if (build.ExitCode == 0) return $"the consumer with {d.Display} ({d.Refusal.Kind}) in it built";
-        if (!mine.Any(e => e.Severity == "error")) return $"{d.Display} ({d.Refusal.Kind}) compiles: its file reports no error";
-        if (Refusals.Added(build, d, d.Name) is { } added) return $"{d.Display} ({d.Refusal.Kind}) is half-generated: the generators added {added}";
-        c.Note(NoteKeys.Compared, $"the build failed and {d.Display} is as written");
-        return null;
-    }
-
-    static string? Linked(Probes.Shapes.Check c, List<BuildDiagnostic> mine)
-    {
-        if (!Refusals.ReadmeHasBuildErrorsHeading()) return "the Generators README has no '## Build errors' heading, which the errors link to";
-        var generator = mine.Where(e => e.Severity == "error" && e.Id.StartsWith("CMTK1", StringComparison.Ordinal)).ToList();
-        if (generator.Count == 0) return c.Inconclusive("no generator error in the row's file to read");
-        if (generator.Where(e => !e.Message.EndsWith($". See {Refusals.TableLink}", StringComparison.Ordinal)).ToList() is { Count: > 0 } bare)
-            return "these errors do not end with the link to the Build errors table: " + Errors(bare);
-        c.Note(NoteKeys.Compared, $"{generator.Count} error(s) end with the link");
-        return null;
-    }
-}
diff --git a/tools/probe/corpus/probes/E01ColumnParityProbe.cs b/tools/probe/corpus/probes/E01ColumnParityProbe.cs
deleted file mode 100644
index c7720746..00000000
--- a/tools/probe/corpus/probes/E01ColumnParityProbe.cs
+++ /dev/null
@@ -1,93 +0,0 @@
-// Claim E01-column-parity (docs/ef-core.md#the-model): "Every property maps as a column of the underlying type, nullable where the property is. A facet you configure on it is kept: a precision, a length, a column type."
-// Oracle: differential. The EF model and the CREATE script of an entity declared with the value object (UseTypeKit) equal those of the same entity declared with the wrapped type (plain EF), in every mapping, shape and facet.
-// Obligations (claims.json), one check each where the row's axes select it, each against the wrapped twin (Baseline.Twin):
-//   column-type (ef.mapping property, key, owned, complex): "Every property maps as a column of the underlying type, nullable where the property is."
-//   nullable (ef.mapping nullable): "nullable where the property is"
-//   facet-kept (ef.facet HasMaxLength, HavePrecision, HasColumnType): "A facet you configure on it is kept: a precision, a length, a column type."
-// Expected: no failure for any row; where a side refuses the model, EfSides says how the check ends.
-using Microsoft.EntityFrameworkCore;
-using Probes.Ef;
-using Probes.Shapes;
-namespace Probes;
-public sealed class E01ColumnParityProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("E01ColumnParityProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        var e = Probes.Ef3.E4.At(r, r["shape.kind"], r["shape.wrapped"], r["shape.site"]);
-        var mapping = r["ef.mapping"];
-        var facet = r["ef.facet"];
-        // The facet as configured, on any wrapped type: EF keeps a length or a precision on a property of any type, and the
-        // wrapped twin shows what it keeps for that type.
-        var columnType = EfModel.ColumnTypes[e.Wrapped];
-        Action<Microsoft.EntityFrameworkCore.Metadata.IMutableProperty>? apply = facet switch
-        {
-            "HasMaxLength" => p => p.SetMaxLength(5),
-            "HavePrecision" => p => { p.SetPrecision(18); p.SetScale(2); },
-            "HasColumnType" => p => p.SetColumnType(columnType),
-            _ => null,
-        };
-        var integerKey = mapping == "key" && e.Wrapped is "int" or "long" or "ulong" && facet != "HasColumnType";
-        var voEntity = EfModel.Entity(mapping, e.Vo);
-        var plainEntity = EfModel.Entity(mapping, e.Plain);
-        string? voModel = null, voScript = null, plainModel = null, plainScript = null;
-        Exception? voEx = null, plainEx = null;
-        await using (var vo = new EfDb(EfModel.Configure(mapping, voEntity, apply, integerKey), typeKit: true))
-            try { voModel = EfModel.Describe(vo.Context); voScript = vo.Context.Database.GenerateCreateScript(); } catch (Exception ex) { voEx = ex; }
-        await using (var plain = new EfDb(EfModel.Configure(mapping, plainEntity, apply, false), typeKit: false))
-            try { plainModel = EfModel.Describe(plain.Context); plainScript = plain.Context.Database.GenerateCreateScript(); } catch (Exception ex) { plainEx = ex; }
-
-        // A key over char or Guid is never generated where EF generates the twin's (README#keys, below): the script's AUTOINCREMENT
-        // is that generation, compared apart by column-type, so neither check compares it in the script.
-        var ownKey = mapping == "key" && e.Wrapped is "char" or "Guid";
-        if (ownKey) { voScript = voScript?.Replace(" AUTOINCREMENT", ""); plainScript = plainScript?.Replace(" AUTOINCREMENT", ""); }
-
-        // The column the facet is configured on, as EfModel.Describe names it, and the fields the facet sets there.
-        var column = mapping switch { "key" => "t.Id: ", "complex" => "t.C.P: ", _ => "t.P: " };
-        string[] facetFields = facet switch { "HasMaxLength" => ["max"], "HavePrecision" => ["prec", "scale"], "HasColumnType" => ["type"], _ => [] };
-
-        // column-type and nullable: every column of the model and the script, as the wrapped twin's, with the facet's own fields
-        // left to facet-kept (and the script too, where the facet is the column type the script spells).
-        var mapped = r.Check(mapping == "nullable" ? "nullable" : "column-type", Baseline.Twin, c =>
-        {
-            if (EfSides.Threw(c, voEx, plainEx, "the model or the create script", out var refused)) return refused;
-            string vm = Mask(voModel!, column, facetFields), pm = Mask(plainModel!, column, facetFields), vs = voScript!, ps = plainScript!;
-            if (ownKey)
-            {
-                // README#keys: "A key over `char` is yours to assign. It's never generated, on any provider" and "A key over a `Guid` is yours to assign" (EF's own plain char and Guid keys are generated on add).
-                if (!voModel!.Contains("pk=True gen=Never")) return "a key over char or Guid is not ValueGeneratedNever: " + voModel;
-                vm = vm.Replace("gen=Never", "gen=*"); pm = pm.Replace("gen=OnAdd", "gen=*").Replace("gen=Never", "gen=*");
-                c.Note(NoteKeys.DocumentedCharGuidKeyNeverGeneratedChecked, "generation compared apart: not-promised char-key-not-generated, guid-key-not-generated");
-            }
-            if (vm != pm) return "model differs: " + EfModel.FirstDiff(vm, pm);
-            if (facet != "HasColumnType" && vs != ps) return "create script differs: " + EfModel.FirstDiff(vs, ps);
-            c.Note(NoteKeys.Compared, facet == "HasColumnType" ? "the model" : "the model and the create script");
-            return null;
-        });
-        if (facet == "none") return mapped;
-
-        // facet-kept: the facet's own fields of the configured column, and for a column type the script, as the wrapped twin keeps them.
-        var kept = r.Check("facet-kept", Baseline.Twin, c =>
-        {
-            if (EfSides.Threw(c, voEx, plainEx, "the model or the create script", out var refused)) return refused;
-            var vl = Line(voModel!, column); var pl = Line(plainModel!, column);
-            foreach (var f in facetFields)
-                if (Field(vl, f) != Field(pl, f)) return $"{facet} not kept: the value object's column has {f}={Field(vl, f)}, the wrapped type's {f}={Field(pl, f)} ({vl})";
-            if (facet == "HasColumnType" && voScript != plainScript) return "create script differs: " + EfModel.FirstDiff(voScript!, plainScript!);
-            c.Note(NoteKeys.Compared, string.Join(",", facetFields.Select(f => $"{f}={Field(pl, f)}")));
-            return null;
-        });
-        return mapped ?? kept;
-    }
-
-    /// <summary>The line EfModel.Describe writes for <paramref name="column"/>; a model without it is the harness's mistake.</summary>
-    static string Line(string model, string column) =>
-        model.Split('\n').FirstOrDefault(l => l.StartsWith(column, StringComparison.Ordinal)) ?? throw new InvalidOperationException($"no column {column.TrimEnd(' ', ':')} in the model: {model}");
-    static string Field(string line, string field) => System.Text.RegularExpressions.Regex.Match(line, $@"(?:^|\s){field}=(\S*)").Groups[1].Value;
-    /// <summary>The model with the given fields of <paramref name="column"/>'s line masked.</summary>
-    static string Mask(string model, string column, string[] fields) => string.Join("\n", model.Split('\n').Select(l =>
-        !l.StartsWith(column, StringComparison.Ordinal) ? l : fields.Aggregate(l, (x, f) => System.Text.RegularExpressions.Regex.Replace(x, $@"(^|\s){f}=\S*", $"$1{f}=*"))));
-}
diff --git a/tools/probe/corpus/probes/E02ValueTranslatesProbe.cs b/tools/probe/corpus/probes/E02ValueTranslatesProbe.cs
deleted file mode 100644
index 372ea708..00000000
--- a/tools/probe/corpus/probes/E02ValueTranslatesProbe.cs
+++ /dev/null
@@ -1,142 +0,0 @@
-// Claim E02-value-translates-to-column (src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries): ".Value, GetValue() and ValueOrNull() translate to the column itself" (column parity: same SQL as the query over the wrapped property).
-// Oracle: differential. For each query shape the SQL (ToQueryString) of the query over the value object's accessor equals the SQL of the same query over the wrapped-type property, and both return the same rows.
-// Obligations (claims.json), each against the wrapped twin (Baseline.Twin):
-//   value, get-value, value-or-null (by ef.accessor): "`.Value`, `GetValue()` and `ValueOrNull()` translate to the column itself.": the rows the query answers
-//   column-not-cast (every row): "A table's column is re-typed, not cast, so an index on it still serves the query.": the SQL
-// Expected: no failure for any row; where a side refuses the query, EfSides says how the check ends. Where SQLite cannot compare or
-// order the wrapped type, every obligation declares itself inapplicable (claims.json, fact KB-039). where-value-compare is >= as C# writes
-// it, over the underlying type for an enum; a string, a bool and a Uri have none, and claims.json excludes the pair.
-using System.Linq.Expressions;
-using System.Reflection;
-using Microsoft.EntityFrameworkCore;
-using Probes.Ef;
-using Probes.Shapes;
-namespace Probes;
-public sealed class E02ValueTranslatesProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("E02ValueTranslatesProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    static MethodInfo? Unwrap(Type vo, string name) =>
-        vo.GetMethods(BindingFlags.Public | BindingFlags.Static).FirstOrDefault(m => m.Name == name && m.GetParameters().Length == 1);
-
-    /// <summary>The type C# compares an enum (or a nullable enum) over: its underlying type, nullable where it is; null for any other type.</summary>
-    static Type? Underlying(Type t) => Nullable.GetUnderlyingType(t) is { IsEnum: true } e ? typeof(Nullable<>).MakeGenericType(Enum.GetUnderlyingType(e))
-                                      : t.IsEnum ? Enum.GetUnderlyingType(t) : null;
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        var e = Probes.Ef3.E4.At(r, r["shape.kind"], r["shape.wrapped"], r["shape.site"]);
-        var acc = r["ef.accessor"];
-        var q = r["ef.query"];
-        var nullable = acc == "ValueOrNull";
-        var mapping = nullable ? "nullable" : "property";
-        MethodInfo? unwrap = acc == "Value" ? null : e.Companion(acc);
-        if (acc != "Value" && unwrap is null) return $"no static {acc}(...) on {e.Vo}";
-        var voProp = nullable && e.Vo.IsValueType ? typeof(Nullable<>).MakeGenericType(e.Vo) : e.Vo;
-        var plProp = nullable && e.Plain.IsValueType ? typeof(Nullable<>).MakeGenericType(e.Plain) : e.Plain;
-        var voEntity = EfModel.Entity(mapping, e.Vo);
-        var plainEntity = EfModel.Entity(mapping, e.Plain);
-        // the type the accessor yields; the plain side is the property itself
-        Type accessType = acc == "Value" ? e.Vo.GetProperty("Value")!.PropertyType : unwrap!.ReturnType;
-        object constant = nullable && !e.Plain.IsValueType ? e.Valid() : e.Valid();
-
-        IQueryable Build(DbContext db, Type entity, bool vo)
-        {
-            var p = Expression.Parameter(entity, "e");
-            Expression prop = Expression.Property(p, "P");
-            Expression access = !vo ? prop : acc == "Value" ? Expression.Property(prop, e.Vo.GetProperty("Value")!) : Expression.Call(unwrap!, prop);
-            var at = access.Type;
-            var src = Q.SetOf(db, entity);
-            var box = Expression.Constant(Q.NewBox(at, constant));
-            Expression param = Expression.Field(box, "Value");
-            LambdaExpression Lam(Expression body) => Expression.Lambda(body, p);
-            switch (q)
-            {
-                case "where-equals": return Q.Call("Where", [entity], src, Lam(Expression.Equal(access, param)));
-                case "where-value-compare":
-                    BinaryExpression cmp;
-                    try { cmp = Expression.GreaterThanOrEqual(access, param); }
-                    // C# compares two values of an enum with >= over its underlying type, and an expression tree it compiles says so
-                    // with a conversion on each side; Expression.GreaterThanOrEqual defines no >= for the enum itself.
-                    catch (InvalidOperationException) when (Underlying(at) is { } u) { cmp = Expression.GreaterThanOrEqual(Expression.Convert(access, u), Expression.Convert(param, u)); }
-                    // string, bool and Uri have no >= in C# (excluded in claims.json): no row asks for one
-                    catch (InvalidOperationException) { r.Substituted("ef.query", "where-equals", "the wrapped type has no >= operator"); cmp = Expression.Equal(access, param); }
-                    return Q.Call("Where", [entity], src, Lam(cmp));
-                case "order-by": return Q.Call("OrderBy", [entity, at], src, Lam(access));
-                case "select": return Q.Call("Select", [entity, at], src, Lam(access));
-                case "contains":
-                    var list = Activator.CreateInstance(typeof(List<>).MakeGenericType(at))!;
-                    list.GetType().GetMethod("Add")!.Invoke(list, [constant]);
-                    var lbox = Expression.Constant(Q.NewBox(list.GetType(), list));
-                    var contains = typeof(Enumerable).GetMethods().First(m => m.Name == "Contains" && m.GetParameters().Length == 2).MakeGenericMethod(at);
-                    return Q.Call("Where", [entity], src, Lam(Expression.Call(contains, Expression.Field(lbox, "Value"), access)));
-                case "group-by":
-                    var grouped = Q.Call("GroupBy", [entity, at], src, Lam(access));
-                    var gt = typeof(IGrouping<,>).MakeGenericType(at, entity);
-                    var g = Expression.Parameter(gt, "g");
-                    return Q.Call("Select", [gt, at], grouped, Expression.Lambda(Expression.Property(g, "Key"), g));
-                default: throw new ArgumentException(q);
-            }
-        }
-
-        // One side's query: its SQL, or the exception translating it; the rows it answers, or the exception running it.
-        async Task<(string? Sql, Exception? Translating, List<string>? Rows, Exception? Running)> Side(Type entity, bool vo)
-        {
-            await using var db = new EfDb(EfModel.Configure(mapping, entity, null, false), typeKit: vo);
-            IQueryable query;
-            try
-            {
-                await db.Context.Database.EnsureCreatedAsync();
-                var row = Activator.CreateInstance(entity)!;
-                var value = vo ? e.MakeVo(e.Valid()) : e.Valid();
-                entity.GetProperty("P")!.SetValue(row, value);
-                db.Context.Add(row);
-                await db.Context.SaveChangesAsync();
-                db.Context.ChangeTracker.Clear();
-                query = Build(db.Context, entity, vo);
-            }
-            catch (Exception ex) { return (null, ex, null, ex); }
-            string sql;
-            try { sql = query.ToQueryString(); }
-            catch (Exception ex) { return (null, ex, null, ex); }
-            try
-            {
-                var list = new List<string>();
-                foreach (var x in (System.Collections.IEnumerable)query) list.Add(Norm(x));
-                return (sql, null, list, null);
-            }
-            catch (Exception ex) { return (sql, null, null, ex); }
-        }
-        var v = await Side(voEntity, true);
-        var pl = await Side(plainEntity, false);
-
-        // The accessor's obligation: the query over it answers what the same query over the wrapped property answers.
-        var answered = r.Check(acc switch { "Value" => "value", "GetValue" => "get-value", _ => "value-or-null" }, Baseline.Twin, c =>
-        {
-            if (EfSides.Threw(c, v.Running, pl.Running, "the query", out var refused)) return refused;
-            if (!v.Rows!.SequenceEqual(pl.Rows!)) return $"rows differ: VO [{string.Join(",", v.Rows!)}] plain [{string.Join(",", pl.Rows!)}]";
-            c.Note(NoteKeys.Compared, $"{v.Rows!.Count} row(s)");
-            return null;
-        });
-        // column-not-cast: the SQL is the wrapped property's, so the column is re-typed and not cast.
-        var sqlOf = r.Check("column-not-cast", Baseline.Twin, c =>
-        {
-            if (EfSides.Threw(c, v.Translating, pl.Translating, "translating the query", out var refused)) return refused;
-            if (v.Sql != pl.Sql) return $"SQL differs.\nVO:\n{v.Sql}\nplain:\n{pl.Sql}";
-            c.Note(NoteKeys.Compared, "the SQL");
-            return null;
-        });
-        return answered ?? sqlOf;
-    }
-    /// <summary>A result as comparable text: an entity by its P, a value object by the value it wraps.</summary>
-    static string Norm(object? x)
-    {
-        if (x is null) return "<null>";
-        var t = x.GetType();
-        if (t.IsGenericType && t.GetGenericTypeDefinition() is var d && (d == typeof(EntP<>) || d == typeof(EntNC<>))) return Norm(t.GetProperty("P")!.GetValue(x));
-        if (t.GetProperty("Value") is { } v && v.DeclaringType == t && t.Namespace == "Probes.Ef" || t.Name == "V" || t.Name.StartsWith("E_")) return Norm(t.GetProperty("Value")!.GetValue(x));
-        return Convert.ToString(x, System.Globalization.CultureInfo.InvariantCulture) ?? "<null>";
-    }
-}
diff --git a/tools/probe/corpus/probes/E03ColumnRoundTripProbe.cs b/tools/probe/corpus/probes/E03ColumnRoundTripProbe.cs
deleted file mode 100644
index 7dc53d48..00000000
--- a/tools/probe/corpus/probes/E03ColumnRoundTripProbe.cs
+++ /dev/null
@@ -1,82 +0,0 @@
-// Claim E03-column-round-trip (src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#what-maps): "Keys, foreign keys, nullable properties, primitive collections and query parameters all map as plain columns of the underlying type."
-// Oracle: metamorphic plus differential. A value object saved in a property / nullable property / key / owned property / complex property and read back by a fresh query equals what was saved (and its Value is the wrapped value);
-// the stored column (SQLite type and quoted content) equals what the wrapped type stored by plain EF holds. A nullable property also round-trips null.
-// Obligations (claims.json), one per row by ef.mapping, against the wrapped twin (Baseline.Twin): stored-as-underlying (property, owned,
-// complex): "Every value object is stored in a plain column of its underlying type"; keys (key) and nullable-properties (nullable):
-// "Keys, foreign keys, nullable properties, primitive collections and query parameters all map as plain columns of the underlying type."
-// Expected: no failure for any row; where a side refuses, EfSides says how the check ends.
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Metadata;
-using Probes.Ef;
-using Probes.Shapes;
-namespace Probes;
-public sealed class E03ColumnRoundTripProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("E03ColumnRoundTripProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    sealed record Side(string? Raw, List<object?> Read, Exception? Ex);
-
-    static async Task<Side> Run(string mapping, Type entity, Func<object?> value, bool vo)
-    {
-        var col = mapping switch { "key" => "Id", "owned" => "O_P", "complex" => "C_P", _ => "P" };
-        await using var db = new EfDb(EfModel.Configure(mapping, entity, p => { if (mapping == "key") p.ValueGenerated = ValueGenerated.Never; }, false), typeKit: vo);
-        try
-        {
-            await db.Context.Database.EnsureCreatedAsync();
-            var n = mapping == "nullable" ? 2 : 1;
-            for (var i = 1; i <= n; i++)
-            {
-                var row = Activator.CreateInstance(entity)!;
-                var v = i == 2 ? null : value();
-                if (mapping == "key") { EfX.Set(row, "Id", v); EfX.Set(row, "Tag", "t"); }
-                else
-                {
-                    EfX.Set(row, "Id", i);
-                    object holder = row;
-                    if (mapping is "owned" or "complex") holder = EfX.Get(row, mapping == "owned" ? "O" : "C")!;
-                    EfX.Set(holder, "P", v);
-                }
-                db.Context.Add(row);
-            }
-            await db.Context.SaveChangesAsync(); db.Context.ChangeTracker.Clear();
-            var read = new List<object?>();
-            foreach (var x in EfX.Enumerate(Q.SetOf(db.Context, entity)))
-            {
-                object? o = mapping switch { "key" => EfX.Get(x, "Id"), "owned" => EfX.Get(EfX.Get(x, "O")!, "P"), "complex" => EfX.Get(EfX.Get(x, "C")!, "P"), _ => EfX.Get(x, "P") };
-                read.Add(o);
-            }
-            var raw = await EfX.RawScalar(db, $"SELECT group_concat(k, '|') FROM (SELECT typeof({col}) || ':' || quote({col}) AS k FROM t ORDER BY rowid)");
-            return new Side(raw, read, null);
-        }
-        catch (Exception ex) { return new Side(null, [], ex); }
-    }
-
-    static object? Plainify(object? o) => o is not null && o.GetType().Namespace is "Probes.Ef3" or "Probes.Ef" or "Probes.Ef4" ? o.GetType().GetProperty("Value")!.GetValue(o) : o;
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        var w = r["shape.wrapped"]; var kind = r["shape.kind"]; var mapping = r["ef.mapping"];
-        var e = Probes.Ef3.E4.At(r, kind, w, r["shape.site"]);
-        var original = e.Valid();
-        var voSide = await Run(mapping, EfModel.Entity(mapping, e.Vo), () => e.MakeVo(original), vo: true);
-        var plainSide = await Run(mapping, EfModel.Entity(mapping, e.Plain), () => original, vo: false);
-        return r.Check(mapping switch { "key" => "keys", "nullable" => "nullable-properties", _ => "stored-as-underlying" }, Baseline.Twin, c =>
-        {
-            if (EfSides.Threw(c, voSide.Ex, plainSide.Ex, $"saving and reading a {mapping}", out var refused)) return refused;
-            if (voSide.Read.Count != plainSide.Read.Count) return $"read {voSide.Read.Count} rows, the wrapped type read {plainSide.Read.Count}";
-            for (var i = 0; i < voSide.Read.Count; i++)
-            {
-                var v = voSide.Read[i]; var p = plainSide.Read[i];
-                if (p is null != v is null) return $"row {i}: the value object read back {(v is null ? "null" : "a value")}, the wrapped type {(p is null ? "null" : "a value")}";
-                if (v is null) continue;
-                if (!Equals(Plainify(v), p)) return $"row {i}: read back Value {Plainify(v)}, the wrapped type reads {p}";
-                if (!Equals(v, e.MakeVo(p!))) return $"row {i}: the read-back value object does not equal the one built from the stored value";
-            }
-            if (voSide.Raw != plainSide.Raw) return $"stored column differs: value object [{voSide.Raw}] vs wrapped type [{plainSide.Raw}]";
-            c.Note(NoteKeys.Compared, $"{voSide.Read.Count} row(s) read back, the stored column {voSide.Raw}");
-            return null;
-        });
-    }
-}
diff --git a/tools/probe/corpus/probes/E04IntegerKeyProbe.cs b/tools/probe/corpus/probes/E04IntegerKeyProbe.cs
deleted file mode 100644
index db254607..00000000
--- a/tools/probe/corpus/probes/E04IntegerKeyProbe.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-// Claim E04-integer-key-generated (README#keys): "A single-column key over an integer is generated on add, like a key of that integer type ... not byte. A key over char is yours to assign: never generated. A key over a Guid is yours to assign ... To have EF generate it instead, configure ValueGeneratedOnAdd()."
-// Oracle: differential against the same key declared with the wrapped type (two entities added with default keys, SaveChanges, the keys read back), except the documented char and Guid keys, which must not be generated by default.
-// Obligations (claims.json), one per row by shape.wrapped and ef.key-config:
-//   generated-on-add (int, long, ulong), byte-not-generated (byte), not-on-efs-list (string, default): Baseline.Twin
-//   char-key-yours, guid-key-yours (char, Guid, default): the README's "yours to assign" (Baseline.Docs)
-//   own-configuration-wins (char, Guid, string, ValueGeneratedOnAdd or ValueGeneratedNever): Baseline.Twin
-using Microsoft.EntityFrameworkCore;
-using Probes.Ef;
-using Probes.Shapes;
-namespace Probes;
-public sealed class E04IntegerKeyProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("E04IntegerKeyProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        var e = KeyRegistry.Of(r);
-        var config = r["ef.key-config"];
-        string voGenerated = "?";
-        async Task<string> Side(Type keyType, bool vo)
-        {
-            var entity = typeof(EntK<>).MakeGenericType(keyType);
-            Action<ModelBuilder> cfg = mb =>
-            {
-                var eb = mb.Entity(entity); eb.ToTable("t"); eb.HasKey("Id");
-                var pb = eb.Property("Id");
-                if (config == "ValueGeneratedOnAdd") pb.ValueGeneratedOnAdd();
-                if (config == "ValueGeneratedNever") pb.ValueGeneratedNever();
-            };
-            await using var db = new EfDb(cfg, typeKit: vo);
-            try
-            {
-                if (vo) voGenerated = db.Context.Model.FindEntityType(entity)!.FindProperty("Id")!.ValueGenerated.ToString();
-                await db.Context.Database.EnsureCreatedAsync();
-                var rows = new[] { Activator.CreateInstance(entity)!, Activator.CreateInstance(entity)! };
-                foreach (var row in rows) db.Context.Add(row);
-                await db.Context.SaveChangesAsync();
-                return "keys=[" + string.Join(",", rows.Select(x => Norm(entity.GetProperty("Id")!.GetValue(x)))) + "]";
-            }
-            catch (Exception) { return "threw"; }   // where it throws (creating the table, or the insert) differs by provider rule; that it cannot generate is the outcome
-        }
-        string Norm(object? k)
-        {
-            if (k is not null && k.GetType().Namespace == "Probes.Ef") k = k.GetType().GetProperty("Value")!.GetValue(k);
-            return k switch { null => "null", Guid g => g == Guid.Empty ? "empty" : "guid", string str when Guid.TryParse(str, out _) => "guid", _ => Convert.ToString(k, System.Globalization.CultureInfo.InvariantCulture)! };
-        }
-        var voOut = await Side(e.Vo, true);
-        var plainOut = await Side(e.Plain, false);
-        if (config == "default" && e.Wrapped is "char" or "Guid")
-            return r.Check(e.Wrapped == "char" ? "char-key-yours" : "guid-key-yours", Baseline.Docs("src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys"), c =>
-            {
-                // documented: yours to assign, never generated: the model declares the key never generated, and the second default
-                // key collides, or both stay default (not-promised meaningful-char-key-unchecked)
-                c.Note(NoteKeys.DocumentedCharGuidNotGeneratedChecked, "the model declares it " + voGenerated);
-                if (voGenerated != "Never") return $"{e.Wrapped} key is declared {voGenerated}, not never generated (plain: {plainOut})";
-                return voOut.StartsWith("threw") || voOut is "keys=[empty,empty]" or "keys=[\0,\0]" ? null : $"{e.Wrapped} key was generated by default: {voOut} (plain: {plainOut})";
-            });
-        // the rest: as the same key declared with the wrapped type, under the same configuration
-        var obligation = (e.Wrapped, config) switch
-        {
-            ("int" or "long" or "ulong", _) => "generated-on-add",
-            ("byte", _) => "byte-not-generated",
-            ("string", "default") => "not-on-efs-list",
-            _ => "own-configuration-wins",
-        };
-        return r.Check(obligation, Baseline.Twin, c =>
-        {
-            if (voOut != plainOut) return $"VO key: {voOut}; plain key: {plainOut}";
-            c.Note(NoteKeys.Compared, voOut);
-            return null;
-        });
-    }
-}
diff --git a/tools/probe/corpus/probes/E05OwnCompareToProbe.cs b/tools/probe/corpus/probes/E05OwnCompareToProbe.cs
deleted file mode 100644
index 80c90646..00000000
--- a/tools/probe/corpus/probes/E05OwnCompareToProbe.cs
+++ /dev/null
@@ -1,127 +0,0 @@
-// Claim E05-own-compareto-rejected (README#queries): "Your own CompareTo(TSelf) can't run in the database ... these queries throw an InvalidOperationException naming the value object: a comparison (<, >, <=, >=, CompareTo); an ordering (OrderBy, ThenBy, their descending forms, Order); Min or Max. ... Equality isn't ordering, and stays allowed. A query filter (HasQueryFilter, named or not) that does the same fails when the model is built."
-// Oracle: exception. A value object with a descending CompareTo, in each such query, must throw InvalidOperationException naming it (never return rows); equality and ordering by .Value return what memory returns.
-// Obligations (claims.json), one per row by ef.op: comparison, ordering, min-max and query-filter against the documented refusal
-// (Baseline.Refusal); equality-allowed and value-order-allowed against memory (Baseline.Model).
-using System.Linq.Expressions;
-using System.Reflection;
-using Microsoft.EntityFrameworkCore;
-using Probes.Ef;
-using Probes.Shapes;
-namespace Probes;
-public sealed class E05OwnCompareToProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("E05OwnCompareToProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    static readonly string[] Refused = ["lt", "gt", "le", "ge", "CompareTo", "OrderBy", "OrderByDescending", "ThenBy", "Order", "Min", "Max"];
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        var op = r["ef.op"];
-        var obligation = op switch
-        {
-            "lt" or "gt" or "le" or "ge" or "CompareTo" => "comparison",
-            "OrderBy" or "OrderByDescending" or "ThenBy" or "Order" => "ordering",
-            "Min" or "Max" => "min-max",
-            "equals" => "equality-allowed",
-            "value-order" => "value-order-allowed",
-            _ => "query-filter",
-        };
-        // a refused query is held to the documented refusal; an allowed one to what memory answers
-        return await r.Check(obligation, Refused.Contains(op) || obligation == "query-filter" ? Baseline.Refusal : Baseline.Model, async c =>
-        {
-            var h = HandOrdered.Of(r["ef.vo"]);
-            var entity = typeof(EntP<>).MakeGenericType(h.Vo);
-            var filter = op is "HasQueryFilter" or "named-query-filter";
-            var box = Expression.Constant(Q.NewBox(h.Vo, HandOrdered.Make(h, h.Values[1])));
-            Expression Const() => Expression.Field(box, "Value");
-            var p = Expression.Parameter(entity, "e");
-            var prop = Expression.Property(p, "P");
-            LambdaExpression Lam(Expression body) => Expression.Lambda(body, p);
-            Expression? predicate = null;
-            try
-            {
-                predicate = op switch
-                {
-                    "lt" => Expression.LessThan(prop, Const()),
-                    "gt" => Expression.GreaterThan(prop, Const()),
-                    "le" => Expression.LessThanOrEqual(prop, Const()),
-                    "ge" => Expression.GreaterThanOrEqual(prop, Const()),
-                    "CompareTo" => Expression.GreaterThan(Expression.Call(prop, h.Vo.GetMethod("CompareTo", [h.Vo])!, Const()), Expression.Constant(0)),
-                    "equals" => Expression.Equal(prop, Const()),
-                    "HasQueryFilter" or "named-query-filter" => Expression.GreaterThan(prop, Const()),
-                    _ => null,
-                };
-            }
-            catch (InvalidOperationException ex) { return c.Inconclusive($"{op} cannot be written over {h.Vo.Name}: {ex.Message}"); }
-
-            Action<ModelBuilder> cfg = mb =>
-            {
-                var eb = mb.Entity(entity);
-                eb.ToTable("t"); eb.HasKey("Id");
-                if (op == "HasQueryFilter") eb.HasQueryFilter(Lam(predicate!));
-                if (op == "named-query-filter") eb.HasQueryFilter("AboveTwo", Lam(predicate!));
-            };
-            await using var db = new EfDb(cfg, typeKit: true);
-            object[] Seed() => h.Values.Select(v => HandOrdered.Make(h, v)).ToArray();
-            Exception? thrown = null;
-            List<string> result = [];
-            try
-            {
-                await db.Context.Database.EnsureCreatedAsync();
-                foreach (var v in Seed()) { var row = Activator.CreateInstance(entity)!; entity.GetProperty("P")!.SetValue(row, v); db.Context.Add(row); }
-                await db.Context.SaveChangesAsync();
-                db.Context.ChangeTracker.Clear();
-                var src = Q.SetOf(db.Context, entity);
-                object? scalar = null;
-                IQueryable? query = null;
-                switch (op)
-                {
-                    case "lt" or "gt" or "le" or "ge" or "CompareTo" or "equals": query = Q.Call("Where", [entity], src, Lam(predicate!)); break;
-                    case "OrderBy": query = Q.Call("OrderBy", [entity, h.Vo], src, Lam(prop)); break;
-                    case "OrderByDescending": query = Q.Call("OrderByDescending", [entity, h.Vo], src, Lam(prop)); break;
-                    case "ThenBy": query = Q.Call("ThenBy", [entity, h.Vo], Q.Call("OrderBy", [entity, typeof(int)], src, Lam(Expression.Property(p, "Id"))), Lam(prop)); break;
-                    case "value-order":
-                        var value = h.Vo.GetProperty("Value")!;
-                        query = Q.Call("OrderBy", [entity, h.Plain], src, Lam(Expression.Property(prop, value))); break;
-                    case "Order" or "Min" or "Max":
-                        var sel = Q.Call("Select", [entity, h.Vo], src, Lam(prop));
-                        var m = typeof(Queryable).GetMethods().First(x => x.Name == op && x.IsGenericMethodDefinition && x.GetParameters().Length == 1 && x.GetGenericArguments().Length == 1).MakeGenericMethod(h.Vo);
-                        try { var res = m.Invoke(null, [sel]); if (op == "Order") query = (IQueryable)res!; else scalar = res; }
-                        catch (TargetInvocationException tie) { throw tie.InnerException!; }
-                        break;
-                    case "HasQueryFilter" or "named-query-filter":
-                        query = src; break;
-                    default: throw new ArgumentException(op);
-                }
-                if (query is not null) foreach (var x in (System.Collections.IEnumerable)query) result.Add(Plain(x));
-                else result.Add(Plain(scalar));
-            }
-            catch (Exception ex) { thrown = ex; }
-
-            if (Refused.Contains(op) || filter)
-            {
-                if (thrown is null) return $"{op} on {h.Vo.Name} returned [{string.Join(",", result)}] instead of throwing";
-                if (thrown is not InvalidOperationException) return $"{op}: expected InvalidOperationException, got {thrown.GetType().Name}: {Trim(thrown.Message)}";
-                if (!thrown.Message.Contains(h.Vo.Name)) return $"{op}: the exception does not name {h.Vo.Name}: {Trim(thrown.Message)}";
-                if (filter && !thrown.Message.Contains("query filter")) return $"{op}: the exception does not say it is the query filter: {Trim(thrown.Message)}";
-                if (!filter && !thrown.Message.Contains(".Value")) return $"{op}: the exception does not point to .Value: {Trim(thrown.Message)}";
-                return null;
-            }
-            if (thrown is not null) return $"{op} (allowed) threw {thrown.GetType().Name}: {Trim(thrown.Message)}";
-            // allowed: equals keeps the one equal row; value-order sorts by the wrapped value, ascending
-            var expected = op == "equals" ? new[] { Plain(h.Values[1]) } : h.Values.OrderBy(v => v, Comparer<object>.Create((a, b) => ((IComparable)a).CompareTo(b))).Select(Plain).ToArray();
-            return result.SequenceEqual(expected) ? null : $"{op}: got [{string.Join(",", result)}], memory gives [{string.Join(",", expected)}]";
-        });
-    }
-    static string Plain(object? x)
-    {
-        if (x is null) return "<null>";
-        var t = x.GetType();
-        if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(EntP<>)) return Plain(t.GetProperty("P")!.GetValue(x));
-        if (t.Namespace == "Probes.Ef" && t.GetProperty("Value") is { } v) return Plain(v.GetValue(x));
-        return Convert.ToString(x, System.Globalization.CultureInfo.InvariantCulture) ?? "<null>";
-    }
-    static string Trim(string s) => s.Length > 300 ? s[..300] : s;
-}
diff --git a/tools/probe/corpus/probes/E06OwnConverterNoValueProbe.cs b/tools/probe/corpus/probes/E06OwnConverterNoValueProbe.cs
deleted file mode 100644
index 2b58f044..00000000
--- a/tools/probe/corpus/probes/E06OwnConverterNoValueProbe.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-// Claim E06-own-converter-no-value (src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries): ".Value translates only where the column holds the underlying value ... A property your application converts itself (HasConversion(c => "C:" + c.Value, ...), a converter type, a conversion in ConfigureConventions) doesn't hold .Value. So a query that reads .Value there fails with EF's 'could not be translated', rather than comparing against what the column really holds. Comparing the value object itself (o.Code == code) goes through that converter and still works."
-// Obligations (claims.json), one per row by ef.op: value-not-translated (value-access), against the README (Baseline.Docs), and
-// value-object-comparison (vo-equality), against the row memory matches (Baseline.Model).
-// Oracle: claim. With the application's own converter (three ways to declare it) the column holds the converter's text; a query on .Value throws InvalidOperationException "could not be translated" (never returns rows or an empty result); a query comparing the value object returns exactly the matching row.
-using System.Linq.Expressions;
-using Microsoft.EntityFrameworkCore;
-using Probes.Ef;
-using Probes.Shapes;
-namespace Probes;
-public sealed class E06OwnConverterNoValueProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("E06OwnConverterNoValueProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    static Action<ModelBuilder> Model<T>(string form) where T : notnull => mb => mb.Entity<EntP<T>>(eb =>
-    {
-        eb.ToTable("t"); eb.HasKey(x => x.Id);
-        switch (form)
-        {
-            case "HasConversion-lambda": eb.Property(x => x.P).HasConversion(v => OwnConv<T>.To(v), s => OwnConv<T>.From(s)); break;
-            case "converter-type": eb.Property(x => x.P).HasConversion<OwnConverter<T>>(); break;
-        }
-    });
-    static Action<ModelConfigurationBuilder>? Conventions<T>(string form) where T : notnull =>
-        form == "ConfigureConventions" ? cb => cb.Properties<T>().HaveConversion<OwnConverter<T>>() : null;
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        var form = r["ef.converter"]; var op = r["ef.op"]; var w = r["shape.wrapped"];
-        // value-access: the README's "could not be translated" (no twin can show it); vo-equality: the one row memory matches
-        var valueAccess = op == "value-access";
-        return await r.Check(valueAccess ? "value-not-translated" : "value-object-comparison",
-            valueAccess ? Baseline.Docs("src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries") : Baseline.Model, async c =>
-        {
-            var e = EfX.Top(EfX.Kinds[r.Index % EfX.Kinds.Length], w);
-            OwnConvs.Setup(e, vo: true);
-            var entity = typeof(EntP<>).MakeGenericType(e.Vo);
-            var cfg = (Action<ModelBuilder>)typeof(E06OwnConverterNoValueProbe).GetMethod(nameof(Model), System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static)!.MakeGenericMethod(e.Vo).Invoke(null, [form])!;
-            var conv = (Action<ModelConfigurationBuilder>?)typeof(E06OwnConverterNoValueProbe).GetMethod(nameof(Conventions), System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static)!.MakeGenericMethod(e.Vo).Invoke(null, [form]);
-            await using var db = new EfDb2(cfg, "after-provider", conv);
-            await db.Context.Database.EnsureCreatedAsync();
-            foreach (var i in new[] { 0, 1 }) { var x = EfX.New(entity); EfX.Set(x, "P", e.MakeVo(EfX.Sample(w, i))); db.Context.Add(x); }
-            await db.Context.SaveChangesAsync();
-            db.Context.ChangeTracker.Clear();
-
-            var stored = await EfX2.RawScalar(db.Connection, "SELECT group_concat(P, ',') FROM (SELECT P FROM t ORDER BY Id)");
-            var expected = "C:" + OwnConv<int>.Fmt(EfX.Sample(w, 0)) + ",C:" + OwnConv<int>.Fmt(EfX.Sample(w, 1));
-            if (stored != expected) return $"{form}: the column holds {stored}, expected the application's converter output {expected}";
-
-            var p = Expression.Parameter(entity, "e");
-            var prop = Expression.Property(p, "P");
-            var src = Q.SetOf(db.Context, entity);
-            if (op == "vo-equality")
-            {
-                var box = Q.NewBox(e.Vo, e.MakeVo(EfX.Sample(w, 1)));
-                var pred = Expression.Lambda(Expression.Equal(prop, Expression.Field(Expression.Constant(box), "Value")), p);
-                List<object> got;
-                // a refusal here is the claim failing, not the harness: comparing the value object goes through the application's converter
-                try { got = EfX.Enumerate(Q.Call("Where", [entity], src, pred)).ToList(); }
-                catch (InvalidOperationException ex) { return $"{form}: comparing the value object failed with {ex.GetType().Name}: {ex.Message[..Math.Min(200, ex.Message.Length)]}"; }
-                if (got.Count != 1 || EfX.Plainify(EfX.Get(got[0], "P")) != EfX.Plainify(EfX.Sample(w, 1))) return $"{form}: comparing the value object returned {got.Count} row(s), expected the one that matches";
-                return null;
-            }
-            var pbox = Q.NewBox(e.Plain, EfX.Sample(w, 1));
-            var vpred = Expression.Lambda(Expression.Equal(Expression.Property(prop, "Value"), Expression.Field(Expression.Constant(pbox), "Value")), p);
-            try
-            {
-                var got = EfX.Enumerate(Q.Call("Where", [entity], src, vpred)).ToList();
-                return $"{form}: a query on .Value of a property the application converts itself returned {got.Count} row(s) instead of failing as untranslatable";
-            }
-            catch (InvalidOperationException ex) when (ex.Message.Contains("could not be translated")) { return null; }
-            catch (Exception ex) { return $"{form}: the .Value query failed with {ex.GetType().Name}: {ex.Message[..Math.Min(200, ex.Message.Length)]}, not EF's 'could not be translated'"; }
-        });
-    }
-}
diff --git a/tools/probe/corpus/probes/E07ClosedSetNameProbe.cs b/tools/probe/corpus/probes/E07ClosedSetNameProbe.cs
deleted file mode 100644
index 16bf3562..00000000
--- a/tools/probe/corpus/probes/E07ClosedSetNameProbe.cs
+++ /dev/null
@@ -1,129 +0,0 @@
-// Claim E07-closed-set-stored-as-name (README#closed-sets): "A closed set is stored as a text column of the member's name, and read back as the member itself. That holds in a table, in a primitive collection of names and in a JSON column alike ... A name the set no longer has throws when it's read, rather than reading as null. An instance that isn't a member throws when it's written."
-// Obligations (claims.json), against the README's section (Baseline.Docs): stored-as-name (round-trip), in-collections-and-json
-// (round-trip in a primitive collection or a JSON column), unknown-name-throws (unknown-name-on-read), non-member-throws (non-member-on-write).
-// Oracle: claim. Round trip: the stored text is the member's name and the read value is the member itself (reference-equal); an unknown stored name throws on read (never null/default); a non-member instance throws on write.
-using Microsoft.EntityFrameworkCore;
-using Probes.Ef;
-using Probes.Shapes;
-namespace Probes;
-public sealed class E07ClosedSetNameProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("E07ClosedSetNameProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        var site = r["ef.site"]; var ev = r["ef.event"];
-        var set = typeof(PSet);
-        Type entity; string column; Action<Microsoft.EntityFrameworkCore.ModelBuilder> cfg;
-        switch (site)
-        {
-            case "table":
-                entity = typeof(EntP<PSet>); column = "P";
-                cfg = mb => { var eb = mb.Entity(entity); eb.ToTable("t"); eb.HasKey("Id"); };
-                break;
-            case "primitive-collection":
-                entity = typeof(EntL<PSet>); column = "Items";
-                cfg = mb => { var eb = mb.Entity(entity); eb.ToTable("t"); eb.HasKey("Id"); };
-                break;
-            case "json-column":
-                entity = typeof(EntO<PSet>); column = "O";
-                cfg = mb => { var eb = mb.Entity(entity); eb.ToTable("t"); eb.HasKey("Id"); eb.OwnsOne(typeof(Own<PSet>), "O", ob => ob.ToJson()); };
-                break;
-            default: throw new ArgumentException(site);
-        }
-        PSet NonMember() => (PSet)Activator.CreateInstance(set, nonPublic: true)!;
-        object Entity(params PSet[] members)
-        {
-            var e = EfX.New(entity);
-            switch (site)
-            {
-                case "table": EfX.Set(e, "P", members[0]); break;
-                case "primitive-collection": EfX.Set(e, "Items", members.ToList()); break;
-                default: var o = new Own<PSet> { P = members[0] }; EfX.Set(e, "O", o); break;
-            }
-            return e;
-        }
-        string Members(object e) => site switch
-        {
-            "table" => ((PSet)EfX.Get(e, "P")!).Name(),
-            "primitive-collection" => string.Join(",", ((List<PSet>)EfX.Get(e, "Items")!).Select(x => x.Name())),
-            _ => ((Own<PSet>)EfX.Get(e, "O")!).P.Name(),
-        };
-
-        var docs = Baseline.Docs("src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#closed-sets");
-        await using var db = new EfDb(cfg, typeKit: true);
-        await db.Context.Database.EnsureCreatedAsync();
-        switch (ev)
-        {
-            case "round-trip":
-            {
-                var e = site == "primitive-collection" ? Entity(PSet.Beta, PSet.Alpha) : Entity(PSet.Beta);
-                db.Context.Add(e); await db.Context.SaveChangesAsync(); db.Context.ChangeTracker.Clear();
-                var stored = await EfX.RawScalar(db, $"SELECT {column} FROM t");
-                var expectStored = site switch { "table" => "Beta", "primitive-collection" => "[\"Beta\",\"Alpha\"]", _ => "{\"P\":\"Beta\"}" };
-                // stored-as-name: a table's text is the member's name, and every site reads back the member itself
-                var named = r.Check("stored-as-name", docs, c =>
-                {
-                    if (site == "table" && stored != expectStored) return $"stored text is {stored}, expected {expectStored}";
-                    object back;
-                    try { back = EfX.Enumerate(Q.SetOf(db.Context, entity)).Single(); }
-                    catch (Exception ex) when (ex is not Xunit.Sdk.XunitException) { return $"reading the stored {stored} back threw {ex.GetType().Name}: {ex.Message.Split('\n')[0]}"; }
-                    if (site == "primitive-collection")
-                    {
-                        var l = (List<PSet>)EfX.Get(back, "Items")!;
-                        if (!(l.Count == 2 && ReferenceEquals(l[0], PSet.Beta) && ReferenceEquals(l[1], PSet.Alpha))) return "read back " + Members(back);
-                    }
-                    else
-                    {
-                        var got = site == "table" ? (PSet)EfX.Get(back, "P")! : ((Own<PSet>)EfX.Get(back, "O")!).P;
-                        if (!ReferenceEquals(got, PSet.Beta)) return "read back is not the member itself: " + got;
-                    }
-                    c.Note(NoteKeys.Compared, site == "table" ? "the stored name and the member read back" : "the members read back");
-                    return null;
-                });
-                if (site == "table") return named;
-                // in-collections-and-json: a primitive collection holds the names as a JSON array, a JSON column the name as the property's value
-                var inJson = r.Check("in-collections-and-json", docs, c =>
-                {
-                    if (stored != expectStored) return $"stored text is {stored}, expected {expectStored}";
-                    c.Note(NoteKeys.Compared, stored);
-                    return null;
-                });
-                return named ?? inJson;
-            }
-            case "unknown-name-on-read":
-            {
-                var e = site == "primitive-collection" ? Entity(PSet.Beta, PSet.Alpha) : Entity(PSet.Alpha);
-                db.Context.Add(e); await db.Context.SaveChangesAsync(); db.Context.ChangeTracker.Clear();
-                var bad = site switch { "table" => "'Gamma'", "primitive-collection" => "'[\"Alpha\",\"Gamma\"]'", _ => "'{\"P\":\"Gamma\"}'" };
-                await EfX.Raw(db, $"UPDATE t SET {column} = {bad}");
-                return r.Check("unknown-name-throws", docs, c =>
-                {
-                    try
-                    {
-                        var back = EfX.Enumerate(Q.SetOf(db.Context, entity)).ToList();
-                        return "an unknown stored name read without throwing: " + (back.Count == 1 ? Safe(() => Members(back[0])) : back.Count + " rows");
-                    }
-                    catch (Exception ex) when (ex is not Xunit.Sdk.XunitException) { c.Note(NoteKeys.Compared, ex.GetType().Name); return null; }
-                });
-            }
-            case "non-member-on-write":
-            {
-                var e = Entity(NonMember());
-                db.Context.Add(e);
-                return await r.Check("non-member-throws", docs, async c =>
-                {
-                    try { await db.Context.SaveChangesAsync(); }
-                    catch (Exception ex) when (ex is not Xunit.Sdk.XunitException) { c.Note(NoteKeys.Compared, ex.GetType().Name); return null; }
-                    var stored = await EfX.RawScalar(db, $"SELECT {column} FROM t");
-                    return "a non-member instance was written without throwing; stored: " + stored;
-                });
-            }
-            default: throw new ArgumentException(ev);
-        }
-    }
-    static string Safe(Func<string> f) { try { return f(); } catch (Exception ex) { return "(" + ex.GetType().Name + ")"; } }
-}
-static class PSetNames { public static string Name(this PSet? s) => s is null ? "null" : s == PSet.Alpha ? "Alpha" : s == PSet.Beta ? "Beta" : "other"; }
diff --git a/tools/probe/corpus/probes/E08OptionResultNotColumnsProbe.cs b/tools/probe/corpus/probes/E08OptionResultNotColumnsProbe.cs
deleted file mode 100644
index 06908358..00000000
--- a/tools/probe/corpus/probes/E08OptionResultNotColumnsProbe.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-// Claim E08-option-result-not-columns (docs/ef-core.md#option-and-result): "EF can't map an Option or a Result property, and building the model fails with an error that says so."
-// Oracle: claim. Building the model (UseTypeKit on) of an entity with an Option/Result as property, key, list element or owned property throws, and the message names the Option/Result type (not a silent column).
-// Obligations (claims.json), both on every row, against the docs page's section (Baseline.Docs): model-fails ("EF can't map an `Option`
-// or a `Result` property": InvalidOperationException, never a column) and error-says-so ("building the model fails with an error that
-// says so": the message names the type). A model that builds, or a message that does not name the type, is a violation.
-using Microsoft.EntityFrameworkCore;
-using CodoMetis.TypeKit;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Metadata;
-using Probes.Ef;
-using Probes.Shapes;
-namespace Probes;
-public sealed class E08OptionResultNotColumnsProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("E08OptionResultNotColumnsProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    static Type PlainOf(string w) => w switch { "string" => typeof(string), "int" => typeof(int), "Guid" => typeof(Guid), _ => throw new ArgumentException(w) };
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        var w = r["shape.wrapped"]; var kind = r["ef.type"]; var pos = r["ef.position"];
-        var plain = PlainOf(w);
-        var vo = EfX.Top("record-struct", w).Vo;
-        Type t = kind switch
-        {
-            "Option-int" => typeof(Option<>).MakeGenericType(plain),
-            "Option-VO" => typeof(Option<>).MakeGenericType(vo),
-            "Result-int-E" => typeof(Result<,>).MakeGenericType(plain, typeof(ShapeFault)),
-            "Result-VO-E" => typeof(Result<,>).MakeGenericType(vo, typeof(ShapeFault)),
-            "Result-E" => typeof(Result<>).MakeGenericType(plain),
-            _ => throw new ArgumentException(kind),
-        };
-        var entity = pos switch
-        {
-            "property" => typeof(EntP<>).MakeGenericType(t),
-            "key" => typeof(EntK<>).MakeGenericType(t),
-            "collection" => typeof(EntL<>).MakeGenericType(t),
-            "owned-property" => typeof(EntO<>).MakeGenericType(t),
-            _ => throw new ArgumentException(pos),
-        };
-        Action<Microsoft.EntityFrameworkCore.ModelBuilder> cfg = mb =>
-        {
-            var eb = mb.Entity(entity); eb.ToTable("t"); eb.HasKey("Id");
-            if (pos == "owned-property") eb.OwnsOne(typeof(Own<>).MakeGenericType(t), "O");
-        };
-        await using var db = new EfDb(cfg, typeKit: true);
-        Exception? thrown = null;
-        try
-        {
-            _ = db.Context.GetService<IDesignTimeModel>().Model;
-            await db.Context.Database.EnsureCreatedAsync();
-        }
-        catch (Exception ex) { thrown = ex; }
-        var docs = Baseline.Docs("docs/ef-core.md#option-and-result");
-        var built = $"the model with {t.Name} as {pos} built and created the table";
-        // model-fails: building the model is refused (InvalidOperationException), never a silent column
-        var fails = r.Check("model-fails", docs, c =>
-        {
-            if (thrown is null) return built;
-            if (thrown is not InvalidOperationException) return $"model build threw {thrown.GetType().Name}, not InvalidOperationException: {thrown.Message.Split('\n')[0]}";
-            c.Note(NoteKeys.Compared, thrown.GetType().Name);
-            return null;
-        });
-        // error-says-so: the refusal names the Option or Result type
-        var says = r.Check("error-says-so", docs, c =>
-        {
-            if (thrown is null) return built + ", with no error to say so";
-            c.Note(NoteKeys.RefusalNamesTheType, thrown.Message.Split('\n')[0]);
-            var friendly = t.Name.Split('`')[0] + "<";
-            return thrown.Message.Contains(friendly) ? null : $"model build failed but the message does not name the type: {thrown.Message.Split('\n')[0]}";
-        });
-        return fails ?? says;
-    }
-}
diff --git a/tools/probe/corpus/probes/E09OrNoneInDbProbe.cs b/tools/probe/corpus/probes/E09OrNoneInDbProbe.cs
deleted file mode 100644
index 9f18dd6b..00000000
--- a/tools/probe/corpus/probes/E09OrNoneInDbProbe.cs
+++ /dev/null
@@ -1,179 +0,0 @@
-// Claim E09-or-none-in-database (src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#an-option-for-nothing-found): "These ask the database for one row and let it run the condition: FirstOrNoneAsync, FirstOrNone, FirstOrError read one row (WHERE ... LIMIT); SingleOrNone(Async) ask for two rows and throw for more than one; ElementAtOrNone skips to its row (OFFSET)."
-// Oracle: claim. Over a table of value-object keys the operator returns what an in-memory evaluation of the same condition gives (none / the first match / the error), the executed SELECT carries the condition (WHERE) and LIMIT (OFFSET for ElementAtOrNone), and SingleOrNone throws InvalidOperationException for more than one match.
-// Obligations (claims.json), one per row by ef.operator, against the README (Baseline.Docs): first-reads-one-row (FirstOrNoneAsync,
-// FirstOrNone, FirstOrError), single-asks-for-two (SingleOrNoneAsync, SingleOrNone), element-at-skips (ElementAtOrNone).
-// Expected: no failure for any row. The condition is written as a lambda at the call or held as an Expression<Func<T,bool>> variable.
-#nullable enable
-#pragma warning disable CMTK0014, CS8618, CS1591, CMTK0005, CMTK1000, CMTK0003, CMTK0006, CA1000
-using System.Data.Common;
-using System.Linq.Expressions;
-using CodoMetis.TypeKit;
-using CodoMetis.TypeKit.ValueObjects;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Diagnostics;
-using Probes.Ef;
-using Probes.Shapes;
-namespace Probes;
-
-public sealed class SqlCap : DbCommandInterceptor
-{
-    public readonly List<string> Sql = [];
-    public override InterceptionResult<DbDataReader> ReaderExecuting(DbCommand command, CommandEventData eventData, InterceptionResult<DbDataReader> result) { Sql.Add(command.CommandText); return result; }
-    public override ValueTask<InterceptionResult<DbDataReader>> ReaderExecutingAsync(DbCommand command, CommandEventData eventData, InterceptionResult<DbDataReader> result, CancellationToken cancellationToken = default) { Sql.Add(command.CommandText); return ValueTask.FromResult(result); }
-}
-
-public sealed class E09OrNoneInDbProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("E09OrNoneInDbProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    /// <summary>One check per row, the operator's obligation, held to the README's SQL and to the in-memory answer of the same condition.</summary>
-    static Task<string?> Check(Probes.Shapes.Row r)
-    {
-        var obligation = r["ef.operator"] switch
-        {
-            "FirstOrNoneAsync" or "FirstOrNone" or "FirstOrError" => "first-reads-one-row",
-            "SingleOrNoneAsync" or "SingleOrNone" => "single-asks-for-two",
-            _ => "element-at-skips",
-        };
-        return r.Check(obligation, Baseline.Docs("src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#an-option-for-nothing-found"), c =>
-            c["shape.wrapped"] switch { "int" => Run_int(r), "Guid" => Run_Guid(r), "string" => Run_string(r), var w => throw new ArgumentException(w) });
-    }
-
-    static string Flat(string s) => s.Replace("\n", " ");
-    static string? Verify(string op, string data, string got, string? thrown, List<int> matching, SqlCap cap)
-    {
-        var expect = op switch
-        {
-            "FirstOrNoneAsync" or "FirstOrNone" => matching.Count == 0 ? "none" : "some:" + matching[0],
-            "FirstOrError" => matching.Count == 0 ? "err" : "ok:" + matching[0],
-            "SingleOrNoneAsync" or "SingleOrNone" => matching.Count > 1 ? "throws" : matching.Count == 0 ? "none" : "some:" + matching[0],
-            "ElementAtOrNone" => matching.Count > 1 ? "some:" + matching[1] : "none",
-            _ => throw new ArgumentException(op),
-        };
-        var actual = thrown is not null ? (thrown == "InvalidOperationException" ? "throws" : "threw " + thrown) : got;
-        if (actual != expect) return $"{op} over {data}: got {actual}, expected {expect}";
-        var selects = cap.Sql.Where(s => s.TrimStart().StartsWith("SELECT", StringComparison.OrdinalIgnoreCase) && s.Contains("FROM \"t\"")).ToList();
-        if (selects.Count == 0) return $"{op}: no SELECT was executed";
-        var last = selects[^1];
-        if (!last.Contains("WHERE")) return $"{op}: the condition did not reach the database: {Flat(last)}";
-        if (!last.Contains("LIMIT")) return $"{op}: the SELECT has no LIMIT (reads more than the rows asked for): {Flat(last)}";
-        if (op == "ElementAtOrNone" && !last.Contains("OFFSET")) return $"{op}: the SELECT has no OFFSET: {Flat(last)}";
-        return null;
-    }
-
-    public sealed class Ent_int { public int Id { get; set; } public PInt Key { get; set; } }
-    static async Task<string?> Run_int(Probes.Shapes.Row r)
-    {
-        var op = r["ef.operator"]; var data = r["ef.data"]; var cond = r["ef.condition"]; _ = r["shape.wrapped"];
-        var cap = new SqlCap();
-        await using var db = new EfDb(mb => { var eb = mb.Entity<Ent_int>(); eb.ToTable("t"); eb.HasKey(x => x.Id); }, typeKit: true, b => b.AddInterceptors(cap));
-        await db.Context.Database.EnsureCreatedAsync();
-        PInt[] keys = data == "empty" ? [] : data == "one-match" ? [PInt.From(10), PInt.From(11), PInt.From(12)] : [PInt.From(10), PInt.From(11), PInt.From(11), PInt.From(12)];
-        for (var i = 0; i < keys.Length; i++) db.Context.Add(new Ent_int { Id = i + 1, Key = keys[i] });
-        await db.Context.SaveChangesAsync(); db.Context.ChangeTracker.Clear();
-        var target = PInt.From(11);
-        var matching = Enumerable.Range(0, keys.Length).Where(i => keys[i] == target).Select(i => i + 1).ToList();
-        Expression<Func<Ent_int, bool>> held = o => o.Key == target;
-        IQueryable<Ent_int> q = db.Context.Set<Ent_int>().OrderBy(o => o.Id);
-        cap.Sql.Clear();
-        var lam = cond == "lambda";
-        string got = ""; string? thrown = null;
-        try
-        {
-            switch (op)
-            {
-                case "FirstOrNoneAsync": got = Show(lam ? await q.FirstOrNoneAsync(o => o.Key == target) : await q.FirstOrNoneAsync(held)); break;
-                case "FirstOrNone": got = Show(lam ? q.FirstOrNone(o => o.Key == target) : q.FirstOrNone(held)); break;
-                case "SingleOrNoneAsync": got = Show(lam ? await q.SingleOrNoneAsync(o => o.Key == target) : await q.SingleOrNoneAsync(held)); break;
-                case "SingleOrNone": got = Show(lam ? q.SingleOrNone(o => o.Key == target) : q.SingleOrNone(held)); break;
-                case "ElementAtOrNone": got = Show(lam ? q.Where(o => o.Key == target).ElementAtOrNone(1) : q.Where(held).ElementAtOrNone(1)); break;
-                case "FirstOrError":
-                    var res = lam ? q.FirstOrError(o => o.Key == target, ShapeFault.Refused) : q.FirstOrError(held, ShapeFault.Refused);
-                    got = res.Match(x => "ok:" + x.Id, _ => "err"); break;
-                default: throw new ArgumentException(op);
-            }
-        }
-        catch (Exception ex) { thrown = ex.GetType().Name; }
-        return Verify(op, data, got, thrown, matching, cap);
-    }
-    static string Show(Option<Ent_int> o) => o.Match(x => "some:" + x.Id, () => "none");
-
-    public sealed class Ent_Guid { public int Id { get; set; } public PGuid Key { get; set; } }
-    static async Task<string?> Run_Guid(Probes.Shapes.Row r)
-    {
-        var op = r["ef.operator"]; var data = r["ef.data"]; var cond = r["ef.condition"]; _ = r["shape.wrapped"];
-        var cap = new SqlCap();
-        await using var db = new EfDb(mb => { var eb = mb.Entity<Ent_Guid>(); eb.ToTable("t"); eb.HasKey(x => x.Id); }, typeKit: true, b => b.AddInterceptors(cap));
-        await db.Context.Database.EnsureCreatedAsync();
-        PGuid[] keys = data == "empty" ? [] : data == "one-match" ? [PGuid.From(new Guid(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)), PGuid.From(new Guid(2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)), PGuid.From(new Guid(3, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11))] : [PGuid.From(new Guid(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)), PGuid.From(new Guid(2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)), PGuid.From(new Guid(2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)), PGuid.From(new Guid(3, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11))];
-        for (var i = 0; i < keys.Length; i++) db.Context.Add(new Ent_Guid { Id = i + 1, Key = keys[i] });
-        await db.Context.SaveChangesAsync(); db.Context.ChangeTracker.Clear();
-        var target = PGuid.From(new Guid(2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11));
-        var matching = Enumerable.Range(0, keys.Length).Where(i => keys[i] == target).Select(i => i + 1).ToList();
-        Expression<Func<Ent_Guid, bool>> held = o => o.Key == target;
-        IQueryable<Ent_Guid> q = db.Context.Set<Ent_Guid>().OrderBy(o => o.Id);
-        cap.Sql.Clear();
-        var lam = cond == "lambda";
-        string got = ""; string? thrown = null;
-        try
-        {
-            switch (op)
-            {
-                case "FirstOrNoneAsync": got = Show(lam ? await q.FirstOrNoneAsync(o => o.Key == target) : await q.FirstOrNoneAsync(held)); break;
-                case "FirstOrNone": got = Show(lam ? q.FirstOrNone(o => o.Key == target) : q.FirstOrNone(held)); break;
-                case "SingleOrNoneAsync": got = Show(lam ? await q.SingleOrNoneAsync(o => o.Key == target) : await q.SingleOrNoneAsync(held)); break;
-                case "SingleOrNone": got = Show(lam ? q.SingleOrNone(o => o.Key == target) : q.SingleOrNone(held)); break;
-                case "ElementAtOrNone": got = Show(lam ? q.Where(o => o.Key == target).ElementAtOrNone(1) : q.Where(held).ElementAtOrNone(1)); break;
-                case "FirstOrError":
-                    var res = lam ? q.FirstOrError(o => o.Key == target, ShapeFault.Refused) : q.FirstOrError(held, ShapeFault.Refused);
-                    got = res.Match(x => "ok:" + x.Id, _ => "err"); break;
-                default: throw new ArgumentException(op);
-            }
-        }
-        catch (Exception ex) { thrown = ex.GetType().Name; }
-        return Verify(op, data, got, thrown, matching, cap);
-    }
-    static string Show(Option<Ent_Guid> o) => o.Match(x => "some:" + x.Id, () => "none");
-
-    public sealed class Ent_string { public int Id { get; set; } public PStr Key { get; set; } }
-    static async Task<string?> Run_string(Probes.Shapes.Row r)
-    {
-        var op = r["ef.operator"]; var data = r["ef.data"]; var cond = r["ef.condition"]; _ = r["shape.wrapped"];
-        var cap = new SqlCap();
-        await using var db = new EfDb(mb => { var eb = mb.Entity<Ent_string>(); eb.ToTable("t"); eb.HasKey(x => x.Id); }, typeKit: true, b => b.AddInterceptors(cap));
-        await db.Context.Database.EnsureCreatedAsync();
-        PStr[] keys = data == "empty" ? [] : data == "one-match" ? [PStr.From("val-a"), PStr.From("val-b"), PStr.From("val-c")] : [PStr.From("val-a"), PStr.From("val-b"), PStr.From("val-b"), PStr.From("val-c")];
-        for (var i = 0; i < keys.Length; i++) db.Context.Add(new Ent_string { Id = i + 1, Key = keys[i] });
-        await db.Context.SaveChangesAsync(); db.Context.ChangeTracker.Clear();
-        var target = PStr.From("val-b");
-        var matching = Enumerable.Range(0, keys.Length).Where(i => keys[i] == target).Select(i => i + 1).ToList();
-        Expression<Func<Ent_string, bool>> held = o => o.Key == target;
-        IQueryable<Ent_string> q = db.Context.Set<Ent_string>().OrderBy(o => o.Id);
-        cap.Sql.Clear();
-        var lam = cond == "lambda";
-        string got = ""; string? thrown = null;
-        try
-        {
-            switch (op)
-            {
-                case "FirstOrNoneAsync": got = Show(lam ? await q.FirstOrNoneAsync(o => o.Key == target) : await q.FirstOrNoneAsync(held)); break;
-                case "FirstOrNone": got = Show(lam ? q.FirstOrNone(o => o.Key == target) : q.FirstOrNone(held)); break;
-                case "SingleOrNoneAsync": got = Show(lam ? await q.SingleOrNoneAsync(o => o.Key == target) : await q.SingleOrNoneAsync(held)); break;
-                case "SingleOrNone": got = Show(lam ? q.SingleOrNone(o => o.Key == target) : q.SingleOrNone(held)); break;
-                case "ElementAtOrNone": got = Show(lam ? q.Where(o => o.Key == target).ElementAtOrNone(1) : q.Where(held).ElementAtOrNone(1)); break;
-                case "FirstOrError":
-                    var res = lam ? q.FirstOrError(o => o.Key == target, ShapeFault.Refused) : q.FirstOrError(held, ShapeFault.Refused);
-                    got = res.Match(x => "ok:" + x.Id, _ => "err"); break;
-                default: throw new ArgumentException(op);
-            }
-        }
-        catch (Exception ex) { thrown = ex.GetType().Name; }
-        return Verify(op, data, got, thrown, matching, cap);
-    }
-    static string Show(Option<Ent_string> o) => o.Match(x => "some:" + x.Id, () => "none");
-}
-public readonly partial record struct PInt : IValue<int>;
-public readonly partial record struct PGuid : IValue<Guid>;
-public readonly partial record struct PStr : IValue<string>;
diff --git a/tools/probe/corpus/probes/E10ReadBackSkipsValidationProbe.cs b/tools/probe/corpus/probes/E10ReadBackSkipsValidationProbe.cs
deleted file mode 100644
index 5daa5fc1..00000000
--- a/tools/probe/corpus/probes/E10ReadBackSkipsValidationProbe.cs
+++ /dev/null
@@ -1,120 +0,0 @@
-// Claim E10-read-back-skips-validation (docs/ef-core.md#reading-back-without-validation): "EF reads a column back without validation, through the value object's Materialize rather than Create." Revalidate() finds the rows today's rules reject.
-// Oracle: claim. A row holding a value the value object's Create refuses (written by a plain-typed twin of the entity into the same table) is read back by EF with UseTypeKit: no exception, .Value is the stored value, Revalidate() is an Error.
-// Obligations (claims.json), both on every row, against the docs page (Baseline.Docs): reads-without-create (the row reads back,
-// .Value as stored) and revalidate-finds (Revalidate() is an Error).
-// Expected: no failure for any row.
-using System.Reflection;
-using Microsoft.EntityFrameworkCore;
-using Probes.Ef;
-using Probes.Shapes;
-namespace Probes;
-public sealed class E10ReadBackSkipsValidationProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("E10ReadBackSkipsValidationProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    static object Refused(string w) => w switch
-    {
-        "string" => "SECRET-7f3a", "int" => -1, "Guid" => Guid.Empty, "decimal" => -1m, "DateTime" => DateTime.MinValue, "Uri" => new Uri("https://example.com/refused"),
-        _ => throw new ArgumentException(w),
-    };
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        var w = r["shape.wrapped"]; var kind = r["shape.kind"]; var mapping = r["ef.mapping"];
-        var e = Probes.Ef3.E3.Find(kind, w);
-        var refused = Refused(w);
-        // the premise: Create refuses this value
-        var create = e.Vo.GetMethod("Create", BindingFlags.Public | BindingFlags.Static, [e.Plain])!;
-        var created = create.Invoke(null, [refused])!;
-        if (created.GetType().GetProperty("State")!.GetValue(created)!.ToString() != "Error") { r.Outcome("harness-error", "Create accepts the supposedly refused value"); return null; }
-        var voEntity = EfModel.Entity(mapping, e.Vo);
-        var plainEntity = EfModel.Entity(mapping, e.Plain);
-        await using var vo = new EfDb(EfModel.Configure(mapping, voEntity, null, false), typeKit: true);
-        Exception? voModel = null, plainModel = null, written = null;
-        try { await vo.Context.Database.EnsureCreatedAsync(); }
-        catch (Exception ex)
-        {
-            voModel = ex;
-            // the wrapped twin's table on its own, to tell a model the framework refuses from one the value object breaks
-            await using var alone = new EfDb(EfModel.Configure(mapping, plainEntity, null, false), typeKit: false);
-            try { await alone.Context.Database.EnsureCreatedAsync(); } catch (Exception pex) { plainModel = pex; }
-        }
-        object? read = null; string? readFailed = null;
-        if (voModel is null)
-        {
-            // a plain-typed twin on the same connection writes the row (nothing validates a plain value)
-            var twinCfg = EfModel.Configure(mapping, plainEntity, p => { if (mapping == "key") p.ValueGenerated = Microsoft.EntityFrameworkCore.Metadata.ValueGenerated.Never; }, false);
-            var twinOpts = new DbContextOptionsBuilder<DynCtx>().UseSqlite(vo.Connection).ReplaceService<Microsoft.EntityFrameworkCore.Infrastructure.IModelCacheKeyFactory, UniqueModelKey>().Options;
-            await using (var twin = new DynCtx(twinOpts, twinCfg))
-            {
-                var row = Activator.CreateInstance(plainEntity)!;
-                if (mapping == "key") { EfX.Set(row, "Id", refused); EfX.Set(row, "Tag", "t"); }
-                else
-                {
-                    EfX.Set(row, "Id", 1);
-                    object? holder = row;
-                    if (mapping is "owned" or "complex") { var prop = mapping == "owned" ? "O" : "C"; holder = EfX.Get(row, prop); }
-                    EfX.Set(holder!, "P", refused);
-                }
-                twin.Add(row);
-                try { await twin.SaveChangesAsync(); } catch (Exception ex) { written = ex; }
-            }
-            if (written is null)
-                try
-                {
-                    var list = EfX.Enumerate(Q.SetOf(vo.Context, voEntity)).ToList();
-                    if (list.Count != 1) readFailed = $"expected 1 row, read {list.Count}";
-                    else read = list[0];
-                }
-                catch (Exception ex) { readFailed = $"reading the row back threw {ex.GetType().Name}: {ex.Message.Split('\n')[0]}"; }
-        }
-        object? vobj = read is null ? null : mapping switch
-        {
-            "key" => EfX.Get(read, "Id"),
-            "owned" => EfX.Get(EfX.Get(read, "O")!, "P"),
-            "complex" => EfX.Get(EfX.Get(read, "C")!, "P"),
-            _ => EfX.Get(read, "P"),
-        };
-        var docs = Baseline.Docs("docs/ef-core.md#reading-back-without-validation");
-        // Where the row could not be written, neither check has anything to read: the model refused (compared with the twin's), or the
-        // twin's write of the refused value (nothing documents why a plain value would be refused).
-        string? Unwritten(Probes.Shapes.Check c, out bool ended)
-        {
-            ended = true;
-            if (voModel is not null) return EfSides.Threw(c, voModel, plainModel, "creating the table", out var refused) ? refused : null;
-            if (written is not null) return c.Inconclusive($"the plain twin could not write the value Create refuses: {written.GetType().Name}: {written.Message.Split('\n')[0]}");
-            ended = false;
-            return null;
-        }
-
-        // reads-without-create: the stored value Create refuses is read back, as it is stored
-        var reads = r.Check("reads-without-create", docs, c =>
-        {
-            var unwritten = Unwritten(c, out var ended);
-            if (ended) return unwritten;
-            if (readFailed is not null) return readFailed;
-            if (vobj is null) return "the value object read back is null";
-            var stored = vobj.GetType().GetProperty("Value")!.GetValue(vobj);
-            if (!Equals(stored, refused)) return $"read-back Value is {stored}, the row holds {refused}";
-            c.Note(NoteKeys.StoredFactoryReadUnvalidated, $"{refused}");
-            return null;
-        });
-        // revalidate-finds: Revalidate() of what was read back is the refusal Create gives today
-        var revalidates = r.Check("revalidate-finds", docs, c =>
-        {
-            var unwritten = Unwritten(c, out var ended);
-            if (ended) return unwritten;
-            if (vobj is null) return c.Inconclusive("nothing was read back to revalidate: " + (readFailed ?? "the value object read back is null"));
-            var reval = vobj.GetType().GetMethod("Revalidate", Type.EmptyTypes);
-            if (reval is null) return "no Revalidate() on " + vobj.GetType().Name;
-            var res = reval.Invoke(vobj, null)!;
-            var state = res.GetType().GetProperty("State")!.GetValue(res)!.ToString();
-            if (state != "Error") return $"Revalidate() of the stored refused value is {state}, expected Error";
-            c.Note(NoteKeys.Compared, "Revalidate() is an Error");
-            return null;
-        });
-        return reads ?? revalidates;
-    }
-}
diff --git a/tools/probe/corpus/probes/E11UseTypeKitOrderProbe.cs b/tools/probe/corpus/probes/E11UseTypeKitOrderProbe.cs
deleted file mode 100644
index df2415f4..00000000
--- a/tools/probe/corpus/probes/E11UseTypeKitOrderProbe.cs
+++ /dev/null
@@ -1,118 +0,0 @@
-// Claim E11-usetypekit-order (src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#setup): "UseTypeKit() adds plugins ... It replaces nothing. So it works alongside a provider ... and it doesn't matter whether you call it before or after UseNpgsql or UseSqlite."
-// Obligation (claims.json): order-does-not-matter, on every row, held to the README's sentence (Baseline.Docs) by the differential below.
-// Oracle: differential between the two orders (and, where a plain type maps the same way, the wrapped type): the model, the CREATE script, the raw stored row and the values read back are equal in every mapping.
-using System.Data.Common;
-using Microsoft.EntityFrameworkCore;
-using Probes.Ef;
-using Probes.Shapes;
-namespace Probes;
-public sealed class E11UseTypeKitOrderProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("E11UseTypeKitOrderProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    static readonly string[] Ws = ["string", "int", "decimal", "Guid", "long"];
-
-    static async Task<string> Raw(EfDb2 db)
-    {
-        await using var cmd = db.Connection.CreateCommand(); cmd.CommandText = "SELECT * FROM t ORDER BY 1";
-        await using DbDataReader rd = await cmd.ExecuteReaderAsync();
-        var lines = new List<string>();
-        while (await rd.ReadAsync()) lines.Add(string.Join("|", Enumerable.Range(0, rd.FieldCount).Select(i => rd.IsDBNull(i) ? "NULL" : rd.GetValue(i).GetType().Name + ":" + Convert.ToString(rd.GetValue(i), System.Globalization.CultureInfo.InvariantCulture))));
-        return string.Join(";", lines);
-    }
-
-    sealed record Out(string Model, string Script, string Raw, string Read);
-
-    /// <summary>One order's model, script, stored row and values; a refusal anywhere on the way is that order's result, compared like the others.</summary>
-    static async Task<Out> Run(string order, string mapping, Type entity, Func<int, object?> value, Action<ModelBuilder> cfg, string? wrapped)
-    {
-        try { return await RunUnguarded(order, mapping, entity, value, cfg, wrapped); }
-        catch (Exception ex) { return new Out($"threw {ex.GetType().Name}: {ex.Message.Split('\n')[0]}", "", "", ""); }
-    }
-
-    static async Task<Out> RunUnguarded(string order, string mapping, Type entity, Func<int, object?> value, Action<ModelBuilder> cfg, string? wrapped)
-    {
-        await using var db = new EfDb2(cfg, order);
-        var model = EfModel.Describe(db.Context);
-        var script = db.Context.Database.GenerateCreateScript();
-        await db.Context.Database.EnsureCreatedAsync();
-        var set = new List<object>();
-        object Mk() => EfX.New(entity);
-        switch (mapping)
-        {
-            case "property" or "closed-set": { var x = Mk(); EfX.Set(x, "P", value(0)); set.Add(x); break; }
-            case "nullable": { var x = Mk(); EfX.Set(x, "P", value(0)); set.Add(x); var y = Mk(); EfX.Set(y, "Id", 2); set.Add(y); break; }
-            case "key": { var x = Mk(); EfX.Set(x, "Id", value(0)); EfX.Set(x, "Tag", "a"); set.Add(x); var y = Mk(); EfX.Set(y, "Id", value(1)); EfX.Set(y, "Tag", "b"); set.Add(y); break; }
-            case "integer-key": { set.Add(Mk()); set.Add(Mk()); break; }
-            case "owned" or "complex":
-            {
-                var x = Mk(); var prop = mapping == "owned" ? "O" : "C"; var own = EfX.Get(x, prop)!; EfX.Set(own, "P", value(0)); set.Add(x); break;
-            }
-        }
-        foreach (var x in set) db.Context.Add(x);
-        await db.Context.SaveChangesAsync();
-        db.Context.ChangeTracker.Clear();
-        var raw = await Raw(db);
-        var read = string.Join(";", EfX.Enumerate(Q.SetOf(db.Context, entity)).Select(x => mapping switch
-        {
-            "property" or "nullable" or "closed-set" => EfX.Plainify(EfX.Get(x, "P")) + "/" + EfX.Plainify(EfX.Get(x, "Id")),
-            "key" => EfX.Plainify(EfX.Get(x, "Id")) + "/" + EfX.Get(x, "Tag"),
-            "integer-key" => EfX.Plainify(EfX.Get(x, "Id")),
-            _ => EfX.Plainify(EfX.Get(EfX.Get(x, mapping == "owned" ? "O" : "C")!, "P")),
-        }).OrderBy(s => s, StringComparer.Ordinal));
-        return new Out(model, script, raw, read);
-    }
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        return await r.Check("order-does-not-matter", Baseline.Docs("src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#setup"), async c =>
-        {
-            var mapping = r["ef.mapping"]; var order = r["ef.order"];
-            var other = order == "before-provider" ? "after-provider" : "before-provider";
-            string w = mapping switch { "integer-key" => r.Index % 2 == 0 ? "int" : "long", "key" => r.Index % 2 == 0 ? "Guid" : "string", "closed-set" => "-", _ => Ws[r.Index % Ws.Length] };
-            Out a, b; Out? plain = null;
-            if (mapping == "closed-set")
-            {
-                var entity = typeof(EntP<PSet>);
-                Action<ModelBuilder> cfg = mb => { var eb = mb.Entity(entity); eb.ToTable("t"); eb.HasKey("Id"); };
-                a = await Run(order, mapping, entity, _ => PSet.Beta, cfg, null);
-                b = await Run(other, mapping, entity, _ => PSet.Beta, cfg, null);
-                if (!a.Raw.Contains("String:Beta")) return "closed set not stored as its name text: " + a.Raw;
-            }
-            else
-            {
-                var kind = EfX.Kinds[r.Index % EfX.Kinds.Length];
-                var e = mapping is "key" or "integer-key" ? KeyRegistry.All.First(x => x.Kind == kind && x.Wrapped == w) : EfX.Top(kind, w);
-                var map = mapping == "integer-key" ? "key" : mapping;
-                var entity = EfModel.Entity(map, e.Vo);
-                var cfg = EfModel.Configure(map, entity, null, false);
-                Func<int, object?> value = i => e.MakeVo(EfX.Sample(w, i));
-                a = await Run(order, mapping, entity, value, cfg, w);
-                b = await Run(other, mapping, entity, value, cfg, w);
-                if (mapping is "property" or "nullable" or "owned" or "complex")
-                {
-                    var pe = EfModel.Entity(map, e.Plain);
-                    plain = await Run("none", mapping, pe, i => EfX.Sample(w, i), EfModel.Configure(map, pe, null, false), w);
-                }
-                else if (mapping == "integer-key")
-                {
-                    var ids = a.Read.Split(';');
-                    if (ids.Distinct().Count() != 2 || ids.Any(x => x is "0" or "")) return "integer key not generated after " + order + ": " + a.Read;
-                }
-            }
-            if (a.Model != b.Model) return $"model differs between {order} and {other}: " + EfModel.FirstDiff(a.Model, b.Model);
-            if (a.Model.StartsWith("threw ", StringComparison.Ordinal)) return $"the value object's entity is refused in both orders: {a.Model}";
-            if (a.Script != b.Script) return $"create script differs between {order} and {other}: " + EfModel.FirstDiff(a.Script, b.Script);
-            if (a.Raw != b.Raw) return $"stored row differs between {order} and {other}: {a.Raw} | {b.Raw}";
-            if (a.Read != b.Read) return $"values read differ between {order} and {other}: {a.Read} | {b.Read}";
-            if (plain is not null)
-            {
-                if (a.Model != plain.Model) return "model differs from the wrapped type's: " + EfModel.FirstDiff(a.Model, plain.Model);
-                if (a.Raw != plain.Raw) return $"stored row differs from the wrapped type's: {a.Raw} | {plain.Raw}";
-            }
-            return null;
-        });
-    }
-}
diff --git a/tools/probe/corpus/probes/E12ConventionByTypeProbe.cs b/tools/probe/corpus/probes/E12ConventionByTypeProbe.cs
deleted file mode 100644
index 0c2581b9..00000000
--- a/tools/probe/corpus/probes/E12ConventionByTypeProbe.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-// Claim E12-convention-by-vo-type (src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#model-wide-conventions-follow-the-propertys-type): "EF applies ConfigureConventions by CLR type. So Properties<decimal>().HavePrecision(18, 2) reaches decimal properties, and not an Amount that wraps one. Configure the value object instead: Properties<Amount>().HavePrecision(18, 2)."
-// Obligations (claims.json), one per row by ef.convention-type: value-object-type-reaches (value-object), against the same convention on
-// the wrapped type and a plain property (Baseline.Twin); underlying-type-does-not-reach (underlying), against the README (Baseline.Docs).
-// Oracle: differential + claim. A convention on the value object type reaches the value object's property exactly as the same convention on the wrapped type reaches a plain property; a convention on the wrapped type does not reach the value object's property (its model equals the model without the convention) while it does reach the plain one.
-using Microsoft.EntityFrameworkCore;
-using Probes.Ef;
-using Probes.Shapes;
-namespace Probes;
-public sealed class E12ConventionByTypeProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("E12ConventionByTypeProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    static string PLine(EfDb2 db) => EfModel.Describe(db.Context).Split('\n').First(l => l.StartsWith("t.P: "));
-
-    static Action<ModelConfigurationBuilder> Conv(string facet, Type target, string w) => cb =>
-    {
-        var pb = cb.Properties(target);
-        switch (facet)
-        {
-            case "HaveMaxLength": pb.HaveMaxLength(5); break;
-            case "HavePrecision": pb.HavePrecision(18, 2); break;
-            case "HaveColumnType": pb.HaveColumnType(EfModel.ColumnTypes[w]); break;
-        }
-    };
-
-    static async Task<string> Line(Type t, string order, Action<ModelConfigurationBuilder>? conv)
-    {
-        var entity = typeof(EntP<>).MakeGenericType(t);
-        await using var db = new EfDb2(mb => { var eb = mb.Entity(entity); eb.ToTable("t"); eb.HasKey("Id"); }, order, conv);
-        return PLine(db);
-    }
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        var facet = r["ef.convention"]; var ct = r["ef.convention-type"]; var w = r["shape.wrapped"];
-        var e = EfX.Top(EfX.Kinds[r.Index % EfX.Kinds.Length], w);
-        var plainNone = await Line(e.Plain, "none", null);
-        var plainConv = await Line(e.Plain, "none", Conv(facet, e.Plain, w));
-        if (plainConv == plainNone)
-        {
-            // the facet changes nothing on the wrapped type's own property (HavePrecision on a string): it cannot show anything on the value object either
-            var fallback = w is "string" or "Uri" ? "HaveMaxLength" : w == "decimal" ? "HavePrecision" : "HaveColumnType";
-            r.Substituted("ef.convention", fallback, $"{facet} has no effect on a plain {w} property");
-            facet = fallback;
-            plainConv = await Line(e.Plain, "none", Conv(facet, e.Plain, w));
-        }
-        var underlying = ct == "underlying";
-        // value-object-type-reaches: as the same convention on the wrapped type reaches a plain property (the twin);
-        // underlying-type-does-not-reach: the README's "reaches `decimal` properties, and not an `Amount` that wraps one"
-        return await r.Check(underlying ? "underlying-type-does-not-reach" : "value-object-type-reaches",
-            underlying ? Baseline.Docs("src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#model-wide-conventions-follow-the-propertys-type") : Baseline.Twin, async c =>
-        {
-            if (plainConv == plainNone) return c.Inconclusive($"{facet} changes nothing on a plain {w} property either, so there is nothing to compare");
-            var voNone = await Line(e.Vo, "after-provider", null);
-            if (underlying)
-            {
-                var reached = await Line(e.Vo, "after-provider", Conv(facet, e.Plain, w));
-                if (reached != voNone) return $"a convention on {w} reached the value object's property: {reached} (without it: {voNone}); the plain property got {plainConv}";
-                c.Note(NoteKeys.Compared, $"{facet} on {w} reaches the plain property ({plainConv}), not the value object's ({reached})");
-                return null;
-            }
-            var voConv = await Line(e.Vo, "after-provider", Conv(facet, e.Vo, w));
-            if (voConv == voNone) return $"a convention on the value object type {e.Vo.Name} did not reach its property: {voConv}";
-            if (voConv != plainConv) return $"the convention on the value object gave {voConv}; on the plain {w} {plainConv}";
-            c.Note(NoteKeys.Compared, voConv);
-            return null;
-        });
-    }
-}
diff --git a/tools/probe/corpus/probes/E13PrimitiveCollectionProbe.cs b/tools/probe/corpus/probes/E13PrimitiveCollectionProbe.cs
deleted file mode 100644
index 342ac09e..00000000
--- a/tools/probe/corpus/probes/E13PrimitiveCollectionProbe.cs
+++ /dev/null
@@ -1,89 +0,0 @@
-// Claim E13-primitive-collections (README#queries): "db.Orders.Where(o => o.Tags.Contains(tag)); db.Orders.Where(o => o.Tags.Any(t => t.Value == "x"));" over a List<ValueObject> primitive collection.
-// Obligations (claims.json), one per row by ef.query, against the ids memory computes (Baseline.Model): element-value (any-value-equals,
-// "db.Orders.Where(o => o.Tags.Any(t => t.Value == "x"));") and contains ("db.Orders.Where(o => o.Tags.Contains(tag));").
-// Oracle: claim plus differential. The ids the query returns equal the ids whose collection holds the value (ground truth computed in memory), and equal what the same query returns over List<wrapped type>.
-using System.Linq.Expressions;
-using Microsoft.EntityFrameworkCore;
-using Probes.Ef;
-using Probes.Shapes;
-namespace Probes;
-public sealed class E13PrimitiveCollectionProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("E13PrimitiveCollectionProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        var w = r["shape.wrapped"]; var qk = r["ef.query"];
-        var kind = EfX.Kinds[r.Index % 2];   // record-struct and sealed-record-class: a validated kind's rule may refuse a sample
-        var e = EfX.Top(kind, w);
-        int[][] data = [[0, 1], [1, 2], [2], []];
-        var needles = new[] { 0, 1, 2, 3 };   // 3 is in no collection
-
-        async Task<(string res, string? err)> Side(bool vo)
-        {
-            var el = vo ? e.Vo : e.Plain;
-            var entity = typeof(EntL<>).MakeGenericType(el);
-            object Make(int i) { var p = EfX.Sample(w, i); return vo ? e.MakeVo(p) : p; }
-            Action<Microsoft.EntityFrameworkCore.ModelBuilder> cfg = mb => { var eb = mb.Entity(entity); eb.ToTable("t"); eb.HasKey("Id"); };
-            await using var db = new EfDb(cfg, typeKit: vo);
-            try
-            {
-                await db.Context.Database.EnsureCreatedAsync();
-                for (var i = 0; i < data.Length; i++)
-                {
-                    var ent = EfX.New(entity); EfX.Set(ent, "Id", i + 1);
-                    var list = EfX.Get(ent, "Items")!;
-                    foreach (var k in data[i]) list.GetType().GetMethod("Add")!.Invoke(list, [Make(k)]);
-                    db.Context.Add(ent);
-                }
-                await db.Context.SaveChangesAsync(); db.Context.ChangeTracker.Clear();
-                var lines = new List<string>();
-                foreach (var n in needles)
-                {
-                    var p = Expression.Parameter(entity, "e");
-                    var items = Expression.Property(p, "Items");
-                    Expression body;
-                    if (qk == "contains")
-                    {
-                        var box = Expression.Constant(Q.NewBox(el, Make(n)));
-                        body = Expression.Call(items, typeof(List<>).MakeGenericType(el).GetMethod("Contains")!, Expression.Field(box, "Value"));
-                    }
-                    else
-                    {
-                        var t = Expression.Parameter(el, "t");
-                        var plainBox = Expression.Constant(Q.NewBox(e.Plain, EfX.Sample(w, n)));
-                        var lhs = vo ? Expression.Property(t, "Value") : (Expression)t;
-                        var inner = Expression.Lambda(Expression.Equal(lhs, Expression.Field(plainBox, "Value")), t);
-                        var any = typeof(Enumerable).GetMethods().First(m => m.Name == "Any" && m.GetParameters().Length == 2).MakeGenericMethod(el);
-                        body = Expression.Call(any, items, inner);
-                    }
-                    var q = Q.Call("Where", [entity], Q.SetOf(db.Context, entity), Expression.Lambda(body, p));
-                    lines.Add($"{n}:" + string.Join(",", EfX.Enumerate(q).Select(x => (int)EfX.Get(x, "Id")!).OrderBy(x => x)));
-                    db.Context.ChangeTracker.Clear();
-                }
-                return (string.Join(" ", lines), null);
-            }
-            catch (Exception ex) { return ("", ex.GetType().Name + ": " + ex.Message.Split('\n')[0]); }
-        }
-        var truth = string.Join(" ", needles.Select(n => $"{n}:" + string.Join(",", Enumerable.Range(0, data.Length).Where(i => data[i].Contains(n)).Select(i => i + 1))));
-        var v = await Side(true);
-        // element-value (Any over .Value) and contains (Contains of a value object): the ids memory finds in the same collections
-        return await r.Check(qk == "contains" ? "contains" : "element-value", Baseline.Model, async c =>
-        {
-            if (v.err is null)
-            {
-                if (v.res != truth) return $"{qk} returned [{v.res}], the collections hold [{truth}]";
-                c.Note(NoteKeys.Compared, truth);
-                return null;
-            }
-            // the value object's query failed: the same query over List<wrapped type> tells the framework's refusal from the value object's
-            var p = await Side(false);
-            if (p.err is null) return $"{qk} over List<{w} value object> threw ({v.err}) where List<{w}> returned [{p.res}]";
-            return v.err.Split(':')[0] == p.err.Split(':')[0]
-                ? c.Inconclusive($"both sides refuse {qk} alike: {v.err}")
-                : $"{qk}: the value object's side threw {v.err}, the wrapped type's {p.err}";
-        });
-    }
-}
diff --git a/tools/probe/corpus/probes/E14InheritanceKeyProbe.cs b/tools/probe/corpus/probes/E14InheritanceKeyProbe.cs
deleted file mode 100644
index e30500c5..00000000
--- a/tools/probe/corpus/probes/E14InheritanceKeyProbe.cs
+++ /dev/null
@@ -1,95 +0,0 @@
-// Claim E14-inheritance-key-generation (README#keys): "The root of an inheritance hierarchy follows the same rules under TPH and TPT. Under TPC, as for an int key, the key is generated only where the provider numbers the whole hierarchy from a sequence (PostgreSQL, SQL Server) ... SQLite has no such sequence, so there you assign it." Key over Guid: yours to assign.
-// Oracle: differential against the same hierarchy keyed by the wrapped type (default keys on two leaf types, SaveChanges, the keys read back; an int/long key over TPH/TPT must be generated, distinct and non-zero),
-// plus the claim for assigned keys (obligations tph-tpt-root for TPH and TPT, tpc-assign-on-sqlite for TPC, Baseline.Twin): every hierarchy round-trips assigned keys polymorphically, and a Guid key is never generated by default.
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Metadata.Builders;
-using Probes.Ef;
-using Probes.Shapes;
-namespace Probes;
-public sealed class E14InheritanceKeyProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("E14InheritanceKeyProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    static Action<Microsoft.EntityFrameworkCore.ModelBuilder> Cfg(string strategy, Type root, Type a, Type b) => mb =>
-    {
-        var rb = mb.Entity(root); rb.HasKey("Id");
-        var ab = mb.Entity(a); var bb = mb.Entity(b);
-        switch (strategy)
-        {
-            case "TPH": rb.ToTable("root"); break;
-            case "TPT": rb.UseTptMappingStrategy(); rb.ToTable("root"); ab.ToTable("leafa"); bb.ToTable("leafb"); break;
-            case "TPC": rb.UseTpcMappingStrategy(); ab.ToTable("leafa"); bb.ToTable("leafb"); break;
-        }
-    };
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        // tph-tpt-root (TPH, TPT) and tpc-assign-on-sqlite (TPC), each against the same hierarchy keyed by the wrapped type
-        return await r.Check(r["ef.inheritance"] == "TPC" ? "tpc-assign-on-sqlite" : "tph-tpt-root", Baseline.Twin, async c =>
-        {
-            var w = r["shape.wrapped"]; var strategy = r["ef.inheritance"];
-            var kind = EfX.Kinds[r.Index % EfX.Kinds.Length];
-            var e = KeyRegistry.All.First(x => x.Kind == kind && x.Wrapped == w);
-
-            // phase A: default keys on one leaf of each type
-            async Task<string> Default(bool vo)
-            {
-                var kt = vo ? e.Vo : e.Plain;
-                Type root = typeof(RootE<>).MakeGenericType(kt), a = typeof(LeafA<>).MakeGenericType(kt), b = typeof(LeafB<>).MakeGenericType(kt);
-                await using var db = new EfDb(Cfg(strategy, root, a, b), typeKit: vo);
-                try
-                {
-                    await db.Context.Database.EnsureCreatedAsync();
-                    var gen = db.Context.Model.FindEntityType(root)!.FindProperty("Id")!.ValueGenerated;
-                    var items = new[] { EfX.New(a), EfX.New(b), EfX.New(a) };
-                    foreach (var x in items) db.Context.Add(x);
-                    await db.Context.SaveChangesAsync();
-                    return $"gen={gen} keys=[" + string.Join(",", items.Select(x => EfX.Plainify(EfX.Get(x, "Id")))) + "]";
-                }
-                catch (Exception ex) { return "threw:" + ex.GetType().Name; }
-            }
-            // phase B: assigned keys, polymorphic read back
-            async Task<string> Assigned(bool vo)
-            {
-                var kt = vo ? e.Vo : e.Plain;
-                Type root = typeof(RootE<>).MakeGenericType(kt), a = typeof(LeafA<>).MakeGenericType(kt), b = typeof(LeafB<>).MakeGenericType(kt);
-                await using var db = new EfDb(Cfg(strategy, root, a, b), typeKit: vo);
-                await db.Context.Database.EnsureCreatedAsync();
-                object K(int i) { var p = EfX.Sample(w, i); return vo ? e.MakeVo(p) : p; }
-                var items = new[] { (a, 0, "a0"), (b, 1, "b1"), (a, 2, "a2") };
-                foreach (var (t, i, name) in items) { var x = EfX.New(t); EfX.Set(x, "Id", K(i)); EfX.Set(x, "Name", name); db.Context.Add(x); }
-                await db.Context.SaveChangesAsync();
-                db.Context.ChangeTracker.Clear();
-                var all = EfX.Enumerate(Q.SetOf(db.Context, root)).Select(x => $"{x.GetType().Name.Split('`')[0]}:{EfX.Get(x, "Name")}:{EfX.Plainify(EfX.Get(x, "Id"))}").OrderBy(s => s, StringComparer.Ordinal);
-                db.Context.ChangeTracker.Clear();
-                var found = await db.Context.FindAsync(root, K(1));
-                return string.Join(",", all) + " find1=" + (found is null ? "null" : (string)EfX.Get(found, "Name")!);
-            }
-
-            var vA = await Default(true);
-            var vB = await Assigned(true);
-            var pB = await Assigned(false);
-            if (vB != pB) return $"assigned keys differ from the plain hierarchy: VO {vB} | plain {pB}";
-            if (!vB.Contains("find1=b1")) return "Find by the assigned key failed: " + vB;
-
-            if (w == "Guid")
-            {
-                // documented: yours to assign, never generated by default (EF generates a plain Guid key; TypeKit's is Never): not-promised guid-key-not-generated
-                if (!vA.StartsWith("gen=Never") && !vA.StartsWith("threw")) return "Guid key under " + strategy + " is not 'yours to assign': " + vA;
-                return null;
-            }
-            var pA = await Default(false);
-            if (vA != pA) return $"default keys differ from the plain hierarchy under {strategy}: VO {vA} | plain {pA}";
-            if (strategy is "TPH" or "TPT")
-            {
-                // documented: the root of a TPH or TPT hierarchy is generated
-                var keys = vA.Substring(vA.IndexOf('[') + 1).TrimEnd(']').Split(',');
-                if (!vA.StartsWith("gen=OnAdd") || keys.Distinct().Count() != 3 || keys.Any(k => k is "0" or "")) return $"{strategy} root key is not generated on add: {vA}";
-            }
-            else r.Note(NoteKeys.TpcSqliteNoSequenceAssignChecked);
-            return null;
-        });
-    }
-}
diff --git a/tools/probe/corpus/probes/E15CompositeKeyProbe.cs b/tools/probe/corpus/probes/E15CompositeKeyProbe.cs
deleted file mode 100644
index a6e1a5d2..00000000
--- a/tools/probe/corpus/probes/E15CompositeKeyProbe.cs
+++ /dev/null
@@ -1,95 +0,0 @@
-// Claim E15-composite-key (docs/ef-core.md#keys): "A composite key of value objects is HasKey(x => new { x.Order, x.Line }), as for primitives."
-// Obligation (claims.json): as-for-primitives, on every row, against the composite key over the wrapped types (Baseline.Twin).
-// Oracle: differential against the same composite key declared over the wrapped types: same model description (key, column types, generation),
-// same Find / equality-query / ordered results, same refusal of a duplicate key; and the claim's own ground truth for the lookups.
-using System.Linq.Expressions;
-using Microsoft.EntityFrameworkCore;
-using Probes.Ef;
-using Probes.Shapes;
-namespace Probes;
-public sealed class E15CompositeKeyProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("E15CompositeKeyProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        return await r.Check("as-for-primitives", Baseline.Twin, async c =>
-        {
-            var w = r["shape.wrapped"];
-            var first = r["ef.key-position"] == "first";
-            var kind = EfX.Kinds[r.Index % EfX.Kinds.Length];
-            var ew = KeyRegistry.All.First(x => x.Kind == kind && x.Wrapped == w);
-            var ei = KeyRegistry.All.First(x => x.Kind == kind && x.Wrapped == "int");
-            // the wrapped-type key under test sits at the requested position; the other element is a value object over int (a "Line")
-            object WPlain(int i) => EfX.Sample(w, i);
-            object IPlain(int i) => 1 + i;
-
-            async Task<(string desc, string truth)> Side(bool vo)
-            {
-                Type tw = vo ? ew.Vo : ew.Plain, ti = vo ? ei.Vo : ei.Plain;
-                var (ta, tb) = first ? (tw, ti) : (ti, tw);
-                var entity = typeof(EntComp<,>).MakeGenericType(ta, tb);
-                object W(int i) => vo ? ew.MakeVo(WPlain(i)) : WPlain(i);
-                object I(int i) => vo ? ei.MakeVo(IPlain(i)) : IPlain(i);
-                (object a, object b) Key(int wi, int ii) => first ? (W(wi), I(ii)) : (I(ii), W(wi));
-                Action<Microsoft.EntityFrameworkCore.ModelBuilder> cfg = mb =>
-                {
-                    var eb = mb.Entity(entity); eb.ToTable("t"); eb.HasKey("A", "B");
-                };
-                await using var db = new EfDb(cfg, typeKit: vo);
-                await db.Context.Database.EnsureCreatedAsync();
-                var model = EfModel.Describe(db.Context);
-                var pk = string.Join(",", db.Context.Model.FindEntityType(entity)!.FindPrimaryKey()!.Properties.Select(p => p.Name));
-                (int wi, int ii)[] seeds = [(0, 0), (0, 1), (1, 0)];
-                foreach (var (wi, ii) in seeds)
-                {
-                    var e = EfX.New(entity); var (a, b) = Key(wi, ii);
-                    EfX.Set(e, "A", a); EfX.Set(e, "B", b); EfX.Set(e, "Tag", $"t{wi}{ii}");
-                    db.Context.Add(e);
-                }
-                await db.Context.SaveChangesAsync();
-                db.Context.ChangeTracker.Clear();
-                var lines = new List<string> { "pk=" + pk, model };
-                // Find by the whole key
-                foreach (var (wi, ii) in new[] { (0, 0), (0, 1), (1, 0), (1, 1) })
-                {
-                    var (a, b) = Key(wi, ii);
-                    var found = await db.Context.FindAsync(entity, a, b);
-                    lines.Add($"find{wi}{ii}=" + (found is null ? "null" : EfX.Get(found, "Tag")));
-                    db.Context.ChangeTracker.Clear();
-                }
-                // equality query on the first key column, and on the second
-                foreach (var col in new[] { "A", "B" })
-                {
-                    var (a, b) = Key(0, 0);
-                    var box = Expression.Constant(Q.NewBox(col == "A" ? ta : tb, col == "A" ? a : b));
-                    var p = Expression.Parameter(entity, "e");
-                    var pred = Expression.Equal(Expression.Property(p, col), Expression.Field(box, "Value"));
-                    var q = Q.Call("Where", [entity], Q.SetOf(db.Context, entity), Expression.Lambda(pred, p));
-                    lines.Add($"where{col}=" + string.Join("|", EfX.Enumerate(q).Select(x => (string)EfX.Get(x, "Tag")!).OrderBy(x => x, StringComparer.Ordinal)));
-                }
-                db.Context.ChangeTracker.Clear();
-                // a duplicate whole key is refused
-                var dup = EfX.New(entity); var (da, dbk) = Key(0, 1);
-                EfX.Set(dup, "A", da); EfX.Set(dup, "B", dbk); EfX.Set(dup, "Tag", "dup");
-                db.Context.Add(dup);
-                try { await db.Context.SaveChangesAsync(); lines.Add("dup=accepted"); } catch (Exception ex) { lines.Add("dup=" + ex.GetType().Name); }
-                db.Context.ChangeTracker.Clear();
-                var all = string.Join(",", EfX.Enumerate(Q.SetOf(db.Context, entity)).Select(x => (string)EfX.Get(x, "Tag")!).OrderBy(x => x, StringComparer.Ordinal));
-                lines.Add("rows=" + all);
-                var truth = string.Join(";", lines.Where(l => l.StartsWith("find") || l.StartsWith("where") || l.StartsWith("dup") || l.StartsWith("rows")));
-                return (string.Join("\n", lines), truth);
-            }
-            var v = await Side(true);
-            var p = await Side(false);
-            const string Expected = "find00=t00;find01=t01;find10=t10;find11=null;whereA=t00|t01;whereB=t00|t10;dup=DbUpdateException;rows=t00,t01,t10";
-            // whereA/whereB depend on the position: A is the first key element
-            var expected = first ? Expected : Expected.Replace("whereA=t00|t01;whereB=t00|t10", "whereA=t00|t10;whereB=t00|t01");
-            if (v.truth != expected) return $"VO side: {v.truth}; expected {expected}";
-            if (v.desc != p.desc) return "model/results differ from the plain composite key: " + EfModel.FirstDiff(v.desc, p.desc);
-            return null;
-        });
-    }
-}
diff --git a/tools/probe/corpus/probes/E16OwnConfigurationWinsProbe.cs b/tools/probe/corpus/probes/E16OwnConfigurationWinsProbe.cs
deleted file mode 100644
index 5fba4b73..00000000
--- a/tools/probe/corpus/probes/E16OwnConfigurationWinsProbe.cs
+++ /dev/null
@@ -1,169 +0,0 @@
-// Claim E16-own-configuration-wins (src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#keys): "A configuration you write yourself always wins over these defaults." (the key defaults: generated on add for an integer, never for char and Guid)
-// Obligations (claims.json), one per row by ef.config, against the wrapped twin (Baseline.Twin): never, on-add, column-type, conversion, optional.
-// Oracle: differential against the same key declared with the wrapped type under the same configuration, plus the claim itself: ValueGeneratedNever / ValueGeneratedOnAdd are what the model says; HasConversion stores what the application's converter writes;
-// HasColumnType is the column's type; IsRequired(false) is refused for a key as for a plain key, and on a non-key property of the same value object makes the column nullable and null round-trips.
-using Microsoft.EntityFrameworkCore;
-using Probes.Ef;
-using Probes.Shapes;
-namespace Probes;
-public sealed class E16OwnConfigurationWinsProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("E16OwnConfigurationWinsProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, Check);
-
-    static object Sample(string w, int i) => w == "char" ? (char)('a' + i) : EfX.Sample(w, i);
-    static string Norm(object? k)
-    {
-        if (k is not null && k.GetType().Namespace == "Probes.Ef") k = k.GetType().GetProperty("Value")!.GetValue(k);
-        return k switch { null => "null", Guid g => g == Guid.Empty ? "empty" : "guid", string s when Guid.TryParse(s, out _) => "guid", _ => Convert.ToString(k, System.Globalization.CultureInfo.InvariantCulture)! };
-    }
-
-    sealed record Res(string Model, string Script, string DefaultAdd, string Assigned, string Raw);
-
-    static async Task<Res> Side(EfEntry e, bool vo, string config)
-    {
-        var w = e.Wrapped;
-        var kt = vo ? e.Vo : e.Plain;
-        var entity = typeof(EntK<>).MakeGenericType(kt);
-        string err = "";
-        Action<ModelBuilder> cfg = mb =>
-        {
-            var eb = mb.Entity(entity); eb.ToTable("t"); eb.HasKey("Id");
-            var pb = eb.Property("Id");
-            try
-            {
-                switch (config)
-                {
-                    case "ValueGeneratedNever": pb.ValueGeneratedNever(); break;
-                    case "ValueGeneratedOnAdd": pb.ValueGeneratedOnAdd(); break;
-                    case "HasColumnType": pb.HasColumnType(EfModel.ColumnTypes[w]); break;
-                    case "HasConversion": pb.HasConversion(OwnConvs.Setup(e, vo)); break;
-                    case "IsRequired-false": pb.IsRequired(false); break;
-                }
-            }
-            catch (Exception ex) { err = "threw-in-config:" + ex.GetType().Name; }
-        };
-        async Task<string> Safe(Func<Task<string>> f) { try { return await f(); } catch (Exception ex) { return "threw:" + ex.GetType().Name; } }
-        string model = "", script = "";
-        try
-        {
-            await using var d0 = new EfDb2(cfg, vo ? "after-provider" : "none");
-            model = EfModel.Describe(d0.Context); script = d0.Context.Database.GenerateCreateScript();
-        }
-        catch (Exception ex) { return new Res("threw:" + ex.GetType().Name, err, err, err, err); }
-        if (err != "") return new Res(err, err, err, err, err);
-        var def = await Safe(async () =>
-        {
-            await using var db = new EfDb2(cfg, vo ? "after-provider" : "none");
-            await db.Context.Database.EnsureCreatedAsync();
-            var rows = new[] { Activator.CreateInstance(entity)!, Activator.CreateInstance(entity)! };
-            foreach (var x in rows) db.Context.Add(x);
-            await db.Context.SaveChangesAsync();
-            return "keys=[" + string.Join(",", rows.Select(x => Norm(EfX.Get(x, "Id")))) + "]";
-        });
-        string raw = "";
-        var assigned = await Safe(async () =>
-        {
-            await using var db = new EfDb2(cfg, vo ? "after-provider" : "none");
-            await db.Context.Database.EnsureCreatedAsync();
-            object K(int i) { var p = Sample(w, i); return vo ? e.MakeVo(p) : p; }
-            foreach (var i in new[] { 0, 1 }) { var x = EfX.New(entity); EfX.Set(x, "Id", K(i)); EfX.Set(x, "Tag", "t" + i); db.Context.Add(x); }
-            await db.Context.SaveChangesAsync();
-            db.Context.ChangeTracker.Clear();
-            raw = await EfX2.RawScalar(db.Connection, "SELECT group_concat(Id, ',') FROM (SELECT Id FROM t ORDER BY Tag)") ?? "null";
-            var read = EfX.Enumerate(Q.SetOf(db.Context, entity)).Select(x => Norm(EfX.Get(x, "Id")) + "/" + EfX.Get(x, "Tag")).OrderBy(s => s, StringComparer.Ordinal);
-            db.Context.ChangeTracker.Clear();
-            var found = await db.Context.FindAsync(entity, K(1));
-            return string.Join(",", read) + " find1=" + (found is null ? "null" : (string)EfX.Get(found, "Tag")!);
-        });
-        return new Res(model, script, def, assigned, raw);
-    }
-
-    // where it throws (the table, or the second insert) is EF's and SQLite's; that it can or cannot generate is the outcome
-    static string Kind(string s) => s.StartsWith("threw") ? "threw" : s;
-    static string StripScript(string s) => s.Replace(" AUTOINCREMENT", "");
-
-    static async Task<string?> Check(Probes.Shapes.Row r)
-    {
-        var config = r["ef.config"]; var w = r["shape.wrapped"];
-        var kind = EfX.Kinds[r.Index % EfX.Kinds.Length];
-        var e = KeyRegistry.All.First(x => x.Kind == kind && x.Wrapped == w);
-        var v = await Side(e, true, config);
-        var p = await Side(e, false, config);
-        var obligation = config switch
-        {
-            "ValueGeneratedNever" => "never", "ValueGeneratedOnAdd" => "on-add", "HasColumnType" => "column-type", "HasConversion" => "conversion",
-            _ => "optional",
-        };
-        // each configuration's obligation, against the same key declared with the wrapped type under the same configuration
-        return await r.Check(obligation, Baseline.Twin, async c =>
-        {
-            if (config == "IsRequired-false")
-            {
-                // the key attempt: EF refuses an optional key, and must refuse the same way for the value object
-                if (v.Model.StartsWith("threw") != p.Model.StartsWith("threw")) return $"IsRequired(false) on a key: VO {v.Model.Split('\n')[0]} | plain {p.Model.Split('\n')[0]}";
-                if (v.Model.StartsWith("threw") && v.Model != p.Model) return $"IsRequired(false) on a key is refused differently: VO {v.Model} | plain {p.Model}";
-                return await OptionalProperty(r, w);
-            }
-
-            if (v.Model.StartsWith("threw") || p.Model.StartsWith("threw"))
-            {
-                if (v.Model == p.Model) return c.Inconclusive("both refuse the model alike: " + v.Model);
-                return $"model refused for one side only: VO {v.Model} | plain {p.Model}";
-            }
-            // the claim: the configuration is what the model says
-            if (config == "ValueGeneratedNever" && !v.Model.Contains("pk=True gen=Never")) return "ValueGeneratedNever not kept: " + v.Model;
-            if (config == "ValueGeneratedOnAdd" && !v.Model.Contains("pk=True gen=OnAdd")) return "ValueGeneratedOnAdd not kept: " + v.Model;
-            if (config == "HasColumnType" && !v.Model.Contains("type=" + EfModel.ColumnTypes[w])) return $"HasColumnType({EfModel.ColumnTypes[w]}) not kept: " + v.Model;
-            if (config == "HasConversion")
-            {
-                if (!v.Model.Contains("type=TEXT")) return "HasConversion to text: the column is not text: " + v.Model;
-                var expect = "C:" + OwnConv<int>.Fmt(Sample(w, 0)) + ",C:" + OwnConv<int>.Fmt(Sample(w, 1));
-                if (v.Raw != expect) return $"stored values are not the application's converter output: {v.Raw}, expected {expect}";
-            }
-            var vm = v.Model; var pm = p.Model;
-            if (config is "HasColumnType" or "HasConversion") { vm = vm.Replace("gen=Never", "gen=*").Replace("gen=OnAdd", "gen=*"); pm = pm.Replace("gen=Never", "gen=*").Replace("gen=OnAdd", "gen=*"); r.Note(NoteKeys.DocumentedCharGuidDefaultGenerationNormalized, "not-promised char-key-not-generated, guid-key-not-generated"); }
-            if (vm != pm) return "model differs from the wrapped type's: " + EfModel.FirstDiff(vm, pm);
-            if (StripScript(v.Script) != StripScript(p.Script)) return "create script differs from the wrapped type's: " + EfModel.FirstDiff(StripScript(v.Script), StripScript(p.Script));
-            if (p.Assigned.StartsWith("threw") && !v.Assigned.StartsWith("threw"))
-            {
-                // the wrapped type's own key fails on SQLite (EF writes AUTOINCREMENT on a BIGINT / TEXT key): the value object's must still do what it was configured to
-                var expectRead = Norm(Sample(w, 0)) + "/t0," + Norm(Sample(w, 1)) + "/t1 find1=t1";
-                var sorted = string.Join(",", expectRead.Split(" find1=")[0].Split(',').OrderBy(x => x, StringComparer.Ordinal)) + " find1=t1";
-                if (v.Assigned != sorted) return $"assigned keys read back as {v.Assigned}, expected {sorted} (the plain key threw: {p.Assigned})";
-                r.Note(NoteKeys.PlainKeyThrowsOnSqliteVoCheckedAgainstExpected);
-            }
-            else
-            {
-                if (v.Assigned != p.Assigned) return $"assigned keys differ: VO {v.Assigned} | plain {p.Assigned}";
-                if (v.Raw != p.Raw) return $"stored keys differ: VO {v.Raw} | plain {p.Raw}";
-            }
-            if (config is "ValueGeneratedNever" or "ValueGeneratedOnAdd" && Kind(v.DefaultAdd) != Kind(p.DefaultAdd)) return $"default keys differ under {config}: VO {v.DefaultAdd} | plain {p.DefaultAdd}";
-            return null;
-        });
-    }
-
-    // IsRequired(false) cannot apply to a key at all; on a non-key property of the same wrapped type it must win over the required default.
-    static async Task<string?> OptionalProperty(Probes.Shapes.Row r, string w)
-    {
-        r.Substituted("ef.config", "IsRequired-false", "applied to a non-key property: EF refuses an optional key (checked above for parity)");
-        var kind = r.Index % 2 == 0 ? "sealed-record-class" : "validated-class";
-        var e = KeyRegistry.All.First(x => x.Kind == kind && x.Wrapped == w);
-        var entity = typeof(EntP<>).MakeGenericType(e.Vo);
-        Action<ModelBuilder> cfg = mb => { var eb = mb.Entity(entity); eb.ToTable("t"); eb.HasKey("Id"); eb.Property("P").IsRequired(false); };
-        await using var db = new EfDb2(cfg, "after-provider");
-        var model = EfModel.Describe(db.Context);
-        if (!model.Contains("t.P: ") || !model.Split('\n').First(l => l.StartsWith("t.P: ")).Contains("nullable=True")) return "IsRequired(false) not kept on a non-key value object property: " + model;
-        await db.Context.Database.EnsureCreatedAsync();
-        var a = EfX.New(entity); EfX.Set(a, "P", null);
-        var b = EfX.New(entity); EfX.Set(b, "P", e.MakeVo(Sample(w, 0)));
-        db.Context.Add(a); db.Context.Add(b);
-        await db.Context.SaveChangesAsync();
-        db.Context.ChangeTracker.Clear();
-        var read = EfX.Enumerate(Q.SetOf(db.Context, entity)).Select(x => EfX.Get(x, "P") is null ? "null" : Norm(EfX.Get(x, "P"))).OrderBy(s => s, StringComparer.Ordinal).ToArray();
-        var expect = new[] { "null", Norm(Sample(w, 0)) }.OrderBy(s => s, StringComparer.Ordinal).ToArray();
-        if (!read.SequenceEqual(expect)) return $"null did not round-trip: read [{string.Join(",", read)}], expected [{string.Join(",", expect)}]";
-        return null;
-    }
-}
diff --git a/tools/probe/corpus/probes/L05EqualityProbe.cs b/tools/probe/corpus/probes/L05EqualityProbe.cs
deleted file mode 100644
index e076c513..00000000
--- a/tools/probe/corpus/probes/L05EqualityProbe.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Claim L05-equality (README.md#what-typekit-guarantees; Generators README "Equality" and "Comparison"; oracle "Equality (metamorphic)"):
-// equal value objects hash alike, CompareTo is zero exactly when Equals is true, both agree with the wrapped type's, through every base and
-// wherever the value is held. The check is Probes.Json.Equality; the shapes are harness/L05Shapes.g.cs.
-using Probes.Json;
-using Probes.Shapes;
-namespace Probes;
-public sealed class L05EqualityProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("L05EqualityProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, r => Task.FromResult(Equality.Check(r)));
-}
diff --git a/tools/probe/corpus/probes/L06OffTheWireProbe.cs b/tools/probe/corpus/probes/L06OffTheWireProbe.cs
deleted file mode 100644
index aa9542ed..00000000
--- a/tools/probe/corpus/probes/L06OffTheWireProbe.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Claim L06-off-the-wire (README.md#what-typekit-guarantees): System.Text.Json throws NotSupportedException for an Option or a Result, in
-// both directions, in every position, unless the application registered its own converter, which takes precedence. The check is
-// Probes.Json.OffTheWire.
-using Probes.Json;
-using Probes.Shapes;
-namespace Probes;
-public sealed class L06OffTheWireProbe
-{
-    public static TheoryData<string, int> Data() => Rows.Data("L06OffTheWireProbe");
-    [Theory, MemberData(nameof(Data))]
-    public Task Row(string probe, int idx) => Rec.Run(probe, idx, OffTheWire.Check);
-}
diff --git a/tools/probe/corpus/registry.json b/tools/probe/corpus/registry.json
deleted file mode 100644
index 55240d81..00000000
--- a/tools/probe/corpus/registry.json
+++ /dev/null
@@ -1,1340 +0,0 @@
-{
-  "probes": {
-    "BaseProbe": {
-      "claim": "C07-fault-responses-blanket",
-      "filter": "*BaseProbe",
-      "variants": [
-        {
-          "PROBE_ONLY": "process.converter-lookup=none"
-        },
-        {
-          "PROBE_ONLY": "process.converter-lookup=wrapped-type-converter-looked-up-first"
-        }
-      ],
-      "watched": [
-        "design/knowledge/KB-037-mvc-under-max-validation-depth-1-runs-an-unbound-action.md",
-        "design/knowledge/KB-040-a-converter-is-charged-a-level-of-max-depth.md",
-        "design/knowledge/KB-041-mvc-cannot-write-its-400-under-a-context-without-validation-problem-details.md",
-        "test/CodoMetis.TypeKit.Facts/FactFixture.cs",
-        "test/CodoMetis.TypeKit.Facts/KB037.fixture.json",
-        "test/CodoMetis.TypeKit.Facts/KB040.fixture.json",
-        "test/CodoMetis.TypeKit.Facts/KB041.fixture.json"
-      ],
-      "seed": {
-        "patch": "seeds/C07-fault-responses-blanket.patch",
-        "defect": "TryParse builds a validated value object without Create, so binding a route, query, header or form value takes a value Create refuses."
-      }
-    },
-    "C01DecimalSpellingProbe": {
-      "claim": "C01-decimal-spelling",
-      "filter": "*C01DecimalSpellingProbe",
-      "seeds": [
-        {
-          "obligation": "smallest-scale",
-          "patch": "seeds/C01-decimal-spelling-smallest-scale.patch",
-          "defect": "Neither decimal converter narrows the scale: both write a decimal with the scale it arrived with (7.80, 7.8000)."
-        },
-        {
-          "obligation": "number-is-a-number",
-          "patch": "seeds/C01-decimal-spelling-number-is-a-number.patch",
-          "defect": "DecimalNumberJsonConverter writes the smallest scale as a string, not as a number."
-        },
-        {
-          "obligation": "string-is-a-string",
-          "patch": "seeds/C01-decimal-spelling-string-is-a-string.patch",
-          "defect": "DecimalStringJsonConverter writes the smallest scale as a number, not as a string."
-        },
-        {
-          "obligation": "reads-a-number-or-a-string",
-          "patch": "seeds/C01-decimal-spelling-reads-a-number-or-a-string.patch",
-          "defect": "Both decimal converters refuse a string holding a number."
-        },
-        {
-          "obligation": "keeps-the-scale-it-reads",
-          "patch": "seeds/C01-decimal-spelling-keeps-the-scale-it-reads.patch",
-          "defect": "Both decimal converters narrow the scale of what they read (7.80 reads as 7.8), as a number or a string."
-        },
-        {
-          "obligation": "covers-every-decimal",
-          "patch": "seeds/C01-decimal-spelling-covers-every-decimal.patch",
-          "defect": "Both decimal converters write a decimal dictionary key with the scale it arrived with, so a key over a decimal, or over a value object over one, keeps its spellings."
-        }
-      ]
-    },
-    "C02OptionalTextProbe": {
-      "claim": "C02-optional-text",
-      "filter": "*C02OptionalTextProbe",
-      "variants": [
-        {
-          "PROBE_ONLY": "process.converter-lookup=none,text.culture!=globalization-invariant"
-        },
-        {
-          "PROBE_ONLY": "process.converter-lookup=wrapped-type-converter-looked-up-first,text.culture!=globalization-invariant"
-        },
-        {
-          "PROBE_ONLY": "text.culture=globalization-invariant",
-          "DOTNET_SYSTEM_GLOBALIZATION_INVARIANT": "1"
-        },
-        {
-          "PROBE_ONLY": "text.culture=globalization-invariant,entry=AsText"
-        },
-        {
-          "PROBE_ONLY": "text.culture=globalization-invariant,entry=AsOptionalText"
-        }
-      ],
-      "seeds": [
-        {
-          "obligation": "hidden-is-an-error-in-both",
-          "patch": "seeds/C02-optional-text-hidden-is-an-error-in-both.patch",
-          "defect": "AsOptionalText and AsOptionalIdentifier turn a hidden-character string into no text, as a blank one, rather than refusing it as Hidden."
-        },
-        {
-          "obligation": "required-blank-is-an-error",
-          "patch": "seeds/C02-optional-text-required-blank-is-an-error.patch",
-          "defect": "An empty or whitespace-only string passes the guard as empty text; only null is Blank."
-        },
-        {
-          "obligation": "optional-blank-is-no-value",
-          "patch": "seeds/C02-optional-text-optional-blank-is-no-value.patch",
-          "defect": "AsOptionalText and AsOptionalIdentifier keep Blank a refusal instead of no value."
-        },
-        {
-          "obligation": "null-is-blank",
-          "patch": "seeds/C02-optional-text-null-is-blank.patch",
-          "defect": "A null string is Hidden, not Blank."
-        }
-      ]
-    },
-    "C03ComposedProbe": {
-      "claim": "C03-composed-faults",
-      "filter": "*C03ComposedProbe",
-      "variants": [
-        {
-          "PROBE_ONLY": "process.converter-lookup=none"
-        },
-        {
-          "PROBE_ONLY": "process.converter-lookup=wrapped-type-converter-looked-up-first"
-        }
-      ],
-      "seeds": [
-        {
-          "obligation": "each-error-own-set",
-          "patch": "seeds/C03-each-error-own-set.patch",
-          "defect": "A composed fault's problem drops the problem type its own set's mapping gives it."
-        },
-        {
-          "obligation": "detail-and-rule-intact",
-          "patch": "seeds/C03-detail-and-rule-intact.patch",
-          "defect": "A composed fault's problem drops the occurrence's detail."
-        },
-        {
-          "obligation": "statuses-ascending",
-          "patch": "seeds/C03-composed-faults.patch",
-          "defect": "A composed fault's operation lists its statuses in descending order."
-        },
-        {
-          "obligation": "shared-status-types",
-          "patch": "seeds/C03-shared-status-types.patch",
-          "defect": "A status two fault sets share names only the problem types of the first set the endpoint answers with."
-        },
-        {
-          "obligation": "unmapped-set-stops-start",
-          "patch": "seeds/C03-unmapped-set-stops-start.patch",
-          "defect": "The startup check skips an unmapped fault type on an endpoint that answers with several, so the host starts."
-        }
-      ]
-    },
-    "C04WithoutFaultsProbe": {
-      "claim": "C04-without-faults",
-      "filter": "*C04WithoutFaultsProbe",
-      "variants": [
-        {
-          "PROBE_ONLY": "process.converter-lookup=none"
-        },
-        {
-          "PROBE_ONLY": "process.converter-lookup=wrapped-type-converter-looked-up-first"
-        }
-      ],
-      "seeds": [
-        {
-          "obligation": "doc-omits-left-out",
-          "patch": "seeds/C04-without-faults.patch",
-          "defect": "WithoutFaults leaves nothing out of the document: an operation still lists the status and problem type of a member its endpoint, group or controller leaves out."
-        },
-        {
-          "obligation": "reporting-left-out-throws",
-          "patch": "seeds/C04-reporting-left-out-throws.patch",
-          "defect": "A member the endpoint leaves out is answered with its mapped status instead of throwing an InvalidOperationException."
-        },
-        {
-          "obligation": "narrows-wider-status",
-          "patch": "seeds/C04-narrows-wider-status.patch",
-          "defect": "A group's or a builder's status for a member stops the host as soon as one of its endpoints leaves the member out, though the others keep it."
-        },
-        {
-          "obligation": "left-out-everywhere-stops-start",
-          "patch": "seeds/C04-left-out-everywhere-stops-start.patch",
-          "defect": "A status that every endpoint of its scope leaves out no longer stops the host."
-        }
-      ]
-    },
-    "C05RuleProbe": {
-      "claim": "C05-with-rule",
-      "filter": "*C05RuleProbe",
-      "variants": [
-        {
-          "PROBE_ONLY": "process.converter-lookup=none"
-        },
-        {
-          "PROBE_ONLY": "process.converter-lookup=wrapped-type-converter-looked-up-first"
-        }
-      ],
-      "seeds": [
-        {
-          "obligation": "rule-qualified",
-          "patch": "seeds/C05-rule-qualified.patch",
-          "defect": "WithRule writes a closed set's rule as its member's bare name, without its type's: RuleSet.X is written X."
-        },
-        {
-          "obligation": "nested-chain",
-          "patch": "seeds/C05-with-rule.patch",
-          "defect": "WithRule names an enum rule without its nesting chain: Rules.Fault.NoAt is written Fault.NoAt."
-        },
-        {
-          "obligation": "stays-the-errors",
-          "patch": "seeds/C05-stays-the-errors.patch",
-          "defect": "A fault that names a rule is answered 400, not the status its mapping gives the error."
-        },
-        {
-          "obligation": "unnamed-value-throws",
-          "patch": "seeds/C05-unnamed-value-throws.patch",
-          "defect": "WithRule takes an enum value no member names, a combination of flags or a cast number, and writes it as a rule."
-        },
-        {
-          "obligation": "no-namespace",
-          "patch": "seeds/C05-no-namespace.patch",
-          "defect": "WithRule names an enum rule with its namespace: PRule.A is written Probes.PRule.A."
-        }
-      ]
-    },
-    "C06FaultKindsProbe": {
-      "claim": "C06-fault-kinds",
-      "filter": "*C06FaultKindsProbe",
-      "variants": [
-        {
-          "PROBE_ONLY": "process.converter-lookup=none"
-        },
-        {
-          "PROBE_ONLY": "process.converter-lookup=wrapped-type-converter-looked-up-first"
-        }
-      ],
-      "seeds": [
-        {
-          "obligation": "kind-gives-status",
-          "patch": "seeds/C06-fault-kinds.patch",
-          "defect": "FaultKind.Malformed is answered and documented as 422, not 400."
-        },
-        {
-          "obligation": "description-as-detail",
-          "patch": "seeds/C06-description-as-detail.patch",
-          "defect": "A fault-set member's description is not written as the problem's detail."
-        },
-        {
-          "obligation": "no-description-no-detail",
-          "patch": "seeds/C06-no-description-no-detail.patch",
-          "defect": "A member without a description is given its name as the problem's detail."
-        },
-        {
-          "obligation": "member-must-have-kind",
-          "patch": "seeds/C06-member-must-have-kind.patch",
-          "defect": "AddFaultResponses<TSet>() maps a member of no kind to 500 instead of failing."
-        }
-      ]
-    },
-    "C07BlanketMappingProbe": {
-      "claim": "C07-fault-responses-blanket",
-      "filter": "*C07BlanketMappingProbe",
-      "variants": [
-        {
-          "PROBE_ONLY": "process.converter-lookup=none"
-        },
-        {
-          "PROBE_ONLY": "process.converter-lookup=wrapped-type-converter-looked-up-first"
-        }
-      ],
-      "seeds": [
-        {
-          "obligation": "by-kind",
-          "patch": "seeds/C07-by-kind.patch",
-          "defect": "AddFaultResponses() answers a member of kind Conflict with 400, not the 409 its kind gives."
-        },
-        {
-          "obligation": "own-mapping",
-          "patch": "seeds/C07-own-mapping.patch",
-          "defect": "AddFaultResponses(fault => ...) keeps only the status its mapping gives and drops the problem type."
-        },
-        {
-          "obligation": "own-set-keeps-mapping",
-          "patch": "seeds/C07-blanket-mapping.patch",
-          "defect": "A fault set mapped on its own loses its mapping to the mapping for every set (AddFaultResponses()), which is consulted first."
-        },
-        {
-          "obligation": "enum-needs-own-mapping",
-          "patch": "seeds/C07-enum-needs-own-mapping.patch",
-          "defect": "The startup check skips an endpoint that answers with an unmapped enum, so the host starts."
-        },
-        {
-          "obligation": "member-without-kind-stops-start",
-          "patch": "seeds/C07-member-without-kind.patch",
-          "defect": "AddFaultResponses() answers a fault-set member of no kind with 500 instead of stopping the start."
-        },
-        {
-          "obligation": "mapping-refusal-stops-start",
-          "patch": "seeds/C07-mapping-refused.patch",
-          "defect": "AddFaultResponses(fault => ...) answers a member its mapping throws for, or gives a status that is no error, with 500 instead of stopping the start."
-        }
-      ]
-    },
-    "C08SameNameWarningProbe": {
-      "claim": "C08-same-name-warning",
-      "filter": "*C08SameNameWarningProbe",
-      "variants": [
-        {
-          "PROBE_ONLY": "process.converter-lookup=none"
-        },
-        {
-          "PROBE_ONLY": "process.converter-lookup=wrapped-type-converter-looked-up-first"
-        }
-      ],
-      "seeds": [
-        {
-          "obligation": "bare-names-warn",
-          "patch": "seeds/C08-same-name-warning.patch",
-          "defect": "Bare fault names are compared as qualified ones, so two fault types an endpoint answers with that write one name (HFault.Clash beside KFault.Clash) log no startup warning."
-        },
-        {
-          "obligation": "qualified-chain-warns",
-          "patch": "seeds/C08-qualified-chain-warns.patch",
-          "defect": "Qualified fault names are compared with their namespace, so two sets of one nesting chain in two namespaces log no startup warning."
-        },
-        {
-          "obligation": "warning-names-both",
-          "patch": "seeds/C08-warning-names-both.patch",
-          "defect": "The startup warning names only the first of the two members written alike."
-        },
-        {
-          "obligation": "qualified-names-fix",
-          "patch": "seeds/C08-qualified-names-fix.patch",
-          "defect": "Under QualifiedFaultNames, fault names are still compared bare, so HFault.Clash beside KFault.Clash logs a warning."
-        },
-        {
-          "obligation": "leave-one-out-fixes",
-          "patch": "seeds/C08-leave-one-out-fixes.patch",
-          "defect": "The same-name check counts a member the endpoint leaves out, so leaving one out does not end the warning."
-        }
-      ]
-    },
-    "C09BaseRecordEqualityProbe": {
-      "claim": "C09-base-record-equality",
-      "filter": "*C09BaseRecordEqualityProbe",
-      "seeds": [
-        {
-          "obligation": "in-a-collection-of-the-base",
-          "patch": "seeds/C09-base-record-equality-in-a-collection-of-the-base.patch",
-          "defect": "The value object implements only its direct base's IEquatable<TBase> again, so a collection of a deeper base compares it by that base's own equality."
-        },
-        {
-          "obligation": "equal-by-the-wrapped-value",
-          "patch": "seeds/C09-base-record-equality-equal-by-the-wrapped-value.patch",
-          "defect": "Over a base record, the generated Equals(TSelf) also calls the base's Equals(TBase), so a base comparing by reference makes two value objects over one value unequal."
-        }
-      ]
-    },
-    "C10PreserveGuardProbe": {
-      "claim": "C10-preserve-guard",
-      "filter": "*C10PreserveGuardProbe",
-      "watched": [
-        "design/knowledge/KB-040-a-converter-is-charged-a-level-of-max-depth.md",
-        "test/CodoMetis.TypeKit.Facts/FactFixture.cs",
-        "test/CodoMetis.TypeKit.Facts/KB040.fixture.json"
-      ],
-      "seeds": [
-        {
-          "obligation": "refused-where-references-could-be-written",
-          "patch": "seeds/C10-preserve-guard-refused-where-references-could-be-written.patch",
-          "defect": "The Preserve guard misses a wrapped class the serializer walks as an object, so a value object over it writes and reads its own $id and $ref instead of refusing."
-        },
-        {
-          "obligation": "value-converters-unaffected",
-          "patch": "seeds/C10-preserve-guard-value-converters-unaffected.patch",
-          "defect": "Under ReferenceHandler.Preserve, the guard refuses a value object over any reference type, a string or a Uri written by a value converter included."
-        },
-        {
-          "obligation": "own-converters-unaffected",
-          "patch": "seeds/C10-preserve-guard-own-converters-unaffected.patch",
-          "defect": "Under ReferenceHandler.Preserve, the guard refuses a value object whose wrapped type the application converts with a converter of its own."
-        },
-        {
-          "obligation": "ignore-cycles-unaffected",
-          "patch": "seeds/C10-preserve-guard-ignore-cycles-unaffected.patch",
-          "defect": "The Preserve guard fires under ReferenceHandler.IgnoreCycles too."
-        }
-      ]
-    },
-    "C11ParseShapesBuildProbe": {
-      "claim": "C11-parse-shapes-build",
-      "filter": "*C11ParseShapesBuildProbe",
-      "variants": [
-        {
-          "PROBE_ONLY": "process.converter-lookup=none,text.culture!=globalization-invariant"
-        },
-        {
-          "PROBE_ONLY": "process.converter-lookup=wrapped-type-converter-looked-up-first,text.culture!=globalization-invariant"
-        },
-        {
-          "PROBE_ONLY": "text.culture=globalization-invariant,process.converter-lookup=none",
-          "DOTNET_SYSTEM_GLOBALIZATION_INVARIANT": "1"
-        },
-        {
-          "PROBE_ONLY": "text.culture=globalization-invariant,process.converter-lookup=wrapped-type-converter-looked-up-first",
-          "DOTNET_SYSTEM_GLOBALIZATION_INVARIANT": "1"
-        }
-      ],
-      "seeds": [
-        {
-          "obligation": "implicit-result",
-          "patch": "seeds/C11-parse-shapes-build-implicit-result.patch",
-          "defect": "A wrapped type whose static Parse returns a type it can't be assigned from is parsed through its type converter, so the value object has parsing."
-        },
-        {
-          "obligation": "ref-text",
-          "patch": "seeds/C11-parse-shapes-build-ref-text.patch",
-          "defect": "A wrapped type whose Parse or string constructor takes its text by ref is parsed through its type converter, so the value object has parsing."
-        },
-        {
-          "obligation": "abstract-string-constructor",
-          "patch": "seeds/C11-parse-shapes-build-abstract-string-constructor.patch",
-          "defect": "An abstract wrapped class with a string constructor is parsed through its type converter, so the value object has parsing."
-        },
-        {
-          "obligation": "parsing-where-it-can-be-parsed",
-          "patch": "seeds/C11-parse-shapes-build-parsing-where-it-can-be-parsed.patch",
-          "defect": "The generated [TypeConverter] is attached to a top-level value object only, so a nested one over a type that parses has no converter from text for MVC binding and the configuration binder."
-        }
-      ]
-    },
-    "C12DescribedConverterProbe": {
-      "claim": "C12-described-converter",
-      "filter": "*C12DescribedConverterProbe",
-      "variants": [
-        {
-          "PROBE_ONLY": "process.converter-lookup=none"
-        },
-        {
-          "PROBE_ONLY": "process.converter-lookup=wrapped-type-converter-looked-up-first"
-        }
-      ],
-      "seeds": [
-        {
-          "obligation": "own-converter-describes-itself",
-          "patch": "seeds/C12-described-converter-own.patch",
-          "defect": "Only a generated converter's description is read: an application's own IDescribedJsonConverter, the decimal converters among them, leaves its type undescribed."
-        },
-        {
-          "obligation": "options-describe",
-          "patch": "seeds/C12-options-descriptions.patch",
-          "defect": "A description the options give through JsonSchemaDescriptions is never found."
-        },
-        {
-          "obligation": "every-position",
-          "patch": "seeds/C12-described-converter.patch",
-          "defect": "A list's items and a dictionary's additionalProperties of a described type are filled only where ASP.NET already wrote them, so the document drops them."
-        },
-        {
-          "obligation": "parameter-keeps-aspnet",
-          "patch": "seeds/C12-parameter-keeps-aspnet.patch",
-          "defect": "A query parameter of a described type is described as its converter writes JSON, not as ASP.NET writes it without converters."
-        }
-      ]
-    },
-    "C13PatchRequiredProbe": {
-      "claim": "C13-patch-required",
-      "filter": "*C13PatchRequiredProbe",
-      "variants": [
-        {
-          "PROBE_ONLY": "process.converter-lookup=none"
-        },
-        {
-          "PROBE_ONLY": "process.converter-lookup=wrapped-type-converter-looked-up-first"
-        }
-      ],
-      "seeds": [
-        {
-          "obligation": "doc-required-where-rejected",
-          "patch": "seeds/C13-patch-required.patch",
-          "defect": "Every patch is taken out of required, also a constructor parameter that RespectRequiredConstructorParameters makes the serializer require."
-        },
-        {
-          "obligation": "doc-optional-where-absent",
-          "patch": "seeds/C13-doc-optional-where-absent.patch",
-          "defect": "Every patch is listed in required, also one the serializer lets a body leave out."
-        },
-        {
-          "obligation": "absent-is-default",
-          "patch": "seeds/C13-absent-is-default.patch",
-          "defect": "The default of a Patch<T>, what a field the request leaves out keeps, reads as Null instead of Absent."
-        }
-      ]
-    },
-    "C14DeclaredProblemProbe": {
-      "claim": "C14-declared-problem",
-      "filter": "*C14DeclaredProblemProbe",
-      "variants": [
-        {
-          "PROBE_ONLY": "process.converter-lookup=none"
-        },
-        {
-          "PROBE_ONLY": "process.converter-lookup=wrapped-type-converter-looked-up-first"
-        }
-      ],
-      "seeds": [
-        {
-          "obligation": "declared-describes-fault",
-          "patch": "seeds/C14-declared-describes-fault.patch",
-          "defect": "A problem response the endpoint declares itself gets no fault or rule on its own schema, only on the shared component."
-        },
-        {
-          "obligation": "declared-names-types",
-          "patch": "seeds/C14-declared-problem.patch",
-          "defect": "A problem response the endpoint declares itself keeps ASP.NET's description, which names none of the problem types answered with its status."
-        },
-        {
-          "obligation": "ascending-with-declared",
-          "patch": "seeds/C14-ascending-with-declared.patch",
-          "defect": "An operation's responses are left in the order they were added, so a status the endpoint declares itself comes before the lower fault statuses."
-        },
-        {
-          "obligation": "application-json-declared",
-          "patch": "seeds/C14-application-json-declared.patch",
-          "defect": "Only an application/problem+json response counts as a declared problem, so [ProducesResponseType<ProblemDetails>(404)] under application/json names no problem types."
-        }
-      ]
-    },
-    "C15MvcFaultStatusDocProbe": {
-      "claim": "C15-mvc-fault-status-doc",
-      "filter": "*C15MvcFaultStatusDocProbe",
-      "variants": [
-        {
-          "PROBE_ONLY": "process.converter-lookup=none"
-        },
-        {
-          "PROBE_ONLY": "process.converter-lookup=wrapped-type-converter-looked-up-first"
-        }
-      ],
-      "seeds": [
-        {
-          "obligation": "builder-reaches-doc",
-          "patch": "seeds/C15-mvc-fault-status-doc.patch",
-          "defect": "The document reads an MVC action's metadata from its descriptor, so what MapControllers()'s builder declares (WithFaultStatus, WithoutFaults) reaches the response but not the document."
-        },
-        {
-          "obligation": "without-faults-leaves-doc",
-          "patch": "seeds/C15-without-faults-doc.patch",
-          "defect": "The document lists every member, also one the endpoint, its controller or its builder leaves out."
-        },
-        {
-          "obligation": "status-per-scope",
-          "patch": "seeds/C15-status-per-scope.patch",
-          "defect": "The document lists each member's mapped status, not the one its endpoint, controller or builder sets, which the response answers with."
-        }
-      ]
-    },
-    "C16OptionsAgreementProbe": {
-      "claim": "C16-options-agreement",
-      "filter": "*C16OptionsAgreementProbe",
-      "variants": [
-        {
-          "PROBE_ONLY": "process.converter-lookup=none"
-        },
-        {
-          "PROBE_ONLY": "process.converter-lookup=wrapped-type-converter-looked-up-first"
-        }
-      ],
-      "seeds": [
-        {
-          "obligation": "differing-refused",
-          "patch": "seeds/C16-options-agreement.patch",
-          "defect": "A type the minimal-API options describe and MVC's options say nothing of is not refused, so the document describes JSON the controllers do not write."
-        },
-        {
-          "obligation": "error-names-type-and-descriptions",
-          "patch": "seeds/C16-error-names-descriptions.patch",
-          "defect": "The refusal names the type but not what each set of options says of it."
-        },
-        {
-          "obligation": "patch-held-refused",
-          "patch": "seeds/C16-patch-held-refused.patch",
-          "defect": "A type held only inside a patch is never compared across the two option sets, so the document describes it as the minimal-API options alone say."
-        },
-        {
-          "obligation": "same-converters-build",
-          "patch": "seeds/C16-same-converters-build.patch",
-          "defect": "Two option sets with the same converters are refused when their naming policy or number handling differs."
-        },
-        {
-          "obligation": "minimal-host-not-compared",
-          "patch": "seeds/C16-minimal-host-builds.patch",
-          "defect": "A host of minimal APIs alone is compared against MVC's default options, so a converter on its own options refuses its document."
-        }
-      ]
-    },
-    "C17Cmtk0014Probe": {
-      "claim": "C17-cmtk0014",
-      "filter": "*C17Cmtk0014Probe",
-      "seeds": [
-        {
-          "obligation": "a-cast-naming-no-member",
-          "patch": "seeds/C17-cmtk0014-a-cast-naming-no-member.patch",
-          "defect": "CMTK0014 no longer judges a conversion, so a cast to a FaultKind or a ConstructorAccessibility that names no member is silent."
-        },
-        {
-          "obligation": "default-and-zero",
-          "patch": "seeds/C17-cmtk0014-default-and-zero.patch",
-          "defect": "CMTK0014 takes a zero for a member, so default, default(FaultKind) and (FaultKind)0 are silent."
-        },
-        {
-          "obligation": "constructor-accessibility-too",
-          "patch": "seeds/C17-cmtk0014-constructor-accessibility-too.patch",
-          "defect": "CMTK0014 no longer reads ConstructorAccessibility, so RequireParameterlessConstructor's argument that names no member is silent."
-        },
-        {
-          "obligation": "reported-where-written",
-          "patch": "seeds/C17-cmtk0014-reported-where-written.patch",
-          "defect": "CMTK0014 is reported at the syntax around the value, not at the value."
-        },
-        {
-          "obligation": "a-member-is-silent",
-          "patch": "seeds/C17-cmtk0014-a-member-is-silent.patch",
-          "defect": "CMTK0014 judges an explicit cast by its form, not by the value it names, so a cast that names a member, such as (FaultKind)2, is reported."
-        }
-      ]
-    },
-    "C18Cmtk1023Probe": {
-      "claim": "C18-cmtk1023",
-      "filter": "*C18Cmtk1023Probe",
-      "watched": [
-        "src/CodoMetis.TypeKit",
-        "src/Directory.Build.props",
-        "src/Directory.Build.targets"
-      ],
-      "seeds": [
-        {
-          "obligation": "names-each-base-member",
-          "patch": "seeds/C18-cmtk1023-names-each-base-member.patch",
-          "defect": "CMTK1023 leaves out a base's explicit IEquatable<TBase>.Equals, so a base comparing by reference through it compiles without a word."
-        },
-        {
-          "obligation": "a-warning-and-generated",
-          "patch": "seeds/C18-cmtk1023-a-warning-and-generated.patch",
-          "defect": "CMTK1023 is reported as information, not as a warning."
-        },
-        {
-          "obligation": "generated-equality-never-calls-the-base",
-          "patch": "seeds/C18-cmtk1023-generated-equality-never-calls-the-base.patch",
-          "defect": "Over a base record, the generated GetHashCode() combines the base's, so a base hashing by reference makes two value objects over one value hash apart."
-        }
-      ]
-    },
-    "C19Cmtk0010KindsProbe": {
-      "claim": "C19-cmtk0010-kinds",
-      "filter": "*C19Cmtk0010KindsProbe",
-      "watched": [
-        "test/CodoMetis.TypeKit.Analyzers.Tests/Variants/TypeArgumentKinds.cs",
-        "test/CodoMetis.TypeKit.Analyzers.Tests/Variants/TypeArgumentSites.cs"
-      ],
-      "seeds": [
-        {
-          "obligation": "methods-the-compiler-calls",
-          "patch": "seeds/C19-cmtk0010-kinds-methods-the-compiler-calls.patch",
-          "defect": "CMTK0010 no longer checks a collection expression's builder method, so a breaking argument it infers there compiles."
-        },
-        {
-          "obligation": "interface-and-unsealed",
-          "patch": "seeds/C19-cmtk0010-kinds-interface-and-unsealed.patch",
-          "defect": "CMTK0010 takes a sealed class for [Unsealed]."
-        },
-        {
-          "obligation": "value-object-and-closed-set",
-          "patch": "seeds/C19-cmtk0010-kinds-value-object-and-closed-set.patch",
-          "defect": "CMTK0010 takes any type that is not an interface for [ValueObject], value object or not."
-        },
-        {
-          "obligation": "flags-enum-and-read-only-struct",
-          "patch": "seeds/C19-cmtk0010-kinds-flags-enum-and-read-only-struct.patch",
-          "defect": "CMTK0010 takes a mutable struct for [ReadOnlyStruct]."
-        },
-        {
-          "obligation": "a-pair-once-at-the-later-argument",
-          "patch": "seeds/C19-cmtk0010-kinds-a-pair-once-at-the-later-argument.patch",
-          "defect": "CMTK0010 reports a breach of [Distinct] or [Unrelated] at the earlier argument of the pair."
-        }
-      ]
-    },
-    "C20ShouldHoldProbe": {
-      "claim": "C20-testing-shouldhold",
-      "filter": "*C20ShouldHoldProbe",
-      "seeds": [
-        {
-          "obligation": "fails-unless-it-holds-that-reason",
-          "patch": "seeds/C20-testing-shouldhold-fails-unless-it-holds-that-reason.patch",
-          "defect": "ShouldHold(reason) checks only the held fault's type, so a fault of that type with another reason passes."
-        },
-        {
-          "obligation": "whichever-of-its-types",
-          "patch": "seeds/C20-testing-shouldhold-whichever-of-its-types.patch",
-          "defect": "ShouldHold(reason) never finds a reason of a composed fault's last type: it reads that case as the bare reason, not as a Fault<TFault>."
-        },
-        {
-          "obligation": "hands-back-detail-and-rule",
-          "patch": "seeds/C20-testing-shouldhold-hands-back-detail-and-rule.patch",
-          "defect": "ShouldHold(reason) hands back a new Fault<TFault> of the reason alone, without the held fault's detail and rule."
-        },
-        {
-          "obligation": "uninitialized-fails",
-          "patch": "seeds/C20-testing-shouldhold-uninitialized-fails.patch",
-          "defect": "ShouldHold(reason) reads an uninitialized composed fault instead of failing as an assertion."
-        },
-        {
-          "obligation": "a-failure-says-the-outcome",
-          "patch": "seeds/C20-testing-shouldhold-a-failure-says-the-outcome.patch",
-          "defect": "A failed ShouldHold(reason) no longer says which fault the composed fault holds."
-        }
-      ]
-    },
-    "C21OpenapiSchemaParityProbe": {
-      "claim": "C21-openapi-schema-parity",
-      "filter": "*C21OpenapiSchemaParityProbe",
-      "seeds": [
-        {
-          "obligation": "the-underlying-types-schema",
-          "patch": "seeds/C21-openapi-schema-parity-the-underlying-types-schema.patch",
-          "defect": "A value object's OpenAPI schema drops the wrapped type's format (int32, uuid, date-time)."
-        },
-        {
-          "obligation": "container-elements",
-          "patch": "seeds/C21-openapi-schema-parity-container-elements.patch",
-          "defect": "A list's or an array's items are not put back for a container of value objects, so the elements lose their schema."
-        },
-        {
-          "obligation": "dictionary-key",
-          "patch": "seeds/C21-openapi-schema-parity-dictionary-key.patch",
-          "defect": "A dictionary keyed by a value object is described with the key's schema for its values."
-        },
-        {
-          "obligation": "every-document-version",
-          "patch": "seeds/C21-openapi-schema-parity-every-document-version.patch",
-          "defect": "Under OpenAPI 2.0 and 3.0 a value object's schema drops the wrapped type's format."
-        },
-        {
-          "obligation": "nullable-admits-null-as-the-wrapped-does",
-          "patch": "seeds/C21-openapi-schema-parity-nullable-admits-null-as-the-wrapped-does.patch",
-          "defect": "6866822 and F3's fixes reversed: every nullable value object in a JSON position takes a nullable property's null (a query, header or form VO? admits null in its type, a nullable struct over string or Uri at a root admits null), and a parameter MVC hands over as a string admits none (an MVC [FromBody] VO? over ulong or long, a query VO? over an enum written by name)."
-        }
-      ],
-      "variants": [
-        {
-          "PROBE_ONLY": "process.converter-lookup=none"
-        },
-        {
-          "PROBE_ONLY": "process.converter-lookup=wrapped-type-converter-looked-up-first"
-        }
-      ]
-    },
-    "C22GeneratorRefusalsProbe": {
-      "claim": "C22-generator-refusals",
-      "filter": "*C22GeneratorRefusalsProbe",
-      "watched": [
-        "src/CodoMetis.TypeKit",
-        "src/CodoMetis.TypeKit.Analyzers",
-        "src/CodoMetis.TypeKit.Generators",
-        "src/Directory.Build.props",
-        "src/Directory.Build.targets"
-      ],
-      "seeds": [
-        {
-          "obligation": "every-error-links-the-table",
-          "patch": "seeds/C22-generator-refusals-every-error-links-the-table.patch",
-          "defect": "CMTK1005's message no longer ends with the link to the Build errors table."
-        },
-        {
-          "obligation": "unsealed-record-class",
-          "patch": "seeds/C22-generator-refusals-unsealed-record-class.patch",
-          "defect": "A record class not declared sealed is no longer refused (CMTK1006 is never reported)."
-        },
-        {
-          "obligation": "over-value-object",
-          "patch": "seeds/C22-generator-refusals-over-value-object.patch",
-          "defect": "The fabric hands the aspect no wrapped-value-object refusal, so a value object over another value object is generated."
-        },
-        {
-          "obligation": "generic-wrapped",
-          "patch": "seeds/C22-generator-refusals-generic-wrapped.patch",
-          "defect": "A generic wrapped type is no longer refused, so List<T> fails inside the generated code (LAMA0611) instead of CMTK1005."
-        },
-        {
-          "obligation": "abstract",
-          "patch": "seeds/C22-generator-refusals-abstract.patch",
-          "defect": "1ef30be reversed: the fabric no longer reports CMTK1022, so an abstract type with a marker compiles with nothing generated and nothing said."
-        },
-        {
-          "obligation": "over-system-enum",
-          "patch": "seeds/C22-generator-refusals-over-system-enum.patch",
-          "defect": "e4b751c's System.Enum refusal reversed: a value object over System.Enum is no longer refused (CMTK1005)."
-        },
-        {
-          "obligation": "named-as-generated-member",
-          "patch": "seeds/C22-generator-refusals-named-as-generated-member.patch",
-          "defect": "e4b751c's name refusal reversed: a value object named From, Parse, MinValue or another generated member is not refused, and fails inside the generated code (LAMA0611, CS0542)."
-        },
-        {
-          "obligation": "closed-set-named-as-generated-member",
-          "patch": "seeds/C22-generator-refusals-closed-set-named-as-generated-member.patch",
-          "defect": "e4b751c's set-name refusal reversed: a closed set named Name, All, Match or another of its generated members is not refused (CMTK1021) and fails inside the generated code."
-        },
-        {
-          "obligation": "equality-operator",
-          "patch": "seeds/C22-generator-refusals-equality-operator.patch",
-          "defect": "e4b751c's operator refusal reversed: a hand-written operator == or != between two of the type is C#'s bare CS0111, with no CMTK1011 naming it."
-        },
-        {
-          "obligation": "no-type-half-generated",
-          "patch": "seeds/C22-generator-refusals-no-type-half-generated.patch",
-          "defect": "CMTK1005 is reported as a warning, so a declaration that cannot be generated builds, with nothing generated for it."
-        },
-        {
-          "obligation": "over-object",
-          "patch": "seeds/C22-generator-refusals-over-object.patch",
-          "defect": "53188ed reversed: a value object over object is no longer refused (CMTK1005) and compiles."
-        }
-      ]
-    },
-    "E01ColumnParityProbe": {
-      "claim": "E01-column-parity",
-      "filter": "*E01ColumnParityProbe",
-      "seeds": [
-        {
-          "obligation": "column-type",
-          "patch": "seeds/E01-column-parity-column-type.patch",
-          "defect": "A value object over an enum is mapped as a text column, as a closed set is, not as the enum's integer column."
-        },
-        {
-          "obligation": "nullable",
-          "patch": "seeds/E01-column-parity-nullable.patch",
-          "defect": "A convention marks every value-object property required, so a nullable one gets a NOT NULL column."
-        },
-        {
-          "obligation": "facet-kept",
-          "patch": "seeds/E01-column-parity-facet-kept.patch",
-          "defect": "A finalizing convention clears the maximum length, precision, scale and column type configured on a value-object property."
-        }
-      ]
-    },
-    "E02ValueTranslatesProbe": {
-      "claim": "E02-value-translates-to-column",
-      "filter": "*E02ValueTranslatesProbe",
-      "seeds": [
-        {
-          "obligation": "value",
-          "patch": "seeds/E02-value-translates-to-column-value.patch",
-          "defect": "The member translator leaves .Value to EF, so a filter, sort or grouping on it is not translated."
-        },
-        {
-          "obligation": "get-value",
-          "patch": "seeds/E02-value-translates-to-column-get-value.patch",
-          "defect": "The method-call translator leaves GetValue() to EF, so a query on it is not translated."
-        },
-        {
-          "obligation": "value-or-null",
-          "patch": "seeds/E02-value-translates-to-column-value-or-null.patch",
-          "defect": "The method-call translator leaves ValueOrNull() to EF, so a query on an optional value object's value is not translated."
-        },
-        {
-          "obligation": "column-not-cast",
-          "patch": "seeds/E02-value-translates-to-column-column-not-cast.patch",
-          "defect": ".Value on a column is translated as a cast of the column, not the column itself."
-        }
-      ]
-    },
-    "E03ColumnRoundTripProbe": {
-      "claim": "E03-column-round-trip",
-      "filter": "*E03ColumnRoundTripProbe",
-      "seeds": [
-        {
-          "obligation": "stored-as-underlying",
-          "patch": "seeds/E03-column-round-trip-stored-as-underlying.patch",
-          "defect": "A decimal value object is mapped through the double mapping, a REAL column, not the TEXT column a decimal gets."
-        },
-        {
-          "obligation": "keys",
-          "patch": "seeds/E03-column-round-trip-keys.patch",
-          "defect": "The type mapping plugin maps no value object used as a key or an index, so a value-object key cannot be stored."
-        },
-        {
-          "obligation": "nullable-properties",
-          "patch": "seeds/E03-column-round-trip-nullable-properties.patch",
-          "defect": "A convention marks every value-object property required, so a nullable one cannot store null."
-        }
-      ]
-    },
-    "E04IntegerKeyProbe": {
-      "claim": "E04-integer-key-generated",
-      "filter": "*E04IntegerKeyProbe",
-      "seeds": [
-        {
-          "obligation": "generated-on-add",
-          "patch": "seeds/E04-integer-key-generated-generated-on-add.patch",
-          "defect": "A key over an integer is declared never generated, so entities added without a key are stored with 0."
-        },
-        {
-          "obligation": "byte-not-generated",
-          "patch": "seeds/E04-integer-key-generated-byte-not-generated.patch",
-          "defect": "A key over byte is declared generated on add, which EF does not do for a plain byte key."
-        },
-        {
-          "obligation": "char-key-yours",
-          "patch": "seeds/E04-integer-key-generated-char-key-yours.patch",
-          "defect": "A key over char is declared generated on add, as EF would for a plain char key."
-        },
-        {
-          "obligation": "guid-key-yours",
-          "patch": "seeds/E04-integer-key-generated-guid-key-yours.patch",
-          "defect": "A key over a Guid is declared generated on add, so EF invents a Guid for an entity added without one."
-        },
-        {
-          "obligation": "not-on-efs-list",
-          "patch": "seeds/E04-integer-key-generated-not-on-efs-list.patch",
-          "defect": "A key over a string is declared generated on add, as a key over an integer is, so EF invents a Guid's text for an entity added without one, where a plain string key is never generated."
-        },
-        {
-          "obligation": "own-configuration-wins",
-          "patch": "seeds/E04-integer-key-generated-own-configuration-wins.patch",
-          "defect": "A key over char or Guid is declared never generated as an explicit configuration, so it overrides the ValueGeneratedOnAdd() the application wrote."
-        }
-      ]
-    },
-    "E05OwnCompareToProbe": {
-      "claim": "E05-own-compareto-rejected",
-      "filter": "*E05OwnCompareToProbe",
-      "seeds": [
-        {
-          "obligation": "comparison",
-          "patch": "seeds/E05-own-compareto-rejected-comparison.patch",
-          "defect": "A query comparing a value object with a hand-written CompareTo (an operator or CompareTo) runs in the database instead of throwing."
-        },
-        {
-          "obligation": "ordering",
-          "patch": "seeds/E05-own-compareto-rejected-ordering.patch",
-          "defect": "A query ordering by a value object with a hand-written CompareTo runs in the database instead of throwing."
-        },
-        {
-          "obligation": "min-max",
-          "patch": "seeds/E05-own-compareto-rejected-min-max.patch",
-          "defect": "Min or Max of a value object with a hand-written CompareTo runs in the database instead of throwing."
-        },
-        {
-          "obligation": "equality-allowed",
-          "patch": "seeds/E05-own-compareto-rejected-equality-allowed.patch",
-          "defect": "An equality of a value object with a hand-written CompareTo is refused as if it were a comparison."
-        },
-        {
-          "obligation": "value-order-allowed",
-          "patch": "seeds/E05-own-compareto-rejected-value-order-allowed.patch",
-          "defect": "Ordering by .Value of a value object with a hand-written CompareTo is refused as if it ordered by the value object."
-        },
-        {
-          "obligation": "query-filter",
-          "patch": "seeds/E05-own-compareto-rejected-query-filter.patch",
-          "defect": "A query filter comparing a value object with a hand-written CompareTo is accepted when the model is built."
-        }
-      ]
-    },
-    "E06OwnConverterNoValueProbe": {
-      "claim": "E06-own-converter-no-value",
-      "filter": "*E06OwnConverterNoValueProbe",
-      "seeds": [
-        {
-          "obligation": "value-not-translated",
-          "patch": "seeds/E06-own-converter-no-value-value-not-translated.patch",
-          "defect": ".Value translates on a column the application converts itself, so the query compares against the converted text instead of failing."
-        },
-        {
-          "obligation": "value-object-comparison",
-          "patch": "seeds/E06-own-converter-no-value-value-object-comparison.patch",
-          "defect": "The query interceptor rewrites a value-object equality as an equality of .Value, which a column the application converts itself cannot answer."
-        }
-      ]
-    },
-    "E07ClosedSetNameProbe": {
-      "claim": "E07-closed-set-stored-as-name",
-      "filter": "*E07ClosedSetNameProbe",
-      "seeds": [
-        {
-          "obligation": "stored-as-name",
-          "patch": "seeds/E07-closed-set-stored-as-name-stored-as-name.patch",
-          "defect": "A closed set's member is stored as its name in upper case, not its name."
-        },
-        {
-          "obligation": "in-collections-and-json",
-          "patch": "seeds/E07-closed-set-stored-as-name-in-collections-and-json.patch",
-          "defect": "The JSON reader/writer of a closed set writes something other than the member's name, so a primitive collection or a JSON column holds no names."
-        },
-        {
-          "obligation": "unknown-name-throws",
-          "patch": "seeds/E07-closed-set-stored-as-name-unknown-name-throws.patch",
-          "defect": "A stored name the closed set no longer has reads back as null instead of throwing."
-        },
-        {
-          "obligation": "non-member-throws",
-          "patch": "seeds/E07-closed-set-stored-as-name-non-member-throws.patch",
-          "defect": "An instance that is not a member of its closed set is written as the name Unknown instead of throwing."
-        }
-      ]
-    },
-    "E08OptionResultNotColumnsProbe": {
-      "claim": "E08-option-result-not-columns",
-      "filter": "*E08OptionResultNotColumnsProbe",
-      "seeds": [
-        {
-          "obligation": "model-fails",
-          "patch": "seeds/E08-option-result-not-columns-model-fails.patch",
-          "defect": "TypeKit's conventions ignore an Option or Result property, so the model builds without the column instead of failing."
-        },
-        {
-          "obligation": "error-says-so",
-          "patch": "seeds/E08-option-result-not-columns-error-says-so.patch",
-          "defect": "The type mapping plugin refuses an Option or Result property with an error that does not name the type."
-        }
-      ]
-    },
-    "E09OrNoneInDbProbe": {
-      "claim": "E09-or-none-in-database",
-      "filter": "*E09OrNoneInDbProbe",
-      "seeds": [
-        {
-          "obligation": "first-reads-one-row",
-          "patch": "seeds/E09-or-none-in-database-first-reads-one-row.patch",
-          "defect": "FirstOrNoneAsync with a condition reads every matching row, without LIMIT 1."
-        },
-        {
-          "obligation": "single-asks-for-two",
-          "patch": "seeds/E09-or-none-in-database-single-asks-for-two.patch",
-          "defect": "SingleOrNoneAsync answers the first of two matching rows instead of throwing."
-        },
-        {
-          "obligation": "element-at-skips",
-          "patch": "seeds/E09-or-none-in-database-element-at-skips.patch",
-          "defect": "ElementAtOrNone on a query reads every row up to its index and skips in memory, without OFFSET."
-        }
-      ]
-    },
-    "E10ReadBackSkipsValidationProbe": {
-      "claim": "E10-read-back-skips-validation",
-      "filter": "*E10ReadBackSkipsValidationProbe",
-      "seeds": [
-        {
-          "obligation": "reads-without-create",
-          "patch": "seeds/E10-read-back-skips-validation-reads-without-create.patch",
-          "defect": "Reading a column back runs Create and throws for a value today's rules refuse, instead of materializing it."
-        },
-        {
-          "obligation": "revalidate-finds",
-          "patch": "seeds/E10-read-back-skips-validation-revalidate-finds.patch",
-          "defect": "The generated Revalidate() answers the value object itself, so a stored value today's rules refuse reads as valid."
-        }
-      ]
-    },
-    "E11UseTypeKitOrderProbe": {
-      "claim": "E11-usetypekit-order",
-      "filter": "*E11UseTypeKitOrderProbe",
-      "seeds": [
-        {
-          "obligation": "order-does-not-matter",
-          "patch": "seeds/E11-usetypekit-order-order-does-not-matter.patch",
-          "defect": "UseTypeKit() adds its services only when the provider's are already registered, so calling it before UseSqlite does nothing."
-        }
-      ]
-    },
-    "E12ConventionByTypeProbe": {
-      "claim": "E12-convention-by-vo-type",
-      "filter": "*E12ConventionByTypeProbe",
-      "seeds": [
-        {
-          "obligation": "value-object-type-reaches",
-          "patch": "seeds/E12-convention-by-vo-type-value-object-type-reaches.patch",
-          "defect": "A finalizing convention clears the max length, precision and scale of value-object properties, so a convention on the value object's type does not reach its property."
-        },
-        {
-          "obligation": "underlying-type-does-not-reach",
-          "patch": "seeds/E12-convention-by-vo-type-underlying-type-does-not-reach.patch",
-          "defect": "A value-object property is configured as the type it wraps is, so a ConfigureConventions convention on decimal reaches an Amount property."
-        }
-      ]
-    },
-    "E13PrimitiveCollectionProbe": {
-      "claim": "E13-primitive-collections",
-      "filter": "*E13PrimitiveCollectionProbe",
-      "seeds": [
-        {
-          "obligation": "element-value",
-          "patch": "seeds/E13-primitive-collections-element-value.patch",
-          "defect": ".Value on an element of a primitive collection of value objects is not translated, so Any(t => t.Value == x) fails."
-        },
-        {
-          "obligation": "contains",
-          "patch": "seeds/E13-primitive-collections-contains.patch",
-          "defect": "The query interceptor rewrites Contains of a value object in a primitive collection as false, so the query matches no row."
-        }
-      ]
-    },
-    "E14InheritanceKeyProbe": {
-      "claim": "E14-inheritance-key-generation",
-      "filter": "*E14InheritanceKeyProbe",
-      "seeds": [
-        {
-          "obligation": "tph-tpt-root",
-          "patch": "seeds/E14-inheritance-key-generation-tph-tpt-root.patch",
-          "defect": "The integer key of a TPH or TPT hierarchy's root is left as EF leaves a value object, never generated."
-        },
-        {
-          "obligation": "tpc-assign-on-sqlite",
-          "patch": "seeds/E14-inheritance-key-generation-tpc-assign-on-sqlite.patch",
-          "defect": "Under TPC on a provider without a sequence (SQLite), an integer key of the hierarchy's root stays generated on add."
-        }
-      ]
-    },
-    "E15CompositeKeyProbe": {
-      "claim": "E15-composite-key",
-      "filter": "*E15CompositeKeyProbe",
-      "seeds": [
-        {
-          "obligation": "as-for-primitives",
-          "patch": "seeds/E15-composite-key-as-for-primitives.patch",
-          "defect": "The first value-object property of a composite key is treated as a single integer key and generated on add."
-        }
-      ]
-    },
-    "E16OwnConfigurationWinsProbe": {
-      "claim": "E16-own-configuration-wins",
-      "filter": "*E16OwnConfigurationWinsProbe",
-      "seeds": [
-        {
-          "obligation": "never",
-          "patch": "seeds/E16-own-configuration-wins-never.patch",
-          "defect": "The integer key default is set as an explicit configuration, so it overrides the application's own ValueGeneratedNever."
-        },
-        {
-          "obligation": "on-add",
-          "patch": "seeds/E16-own-configuration-wins-on-add.patch",
-          "defect": "A key over char or Guid is declared never generated as an explicit configuration, so it overrides the application's own ValueGeneratedOnAdd."
-        },
-        {
-          "obligation": "column-type",
-          "patch": "seeds/E16-own-configuration-wins-column-type.patch",
-          "defect": "A finalizing convention clears the column type configured on a value-object property."
-        },
-        {
-          "obligation": "conversion",
-          "patch": "seeds/E16-own-configuration-wins-conversion.patch",
-          "defect": "A finalizing convention removes the converter the application configured on a value-object property, so TypeKit's mapping stores the plain value."
-        },
-        {
-          "obligation": "optional",
-          "patch": "seeds/E16-own-configuration-wins-optional.patch",
-          "defect": "A finalizing convention makes a value-object property required again after the application configured IsRequired(false)."
-        }
-      ]
-    },
-    "L01JsonBytesProbe": {
-      "claim": "L01-json-bytes",
-      "filter": "*L01JsonBytesProbe",
-      "watched": [
-        "design/knowledge/KB-040-a-converter-is-charged-a-level-of-max-depth.md",
-        "test/CodoMetis.TypeKit.Facts/FactFixture.cs",
-        "test/CodoMetis.TypeKit.Facts/KB040.fixture.json"
-      ],
-      "seeds": [
-        {
-          "obligation": "as-a-dictionary-key-too",
-          "patch": "seeds/L01-json-bytes-as-a-dictionary-key-too.patch",
-          "defect": "A dictionary key is written with ToString(), not the wrapped type's key converter and DictionaryKeyPolicy."
-        },
-        {
-          "obligation": "the-underlying-types-json",
-          "patch": "seeds/L01-json-bytes-the-underlying-types-json.patch",
-          "defect": "The generated converter writes a number as it is, ignoring the options' JsonNumberHandling.WriteAsString."
-        },
-        {
-          "obligation": "read-as-the-underlying-type-reads",
-          "patch": "seeds/L01-json-bytes-read-as-the-underlying-type-reads.patch",
-          "defect": "The generated converter refuses a JSON string that holds an escape sequence, which the wrapped type reads."
-        }
-      ]
-    },
-    "L02NoQuoteProbe": {
-      "claim": "L02-no-quote",
-      "filter": "*L02NoQuoteProbe",
-      "variants": [
-        {
-          "PROBE_ONLY": "process.converter-lookup=none,text.culture!=globalization-invariant"
-        },
-        {
-          "PROBE_ONLY": "process.converter-lookup=wrapped-type-converter-looked-up-first,text.culture!=globalization-invariant"
-        },
-        {
-          "PROBE_ONLY": "text.culture=globalization-invariant",
-          "DOTNET_SYSTEM_GLOBALIZATION_INVARIANT": "1"
-        }
-      ],
-      "seeds": [
-        {
-          "obligation": "parsing-never-repeats",
-          "patch": "seeds/L02-no-quote-parsing-never-repeats.patch",
-          "defect": "Generated parsing calls the wrapped type's Parse instead of its TryParse, whose FormatException quotes the input."
-        },
-        {
-          "obligation": "json-never-repeats",
-          "patch": "seeds/L02-no-quote-json-never-repeats.patch",
-          "defect": "A JSON value the wrapped type can't read is refused with its text in the JsonException's message."
-        },
-        {
-          "obligation": "no-inner-that-quotes",
-          "patch": "seeds/L02-no-quote-no-inner-that-quotes.patch",
-          "defect": "Generated parsing refuses unreadable text with an inner FormatException that quotes it."
-        }
-      ]
-    },
-    "L03OneRuleProbe": {
-      "claim": "L03-one-rule",
-      "filter": "*L03OneRuleProbe",
-      "variants": [
-        {
-          "PROBE_ONLY": "process.converter-lookup=none,text.culture!=globalization-invariant"
-        },
-        {
-          "PROBE_ONLY": "process.converter-lookup=wrapped-type-converter-looked-up-first,text.culture!=globalization-invariant"
-        },
-        {
-          "PROBE_ONLY": "text.culture=globalization-invariant",
-          "DOTNET_SYSTEM_GLOBALIZATION_INVARIANT": "1"
-        }
-      ],
-      "watched": [
-        "design/knowledge/KB-040-a-converter-is-charged-a-level-of-max-depth.md",
-        "test/CodoMetis.TypeKit.Facts/FactFixture.cs",
-        "test/CodoMetis.TypeKit.Facts/KB040.fixture.json"
-      ],
-      "seeds": [
-        {
-          "obligation": "parsing-runs-create",
-          "patch": "seeds/L03-one-rule-parsing-runs-create.patch",
-          "defect": "Parse and the type converter build a validated value object without Create."
-        },
-        {
-          "obligation": "tryfrom-runs-create",
-          "patch": "seeds/L03-one-rule-tryfrom-runs-create.patch",
-          "defect": "TryFrom wraps the value without Create, so it gives a value Create refuses."
-        },
-        {
-          "obligation": "json-runs-create",
-          "patch": "seeds/L03-one-rule-json-runs-create.patch",
-          "defect": "The JSON converter's materialize flag is read backwards: a JSON read skips Create, and only StoredJsonConverterFactory runs it."
-        },
-        {
-          "obligation": "refusals-name-the-fault",
-          "patch": "seeds/L03-one-rule-refusals-name-the-fault.patch",
-          "defect": "The JsonException, the FormatException and the FromKnownGood exception name the type of the fault Create returned, not the fault."
-        }
-      ]
-    },
-    "L04RoundTripProbe": {
-      "claim": "L04-round-trip",
-      "filter": "*L04RoundTripProbe",
-      "variants": [
-        {
-          "PROBE_ONLY": "process.converter-lookup=none,text.culture!=globalization-invariant"
-        },
-        {
-          "PROBE_ONLY": "process.converter-lookup=wrapped-type-converter-looked-up-first,text.culture!=globalization-invariant"
-        },
-        {
-          "PROBE_ONLY": "text.culture=globalization-invariant",
-          "DOTNET_SYSTEM_GLOBALIZATION_INVARIANT": "1"
-        }
-      ],
-      "watched": [
-        "design/knowledge/KB-040-a-converter-is-charged-a-level-of-max-depth.md",
-        "test/CodoMetis.TypeKit.Facts/FactFixture.cs",
-        "test/CodoMetis.TypeKit.Facts/KB040.fixture.json"
-      ],
-      "seeds": [
-        {
-          "obligation": "invariant-whatever-the-culture",
-          "patch": "seeds/L04-round-trip-invariant-whatever-the-culture.patch",
-          "defect": "Generated formatting uses the current culture instead of the provider (invariant by default)."
-        },
-        {
-          "obligation": "the-type-converter-writes-the-same",
-          "patch": "seeds/L04-round-trip-the-type-converter-writes-the-same.patch",
-          "defect": "The type converter writes the wrapped value in the current culture when no culture is passed."
-        },
-        {
-          "obligation": "text-reads-back",
-          "patch": "seeds/L04-round-trip-text-reads-back.patch",
-          "defect": "The type converter reads text in the current culture when no culture is passed."
-        },
-        {
-          "obligation": "json-refusal-is-a-json-exception",
-          "patch": "seeds/L04-round-trip-json-refusal-is-a-json-exception.patch",
-          "defect": "The generated converter lets the wrapped converter's own exception out for input it can't read (a FormatException for a Guid)."
-        }
-      ]
-    },
-    "L05EqualityProbe": {
-      "claim": "L05-equality",
-      "filter": "*L05EqualityProbe",
-      "seeds": [
-        {
-          "obligation": "through-every-base",
-          "patch": "seeds/L05-equality-through-every-base.patch",
-          "defect": "A deeper base record whose IEquatable is implemented explicitly keeps its own Equals, so equal value objects compare unequal through that base and a HashSet of it holds both."
-        },
-        {
-          "obligation": "equality-is-the-underlying-values",
-          "patch": "seeds/L05-equality-equality-is-the-underlying-values.patch",
-          "defect": "Over a base record, the generated GetHashCode() hashes the value's text, so 7.8m and 7.80m, or 0.0 and -0.0, hash apart."
-        },
-        {
-          "obligation": "ordering-follows-the-underlying-type",
-          "patch": "seeds/L05-equality-ordering-follows-the-underlying-type.patch",
-          "defect": "The generated CompareTo orders the wrapped values in reverse."
-        }
-      ]
-    },
-    "L06OffTheWireProbe": {
-      "claim": "L06-off-the-wire",
-      "filter": "*L06OffTheWireProbe",
-      "seeds": [
-        {
-          "obligation": "never-written",
-          "patch": "seeds/L06-off-the-wire-never-written.patch",
-          "defect": "The refusing converter writes {} for an Option or a Result instead of throwing NotSupportedException, so a Some is written as {} and reads back as None."
-        },
-        {
-          "obligation": "never-read",
-          "patch": "seeds/L06-off-the-wire-never-read.patch",
-          "defect": "Reading an Option or a Result throws a JsonException, as for malformed input, not NotSupportedException."
-        }
-      ]
-    }
-  }
-}
diff --git a/tools/probe/corpus/rows/BaseProbe.json.gz b/tools/probe/corpus/rows/BaseProbe.json.gz
deleted file mode 100644
index 078ef2fe..00000000
Binary files a/tools/probe/corpus/rows/BaseProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C01DecimalSpellingProbe.json.gz b/tools/probe/corpus/rows/C01DecimalSpellingProbe.json.gz
deleted file mode 100644
index 59d80c38..00000000
Binary files a/tools/probe/corpus/rows/C01DecimalSpellingProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C02OptionalTextProbe.json.gz b/tools/probe/corpus/rows/C02OptionalTextProbe.json.gz
deleted file mode 100644
index 51817f86..00000000
Binary files a/tools/probe/corpus/rows/C02OptionalTextProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C03ComposedProbe.json.gz b/tools/probe/corpus/rows/C03ComposedProbe.json.gz
deleted file mode 100644
index f2a7899e..00000000
Binary files a/tools/probe/corpus/rows/C03ComposedProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C04WithoutFaultsProbe.json.gz b/tools/probe/corpus/rows/C04WithoutFaultsProbe.json.gz
deleted file mode 100644
index d5fa3f24..00000000
Binary files a/tools/probe/corpus/rows/C04WithoutFaultsProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C05RuleProbe.json.gz b/tools/probe/corpus/rows/C05RuleProbe.json.gz
deleted file mode 100644
index 7ad0dc77..00000000
Binary files a/tools/probe/corpus/rows/C05RuleProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C06FaultKindsProbe.json.gz b/tools/probe/corpus/rows/C06FaultKindsProbe.json.gz
deleted file mode 100644
index 562ae319..00000000
Binary files a/tools/probe/corpus/rows/C06FaultKindsProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C07BlanketMappingProbe.json.gz b/tools/probe/corpus/rows/C07BlanketMappingProbe.json.gz
deleted file mode 100644
index 078ef2fe..00000000
Binary files a/tools/probe/corpus/rows/C07BlanketMappingProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C08SameNameWarningProbe.json.gz b/tools/probe/corpus/rows/C08SameNameWarningProbe.json.gz
deleted file mode 100644
index 316ea2be..00000000
Binary files a/tools/probe/corpus/rows/C08SameNameWarningProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C09BaseRecordEqualityProbe.json.gz b/tools/probe/corpus/rows/C09BaseRecordEqualityProbe.json.gz
deleted file mode 100644
index 61cf4ba6..00000000
Binary files a/tools/probe/corpus/rows/C09BaseRecordEqualityProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C10PreserveGuardProbe.json.gz b/tools/probe/corpus/rows/C10PreserveGuardProbe.json.gz
deleted file mode 100644
index c1206100..00000000
Binary files a/tools/probe/corpus/rows/C10PreserveGuardProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C11ParseShapesBuildProbe.json.gz b/tools/probe/corpus/rows/C11ParseShapesBuildProbe.json.gz
deleted file mode 100644
index ffe8f639..00000000
Binary files a/tools/probe/corpus/rows/C11ParseShapesBuildProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C12DescribedConverterProbe.json.gz b/tools/probe/corpus/rows/C12DescribedConverterProbe.json.gz
deleted file mode 100644
index 694df302..00000000
Binary files a/tools/probe/corpus/rows/C12DescribedConverterProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C13PatchRequiredProbe.json.gz b/tools/probe/corpus/rows/C13PatchRequiredProbe.json.gz
deleted file mode 100644
index 28c4797f..00000000
Binary files a/tools/probe/corpus/rows/C13PatchRequiredProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C14DeclaredProblemProbe.json.gz b/tools/probe/corpus/rows/C14DeclaredProblemProbe.json.gz
deleted file mode 100644
index c3da4a42..00000000
Binary files a/tools/probe/corpus/rows/C14DeclaredProblemProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C15MvcFaultStatusDocProbe.json.gz b/tools/probe/corpus/rows/C15MvcFaultStatusDocProbe.json.gz
deleted file mode 100644
index 1c4b21d1..00000000
Binary files a/tools/probe/corpus/rows/C15MvcFaultStatusDocProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C16OptionsAgreementProbe.json.gz b/tools/probe/corpus/rows/C16OptionsAgreementProbe.json.gz
deleted file mode 100644
index 762426f8..00000000
Binary files a/tools/probe/corpus/rows/C16OptionsAgreementProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C17Cmtk0014Probe.json.gz b/tools/probe/corpus/rows/C17Cmtk0014Probe.json.gz
deleted file mode 100644
index c373c112..00000000
Binary files a/tools/probe/corpus/rows/C17Cmtk0014Probe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C18Cmtk1023Probe.json.gz b/tools/probe/corpus/rows/C18Cmtk1023Probe.json.gz
deleted file mode 100644
index 0daaefd6..00000000
Binary files a/tools/probe/corpus/rows/C18Cmtk1023Probe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C19Cmtk0010KindsProbe.json.gz b/tools/probe/corpus/rows/C19Cmtk0010KindsProbe.json.gz
deleted file mode 100644
index f0242cec..00000000
Binary files a/tools/probe/corpus/rows/C19Cmtk0010KindsProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C20ShouldHoldProbe.json.gz b/tools/probe/corpus/rows/C20ShouldHoldProbe.json.gz
deleted file mode 100644
index 6f5be161..00000000
Binary files a/tools/probe/corpus/rows/C20ShouldHoldProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C21OpenapiSchemaParityProbe.json.gz b/tools/probe/corpus/rows/C21OpenapiSchemaParityProbe.json.gz
deleted file mode 100644
index bdcf9ef2..00000000
Binary files a/tools/probe/corpus/rows/C21OpenapiSchemaParityProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/C22GeneratorRefusalsProbe.json.gz b/tools/probe/corpus/rows/C22GeneratorRefusalsProbe.json.gz
deleted file mode 100644
index a435a310..00000000
Binary files a/tools/probe/corpus/rows/C22GeneratorRefusalsProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/E01ColumnParityProbe.json.gz b/tools/probe/corpus/rows/E01ColumnParityProbe.json.gz
deleted file mode 100644
index e47d8738..00000000
Binary files a/tools/probe/corpus/rows/E01ColumnParityProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/E02ValueTranslatesProbe.json.gz b/tools/probe/corpus/rows/E02ValueTranslatesProbe.json.gz
deleted file mode 100644
index b420251c..00000000
Binary files a/tools/probe/corpus/rows/E02ValueTranslatesProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/E03ColumnRoundTripProbe.json.gz b/tools/probe/corpus/rows/E03ColumnRoundTripProbe.json.gz
deleted file mode 100644
index 7b341810..00000000
Binary files a/tools/probe/corpus/rows/E03ColumnRoundTripProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/E04IntegerKeyProbe.json.gz b/tools/probe/corpus/rows/E04IntegerKeyProbe.json.gz
deleted file mode 100644
index d8e9aee1..00000000
Binary files a/tools/probe/corpus/rows/E04IntegerKeyProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/E05OwnCompareToProbe.json.gz b/tools/probe/corpus/rows/E05OwnCompareToProbe.json.gz
deleted file mode 100644
index 4e110c7a..00000000
Binary files a/tools/probe/corpus/rows/E05OwnCompareToProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/E06OwnConverterNoValueProbe.json.gz b/tools/probe/corpus/rows/E06OwnConverterNoValueProbe.json.gz
deleted file mode 100644
index a8a88b64..00000000
Binary files a/tools/probe/corpus/rows/E06OwnConverterNoValueProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/E07ClosedSetNameProbe.json.gz b/tools/probe/corpus/rows/E07ClosedSetNameProbe.json.gz
deleted file mode 100644
index ca9d3c13..00000000
Binary files a/tools/probe/corpus/rows/E07ClosedSetNameProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/E08OptionResultNotColumnsProbe.json.gz b/tools/probe/corpus/rows/E08OptionResultNotColumnsProbe.json.gz
deleted file mode 100644
index aaaf1496..00000000
Binary files a/tools/probe/corpus/rows/E08OptionResultNotColumnsProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/E09OrNoneInDbProbe.json.gz b/tools/probe/corpus/rows/E09OrNoneInDbProbe.json.gz
deleted file mode 100644
index 7b19af30..00000000
Binary files a/tools/probe/corpus/rows/E09OrNoneInDbProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/E10ReadBackSkipsValidationProbe.json.gz b/tools/probe/corpus/rows/E10ReadBackSkipsValidationProbe.json.gz
deleted file mode 100644
index 331e16cf..00000000
Binary files a/tools/probe/corpus/rows/E10ReadBackSkipsValidationProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/E11UseTypeKitOrderProbe.json.gz b/tools/probe/corpus/rows/E11UseTypeKitOrderProbe.json.gz
deleted file mode 100644
index 8af704b4..00000000
Binary files a/tools/probe/corpus/rows/E11UseTypeKitOrderProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/E12ConventionByTypeProbe.json.gz b/tools/probe/corpus/rows/E12ConventionByTypeProbe.json.gz
deleted file mode 100644
index e520ae6a..00000000
Binary files a/tools/probe/corpus/rows/E12ConventionByTypeProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/E13PrimitiveCollectionProbe.json.gz b/tools/probe/corpus/rows/E13PrimitiveCollectionProbe.json.gz
deleted file mode 100644
index 665ad59f..00000000
Binary files a/tools/probe/corpus/rows/E13PrimitiveCollectionProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/E14InheritanceKeyProbe.json.gz b/tools/probe/corpus/rows/E14InheritanceKeyProbe.json.gz
deleted file mode 100644
index c48350c4..00000000
Binary files a/tools/probe/corpus/rows/E14InheritanceKeyProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/E15CompositeKeyProbe.json.gz b/tools/probe/corpus/rows/E15CompositeKeyProbe.json.gz
deleted file mode 100644
index c081c2ac..00000000
Binary files a/tools/probe/corpus/rows/E15CompositeKeyProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/E16OwnConfigurationWinsProbe.json.gz b/tools/probe/corpus/rows/E16OwnConfigurationWinsProbe.json.gz
deleted file mode 100644
index ccc341ce..00000000
Binary files a/tools/probe/corpus/rows/E16OwnConfigurationWinsProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/L01JsonBytesProbe.json.gz b/tools/probe/corpus/rows/L01JsonBytesProbe.json.gz
deleted file mode 100644
index 10767ecc..00000000
Binary files a/tools/probe/corpus/rows/L01JsonBytesProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/L02NoQuoteProbe.json.gz b/tools/probe/corpus/rows/L02NoQuoteProbe.json.gz
deleted file mode 100644
index 8c537a24..00000000
Binary files a/tools/probe/corpus/rows/L02NoQuoteProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/L03OneRuleProbe.json.gz b/tools/probe/corpus/rows/L03OneRuleProbe.json.gz
deleted file mode 100644
index fffe2faa..00000000
Binary files a/tools/probe/corpus/rows/L03OneRuleProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/L04RoundTripProbe.json.gz b/tools/probe/corpus/rows/L04RoundTripProbe.json.gz
deleted file mode 100644
index 3792095b..00000000
Binary files a/tools/probe/corpus/rows/L04RoundTripProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/L05EqualityProbe.json.gz b/tools/probe/corpus/rows/L05EqualityProbe.json.gz
deleted file mode 100644
index 515deaf4..00000000
Binary files a/tools/probe/corpus/rows/L05EqualityProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/rows/L06OffTheWireProbe.json.gz b/tools/probe/corpus/rows/L06OffTheWireProbe.json.gz
deleted file mode 100644
index 46bf206f..00000000
Binary files a/tools/probe/corpus/rows/L06OffTheWireProbe.json.gz and /dev/null differ
diff --git a/tools/probe/corpus/seeds/C01-decimal-spelling-covers-every-decimal.patch b/tools/probe/corpus/seeds/C01-decimal-spelling-covers-every-decimal.patch
deleted file mode 100644
index ba0401e4..00000000
--- a/tools/probe/corpus/seeds/C01-decimal-spelling-covers-every-decimal.patch
+++ /dev/null
@@ -1,22 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/DecimalJsonConverters.cs b/src/CodoMetis.TypeKit/DecimalJsonConverters.cs
-index 9007276..b60dc4d 100644
---- a/src/CodoMetis.TypeKit/DecimalJsonConverters.cs
-+++ b/src/CodoMetis.TypeKit/DecimalJsonConverters.cs
-@@ -55,7 +55,7 @@ public sealed class DecimalNumberJsonConverter : JsonConverter<decimal>, IDescri
-     public override void WriteAsPropertyName(Utf8JsonWriter writer, decimal value, JsonSerializerOptions options)
-     {
-         ArgumentNullException.ThrowIfNull(writer);
--        writer.WritePropertyName(DecimalJson.Text(value));
-+        writer.WritePropertyName(value.ToString(CultureInfo.InvariantCulture));
-     }
- }
- 
-@@ -105,7 +105,7 @@ public sealed class DecimalStringJsonConverter : JsonConverter<decimal>, IDescri
-     public override void WriteAsPropertyName(Utf8JsonWriter writer, decimal value, JsonSerializerOptions options)
-     {
-         ArgumentNullException.ThrowIfNull(writer);
--        writer.WritePropertyName(DecimalJson.Text(value));
-+        writer.WritePropertyName(value.ToString(CultureInfo.InvariantCulture));
-     }
- }
- 
diff --git a/tools/probe/corpus/seeds/C01-decimal-spelling-keeps-the-scale-it-reads.patch b/tools/probe/corpus/seeds/C01-decimal-spelling-keeps-the-scale-it-reads.patch
deleted file mode 100644
index ea049332..00000000
--- a/tools/probe/corpus/seeds/C01-decimal-spelling-keeps-the-scale-it-reads.patch
+++ /dev/null
@@ -1,22 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/DecimalJsonConverters.cs b/src/CodoMetis.TypeKit/DecimalJsonConverters.cs
-index 9007276..471f160 100644
---- a/src/CodoMetis.TypeKit/DecimalJsonConverters.cs
-+++ b/src/CodoMetis.TypeKit/DecimalJsonConverters.cs
-@@ -143,7 +143,7 @@ internal static class DecimalJson
-     /// <summary>A number, or a string holding one.</summary>
-     public static decimal Read(ref Utf8JsonReader reader) => reader.TokenType switch
-     {
--        JsonTokenType.Number => reader.TryGetDecimal(out var value) ? value : throw new JsonException(),
-+        JsonTokenType.Number => reader.TryGetDecimal(out var value) ? Minimal(value) : throw new JsonException(),
-         JsonTokenType.String => ReadText(ref reader),
-         _ => throw new JsonException(),
-     };
-@@ -164,7 +164,7 @@ internal static class DecimalJson
-             return text is not null && TryParse(Encoding.UTF8.GetBytes(text), out var unescaped) ? unescaped : throw new JsonException();
-         }
- 
--        return TryParse(reader.ValueSpan, out var value) ? value : throw new JsonException();
-+        return TryParse(reader.ValueSpan, out var value) ? Minimal(value) : throw new JsonException();
-     }
- 
-     private static bool TryParse(ReadOnlySpan<byte> utf8, out decimal value) =>
diff --git a/tools/probe/corpus/seeds/C01-decimal-spelling-number-is-a-number.patch b/tools/probe/corpus/seeds/C01-decimal-spelling-number-is-a-number.patch
deleted file mode 100644
index a4947393..00000000
--- a/tools/probe/corpus/seeds/C01-decimal-spelling-number-is-a-number.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/DecimalJsonConverters.cs b/src/CodoMetis.TypeKit/DecimalJsonConverters.cs
-index 9007276..ef426a1 100644
---- a/src/CodoMetis.TypeKit/DecimalJsonConverters.cs
-+++ b/src/CodoMetis.TypeKit/DecimalJsonConverters.cs
-@@ -45,7 +45,7 @@ public sealed class DecimalNumberJsonConverter : JsonConverter<decimal>, IDescri
-     public override void Write(Utf8JsonWriter writer, decimal value, JsonSerializerOptions options)
-     {
-         ArgumentNullException.ThrowIfNull(writer);
--        writer.WriteNumberValue(DecimalJson.Minimal(value));
-+        writer.WriteStringValue(DecimalJson.Text(value));
-     }
- 
-     /// <inheritdoc />
diff --git a/tools/probe/corpus/seeds/C01-decimal-spelling-reads-a-number-or-a-string.patch b/tools/probe/corpus/seeds/C01-decimal-spelling-reads-a-number-or-a-string.patch
deleted file mode 100644
index b5c82df6..00000000
--- a/tools/probe/corpus/seeds/C01-decimal-spelling-reads-a-number-or-a-string.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/DecimalJsonConverters.cs b/src/CodoMetis.TypeKit/DecimalJsonConverters.cs
-index 9007276..cd760e4 100644
---- a/src/CodoMetis.TypeKit/DecimalJsonConverters.cs
-+++ b/src/CodoMetis.TypeKit/DecimalJsonConverters.cs
-@@ -144,7 +144,7 @@ internal static class DecimalJson
-     public static decimal Read(ref Utf8JsonReader reader) => reader.TokenType switch
-     {
-         JsonTokenType.Number => reader.TryGetDecimal(out var value) ? value : throw new JsonException(),
--        JsonTokenType.String => ReadText(ref reader),
-+        JsonTokenType.String => throw new JsonException(),
-         _ => throw new JsonException(),
-     };
- 
diff --git a/tools/probe/corpus/seeds/C01-decimal-spelling-smallest-scale.patch b/tools/probe/corpus/seeds/C01-decimal-spelling-smallest-scale.patch
deleted file mode 100644
index 5afc4c05..00000000
--- a/tools/probe/corpus/seeds/C01-decimal-spelling-smallest-scale.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/DecimalJsonConverters.cs b/src/CodoMetis.TypeKit/DecimalJsonConverters.cs
-index 9007276..3c3c878 100644
---- a/src/CodoMetis.TypeKit/DecimalJsonConverters.cs
-+++ b/src/CodoMetis.TypeKit/DecimalJsonConverters.cs
-@@ -135,7 +135,7 @@ internal static class DecimalJson
-     });
- 
-     /// <summary>The value at its smallest scale; a zero of any scale or sign is <c>0</c>.</summary>
--    public static decimal Minimal(decimal value) => value == 0m ? 0m : value / OneAtLargestScale;
-+    public static decimal Minimal(decimal value) => value;
- 
-     /// <summary>The minimal-scale spelling, invariant, never with an exponent.</summary>
-     public static string Text(decimal value) => Minimal(value).ToString(CultureInfo.InvariantCulture);
diff --git a/tools/probe/corpus/seeds/C01-decimal-spelling-string-is-a-string.patch b/tools/probe/corpus/seeds/C01-decimal-spelling-string-is-a-string.patch
deleted file mode 100644
index 0801a816..00000000
--- a/tools/probe/corpus/seeds/C01-decimal-spelling-string-is-a-string.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/DecimalJsonConverters.cs b/src/CodoMetis.TypeKit/DecimalJsonConverters.cs
-index 9007276..60cebf9 100644
---- a/src/CodoMetis.TypeKit/DecimalJsonConverters.cs
-+++ b/src/CodoMetis.TypeKit/DecimalJsonConverters.cs
-@@ -95,7 +95,7 @@ public sealed class DecimalStringJsonConverter : JsonConverter<decimal>, IDescri
-     public override void Write(Utf8JsonWriter writer, decimal value, JsonSerializerOptions options)
-     {
-         ArgumentNullException.ThrowIfNull(writer);
--        writer.WriteStringValue(DecimalJson.Text(value));
-+        writer.WriteNumberValue(DecimalJson.Minimal(value));
-     }
- 
-     /// <inheritdoc />
diff --git a/tools/probe/corpus/seeds/C02-optional-text-hidden-is-an-error-in-both.patch b/tools/probe/corpus/seeds/C02-optional-text-hidden-is-an-error-in-both.patch
deleted file mode 100644
index 7433212c..00000000
--- a/tools/probe/corpus/seeds/C02-optional-text-hidden-is-an-error-in-both.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/StringTextExtensions.cs b/src/CodoMetis.TypeKit/StringTextExtensions.cs
-index 29681aa..62ab884 100644
---- a/src/CodoMetis.TypeKit/StringTextExtensions.cs
-+++ b/src/CodoMetis.TypeKit/StringTextExtensions.cs
-@@ -163,7 +163,7 @@ public static class StringTextExtensions
-     /// <summary>A guard's answer for an optional field: <see cref="TextFault.Blank"/> is absence, every other fault a refusal.</summary>
-     private static Result<Option<string>, TextFault> Optional(Result<string, TextFault> guarded) =>
-         guarded.Map(Option.Some)
--               .Recover(fault => fault == TextFault.Blank ? Option.None<string>() : Result.Error(fault));
-+               .Recover(fault => fault is TextFault.Blank or TextFault.Hidden ? Option.None<string>() : Result.Error(fault));
- 
-     private static Result<string, TextFault> Clean(string? text, bool tolerateJoiners, bool canonicalize)
-     {
diff --git a/tools/probe/corpus/seeds/C02-optional-text-null-is-blank.patch b/tools/probe/corpus/seeds/C02-optional-text-null-is-blank.patch
deleted file mode 100644
index b68f2896..00000000
--- a/tools/probe/corpus/seeds/C02-optional-text-null-is-blank.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/StringTextExtensions.cs b/src/CodoMetis.TypeKit/StringTextExtensions.cs
-index 29681aa..76d683e 100644
---- a/src/CodoMetis.TypeKit/StringTextExtensions.cs
-+++ b/src/CodoMetis.TypeKit/StringTextExtensions.cs
-@@ -167,6 +167,7 @@ public static class StringTextExtensions
- 
-     private static Result<string, TextFault> Clean(string? text, bool tolerateJoiners, bool canonicalize)
-     {
-+        if (text is null) return Result.Error(TextFault.Hidden);
-         var trimmed = text?.Trim() ?? string.Empty;
- 
-         if (trimmed.Length == 0) return Result.Error(TextFault.Blank);
diff --git a/tools/probe/corpus/seeds/C02-optional-text-optional-blank-is-no-value.patch b/tools/probe/corpus/seeds/C02-optional-text-optional-blank-is-no-value.patch
deleted file mode 100644
index 24d74224..00000000
--- a/tools/probe/corpus/seeds/C02-optional-text-optional-blank-is-no-value.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/StringTextExtensions.cs b/src/CodoMetis.TypeKit/StringTextExtensions.cs
-index 29681aa..4eb6b00 100644
---- a/src/CodoMetis.TypeKit/StringTextExtensions.cs
-+++ b/src/CodoMetis.TypeKit/StringTextExtensions.cs
-@@ -163,7 +163,7 @@ public static class StringTextExtensions
-     /// <summary>A guard's answer for an optional field: <see cref="TextFault.Blank"/> is absence, every other fault a refusal.</summary>
-     private static Result<Option<string>, TextFault> Optional(Result<string, TextFault> guarded) =>
-         guarded.Map(Option.Some)
--               .Recover(fault => fault == TextFault.Blank ? Option.None<string>() : Result.Error(fault));
-+               .Recover(fault => fault == (TextFault)99 ? Option.None<string>() : Result.Error(fault));
- 
-     private static Result<string, TextFault> Clean(string? text, bool tolerateJoiners, bool canonicalize)
-     {
diff --git a/tools/probe/corpus/seeds/C02-optional-text-required-blank-is-an-error.patch b/tools/probe/corpus/seeds/C02-optional-text-required-blank-is-an-error.patch
deleted file mode 100644
index 2efb96c3..00000000
--- a/tools/probe/corpus/seeds/C02-optional-text-required-blank-is-an-error.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/StringTextExtensions.cs b/src/CodoMetis.TypeKit/StringTextExtensions.cs
-index 29681aa..5a6eea9 100644
---- a/src/CodoMetis.TypeKit/StringTextExtensions.cs
-+++ b/src/CodoMetis.TypeKit/StringTextExtensions.cs
-@@ -169,6 +169,7 @@ public static class StringTextExtensions
-     {
-         var trimmed = text?.Trim() ?? string.Empty;
- 
-+        if (trimmed.Length == 0 && text is not null) return trimmed;
-         if (trimmed.Length == 0) return Result.Error(TextFault.Blank);
-         if (IsHidden(trimmed, tolerateJoiners)) return Result.Error(TextFault.Hidden);
- 
diff --git a/tools/probe/corpus/seeds/C03-composed-faults.patch b/tools/probe/corpus/seeds/C03-composed-faults.patch
deleted file mode 100644
index f4b6159e..00000000
--- a/tools/probe/corpus/seeds/C03-composed-faults.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-index 475e121..90b855b 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-@@ -148,7 +148,7 @@ internal sealed class FaultResponsesOperationTransformer : IOpenApiOperationTran
-     /// </summary>
-     private static void Ascending(OpenApiResponses responses)
-     {
--        var ordered = responses.OrderBy(response => Rank(response.Key)).ToList();
-+        var ordered = responses.OrderByDescending(response => Rank(response.Key)).ToList();
-         if (ordered.Select(response => response.Key).SequenceEqual(responses.Keys, StringComparer.Ordinal)) return;
- 
-         // A dictionary cleared and filled again enumerates in the order it was filled, as the writer reads it.
diff --git a/tools/probe/corpus/seeds/C03-detail-and-rule-intact.patch b/tools/probe/corpus/seeds/C03-detail-and-rule-intact.patch
deleted file mode 100644
index a7ea20bf..00000000
--- a/tools/probe/corpus/seeds/C03-detail-and-rule-intact.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/TypeKitHttpResultExtensions.cs b/src/CodoMetis.TypeKit.AspNetCore/TypeKitHttpResultExtensions.cs
-index 6df36fb..17611f3 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/TypeKitHttpResultExtensions.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/TypeKitHttpResultExtensions.cs
-@@ -249,7 +249,7 @@ public static class TypeKitHttpResultExtensions
-             static fault => fault.Match<Results<TSuccess, FaultProblem<T1>, FaultProblem<T2>, FaultProblem<T3>>>(static f => Problem(f), static f => Problem(f), static f => Problem(f)));
-     }
- 
--    private static FaultProblem<TFault> Problem<TFault>(Fault<TFault> fault) where TFault : notnull => new(fault.Reason, fault.Detail, fault.Rule);
-+    private static FaultProblem<TFault> Problem<TFault>(Fault<TFault> fault) where TFault : notnull => new(fault.Reason, null, fault.Rule);
- }
- 
- /// <summary>Turns a <c>Result</c> whose fault is a closed set into the HTTP response an endpoint returns, as <see cref="TypeKitHttpResultExtensions"/> does for an enum.</summary>
diff --git a/tools/probe/corpus/seeds/C03-each-error-own-set.patch b/tools/probe/corpus/seeds/C03-each-error-own-set.patch
deleted file mode 100644
index 61b70590..00000000
--- a/tools/probe/corpus/seeds/C03-each-error-own-set.patch
+++ /dev/null
@@ -1,35 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs
-index f9919a2..1e4ed87 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs
-@@ -47,6 +47,8 @@ public sealed class FaultProblem<TFault> : IResult, IEndpointMetadataProvider
-     /// <summary>The rule that refused, <c>EmailFault.NoAt</c>, where the result carried a <see cref="Fault{TFault}"/> naming one.</summary>
-     public string? Rule { get; }
- 
-+    internal bool Composed { get; init; }
-+
-     /// <inheritdoc />
-     public async Task ExecuteAsync(HttpContext httpContext)
-     {
-@@ -77,7 +79,7 @@ public sealed class FaultProblem<TFault> : IResult, IEndpointMetadataProvider
-         {
-             await TypedResults.Problem(
-                     statusCode: status,
--                    type: answer.Type,
-+                    type: Composed ? null : answer.Type,
-                     title: answer.Title,
-                     detail: detail,
-                     extensions: extensions)
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/TypeKitHttpResultExtensions.cs b/src/CodoMetis.TypeKit.AspNetCore/TypeKitHttpResultExtensions.cs
-index 6df36fb..83ae661 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/TypeKitHttpResultExtensions.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/TypeKitHttpResultExtensions.cs
-@@ -249,7 +249,7 @@ public static class TypeKitHttpResultExtensions
-             static fault => fault.Match<Results<TSuccess, FaultProblem<T1>, FaultProblem<T2>, FaultProblem<T3>>>(static f => Problem(f), static f => Problem(f), static f => Problem(f)));
-     }
- 
--    private static FaultProblem<TFault> Problem<TFault>(Fault<TFault> fault) where TFault : notnull => new(fault.Reason, fault.Detail, fault.Rule);
-+    private static FaultProblem<TFault> Problem<TFault>(Fault<TFault> fault) where TFault : notnull => new(fault.Reason, fault.Detail, fault.Rule) { Composed = true };
- }
- 
- /// <summary>Turns a <c>Result</c> whose fault is a closed set into the HTTP response an endpoint returns, as <see cref="TypeKitHttpResultExtensions"/> does for an enum.</summary>
diff --git a/tools/probe/corpus/seeds/C03-shared-status-types.patch b/tools/probe/corpus/seeds/C03-shared-status-types.patch
deleted file mode 100644
index 84054939..00000000
--- a/tools/probe/corpus/seeds/C03-shared-status-types.patch
+++ /dev/null
@@ -1,14 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-index 8e936ee..934c951 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-@@ -98,7 +98,8 @@ internal sealed class FaultResponsesOperationTransformer : IOpenApiOperationTran
- 
-             foreach (var status in statuses)
-             {
--                if (!answered.TryGetValue(status, out var types)) answered[status] = types = [];
-+                if (answered.TryGetValue(status, out var types)) continue;
-+                answered[status] = types = [];
-                 types.AddRange(metadata.Types(context.ApplicationServices, status, endpointMetadata).Except(types, StringComparer.Ordinal).ToList());
-             }
-         }
diff --git a/tools/probe/corpus/seeds/C03-unmapped-set-stops-start.patch b/tools/probe/corpus/seeds/C03-unmapped-set-stops-start.patch
deleted file mode 100644
index a5429447..00000000
--- a/tools/probe/corpus/seeds/C03-unmapped-set-stops-start.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-index c537edf..2ff421e 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-@@ -50,7 +50,7 @@ internal sealed class FaultResponsesStartupCheck : IStartupFilter
- 
-         var unmapped = endpoints.Endpoints
-             .SelectMany(endpoint => endpoint.Metadata.OfType<FaultResponsesMetadata>().Select(metadata => (Endpoint: endpoint, Metadata: metadata)))
--            .Where(pair => pair.Metadata.Statuses(services, pair.Endpoint.Metadata) is null)
-+            .Where(pair => pair.Metadata.Statuses(services, pair.Endpoint.Metadata) is null && pair.Endpoint.Metadata.OfType<FaultResponsesMetadata>().Distinct().Count() < 2)
-             // By type, not by name: two nested types of one simple name are two refusals.
-             .GroupBy(pair => pair.Metadata.FaultType, pair => (pair.Metadata.FaultName, Endpoint: Name(pair.Endpoint)))
-             .Select(fault =>
diff --git a/tools/probe/corpus/seeds/C04-left-out-everywhere-stops-start.patch b/tools/probe/corpus/seeds/C04-left-out-everywhere-stops-start.patch
deleted file mode 100644
index d539295c..00000000
--- a/tools/probe/corpus/seeds/C04-left-out-everywhere-stops-start.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-index c537edf..707ddd2 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-@@ -88,7 +88,7 @@ internal sealed class FaultResponsesStartupCheck : IStartupFilter
-                 .Select(left => (left.Status, left.Member, left.Message, Endpoint: endpoint)))
-             .GroupBy(left => left.Status, DeclarationComparer)
-             .SelectMany(status => status.GroupBy(left => left.Member, StringComparer.Ordinal)
--                .Where(member => scopes[status.Key].All(endpoint => member.Any(left => left.Endpoint == endpoint)))
-+                .Where(member => scopes[status.Key].All(endpoint => member.Any(left => left.Endpoint == endpoint)) && scopes[status.Key].Count == 0)
-                 .Select(member => $"{member.First().Message}, on {string.Join(", ", member.Select(left => Name(left.Endpoint)).Distinct())}."));
- 
-         // Two fault types an endpoint answers with should not write one name: the client reads two faults
diff --git a/tools/probe/corpus/seeds/C04-narrows-wider-status.patch b/tools/probe/corpus/seeds/C04-narrows-wider-status.patch
deleted file mode 100644
index f42097b8..00000000
--- a/tools/probe/corpus/seeds/C04-narrows-wider-status.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-index c537edf..46478c5 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-@@ -88,7 +88,7 @@ internal sealed class FaultResponsesStartupCheck : IStartupFilter
-                 .Select(left => (left.Status, left.Member, left.Message, Endpoint: endpoint)))
-             .GroupBy(left => left.Status, DeclarationComparer)
-             .SelectMany(status => status.GroupBy(left => left.Member, StringComparer.Ordinal)
--                .Where(member => scopes[status.Key].All(endpoint => member.Any(left => left.Endpoint == endpoint)))
-+                .Where(member => scopes[status.Key].Any(endpoint => member.Any(left => left.Endpoint == endpoint)))
-                 .Select(member => $"{member.First().Message}, on {string.Join(", ", member.Select(left => Name(left.Endpoint)).Distinct())}."));
- 
-         // Two fault types an endpoint answers with should not write one name: the client reads two faults
diff --git a/tools/probe/corpus/seeds/C04-reporting-left-out-throws.patch b/tools/probe/corpus/seeds/C04-reporting-left-out-throws.patch
deleted file mode 100644
index cf3b3824..00000000
--- a/tools/probe/corpus/seeds/C04-reporting-left-out-throws.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs
-index f9919a2..03c9112 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs
-@@ -57,7 +57,7 @@ public sealed class FaultProblem<TFault> : IResult, IEndpointMetadataProvider
-         var endpoint = httpContext.GetEndpoint();
- 
-         // The document lists no status for a member the endpoint leaves out: answering it would contradict it.
--        if (endpoint is not null && FaultExclusions.Excluding(endpoint.Metadata, Fault, responses.Type) is { } exclusion)
-+        if (endpoint is not null && FaultExclusions.Excluding([], Fault, responses.Type) is { } exclusion)
-             throw new InvalidOperationException(
-                 $"{endpoint.DisplayName ?? "The endpoint"} reported {answer.QualifiedName}, which {exclusion.Describe()} leaves out of its document, " +
-                 "so no status the document lists answers it. Remove the member from what the endpoint leaves out, or report another." + FaultRefusals.LeftOut);
diff --git a/tools/probe/corpus/seeds/C04-without-faults.patch b/tools/probe/corpus/seeds/C04-without-faults.patch
deleted file mode 100644
index 28e340aa..00000000
--- a/tools/probe/corpus/seeds/C04-without-faults.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-index 45c20b0..60bc81e 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-@@ -157,7 +157,7 @@ internal sealed class FaultResponses<TFault> where TFault : notnull
- 
-     /// <summary>The members an endpoint answers with: every member, but those its metadata leaves out.</summary>
-     public IEnumerable<TFault> AnsweredBy(IReadOnlyList<object> endpointMetadata) =>
--        Type.Members.Where(fault => FaultExclusions.Excluding(endpointMetadata, fault, Type) is null);
-+        Type.Members;
- 
-     private int StatusOf(TFault fault, IReadOnlyList<object> endpointMetadata) =>
-         FaultStatuses.Override(endpointMetadata, fault, Type) ?? _answers[fault].Status;
diff --git a/tools/probe/corpus/seeds/C05-no-namespace.patch b/tools/probe/corpus/seeds/C05-no-namespace.patch
deleted file mode 100644
index da87d2dc..00000000
--- a/tools/probe/corpus/seeds/C05-no-namespace.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/Fault.cs b/src/CodoMetis.TypeKit/Fault.cs
-index e2f33a8..88c10d3 100644
---- a/src/CodoMetis.TypeKit/Fault.cs
-+++ b/src/CodoMetis.TypeKit/Fault.cs
-@@ -180,7 +180,7 @@ internal static class FaultRuleNames
- {
-     /// <summary><c>Billing.Fault</c> for an enum nested in <c>Billing</c>, without a generic arity.</summary>
-     public static string NestingChain(Type type) =>
--        type.DeclaringType is { } declaring ? $"{NestingChain(declaring)}.{Simple(type)}" : Simple(type);
-+        type.DeclaringType is { } declaring ? $"{NestingChain(declaring)}.{Simple(type)}" : $"{type.Namespace}.{Simple(type)}";
- 
-     private static string Simple(Type type) =>
-         type.Name.IndexOf('`') is var tick and >= 0 ? type.Name[..tick] : type.Name;
diff --git a/tools/probe/corpus/seeds/C05-rule-qualified.patch b/tools/probe/corpus/seeds/C05-rule-qualified.patch
deleted file mode 100644
index 9e37bad3..00000000
--- a/tools/probe/corpus/seeds/C05-rule-qualified.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/Fault.cs b/src/CodoMetis.TypeKit/Fault.cs
-index e2f33a8..700c935 100644
---- a/src/CodoMetis.TypeKit/Fault.cs
-+++ b/src/CodoMetis.TypeKit/Fault.cs
-@@ -170,7 +170,7 @@ public static class FaultClosedSetRuleExtensions
-         public Fault<TFault> WithRule<TRule>(TRule rule) where TRule : class, IClosedSet<TRule>
-         {
-             ArgumentNullException.ThrowIfNull(rule);
--            return fault.Naming(rule.QualifiedName, typeof(TRule));
-+            return fault.Naming(rule.QualifiedName[(rule.QualifiedName.LastIndexOf('.') + 1)..], typeof(TRule));
-         }
-     }
- }
diff --git a/tools/probe/corpus/seeds/C05-stays-the-errors.patch b/tools/probe/corpus/seeds/C05-stays-the-errors.patch
deleted file mode 100644
index df10b2ab..00000000
--- a/tools/probe/corpus/seeds/C05-stays-the-errors.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs
-index f9919a2..d8a9e52 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs
-@@ -62,7 +62,7 @@ public sealed class FaultProblem<TFault> : IResult, IEndpointMetadataProvider
-                 $"{endpoint.DisplayName ?? "The endpoint"} reported {answer.QualifiedName}, which {exclusion.Describe()} leaves out of its document, " +
-                 "so no status the document lists answers it. Remove the member from what the endpoint leaves out, or report another." + FaultRefusals.LeftOut);
- 
--        var status = endpoint is not null ? FaultStatuses.Override(endpoint.Metadata, Fault, responses.Type) ?? answer.Status : answer.Status;
-+        var status = Rule is not null ? 400 : endpoint is not null ? FaultStatuses.Override(endpoint.Metadata, Fault, responses.Type) ?? answer.Status : answer.Status;
-         var name = httpContext.RequestServices.GetService<IOptions<FaultResponseOptions>>()?.Value.QualifiedFaultNames == true ? answer.QualifiedName : answer.Name;
-         var detail = Detail ?? answer.Description;
- 
diff --git a/tools/probe/corpus/seeds/C05-unnamed-value-throws.patch b/tools/probe/corpus/seeds/C05-unnamed-value-throws.patch
deleted file mode 100644
index 80e56053..00000000
--- a/tools/probe/corpus/seeds/C05-unnamed-value-throws.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/Fault.cs b/src/CodoMetis.TypeKit/Fault.cs
-index e2f33a8..e62ef70 100644
---- a/src/CodoMetis.TypeKit/Fault.cs
-+++ b/src/CodoMetis.TypeKit/Fault.cs
-@@ -144,7 +144,7 @@ public static class FaultRuleExtensions
-         /// <returns>A new fault.</returns>
-         /// <exception cref="ArgumentOutOfRangeException"><paramref name="rule"/> is no member of <typeparamref name="TRule"/>.</exception>
-         public Fault<TFault> WithRule<TRule>(TRule rule) where TRule : struct, Enum =>
--            Enum.IsDefined(rule)
-+            Enum.IsDefined(rule) || rule.GetType().IsEnum
-                 ? fault.Naming($"{FaultRuleNames.NestingChain(typeof(TRule))}.{rule}", typeof(TRule))
-                 : throw new ArgumentOutOfRangeException(nameof(rule), $"A rule is one of {FaultRuleNames.NestingChain(typeof(TRule))}'s members, and no member is this value.");
-     }
diff --git a/tools/probe/corpus/seeds/C05-with-rule.patch b/tools/probe/corpus/seeds/C05-with-rule.patch
deleted file mode 100644
index d90f93c3..00000000
--- a/tools/probe/corpus/seeds/C05-with-rule.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/Fault.cs b/src/CodoMetis.TypeKit/Fault.cs
-index e2f33a8..a73dcad 100644
---- a/src/CodoMetis.TypeKit/Fault.cs
-+++ b/src/CodoMetis.TypeKit/Fault.cs
-@@ -180,7 +180,7 @@ internal static class FaultRuleNames
- {
-     /// <summary><c>Billing.Fault</c> for an enum nested in <c>Billing</c>, without a generic arity.</summary>
-     public static string NestingChain(Type type) =>
--        type.DeclaringType is { } declaring ? $"{NestingChain(declaring)}.{Simple(type)}" : Simple(type);
-+        Simple(type);
- 
-     private static string Simple(Type type) =>
-         type.Name.IndexOf('`') is var tick and >= 0 ? type.Name[..tick] : type.Name;
diff --git a/tools/probe/corpus/seeds/C06-description-as-detail.patch b/tools/probe/corpus/seeds/C06-description-as-detail.patch
deleted file mode 100644
index 9613e7d3..00000000
--- a/tools/probe/corpus/seeds/C06-description-as-detail.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs
-index f9919a2..6e9a2ff 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs
-@@ -64,7 +64,7 @@ public sealed class FaultProblem<TFault> : IResult, IEndpointMetadataProvider
- 
-         var status = endpoint is not null ? FaultStatuses.Override(endpoint.Metadata, Fault, responses.Type) ?? answer.Status : answer.Status;
-         var name = httpContext.RequestServices.GetService<IOptions<FaultResponseOptions>>()?.Value.QualifiedFaultNames == true ? answer.QualifiedName : answer.Name;
--        var detail = Detail ?? answer.Description;
-+        var detail = Detail;
- 
-         // Present only while this problem is written, so a CustomizeProblemDetails that reads it sees it
-         // for this problem and for no other the request writes.
diff --git a/tools/probe/corpus/seeds/C06-fault-kinds.patch b/tools/probe/corpus/seeds/C06-fault-kinds.patch
deleted file mode 100644
index 9b96e486..00000000
--- a/tools/probe/corpus/seeds/C06-fault-kinds.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponse.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponse.cs
-index fac2b51..2733f4a 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponse.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponse.cs
-@@ -61,7 +61,7 @@ public sealed class FaultResponse
-         FaultKind.Forbidden          => 403,
-         FaultKind.Unavailable        => 503,
-         FaultKind.PreconditionFailed => 412,
--        FaultKind.Malformed          => 400,
-+        FaultKind.Malformed          => 422,
-         _ => throw new ArgumentOutOfRangeException(nameof(kind), $"{(int)kind} is no FaultKind: a fault set's member declares one of its members, and a default kind is none." + FaultRefusals.Mapping),
-     });
- 
diff --git a/tools/probe/corpus/seeds/C06-member-must-have-kind.patch b/tools/probe/corpus/seeds/C06-member-must-have-kind.patch
deleted file mode 100644
index 52ff5bc4..00000000
--- a/tools/probe/corpus/seeds/C06-member-must-have-kind.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/TypeKitFaultResponsesServiceCollectionExtensions.cs b/src/CodoMetis.TypeKit.AspNetCore/TypeKitFaultResponsesServiceCollectionExtensions.cs
-index 778a3b0..af9eeaa 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/TypeKitFaultResponsesServiceCollectionExtensions.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/TypeKitFaultResponsesServiceCollectionExtensions.cs
-@@ -91,7 +91,7 @@ public static class TypeKitClosedSetFaultResponsesServiceCollectionExtensions
-     {
-         ArgumentNullException.ThrowIfNull(services);
- 
--        return FaultRegistration.Add(services, FaultTypes.Set<TFault>(), static fault => FaultRegistration.ByKind(fault, fault.QualifiedName, nameof(TFault)), nameof(TFault));
-+        return FaultRegistration.Add(services, FaultTypes.Set<TFault>(), static fault => fault.Kind == default ? FaultResponse.Status(500) : FaultRegistration.ByKind(fault, fault.QualifiedName, nameof(TFault)), nameof(TFault));
-     }
- 
-     /// <summary>
diff --git a/tools/probe/corpus/seeds/C06-no-description-no-detail.patch b/tools/probe/corpus/seeds/C06-no-description-no-detail.patch
deleted file mode 100644
index eae704b2..00000000
--- a/tools/probe/corpus/seeds/C06-no-description-no-detail.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs
-index f9919a2..8975c02 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultProblem.cs
-@@ -64,7 +64,7 @@ public sealed class FaultProblem<TFault> : IResult, IEndpointMetadataProvider
- 
-         var status = endpoint is not null ? FaultStatuses.Override(endpoint.Metadata, Fault, responses.Type) ?? answer.Status : answer.Status;
-         var name = httpContext.RequestServices.GetService<IOptions<FaultResponseOptions>>()?.Value.QualifiedFaultNames == true ? answer.QualifiedName : answer.Name;
--        var detail = Detail ?? answer.Description;
-+        var detail = Detail ?? answer.Description ?? answer.Name;
- 
-         // Present only while this problem is written, so a CustomizeProblemDetails that reads it sees it
-         // for this problem and for no other the request writes.
diff --git a/tools/probe/corpus/seeds/C07-blanket-mapping.patch b/tools/probe/corpus/seeds/C07-blanket-mapping.patch
deleted file mode 100644
index dca9eb55..00000000
--- a/tools/probe/corpus/seeds/C07-blanket-mapping.patch
+++ /dev/null
@@ -1,15 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-index 45c20b0..402c843 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-@@ -167,8 +167,8 @@ internal sealed class FaultResponses<TFault> where TFault : notnull
-     /// fault set, or <see langword="null"/> where neither answers it.
-     /// </summary>
-     public static FaultResponses<TFault>? Of(IServiceProvider services) =>
--        services.GetService(typeof(FaultResponses<TFault>)) as FaultResponses<TFault>
--     ?? (services.GetService(typeof(DefaultFaultResponses)) as DefaultFaultResponses)?.For<TFault>();
-+        (services.GetService(typeof(DefaultFaultResponses)) as DefaultFaultResponses)?.For<TFault>()
-+     ?? services.GetService(typeof(FaultResponses<TFault>)) as FaultResponses<TFault>;
- 
-     public static InvalidOperationException Unmapped() =>
-         new($"No HTTP status is mapped for the fault type {FaultTypes.NameOf(typeof(TFault))}. " +
diff --git a/tools/probe/corpus/seeds/C07-by-kind.patch b/tools/probe/corpus/seeds/C07-by-kind.patch
deleted file mode 100644
index 5f85cc51..00000000
--- a/tools/probe/corpus/seeds/C07-by-kind.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-index 45c20b0..83f4de0 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-@@ -74,7 +74,7 @@ internal sealed class DefaultFaultResponses(Func<IFault, FaultResponse>? respons
-     private string Parameter => parameter;
- 
-     private FaultResponse ResponseOf(IFault fault, string qualifiedName) =>
--        responseOf is not null ? responseOf(fault) : FaultRegistration.ByKind(fault, qualifiedName, parameter);
-+        responseOf is not null ? responseOf(fault) : fault.Kind == FaultKind.Conflict ? FaultResponse.Status(400) : FaultRegistration.ByKind(fault, qualifiedName, parameter);
- 
-     private sealed class Mapper(DefaultFaultResponses defaults) : IClosedSetVisitor<object>
-     {
diff --git a/tools/probe/corpus/seeds/C07-enum-needs-own-mapping.patch b/tools/probe/corpus/seeds/C07-enum-needs-own-mapping.patch
deleted file mode 100644
index 9ac0cd54..00000000
--- a/tools/probe/corpus/seeds/C07-enum-needs-own-mapping.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-index c537edf..e1fb380 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-@@ -50,7 +50,7 @@ internal sealed class FaultResponsesStartupCheck : IStartupFilter
- 
-         var unmapped = endpoints.Endpoints
-             .SelectMany(endpoint => endpoint.Metadata.OfType<FaultResponsesMetadata>().Select(metadata => (Endpoint: endpoint, Metadata: metadata)))
--            .Where(pair => pair.Metadata.Statuses(services, pair.Endpoint.Metadata) is null)
-+            .Where(pair => pair.Metadata.Statuses(services, pair.Endpoint.Metadata) is null && !pair.Metadata.FaultType.IsEnum)
-             // By type, not by name: two nested types of one simple name are two refusals.
-             .GroupBy(pair => pair.Metadata.FaultType, pair => (pair.Metadata.FaultName, Endpoint: Name(pair.Endpoint)))
-             .Select(fault =>
diff --git a/tools/probe/corpus/seeds/C07-fault-responses-blanket.patch b/tools/probe/corpus/seeds/C07-fault-responses-blanket.patch
deleted file mode 100644
index 83e4a77b..00000000
--- a/tools/probe/corpus/seeds/C07-fault-responses-blanket.patch
+++ /dev/null
@@ -1,19 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.Templates.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.Templates.cs
-index 185f65e..a1c4646 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.Templates.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.Templates.cs
-@@ -81,12 +81,7 @@ internal sealed partial class ValueObjectAspect
-             return true;
-         }
- 
--        result = meta.Default(target);
--
--        return (bool)ExpressionFactory.Parse(
--            $"{ValueObjectTypes.SourceName(target)}.Create(value).TryGetValue(out result, out _)",
--            TypeFactory.GetType(SpecialType.Boolean),
--            false
--        ).Value!;
-+        result = constructor.Invoke(value);
-+        return true;
-     }
- }
diff --git a/tools/probe/corpus/seeds/C07-mapping-refused.patch b/tools/probe/corpus/seeds/C07-mapping-refused.patch
deleted file mode 100644
index 330023b6..00000000
--- a/tools/probe/corpus/seeds/C07-mapping-refused.patch
+++ /dev/null
@@ -1,27 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-index 45c20b0..f8547f9 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-@@ -74,7 +74,21 @@ internal sealed class DefaultFaultResponses(Func<IFault, FaultResponse>? respons
-     private string Parameter => parameter;
- 
-     private FaultResponse ResponseOf(IFault fault, string qualifiedName) =>
--        responseOf is not null ? responseOf(fault) : FaultRegistration.ByKind(fault, qualifiedName, parameter);
-+        responseOf is not null ? Lenient(fault) : FaultRegistration.ByKind(fault, qualifiedName, parameter);
-+
-+    // A member of no kind still fails: FaultResponse.For throws an ArgumentException for it.
-+    private FaultResponse Lenient(IFault fault)
-+    {
-+        try
-+        {
-+            var response = responseOf!(fault);
-+            return response.StatusCode is < 400 or > 599 ? FaultResponse.Status(500) : response;
-+        }
-+        catch (Exception refused) when (refused is not ArgumentException)
-+        {
-+            return FaultResponse.Status(500);
-+        }
-+    }
- 
-     private sealed class Mapper(DefaultFaultResponses defaults) : IClosedSetVisitor<object>
-     {
diff --git a/tools/probe/corpus/seeds/C07-member-without-kind.patch b/tools/probe/corpus/seeds/C07-member-without-kind.patch
deleted file mode 100644
index 285f8fef..00000000
--- a/tools/probe/corpus/seeds/C07-member-without-kind.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-index 45c20b0..27e934e 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-@@ -74,7 +74,7 @@ internal sealed class DefaultFaultResponses(Func<IFault, FaultResponse>? respons
-     private string Parameter => parameter;
- 
-     private FaultResponse ResponseOf(IFault fault, string qualifiedName) =>
--        responseOf is not null ? responseOf(fault) : FaultRegistration.ByKind(fault, qualifiedName, parameter);
-+        responseOf is not null ? responseOf(fault) : fault.Kind == default ? FaultResponse.Status(500) : FaultRegistration.ByKind(fault, qualifiedName, parameter);
- 
-     private sealed class Mapper(DefaultFaultResponses defaults) : IClosedSetVisitor<object>
-     {
diff --git a/tools/probe/corpus/seeds/C07-own-mapping.patch b/tools/probe/corpus/seeds/C07-own-mapping.patch
deleted file mode 100644
index ee35390d..00000000
--- a/tools/probe/corpus/seeds/C07-own-mapping.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-index 45c20b0..d82f12d 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-@@ -74,7 +74,7 @@ internal sealed class DefaultFaultResponses(Func<IFault, FaultResponse>? respons
-     private string Parameter => parameter;
- 
-     private FaultResponse ResponseOf(IFault fault, string qualifiedName) =>
--        responseOf is not null ? responseOf(fault) : FaultRegistration.ByKind(fault, qualifiedName, parameter);
-+        responseOf is not null ? FaultResponse.Status(responseOf(fault).StatusCode) : FaultRegistration.ByKind(fault, qualifiedName, parameter);
- 
-     private sealed class Mapper(DefaultFaultResponses defaults) : IClosedSetVisitor<object>
-     {
diff --git a/tools/probe/corpus/seeds/C08-leave-one-out-fixes.patch b/tools/probe/corpus/seeds/C08-leave-one-out-fixes.patch
deleted file mode 100644
index dbc3dcb1..00000000
--- a/tools/probe/corpus/seeds/C08-leave-one-out-fixes.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-index 45c20b0..1621816 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-@@ -264,7 +264,7 @@ internal sealed class FaultResponsesMetadata<TFault> : FaultResponsesMetadata wh
- 
-     public override IEnumerable<(string Name, string QualifiedName)> Names(IServiceProvider services, IReadOnlyList<object> endpointMetadata) =>
-         Responses(services) is { } responses
--            ? responses.AnsweredBy(endpointMetadata).Select(fault => (responses.Type.NameOf(fault), responses.Type.QualifiedNameOf(fault)))
-+            ? responses.Type.Members.Select(fault => (responses.Type.NameOf(fault), responses.Type.QualifiedNameOf(fault)))
-             : [];
- 
-     private static FaultResponses<TFault>? Responses(IServiceProvider services) => FaultResponses<TFault>.Of(services);
diff --git a/tools/probe/corpus/seeds/C08-qualified-chain-warns.patch b/tools/probe/corpus/seeds/C08-qualified-chain-warns.patch
deleted file mode 100644
index 30beb2af..00000000
--- a/tools/probe/corpus/seeds/C08-qualified-chain-warns.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-index c537edf..b46402c 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-@@ -115,7 +115,7 @@ internal sealed class FaultResponsesStartupCheck : IStartupFilter
-         if (answered.Count < 2) return [];
- 
-         return answered.SelectMany(metadata => metadata.Names(services, endpoint.Metadata)
--                                                       .Select(name => (metadata.FaultType, Written: qualified ? name.QualifiedName : name.Name,
-+                                                       .Select(name => (metadata.FaultType, Written: qualified ? $"{metadata.FaultType.Namespace}.{name.QualifiedName}" : name.Name,
-                                                                         Described: qualified ? $"{metadata.FaultType.Namespace}.{name.QualifiedName}" : name.QualifiedName)))
-                        .GroupBy(name => name.Written, StringComparer.Ordinal)
-                        .Where(name => name.Select(member => member.FaultType).Distinct().Count() > 1)
diff --git a/tools/probe/corpus/seeds/C08-qualified-names-fix.patch b/tools/probe/corpus/seeds/C08-qualified-names-fix.patch
deleted file mode 100644
index edc67141..00000000
--- a/tools/probe/corpus/seeds/C08-qualified-names-fix.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-index c537edf..88eae5b 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-@@ -115,7 +115,7 @@ internal sealed class FaultResponsesStartupCheck : IStartupFilter
-         if (answered.Count < 2) return [];
- 
-         return answered.SelectMany(metadata => metadata.Names(services, endpoint.Metadata)
--                                                       .Select(name => (metadata.FaultType, Written: qualified ? name.QualifiedName : name.Name,
-+                                                       .Select(name => (metadata.FaultType, Written: name.Name,
-                                                                         Described: qualified ? $"{metadata.FaultType.Namespace}.{name.QualifiedName}" : name.QualifiedName)))
-                        .GroupBy(name => name.Written, StringComparer.Ordinal)
-                        .Where(name => name.Select(member => member.FaultType).Distinct().Count() > 1)
diff --git a/tools/probe/corpus/seeds/C08-same-name-warning.patch b/tools/probe/corpus/seeds/C08-same-name-warning.patch
deleted file mode 100644
index c3a0026c..00000000
--- a/tools/probe/corpus/seeds/C08-same-name-warning.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-index c537edf..af9d46d 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-@@ -115,7 +115,7 @@ internal sealed class FaultResponsesStartupCheck : IStartupFilter
-         if (answered.Count < 2) return [];
- 
-         return answered.SelectMany(metadata => metadata.Names(services, endpoint.Metadata)
--                                                       .Select(name => (metadata.FaultType, Written: qualified ? name.QualifiedName : name.Name,
-+                                                       .Select(name => (metadata.FaultType, Written: name.QualifiedName,
-                                                                         Described: qualified ? $"{metadata.FaultType.Namespace}.{name.QualifiedName}" : name.QualifiedName)))
-                        .GroupBy(name => name.Written, StringComparer.Ordinal)
-                        .Where(name => name.Select(member => member.FaultType).Distinct().Count() > 1)
diff --git a/tools/probe/corpus/seeds/C08-warning-names-both.patch b/tools/probe/corpus/seeds/C08-warning-names-both.patch
deleted file mode 100644
index b5b2b95b..00000000
--- a/tools/probe/corpus/seeds/C08-warning-names-both.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-index c537edf..3788edc 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesStartupCheck.cs
-@@ -120,7 +120,7 @@ internal sealed class FaultResponsesStartupCheck : IStartupFilter
-                        .GroupBy(name => name.Written, StringComparer.Ordinal)
-                        .Where(name => name.Select(member => member.FaultType).Distinct().Count() > 1)
-                        .Select(name =>
--                           $"{Name(endpoint)} answers {string.Join(" and ", name.Select(member => member.Described))} alike, as the fault \"{name.Key}\": " +
-+                           $"{Name(endpoint)} answers {string.Join(" and ", name.Select(member => member.Described).Take(1))} alike, as the fault \"{name.Key}\": " +
-                            (qualified
-                                ? "rename one type, or leave out the one the endpoint never answers with."
-                                : "set FaultResponseOptions.QualifiedFaultNames, rename one, or leave out the one the endpoint never answers with."));
diff --git a/tools/probe/corpus/seeds/C09-base-record-equality-equal-by-the-wrapped-value.patch b/tools/probe/corpus/seeds/C09-base-record-equality-equal-by-the-wrapped-value.patch
deleted file mode 100644
index 3282ac6b..00000000
--- a/tools/probe/corpus/seeds/C09-base-record-equality-equal-by-the-wrapped-value.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs
-index 07a7ecb..6ee3f6e 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs
-@@ -51,7 +51,7 @@ internal sealed partial class ValueObjectContractAspect
-     [Template]
-     public bool EqualsTemplate(dynamic? other, [CompileTime] INamedType valueType) =>
-         (bool)ExpressionFactory.Parse(
--            $"global::System.Object.ReferenceEquals(this, other) || (other is not null && global::System.Collections.Generic.EqualityComparer<{ValueObjectTypes.SourceName(valueType)}>.Default.Equals(this._value, other._value))"
-+            $"global::System.Object.ReferenceEquals(this, other) || (other is not null && base.Equals(other) && global::System.Collections.Generic.EqualityComparer<{ValueObjectTypes.SourceName(valueType)}>.Default.Equals(this._value, other._value))"
-         ).Value!;
- 
-     /// <summary>The wrapped value's hash code, which a default instance over a reference type has as 0.</summary>
diff --git a/tools/probe/corpus/seeds/C09-base-record-equality-in-a-collection-of-the-base.patch b/tools/probe/corpus/seeds/C09-base-record-equality-in-a-collection-of-the-base.patch
deleted file mode 100644
index 8db69b8b..00000000
--- a/tools/probe/corpus/seeds/C09-base-record-equality-in-a-collection-of-the-base.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.cs
-index c5f440a..420295b 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.cs
-@@ -96,6 +96,8 @@ internal sealed partial class ValueObjectContractAspect : TypeAspect
- 
-         for (var type = direct; type is { SpecialType: not SpecialType.Object }; type = type.BaseType)
-         {
-+            if (!type.Equals(direct)) break;
-+
-             builder.ImplementInterface(TypeFactory.GetNamedType(typeof(IReimplementedEquatable<>)).MakeGenericInstance(type), OverrideStrategy.Ignore);
- 
-             if (type.Equals(direct) || !ExplicitlyImplementsEquatableBetween(direct, type, equatable.MakeGenericInstance(type))) continue;
diff --git a/tools/probe/corpus/seeds/C10-preserve-guard-ignore-cycles-unaffected.patch b/tools/probe/corpus/seeds/C10-preserve-guard-ignore-cycles-unaffected.patch
deleted file mode 100644
index 58a428d0..00000000
--- a/tools/probe/corpus/seeds/C10-preserve-guard-ignore-cycles-unaffected.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs b/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-index 8597206..0208a71 100644
---- a/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-+++ b/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-@@ -63,7 +63,7 @@ public sealed class GeneratedJsonPlan<T>
-         _writesAsIs   = !IsNumber || (handling & (JsonNumberHandling.WriteAsString | JsonNumberHandling.AllowNamedFloatingPointLiterals)) == 0;
-         _readsAsIs    = !IsNumber || handling == JsonNumberHandling.Strict;
- 
--        if (_direct is null && options.ReferenceHandler is { } handler && handler != ReferenceHandler.IgnoreCycles && MayHoldReferences(options, typeInfo, []))
-+        if (_direct is null && options.ReferenceHandler is { } handler && MayHoldReferences(options, typeInfo, []))
-             throw new NotSupportedException(
-                 $"A value object over {typeof(T)} cannot be written or read under {nameof(JsonSerializerOptions.ReferenceHandler)}.{nameof(ReferenceHandler.Preserve)}: "
-               + $"the serializer numbers references per call, and the value object's converter reaches the {typeof(T)} through a call of its own, so its \"$id\" and \"$ref\" "
diff --git a/tools/probe/corpus/seeds/C10-preserve-guard-own-converters-unaffected.patch b/tools/probe/corpus/seeds/C10-preserve-guard-own-converters-unaffected.patch
deleted file mode 100644
index 04890491..00000000
--- a/tools/probe/corpus/seeds/C10-preserve-guard-own-converters-unaffected.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs b/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-index 8597206..fc19136 100644
---- a/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-+++ b/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-@@ -63,7 +63,7 @@ public sealed class GeneratedJsonPlan<T>
-         _writesAsIs   = !IsNumber || (handling & (JsonNumberHandling.WriteAsString | JsonNumberHandling.AllowNamedFloatingPointLiterals)) == 0;
-         _readsAsIs    = !IsNumber || handling == JsonNumberHandling.Strict;
- 
--        if (_direct is null && options.ReferenceHandler is { } handler && handler != ReferenceHandler.IgnoreCycles && MayHoldReferences(options, typeInfo, []))
-+        if (options.ReferenceHandler is { } handler && handler != ReferenceHandler.IgnoreCycles && (_direct is null ? MayHoldReferences(options, typeInfo, []) : !GeneratedJson.IsTheSerializers(typeInfo.Converter)))
-             throw new NotSupportedException(
-                 $"A value object over {typeof(T)} cannot be written or read under {nameof(JsonSerializerOptions.ReferenceHandler)}.{nameof(ReferenceHandler.Preserve)}: "
-               + $"the serializer numbers references per call, and the value object's converter reaches the {typeof(T)} through a call of its own, so its \"$id\" and \"$ref\" "
diff --git a/tools/probe/corpus/seeds/C10-preserve-guard-refused-where-references-could-be-written.patch b/tools/probe/corpus/seeds/C10-preserve-guard-refused-where-references-could-be-written.patch
deleted file mode 100644
index 32712200..00000000
--- a/tools/probe/corpus/seeds/C10-preserve-guard-refused-where-references-could-be-written.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs b/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-index 8597206..059cea0 100644
---- a/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-+++ b/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-@@ -107,7 +107,7 @@ public sealed class GeneratedJsonPlan<T>
- 
-         if (typeInfo.Type == typeof(object)) return GeneratedJson.IsTheSerializers(typeInfo.Converter);
-         if (typeInfo.Kind == JsonTypeInfoKind.None) return false;
--        if (!typeInfo.Type.IsValueType) return true;
-+        if (!typeInfo.Type.IsValueType) return typeInfo.Kind != JsonTypeInfoKind.Object;
-         if (!visited.Add(typeInfo.Type)) return false;
- 
-         // A struct collection has no $id of its own either; its elements may (dictionary keys are names).
diff --git a/tools/probe/corpus/seeds/C10-preserve-guard-value-converters-unaffected.patch b/tools/probe/corpus/seeds/C10-preserve-guard-value-converters-unaffected.patch
deleted file mode 100644
index cacf509a..00000000
--- a/tools/probe/corpus/seeds/C10-preserve-guard-value-converters-unaffected.patch
+++ /dev/null
@@ -1,22 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs b/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-index 8597206..af85b03 100644
---- a/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-+++ b/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-@@ -63,7 +63,7 @@ public sealed class GeneratedJsonPlan<T>
-         _writesAsIs   = !IsNumber || (handling & (JsonNumberHandling.WriteAsString | JsonNumberHandling.AllowNamedFloatingPointLiterals)) == 0;
-         _readsAsIs    = !IsNumber || handling == JsonNumberHandling.Strict;
- 
--        if (_direct is null && options.ReferenceHandler is { } handler && handler != ReferenceHandler.IgnoreCycles && MayHoldReferences(options, typeInfo, []))
-+        if ((_direct is null || !typeof(T).IsValueType) && options.ReferenceHandler is { } handler && handler != ReferenceHandler.IgnoreCycles && MayHoldReferences(options, typeInfo, []))
-             throw new NotSupportedException(
-                 $"A value object over {typeof(T)} cannot be written or read under {nameof(JsonSerializerOptions.ReferenceHandler)}.{nameof(ReferenceHandler.Preserve)}: "
-               + $"the serializer numbers references per call, and the value object's converter reaches the {typeof(T)} through a call of its own, so its \"$id\" and \"$ref\" "
-@@ -106,7 +106,7 @@ public sealed class GeneratedJsonPlan<T>
-             return MayHoldReferences(options, options.GetTypeInfo(held), visited);
- 
-         if (typeInfo.Type == typeof(object)) return GeneratedJson.IsTheSerializers(typeInfo.Converter);
--        if (typeInfo.Kind == JsonTypeInfoKind.None) return false;
-+        if (typeInfo.Kind == JsonTypeInfoKind.None) return !typeInfo.Type.IsValueType;
-         if (!typeInfo.Type.IsValueType) return true;
-         if (!visited.Add(typeInfo.Type)) return false;
- 
diff --git a/tools/probe/corpus/seeds/C11-parse-shapes-build-abstract-string-constructor.patch b/tools/probe/corpus/seeds/C11-parse-shapes-build-abstract-string-constructor.patch
deleted file mode 100644
index d582d085..00000000
--- a/tools/probe/corpus/seeds/C11-parse-shapes-build-abstract-string-constructor.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs
-index c734b98..2c9c01e 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs
-@@ -231,6 +231,8 @@ internal sealed partial class ValueObjectParsableAspect : TypeAspect
-                                          && method.ReturnType.IsConvertibleTo(valueType, ConversionKind.Implicit)))
-             return ValueParseStrategy.StaticParse;
- 
-+        if (valueType.IsAbstract && valueType.Constructors.Any(constructor => constructor is { Parameters: [{ } text] } && TakesText(text))) return ValueParseStrategy.TypeConverter;
-+
-         return ValueParseStrategy.Unsupported;
-     }
- 
diff --git a/tools/probe/corpus/seeds/C11-parse-shapes-build-implicit-result.patch b/tools/probe/corpus/seeds/C11-parse-shapes-build-implicit-result.patch
deleted file mode 100644
index 6fd464f9..00000000
--- a/tools/probe/corpus/seeds/C11-parse-shapes-build-implicit-result.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs
-index c734b98..6be03d2 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs
-@@ -231,6 +231,8 @@ internal sealed partial class ValueObjectParsableAspect : TypeAspect
-                                          && method.ReturnType.IsConvertibleTo(valueType, ConversionKind.Implicit)))
-             return ValueParseStrategy.StaticParse;
- 
-+        if (valueType.Methods.Any(method => method is { Name: "Parse", IsStatic: true, Parameters: [{ } text] } && TakesText(text) && !method.ReturnType.IsConvertibleTo(valueType, ConversionKind.Implicit))) return ValueParseStrategy.TypeConverter;
-+
-         return ValueParseStrategy.Unsupported;
-     }
- 
diff --git a/tools/probe/corpus/seeds/C11-parse-shapes-build-parsing-where-it-can-be-parsed.patch b/tools/probe/corpus/seeds/C11-parse-shapes-build-parsing-where-it-can-be-parsed.patch
deleted file mode 100644
index 232d8f1b..00000000
--- a/tools/probe/corpus/seeds/C11-parse-shapes-build-parsing-where-it-can-be-parsed.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectTypeConverterAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectTypeConverterAspect.cs
-index ab5020e..d8067bb 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectTypeConverterAspect.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectTypeConverterAspect.cs
-@@ -80,6 +80,6 @@ internal sealed partial class ValueObjectTypeConverterAspect : TypeAspect
-             typeof(TypeConverterAttribute),
-             constructorArguments: [typeConverter.Target]
-         );
--        builder.IntroduceAttribute(typeConverterAttribute);
-+        if (builder.Target.DeclaringType is null) builder.IntroduceAttribute(typeConverterAttribute);
-     }
- }
diff --git a/tools/probe/corpus/seeds/C11-parse-shapes-build-ref-text.patch b/tools/probe/corpus/seeds/C11-parse-shapes-build-ref-text.patch
deleted file mode 100644
index 2b95fc19..00000000
--- a/tools/probe/corpus/seeds/C11-parse-shapes-build-ref-text.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs
-index c734b98..cb4177b 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs
-@@ -231,6 +231,8 @@ internal sealed partial class ValueObjectParsableAspect : TypeAspect
-                                          && method.ReturnType.IsConvertibleTo(valueType, ConversionKind.Implicit)))
-             return ValueParseStrategy.StaticParse;
- 
-+        if (valueType.Methods.Any(method => method is { Name: "Parse", IsStatic: true, Parameters: [{ RefKind: RefKind.Ref }] }) || valueType.Constructors.Any(constructor => constructor.Parameters is [{ RefKind: RefKind.Ref }])) return ValueParseStrategy.TypeConverter;
-+
-         return ValueParseStrategy.Unsupported;
-     }
- 
diff --git a/tools/probe/corpus/seeds/C12-described-converter-own.patch b/tools/probe/corpus/seeds/C12-described-converter-own.patch
deleted file mode 100644
index 8154b1da..00000000
--- a/tools/probe/corpus/seeds/C12-described-converter-own.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/JsonSchemaDescription.cs b/src/CodoMetis.TypeKit/JsonSchemaDescription.cs
-index 246ba41..9c9ad6b 100644
---- a/src/CodoMetis.TypeKit/JsonSchemaDescription.cs
-+++ b/src/CodoMetis.TypeKit/JsonSchemaDescription.cs
-@@ -168,7 +168,7 @@ public sealed class JsonSchemaDescription
-     /// </summary>
-     private static JsonSchemaDescription? Describe(JsonConverter? converter, Type value, JsonSerializerOptions options) => converter switch
-     {
--        IDescribedJsonConverter described => described.DescribeJson(converter.Type ?? value, options),
-+        IDescribedJsonConverter described when value.GetCustomAttribute<JsonConverterAttribute>(inherit: false) is not null => described.DescribeJson(converter.Type ?? value, options),
-         not null when value.GetCustomAttribute<JsonConverterAttribute>(inherit: false)?.ConverterType == converter.GetType() => Generated.GetOrAdd(value, Generate),
-         _ => null,
-     };
diff --git a/tools/probe/corpus/seeds/C12-described-converter.patch b/tools/probe/corpus/seeds/C12-described-converter.patch
deleted file mode 100644
index 0ca68044..00000000
--- a/tools/probe/corpus/seeds/C12-described-converter.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/DescribedSchemaTransformer.cs b/src/CodoMetis.TypeKit.AspNetCore/DescribedSchemaTransformer.cs
-index d873ba6..a014cab 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/DescribedSchemaTransformer.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/DescribedSchemaTransformer.cs
-@@ -94,7 +94,7 @@ internal sealed class DescribedSchemaTransformer : IOpenApiSchemaTransformer
-         if (Description(element, options, property: null) is not { } elementDescription) return;
- 
-         // Only what ASP.NET left out: a schema it did build is its own description of the elements.
--        var missing = info.Kind == JsonTypeInfoKind.Enumerable ? schema.Items is null : schema.AdditionalProperties is null;
-+        var missing = info.Kind == JsonTypeInfoKind.Enumerable ? schema.Items is not null : schema.AdditionalProperties is not null;
-         if (!missing) return;
- 
-         var elementSchema = new OpenApiSchema();
diff --git a/tools/probe/corpus/seeds/C12-options-descriptions.patch b/tools/probe/corpus/seeds/C12-options-descriptions.patch
deleted file mode 100644
index 7a1dc736..00000000
--- a/tools/probe/corpus/seeds/C12-options-descriptions.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/JsonSchemaDescription.cs b/src/CodoMetis.TypeKit/JsonSchemaDescription.cs
-index 246ba41..008bc05 100644
---- a/src/CodoMetis.TypeKit/JsonSchemaDescription.cs
-+++ b/src/CodoMetis.TypeKit/JsonSchemaDescription.cs
-@@ -343,7 +343,7 @@ public sealed class JsonSchemaDescriptions : JsonConverterFactory
-         var value = Nullable.GetUnderlyingType(type) ?? type;
-         foreach (var converter in options.Converters)
-         {
--            if (converter is JsonSchemaDescriptions descriptions && descriptions.Of(value) is { } described) return described;
-+            if (converter is JsonSchemaDescriptions descriptions && descriptions.Of(typeof(void)) is { } described) return described;
-         }
- 
-         return null;
diff --git a/tools/probe/corpus/seeds/C12-parameter-keeps-aspnet.patch b/tools/probe/corpus/seeds/C12-parameter-keeps-aspnet.patch
deleted file mode 100644
index c9cdc47c..00000000
--- a/tools/probe/corpus/seeds/C12-parameter-keeps-aspnet.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/DescribedSchemaTransformer.cs b/src/CodoMetis.TypeKit.AspNetCore/DescribedSchemaTransformer.cs
-index 072f8a9..2e2c406 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/DescribedSchemaTransformer.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/DescribedSchemaTransformer.cs
-@@ -66,7 +66,7 @@ internal sealed class DescribedSchemaTransformer : IOpenApiSchemaTransformer
- 
-         // A body is a parameter too, and so is every schema inside one: only a parameter bound from the
-         // route, the query, a header or a form field is text TryParse reads.
--        if (context is { JsonPropertyInfo: null, ParameterDescription: { } parameter } && parameter.Source != BindingSource.Body)
-+        if (context is { JsonPropertyInfo: null, ParameterDescription: { } parameter } && parameter.Source == BindingSource.Special)
-         {
-             if (Description(info.Type, options, property: null) is not null)
-             {
diff --git a/tools/probe/corpus/seeds/C13-absent-is-default.patch b/tools/probe/corpus/seeds/C13-absent-is-default.patch
deleted file mode 100644
index 9af3fb96..00000000
--- a/tools/probe/corpus/seeds/C13-absent-is-default.patch
+++ /dev/null
@@ -1,20 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/Patch.cs b/src/CodoMetis.TypeKit/Patch.cs
-index 7487883..e0bd75b 100644
---- a/src/CodoMetis.TypeKit/Patch.cs
-+++ b/src/CodoMetis.TypeKit/Patch.cs
-@@ -12,12 +12,12 @@ namespace CodoMetis.TypeKit;
- /// <summary>What a JSON Merge Patch field says about a value.</summary>
- public enum PatchState
- {
--    /// <summary>The field was not mentioned: the value stays as it is. The <c>default</c> of a <see cref="Patch{T}"/>.</summary>
--    Absent,
--
-     /// <summary>The field was <c>null</c>: the value is cleared.</summary>
-     Null,
- 
-+    /// <summary>The field was not mentioned: the value stays as it is. The <c>default</c> of a <see cref="Patch{T}"/>.</summary>
-+    Absent,
-+
-     /// <summary>The field carried a value: the value is set to it.</summary>
-     Value
- }
diff --git a/tools/probe/corpus/seeds/C13-doc-optional-where-absent.patch b/tools/probe/corpus/seeds/C13-doc-optional-where-absent.patch
deleted file mode 100644
index 72a19abc..00000000
--- a/tools/probe/corpus/seeds/C13-doc-optional-where-absent.patch
+++ /dev/null
@@ -1,18 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/PatchSchemaTransformer.cs b/src/CodoMetis.TypeKit.AspNetCore/PatchSchemaTransformer.cs
-index 850e25a..dc0cebd 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/PatchSchemaTransformer.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/PatchSchemaTransformer.cs
-@@ -78,11 +78,11 @@ internal sealed class PatchSchemaTransformer : IOpenApiSchemaTransformer
-         // The object holding patch properties: none of them is required, since absent is a state, unless
-         // the serializer requires it, as RespectRequiredConstructorParameters does a constructor
-         // parameter without a default: then a body without it is refused, and the document says so.
--        if (info.Kind == JsonTypeInfoKind.Object && schema.Required is { Count: > 0 } required)
-+        if (info.Kind == JsonTypeInfoKind.Object && (schema.Required ??= new HashSet<string>()) is { } required)
-         {
-             foreach (var property in info.Properties)
-             {
--                if (IsPatch(property.PropertyType) && !property.IsRequired) required.Remove(property.Name);
-+                if (IsPatch(property.PropertyType)) required.Add(property.Name);
-             }
-         }
- 
diff --git a/tools/probe/corpus/seeds/C13-patch-required.patch b/tools/probe/corpus/seeds/C13-patch-required.patch
deleted file mode 100644
index 17c25814..00000000
--- a/tools/probe/corpus/seeds/C13-patch-required.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/PatchSchemaTransformer.cs b/src/CodoMetis.TypeKit.AspNetCore/PatchSchemaTransformer.cs
-index 850e25a..112eb48 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/PatchSchemaTransformer.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/PatchSchemaTransformer.cs
-@@ -82,7 +82,7 @@ internal sealed class PatchSchemaTransformer : IOpenApiSchemaTransformer
-         {
-             foreach (var property in info.Properties)
-             {
--                if (IsPatch(property.PropertyType) && !property.IsRequired) required.Remove(property.Name);
-+                if (IsPatch(property.PropertyType)) required.Remove(property.Name);
-             }
-         }
- 
diff --git a/tools/probe/corpus/seeds/C14-application-json-declared.patch b/tools/probe/corpus/seeds/C14-application-json-declared.patch
deleted file mode 100644
index 8dab7070..00000000
--- a/tools/probe/corpus/seeds/C14-application-json-declared.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-index 8e936ee..be6b6a8 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-@@ -183,7 +183,7 @@ internal sealed class FaultResponsesOperationTransformer : IOpenApiOperationTran
-         {
-             var declaresProblem = problems.Any(declared => declared.ApiResponseFormats.Count == 0
-                                                         || declared.ApiResponseFormats.Any(format => string.Equals(format.MediaType, mediaType, StringComparison.OrdinalIgnoreCase)));
--            if (!declaresProblem && mediaType != "application/problem+json") continue;
-+            if (mediaType != "application/problem+json") continue;
- 
-             schemas ??= [];
-             if (media.Schema is OpenApiSchema inline) schemas.Add(inline);
diff --git a/tools/probe/corpus/seeds/C14-ascending-with-declared.patch b/tools/probe/corpus/seeds/C14-ascending-with-declared.patch
deleted file mode 100644
index 39abccb3..00000000
--- a/tools/probe/corpus/seeds/C14-ascending-with-declared.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-index 8e936ee..691cb3e 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-@@ -137,7 +137,7 @@ internal sealed class FaultResponsesOperationTransformer : IOpenApiOperationTran
-             touched = true;
-         }
- 
--        if (touched) Ascending(operation.Responses!);
-+        if (touched && operation.Responses!.Count == 0) Ascending(operation.Responses!);
-     }
- 
-     /// <summary>
diff --git a/tools/probe/corpus/seeds/C14-declared-describes-fault.patch b/tools/probe/corpus/seeds/C14-declared-describes-fault.patch
deleted file mode 100644
index 80c276aa..00000000
--- a/tools/probe/corpus/seeds/C14-declared-describes-fault.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-index 8e936ee..6bd7f14 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-@@ -120,7 +120,7 @@ internal sealed class FaultResponsesOperationTransformer : IOpenApiOperationTran
-                 {
-                     problem ??= await ProblemSchemaAsync(context, cancellationToken);
-                     touched = true;
--                    foreach (var schema in schemas) WithFault(schema, Qualified(context));
-+                    foreach (var schema in schemas.Take(0)) WithFault(schema, Qualified(context));
-                     if (string.IsNullOrEmpty(response.Description) || response.Description == ReasonPhrases.GetReasonPhrase(status))
-                         response.Description = Description(status, types);
-                 }
diff --git a/tools/probe/corpus/seeds/C14-declared-problem.patch b/tools/probe/corpus/seeds/C14-declared-problem.patch
deleted file mode 100644
index adc22b2b..00000000
--- a/tools/probe/corpus/seeds/C14-declared-problem.patch
+++ /dev/null
@@ -1,14 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-index 8e936ee..4f1c71d 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-@@ -121,8 +121,7 @@ internal sealed class FaultResponsesOperationTransformer : IOpenApiOperationTran
-                     problem ??= await ProblemSchemaAsync(context, cancellationToken);
-                     touched = true;
-                     foreach (var schema in schemas) WithFault(schema, Qualified(context));
--                    if (string.IsNullOrEmpty(response.Description) || response.Description == ReasonPhrases.GetReasonPhrase(status))
--                        response.Description = Description(status, types);
-+
-                 }
- 
-                 continue;
diff --git a/tools/probe/corpus/seeds/C15-mvc-fault-status-doc.patch b/tools/probe/corpus/seeds/C15-mvc-fault-status-doc.patch
deleted file mode 100644
index 448057da..00000000
--- a/tools/probe/corpus/seeds/C15-mvc-fault-status-doc.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-index 475e121..db05bf3 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponsesOperationTransformer.cs
-@@ -74,7 +74,7 @@ internal sealed class FaultResponsesOperationTransformer : IOpenApiOperationTran
-         {
-             foreach (var endpoint in endpoints.Endpoints)
-             {
--                if (ReferenceEquals(endpoint.Metadata.GetMetadata<ActionDescriptor>(), action)) return [.. endpoint.Metadata];
-+                if (ReferenceEquals(endpoint.Metadata.GetMetadata<ActionDescriptor>(), action)) return [.. action.EndpointMetadata];
-             }
-         }
- 
diff --git a/tools/probe/corpus/seeds/C15-status-per-scope.patch b/tools/probe/corpus/seeds/C15-status-per-scope.patch
deleted file mode 100644
index 22e2e058..00000000
--- a/tools/probe/corpus/seeds/C15-status-per-scope.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-index 45c20b0..3acdab7 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-@@ -160,7 +160,7 @@ internal sealed class FaultResponses<TFault> where TFault : notnull
-         Type.Members.Where(fault => FaultExclusions.Excluding(endpointMetadata, fault, Type) is null);
- 
-     private int StatusOf(TFault fault, IReadOnlyList<object> endpointMetadata) =>
--        FaultStatuses.Override(endpointMetadata, fault, Type) ?? _answers[fault].Status;
-+        FaultStatuses.Override(endpointMetadata.Take(0).ToList(), fault, Type) ?? _answers[fault].Status;
- 
-     /// <summary>
-     /// How the host answers <typeparamref name="TFault"/>: its own mapping, or else the default for every
diff --git a/tools/probe/corpus/seeds/C15-without-faults-doc.patch b/tools/probe/corpus/seeds/C15-without-faults-doc.patch
deleted file mode 100644
index 28e340aa..00000000
--- a/tools/probe/corpus/seeds/C15-without-faults-doc.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-index 45c20b0..60bc81e 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/FaultResponses.cs
-@@ -157,7 +157,7 @@ internal sealed class FaultResponses<TFault> where TFault : notnull
- 
-     /// <summary>The members an endpoint answers with: every member, but those its metadata leaves out.</summary>
-     public IEnumerable<TFault> AnsweredBy(IReadOnlyList<object> endpointMetadata) =>
--        Type.Members.Where(fault => FaultExclusions.Excluding(endpointMetadata, fault, Type) is null);
-+        Type.Members;
- 
-     private int StatusOf(TFault fault, IReadOnlyList<object> endpointMetadata) =>
-         FaultStatuses.Override(endpointMetadata, fault, Type) ?? _answers[fault].Status;
diff --git a/tools/probe/corpus/seeds/C16-error-names-descriptions.patch b/tools/probe/corpus/seeds/C16-error-names-descriptions.patch
deleted file mode 100644
index 48d773d1..00000000
--- a/tools/probe/corpus/seeds/C16-error-names-descriptions.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/DescribedOptionsAgreement.cs b/src/CodoMetis.TypeKit.AspNetCore/DescribedOptionsAgreement.cs
-index d8b04d4..2c78b7e 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/DescribedOptionsAgreement.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/DescribedOptionsAgreement.cs
-@@ -45,7 +45,7 @@ internal static class DescribedOptionsAgreement
- 
-         throw new InvalidOperationException(
-             $"The OpenAPI document is built from the minimal-API JSON options (ConfigureHttpJsonOptions), and the controllers write with MVC's "
--          + $"(AddControllers().AddJsonOptions), and the two describe '{type}' differently: the minimal-API options as {Say(http)}, MVC's as {Say(controllers)}. "
-+          + $"(AddControllers().AddJsonOptions), and the two describe '{type}' differently: the minimal-API options as {Say(null)}, MVC's as {Say(null)}. "
-           + "Register the same converters and descriptions on both, in the same order, or the document describes JSON the controllers do not write.");
-     }
- 
diff --git a/tools/probe/corpus/seeds/C16-minimal-host-builds.patch b/tools/probe/corpus/seeds/C16-minimal-host-builds.patch
deleted file mode 100644
index dd465222..00000000
--- a/tools/probe/corpus/seeds/C16-minimal-host-builds.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/DescribedOptionsAgreement.cs b/src/CodoMetis.TypeKit.AspNetCore/DescribedOptionsAgreement.cs
-index d8b04d4..39572de 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/DescribedOptionsAgreement.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/DescribedOptionsAgreement.cs
-@@ -53,7 +53,7 @@ internal static class DescribedOptionsAgreement
-     private static StrongBox<JsonSerializerOptions?> MvcOptions(IServiceProvider services)
-     {
-         var actions = services.GetService<IActionDescriptorCollectionProvider>();
--        if (actions is null || !actions.ActionDescriptors.Items.OfType<ControllerActionDescriptor>().Any()) return new(null);
-+        if (actions is null || !actions.ActionDescriptors.Items.OfType<ControllerActionDescriptor>().Any()) return new(services.GetService<IOptions<MvcJsonOptions>>()?.Value.JsonSerializerOptions);
- 
-         return new(services.GetRequiredService<IOptions<MvcJsonOptions>>().Value.JsonSerializerOptions);
-     }
diff --git a/tools/probe/corpus/seeds/C16-options-agreement.patch b/tools/probe/corpus/seeds/C16-options-agreement.patch
deleted file mode 100644
index fcbe69e3..00000000
--- a/tools/probe/corpus/seeds/C16-options-agreement.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/DescribedOptionsAgreement.cs b/src/CodoMetis.TypeKit.AspNetCore/DescribedOptionsAgreement.cs
-index d8b04d4..b333446 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/DescribedOptionsAgreement.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/DescribedOptionsAgreement.cs
-@@ -41,7 +41,7 @@ internal static class DescribedOptionsAgreement
- 
-         var http = JsonSchemaDescription.For(type, document);
-         var controllers = JsonSchemaDescription.For(type, mvc);
--        if (Same(http, controllers)) return;
-+        if (controllers is null || Same(http, controllers)) return;
- 
-         throw new InvalidOperationException(
-             $"The OpenAPI document is built from the minimal-API JSON options (ConfigureHttpJsonOptions), and the controllers write with MVC's "
diff --git a/tools/probe/corpus/seeds/C16-patch-held-refused.patch b/tools/probe/corpus/seeds/C16-patch-held-refused.patch
deleted file mode 100644
index 01bb888c..00000000
--- a/tools/probe/corpus/seeds/C16-patch-held-refused.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/PatchSchemaTransformer.cs b/src/CodoMetis.TypeKit.AspNetCore/PatchSchemaTransformer.cs
-index 850e25a..0af8e31 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/PatchSchemaTransformer.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/PatchSchemaTransformer.cs
-@@ -93,7 +93,6 @@ internal sealed class PatchSchemaTransformer : IOpenApiSchemaTransformer
-         var argument = info.Type.GetGenericArguments()[0];
-         // The argument is held by the patch alone, where ASP.NET asks no transformer of it: a document and a
-         // controller that describe it differently are told apart here.
--        DescribedOptionsAgreement.ThrowIfDisagreeing(context.ApplicationServices, argument, info.Options);
-         // One the options write with a converter that says nothing is what ASP.NET writes for any such: {}.
-         var inner = DescribedSchemaTransformer.Description(argument, info.Options, property: null) is { } description
-             ? await DescribedSchemaTransformer.SchemaAsync(description, argument, context, cancellationToken)
diff --git a/tools/probe/corpus/seeds/C16-same-converters-build.patch b/tools/probe/corpus/seeds/C16-same-converters-build.patch
deleted file mode 100644
index b6dc817e..00000000
--- a/tools/probe/corpus/seeds/C16-same-converters-build.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/DescribedOptionsAgreement.cs b/src/CodoMetis.TypeKit.AspNetCore/DescribedOptionsAgreement.cs
-index d8b04d4..967f60a 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/DescribedOptionsAgreement.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/DescribedOptionsAgreement.cs
-@@ -41,7 +41,7 @@ internal static class DescribedOptionsAgreement
- 
-         var http = JsonSchemaDescription.For(type, document);
-         var controllers = JsonSchemaDescription.For(type, mvc);
--        if (Same(http, controllers)) return;
-+        if (Same(http, controllers) && document.PropertyNamingPolicy == mvc.PropertyNamingPolicy && document.NumberHandling == mvc.NumberHandling) return;
- 
-         throw new InvalidOperationException(
-             $"The OpenAPI document is built from the minimal-API JSON options (ConfigureHttpJsonOptions), and the controllers write with MVC's "
diff --git a/tools/probe/corpus/seeds/C17-cmtk0014-a-cast-naming-no-member.patch b/tools/probe/corpus/seeds/C17-cmtk0014-a-cast-naming-no-member.patch
deleted file mode 100644
index f7c4fce5..00000000
--- a/tools/probe/corpus/seeds/C17-cmtk0014-a-cast-naming-no-member.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs b/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs
-index 7265ea3..3967d2b 100644
---- a/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs
-+++ b/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs
-@@ -50,7 +50,7 @@ public sealed class UndefinedEnumValueAnalyzer : DiagnosticAnalyzer
- 
-     /// <summary>The operations that can be a constant of an enum, folded or not; each is judged only where no other contains it.</summary>
-     private static readonly ImmutableArray<OperationKind> Kinds =
--        [OperationKind.Conversion, OperationKind.DefaultValue, OperationKind.Binary, OperationKind.Unary, OperationKind.Conditional];
-+        [OperationKind.DefaultValue, OperationKind.Binary, OperationKind.Unary, OperationKind.Conditional];
- 
-     /// <inheritdoc/>
-     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => [Rule];
diff --git a/tools/probe/corpus/seeds/C17-cmtk0014-a-member-is-silent.patch b/tools/probe/corpus/seeds/C17-cmtk0014-a-member-is-silent.patch
deleted file mode 100644
index 2cb967ad..00000000
--- a/tools/probe/corpus/seeds/C17-cmtk0014-a-member-is-silent.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs b/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs
-index 7265ea3..1750073 100644
---- a/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs
-+++ b/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs
-@@ -105,7 +105,7 @@ public sealed class UndefinedEnumValueAnalyzer : DiagnosticAnalyzer
-         if (operation.Type is not INamedTypeSymbol type || !enums.TryGetValue(type, out var known)) return null;
-         if (!operation.ConstantValue.HasValue || operation.ConstantValue.Value is not { } value) return null;
- 
--        return known.Members.Contains(value) ? null : (type, known.Consequence);
-+        return known.Members.Contains(value) && operation is not IConversionOperation { IsImplicit: false } ? null : (type, known.Consequence);
-     }
- 
-     /// <summary>Whether <paramref name="operation"/> is an operand of a larger constant of an enum, which is judged in its place.</summary>
diff --git a/tools/probe/corpus/seeds/C17-cmtk0014-constructor-accessibility-too.patch b/tools/probe/corpus/seeds/C17-cmtk0014-constructor-accessibility-too.patch
deleted file mode 100644
index 0451dff2..00000000
--- a/tools/probe/corpus/seeds/C17-cmtk0014-constructor-accessibility-too.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs b/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs
-index 7265ea3..52c2a37 100644
---- a/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs
-+++ b/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs
-@@ -45,7 +45,6 @@ public sealed class UndefinedEnumValueAnalyzer : DiagnosticAnalyzer
-     private static readonly (string MetadataName, string Consequence)[] Enums =
-     [
-         ("CodoMetis.TypeKit.ClosedSets.FaultKind", "a host refuses a fault set's member of no kind where it maps the set, when it starts"),
--        ("CodoMetis.TypeKit.ConstructorAccessibility", "CMTK0011 reads it as public"),
-     ];
- 
-     /// <summary>The operations that can be a constant of an enum, folded or not; each is judged only where no other contains it.</summary>
diff --git a/tools/probe/corpus/seeds/C17-cmtk0014-default-and-zero.patch b/tools/probe/corpus/seeds/C17-cmtk0014-default-and-zero.patch
deleted file mode 100644
index 0f1cb0fb..00000000
--- a/tools/probe/corpus/seeds/C17-cmtk0014-default-and-zero.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs b/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs
-index 7265ea3..cf1a34a 100644
---- a/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs
-+++ b/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs
-@@ -105,7 +105,7 @@ public sealed class UndefinedEnumValueAnalyzer : DiagnosticAnalyzer
-         if (operation.Type is not INamedTypeSymbol type || !enums.TryGetValue(type, out var known)) return null;
-         if (!operation.ConstantValue.HasValue || operation.ConstantValue.Value is not { } value) return null;
- 
--        return known.Members.Contains(value) ? null : (type, known.Consequence);
-+        return known.Members.Contains(value) || value is 0 ? null : (type, known.Consequence);
-     }
- 
-     /// <summary>Whether <paramref name="operation"/> is an operand of a larger constant of an enum, which is judged in its place.</summary>
diff --git a/tools/probe/corpus/seeds/C17-cmtk0014-reported-where-written.patch b/tools/probe/corpus/seeds/C17-cmtk0014-reported-where-written.patch
deleted file mode 100644
index afb80f41..00000000
--- a/tools/probe/corpus/seeds/C17-cmtk0014-reported-where-written.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs b/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs
-index 7265ea3..f26fec1 100644
---- a/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs
-+++ b/src/CodoMetis.TypeKit.Analyzers/UndefinedEnumValueAnalyzer.cs
-@@ -93,7 +93,7 @@ public sealed class UndefinedEnumValueAnalyzer : DiagnosticAnalyzer
- 
-         context.Report(Diagnostic.Create(
-             Rule,
--            operation.Syntax.GetLocation(),
-+            (operation.Syntax.Parent ?? operation.Syntax).GetLocation(),
-             operation.Syntax.ToString(),
-             enumeration.Type.Name,
-             enumeration.Consequence));
diff --git a/tools/probe/corpus/seeds/C18-cmtk1023-a-warning-and-generated.patch b/tools/probe/corpus/seeds/C18-cmtk1023-a-warning-and-generated.patch
deleted file mode 100644
index cf9e979a..00000000
--- a/tools/probe/corpus/seeds/C18-cmtk1023-a-warning-and-generated.patch
+++ /dev/null
@@ -1,11 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/AspectDiagnostics.cs b/src/CodoMetis.TypeKit.Generators/AspectDiagnostics.cs
-index 6fd2f8d..9a8f738 100644
---- a/src/CodoMetis.TypeKit.Generators/AspectDiagnostics.cs
-+++ b/src/CodoMetis.TypeKit.Generators/AspectDiagnostics.cs
-@@ -100,5 +100,5 @@ internal static class AspectDiagnostics
-     /// longer calls (decision 75).
-     /// </summary>
-     public static readonly DiagnosticDefinition<(INamedType Type, string Members)> InheritedEqualityNotUsed =
--        new("CMTK1023", Severity.Warning, "'{0}' inherits {1}, which its generated equality does not call: a value object's equality is its wrapped value's, as its ordering, its JSON and its EF Core column are, and a base's would make values equal that sort apart. Remove them from the base, or derive from a record without them; to make values that differ only in form equal, normalise them in Create." + SeeBuildErrors);
-+        new("CMTK1023", Severity.Info, "'{0}' inherits {1}, which its generated equality does not call: a value object's equality is its wrapped value's, as its ordering, its JSON and its EF Core column are, and a base's would make values equal that sort apart. Remove them from the base, or derive from a record without them; to make values that differ only in form equal, normalise them in Create." + SeeBuildErrors);
- }
diff --git a/tools/probe/corpus/seeds/C18-cmtk1023-generated-equality-never-calls-the-base.patch b/tools/probe/corpus/seeds/C18-cmtk1023-generated-equality-never-calls-the-base.patch
deleted file mode 100644
index 9be9b8f1..00000000
--- a/tools/probe/corpus/seeds/C18-cmtk1023-generated-equality-never-calls-the-base.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs
-index 07a7ecb..1bc5231 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs
-@@ -58,7 +58,7 @@ internal sealed partial class ValueObjectContractAspect
-     [Template]
-     public int GetHashCodeTemplate([CompileTime] INamedType valueType) =>
-         (int)ExpressionFactory.Parse(
--            $"global::System.Collections.Generic.EqualityComparer<{ValueObjectTypes.SourceName(valueType)}>.Default.GetHashCode(this._value!)"
-+            $"global::System.HashCode.Combine(base.GetHashCode(), global::System.Collections.Generic.EqualityComparer<{ValueObjectTypes.SourceName(valueType)}>.Default.GetHashCode(this._value!))"
-         ).Value!;
- 
-     /// <summary><c>Create</c> with the fault carried into the throw.</summary>
diff --git a/tools/probe/corpus/seeds/C18-cmtk1023-names-each-base-member.patch b/tools/probe/corpus/seeds/C18-cmtk1023-names-each-base-member.patch
deleted file mode 100644
index 006ca6b3..00000000
--- a/tools/probe/corpus/seeds/C18-cmtk1023-names-each-base-member.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectDeclaration.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectDeclaration.cs
-index cb0cbae..f713c7e 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectDeclaration.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectDeclaration.cs
-@@ -436,7 +436,7 @@ internal static class ValueObjectDeclaration
-             .. SelfAndBases(target).Skip(1).SelectMany(type => type.Methods
-                                                                    .Where(method => method is { IsStatic: false } && IsHandWritten(method)
-                                                                                  && (method.IsExplicitInterfaceImplementation
--                                                                                         ? method.ExplicitInterfaceImplementations.Any(implemented => implemented.DeclaringType.Definition.Equals(equatable))
-+                                                                                         ? false
-                                                                                          : (method is { Name: nameof(Equals), Parameters: [{ } other] } && other.Type.Equals(type))
-                                                                                         || method is { Name: nameof(GetHashCode), Parameters.Count: 0 }))
-                                                                    .Select(method => $"{Describe(method)} in its base type {type.ToDisplayString()}"))
diff --git a/tools/probe/corpus/seeds/C19-cmtk0010-kinds-a-pair-once-at-the-later-argument.patch b/tools/probe/corpus/seeds/C19-cmtk0010-kinds-a-pair-once-at-the-later-argument.patch
deleted file mode 100644
index 8194f01c..00000000
--- a/tools/probe/corpus/seeds/C19-cmtk0010-kinds-a-pair-once-at-the-later-argument.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs b/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs
-index 5c1fd7e..703f84c 100644
---- a/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs
-+++ b/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs
-@@ -518,7 +518,7 @@ public sealed class TypeArgumentConstraintAnalyzer : DiagnosticAnalyzer
-                 {
-                     yield return Diagnostic.Create(
-                         Rule,
--                        locationOf(later),
-+                        locationOf(earlier),
-                         arguments[later].Argument.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat),
-                         arguments[later].Parameter.Name,
-                         Owner(arguments[later].Owner),
diff --git a/tools/probe/corpus/seeds/C19-cmtk0010-kinds-flags-enum-and-read-only-struct.patch b/tools/probe/corpus/seeds/C19-cmtk0010-kinds-flags-enum-and-read-only-struct.patch
deleted file mode 100644
index db7b18fc..00000000
--- a/tools/probe/corpus/seeds/C19-cmtk0010-kinds-flags-enum-and-read-only-struct.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs b/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs
-index 5c1fd7e..2f1a554 100644
---- a/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs
-+++ b/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs
-@@ -812,7 +812,7 @@ public sealed class TypeArgumentConstraintAnalyzer : DiagnosticAnalyzer
-         TypeArgumentConstraint.ValueObject    => argument.TypeKind is not TypeKind.Interface && symbols.FindMarker(argument, out _) is not null,
-         TypeArgumentConstraint.ClosedSet      => symbols.FindClosedSetMarker(argument) is not null,
-         TypeArgumentConstraint.FlagsEnum      => symbols.IsFlagsEnum(argument),
--        TypeArgumentConstraint.ReadOnlyStruct => argument is INamedTypeSymbol { TypeKind: TypeKind.Struct, IsReadOnly: true },
-+        TypeArgumentConstraint.ReadOnlyStruct => argument is INamedTypeSymbol { TypeKind: TypeKind.Struct },
-         _                                     => argument.TypeKind is TypeKind.Array or TypeKind.Enum or TypeKind.Delegate or TypeKind.Dynamic
-                                               || argument is INamedTypeSymbol { TypeKind: TypeKind.Class or TypeKind.Struct, IsAbstract: false, IsStatic: false },
-     };
diff --git a/tools/probe/corpus/seeds/C19-cmtk0010-kinds-interface-and-unsealed.patch b/tools/probe/corpus/seeds/C19-cmtk0010-kinds-interface-and-unsealed.patch
deleted file mode 100644
index 13b21c27..00000000
--- a/tools/probe/corpus/seeds/C19-cmtk0010-kinds-interface-and-unsealed.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs b/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs
-index 5c1fd7e..a7c9f49 100644
---- a/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs
-+++ b/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs
-@@ -808,7 +808,7 @@ public sealed class TypeArgumentConstraintAnalyzer : DiagnosticAnalyzer
-         TypeArgumentConstraint.Interface      => argument.TypeKind is TypeKind.Interface,
-         // dynamic is object, a class that can be derived from, as [Concrete] takes it. The abstract bases nothing
-         // derives from (Enum, Delegate, MulticastDelegate, ValueType, Array) are taken too until 3.0.0 (decision 34).
--        TypeArgumentConstraint.Unsealed       => argument.TypeKind is TypeKind.Dynamic || argument is INamedTypeSymbol { TypeKind: TypeKind.Class, IsSealed: false, IsStatic: false },
-+        TypeArgumentConstraint.Unsealed       => argument.TypeKind is TypeKind.Dynamic || argument is INamedTypeSymbol { TypeKind: TypeKind.Class, IsStatic: false },
-         TypeArgumentConstraint.ValueObject    => argument.TypeKind is not TypeKind.Interface && symbols.FindMarker(argument, out _) is not null,
-         TypeArgumentConstraint.ClosedSet      => symbols.FindClosedSetMarker(argument) is not null,
-         TypeArgumentConstraint.FlagsEnum      => symbols.IsFlagsEnum(argument),
diff --git a/tools/probe/corpus/seeds/C19-cmtk0010-kinds-methods-the-compiler-calls.patch b/tools/probe/corpus/seeds/C19-cmtk0010-kinds-methods-the-compiler-calls.patch
deleted file mode 100644
index 8d87ff1c..00000000
--- a/tools/probe/corpus/seeds/C19-cmtk0010-kinds-methods-the-compiler-calls.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs b/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs
-index 5c1fd7e..c297b6a 100644
---- a/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs
-+++ b/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs
-@@ -161,7 +161,6 @@ public sealed class TypeArgumentConstraintAnalyzer : DiagnosticAnalyzer
- 
-                 if (construct.MethodKind == MethodKind.Ordinary)
-                 {
--                    yield return (construct, collection);
-                     break;
-                 }
- 
diff --git a/tools/probe/corpus/seeds/C19-cmtk0010-kinds-value-object-and-closed-set.patch b/tools/probe/corpus/seeds/C19-cmtk0010-kinds-value-object-and-closed-set.patch
deleted file mode 100644
index 58d99d22..00000000
--- a/tools/probe/corpus/seeds/C19-cmtk0010-kinds-value-object-and-closed-set.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs b/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs
-index 5c1fd7e..bce7547 100644
---- a/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs
-+++ b/src/CodoMetis.TypeKit.Analyzers/TypeArgumentConstraintAnalyzer.cs
-@@ -809,7 +809,7 @@ public sealed class TypeArgumentConstraintAnalyzer : DiagnosticAnalyzer
-         // dynamic is object, a class that can be derived from, as [Concrete] takes it. The abstract bases nothing
-         // derives from (Enum, Delegate, MulticastDelegate, ValueType, Array) are taken too until 3.0.0 (decision 34).
-         TypeArgumentConstraint.Unsealed       => argument.TypeKind is TypeKind.Dynamic || argument is INamedTypeSymbol { TypeKind: TypeKind.Class, IsSealed: false, IsStatic: false },
--        TypeArgumentConstraint.ValueObject    => argument.TypeKind is not TypeKind.Interface && symbols.FindMarker(argument, out _) is not null,
-+        TypeArgumentConstraint.ValueObject    => argument.TypeKind is not TypeKind.Interface,
-         TypeArgumentConstraint.ClosedSet      => symbols.FindClosedSetMarker(argument) is not null,
-         TypeArgumentConstraint.FlagsEnum      => symbols.IsFlagsEnum(argument),
-         TypeArgumentConstraint.ReadOnlyStruct => argument is INamedTypeSymbol { TypeKind: TypeKind.Struct, IsReadOnly: true },
diff --git a/tools/probe/corpus/seeds/C20-testing-shouldhold-a-failure-says-the-outcome.patch b/tools/probe/corpus/seeds/C20-testing-shouldhold-a-failure-says-the-outcome.patch
deleted file mode 100644
index bdd6a3de..00000000
--- a/tools/probe/corpus/seeds/C20-testing-shouldhold-a-failure-says-the-outcome.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs b/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs
-index 6b825b3..443a910 100644
---- a/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs
-+++ b/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs
-@@ -68,6 +68,6 @@ internal static class HeldFaults
-         var held = read();
-         return held is Fault<TFault> asked && EqualityComparer<TFault>.Default.Equals(asked.Reason, reason)
-             ? asked
--            : throw new TypeKitAssertionException($"Expected the fault {reason}, but the {Outcomes.Name<TComposed>()} is the fault {held}.");
-+            : throw new TypeKitAssertionException($"Expected the fault {reason}, but the {Outcomes.Name<TComposed>()} holds another.");
-     }
- }
diff --git a/tools/probe/corpus/seeds/C20-testing-shouldhold-fails-unless-it-holds-that-reason.patch b/tools/probe/corpus/seeds/C20-testing-shouldhold-fails-unless-it-holds-that-reason.patch
deleted file mode 100644
index b54b85ea..00000000
--- a/tools/probe/corpus/seeds/C20-testing-shouldhold-fails-unless-it-holds-that-reason.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs b/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs
-index 6b825b3..c09f2da 100644
---- a/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs
-+++ b/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs
-@@ -66,7 +66,7 @@ internal static class HeldFaults
-                 $"Expected the fault {reason}, but the {Outcomes.Name<TComposed>()} is uninitialized: a default instance, which holds no fault.");
- 
-         var held = read();
--        return held is Fault<TFault> asked && EqualityComparer<TFault>.Default.Equals(asked.Reason, reason)
-+        return held is Fault<TFault> asked
-             ? asked
-             : throw new TypeKitAssertionException($"Expected the fault {reason}, but the {Outcomes.Name<TComposed>()} is the fault {held}.");
-     }
diff --git a/tools/probe/corpus/seeds/C20-testing-shouldhold-hands-back-detail-and-rule.patch b/tools/probe/corpus/seeds/C20-testing-shouldhold-hands-back-detail-and-rule.patch
deleted file mode 100644
index f1281a45..00000000
--- a/tools/probe/corpus/seeds/C20-testing-shouldhold-hands-back-detail-and-rule.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs b/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs
-index 6b825b3..e02bba5 100644
---- a/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs
-+++ b/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs
-@@ -67,7 +67,7 @@ internal static class HeldFaults
- 
-         var held = read();
-         return held is Fault<TFault> asked && EqualityComparer<TFault>.Default.Equals(asked.Reason, reason)
--            ? asked
-+            ? Fault.Of(asked.Reason)
-             : throw new TypeKitAssertionException($"Expected the fault {reason}, but the {Outcomes.Name<TComposed>()} is the fault {held}.");
-     }
- }
diff --git a/tools/probe/corpus/seeds/C20-testing-shouldhold-uninitialized-fails.patch b/tools/probe/corpus/seeds/C20-testing-shouldhold-uninitialized-fails.patch
deleted file mode 100644
index 3548a2e2..00000000
--- a/tools/probe/corpus/seeds/C20-testing-shouldhold-uninitialized-fails.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs b/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs
-index 6b825b3..61ae1a6 100644
---- a/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs
-+++ b/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs
-@@ -61,7 +61,7 @@ internal static class HeldFaults
-     /// <param name="read">The held fault, boxed: the composed fault's types are told apart only at run time.</param>
-     public static Fault<TFault> Expect<TComposed, TFault>(TFault reason, bool uninitialized, Func<object> read) where TFault : notnull
-     {
--        if (uninitialized)
-+        if (uninitialized && reason is null)
-             throw new TypeKitAssertionException(
-                 $"Expected the fault {reason}, but the {Outcomes.Name<TComposed>()} is uninitialized: a default instance, which holds no fault.");
- 
diff --git a/tools/probe/corpus/seeds/C20-testing-shouldhold-whichever-of-its-types.patch b/tools/probe/corpus/seeds/C20-testing-shouldhold-whichever-of-its-types.patch
deleted file mode 100644
index 9be5f520..00000000
--- a/tools/probe/corpus/seeds/C20-testing-shouldhold-whichever-of-its-types.patch
+++ /dev/null
@@ -1,22 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs b/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs
-index 6b825b3..9839131 100644
---- a/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs
-+++ b/src/CodoMetis.TypeKit.Testing/FaultAssertions.cs
-@@ -23,7 +23,7 @@ public static class FaultAssertions
-     /// <returns>The held fault, its detail and rule intact.</returns>
-     /// <exception cref="TypeKitAssertionException">The fault is another, of either type, or uninitialized.</exception>
-     public static Fault<T2> ShouldHold<[Distinct] T1, [Distinct] T2>(this Fault<T1, T2> fault, T2 reason) where T1 : notnull where T2 : notnull =>
--        HeldFaults.Expect<Fault<T1, T2>, T2>(reason, Uninitialized(fault), () => fault.Match<object>(held => held, held => held));
-+        HeldFaults.Expect<Fault<T1, T2>, T2>(reason, Uninitialized(fault), () => fault.Match<object>(held => held, held => held.Reason));
- 
-     /// <summary>The fault a composed fault must hold, of its first type.</summary>
-     /// <param name="fault">The fault under test.</param>
-@@ -47,7 +47,7 @@ public static class FaultAssertions
-     /// <returns>The held fault, its detail and rule intact.</returns>
-     /// <exception cref="TypeKitAssertionException">The fault is another, of any of the types, or uninitialized.</exception>
-     public static Fault<T3> ShouldHold<[Distinct] T1, [Distinct] T2, [Distinct] T3>(this Fault<T1, T2, T3> fault, T3 reason) where T1 : notnull where T2 : notnull where T3 : notnull =>
--        HeldFaults.Expect<Fault<T1, T2, T3>, T3>(reason, Uninitialized(fault), () => fault.Match<object>(held => held, held => held, held => held));
-+        HeldFaults.Expect<Fault<T1, T2, T3>, T3>(reason, Uninitialized(fault), () => fault.Match<object>(held => held, held => held, held => held.Reason));
- 
-     private static bool Uninitialized<TComposed>(TComposed fault) where TComposed : struct =>
-         EqualityComparer<TComposed>.Default.Equals(fault, default);
diff --git a/tools/probe/corpus/seeds/C21-openapi-schema-parity-container-elements.patch b/tools/probe/corpus/seeds/C21-openapi-schema-parity-container-elements.patch
deleted file mode 100644
index a7da6f5e..00000000
--- a/tools/probe/corpus/seeds/C21-openapi-schema-parity-container-elements.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs b/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs
-index 4c226cd..5b478a8 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs
-@@ -108,7 +108,7 @@ internal sealed class ValueObjectSchemaTransformer : IOpenApiSchemaTransformer
- 
-         // Only what ASP.NET left out: a schema it did build is its own description of the elements.
-         if (info.Kind == JsonTypeInfoKind.Enumerable && schema.Items is null)
--            schema.Items = await ElementSchemaAsync(element, context, cancellationToken);
-+            return;
-         else if (info.Kind == JsonTypeInfoKind.Dictionary && schema.AdditionalProperties is null)
-             schema.AdditionalProperties = await ElementSchemaAsync(element, context, cancellationToken);
-     }
diff --git a/tools/probe/corpus/seeds/C21-openapi-schema-parity-dictionary-key.patch b/tools/probe/corpus/seeds/C21-openapi-schema-parity-dictionary-key.patch
deleted file mode 100644
index 2ff5246c..00000000
--- a/tools/probe/corpus/seeds/C21-openapi-schema-parity-dictionary-key.patch
+++ /dev/null
@@ -1,17 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs b/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs
-index 4c226cd..98cffde 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs
-@@ -104,6 +104,12 @@ internal sealed class ValueObjectSchemaTransformer : IOpenApiSchemaTransformer
-             return;
-         }
- 
-+        if (info.Kind == JsonTypeInfoKind.Dictionary && info.KeyType is { } key && ValueObjectTypes.IsValueObject(key))
-+        {
-+            schema.AdditionalProperties = await ElementSchemaAsync(key, context, cancellationToken);
-+            return;
-+        }
-+
-         if (info.ElementType is not { } element || !ValueObjectTypes.IsValueObject(element) || DescribedSchemaTransformer.Replaced(element, info.Options)) return;
- 
-         // Only what ASP.NET left out: a schema it did build is its own description of the elements.
diff --git a/tools/probe/corpus/seeds/C21-openapi-schema-parity-every-document-version.patch b/tools/probe/corpus/seeds/C21-openapi-schema-parity-every-document-version.patch
deleted file mode 100644
index a24446e2..00000000
--- a/tools/probe/corpus/seeds/C21-openapi-schema-parity-every-document-version.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs b/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs
-index b415acf..b99800e 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs
-@@ -267,6 +267,7 @@ internal sealed class ValueObjectSchemaTransformer : IOpenApiSchemaTransformer
-             if (position == NullablePosition.None)
-             {
-                 schema.FillFrom(wrappedSchema);
-+                if (DescribedSchemaTransformer.Version(context) < OpenApiSpecVersion.OpenApi3_1) schema.Format = null;
-             }
-             else if (SchemaReferenceId(context.JsonTypeInfo.Options.GetTypeInfo(wrapped), context) is not null)
-             {
diff --git a/tools/probe/corpus/seeds/C21-openapi-schema-parity-nullable-admits-null-as-the-wrapped-does.patch b/tools/probe/corpus/seeds/C21-openapi-schema-parity-nullable-admits-null-as-the-wrapped-does.patch
deleted file mode 100644
index 688f8828..00000000
--- a/tools/probe/corpus/seeds/C21-openapi-schema-parity-nullable-admits-null-as-the-wrapped-does.patch
+++ /dev/null
@@ -1,28 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs b/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs
-index 6078f79..2493ef9 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs
-@@ -108,10 +108,8 @@ internal sealed class ValueObjectSchemaTransformer : IOpenApiSchemaTransformer
-             if (component && nullableProperty) MarkNullableProperty(schema);
- 
-             var position = component ? NullablePosition.None
--                : nullableProperty ? NullablePosition.Property
--                : Nullable.GetUnderlyingType(info.Type) is null || !wrapped.IsValueType ? NullablePosition.None
--                : IsParameterOutsideTheBody(context) ? NullablePosition.ParameterOutsideTheBody
--                : NullablePosition.Root;
-+                : Nullable.GetUnderlyingType(info.Type) is not null || nullableProperty ? NullablePosition.Property
-+                : NullablePosition.None;
- 
-             await DescribeAsync(schema, info.Type, wrapped, outside, position, context, cancellationToken);
-             return;
-@@ -129,9 +127,7 @@ internal sealed class ValueObjectSchemaTransformer : IOpenApiSchemaTransformer
-             // MVC hands a value object bound from the body here too, as the string it would parse. There
-             // ASP.NET's exporter admits null in the schema of the Nullable<T> of a wrapped value type, inside
-             // the null-or ASP.NET puts around a nullable body, and outside the body among its values alone.
--            var position = Nullable.GetUnderlyingType(valueObject) is null || !parameterWrapped.IsValueType ? NullablePosition.None
--                : parameter.Source == BindingSource.Body ? NullablePosition.Root
--                : NullablePosition.ParameterOutsideTheBody;
-+            var position = NullablePosition.None;
- 
-             // ASP.NET's placeholder for any TryParse-bound parameter; the wrapped type says what it is.
-             schema.Type = null;
diff --git a/tools/probe/corpus/seeds/C21-openapi-schema-parity-the-underlying-types-schema.patch b/tools/probe/corpus/seeds/C21-openapi-schema-parity-the-underlying-types-schema.patch
deleted file mode 100644
index 9f4d1e88..00000000
--- a/tools/probe/corpus/seeds/C21-openapi-schema-parity-the-underlying-types-schema.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs b/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs
-index b415acf..9b7e9e0 100644
---- a/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs
-+++ b/src/CodoMetis.TypeKit.AspNetCore/ValueObjectSchemaTransformer.cs
-@@ -267,6 +267,7 @@ internal sealed class ValueObjectSchemaTransformer : IOpenApiSchemaTransformer
-             if (position == NullablePosition.None)
-             {
-                 schema.FillFrom(wrappedSchema);
-+                schema.Format = null;
-             }
-             else if (SchemaReferenceId(context.JsonTypeInfo.Options.GetTypeInfo(wrapped), context) is not null)
-             {
diff --git a/tools/probe/corpus/seeds/C22-generator-refusals-abstract.patch b/tools/probe/corpus/seeds/C22-generator-refusals-abstract.patch
deleted file mode 100644
index 2d33feb8..00000000
--- a/tools/probe/corpus/seeds/C22-generator-refusals-abstract.patch
+++ /dev/null
@@ -1,16 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectFabric.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectFabric.cs
-index 6ceba7f..ba99b2d 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectFabric.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectFabric.cs
-@@ -40,11 +40,6 @@ internal sealed class ValueObjectFabric : TransitiveProjectFabric
-                               CompanionClass.NameOwner(type),
-                               ValueObjectTypes.WrappedValueObjectRefusal(type)));
- 
--        // An abstract type gets no aspect, so it is refused here, where it is selected.
--        amender.SelectTypes(includeNestedTypes: true)
--               .Where(ValueObjectTypes.IsAbstractValueObject)
--               .ReportDiagnostic(type => AspectDiagnostics.AbstractValueObject.WithArguments(type));
--
-         amender.SelectTypes(includeNestedTypes: true)
-                .Where(ClosedSetTypes.IsClosedSet)
-                .AddAspect(_ => new ClosedSetAspect());
diff --git a/tools/probe/corpus/seeds/C22-generator-refusals-closed-set-named-as-generated-member.patch b/tools/probe/corpus/seeds/C22-generator-refusals-closed-set-named-as-generated-member.patch
deleted file mode 100644
index c5281d93..00000000
--- a/tools/probe/corpus/seeds/C22-generator-refusals-closed-set-named-as-generated-member.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ClosedSetAspect.cs b/src/CodoMetis.TypeKit.Generators/ClosedSetAspect.cs
-index bd675fb..5601d62 100644
---- a/src/CodoMetis.TypeKit.Generators/ClosedSetAspect.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ClosedSetAspect.cs
-@@ -72,7 +72,6 @@ internal sealed partial class ClosedSetAspect : TypeAspect
- 
-         // A set named as a generated member failed inside the generated code (LAMA0611, CS0542: a
-         // member cannot have the name of its type), naming nothing the user wrote.
--        if (generatedNames.Contains(target.Name)) problems.Add(ClosedSetNamedAsGeneratedMember.WithArguments(target));
- 
-         foreach (var member in members.Where(member => generatedNames.Contains(member.Name)))
-             problems.Add(ClosedSetMemberNameTaken.WithArguments((target, member.Name, "has the name of a member the generators introduce")));
diff --git a/tools/probe/corpus/seeds/C22-generator-refusals-equality-operator.patch b/tools/probe/corpus/seeds/C22-generator-refusals-equality-operator.patch
deleted file mode 100644
index f59ca69f..00000000
--- a/tools/probe/corpus/seeds/C22-generator-refusals-equality-operator.patch
+++ /dev/null
@@ -1,15 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectDeclaration.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectDeclaration.cs
-index cb0cbae..7d2bf7f 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectDeclaration.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectDeclaration.cs
-@@ -411,10 +411,6 @@ internal static class ValueObjectDeclaration
-                                            ? method.ExplicitInterfaceImplementations.Any(implemented => implemented.DeclaringType.Definition.Equals(equatable))
-                                            : (method is { Name: nameof(Equals), Parameters: [{ } other] } && other.Type.Equals(target))
-                                           || method is { Name: nameof(GetHashCode), Parameters.Count: 0 }))
--                     .Select(Describe),
--            .. target.Methods
--                     .Where(method => method is { IsStatic: true, IsImplicitlyDeclared: false, IsExplicitInterfaceImplementation: false, OperatorKind: OperatorKind.Equality or OperatorKind.Inequality, Parameters: [{ } left, { } right] }
--                                   && left.Type.ToNonNullable().Equals(target) && right.Type.ToNonNullable().Equals(target))
-                      .Select(Describe)
-         ];
-     }
diff --git a/tools/probe/corpus/seeds/C22-generator-refusals-every-error-links-the-table.patch b/tools/probe/corpus/seeds/C22-generator-refusals-every-error-links-the-table.patch
deleted file mode 100644
index 02cdd7dd..00000000
--- a/tools/probe/corpus/seeds/C22-generator-refusals-every-error-links-the-table.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/AspectDiagnostics.cs b/src/CodoMetis.TypeKit.Generators/AspectDiagnostics.cs
-index 6fd2f8d..6531cc1 100644
---- a/src/CodoMetis.TypeKit.Generators/AspectDiagnostics.cs
-+++ b/src/CodoMetis.TypeKit.Generators/AspectDiagnostics.cs
-@@ -34,7 +34,7 @@ internal static class AspectDiagnostics
-         new("CMTK1004", Severity.Error, "'{0}' implements {1}, whose first type argument must be '{0}' itself, so it is not generated." + SeeBuildErrors);
- 
-     public static readonly DiagnosticDefinition<(INamedType Type, string Reason)> UnsupportedValueObject =
--        new("CMTK1005", Severity.Error, "'{0}' cannot be generated as a value object: {1}." + SeeBuildErrors);
-+        new("CMTK1005", Severity.Error, "'{0}' cannot be generated as a value object: {1}.");
- 
-     public static readonly DiagnosticDefinition<INamedType> MissingSealedKeyword =
-         new("CMTK1006", Severity.Error, "'{0}' is a value object and must be declared sealed, so it is not generated." + SeeBuildErrors);
diff --git a/tools/probe/corpus/seeds/C22-generator-refusals-generic-wrapped.patch b/tools/probe/corpus/seeds/C22-generator-refusals-generic-wrapped.patch
deleted file mode 100644
index 3d437056..00000000
--- a/tools/probe/corpus/seeds/C22-generator-refusals-generic-wrapped.patch
+++ /dev/null
@@ -1,17 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs
-index db8d4e9..0b1612d 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs
-@@ -246,12 +246,6 @@ internal sealed partial class ValueObjectAspect : TypeAspect
-         // name lost its type arguments there, and a named tuple broke the attribute. Refused rather than
-         // made to work, because a value object's equality is its wrapped value's, and a generic type's
-         // is not value equality in general. Refusing now and lifting it later breaks nobody.
--        if (namedValueType.IsGeneric || IsNestedInGeneric(namedValueType))
--        {
--            builder.Diagnostics.Report(UnsupportedValueObject.WithArguments((target,
--                $"the wrapped type '{namedValueType.ToDisplayString()}' is generic, and a value object's equality is its wrapped value's, which a generic type does not guarantee (a List<T> compares by reference); wrap a non-generic type of your own that has the equality you need")));
--            return false;
--        }
- 
-         // Before the field is introduced: over a struct that wraps itself it has no layout (CS0523),
-         // which Metalama reports as a bug in this aspect.
diff --git a/tools/probe/corpus/seeds/C22-generator-refusals-named-as-generated-member.patch b/tools/probe/corpus/seeds/C22-generator-refusals-named-as-generated-member.patch
deleted file mode 100644
index 7bfe1b73..00000000
--- a/tools/probe/corpus/seeds/C22-generator-refusals-named-as-generated-member.patch
+++ /dev/null
@@ -1,16 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs
-index db8d4e9..e3f46d8 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs
-@@ -146,11 +146,6 @@ internal sealed partial class ValueObjectAspect : TypeAspect
-             return false;
-         }
- 
--        if (ValueObjectDeclaration.GeneratedMemberNames.Contains(target.Name))
--        {
--            builder.Diagnostics.Report(UnsupportedValueObject.WithArguments((target, $"a value object cannot be named '{target.Name}', the name of a member the generators introduce, since a member cannot have the name of its type; rename it")));
--            return false;
--        }
- 
-         // The companion class and the attribute's type arguments sit outside the file, where a file-local
-         // type, or one nested in it, cannot be named, and Metalama crashed on it (LAMA0001, naming nothing).
diff --git a/tools/probe/corpus/seeds/C22-generator-refusals-no-type-half-generated.patch b/tools/probe/corpus/seeds/C22-generator-refusals-no-type-half-generated.patch
deleted file mode 100644
index 9587d372..00000000
--- a/tools/probe/corpus/seeds/C22-generator-refusals-no-type-half-generated.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/AspectDiagnostics.cs b/src/CodoMetis.TypeKit.Generators/AspectDiagnostics.cs
-index 6fd2f8d..1f23cde 100644
---- a/src/CodoMetis.TypeKit.Generators/AspectDiagnostics.cs
-+++ b/src/CodoMetis.TypeKit.Generators/AspectDiagnostics.cs
-@@ -34,7 +34,7 @@ internal static class AspectDiagnostics
-         new("CMTK1004", Severity.Error, "'{0}' implements {1}, whose first type argument must be '{0}' itself, so it is not generated." + SeeBuildErrors);
- 
-     public static readonly DiagnosticDefinition<(INamedType Type, string Reason)> UnsupportedValueObject =
--        new("CMTK1005", Severity.Error, "'{0}' cannot be generated as a value object: {1}." + SeeBuildErrors);
-+        new("CMTK1005", Severity.Warning, "'{0}' cannot be generated as a value object: {1}." + SeeBuildErrors);
- 
-     public static readonly DiagnosticDefinition<INamedType> MissingSealedKeyword =
-         new("CMTK1006", Severity.Error, "'{0}' is a value object and must be declared sealed, so it is not generated." + SeeBuildErrors);
diff --git a/tools/probe/corpus/seeds/C22-generator-refusals-over-object.patch b/tools/probe/corpus/seeds/C22-generator-refusals-over-object.patch
deleted file mode 100644
index fdc63eee..00000000
--- a/tools/probe/corpus/seeds/C22-generator-refusals-over-object.patch
+++ /dev/null
@@ -1,17 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs
-index db8d4e9..4c4f0c1 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs
-@@ -225,12 +225,6 @@ internal sealed partial class ValueObjectAspect : TypeAspect
-         // object property holding 5 is written as 5 (measured 2026-10-13). An interface or an abstract
-         // class is written and read as the serializer writes it (its declared members, or polymorphic
-         // where the type says so), so it stays allowed.
--        if (namedValueType.SpecialType == SpecialType.Object)
--        {
--            builder.Diagnostics.Report(UnsupportedValueObject.WithArguments((target,
--                "the wrapped type 'object' holds a value of any type, which the serializer writes by its run-time type and a value object's converter cannot (5 was written as {}); wrap the type the value has")));
--            return false;
--        }
- 
-         // System.Enum is the base of every enum and no enum itself: its generic Enum.Parse<TEnum>(string)
-         // was taken for a Parse of its own, and the generated parsing failed inside the generated code
diff --git a/tools/probe/corpus/seeds/C22-generator-refusals-over-system-enum.patch b/tools/probe/corpus/seeds/C22-generator-refusals-over-system-enum.patch
deleted file mode 100644
index a805c7e3..00000000
--- a/tools/probe/corpus/seeds/C22-generator-refusals-over-system-enum.patch
+++ /dev/null
@@ -1,17 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs
-index db8d4e9..43e7c4a 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs
-@@ -235,12 +235,6 @@ internal sealed partial class ValueObjectAspect : TypeAspect
-         // System.Enum is the base of every enum and no enum itself: its generic Enum.Parse<TEnum>(string)
-         // was taken for a Parse of its own, and the generated parsing failed inside the generated code
-         // (LAMA0611, CS0411), naming nothing the user wrote.
--        if (namedValueType.Equals(TypeFactory.GetNamedType(typeof(Enum))))
--        {
--            builder.Diagnostics.Report(UnsupportedValueObject.WithArguments((target,
--                "the wrapped type 'Enum' is the base of every enum and no enum itself; wrap the enum type")));
--            return false;
--        }
- 
-         // A generic wrapped type, tuples included, failed inside the generated code (LAMA0611): its
-         // name lost its type arguments there, and a named tuple broke the attribute. Refused rather than
diff --git a/tools/probe/corpus/seeds/C22-generator-refusals-over-value-object.patch b/tools/probe/corpus/seeds/C22-generator-refusals-over-value-object.patch
deleted file mode 100644
index 786ea89c..00000000
--- a/tools/probe/corpus/seeds/C22-generator-refusals-over-value-object.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectFabric.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectFabric.cs
-index 6ceba7f..3f10fec 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectFabric.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectFabric.cs
-@@ -38,7 +38,7 @@ internal sealed class ValueObjectFabric : TransitiveProjectFabric
-                .Where(ValueObjectTypes.IsValueObject)
-                .AddAspect(type => new ValueObjectAspect(
-                               CompanionClass.NameOwner(type),
--                              ValueObjectTypes.WrappedValueObjectRefusal(type)));
-+                              null));
- 
-         // An abstract type gets no aspect, so it is refused here, where it is selected.
-         amender.SelectTypes(includeNestedTypes: true)
diff --git a/tools/probe/corpus/seeds/C22-generator-refusals-unsealed-record-class.patch b/tools/probe/corpus/seeds/C22-generator-refusals-unsealed-record-class.patch
deleted file mode 100644
index 8cf83217..00000000
--- a/tools/probe/corpus/seeds/C22-generator-refusals-unsealed-record-class.patch
+++ /dev/null
@@ -1,17 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs
-index db8d4e9..c8e8392 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs
-@@ -163,12 +163,6 @@ internal sealed partial class ValueObjectAspect : TypeAspect
-         // A record class that can be derived from is not generated: a derived record compares equal
-         // only to its own type, which is not value equality, and a derived value object then failed
-         // inside the generated code (LAMA0611), where the error names nothing the user wrote.
--        if (target is { TypeKind: TypeKind.Class, IsSealed: false })
--        {
--            builder.Diagnostics.Report(MissingSealedKeyword.WithArguments(target));
--            return false;
--        }
--
-         for (var baseType = target.BaseType; baseType is not null; baseType = baseType.BaseType)
-         {
-             if (!baseType.IsAbstract && ValueObjectTypes.Markers(baseType).Count > 0)
diff --git a/tools/probe/corpus/seeds/E01-column-parity-column-type.patch b/tools/probe/corpus/seeds/E01-column-parity-column-type.patch
deleted file mode 100644
index 85a5d4e1..00000000
--- a/tools/probe/corpus/seeds/E01-column-parity-column-type.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTypeMappingSourcePlugin.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTypeMappingSourcePlugin.cs
-index d04ed86..a3b3de2 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTypeMappingSourcePlugin.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTypeMappingSourcePlugin.cs
-@@ -49,7 +49,7 @@ internal sealed class ValueObjectTypeMappingSourcePlugin(IServiceProvider servic
-         _typeMappingSource ??= services.GetRequiredService<IRelationalTypeMappingSource>();
- 
-         var wrapped = _typeMappingSource.FindMapping(
--            valueObject.WrappedType, mappingInfo.StoreTypeName, mappingInfo.IsKeyOrIndex, mappingInfo.IsUnicode, mappingInfo.Size,
-+            valueObject.WrappedType.IsEnum ? typeof(string) : valueObject.WrappedType, mappingInfo.StoreTypeName, mappingInfo.IsKeyOrIndex, mappingInfo.IsUnicode, mappingInfo.Size,
-             mappingInfo.IsRowVersion, mappingInfo.IsFixedLength, mappingInfo.Precision, mappingInfo.Scale);
- 
-         return wrapped is null ? null : ValueObjectMapping.For(valueObject).ComposeOnto(wrapped);
diff --git a/tools/probe/corpus/seeds/E01-column-parity-facet-kept.patch b/tools/probe/corpus/seeds/E01-column-parity-facet-kept.patch
deleted file mode 100644
index 63ba2837..00000000
--- a/tools/probe/corpus/seeds/E01-column-parity-facet-kept.patch
+++ /dev/null
@@ -1,23 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index 934f884..b30cfc4 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-@@ -52,8 +52,18 @@ internal sealed class ValueObjectKeyValueGenerationConvention : IModelFinalizing
-     public void ProcessModelFinalizing(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
-     {
-         foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
-+        {
-+            foreach (var p in entityType.GetDeclaredProperties())
-+                if (ValueObjectTypes.Describe(Nullable.GetUnderlyingType(p.ClrType) ?? p.ClrType) is not null)
-+                {
-+                    if (p.GetMaxLengthConfigurationSource() == ConfigurationSource.Explicit) ((IMutableProperty)p).SetMaxLength(null);
-+                    if (p.GetPrecisionConfigurationSource() == ConfigurationSource.Explicit) ((IMutableProperty)p).SetPrecision(null);
-+                    if (p.GetScaleConfigurationSource() == ConfigurationSource.Explicit) ((IMutableProperty)p).SetScale(null);
-+                    if (p.GetColumnTypeConfigurationSource() == ConfigurationSource.Explicit) ((IMutableProperty)p).SetColumnType(null);
-+                }
-             if (GeneratedKey(entityType) is { } property)
-                 property.Builder.ValueGenerated(ValueGenerated.OnAdd);
-+        }
-     }
- 
-     /// <summary>The entity type's key, where it is a value object over an integer EF generates a key of.</summary>
diff --git a/tools/probe/corpus/seeds/E01-column-parity-nullable.patch b/tools/probe/corpus/seeds/E01-column-parity-nullable.patch
deleted file mode 100644
index 189920fc..00000000
--- a/tools/probe/corpus/seeds/E01-column-parity-nullable.patch
+++ /dev/null
@@ -1,17 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index 934f884..7c7fa9c 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-@@ -52,8 +52,12 @@ internal sealed class ValueObjectKeyValueGenerationConvention : IModelFinalizing
-     public void ProcessModelFinalizing(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
-     {
-         foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
-+        {
-+            foreach (var p in entityType.GetDeclaredProperties())
-+                if (!p.IsKey() && ValueObjectTypes.Describe(Nullable.GetUnderlyingType(p.ClrType) ?? p.ClrType) is not null) p.Builder.IsRequired(true);
-             if (GeneratedKey(entityType) is { } property)
-                 property.Builder.ValueGenerated(ValueGenerated.OnAdd);
-+        }
-     }
- 
-     /// <summary>The entity type's key, where it is a value object over an integer EF generates a key of.</summary>
diff --git a/tools/probe/corpus/seeds/E02-value-translates-to-column-get-value.patch b/tools/probe/corpus/seeds/E02-value-translates-to-column-get-value.patch
deleted file mode 100644
index 195c217a..00000000
--- a/tools/probe/corpus/seeds/E02-value-translates-to-column-get-value.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs
-index 4cbf797..b3f43b0 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs
-@@ -73,7 +73,7 @@ internal sealed class ValueObjectMethodCallTranslatorPlugin(
-         )
-         {
-             if (instance is not null || arguments.Count != 1) return null;
--            if (method.GetCustomAttribute<TranslatedAsWrappedValueAttribute>() is null) return null;
-+            if (method.GetCustomAttribute<TranslatedAsWrappedValueAttribute>() is null || method.Name == "GetValue") return null;
- 
-             var parameterType = method.GetParameters()[0].ParameterType;
-             var valueType     = Nullable.GetUnderlyingType(method.ReturnType) ?? method.ReturnType;
diff --git a/tools/probe/corpus/seeds/E02-value-translates-to-column-value-or-null.patch b/tools/probe/corpus/seeds/E02-value-translates-to-column-value-or-null.patch
deleted file mode 100644
index 508fe393..00000000
--- a/tools/probe/corpus/seeds/E02-value-translates-to-column-value-or-null.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs
-index 4cbf797..928d9dd 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs
-@@ -73,7 +73,7 @@ internal sealed class ValueObjectMethodCallTranslatorPlugin(
-         )
-         {
-             if (instance is not null || arguments.Count != 1) return null;
--            if (method.GetCustomAttribute<TranslatedAsWrappedValueAttribute>() is null) return null;
-+            if (method.GetCustomAttribute<TranslatedAsWrappedValueAttribute>() is null || method.Name == "ValueOrNull") return null;
- 
-             var parameterType = method.GetParameters()[0].ParameterType;
-             var valueType     = Nullable.GetUnderlyingType(method.ReturnType) ?? method.ReturnType;
diff --git a/tools/probe/corpus/seeds/E02-value-translates-to-column-value.patch b/tools/probe/corpus/seeds/E02-value-translates-to-column-value.patch
deleted file mode 100644
index 41a53ec9..00000000
--- a/tools/probe/corpus/seeds/E02-value-translates-to-column-value.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs
-index 4cbf797..28a0492 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs
-@@ -34,7 +34,7 @@ internal sealed class ValueObjectMemberTranslatorPlugin(
-             IDiagnosticsLogger<DbLoggerCategory.Query> logger
-         )
-         {
--            if (instance is null || member.Name != nameof(IValueObject<,>.Value)) return null;
-+            if (instance is null || member.Name != nameof(IValueObject<,>.Value) || member.Name.Length > 0) return null;
-             if (member.DeclaringType is not { } declaringType || ValueObjectTypes.Describe(declaringType) is not { } valueObject) return null;
- 
-             return WrappedValue.Of(instance, valueObject, returnType, sqlExpressionFactory, typeMappingSource);
diff --git a/tools/probe/corpus/seeds/E03-column-round-trip-keys.patch b/tools/probe/corpus/seeds/E03-column-round-trip-keys.patch
deleted file mode 100644
index 4c9880d7..00000000
--- a/tools/probe/corpus/seeds/E03-column-round-trip-keys.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTypeMappingSourcePlugin.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTypeMappingSourcePlugin.cs
-index d04ed86..8f40572 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTypeMappingSourcePlugin.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTypeMappingSourcePlugin.cs
-@@ -45,6 +45,7 @@ internal sealed class ValueObjectTypeMappingSourcePlugin(IServiceProvider servic
-         }
- 
-         if (ValueObjectTypes.Describe(Nullable.GetUnderlyingType(clrType) ?? clrType) is not { } valueObject) return null;
-+        if (mappingInfo.IsKeyOrIndex) return null;
- 
-         _typeMappingSource ??= services.GetRequiredService<IRelationalTypeMappingSource>();
- 
diff --git a/tools/probe/corpus/seeds/E03-column-round-trip-nullable-properties.patch b/tools/probe/corpus/seeds/E03-column-round-trip-nullable-properties.patch
deleted file mode 100644
index 189920fc..00000000
--- a/tools/probe/corpus/seeds/E03-column-round-trip-nullable-properties.patch
+++ /dev/null
@@ -1,17 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index 934f884..7c7fa9c 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-@@ -52,8 +52,12 @@ internal sealed class ValueObjectKeyValueGenerationConvention : IModelFinalizing
-     public void ProcessModelFinalizing(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
-     {
-         foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
-+        {
-+            foreach (var p in entityType.GetDeclaredProperties())
-+                if (!p.IsKey() && ValueObjectTypes.Describe(Nullable.GetUnderlyingType(p.ClrType) ?? p.ClrType) is not null) p.Builder.IsRequired(true);
-             if (GeneratedKey(entityType) is { } property)
-                 property.Builder.ValueGenerated(ValueGenerated.OnAdd);
-+        }
-     }
- 
-     /// <summary>The entity type's key, where it is a value object over an integer EF generates a key of.</summary>
diff --git a/tools/probe/corpus/seeds/E03-column-round-trip-stored-as-underlying.patch b/tools/probe/corpus/seeds/E03-column-round-trip-stored-as-underlying.patch
deleted file mode 100644
index b1f413f3..00000000
--- a/tools/probe/corpus/seeds/E03-column-round-trip-stored-as-underlying.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTypeMappingSourcePlugin.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTypeMappingSourcePlugin.cs
-index d04ed86..9efc11b 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTypeMappingSourcePlugin.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTypeMappingSourcePlugin.cs
-@@ -49,7 +49,7 @@ internal sealed class ValueObjectTypeMappingSourcePlugin(IServiceProvider servic
-         _typeMappingSource ??= services.GetRequiredService<IRelationalTypeMappingSource>();
- 
-         var wrapped = _typeMappingSource.FindMapping(
--            valueObject.WrappedType, mappingInfo.StoreTypeName, mappingInfo.IsKeyOrIndex, mappingInfo.IsUnicode, mappingInfo.Size,
-+            valueObject.WrappedType == typeof(decimal) ? typeof(double) : valueObject.WrappedType, mappingInfo.StoreTypeName, mappingInfo.IsKeyOrIndex, mappingInfo.IsUnicode, mappingInfo.Size,
-             mappingInfo.IsRowVersion, mappingInfo.IsFixedLength, mappingInfo.Precision, mappingInfo.Scale);
- 
-         return wrapped is null ? null : ValueObjectMapping.For(valueObject).ComposeOnto(wrapped);
diff --git a/tools/probe/corpus/seeds/E04-integer-key-generated-byte-not-generated.patch b/tools/probe/corpus/seeds/E04-integer-key-generated-byte-not-generated.patch
deleted file mode 100644
index bdbd514f..00000000
--- a/tools/probe/corpus/seeds/E04-integer-key-generated-byte-not-generated.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index 934f884..96b4bbd 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-@@ -77,7 +77,7 @@ internal sealed class ValueObjectKeyValueGenerationConvention : IModelFinalizing
-     /// </summary>
-     private static bool IsGeneratedByTheDatabase(Type wrapped) =>
-         wrapped == typeof(int) || wrapped == typeof(long) || wrapped == typeof(short) || wrapped == typeof(sbyte)
--     || wrapped == typeof(uint) || wrapped == typeof(ulong) || wrapped == typeof(ushort);
-+     || wrapped == typeof(uint) || wrapped == typeof(ulong) || wrapped == typeof(ushort) || wrapped == typeof(byte);
- }
- 
- /// <summary>
diff --git a/tools/probe/corpus/seeds/E04-integer-key-generated-generated-on-add.patch b/tools/probe/corpus/seeds/E04-integer-key-generated-generated-on-add.patch
deleted file mode 100644
index 7384d9b8..00000000
--- a/tools/probe/corpus/seeds/E04-integer-key-generated-generated-on-add.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index 934f884..fee4e9a 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-@@ -53,7 +53,7 @@ internal sealed class ValueObjectKeyValueGenerationConvention : IModelFinalizing
-     {
-         foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
-             if (GeneratedKey(entityType) is { } property)
--                property.Builder.ValueGenerated(ValueGenerated.OnAdd);
-+                property.Builder.ValueGenerated(ValueGenerated.Never);
-     }
- 
-     /// <summary>The entity type's key, where it is a value object over an integer EF generates a key of.</summary>
diff --git a/tools/probe/corpus/seeds/E04-integer-key-generated-guid-key-yours.patch b/tools/probe/corpus/seeds/E04-integer-key-generated-guid-key-yours.patch
deleted file mode 100644
index 8c6b7d8d..00000000
--- a/tools/probe/corpus/seeds/E04-integer-key-generated-guid-key-yours.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index 934f884..55d4b57 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-@@ -77,7 +77,7 @@ internal sealed class ValueObjectKeyValueGenerationConvention : IModelFinalizing
-     /// </summary>
-     private static bool IsGeneratedByTheDatabase(Type wrapped) =>
-         wrapped == typeof(int) || wrapped == typeof(long) || wrapped == typeof(short) || wrapped == typeof(sbyte)
--     || wrapped == typeof(uint) || wrapped == typeof(ulong) || wrapped == typeof(ushort);
-+     || wrapped == typeof(uint) || wrapped == typeof(ulong) || wrapped == typeof(ushort) || wrapped == typeof(Guid);
- }
- 
- /// <summary>
diff --git a/tools/probe/corpus/seeds/E04-integer-key-generated-not-on-efs-list.patch b/tools/probe/corpus/seeds/E04-integer-key-generated-not-on-efs-list.patch
deleted file mode 100644
index 8791b695..00000000
--- a/tools/probe/corpus/seeds/E04-integer-key-generated-not-on-efs-list.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index c64d73e..afedaa5 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-@@ -77,7 +77,7 @@ internal sealed class ValueObjectKeyValueGenerationConvention : IModelFinalizing
-     /// </summary>
-     private static bool IsGeneratedByTheDatabase(Type wrapped) =>
-         wrapped == typeof(int) || wrapped == typeof(long) || wrapped == typeof(short) || wrapped == typeof(sbyte)
--     || wrapped == typeof(uint) || wrapped == typeof(ulong) || wrapped == typeof(ushort);
-+     || wrapped == typeof(uint) || wrapped == typeof(ulong) || wrapped == typeof(ushort) || wrapped == typeof(string);
- }
- 
- /// <summary>
diff --git a/tools/probe/corpus/seeds/E04-integer-key-generated-own-configuration-wins.patch b/tools/probe/corpus/seeds/E04-integer-key-generated-own-configuration-wins.patch
deleted file mode 100644
index a76b9d10..00000000
--- a/tools/probe/corpus/seeds/E04-integer-key-generated-own-configuration-wins.patch
+++ /dev/null
@@ -1,18 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index 934f884..6b023d9 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-@@ -52,8 +52,13 @@ internal sealed class ValueObjectKeyValueGenerationConvention : IModelFinalizing
-     public void ProcessModelFinalizing(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
-     {
-         foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
-+        {
-+            if (entityType.FindPrimaryKey() is { Properties: [var key] }
-+             && ValueObjectTypes.Describe(key.ClrType) is { WrappedType: var keyWrapped } && (keyWrapped == typeof(char) || keyWrapped == typeof(Guid)))
-+                ((IMutableProperty)key).ValueGenerated = ValueGenerated.Never;
-             if (GeneratedKey(entityType) is { } property)
-                 property.Builder.ValueGenerated(ValueGenerated.OnAdd);
-+        }
-     }
- 
-     /// <summary>The entity type's key, where it is a value object over an integer EF generates a key of.</summary>
diff --git a/tools/probe/corpus/seeds/E05-own-compareto-rejected-comparison.patch b/tools/probe/corpus/seeds/E05-own-compareto-rejected-comparison.patch
deleted file mode 100644
index aea808cd..00000000
--- a/tools/probe/corpus/seeds/E05-own-compareto-rejected-comparison.patch
+++ /dev/null
@@ -1,22 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-index 5f1499f..81d9b28 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-@@ -84,7 +84,7 @@ internal static class HandWrittenOrdering
-         protected override Expression VisitBinary(BinaryExpression node)
-         {
-             if (node.NodeType is ExpressionType.LessThan or ExpressionType.LessThanOrEqual or ExpressionType.GreaterThan or ExpressionType.GreaterThanOrEqual
--             && !RunsInMemory(node))
-+             && !RunsInMemory(node) && skipsWhatRunsInMemory)
-             {
-                 Refuse(node.Left.Type, $"compared with {Operator(node.NodeType)}");
-                 Refuse(node.Right.Type, $"compared with {Operator(node.NodeType)}");
-@@ -99,7 +99,7 @@ internal static class HandWrittenOrdering
- 
-             if (method.Name is nameof(IComparable.CompareTo) or nameof(IComparer<>.Compare))
-             {
--                if (!RunsInMemory(node))
-+                if (!RunsInMemory(node) && skipsWhatRunsInMemory)
-                 {
-                     if (node.Object is not null) Refuse(node.Object.Type, $"compared with {method.Name}");
-                     foreach (var argument in node.Arguments) Refuse(argument.Type, $"compared with {method.Name}");
diff --git a/tools/probe/corpus/seeds/E05-own-compareto-rejected-equality-allowed.patch b/tools/probe/corpus/seeds/E05-own-compareto-rejected-equality-allowed.patch
deleted file mode 100644
index 6cefc240..00000000
--- a/tools/probe/corpus/seeds/E05-own-compareto-rejected-equality-allowed.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-index 5f1499f..6b47cfd 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-@@ -83,7 +83,7 @@ internal static class HandWrittenOrdering
-     {
-         protected override Expression VisitBinary(BinaryExpression node)
-         {
--            if (node.NodeType is ExpressionType.LessThan or ExpressionType.LessThanOrEqual or ExpressionType.GreaterThan or ExpressionType.GreaterThanOrEqual
-+            if (node.NodeType is ExpressionType.Equal or ExpressionType.LessThan or ExpressionType.LessThanOrEqual or ExpressionType.GreaterThan or ExpressionType.GreaterThanOrEqual
-              && !RunsInMemory(node))
-             {
-                 Refuse(node.Left.Type, $"compared with {Operator(node.NodeType)}");
diff --git a/tools/probe/corpus/seeds/E05-own-compareto-rejected-min-max.patch b/tools/probe/corpus/seeds/E05-own-compareto-rejected-min-max.patch
deleted file mode 100644
index 38d37356..00000000
--- a/tools/probe/corpus/seeds/E05-own-compareto-rejected-min-max.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-index 5f1499f..89d2907 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-@@ -142,7 +142,6 @@ internal static class HandWrittenOrdering
-             nameof(Queryable.OrderBy) or nameof(Queryable.OrderByDescending) or nameof(Queryable.ThenBy) or nameof(Queryable.ThenByDescending)
-              or nameof(Queryable.MinBy) or nameof(Queryable.MaxBy) when method.IsGenericMethod => method.GetGenericArguments()[1],
-             nameof(Queryable.Order) or nameof(Queryable.OrderDescending) when method.IsGenericMethod => method.GetGenericArguments()[0],
--            nameof(Queryable.Min) or nameof(Queryable.Max) => method.ReturnType,
-             _ => null,
-         };
- 
diff --git a/tools/probe/corpus/seeds/E05-own-compareto-rejected-ordering.patch b/tools/probe/corpus/seeds/E05-own-compareto-rejected-ordering.patch
deleted file mode 100644
index 51de5081..00000000
--- a/tools/probe/corpus/seeds/E05-own-compareto-rejected-ordering.patch
+++ /dev/null
@@ -1,15 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-index 5f1499f..6acc064 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-@@ -139,9 +139,7 @@ internal static class HandWrittenOrdering
-         /// <summary>The type a LINQ operator orders by: the key, the element for <c>Order</c>, the result for <c>Min</c> and <c>Max</c>.</summary>
-         private static Type? OrderedType(MethodInfo method) => method.Name switch
-         {
--            nameof(Queryable.OrderBy) or nameof(Queryable.OrderByDescending) or nameof(Queryable.ThenBy) or nameof(Queryable.ThenByDescending)
--             or nameof(Queryable.MinBy) or nameof(Queryable.MaxBy) when method.IsGenericMethod => method.GetGenericArguments()[1],
--            nameof(Queryable.Order) or nameof(Queryable.OrderDescending) when method.IsGenericMethod => method.GetGenericArguments()[0],
-+            nameof(Queryable.MinBy) or nameof(Queryable.MaxBy) when method.IsGenericMethod => method.GetGenericArguments()[1],
-             nameof(Queryable.Min) or nameof(Queryable.Max) => method.ReturnType,
-             _ => null,
-         };
diff --git a/tools/probe/corpus/seeds/E05-own-compareto-rejected-query-filter.patch b/tools/probe/corpus/seeds/E05-own-compareto-rejected-query-filter.patch
deleted file mode 100644
index d82d5cb8..00000000
--- a/tools/probe/corpus/seeds/E05-own-compareto-rejected-query-filter.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-index 5f1499f..0efc973 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-@@ -56,7 +56,7 @@ internal sealed class HandWrittenOrderingQueryFilterConvention : IModelFinalized
-     {
-         foreach (var entityType in model.GetEntityTypes())
-             foreach (var filter in entityType.GetDeclaredQueryFilters())
--                if (filter.Expression is { } expression)
-+                if (filter.Expression is { } expression && expression.Parameters.Count == 0)
-                     HandWrittenOrdering.RefuseInFilter(expression, filter.IsAnonymous
-                         ? $"in the query filter of {entityType.DisplayName()}"
-                         : $"in the query filter \"{filter.Key}\" of {entityType.DisplayName()}");
diff --git a/tools/probe/corpus/seeds/E05-own-compareto-rejected-value-order-allowed.patch b/tools/probe/corpus/seeds/E05-own-compareto-rejected-value-order-allowed.patch
deleted file mode 100644
index c8e5b6eb..00000000
--- a/tools/probe/corpus/seeds/E05-own-compareto-rejected-value-order-allowed.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-index 09a9e8c..3d10963 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-@@ -117,6 +117,7 @@ internal static class HandWrittenOrdering
-                 // A key the selector converts (to object, IComparable) is still ordered in memory by the
-                 // value object's CompareTo, while EF drops the conversion and orders by the column.
-                 if (KeySelector(node) is { } key) Refuse(Unconverted(key.Body).Type, $"ordered by {method.Name}");
-+                if (KeySelector(node) is { Body: MemberExpression { Expression: { } owner } }) Refuse(owner.Type, $"ordered by {method.Name}");
-             }
-             else if (IsDbFunction(method) && !RunsInMemory(node))
-             {
diff --git a/tools/probe/corpus/seeds/E06-own-converter-no-value-value-not-translated.patch b/tools/probe/corpus/seeds/E06-own-converter-no-value-value-not-translated.patch
deleted file mode 100644
index ea216387..00000000
--- a/tools/probe/corpus/seeds/E06-own-converter-no-value-value-not-translated.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs
-index 4cbf797..2da8e5a 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs
-@@ -117,7 +117,7 @@ internal static class WrappedValue
-                    ?? typeMappingSource.FindMapping(valueType);
- 
-         if (operand.TypeMapping is { } operandMapping
--         && (operandMapping.Converter is not { } converter || !ValueObjectMapping.For(valueObject).StoresTheWrappedValue(converter, mapping?.Converter)))
-+         && operandMapping.Converter is null)
-             return null;
- 
-         return operand is ColumnExpression column && !IsCollectionElement(column)
diff --git a/tools/probe/corpus/seeds/E06-own-converter-no-value-value-object-comparison.patch b/tools/probe/corpus/seeds/E06-own-converter-no-value-value-object-comparison.patch
deleted file mode 100644
index 2341e337..00000000
--- a/tools/probe/corpus/seeds/E06-own-converter-no-value-value-object-comparison.patch
+++ /dev/null
@@ -1,28 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-index 5f1499f..00292f7 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-@@ -34,7 +34,22 @@ internal sealed class HandWrittenOrderingInterceptor : IQueryExpressionIntercept
-     {
-         HandWrittenOrdering.RefuseIn(queryExpression);
- 
--        return queryExpression;
-+        return new EqualityOfValues().Visit(queryExpression);
-+    }
-+
-+    /// <summary>A value-object equality, as an equality of the values it wraps.</summary>
-+    private sealed class EqualityOfValues : ExpressionVisitor
-+    {
-+        protected override Expression VisitBinary(BinaryExpression node)
-+        {
-+#pragma warning disable IL2075
-+            if (node.NodeType == ExpressionType.Equal && node.Left.Type == node.Right.Type && ValueObjectTypes.IsValueObject(node.Left.Type)
-+             && node.Left.Type.GetProperty("Value") is { } value)
-+                return Expression.Equal(Expression.Property(Visit(node.Left)!, value), Expression.Property(Visit(node.Right)!, value));
-+#pragma warning restore IL2075
-+
-+            return base.VisitBinary(node);
-+        }
-     }
- }
- 
diff --git a/tools/probe/corpus/seeds/E07-closed-set-stored-as-name-in-collections-and-json.patch b/tools/probe/corpus/seeds/E07-closed-set-stored-as-name-in-collections-and-json.patch
deleted file mode 100644
index 0cd27420..00000000
--- a/tools/probe/corpus/seeds/E07-closed-set-stored-as-name-in-collections-and-json.patch
+++ /dev/null
@@ -1,15 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ClosedSetMapping.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ClosedSetMapping.cs
-index bbaa392..50a8e08 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ClosedSetMapping.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ClosedSetMapping.cs
-@@ -47,7 +47,9 @@ internal abstract class ClosedSetMapping
-         public override ValueConverter Converter { get; } = new ValueConverter<TSet, string>(ClosedSetConverter<TSet>.ToProvider, ClosedSetConverter<TSet>.FromProvider);
- 
-         protected override JsonValueReaderWriter? ReaderWriterOver(JsonValueReaderWriter? text) =>
--            text is JsonValueReaderWriter<string> typed ? new JsonConvertedValueReaderWriter<TSet, string>(typed, Converter) : null;
-+            text is JsonValueReaderWriter<string> typed
-+                ? new JsonConvertedValueReaderWriter<TSet, string>(typed, new ValueConverter<TSet, string>(member => member.Name + "!", name => ClosedSetConverter<TSet>.MemberNamed(name)))
-+                : null;
-     }
- 
-     private sealed class Factory : IClosedSetVisitor<ClosedSetMapping>
diff --git a/tools/probe/corpus/seeds/E07-closed-set-stored-as-name-non-member-throws.patch b/tools/probe/corpus/seeds/E07-closed-set-stored-as-name-non-member-throws.patch
deleted file mode 100644
index 6343d4cb..00000000
--- a/tools/probe/corpus/seeds/E07-closed-set-stored-as-name-non-member-throws.patch
+++ /dev/null
@@ -1,17 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ClosedSetConverter.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ClosedSetConverter.cs
-index f0049b3..2c06526 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ClosedSetConverter.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ClosedSetConverter.cs
-@@ -45,7 +45,11 @@ public sealed class ClosedSetConverter<TSet> : ValueConverter<TSet, string>
-     /// <returns>Its name.</returns>
-     /// <exception cref="InvalidOperationException">The instance is not one of the set's members.</exception>
-     [EditorBrowsable(EditorBrowsableState.Never)]
--    public static string ProviderValue(TSet member) => member.Name;
-+    public static string ProviderValue(TSet member)
-+    {
-+        try { return member.Name; }
-+        catch (InvalidOperationException) { return "Unknown"; }
-+    }
- 
-     /// <summary>The member of a stored name.</summary>
-     /// <remarks>Public for the code EF's compiled model generates; nothing else needs to call it.</remarks>
diff --git a/tools/probe/corpus/seeds/E07-closed-set-stored-as-name-stored-as-name.patch b/tools/probe/corpus/seeds/E07-closed-set-stored-as-name-stored-as-name.patch
deleted file mode 100644
index 43428d26..00000000
--- a/tools/probe/corpus/seeds/E07-closed-set-stored-as-name-stored-as-name.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ClosedSetConverter.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ClosedSetConverter.cs
-index f0049b3..6e7f826 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ClosedSetConverter.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ClosedSetConverter.cs
-@@ -45,7 +45,7 @@ public sealed class ClosedSetConverter<TSet> : ValueConverter<TSet, string>
-     /// <returns>Its name.</returns>
-     /// <exception cref="InvalidOperationException">The instance is not one of the set's members.</exception>
-     [EditorBrowsable(EditorBrowsableState.Never)]
--    public static string ProviderValue(TSet member) => member.Name;
-+    public static string ProviderValue(TSet member) => member.Name.ToUpperInvariant();
- 
-     /// <summary>The member of a stored name.</summary>
-     /// <remarks>Public for the code EF's compiled model generates; nothing else needs to call it.</remarks>
diff --git a/tools/probe/corpus/seeds/E07-closed-set-stored-as-name-unknown-name-throws.patch b/tools/probe/corpus/seeds/E07-closed-set-stored-as-name-unknown-name-throws.patch
deleted file mode 100644
index 50afdc25..00000000
--- a/tools/probe/corpus/seeds/E07-closed-set-stored-as-name-unknown-name-throws.patch
+++ /dev/null
@@ -1,11 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ClosedSetConverter.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ClosedSetConverter.cs
-index f0049b3..6ebae68 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ClosedSetConverter.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ClosedSetConverter.cs
-@@ -56,5 +56,5 @@ public sealed class ClosedSetConverter<TSet> : ValueConverter<TSet, string>
-     public static TSet MemberNamed(string name) =>
-         TSet.TryParse(name, out var member)
-             ? member
--            : throw new InvalidOperationException($"{typeof(TSet).Name} has no member of that name: the column holds a name the set no longer has.");
-+            : null!;
- }
diff --git a/tools/probe/corpus/seeds/E08-option-result-not-columns-error-says-so.patch b/tools/probe/corpus/seeds/E08-option-result-not-columns-error-says-so.patch
deleted file mode 100644
index d25351e9..00000000
--- a/tools/probe/corpus/seeds/E08-option-result-not-columns-error-says-so.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTypeMappingSourcePlugin.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTypeMappingSourcePlugin.cs
-index d04ed86..591bfb4 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTypeMappingSourcePlugin.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTypeMappingSourcePlugin.cs
-@@ -33,6 +33,8 @@ internal sealed class ValueObjectTypeMappingSourcePlugin(IServiceProvider servic
-     public RelationalTypeMapping? FindMapping(in RelationalTypeMappingInfo mappingInfo)
-     {
-         if (mappingInfo.ClrType is not { } clrType) return null;
-+        if (clrType.Name.StartsWith("Option`", StringComparison.Ordinal) || clrType.Name.StartsWith("Result`", StringComparison.Ordinal))
-+            throw new InvalidOperationException("This property cannot be mapped.");
- 
-         // A closed set is a text column holding the member's name.
-         if (ClosedSetMapping.Describe(clrType) is { } set)
diff --git a/tools/probe/corpus/seeds/E08-option-result-not-columns-model-fails.patch b/tools/probe/corpus/seeds/E08-option-result-not-columns-model-fails.patch
deleted file mode 100644
index b1ba36b8..00000000
--- a/tools/probe/corpus/seeds/E08-option-result-not-columns-model-fails.patch
+++ /dev/null
@@ -1,20 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index 934f884..0981e07 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-@@ -52,8 +52,15 @@ internal sealed class ValueObjectKeyValueGenerationConvention : IModelFinalizing
-     public void ProcessModelFinalizing(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
-     {
-         foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
-+        {
-+#pragma warning disable IL2075
-+            foreach (var clr in entityType.ClrType.GetProperties())
-+#pragma warning restore IL2075
-+                if (clr.PropertyType.Name.StartsWith("Option`", StringComparison.Ordinal) || clr.PropertyType.Name.StartsWith("Result`", StringComparison.Ordinal))
-+                    entityType.Builder.Ignore(clr.Name);
-             if (GeneratedKey(entityType) is { } property)
-                 property.Builder.ValueGenerated(ValueGenerated.OnAdd);
-+        }
-     }
- 
-     /// <summary>The entity type's key, where it is a value object over an integer EF generates a key of.</summary>
diff --git a/tools/probe/corpus/seeds/E09-or-none-in-database-element-at-skips.patch b/tools/probe/corpus/seeds/E09-or-none-in-database-element-at-skips.patch
deleted file mode 100644
index 154d16e3..00000000
--- a/tools/probe/corpus/seeds/E09-or-none-in-database-element-at-skips.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/OptionExtensions.cs b/src/CodoMetis.TypeKit/OptionExtensions.cs
-index 369d57a..c77b64a 100644
---- a/src/CodoMetis.TypeKit/OptionExtensions.cs
-+++ b/src/CodoMetis.TypeKit/OptionExtensions.cs
-@@ -576,7 +576,7 @@ public static class Option
-         {
-             ArgumentNullException.ThrowIfNull(source);
- 
--            return index < 0 ? None<T>() : FirstOf(source.Skip(index).Take(1));
-+            return index < 0 ? None<T>() : FirstOf(source.Take(index + 1).AsEnumerable().Skip(index));
-         }
- 
-         /// <summary>Refused: a query skips to an index from the start, and one from the end would read every row to find it.</summary>
diff --git a/tools/probe/corpus/seeds/E09-or-none-in-database-first-reads-one-row.patch b/tools/probe/corpus/seeds/E09-or-none-in-database-first-reads-one-row.patch
deleted file mode 100644
index 14f7bf03..00000000
--- a/tools/probe/corpus/seeds/E09-or-none-in-database-first-reads-one-row.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/TypeKitQueryableExtensions.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/TypeKitQueryableExtensions.cs
-index 9636046..8c15b34 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/TypeKitQueryableExtensions.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/TypeKitQueryableExtensions.cs
-@@ -43,7 +43,7 @@ public static class TypeKitQueryableExtensions
-             ArgumentNullException.ThrowIfNull(source);
-             ArgumentNullException.ThrowIfNull(predicate);
- 
--            return FirstOfAsync(source.Where(predicate).Take(1), cancellationToken);
-+            return FirstOfAsync(source.Where(predicate), cancellationToken);
-         }
- 
-         /// <summary>The only element of the query, or <c>None</c>: the database is asked for two, and more than one throws.</summary>
diff --git a/tools/probe/corpus/seeds/E09-or-none-in-database-single-asks-for-two.patch b/tools/probe/corpus/seeds/E09-or-none-in-database-single-asks-for-two.patch
deleted file mode 100644
index 844c1f71..00000000
--- a/tools/probe/corpus/seeds/E09-or-none-in-database-single-asks-for-two.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/TypeKitQueryableExtensions.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/TypeKitQueryableExtensions.cs
-index 9636046..22caa03 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/TypeKitQueryableExtensions.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/TypeKitQueryableExtensions.cs
-@@ -88,7 +88,7 @@ public static class TypeKitQueryableExtensions
-         await foreach (var element in limited.AsAsyncEnumerable().WithCancellation(cancellationToken).ConfigureAwait(false))
-         {
-             if (found.IsSome())
--                throw new InvalidOperationException("The query holds more than one element, so SingleOrNoneAsync has no single one to answer. Use FirstOrNoneAsync where any one will do.");
-+                return found;
- 
-             found = Option.Some(element);
-         }
diff --git a/tools/probe/corpus/seeds/E10-read-back-skips-validation-reads-without-create.patch b/tools/probe/corpus/seeds/E10-read-back-skips-validation-reads-without-create.patch
deleted file mode 100644
index 78b3614a..00000000
--- a/tools/probe/corpus/seeds/E10-read-back-skips-validation-reads-without-create.patch
+++ /dev/null
@@ -1,20 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectConverter.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectConverter.cs
-index 48895b1..a308d3c 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectConverter.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectConverter.cs
-@@ -70,6 +70,14 @@ public sealed class ValueObjectConverter<TValueObject, T> : ValueConverter<TValu
-     /// <returns>The value object.</returns>
-     [EditorBrowsable(EditorBrowsableState.Never)]
- #pragma warning disable CMTK0004 // the read path, as above
--    public static TValueObject Materialize(T value) => TValueObject.Materialize(value);
-+    public static TValueObject Materialize(T value)
-+    {
-+#pragma warning disable IL2090, IL2075
-+        if (typeof(TValueObject).GetMethod("Create", [typeof(T)])?.Invoke(null, [value]) is { } created
-+         && created.GetType().GetProperty("State")?.GetValue(created)?.ToString() == "Error")
-+            throw new InvalidOperationException("The column holds a value Create refuses.");
-+#pragma warning restore IL2090, IL2075
-+        return TValueObject.Materialize(value);
-+    }
- #pragma warning restore CMTK0004
- }
diff --git a/tools/probe/corpus/seeds/E10-read-back-skips-validation-revalidate-finds.patch b/tools/probe/corpus/seeds/E10-read-back-skips-validation-revalidate-finds.patch
deleted file mode 100644
index 3f4a12a1..00000000
--- a/tools/probe/corpus/seeds/E10-read-back-skips-validation-revalidate-finds.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs
-index 07a7ecb..8b626aa 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs
-@@ -37,7 +37,7 @@ internal sealed partial class ValueObjectContractAspect
-     /// <summary><c>Create</c> of the value this instance holds.</summary>
-     [Template]
-     public dynamic RevalidateTemplate([CompileTime] INamedType target) =>
--        ExpressionFactory.Parse($"{ValueObjectTypes.SourceName(target)}.Create(this.Value)").Value!;
-+        ExpressionFactory.Parse("this").Value!;
- 
-     /// <summary>
-     /// A deeper base's <c>Equals(TBase)</c>, declared by the value object so that its listed
diff --git a/tools/probe/corpus/seeds/E11-usetypekit-order-order-does-not-matter.patch b/tools/probe/corpus/seeds/E11-usetypekit-order-order-does-not-matter.patch
deleted file mode 100644
index 54b917be..00000000
--- a/tools/probe/corpus/seeds/E11-usetypekit-order-order-does-not-matter.patch
+++ /dev/null
@@ -1,17 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/TypeKitOptionsExtension.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/TypeKitOptionsExtension.cs
-index d9d37fd..80be5a6 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/TypeKitOptionsExtension.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/TypeKitOptionsExtension.cs
-@@ -10,7 +10,11 @@ internal sealed class TypeKitOptionsExtension : IDbContextOptionsExtension
- 
-     public DbContextOptionsExtensionInfo Info => _info ??= new ExtensionInfo(this);
- 
--    public void ApplyServices(IServiceCollection services) => services.AddEntityFrameworkTypeKit();
-+    public void ApplyServices(IServiceCollection services)
-+    {
-+        if (services.Any(descriptor => descriptor.ServiceType == typeof(Microsoft.EntityFrameworkCore.Storage.IDatabaseProvider)))
-+            services.AddEntityFrameworkTypeKit();
-+    }
- 
-     public void Validate(IDbContextOptions options)
-     {
diff --git a/tools/probe/corpus/seeds/E12-convention-by-vo-type-underlying-type-does-not-reach.patch b/tools/probe/corpus/seeds/E12-convention-by-vo-type-underlying-type-does-not-reach.patch
deleted file mode 100644
index f98d2beb..00000000
--- a/tools/probe/corpus/seeds/E12-convention-by-vo-type-underlying-type-does-not-reach.patch
+++ /dev/null
@@ -1,35 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/TypeKitConventionSetPlugin.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/TypeKitConventionSetPlugin.cs
-index f0ec2c3..05e6d4c 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/TypeKitConventionSetPlugin.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/TypeKitConventionSetPlugin.cs
-@@ -1,3 +1,4 @@
-+using Microsoft.EntityFrameworkCore.Metadata.Builders;
- using Microsoft.EntityFrameworkCore.Metadata.Conventions;
- using Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure;
- 
-@@ -16,6 +17,8 @@ internal sealed class TypeKitConventionSetPlugin : IConventionSetPlugin
-     {
-         var finalizing = conventionSet.ModelFinalizingConventions;
- 
-+        conventionSet.PropertyAddedConventions.Add(new WrappedTypeConfigurationConvention());
-+
-         // After the last of EF's finalizing conventions that change what its value-generation convention
-         // re-reads, and so before a provider's value-generation strategy (an identity column on PostgreSQL
-         // and SQL Server), which is chosen for keys already generated on add and comes after them.
-@@ -52,3 +55,16 @@ internal sealed class TypeKitConventionSetPlugin : IConventionSetPlugin
-         return last + 1;
-     }
- }
-+
-+/// <summary>A value-object property configured as the type it wraps is: <c>ConfigureConventions</c> by the wrapped type reaches it.</summary>
-+internal sealed class WrappedTypeConfigurationConvention : IPropertyAddedConvention
-+{
-+    public void ProcessPropertyAdded(IConventionPropertyBuilder propertyBuilder, IConventionContext<IConventionPropertyBuilder> context)
-+    {
-+        var property = propertyBuilder.Metadata;
-+        if (ValueObjectTypes.Describe(Nullable.GetUnderlyingType(property.ClrType) ?? property.ClrType) is not { WrappedType: var wrapped }) return;
-+#pragma warning disable EF1001
-+        ((Microsoft.EntityFrameworkCore.Metadata.Internal.Model)property.DeclaringType.Model).Configuration?.FindProperty(wrapped)?.Apply((Microsoft.EntityFrameworkCore.Metadata.IMutableProperty)property);
-+#pragma warning restore EF1001
-+    }
-+}
diff --git a/tools/probe/corpus/seeds/E12-convention-by-vo-type-value-object-type-reaches.patch b/tools/probe/corpus/seeds/E12-convention-by-vo-type-value-object-type-reaches.patch
deleted file mode 100644
index 91a3be65..00000000
--- a/tools/probe/corpus/seeds/E12-convention-by-vo-type-value-object-type-reaches.patch
+++ /dev/null
@@ -1,22 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index 934f884..f8299cf 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-@@ -52,8 +52,17 @@ internal sealed class ValueObjectKeyValueGenerationConvention : IModelFinalizing
-     public void ProcessModelFinalizing(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
-     {
-         foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
-+        {
-+            foreach (var valueObjectProperty in entityType.GetDeclaredProperties())
-+                if (ValueObjectTypes.Describe(Nullable.GetUnderlyingType(valueObjectProperty.ClrType) ?? valueObjectProperty.ClrType) is not null)
-+                {
-+                    ((IMutableProperty)valueObjectProperty).SetMaxLength(null);
-+                    ((IMutableProperty)valueObjectProperty).SetPrecision(null);
-+                    ((IMutableProperty)valueObjectProperty).SetScale(null);
-+                }
-             if (GeneratedKey(entityType) is { } property)
-                 property.Builder.ValueGenerated(ValueGenerated.OnAdd);
-+        }
-     }
- 
-     /// <summary>The entity type's key, where it is a value object over an integer EF generates a key of.</summary>
diff --git a/tools/probe/corpus/seeds/E13-primitive-collections-contains.patch b/tools/probe/corpus/seeds/E13-primitive-collections-contains.patch
deleted file mode 100644
index f2c676d9..00000000
--- a/tools/probe/corpus/seeds/E13-primitive-collections-contains.patch
+++ /dev/null
@@ -1,22 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-index 09a9e8c..2e137c8 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/HandWrittenOrderingInterceptor.cs
-@@ -36,7 +36,16 @@ internal sealed class HandWrittenOrderingInterceptor : IQueryExpressionIntercept
-     {
-         HandWrittenOrdering.RefuseIn(queryExpression);
- 
--        return queryExpression;
-+        return new ContainsOfValueObjects().Visit(queryExpression);
-+    }
-+
-+    /// <summary>A value object's <c>Contains</c> in a collection, as a match of nothing.</summary>
-+    private sealed class ContainsOfValueObjects : ExpressionVisitor
-+    {
-+        protected override Expression VisitMethodCall(MethodCallExpression node) =>
-+            node.Method.Name == nameof(Enumerable.Contains) && node.Arguments.Count > 0 && ValueObjectTypes.IsValueObject(node.Arguments[^1].Type)
-+                ? Expression.Constant(false)
-+                : base.VisitMethodCall(node);
-     }
- }
- 
diff --git a/tools/probe/corpus/seeds/E13-primitive-collections-element-value.patch b/tools/probe/corpus/seeds/E13-primitive-collections-element-value.patch
deleted file mode 100644
index 24203343..00000000
--- a/tools/probe/corpus/seeds/E13-primitive-collections-element-value.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs
-index 4cbf797..7cd060d 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectTranslators.cs
-@@ -120,6 +120,8 @@ internal static class WrappedValue
-          && (operandMapping.Converter is not { } converter || !ValueObjectMapping.For(valueObject).StoresTheWrappedValue(converter, mapping?.Converter)))
-             return null;
- 
-+        if (operand is ColumnExpression element && IsCollectionElement(element)) return null;
-+
-         return operand is ColumnExpression column && !IsCollectionElement(column)
-                    ? new ColumnExpression(column.Name, column.TableAlias, valueType, mapping, column.IsNullable)
-                    : sqlExpressionFactory.Convert(operand, valueType, mapping);
diff --git a/tools/probe/corpus/seeds/E14-inheritance-key-generation-tpc-assign-on-sqlite.patch b/tools/probe/corpus/seeds/E14-inheritance-key-generation-tpc-assign-on-sqlite.patch
deleted file mode 100644
index 99e84eb1..00000000
--- a/tools/probe/corpus/seeds/E14-inheritance-key-generation-tpc-assign-on-sqlite.patch
+++ /dev/null
@@ -1,14 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index 934f884..feb0d14 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-@@ -110,8 +110,7 @@ internal sealed class ValueObjectTpcKeyValueGenerationConvention : IModelFinaliz
-             if (property.GetValueGeneratedConfigurationSource() != ConfigurationSource.Convention) continue;
- 
-             var table = property.GetMappedStoreObjects(StoreObjectType.Table).FirstOrDefault();
--            if (table.Name is null || RelationalValueGenerationConvention.GetValueGenerated(property, table) is null)
--                property.Builder.ValueGenerated(null);
-+            _ = table;
-         }
-     }
- }
diff --git a/tools/probe/corpus/seeds/E14-inheritance-key-generation-tph-tpt-root.patch b/tools/probe/corpus/seeds/E14-inheritance-key-generation-tph-tpt-root.patch
deleted file mode 100644
index c2842e41..00000000
--- a/tools/probe/corpus/seeds/E14-inheritance-key-generation-tph-tpt-root.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index 934f884..804be76 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-@@ -60,6 +60,7 @@ internal sealed class ValueObjectKeyValueGenerationConvention : IModelFinalizing
-     internal static IConventionProperty? GeneratedKey(IConventionEntityType entityType)
-     {
-         if (entityType.BaseType is not null || entityType.FindPrimaryKey() is not { Properties: [var property] }) return null;
-+        if (entityType.GetDirectlyDerivedTypes().Any() && entityType.GetMappingStrategy() != RelationalAnnotationNames.TpcMappingStrategy) return null;
-         // As EF's own rule: the foreign key that links a TPT table to its base type's is no reason not to
-         // generate the key, and EntityTypeHierarchyMappingConvention has added it by now.
-         if (property.GetContainingForeignKeys().Any(foreignKey => !foreignKey.IsBaseLinking())) return null;
diff --git a/tools/probe/corpus/seeds/E15-composite-key-as-for-primitives.patch b/tools/probe/corpus/seeds/E15-composite-key-as-for-primitives.patch
deleted file mode 100644
index 232734c4..00000000
--- a/tools/probe/corpus/seeds/E15-composite-key-as-for-primitives.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index 934f884..a58d509 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-@@ -59,7 +59,7 @@ internal sealed class ValueObjectKeyValueGenerationConvention : IModelFinalizing
-     /// <summary>The entity type's key, where it is a value object over an integer EF generates a key of.</summary>
-     internal static IConventionProperty? GeneratedKey(IConventionEntityType entityType)
-     {
--        if (entityType.BaseType is not null || entityType.FindPrimaryKey() is not { Properties: [var property] }) return null;
-+        if (entityType.BaseType is not null || entityType.FindPrimaryKey() is not { Properties: [var property, ..] }) return null;
-         // As EF's own rule: the foreign key that links a TPT table to its base type's is no reason not to
-         // generate the key, and EntityTypeHierarchyMappingConvention has added it by now.
-         if (property.GetContainingForeignKeys().Any(foreignKey => !foreignKey.IsBaseLinking())) return null;
diff --git a/tools/probe/corpus/seeds/E16-own-configuration-wins-column-type.patch b/tools/probe/corpus/seeds/E16-own-configuration-wins-column-type.patch
deleted file mode 100644
index 239fe9da..00000000
--- a/tools/probe/corpus/seeds/E16-own-configuration-wins-column-type.patch
+++ /dev/null
@@ -1,17 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index 934f884..e0bab02 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-@@ -52,8 +52,12 @@ internal sealed class ValueObjectKeyValueGenerationConvention : IModelFinalizing
-     public void ProcessModelFinalizing(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
-     {
-         foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
-+        {
-+            foreach (var p in entityType.GetDeclaredProperties())
-+                if (ValueObjectTypes.Describe(Nullable.GetUnderlyingType(p.ClrType) ?? p.ClrType) is not null && p.GetColumnTypeConfigurationSource() == ConfigurationSource.Explicit) ((IMutableProperty)p).SetColumnType(null);
-             if (GeneratedKey(entityType) is { } property)
-                 property.Builder.ValueGenerated(ValueGenerated.OnAdd);
-+        }
-     }
- 
-     /// <summary>The entity type's key, where it is a value object over an integer EF generates a key of.</summary>
diff --git a/tools/probe/corpus/seeds/E16-own-configuration-wins-conversion.patch b/tools/probe/corpus/seeds/E16-own-configuration-wins-conversion.patch
deleted file mode 100644
index d2d7a365..00000000
--- a/tools/probe/corpus/seeds/E16-own-configuration-wins-conversion.patch
+++ /dev/null
@@ -1,17 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index 934f884..0f45005 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-@@ -52,8 +52,12 @@ internal sealed class ValueObjectKeyValueGenerationConvention : IModelFinalizing
-     public void ProcessModelFinalizing(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
-     {
-         foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
-+        {
-+            foreach (var p in entityType.GetDeclaredProperties())
-+                if (ValueObjectTypes.Describe(Nullable.GetUnderlyingType(p.ClrType) ?? p.ClrType) is not null && p.GetValueConverterConfigurationSource() == ConfigurationSource.Explicit) ((IMutableProperty)p).SetValueConverter((Microsoft.EntityFrameworkCore.Storage.ValueConversion.ValueConverter?)null);
-             if (GeneratedKey(entityType) is { } property)
-                 property.Builder.ValueGenerated(ValueGenerated.OnAdd);
-+        }
-     }
- 
-     /// <summary>The entity type's key, where it is a value object over an integer EF generates a key of.</summary>
diff --git a/tools/probe/corpus/seeds/E16-own-configuration-wins-never.patch b/tools/probe/corpus/seeds/E16-own-configuration-wins-never.patch
deleted file mode 100644
index 4c96dc73..00000000
--- a/tools/probe/corpus/seeds/E16-own-configuration-wins-never.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index 934f884..a0f8ac8 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-@@ -53,7 +53,7 @@ internal sealed class ValueObjectKeyValueGenerationConvention : IModelFinalizing
-     {
-         foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
-             if (GeneratedKey(entityType) is { } property)
--                property.Builder.ValueGenerated(ValueGenerated.OnAdd);
-+                ((IMutableProperty)property).ValueGenerated = ValueGenerated.OnAdd;
-     }
- 
-     /// <summary>The entity type's key, where it is a value object over an integer EF generates a key of.</summary>
diff --git a/tools/probe/corpus/seeds/E16-own-configuration-wins-on-add.patch b/tools/probe/corpus/seeds/E16-own-configuration-wins-on-add.patch
deleted file mode 100644
index a76b9d10..00000000
--- a/tools/probe/corpus/seeds/E16-own-configuration-wins-on-add.patch
+++ /dev/null
@@ -1,18 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index 934f884..6b023d9 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-@@ -52,8 +52,13 @@ internal sealed class ValueObjectKeyValueGenerationConvention : IModelFinalizing
-     public void ProcessModelFinalizing(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
-     {
-         foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
-+        {
-+            if (entityType.FindPrimaryKey() is { Properties: [var key] }
-+             && ValueObjectTypes.Describe(key.ClrType) is { WrappedType: var keyWrapped } && (keyWrapped == typeof(char) || keyWrapped == typeof(Guid)))
-+                ((IMutableProperty)key).ValueGenerated = ValueGenerated.Never;
-             if (GeneratedKey(entityType) is { } property)
-                 property.Builder.ValueGenerated(ValueGenerated.OnAdd);
-+        }
-     }
- 
-     /// <summary>The entity type's key, where it is a value object over an integer EF generates a key of.</summary>
diff --git a/tools/probe/corpus/seeds/E16-own-configuration-wins-optional.patch b/tools/probe/corpus/seeds/E16-own-configuration-wins-optional.patch
deleted file mode 100644
index 013a1a16..00000000
--- a/tools/probe/corpus/seeds/E16-own-configuration-wins-optional.patch
+++ /dev/null
@@ -1,17 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-index 934f884..b72ef00 100644
---- a/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-+++ b/src/CodoMetis.TypeKit.EntityFrameworkCore/ValueObjectKeyValueGenerationConvention.cs
-@@ -52,8 +52,12 @@ internal sealed class ValueObjectKeyValueGenerationConvention : IModelFinalizing
-     public void ProcessModelFinalizing(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
-     {
-         foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
-+        {
-+            foreach (var p in entityType.GetDeclaredProperties())
-+                if (!p.IsKey() && ValueObjectTypes.Describe(Nullable.GetUnderlyingType(p.ClrType) ?? p.ClrType) is not null && p.GetIsNullableConfigurationSource() == ConfigurationSource.Explicit) ((IMutableProperty)p).IsNullable = false;
-             if (GeneratedKey(entityType) is { } property)
-                 property.Builder.ValueGenerated(ValueGenerated.OnAdd);
-+        }
-     }
- 
-     /// <summary>The entity type's key, where it is a value object over an integer EF generates a key of.</summary>
diff --git a/tools/probe/corpus/seeds/L01-json-bytes-read-as-the-underlying-type-reads.patch b/tools/probe/corpus/seeds/L01-json-bytes-read-as-the-underlying-type-reads.patch
deleted file mode 100644
index e1cea816..00000000
--- a/tools/probe/corpus/seeds/L01-json-bytes-read-as-the-underlying-type-reads.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs b/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-index 8597206..906a92b 100644
---- a/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-+++ b/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-@@ -189,6 +189,7 @@ public sealed class GeneratedJsonPlan<T>
-     public T Read<TValueObject>(ref Utf8JsonReader reader, JsonSerializerOptions options)
-     {
-         T? value;
-+        if (reader.TokenType == JsonTokenType.String && reader.ValueIsEscaped) throw GeneratedJson.Unreadable<TValueObject, T>();
- 
-         try
-         {
diff --git a/tools/probe/corpus/seeds/L01-json-bytes-the-underlying-types-json.patch b/tools/probe/corpus/seeds/L01-json-bytes-the-underlying-types-json.patch
deleted file mode 100644
index a4757804..00000000
--- a/tools/probe/corpus/seeds/L01-json-bytes-the-underlying-types-json.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs b/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-index 8597206..957fcc1 100644
---- a/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-+++ b/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-@@ -60,7 +60,7 @@ public sealed class GeneratedJsonPlan<T>
-         // flags change what is written; reading a number from a string is decided per token.
-         _direct       = typeInfo.Kind == JsonTypeInfoKind.None ? typeInfo.Converter as JsonConverter<T> : null;
-         _keyConverter = typeInfo.Converter as JsonConverter<T>;
--        _writesAsIs   = !IsNumber || (handling & (JsonNumberHandling.WriteAsString | JsonNumberHandling.AllowNamedFloatingPointLiterals)) == 0;
-+        _writesAsIs   = true;
-         _readsAsIs    = !IsNumber || handling == JsonNumberHandling.Strict;
- 
-         if (_direct is null && options.ReferenceHandler is { } handler && handler != ReferenceHandler.IgnoreCycles && MayHoldReferences(options, typeInfo, []))
diff --git a/tools/probe/corpus/seeds/L02-no-quote-json-never-repeats.patch b/tools/probe/corpus/seeds/L02-no-quote-json-never-repeats.patch
deleted file mode 100644
index d563e5b0..00000000
--- a/tools/probe/corpus/seeds/L02-no-quote-json-never-repeats.patch
+++ /dev/null
@@ -1,22 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs b/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-index 8597206..c2f989a 100644
---- a/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-+++ b/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-@@ -198,7 +198,7 @@ public sealed class GeneratedJsonPlan<T>
-         }
-         catch (Exception exception) when (GeneratedJson.IsRefusal(exception))
-         {
--            throw GeneratedJson.Unreadable<TValueObject, T>();
-+            throw new JsonException(GeneratedJson.Unreadable<TValueObject, T>().Message + " (" + System.Text.Encoding.UTF8.GetString(reader.ValueSpan) + ")");
-         }
- 
-         return value is null ? throw GeneratedJson.Unreadable<TValueObject, T>() : value;
-@@ -240,7 +240,7 @@ public sealed class GeneratedJsonPlan<T>
-         }
-         catch (Exception exception) when (GeneratedJson.IsRefusal(exception))
-         {
--            throw GeneratedJson.Unreadable<TValueObject, T>();
-+            throw new JsonException(GeneratedJson.Unreadable<TValueObject, T>().Message + " (" + System.Text.Encoding.UTF8.GetString(reader.ValueSpan) + ")");
-         }
- 
-         return value is null ? throw GeneratedJson.Unreadable<TValueObject, T>() : value;
diff --git a/tools/probe/corpus/seeds/L02-no-quote-no-inner-that-quotes.patch b/tools/probe/corpus/seeds/L02-no-quote-no-inner-that-quotes.patch
deleted file mode 100644
index 50acda27..00000000
--- a/tools/probe/corpus/seeds/L02-no-quote-no-inner-that-quotes.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs
-index c734b98..9917c71 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs
-@@ -54,7 +54,7 @@ internal sealed class ParsableImplementationArguments
-     public string InnerParse(string input = "s")
-     {
-         var valueType   = ValueObjectTypes.SourceName(ValueType);
--        var unreadable  = $"throw global::CodoMetis.TypeKit.CompilerServices.GeneratedParsing.Unreadable<{ValueObjectTypes.SourceName(ValueObjectType)}, {valueType}>()";
-+        var unreadable  = $"throw new global::System.FormatException(global::CodoMetis.TypeKit.CompilerServices.GeneratedParsing.Unreadable<{ValueObjectTypes.SourceName(ValueObjectType)}, {valueType}>().Message, new global::System.FormatException(\"The input '\" + {input}.ToString() + \"' was not in a correct format.\"))";
-         const string at = "global::CodoMetis.TypeKit.CompilerServices.GeneratedParsing";
- 
-         return Strategy switch
diff --git a/tools/probe/corpus/seeds/L02-no-quote-parsing-never-repeats.patch b/tools/probe/corpus/seeds/L02-no-quote-parsing-never-repeats.patch
deleted file mode 100644
index 05a5b248..00000000
--- a/tools/probe/corpus/seeds/L02-no-quote-parsing-never-repeats.patch
+++ /dev/null
@@ -1,32 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/CompilerServices/GeneratedParsing.cs b/src/CodoMetis.TypeKit/CompilerServices/GeneratedParsing.cs
-index ef70519..2827564 100644
---- a/src/CodoMetis.TypeKit/CompilerServices/GeneratedParsing.cs
-+++ b/src/CodoMetis.TypeKit/CompilerServices/GeneratedParsing.cs
-@@ -44,8 +44,11 @@ public static class GeneratedParsing
-     /// <typeparam name="T">The type to parse.</typeparam>
-     /// <returns>Whether parsing succeeded.</returns>
-     public static bool TryParse<T>([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out T result)
--        where T : IParsable<T> =>
--        T.TryParse(s, provider, out result);
-+        where T : IParsable<T>
-+    {
-+        result = T.Parse(s!, provider);
-+        return true;
-+    }
- 
-     /// <summary><see cref="ISpanParsable{TSelf}.TryParse"/> of <typeparamref name="T"/>.</summary>
-     /// <param name="s">The characters.</param>
-@@ -54,8 +57,11 @@ public static class GeneratedParsing
-     /// <typeparam name="T">The type to parse.</typeparam>
-     /// <returns>Whether parsing succeeded.</returns>
-     public static bool TryParseSpan<T>(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out T result)
--        where T : ISpanParsable<T> =>
--        T.TryParse(s, provider, out result);
-+        where T : ISpanParsable<T>
-+    {
-+        result = T.Parse(s, provider);
-+        return true;
-+    }
- 
-     /// <summary><see cref="IUtf8SpanParsable{TSelf}.TryParse"/> of <typeparamref name="T"/>.</summary>
-     /// <param name="utf8Text">The UTF-8 text.</param>
diff --git a/tools/probe/corpus/seeds/L03-one-rule-json-runs-create.patch b/tools/probe/corpus/seeds/L03-one-rule-json-runs-create.patch
deleted file mode 100644
index 0cff4bfe..00000000
--- a/tools/probe/corpus/seeds/L03-one-rule-json-runs-create.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.Templates.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.Templates.cs
-index 185f65e..8d0c981 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.Templates.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.Templates.cs
-@@ -40,7 +40,7 @@ internal sealed partial class ValueObjectAspect
-         if (meta.CompileTime(kind == ValueObjectKind.Plain))
-             return constructor.Invoke(value)!;
- 
--        if (materialize)
-+        if (!materialize)
-             return constructor.Invoke(value)!;
- 
-         return ExpressionFactory.Parse(
diff --git a/tools/probe/corpus/seeds/L03-one-rule-parsing-runs-create.patch b/tools/probe/corpus/seeds/L03-one-rule-parsing-runs-create.patch
deleted file mode 100644
index b49d34d0..00000000
--- a/tools/probe/corpus/seeds/L03-one-rule-parsing-runs-create.patch
+++ /dev/null
@@ -1,15 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.Templates.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.Templates.cs
-index 185f65e..dcebbca 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.Templates.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.Templates.cs
-@@ -60,9 +60,7 @@ internal sealed partial class ValueObjectAspect
-         if (meta.CompileTime(kind == ValueObjectKind.Plain))
-             return constructor.Invoke(value)!;
- 
--        return ExpressionFactory.Parse(
--            $"global::CodoMetis.TypeKit.CompilerServices.GeneratedFactories.OrFormatException({ValueObjectTypes.SourceName(target)}.Create(value))"
--        ).Value!;
-+        return constructor.Invoke(value)!;
-     }
- 
-     /// <summary><c>TryParse</c>'s way in. A refusal returns <see langword="false"/>, as <c>TryParse</c> does.</summary>
diff --git a/tools/probe/corpus/seeds/L03-one-rule-refusals-name-the-fault.patch b/tools/probe/corpus/seeds/L03-one-rule-refusals-name-the-fault.patch
deleted file mode 100644
index 78488c80..00000000
--- a/tools/probe/corpus/seeds/L03-one-rule-refusals-name-the-fault.patch
+++ /dev/null
@@ -1,33 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/CompilerServices/GeneratedFactories.cs b/src/CodoMetis.TypeKit/CompilerServices/GeneratedFactories.cs
-index 5550a22..1b87150 100644
---- a/src/CodoMetis.TypeKit/CompilerServices/GeneratedFactories.cs
-+++ b/src/CodoMetis.TypeKit/CompilerServices/GeneratedFactories.cs
-@@ -35,7 +35,7 @@ public static class GeneratedFactories
-     {
-         if (result.TryGetValue(out var value, out var fault)) return value;
- 
--        throw new JsonException($"{typeof(TValueObject).Name} refused the JSON value ({fault}).{Refusals.RefusedValue}");
-+        throw new JsonException($"{typeof(TValueObject).Name} refused the JSON value ({fault.GetType().Name}).{Refusals.RefusedValue}");
-     }
- 
-     /// <summary>Unwraps what <c>Create</c> accepted from text, or throws the exception parsing reports.</summary>
-@@ -50,7 +50,7 @@ public static class GeneratedFactories
-     {
-         if (result.TryGetValue(out var value, out var fault)) return value;
- 
--        throw new FormatException($"{typeof(TValueObject).Name} refused the input ({fault}).{Refusals.RefusedValue}");
-+        throw new FormatException($"{typeof(TValueObject).Name} refused the input ({fault.GetType().Name}).{Refusals.RefusedValue}");
-     }
- 
-     /// <summary>
-@@ -75,8 +75,8 @@ public static class GeneratedFactories
- 
-         throw new InvalidOperationException(
-             source is null
--                ? $"{typeof(TValueObject).Name} refused a value the call site declared known-good ({fault}).{Refusals.RefusedKnownGood}"
--                : $"{typeof(TValueObject).Name} refused {source}, which the call site declared known-good ({fault}).{Refusals.RefusedKnownGood}"
-+                ? $"{typeof(TValueObject).Name} refused a value the call site declared known-good ({fault.GetType().Name}).{Refusals.RefusedKnownGood}"
-+                : $"{typeof(TValueObject).Name} refused {source}, which the call site declared known-good ({fault.GetType().Name}).{Refusals.RefusedKnownGood}"
-         );
-     }
- 
diff --git a/tools/probe/corpus/seeds/L03-one-rule-tryfrom-runs-create.patch b/tools/probe/corpus/seeds/L03-one-rule-tryfrom-runs-create.patch
deleted file mode 100644
index 527dc617..00000000
--- a/tools/probe/corpus/seeds/L03-one-rule-tryfrom-runs-create.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs
-index 07a7ecb..fb43ddf 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs
-@@ -32,7 +32,7 @@ internal sealed partial class ValueObjectContractAspect
-     /// </summary>
-     [Template]
-     public static dynamic TryFromTemplate(dynamic? value, [CompileTime] INamedType target) =>
--        ExpressionFactory.Parse($"global::CodoMetis.TypeKit.Result.ToOption({ValueObjectTypes.SourceName(target)}.Create(value))").Value!;
-+        ExpressionFactory.Parse($"global::CodoMetis.TypeKit.Option.Some({ValueObjectTypes.SourceName(target)}.__FromJson(value, true))").Value!;
- 
-     /// <summary><c>Create</c> of the value this instance holds.</summary>
-     [Template]
diff --git a/tools/probe/corpus/seeds/L04-round-trip-invariant-whatever-the-culture.patch b/tools/probe/corpus/seeds/L04-round-trip-invariant-whatever-the-culture.patch
deleted file mode 100644
index 981bdc78..00000000
--- a/tools/probe/corpus/seeds/L04-round-trip-invariant-whatever-the-culture.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/CompilerServices/GeneratedFormatting.cs b/src/CodoMetis.TypeKit/CompilerServices/GeneratedFormatting.cs
-index 8f93241..fe989ca 100644
---- a/src/CodoMetis.TypeKit/CompilerServices/GeneratedFormatting.cs
-+++ b/src/CodoMetis.TypeKit/CompilerServices/GeneratedFormatting.cs
-@@ -27,7 +27,7 @@ public static class GeneratedFormatting
-     /// <typeparam name="T">The type to format.</typeparam>
-     /// <returns>The formatted text.</returns>
-     public static string ToString<T>(T value, string? format, IFormatProvider? provider) where T : IFormattable =>
--        value.ToString(format, provider);
-+        value.ToString(format, System.Globalization.CultureInfo.CurrentCulture);
- 
-     /// <summary><see cref="ISpanFormattable.TryFormat"/> of <typeparamref name="T"/>.</summary>
-     /// <param name="value">The value.</param>
diff --git a/tools/probe/corpus/seeds/L04-round-trip-json-refusal-is-a-json-exception.patch b/tools/probe/corpus/seeds/L04-round-trip-json-refusal-is-a-json-exception.patch
deleted file mode 100644
index ead87060..00000000
--- a/tools/probe/corpus/seeds/L04-round-trip-json-refusal-is-a-json-exception.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs b/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-index 8597206..7515d92 100644
---- a/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-+++ b/src/CodoMetis.TypeKit/CompilerServices/GeneratedJsonPlan.cs
-@@ -198,7 +198,7 @@ public sealed class GeneratedJsonPlan<T>
-         }
-         catch (Exception exception) when (GeneratedJson.IsRefusal(exception))
-         {
--            throw GeneratedJson.Unreadable<TValueObject, T>();
-+            throw;
-         }
- 
-         return value is null ? throw GeneratedJson.Unreadable<TValueObject, T>() : value;
diff --git a/tools/probe/corpus/seeds/L04-round-trip-text-reads-back.patch b/tools/probe/corpus/seeds/L04-round-trip-text-reads-back.patch
deleted file mode 100644
index d3c462d2..00000000
--- a/tools/probe/corpus/seeds/L04-round-trip-text-reads-back.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectTypeConverterAspect.Templates.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectTypeConverterAspect.Templates.cs
-index 232ed9d..0ae0961 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectTypeConverterAspect.Templates.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectTypeConverterAspect.Templates.cs
-@@ -33,7 +33,7 @@ internal sealed partial class ValueObjectTypeConverterAspect
-             // ReSharper disable once ConvertIfStatementToNullCoalescingExpression
-             if (culture == null)
-             {
--                provider = CultureInfo.InvariantCulture;
-+                provider = CultureInfo.CurrentCulture;
-             }
-             else
-             {
diff --git a/tools/probe/corpus/seeds/L04-round-trip-the-type-converter-writes-the-same.patch b/tools/probe/corpus/seeds/L04-round-trip-the-type-converter-writes-the-same.patch
deleted file mode 100644
index 430ac0d5..00000000
--- a/tools/probe/corpus/seeds/L04-round-trip-the-type-converter-writes-the-same.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectTypeConverterAspect.Templates.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectTypeConverterAspect.Templates.cs
-index 232ed9d..091a954 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectTypeConverterAspect.Templates.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectTypeConverterAspect.Templates.cs
-@@ -70,7 +70,7 @@ internal sealed partial class ValueObjectTypeConverterAspect
-             // ReSharper disable once ConvertIfStatementToNullCoalescingExpression
-             if (culture == null)
-             {
--                provider = CultureInfo.InvariantCulture;
-+                provider = CultureInfo.CurrentCulture;
-             }
-             else
-             {
diff --git a/tools/probe/corpus/seeds/L05-equality-equality-is-the-underlying-values.patch b/tools/probe/corpus/seeds/L05-equality-equality-is-the-underlying-values.patch
deleted file mode 100644
index 59cc1aee..00000000
--- a/tools/probe/corpus/seeds/L05-equality-equality-is-the-underlying-values.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs
-index 07a7ecb..c9468d4 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.Templates.cs
-@@ -58,7 +58,7 @@ internal sealed partial class ValueObjectContractAspect
-     [Template]
-     public int GetHashCodeTemplate([CompileTime] INamedType valueType) =>
-         (int)ExpressionFactory.Parse(
--            $"global::System.Collections.Generic.EqualityComparer<{ValueObjectTypes.SourceName(valueType)}>.Default.GetHashCode(this._value!)"
-+            $"global::System.StringComparer.Ordinal.GetHashCode(global::System.Convert.ToString((object?)this._value, global::System.Globalization.CultureInfo.InvariantCulture) ?? string.Empty)"
-         ).Value!;
- 
-     /// <summary><c>Create</c> with the fault carried into the throw.</summary>
diff --git a/tools/probe/corpus/seeds/L05-equality-ordering-follows-the-underlying-type.patch b/tools/probe/corpus/seeds/L05-equality-ordering-follows-the-underlying-type.patch
deleted file mode 100644
index 3abfa58b..00000000
--- a/tools/probe/corpus/seeds/L05-equality-ordering-follows-the-underlying-type.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectComparableAspect.Templates.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectComparableAspect.Templates.cs
-index 3936706..4d21804 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectComparableAspect.Templates.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectComparableAspect.Templates.cs
-@@ -41,7 +41,7 @@ internal sealed partial class ValueObjectComparableAspect
-         // The wrapped type is never an open generic (ValueObjectAspect refuses those).
-         string typeName = meta.CompileTime(ValueObjectTypes.SourceName(tag.ValueType));
-         return (int)ExpressionFactory.Parse(
--            $"global::System.Collections.Generic.Comparer<{typeName}>.Default.Compare(this.Value, other.Value)",
-+            $"global::System.Collections.Generic.Comparer<{typeName}>.Default.Compare(other.Value, this.Value)",
-             TypeFactory.GetType(SpecialType.Int32),
-             false
-         ).Value!;
diff --git a/tools/probe/corpus/seeds/L05-equality-through-every-base.patch b/tools/probe/corpus/seeds/L05-equality-through-every-base.patch
deleted file mode 100644
index 9239ea5d..00000000
--- a/tools/probe/corpus/seeds/L05-equality-through-every-base.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.cs
-index c5f440a..1bddab3 100644
---- a/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.cs
-+++ b/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.cs
-@@ -98,7 +98,7 @@ internal sealed partial class ValueObjectContractAspect : TypeAspect
-         {
-             builder.ImplementInterface(TypeFactory.GetNamedType(typeof(IReimplementedEquatable<>)).MakeGenericInstance(type), OverrideStrategy.Ignore);
- 
--            if (type.Equals(direct) || !ExplicitlyImplementsEquatableBetween(direct, type, equatable.MakeGenericInstance(type))) continue;
-+            if (type.Equals(direct) || ExplicitlyImplementsEquatableBetween(direct, type, equatable.MakeGenericInstance(type))) continue;
- 
-             // One the value object declares itself implements the interface already, as C# maps it.
-             if (builder.Target.Methods.Any(method => method is { Name: nameof(Equals), Parameters: [{ } other] } && other.Type.ToNonNullable().Equals(type))) continue;
diff --git a/tools/probe/corpus/seeds/L06-off-the-wire-never-read.patch b/tools/probe/corpus/seeds/L06-off-the-wire-never-read.patch
deleted file mode 100644
index 768bb5d8..00000000
--- a/tools/probe/corpus/seeds/L06-off-the-wire-never-read.patch
+++ /dev/null
@@ -1,21 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/NotWireTypeJsonConverterFactory.cs b/src/CodoMetis.TypeKit/NotWireTypeJsonConverterFactory.cs
-index ebe7eb6..7cbbe4e 100644
---- a/src/CodoMetis.TypeKit/NotWireTypeJsonConverterFactory.cs
-+++ b/src/CodoMetis.TypeKit/NotWireTypeJsonConverterFactory.cs
-@@ -107,14 +107,14 @@ public sealed class NotWireTypeJsonConverterFactory : JsonConverterFactory
-         public override bool CanConvert(Type typeToConvert) => IsRefused(typeToConvert);
- 
-         public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
--            throw new NotSupportedException(Message(typeToConvert));
-+            throw new JsonException(Message(typeToConvert));
- 
-         public override void Write(Utf8JsonWriter writer, object? value, JsonSerializerOptions options) =>
-             throw new NotSupportedException(Message(refused));
- 
-         /// <summary>A dictionary key too, rather than the serializer's message about <see cref="object"/> keys.</summary>
-         public override object ReadAsPropertyName(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
--            throw new NotSupportedException(Message(typeToConvert));
-+            throw new JsonException(Message(typeToConvert));
- 
-         public override void WriteAsPropertyName(Utf8JsonWriter writer, object value, JsonSerializerOptions options) =>
-             throw new NotSupportedException(Message(refused));
diff --git a/tools/probe/corpus/seeds/L06-off-the-wire-never-written.patch b/tools/probe/corpus/seeds/L06-off-the-wire-never-written.patch
deleted file mode 100644
index ca42b8b7..00000000
--- a/tools/probe/corpus/seeds/L06-off-the-wire-never-written.patch
+++ /dev/null
@@ -1,18 +0,0 @@
-diff --git a/src/CodoMetis.TypeKit/NotWireTypeJsonConverterFactory.cs b/src/CodoMetis.TypeKit/NotWireTypeJsonConverterFactory.cs
-index ebe7eb6..a915ada 100644
---- a/src/CodoMetis.TypeKit/NotWireTypeJsonConverterFactory.cs
-+++ b/src/CodoMetis.TypeKit/NotWireTypeJsonConverterFactory.cs
-@@ -109,8 +109,11 @@ public sealed class NotWireTypeJsonConverterFactory : JsonConverterFactory
-         public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
-             throw new NotSupportedException(Message(typeToConvert));
- 
--        public override void Write(Utf8JsonWriter writer, object? value, JsonSerializerOptions options) =>
--            throw new NotSupportedException(Message(refused));
-+        public override void Write(Utf8JsonWriter writer, object? value, JsonSerializerOptions options)
-+        {
-+            writer.WriteStartObject();
-+            writer.WriteEndObject();
-+        }
- 
-         /// <summary>A dictionary key too, rather than the serializer's message about <see cref="object"/> keys.</summary>
-         public override object ReadAsPropertyName(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
diff --git a/tools/probe/enumerate.cs b/tools/probe/enumerate.cs
deleted file mode 100644
index f7ccd617..00000000
--- a/tools/probe/enumerate.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-// The generated axes of .claude/probe-axes.md: every public settable property of each options type a
-// TypeKit feature reads, by reflection, never from memory. It runs outside the repository, so neither
-// global.json nor central package management applies to it:
-//
-//   `prober replay` (tools/Prober) runs it (copied outside the repository, its #:package versions taken from
-//   Directory.Packages.props) whenever a dependency input changes, into the prober's axes-generated.json.
-//
-// Each property is an axis "<prefix>.<Name>" whose values are "default" and every other value a bool
-// or an enum allows (each flag of a [Flags] enum on its own). A property of any other type is listed
-// under "needsValues"; probe-axes.md's "hand" map gives its values.
-#:sdk Microsoft.NET.Sdk.Web
-#:property TargetFramework=net10.0
-#:property PublishAot=false
-#:package Microsoft.AspNetCore.OpenApi@10.0.12
-using System.Reflection;
-using System.Text.Json;
-
-var sources = new (string Prefix, object Instance)[]
-{
-    ("json", new JsonSerializerOptions()),
-    ("openapi", new Microsoft.AspNetCore.OpenApi.OpenApiOptions()),
-    ("mvc", new Microsoft.AspNetCore.Mvc.MvcOptions()),
-};
-
-var axes = new SortedDictionary<string, List<string>>();
-var needsValues = new List<string>();
-var versions = new SortedDictionary<string, string>();
-foreach (var (prefix, instance) in sources)
-{
-    var type = instance.GetType();
-    versions[type.FullName!] = type.Assembly.GetName().Version!.ToString();
-    foreach (var p in type.GetProperties(BindingFlags.Public | BindingFlags.Instance).OrderBy(p => p.Name))
-    {
-        if (p.SetMethod is not { IsPublic: true } && !IsCollection(p.PropertyType)) continue;
-        if (p.GetCustomAttribute<ObsoleteAttribute>() is not null) continue;
-        var name = $"{prefix}.{p.Name}";
-        var t = Nullable.GetUnderlyingType(p.PropertyType) ?? p.PropertyType;
-        var current = p.GetIndexParameters().Length == 0 ? p.GetValue(instance) : null;
-        if (t == typeof(bool))
-            axes[name] = ["default", (!(bool)(current ?? false)).ToString().ToLowerInvariant()];
-        else if (t.IsEnum)
-        {
-            var flags = t.IsDefined(typeof(FlagsAttribute));
-            var values = Enum.GetValues(t).Cast<object>()
-                .Where(v => !Equals(v, current) && (!flags || IsSingleFlag(Convert.ToInt64(v))))
-                .Select(v => v.ToString()!);
-            axes[name] = ["default", .. values];
-        }
-        else needsValues.Add(name);
-    }
-}
-
-Console.WriteLine(JsonSerializer.Serialize(new { versions, axes, needsValues }, new JsonSerializerOptions { WriteIndented = true }));
-
-static bool IsSingleFlag(long v) => v != 0 && (v & (v - 1)) == 0;
-static bool IsCollection(Type t) => t.IsGenericType && t.GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(ICollection<>));
diff --git a/tools/probe/generators/Directory.Build.props b/tools/probe/generators/Directory.Build.props
deleted file mode 100644
index 26b81c53..00000000
--- a/tools/probe/generators/Directory.Build.props
+++ /dev/null
@@ -1,8 +0,0 @@
-<Project>
-    <!--
-      The harness generators are file-based apps (design/adr/0092, form 1), not tool projects: they take the
-      repository's settings (warnings are errors, nullable, C# 14) and none of tools/Directory.Build.*, which
-      compile tools/Shared into a tool and stamp its sources for a project file a file-based app does not have.
-    -->
-    <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove('$(MSBuildThisFileDirectory)', 'CodoMetis.TypeKit.slnx'))/Directory.Build.props" />
-</Project>
diff --git a/tools/probe/generators/Directory.Build.targets b/tools/probe/generators/Directory.Build.targets
deleted file mode 100644
index d4ec8c75..00000000
--- a/tools/probe/generators/Directory.Build.targets
+++ /dev/null
@@ -1,3 +0,0 @@
-<Project>
-    <!-- Here so that tools/Directory.Build.targets, the tool projects' source stamp, is not imported (see Directory.Build.props). -->
-</Project>
diff --git a/tools/probe/generators/README.md b/tools/probe/generators/README.md
deleted file mode 100644
index be768ee4..00000000
--- a/tools/probe/generators/README.md
+++ /dev/null
@@ -1,85 +0,0 @@
-# Harness generators
-
-The apps here write the generated declarations of the probe harness, every
-`tools/probe/corpus/harness/*.g.cs`. Each file's first line names the app that wrote it. Never edit one by
-hand: change the app, or its input, and run it again.
-
-| App | Mode | Writes | From |
-|---|---|---|---|
-| `shapes.cs` | | `Shapes.g.cs`: a value object per `shape.kind` x `shape.wrapped`, its plain twin, the registry, the polymorphic stand-ins, `ProbeContext` | the axes file's `shape.kind`, `shape.wrapped`, `shape.position` and `shape.containing`; L06's rows for its carriers |
-| `containers.cs` | | `Containers.g.cs`: a generic container per `shape.containing` and member style | the axes file's `shape.containing` |
-| `ef.cs` | `catalogue` | `EfShapes.g.cs`: a value object per (kind, wrapped, site), `EfRegistry` | E01's first 90 rows, E02's first 108 |
-| `ef.cs` | `top-level` | `EfShapes3.g.cs`: every kind at top level for each wrapped type of the catalogue, `Reg3` | the same rows |
-| `ef.cs` | `nested` | `EfShapes4.g.cs`: every kind at each nested site for each wrapped type of the catalogue, `Reg4` | the same rows |
-| `ef.cs` | `keys` | `KeyShapes.g.cs`: a value object per (kind, wrapped), `KeyRegistry` | E04's rows |
-| `json-family.cs` | `stand-ins` | `JsonFamilyShapes.g.cs`: L06's polymorphic stand-ins over `Option` and `Result` | the table in the app |
-| `json-family.cs` | `l05` | `L05Shapes.g.cs`: a value object or closed set per (kind, wrapped, inheritance, site), `L05Registry` | L05's rows |
-| `decls.cs` | `C09` | `C09Shapes.g.cs`: each row's base records and value object, `C09Table` | C09's rows |
-| `decls.cs` | `C11` | `C11Shapes.g.cs`: each row's value object and its control, `C11Table` | C11's rows |
-| `faults.cs` | | `FaultClaimControllers.g.cs`: the controllers of C04, C06, C14 and C15, `FxCtl` | the table in the app |
-| `rules.cs` | | `RuleControllers.g.cs`: the controllers of C03 and C05, one action per arity and response variant | the table in the app |
-
-The axes file is `.claude/probe-axes.md`, read from its `json probe-axes` block. A rows file is
-`tools/probe/corpus/rows/<probe>.json.gz`, gzipped JSON, one per probe with its claim inside, which `prober rows --probe P`
-writes. A value the app's
-tables do not know (a new `shape.wrapped`, say) is refused with exit 2 and the value named, never skipped.
-
-## Running one
-
-From the repository root, each app takes its inputs and `--out` by name:
-
-```bash
-dotnet run tools/probe/generators/shapes.cs -- --axes .claude/probe-axes.md --l06 tools/probe/corpus/rows/L06OffTheWireProbe.json.gz --out tools/probe/corpus/harness/Shapes.g.cs
-```
-
-```bash
-dotnet run tools/probe/generators/decls.cs -- C09 --rows tools/probe/corpus/rows/C09BaseRecordEqualityProbe.json.gz --out tools/probe/corpus/harness/C09Shapes.g.cs
-```
-
-The arguments of every file are in the table `Generators` of
-`test/CodoMetis.TypeKit.Conventions.Tests/GeneratedHarnessTests.cs`, the one place the mapping lives, and
-the head of each app shows how to run it. Run the app again after `prober rows` rewrites a rows file it reads,
-after a change to the axes file's `shape.*` axes, and after a change to the app, and commit the output with
-the change.
-
-## The twin and the context
-
-`shapes.cs` writes each value object's twin beside it: the wrapped type at the value object's nullability, so a class value object
-over a struct faces the struct made nullable (`int?` for a sealed record class over `int`) and the rest face the wrapped type itself.
-The closed set's twin is a string, its member's name. The registry's `Plain` is the twin, and the harness builds both sides of a
-comparison in one place (`Sides.Twins`), which refuses, as a harness error, a twin and a value object that do not hold the same shape.
-
-`ProbeContext` is the one source-generated context: every value object and every twin, at the root and at every `shape.position` in every
-`shape.containing`, and the `Option` and `Result` carriers L06's rows hold under the context. Under
-`json.TypeInfoResolver=source-generated-context` a row resolves through it alone, with no reflection behind it, and a shape it does not
-list is a harness error; `json.TypeInfoResolverChain=context-then-default` is the configuration with the reflection fallback. It is one
-declaration because System.Text.Json's generator fails on a second partial part that carries `[JsonSerializable]`. The carriers come from
-L06's rows, so run `shapes.cs` again after `prober rows --probe L06OffTheWireProbe`: an `Option` and two `Result`s over every value object
-at every position would be some 16000 more types. Measured 2026-10-17 on Linux x64, a rebuild of the Samples after a harness change took
-38 s before the context listed the positions, 73 s with it (8974 types: every shape and twin, the struct value objects made
-nullable, L06's carriers), and 3 min 49 s in a trial that listed every carrier at every position too (23266 types).
-
-`ef.cs` reads `--rows <path>` once per file; `--first <n>` after one reads only its first n rows. The
-catalogue is E01's and E02's first round of rows: the rows appended since (old rows kept) run on the
-complete grids of `top-level` and `nested`, which read the same rows to learn the catalogue's wrapped types,
-in its order, and which of them it validates.
-
-## The guard
-
-`GeneratedHarnessTests` in the conventions tests runs every app into a temporary directory with the
-arguments of its table and fails on any difference from the committed file, line endings aside. It also
-fails on a `.g.cs` in the harness that the table does not list. The test takes about 13 seconds, warm or cold
-(measured 2026-10-16 on macOS arm64: each `dotnet run` costs about a second, a first build little more).
-
-The apps are file-based apps, the first form of
-[decision 92](../../../design/adr/0092-repository-tooling-is-dotnet-and-ci-needs-no-ai.md): one file each, BCL
-only, no tests of their own. The conventions test is their guard, and it compares outputs, so it sees what a
-change does to the harness rather than how the app does it. An app that writes one declaration per distinct
-shape (`ef.cs`, `json-family.cs`'s `l05`, `shapes.cs`'s carriers) writes the same file without a row whose shape another row repeats;
-`decls.cs` writes one per row.
-
-They run inside the repository, so `global.json` and the root `Directory.Build.props` apply (warnings are
-errors). This directory's `Directory.Build.props` and `Directory.Build.targets` keep `tools/Directory.Build.*`
-out: those compile `tools/Shared` into a tool project and stamp its sources for a project file a file-based
-app does not have. Never start two copies of one app at once on a cold build cache: the first runs race on it
-(decision 92's evidence), which is why the test runs the files one after another.
diff --git a/tools/probe/generators/containers.cs b/tools/probe/generators/containers.cs
deleted file mode 100644
index 71f744f1..00000000
--- a/tools/probe/generators/containers.cs
+++ /dev/null
@@ -1,78 +0,0 @@
-// Writes tools/probe/corpus/harness/Containers.g.cs: for each shape.containing of the axes file, one generic
-// container per member style (P property, F field, C constructor parameter, R required init). The position
-// (list, dictionary, ...) is the member's declared type, which the probe chooses.
-//
-//   dotnet run tools/probe/generators/containers.cs -- --axes .claude/probe-axes.md --out tools/probe/corpus/harness/Containers.g.cs
-//
-// GeneratedHarnessTests in the conventions tests holds the committed file to this output.
-using System.Text;
-using System.Text.Json.Nodes;
-
-try
-{
-    var containing = Values(AxesBlock(Arg(args, "--axes")), "shape.containing");
-    File.WriteAllText(Arg(args, "--out"), Generate(containing), new UTF8Encoding(false));
-    return 0;
-}
-catch (GeneratorError e)
-{
-    Console.Error.WriteLine($"containers.cs: {e.Message}");
-    return 2;
-}
-
-static string Generate(IReadOnlyList<string> containing)
-{
-    var o = new List<string>
-    {
-        "// <auto-generated/> by tools/probe/generators/containers.cs",
-        "#nullable disable\n#pragma warning disable CS8618, CS1591, CS0649",
-        "using System.Text.Json.Serialization;",
-        "namespace Probes.Shapes;",
-    };
-    foreach (var c in containing)
-    {
-        var n = c.Replace('-', '_');
-        // the declaration keyword and the type parameters; a record class takes its constructor parameter positionally
-        var (keyword, parameters) = c switch
-        {
-            "class" => ("class", "<M>"),
-            "record-class" => ("record class", "<M>"),
-            "struct" => ("struct", "<M>"),
-            "record-struct" => ("record struct", "<M>"),
-            "generic-type" => ("class", "<M, U>"),
-            _ => throw new GeneratorError($"shape.containing {c} has no container here"),
-        };
-        var name = $"Cn_{n}_";
-        o.Add($"public {keyword} {name}P{parameters} {{ public M P {{ get; set; }} }}");
-        o.Add($"public {keyword} {name}F{parameters} {{ public M F; }}");
-        o.Add(c == "record-class"
-            ? $"public {keyword} {name}C{parameters}(M P);"
-            : $"public {keyword} {name}C{parameters} {{ public M P {{ get; }} [JsonConstructor] public {name}C(M p) {{ P = p; }} }}");
-        o.Add($"public {keyword} {name}R{parameters} {{ public required M P {{ get; init; }} }}");
-    }
-    return string.Join("\n", o) + "\n";
-}
-
-static string Arg(string[] args, string name)
-{
-    var at = Array.IndexOf(args, name);
-    return at >= 0 && at + 1 < args.Length ? args[at + 1] : throw new GeneratorError($"{name} <path> is required");
-}
-
-static JsonObject AxesBlock(string path)
-{
-    const string marker = "```json probe-axes";
-    var text = File.ReadAllText(path);
-    var at = text.IndexOf(marker, StringComparison.Ordinal);
-    if (at < 0) throw new GeneratorError($"{path} has no {marker} block");
-    var body = text[(at + marker.Length)..];
-    return JsonNode.Parse(body[..body.IndexOf("```", StringComparison.Ordinal)]) as JsonObject
-           ?? throw new GeneratorError($"the {marker} block of {path} is not a JSON object");
-}
-
-static List<string> Values(JsonObject block, string axis) =>
-    block["axes"]?[axis] is JsonArray values
-        ? [.. values.Select(v => v?.GetValue<string>() ?? throw new GeneratorError($"{axis} holds a null"))]
-        : throw new GeneratorError($"the axes file has no axis {axis}");
-
-sealed class GeneratorError(string message) : Exception(message);
diff --git a/tools/probe/generators/decls.cs b/tools/probe/generators/decls.cs
deleted file mode 100644
index e219a391..00000000
--- a/tools/probe/generators/decls.cs
+++ /dev/null
@@ -1,261 +0,0 @@
-// Writes the declarations the C09 and C11 probes build, one value object per row of the probe's rows file:
-//
-//   C09  C09Shapes.g.cs  each row's base records (their own equality under base-equality) and the value object over them
-//   C11  C11Shapes.g.cs  each row's value object over its parse-shape's wrapped type, with a control that parses where one exists
-//
-//   dotnet run tools/probe/generators/decls.cs -- C09 --rows tools/probe/corpus/rows/C09BaseRecordEqualityProbe.json.gz \
-//       --out tools/probe/corpus/harness/C09Shapes.g.cs
-//   dotnet run tools/probe/generators/decls.cs -- C11 --rows tools/probe/corpus/rows/C11ParseShapesBuildProbe.json.gz \
-//       --out tools/probe/corpus/harness/C11Shapes.g.cs
-//
-// A row's excluded values are replaced by the nearest that exists; the table names the effective settings and the row's
-// own key, which the probe checks against the rows file it runs (a stale file is a harness error). A rows file is gzipped
-// JSON, written by `prober rows`. GeneratedHarnessTests in the conventions tests holds each file to this output.
-using System.IO.Compression;
-using System.Text;
-using System.Text.Json.Nodes;
-
-try
-{
-    var mode = args.Length > 0 ? args[0] : throw new GeneratorError("a mode is required: C09 or C11");
-    var path = Arg(args, "--rows");
-    var (claim, rows) = Rows(path);
-    if (!claim.StartsWith(mode + "-", StringComparison.Ordinal)) throw new GeneratorError($"mode {mode} reads {mode}'s rows, not {claim}'s");
-    var text = mode switch
-    {
-        "C09" => C09(Path.GetFileName(path), rows),
-        "C11" => C11(Path.GetFileName(path), rows),
-        _ => throw new GeneratorError($"unknown mode {mode}"),
-    };
-    File.WriteAllText(Arg(args, "--out"), text, new UTF8Encoding(false));
-    return 0;
-}
-catch (GeneratorError e)
-{
-    Console.Error.WriteLine($"decls.cs: {e.Message}");
-    return 2;
-}
-
-static string Head(string file, string ns) =>
-    $"// <auto-generated/> by tools/probe/generators/decls.cs from rows/{file}: one value object per row. Do not edit; regenerate with the rows.\n" +
-    "#nullable enable\n" +
-    "// CMTK1023: the bases' own equality is the point (C09) or beside it (C11); CS8851: a base's Equals without GetHashCode, on purpose.\n" +
-    "#pragma warning disable CMTK1023, CS8851, CS1591\n" +
-    "using CodoMetis.TypeKit;\n" +
-    "using CodoMetis.TypeKit.ValueObjects;\n" +
-    $"namespace Probes.Build.{ns};\n";
-
-// The row's own key: every axis=value, sorted by axis.
-static string Key(Dictionary<string, string> row) => string.Join(";", row.Keys.Order(StringComparer.Ordinal).Select(k => $"{k}={row[k]}"));
-
-// The declarations at the row's site, and the qualifier that reaches them from the namespace.
-static (string Text, string Qualifier) AtSite(string site, int idx, string inner) => site switch
-{
-    "top-level" => (inner, ""),
-    "nested-in-class" => ($"public static partial class O{idx}\n{{\n{inner}}}\n", $"O{idx}."),
-    "nested-in-struct" => ($"public partial struct O{idx}\n{{\n{inner}}}\n", $"O{idx}."),
-    "nested-two-levels" => ($"public static partial class O{idx}\n{{\npublic sealed partial class P{idx}\n{{\n{inner}}}\n}}\n", $"O{idx}.P{idx}."),
-    _ => throw new GeneratorError($"shape.site {site} has no site here"),
-};
-
-// How many base records an inheritance puts under the value object.
-static int Depth(string inheritance) => inheritance switch
-{
-    "base-depth-2" => 2,
-    "base-depth-3" => 3,
-    "base-depth-1" or "base-explicit-IEquatable" or "explicit-interface-member" => 1,
-    _ => 0,
-};
-
-static string Record(string name, List<string> parents, List<string> members) =>
-    $"public abstract record {name}" + (parents.Count > 0 ? " : " + string.Join(", ", parents) : "") + " { " + string.Join(" ", members) + " }";
-
-static string Substitutions(List<(string Axis, string Value)> subs) => string.Join(", ", subs.Select(s => $"(\"{s.Axis}\", \"{s.Value}\")"));
-
-static string Table(string name, string caseType, List<string> table) =>
-    $"public static partial class {name}\n{{\n    public static readonly {caseType}[] Cases =\n    [\n" + string.Join("\n", table) + "\n    ];\n}\n";
-
-static string C09(string file, List<Dictionary<string, string>> rows)
-{
-    var o = new List<string> { Head(file, "C09") };
-    var table = new List<string>();
-    for (var idx = 0; idx < rows.Count; idx++)
-    {
-        var row = rows[idx];
-        var subs = new List<(string, string)>();
-        var kind = row["shape.kind"];
-        if (kind is "record-struct" or "closed-set") { subs.Add(("shape.kind", "sealed-record-class")); kind = "sealed-record-class"; }
-        else if (kind == "validated-struct") { subs.Add(("shape.kind", "validated-class")); kind = "validated-class"; }
-        var site = row["shape.site"];
-        if (site == "in-generic-type") { subs.Add(("shape.site", "nested-in-class")); site = "nested-in-class"; }
-        var inh = row["shape.inheritance"];
-        if (inh == "none") { subs.Add(("shape.inheritance", "base-depth-1")); inh = "base-depth-1"; }
-        var eq = row["base-equality"];
-        var w = WrappedType(row["shape.wrapped"]);
-
-        var n = Depth(inh);
-        var body = new List<string>();
-        if (inh == "explicit-interface-member") body.Add($"public interface IMark{idx} {{ int Mark(); }}");
-        for (var d = n; d >= 1; d--)
-        {
-            var name = $"B{idx}_{d}";
-            var parents = d == n ? new List<string>() : [$"B{idx}_{d + 1}"];
-            var members = new List<string>();
-            if (d == n)
-            {
-                // the deepest base carries the row's own equality
-                if (eq == "override-Equals") members.Add($"public virtual bool Equals({name}? other) => ReferenceEquals(this, other);");
-                else if (eq == "override-GetHashCode") members.Add("public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this);");
-                else if (eq == "explicit-IEquatable")
-                {
-                    parents.Add($"System.IEquatable<{name}>");
-                    members.Add($"bool System.IEquatable<{name}>.Equals({name}? other) => ReferenceEquals(this, other);");
-                }
-            }
-            if (d == 1 && inh == "base-explicit-IEquatable" && !(eq == "explicit-IEquatable" && n == 1))
-            {
-                parents.Add($"System.IEquatable<{name}>");
-                members.Add($"bool System.IEquatable<{name}>.Equals({name}? other) => ReferenceEquals(this, other);");
-            }
-            if (d == 1 && inh == "explicit-interface-member")
-            {
-                parents.Add($"IMark{idx}");
-                members.Add($"int IMark{idx}.Mark() => 1;");
-            }
-            body.Add(Record(name, parents, members));
-        }
-        var v = $"V{idx}";
-        string make;
-        if (kind == "validated-class")
-        {
-            body.Add($"public sealed partial record {v} : B{idx}_1, IValidatedValue<{v}, {w}, global::Probes.Shapes.ShapeFault>\n{{\n" +
-                     $"    public static Result<{v}, global::Probes.Shapes.ShapeFault> Create({w} value) => new {v}(value);\n}}");
-            make = $"{v}.FromKnownGood(({w})x)";
-        }
-        else
-        {
-            body.Add($"public sealed partial record {v} : B{idx}_1, IValue<{w}>;");
-            make = $"{v}.From(({w})x)";
-        }
-        var (text, q) = AtSite(site, idx, string.Join("\n", body) + "\n");
-        o.Add($"// row {idx}\n" + text);
-        var bases = string.Join(", ", Enumerable.Range(1, n).Select(d => $"typeof({q}B{idx}_{d})"));
-        table.Add($"        new({idx}, \"{Key(row)}\", \"{kind}\", \"{site}\", \"{inh}\", typeof({q}{v}), [{bases}], x => {q}{make}, [{Substitutions(subs)}]),");
-    }
-    o.Add(Table("C09Table", "C09Case", table));
-    return string.Join("\n", o);
-}
-
-static string C11(string file, List<Dictionary<string, string>> rows)
-{
-    // A parse shape's control (a wrapped type of the same shape that parses) and its odd wrapped type.
-    var control = new Dictionary<string, string>(StringComparer.Ordinal)
-    {
-        ["implicit-result"] = "global::Probes.Build.C11ParsedShape",
-        ["ref-text"] = "global::Probes.Build.C11ParsesFromIn",
-        ["abstract-string-ctor"] = "global::Probes.Build.C11ConstructedConcrete",
-    };
-    var odd = new Dictionary<string, string>(StringComparer.Ordinal)
-    {
-        ["implicit-result"] = "global::Probes.Build.C11ParsesToInt",
-        ["abstract-string-ctor"] = "global::Probes.Build.C11AbstractText",
-    };
-    const string fault = "global::Probes.Shapes.ShapeFault";
-
-    var o = new List<string> { Head(file, "C11") };
-    var table = new List<string>();
-    for (var idx = 0; idx < rows.Count; idx++)
-    {
-        var row = rows[idx];
-        var subs = new List<(string, string)>();
-        var kind = row["shape.kind"];
-        if (kind == "closed-set") { subs.Add(("shape.kind", "sealed-record-class")); kind = "sealed-record-class"; }
-        var site = row["shape.site"];
-        if (site == "in-generic-type") { subs.Add(("shape.site", "nested-in-class")); site = "nested-in-class"; }
-        var inh = row["shape.inheritance"];
-        var isStruct = kind is "record-struct" or "validated-struct";
-        if (isStruct && inh is not ("none" or "explicit-interface-member")) { subs.Add(("shape.inheritance", "none")); inh = "none"; }
-        var shape = row["parse-shape"];
-        var w = shape switch
-        {
-            "ordinary" => WrappedType(row["shape.wrapped"]),
-            "ref-text" => idx % 2 == 0 ? "global::Probes.Build.C11ParsesByRef" : "global::Probes.Build.C11ConstructedByRef",
-            _ => odd.TryGetValue(shape, out var t) ? t : throw new GeneratorError($"parse-shape {shape} has no wrapped type here"),
-        };
-        var n = isStruct || inh == "explicit-interface-member" ? 0 : Depth(inh);
-        var body = new List<string>();
-        if (inh == "explicit-interface-member") body.Add($"public interface IMark{idx} {{ int Mark(); }}");
-
-        void Declare(string v, string b, string wrapped)
-        {
-            var mark = inh == "explicit-interface-member" ? $", IMark{idx}" : "";
-            for (var d = n; d >= 1; d--)
-            {
-                var name = $"{b}{idx}_{d}";
-                var parents = d == n ? new List<string>() : [$"{b}{idx}_{d + 1}"];
-                var members = new List<string>();
-                if (d == 1 && inh == "base-explicit-IEquatable")
-                {
-                    parents.Add($"System.IEquatable<{name}>");
-                    members.Add($"bool System.IEquatable<{name}>.Equals({name}? other) => ReferenceEquals(this, other);");
-                }
-                body.Add(Record(name, parents, members));
-            }
-            var @base = n > 0 ? $"{b}{idx}_1, " : "";
-            var m = mark != "" ? $" int IMark{idx}.Mark() => 1;" : "";
-            body.Add(kind switch
-            {
-                "record-struct" => $"public readonly partial record struct {v} : IValue<{wrapped}>{mark} {{{m} }}",
-                "sealed-record-class" => $"public sealed partial record {v} : {@base}IValue<{wrapped}>{mark} {{{m} }}",
-                "validated-struct" => $"public readonly partial record struct {v} : IValidatedValue<{v}, {wrapped}, {fault}>{mark}\n{{\n" +
-                                      $"    public static Result<{v}, {fault}> Create({wrapped} value) => new {v}(value);{m}\n}}",
-                "validated-class" => $"public sealed partial record {v} : {@base}IValidatedValue<{v}, {wrapped}, {fault}>{mark}\n{{\n" +
-                                     $"    public static Result<{v}, {fault}> Create({wrapped} value) => new {v}(value);{m}\n}}",
-                _ => throw new GeneratorError($"shape.kind {kind} has no declaration here"),
-            });
-        }
-
-        var v = $"V{idx}";
-        Declare(v, "B", w);
-        var c = control.GetValueOrDefault(shape);
-        if (c is not null) Declare($"VC{idx}", "BC", c);
-        var (text, q) = AtSite(site, idx, string.Join("\n", body) + "\n");
-        o.Add($"// row {idx}\n" + text);
-        var ctl = c is not null ? $"typeof({q}VC{idx}), typeof({c})" : "null, null";
-        table.Add($"        new({idx}, \"{Key(row)}\", \"{kind}\", \"{site}\", \"{inh}\", typeof({q}{v}), typeof({w}), {ctl}, [{Substitutions(subs)}]),");
-    }
-    o.Add(Table("C11Table", "C11Case", table));
-    return string.Join("\n", o);
-}
-
-static string WrappedType(string key) => key switch
-{
-    "string" => "string", "Guid" => "global::System.Guid", "int" => "int", "long" => "long", "byte" => "byte", "ulong" => "ulong",
-    "decimal" => "decimal", "double" => "double", "bool" => "bool", "char" => "char", "DateTime" => "global::System.DateTime",
-    "DateTimeOffset" => "global::System.DateTimeOffset", "DateOnly" => "global::System.DateOnly", "TimeOnly" => "global::System.TimeOnly",
-    "TimeSpan" => "global::System.TimeSpan", "enum" => "global::Probes.Shapes.PEnum", "flags-enum" => "global::Probes.Shapes.PFlags",
-    "Uri" => "global::System.Uri", "NodaTime.Instant" => "global::NodaTime.Instant", "own-record-class" => "global::Probes.Shapes.PRec",
-    _ => throw new GeneratorError($"shape.wrapped {key} is not in decls.cs's table"),
-};
-
-static string Arg(string[] args, string name)
-{
-    var at = Array.IndexOf(args, name);
-    return at >= 0 && at + 1 < args.Length ? args[at + 1] : throw new GeneratorError($"{name} <path> is required");
-}
-
-// A rows file of `prober rows`: gzipped JSON, {"claim": ..., "rows": [{"row": {axis: value}}, ...]}.
-static (string Claim, List<Dictionary<string, string>> Rows) Rows(string path)
-{
-    using var gzip = new GZipStream(File.OpenRead(path), CompressionMode.Decompress);
-    var document = JsonNode.Parse(gzip) ?? throw new GeneratorError($"{path} is empty");
-    var claim = document["claim"]?.GetValue<string>() ?? throw new GeneratorError($"{path} names no claim");
-    var rows = document["rows"] as JsonArray ?? throw new GeneratorError($"{path} has no rows");
-    return (claim,
-    [
-        .. rows.Select(r => (r?["row"] as JsonObject ?? throw new GeneratorError($"{path}: an entry without a row"))
-                   .ToDictionary(p => p.Key, p => p.Value?.GetValue<string>() ?? throw new GeneratorError($"{path}: {p.Key} is null"), StringComparer.Ordinal)),
-    ]);
-}
-
-sealed class GeneratorError(string message) : Exception(message);
diff --git a/tools/probe/generators/ef.cs b/tools/probe/generators/ef.cs
deleted file mode 100644
index 11108484..00000000
--- a/tools/probe/generators/ef.cs
+++ /dev/null
@@ -1,266 +0,0 @@
-// Writes the EF probes' shapes, one mode per file of tools/probe/corpus/harness:
-//
-//   catalogue  EfShapes.g.cs   one value object per (shape.kind, shape.wrapped, shape.site) the rows name, and EfRegistry
-//   keys       KeyShapes.g.cs  the same for the key claims (a row without shape.site is top-level), and KeyRegistry
-//   top-level  EfShapes3.g.cs  every kind at top level for each wrapped type the catalogue holds, and Reg3
-//   nested     EfShapes4.g.cs  every kind at each nested site for each wrapped type the catalogue holds, and Reg4
-//
-//   dotnet run tools/probe/generators/ef.cs -- catalogue --out tools/probe/corpus/harness/EfShapes.g.cs \
-//       --rows tools/probe/corpus/rows/E01ColumnParityProbe.json.gz --first 90 \
-//       --rows tools/probe/corpus/rows/E02ValueTranslatesProbe.json.gz --first 108
-//
-// --rows names a rows file (gzipped JSON, written by `prober rows`); --first after it reads only its first n rows.
-// The catalogue is E01's and E02's first round of rows: the rows appended since run on the complete grids of
-// top-level and nested, which take the same rows to learn which wrapped types the catalogue holds, in its order,
-// and which of them it validates. GeneratedHarnessTests in the conventions tests holds each file to this output,
-// with the arguments it lists.
-using System.IO.Compression;
-using System.Text;
-using System.Text.Json.Nodes;
-
-try
-{
-    var mode = args.Length > 0 ? args[0] : throw new GeneratorError("a mode is required: catalogue, keys, top-level or nested");
-    var combos = Combos(RowsArguments(args));
-    var text = mode switch
-    {
-        "catalogue" => Catalogue(combos, keys: false),
-        "keys" => Catalogue(combos, keys: true),
-        "top-level" => TopLevel(combos),
-        "nested" => Nested(combos),
-        _ => throw new GeneratorError($"unknown mode {mode}"),
-    };
-    File.WriteAllText(Arg(args, "--out"), text, new UTF8Encoding(false));
-    return 0;
-}
-catch (GeneratorError e)
-{
-    Console.Error.WriteLine($"ef.cs: {e.Message}");
-    return 2;
-}
-
-// The distinct (kind, wrapped, site) of the rows, sorted ordinally. A closed set and a value object nested in a
-// generic type (CMTK1005 at build) have no shape here.
-static List<(string Kind, string Wrapped, string Site)> Combos(IEnumerable<Dictionary<string, string>> rows) =>
-[
-    .. rows.Where(r => r["shape.kind"] != "closed-set")
-           .Select(r => (Kind: r["shape.kind"], Wrapped: r["shape.wrapped"], Site: r.GetValueOrDefault("shape.site", "top-level")))
-           .Where(c => c.Site != "in-generic-type")
-           .Distinct()
-           .OrderBy(c => c.Kind, StringComparer.Ordinal).ThenBy(c => c.Wrapped, StringComparer.Ordinal).ThenBy(c => c.Site, StringComparer.Ordinal),
-];
-
-static string Catalogue(List<(string Kind, string Wrapped, string Site)> combos, bool keys)
-{
-    var o = new List<string>
-    {
-        keys
-            ? "// <auto-generated/> by tools/probe/generators/ef.cs keys; the EF key probes' shape catalogue (shape.kind x shape.wrapped). Do not edit."
-            : "// <auto-generated/> by tools/probe/generators/ef.cs catalogue; the EF probes' shape catalogue (shape.kind x shape.wrapped x shape.site). Do not edit.",
-        "#nullable enable", Grids.Pragmas,
-        "using CodoMetis.TypeKit;", "using CodoMetis.TypeKit.ValueObjects;", "using Probes.Shapes;", "namespace Probes.Ef;",
-    };
-    var prefix = keys ? "K" : "";
-    var registry = new List<string>();
-    foreach (var (kind, key, site) in combos)
-    {
-        var w = Wrapped.Of(key);
-        var n = $"{(keys ? "K" : "E")}_{Ident(kind)}_{Ident(key)}";
-        string path;
-        switch (site)
-        {
-            case "top-level":
-                o.Add(Declaration(kind, n, w));
-                path = n;
-                break;
-            case "nested-in-class":
-                o.Add($"public static class C{prefix}_{n}\n{{\n{Declaration(kind, "V", w)}\n}}");
-                path = $"C{prefix}_{n}.V";
-                break;
-            case "nested-in-struct":
-                o.Add($"public struct S{prefix}_{n}\n{{\n{Declaration(kind, "V", w)}\n}}");
-                path = $"S{prefix}_{n}.V";
-                break;
-            case "nested-two-levels":
-                o.Add($"public static class C2{prefix}_{n}\n{{\n public static class Inner\n {{\n{Declaration(kind, "V", w)}\n }}\n}}");
-                path = $"C2{prefix}_{n}.Inner.V";
-                break;
-            default:
-                throw new GeneratorError($"shape.site {site} has no shape here");
-        }
-        registry.Add($"        e.Add(new EfEntry(\"{kind}\", \"{key}\", \"{site}\", typeof({path}), typeof({w.Type}), () => {w.Valid}));");
-    }
-    o.Add(keys
-        ? "public static partial class KeyRegistry\n{\n" +
-          "    public static readonly List<EfEntry> All = Build();\n" +
-          "    static List<EfEntry> Build() { var e = new List<EfEntry>(); Fill(e); return e; }\n" +
-          "    public static EfEntry Of(Probes.Shapes.Row r) { var k = r[\"shape.kind\"]; var w = r[\"shape.wrapped\"]; return All.First(x => x.Kind == k && x.Wrapped == w); }\n" +
-          "    public static void Fill(List<EfEntry> e)\n    {"
-        : "public static partial class EfRegistry\n{\n    static partial void Fill(List<EfEntry> e)\n    {");
-    o.AddRange(registry);
-    o.Add("    }\n}");
-    return string.Join("\n", o) + "\n";
-}
-
-static string Declaration(string kind, string name, Wrapped w) => kind switch
-{
-    "record-struct" => $"public readonly partial record struct {name} : IValue<{w.Type}>;",
-    "sealed-record-class" => $"public sealed partial record class {name} : IValue<{w.Type}>;",
-    "validated-struct" or "validated-class" =>
-        $"public {(kind == "validated-struct" ? "readonly partial record struct" : "sealed partial record class")} {name} : IValidatedValue<{name}, {w.Type}, ShapeFault>\n{{\n" +
-        $"    public static Result<{name}, ShapeFault> Create({w.Type} value) =>\n" +
-        $"        EqualityComparer<{w.Type}>.Default.Equals(value, {w.Refused}) ? Result.Error(ShapeFault.Refused) : new {name}(value);\n}}",
-    _ => throw new GeneratorError($"shape.kind {kind} has no declaration here"),
-};
-
-// The grids: the catalogue's wrapped types in its order; the validated kinds only for a wrapped type the catalogue validates.
-static (List<string> Wrapped, HashSet<string> Validated) Grid(List<(string Kind, string Wrapped, string Site)> combos) =>
-(
-    [.. combos.Select(c => c.Wrapped).Distinct()],
-    [.. combos.Where(c => c.Kind.StartsWith("validated", StringComparison.Ordinal)).Select(c => c.Wrapped)]
-);
-
-static string OneLine(string abbreviation, string name, Wrapped w) => abbreviation switch
-{
-    "rs" => $"public readonly partial record struct {name} : IValue<{w.Type}>;",
-    "rc" => $"public sealed partial record class {name} : IValue<{w.Type}>;",
-    _ => $"public {(abbreviation == "vs" ? "readonly partial record struct" : "sealed partial record class")} {name} : IValidatedValue<{name}, {w.Type}, ShapeFault> " +
-         $"{{ public static Result<{name}, ShapeFault> Create({w.Type} value) => EqualityComparer<{w.Type}>.Default.Equals(value, {w.Refused}) ? Result.Error(ShapeFault.Refused) : new {name}(value); }}",
-};
-
-static IEnumerable<(string Kind, string Abbreviation)> KindsFor(string key, HashSet<string> validated) =>
-    Grids.Kinds.Where(k => k.Abbreviation is "rs" or "rc" || validated.Contains(key));
-
-static string TopLevel(List<(string Kind, string Wrapped, string Site)> combos)
-{
-    var (wrapped, validated) = Grid(combos);
-    var o = new List<string>
-    {
-        "// <auto-generated/> by tools/probe/generators/ef.cs top-level: top-level shapes for every (kind, wrapped) the E03/E09/E10 probes need. Do not edit.",
-        "#nullable enable", Grids.Pragmas,
-        "using CodoMetis.TypeKit;", "using CodoMetis.TypeKit.ValueObjects;", "using Probes.Shapes;", "namespace Probes.Ef3;",
-    };
-    foreach (var key in wrapped)
-        foreach (var (_, p) in KindsFor(key, validated))
-            o.Add(OneLine(p, $"X_{p}_{Ident(key)}", Wrapped.Of(key)));
-    o.Add("public static class Reg3 {");
-    o.Add(" public static readonly Dictionary<(string Kind, string Wrapped), (Type Vo, Type Plain)> All = new() {");
-    foreach (var key in wrapped)
-        foreach (var (kind, p) in KindsFor(key, validated))
-            o.Add($"  [(\"{kind}\", \"{key}\")] = (typeof(X_{p}_{Ident(key)}), typeof({Wrapped.Of(key).Type})),");
-    o.Add(" };");
-    o.Add("}");
-    return string.Join("\n", o) + "\n";
-}
-
-static string Nested(List<(string Kind, string Wrapped, string Site)> combos)
-{
-    var (wrapped, validated) = Grid(combos);
-    var o = new List<string>
-    {
-        "// <auto-generated/> by tools/probe/generators/ef.cs nested: nested-site shapes (nested-in-class, nested-in-struct, nested-two-levels) for every kind x wrapped. Do not edit.",
-        "#nullable enable", Grids.Pragmas,
-        "using CodoMetis.TypeKit;", "using CodoMetis.TypeKit.ValueObjects;", "using Probes.Shapes;", "namespace Probes.Ef4;",
-    };
-    var registry = new List<string>();
-    foreach (var key in wrapped)
-    {
-        var w = Wrapped.Of(key);
-        foreach (var (kind, p) in KindsFor(key, validated))
-        {
-            var decl = OneLine(p, "V", w);
-            var n = $"{p}_{Ident(key)}";
-            o.Add($"public static class NC_{n} {{ {decl} }}");
-            o.Add($"public struct NS_{n} {{ {decl} }}");
-            o.Add($"public static class N2_{n} {{ public static class Inner {{ {decl} }} }}");
-            foreach (var (site, path) in new[] { ("nested-in-class", $"NC_{n}.V"), ("nested-in-struct", $"NS_{n}.V"), ("nested-two-levels", $"N2_{n}.Inner.V") })
-                registry.Add($"  [(\"{kind}\", \"{key}\", \"{site}\")] = (typeof({path}), typeof({w.Type})),");
-        }
-    }
-    o.Add("public static class Reg4 {");
-    o.Add(" public static readonly Dictionary<(string Kind, string Wrapped, string Site), (Type Vo, Type Plain)> All = new() {");
-    o.AddRange(registry);
-    o.Add(" };");
-    o.Add("}");
-    return string.Join("\n", o) + "\n";
-}
-
-static string Ident(string s) => s.Replace('-', '_').Replace('.', '_');
-
-static string Arg(string[] args, string name)
-{
-    var at = Array.IndexOf(args, name);
-    return at >= 0 && at + 1 < args.Length ? args[at + 1] : throw new GeneratorError($"{name} <path> is required");
-}
-
-// Every --rows file's rows, in order, each cut to the --first n that follows it.
-static IEnumerable<Dictionary<string, string>> RowsArguments(string[] args)
-{
-    var any = false;
-    for (var i = 1; i < args.Length; i++)
-    {
-        if (args[i] != "--rows") continue;
-        if (i + 1 >= args.Length) throw new GeneratorError("--rows <path> needs a path");
-        var rows = Rows(args[i + 1]);
-        if (i + 3 < args.Length && args[i + 2] == "--first")
-        {
-            var first = int.Parse(args[i + 3], System.Globalization.CultureInfo.InvariantCulture);
-            if (first > rows.Count) throw new GeneratorError($"--first {first}, but {args[i + 1]} holds {rows.Count} rows");
-            rows = rows.GetRange(0, first);
-        }
-        any = true;
-        foreach (var row in rows) yield return row;
-    }
-    if (!any) throw new GeneratorError("at least one --rows <path> is required");
-}
-
-// A rows file of `prober rows`: gzipped JSON, {"claim": ..., "rows": [{"row": {axis: value}}, ...]}.
-static List<Dictionary<string, string>> Rows(string path)
-{
-    using var gzip = new GZipStream(File.OpenRead(path), CompressionMode.Decompress);
-    var rows = JsonNode.Parse(gzip)?["rows"] as JsonArray ?? throw new GeneratorError($"{path} has no rows");
-    return
-    [
-        .. rows.Select(r => (r?["row"] as JsonObject ?? throw new GeneratorError($"{path}: an entry without a row"))
-                   .ToDictionary(p => p.Key, p => p.Value?.GetValue<string>() ?? throw new GeneratorError($"{path}: {p.Key} is null"), StringComparer.Ordinal)),
-    ];
-}
-
-/// <summary>A wrapped type: its C# spelling, a value Create keeps and the one it refuses.</summary>
-sealed record Wrapped(string Type, string Valid, string Refused)
-{
-    static readonly Dictionary<string, Wrapped> Table = new(StringComparer.Ordinal)
-    {
-        ["string"] = new("string", "\"alpha\"", "\"SECRET-7f3a\""),
-        ["Guid"] = new("Guid", "Guid.Parse(\"11111111-1111-1111-1111-111111111111\")", "Guid.Empty"),
-        ["int"] = new("int", "42", "-1"),
-        ["long"] = new("long", "4200000000L", "-1L"),
-        ["byte"] = new("byte", "(byte)7", "(byte)255"),
-        ["ulong"] = new("ulong", "4200000000UL", "0UL"),
-        ["decimal"] = new("decimal", "7.80m", "-1m"),
-        ["double"] = new("double", "1.5", "-1.0"),
-        ["bool"] = new("bool", "true", "false"),
-        ["char"] = new("char", "'a'", "'x'"),
-        ["DateTime"] = new("DateTime", "new DateTime(2026,10,15,8,30,0,DateTimeKind.Utc)", "DateTime.MinValue"),
-        ["DateTimeOffset"] = new("DateTimeOffset", "new DateTimeOffset(2026,10,15,8,30,0,TimeSpan.Zero)", "DateTimeOffset.MinValue"),
-        ["DateOnly"] = new("DateOnly", "new DateOnly(2026,10,15)", "DateOnly.MinValue"),
-        ["TimeOnly"] = new("TimeOnly", "new TimeOnly(8,30,15)", "TimeOnly.MinValue"),
-        ["TimeSpan"] = new("TimeSpan", "TimeSpan.FromMinutes(90)", "TimeSpan.MinValue"),
-        ["enum"] = new("PEnum", "PEnum.B", "(PEnum)99"),
-        ["flags-enum"] = new("PFlags", "PFlags.P | PFlags.Q", "(PFlags)0"),
-        ["Uri"] = new("Uri", "new Uri(\"https://example.com/a\")", "new Uri(\"https://example.com/refused\")"),
-    };
-
-    public static Wrapped Of(string key) =>
-        Table.TryGetValue(key, out var w) ? w : throw new GeneratorError($"shape.wrapped {key} is not in ef.cs's table");
-}
-
-static class Grids
-{
-    public const string Pragmas = "#pragma warning disable CMTK0014, CS8618, CS1591, CMTK0005, CMTK1000, CMTK0003, CMTK0006, CA1000";
-
-    public static readonly (string Kind, string Abbreviation)[] Kinds =
-        [("record-struct", "rs"), ("sealed-record-class", "rc"), ("validated-struct", "vs"), ("validated-class", "vc")];
-}
-
-sealed class GeneratorError(string message) : Exception(message);
diff --git a/tools/probe/generators/faults.cs b/tools/probe/generators/faults.cs
deleted file mode 100644
index 658d02d6..00000000
--- a/tools/probe/generators/faults.cs
+++ /dev/null
@@ -1,139 +0,0 @@
-// Writes tools/probe/corpus/harness/FaultClaimControllers.g.cs: the MVC controllers of the fault claims C04, C06, C14
-// and C15 and, from the same data, the table FxCtl that FaultClaim reads as the oracle's input (what each controller
-// and action declares). Its input is the table below, not a rows file: each row of those claims picks a controller.
-//
-//   dotnet run tools/probe/generators/faults.cs -- --out tools/probe/corpus/harness/FaultClaimControllers.g.cs
-//
-// GeneratedHarnessTests in the conventions tests holds the committed file to this output.
-using System.Text;
-
-try
-{
-    File.WriteAllText(Arg(args, "--out"), Generate(), new UTF8Encoding(false));
-    return 0;
-}
-catch (GeneratorError e)
-{
-    Console.Error.WriteLine($"faults.cs: {e.Message}");
-    return 2;
-}
-
-static string Generate()
-{
-    // The result type an action answers, by the last segment of its route; decl answers one, with a 429 of its own.
-    string[] results = ["one", "two", "dup", "decl"];
-    var returns = new Dictionary<string, string>(StringComparer.Ordinal)
-    {
-        ["one"] = "Results<NoContent, FaultProblem<HFault>>",
-        ["two"] = "Results<NoContent, FaultProblem<HFault>, FaultProblem<GFault>>",
-        ["dup"] = "Results<NoContent, FaultProblem<HFault>, FaultProblem<KFault>>",
-        ["decl"] = "Results<NoContent, FaultProblem<HFault>>",
-    };
-    var bodies = new Dictionary<string, string>(StringComparer.Ordinal)
-        { ["one"] = "FxErr.One(e)", ["two"] = "FxErr.Two(e)", ["dup"] = "FxErr.Dup(e)", ["decl"] = "FxErr.One(e)" };
-
-    var o = new List<string>
-    {
-        "// Generated by tools/probe/generators/faults.cs (the fault claims' MVC controllers, C04 C06 C14 C15): do not edit by hand.",
-        "// Every action answers FxErr's errors; its route ends in the result type it answers (one, two, dup) or decl (one, with a",
-        "// [ProducesResponseType<ProblemDetails>(429)] of its own). The table FxCtl.All restates what each class and action declares,",
-        "// in ASP.NET's metadata order (controller, then action), as the input FaultClaim computes the expected response and document from.",
-        "using CodoMetis.TypeKit;",
-        "using CodoMetis.TypeKit.AspNetCore;",
-        "using Microsoft.AspNetCore.Http;",
-        "using Microsoft.AspNetCore.Http.HttpResults;",
-        "using Microsoft.AspNetCore.Mvc;",
-        "namespace Probes.Faults;",
-        "",
-    };
-    foreach (var (name, variants, actions) in Table.Controllers)
-    {
-        o.Add($"internal abstract class Fx{name}Base : ControllerBase");
-        o.Add("{");
-        foreach (var (route, decls, declared) in actions)
-        {
-            foreach (var t in results)
-            {
-                var attrs = new List<string> { $"HttpGet(\"c/{route}/{t}\")" };
-                attrs.AddRange(decls.Select(Attribute));
-                attrs.AddRange(declared.Select(DeclaredAttribute));
-                if (t == "decl") attrs.Add("ProducesResponseType<ProblemDetails>(429)");
-                o.Add($"    [{string.Join(", ", attrs)}] public {returns[t]} {Pascal(route)}{char.ToUpperInvariant(t[0])}{t[1..]}(int e) => {bodies[t]}.ToHttpResult();");
-            }
-        }
-        o.Add("}");
-        foreach (var (suffix, classDecls) in variants)
-        {
-            var a = string.Join(", ", classDecls.Select(Attribute));
-            o.Add($"[ApiController{(a != "" ? ", " + a : "")}] internal sealed class Fx{name}{suffix}Api : Fx{name}Base {{ }}");
-            o.Add($"{(a != "" ? "[" + a + "] " : "")}internal sealed class Fx{name}{suffix}Plain : Fx{name}Base {{ }}");
-        }
-        o.Add("");
-    }
-    o.Add("public static partial class FxCtl");
-    o.Add("{");
-    o.Add("    static partial void Fill(Dictionary<string, Ctl> d)");
-    o.Add("    {");
-    foreach (var (name, variants, actions) in Table.Controllers)
-    {
-        var acts = string.Join(", ", actions.Select(x =>
-            $"new(\"{x.Route}\", [{string.Join(", ", x.Decls.Select(Literal))}], [{string.Join(", ", x.Declared.Select(s => s.Status))}])"));
-        foreach (var (suffix, classDecls) in variants)
-            o.Add($"        d[\"{name}{suffix}\"] = new(typeof(Fx{name}{suffix}Api), typeof(Fx{name}{suffix}Plain), [{string.Join(", ", classDecls.Select(Literal))}], [{acts}]);");
-    }
-    o.Add("    }");
-    o.Add("}");
-    return string.Join("\n", o) + "\n";
-}
-
-// A fault member's status: WithoutFaults where the status is 0 (left out), FaultStatus otherwise.
-static string Attribute(Decl d) => d.Status == 0 ? $"WithoutFaults<{d.Type}>(\"{d.Member}\")" : $"FaultStatus<{d.Type}>(\"{d.Member}\", {d.Status})";
-
-static string Literal(Decl d) => $"new(\"{d.Type}\", \"{d.Member}\", {d.Status})";
-
-// A status the action declares itself: pp as ProducesProblem declares it (with application/problem+json), prt as [ProducesResponseType] alone.
-static string DeclaredAttribute(Declared x) =>
-    x.How == "pp" ? $"ProducesResponseType<ProblemDetails>({x.Status}, \"application/problem+json\")" : $"ProducesResponseType<ProblemDetails>({x.Status})";
-
-static string Pascal(string route) =>
-    string.Concat(route.Split('/', StringSplitOptions.RemoveEmptyEntries).Select(p => char.ToUpperInvariant(p[0]) + p[1..]));
-
-static string Arg(string[] args, string name)
-{
-    var at = Array.IndexOf(args, name);
-    return at >= 0 && at + 1 < args.Length ? args[at + 1] : throw new GeneratorError($"{name} <path> is required");
-}
-
-/// <summary>A fault member's declared status on a class or an action; 0 leaves the member out.</summary>
-sealed record Decl(string Type, string Member, int Status);
-
-/// <summary>A status an action declares itself, and how.</summary>
-sealed record Declared(int Status, string How);
-
-sealed record ControllerAction(string Route, Decl[] Decls, Declared[] Declared);
-
-/// <summary>The controllers: each name's class variants (suffix, the class's declarations) and its actions.</summary>
-static class Table
-{
-    public static readonly (string Name, (string Suffix, Decl[] Decls)[] Variants, ControllerAction[] Actions)[] Controllers =
-    [
-        ("C04Ep", [("", []), ("S", [new("HFault", "Down", 507)])],
-            [new("fx/ep/wo", [new("HFault", "Down", 0)], []), new("fx/ep/keep", [], [])]),
-        ("C04CtWo", [("", [new("HFault", "Down", 0)])],
-            [new("fx/ct/wo/a", [], []), new("fx/ct/wo/b", [], [])]),
-        ("C04CtKeep", [("", [])], [new("fx/ct/keep", [], [])]),
-        ("C04Gr", [("", [])], [new("fx/gr/a", [], []), new("fx/gr/b", [], [])]),
-        ("C06K", [("", [])], [new("k", [], [])]),
-        ("C14Pp", [("", [])], [new("d/pp", [], [new(404, "pp")])]),
-        ("C14Prt", [("", [])], [new("d/prt", [], [new(404, "prt")])]),
-        ("C14None", [("", [])], [new("d/none", [], [])]),
-        ("C15M", [("", [])], [new("s/a", [], []), new("s/p", [new("HFault", "Denied", 452)], [])]),
-        ("C15AS", [("", [])], [new("s/a", [new("HFault", "Denied", 451)], []), new("s/k", [], [])]),
-        ("C15AW", [("", [])], [new("s/a", [new("HFault", "Down", 0)], []), new("s/k", [], [])]),
-        ("C15CS", [("", [new("HFault", "Denied", 451)])], [new("s/a", [], []), new("s/p", [new("HFault", "Denied", 452)], [])]),
-        ("C15CW", [("", [new("HFault", "Down", 0)])], [new("s/a", [], []), new("s/p", [new("HFault", "Denied", 452)], [])]),
-        ("C15K", [("", [])], [new("s/k", [], [])]),
-    ];
-}
-
-sealed class GeneratorError(string message) : Exception(message);
diff --git a/tools/probe/generators/json-family.cs b/tools/probe/generators/json-family.cs
deleted file mode 100644
index dd8d5ef3..00000000
--- a/tools/probe/generators/json-family.cs
+++ /dev/null
@@ -1,220 +0,0 @@
-// Writes the JSON family's declarations from its rows, one mode per file of tools/probe/corpus/harness:
-//
-//   stand-ins  JsonFamilyShapes.g.cs  L06's polymorphic stand-ins over Option and Result, a base and its derived type per
-//                                     value object and carrier; the source-generated context the family runs on is the
-//                                     one ProbeContext (shapes.cs), which lists the carriers L06's rows hold
-//   l05        L05Shapes.g.cs         L05's value objects and closed sets, one per (kind, wrapped, inheritance, site) its
-//                                     rows name, and L05Registry
-//
-//   dotnet run tools/probe/generators/json-family.cs -- stand-ins --out tools/probe/corpus/harness/JsonFamilyShapes.g.cs
-//   dotnet run tools/probe/generators/json-family.cs -- l05 --out tools/probe/corpus/harness/L05Shapes.g.cs \
-//       --rows tools/probe/corpus/rows/L05EqualityProbe.json.gz
-//
-// A rows file is gzipped JSON, written by `prober rows`. GeneratedHarnessTests in the conventions tests holds each
-// file to this output.
-using System.IO.Compression;
-using System.Text;
-using System.Text.Json.Nodes;
-using System.Text.RegularExpressions;
-
-try
-{
-    var mode = args.Length > 0 ? args[0] : throw new GeneratorError("a mode is required: stand-ins or l05");
-    var text = mode switch
-    {
-        "stand-ins" => StandIns(),
-        "l05" => L05(Rows(Arg(args, "--rows"))),
-        _ => throw new GeneratorError($"unknown mode {mode}"),
-    };
-    File.WriteAllText(Arg(args, "--out"), text, new UTF8Encoding(false));
-    return 0;
-}
-catch (GeneratorError e)
-{
-    Console.Error.WriteLine($"json-family.cs: {e.Message}");
-    return 2;
-}
-
-static string StandIns()
-{
-    var o = new List<string>
-    {
-        "// <auto-generated/> by tools/probe/generators/json-family.cs stand-ins: L06's polymorphic stand-ins over Option and Result. Do not edit.",
-        "#nullable disable", "#pragma warning disable CS8618, CS1591, CMTK0005, CMTK0006",
-        "using CodoMetis.TypeKit;", "using Probes.Shapes;",
-        "namespace Probes.Json;", "",
-    };
-    // a base per value object and carrier, its derived type holding the Option or Result
-    var vos = new[] { "record-struct", "sealed-record-class", "validated-struct", "validated-class" }
-        .SelectMany(k => Shape.WrappedTypes.Keys.Select(w => Shape.Vo(k, w))).Append("PSet");
-    foreach (var v in vos)
-    {
-        foreach (var (key, pattern) in new[] { ("O", "Option<{0}>"), ("RTE", "Result<{0}, ShapeFault>"), ("RE", "Result<{0}>") })
-        {
-            var (b, d) = ($"L06PB_{Shape.San(v)}_{key}", $"L06PD_{Shape.San(v)}_{key}");
-            o.Add($"[System.Text.Json.Serialization.JsonPolymorphic] [System.Text.Json.Serialization.JsonDerivedType(typeof({d}), \"d\")] public abstract class {b} {{ }}");
-            o.Add($"public sealed class {d} : {b} {{ public {string.Format(System.Globalization.CultureInfo.InvariantCulture, pattern, v)} Value {{ get; set; }} }}");
-        }
-    }
-    return string.Join("\n", o) + "\n";
-}
-
-static string L05(List<Dictionary<string, string>> rows)
-{
-    // A row the covering array made with an excluded pair runs the nearest shape that exists (the probe notes the substitution).
-    static string SiteOf(Dictionary<string, string> r) => r["shape.site"] == "in-generic-type" ? "top-level" : r["shape.site"];
-    static string InheritanceOf(Dictionary<string, string> r) =>
-        Shape.VoIsStruct(r["shape.kind"]) && r["shape.inheritance"].StartsWith("base-", StringComparison.Ordinal) ? "none" : r["shape.inheritance"];
-
-    var tuples = rows
-        .Select(r => (Kind: r["shape.kind"], Wrapped: r["shape.kind"] == "closed-set" ? "-" : r["shape.wrapped"], Inheritance: InheritanceOf(r), Site: SiteOf(r)))
-        .Distinct()
-        .OrderBy(t => t.Kind, StringComparer.Ordinal).ThenBy(t => t.Wrapped, StringComparer.Ordinal)
-        .ThenBy(t => t.Inheritance, StringComparer.Ordinal).ThenBy(t => t.Site, StringComparer.Ordinal)
-        .ToList();
-
-    var o = new List<string>
-    {
-        "// <auto-generated/> by tools/probe/generators/json-family.cs from the rows of L05-equality. Do not edit.",
-        "#nullable enable",
-        "#pragma warning disable CS1591, CMTK0005, CMTK1023 // CMTK1023: a base record with an explicit IEquatable is the shape under test",
-        "using CodoMetis.TypeKit;", "using CodoMetis.TypeKit.ValueObjects;", "using CodoMetis.TypeKit.ClosedSets;", "using Probes.Shapes;",
-        "namespace Probes.Json;", "",
-        "public interface IL05Tag { string Tag { get; } }",
-        "public abstract record L05B1;", "public abstract record L05B2a;", "public abstract record L05B2b : L05B2a;",
-        "public abstract record L05B3a;", "public abstract record L05B3b : L05B3a;", "public abstract record L05B3c : L05B3b;",
-        "// a deeper base whose own IEquatable says \"never equal\": the value object must not use it",
-        "public abstract record L05E0 : IEquatable<L05E0> { bool IEquatable<L05E0>.Equals(L05E0? other) => false; }",
-        "public abstract record L05E1 : L05E0;",
-        "public abstract class L05CB1;", "public abstract class L05CB2a;", "public abstract class L05CB2b : L05CB2a;",
-        "public abstract class L05CB3a;", "public abstract class L05CB3b : L05CB3a;", "public abstract class L05CB3c : L05CB3b;",
-        "public abstract class L05CE0 : IEquatable<L05CE0> { bool IEquatable<L05CE0>.Equals(L05CE0? other) => ReferenceEquals(this, other); }",
-        "public abstract class L05CE1 : L05CE0;", "",
-    };
-    // the base each inheritance names: records under a value object, classes under a closed set
-    var recordBases = new Dictionary<string, string>(StringComparer.Ordinal)
-        { ["base-depth-1"] = "L05B1", ["base-depth-2"] = "L05B2b", ["base-depth-3"] = "L05B3c", ["base-explicit-IEquatable"] = "L05E1" };
-    var classBases = new Dictionary<string, string>(StringComparer.Ordinal)
-        { ["base-depth-1"] = "L05CB1", ["base-depth-2"] = "L05CB2b", ["base-depth-3"] = "L05CB3c", ["base-explicit-IEquatable"] = "L05CE1" };
-
-    var registry = new List<string>();
-    for (var i = 0; i < tuples.Count; i++)
-    {
-        var (k, w, inh, site) = tuples[i];
-        var n = $"L05_{i}_{Shape.San(k)}_{Shape.San(w)}";
-        var bases = new List<string>();
-        if (inh.StartsWith("base-", StringComparison.Ordinal)) bases.Add((k == "closed-set" ? classBases : recordBases)[inh]);
-        var tag = inh == "explicit-interface-member" ? " string IL05Tag.Tag => \"t\";" : "";
-        if (inh == "explicit-interface-member") bases.Add("IL05Tag");
-        var head = string.Concat(bases.Select(b => b + ", "));
-        string decl;
-        if (k == "closed-set")
-            decl = $"public sealed partial class {n} : {head}IClosedSet<{n}> {{ public static readonly {n} Alpha = new(); public static readonly {n} Beta = new();{tag} }}";
-        else
-        {
-            var t = Shape.WrappedTypes[w];
-            decl = k switch
-            {
-                "record-struct" => $"public readonly partial record struct {n} : {head}IValue<{t}> {{{tag} }}",
-                "sealed-record-class" => $"public sealed partial record {n} : {head}IValue<{t}> {{{tag} }}",
-                "validated-struct" => $"public readonly partial record struct {n} : {head}IValidatedValue<{n}, {t}, ShapeFault> {{ public static Result<{n}, ShapeFault> Create({t} value) => new {n}(value);{tag} }}",
-                "validated-class" => $"public sealed partial record {n} : {head}IValidatedValue<{n}, {t}, ShapeFault> {{ public static Result<{n}, ShapeFault> Create({t} value) => new {n}(value);{tag} }}",
-                _ => throw new GeneratorError($"shape.kind {k} has no declaration here"),
-            };
-        }
-        string full;
-        switch (site)
-        {
-            case "top-level": o.Add(decl); full = n; break;
-            case "nested-in-class": o.Add($"public partial class L05Oc{i} {{ {decl} }}"); full = $"L05Oc{i}.{n}"; break;
-            case "nested-in-struct": o.Add($"public partial struct L05Os{i} {{ {decl} }}"); full = $"L05Os{i}.{n}"; break;
-            case "nested-two-levels": o.Add($"public partial class L05Ot{i} {{ public partial class Inner {{ {decl} }} }}"); full = $"L05Ot{i}.Inner.{n}"; break;
-            default: throw new GeneratorError($"shape.site {site} has no shape here");
-        }
-        if (k == "closed-set")
-            registry.Add($"        Add(\"{k}\", \"-\", \"{inh}\", \"{site}\", typeof({full}), () => {full}.Alpha, () => {full}.All.First(m => m.Name == \"Alpha\"), () => {full}.Beta);");
-        else
-        {
-            var (a1, a2, b) = L05Samples.All[w];
-            registry.Add($"        Add(\"{k}\", \"{w}\", \"{inh}\", \"{site}\", typeof({full}), () => {a1}, () => {a2}, () => {b});");
-        }
-    }
-    o.AddRange(["", "public static partial class L05Registry", "{", "    static partial void Fill()", "    {"]);
-    o.AddRange(registry);
-    o.AddRange(["    }", "}", ""]);
-    return string.Join("\n", o);
-}
-
-static string Arg(string[] args, string name)
-{
-    var at = Array.IndexOf(args, name);
-    return at >= 0 && at + 1 < args.Length ? args[at + 1] : throw new GeneratorError($"{name} <path> is required");
-}
-
-// A rows file of `prober rows`: gzipped JSON, {"claim": ..., "rows": [{"row": {axis: value}}, ...]}.
-static List<Dictionary<string, string>> Rows(string path)
-{
-    using var gzip = new GZipStream(File.OpenRead(path), CompressionMode.Decompress);
-    var rows = JsonNode.Parse(gzip)?["rows"] as JsonArray ?? throw new GeneratorError($"{path} has no rows");
-    return
-    [
-        .. rows.Select(r => (r?["row"] as JsonObject ?? throw new GeneratorError($"{path}: an entry without a row"))
-                   .ToDictionary(p => p.Key, p => p.Value?.GetValue<string>() ?? throw new GeneratorError($"{path}: {p.Key} is null"), StringComparer.Ordinal)),
-    ];
-}
-
-/// <summary>
-/// L05's samples of each wrapped type, as C# expressions: a1, a2 (equal to a1 by the wrapped type's own equality, in
-/// another form), b (unequal, greater where ordered).
-/// </summary>
-static class L05Samples
-{
-    public static readonly Dictionary<string, (string A1, string A2, string B)> All = new(StringComparer.Ordinal)
-    {
-        ["string"] = ("\"alpha\"", "new string(\"alpha\".ToCharArray())", "\"beta\""),
-        ["Guid"] = ("Guid.Parse(\"11111111-1111-1111-1111-111111111111\")", "new Guid(\"11111111111111111111111111111111\")", "Guid.Parse(\"22222222-2222-2222-2222-222222222222\")"),
-        ["int"] = ("42", "42", "43"),
-        ["long"] = ("4200000000L", "4200000000L", "4200000001L"),
-        ["byte"] = ("(byte)7", "(byte)7", "(byte)8"),
-        ["ulong"] = ("4200000000UL", "4200000000UL", "4200000001UL"),
-        ["decimal"] = ("7.8m", "7.80m", "7.81m"),
-        ["double"] = ("0.0", "-0.0", "1.5"),
-        ["bool"] = ("false", "false", "true"),
-        ["char"] = ("'a'", "'a'", "'b'"),
-        ["DateTime"] = ("new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Utc)", "new DateTime(2026, 10, 15, 8, 30, 0, DateTimeKind.Unspecified)", "new DateTime(2026, 10, 15, 8, 31, 0, DateTimeKind.Utc)"),
-        ["DateTimeOffset"] = ("new DateTimeOffset(2026, 10, 15, 8, 30, 0, TimeSpan.Zero)", "new DateTimeOffset(2026, 10, 15, 10, 30, 0, TimeSpan.FromHours(2))", "new DateTimeOffset(2026, 10, 15, 8, 31, 0, TimeSpan.Zero)"),
-        ["DateOnly"] = ("new DateOnly(2026, 10, 15)", "DateOnly.FromDayNumber(new DateOnly(2026, 10, 15).DayNumber)", "new DateOnly(2026, 10, 16)"),
-        ["TimeOnly"] = ("new TimeOnly(8, 30, 15)", "new TimeOnly(new TimeOnly(8, 30, 15).Ticks)", "new TimeOnly(8, 30, 16)"),
-        ["TimeSpan"] = ("TimeSpan.FromMinutes(90)", "TimeSpan.FromSeconds(5400)", "TimeSpan.FromMinutes(91)"),
-        ["enum"] = ("PEnum.B", "(PEnum)1", "PEnum.C"),
-        ["flags-enum"] = ("PFlags.P | PFlags.Q", "(PFlags)3", "PFlags.R"),
-        ["Uri"] = ("new Uri(\"https://example.com/a\")", "new Uri(\"HTTPS://EXAMPLE.COM/a\")", "new Uri(\"https://example.com/b\")"),
-        ["NodaTime.Instant"] = ("global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30)", "global::NodaTime.Instant.FromUnixTimeTicks(global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 30).ToUnixTimeTicks())", "global::NodaTime.Instant.FromUtc(2026, 10, 15, 8, 31)"),
-        ["own-record-class"] = ("new PRec { A = \"x\", B = 1 }", "new PRec { A = new string(\"x\".ToCharArray()), B = 1 }", "new PRec { A = \"y\", B = 1 }"),
-    };
-}
-
-/// <summary>The names the shapes of Shapes.g.cs go by.</summary>
-static partial class Shape
-{
-    /// <summary>Each wrapped type's C# spelling, in the axes file's order.</summary>
-    public static readonly Dictionary<string, string> WrappedTypes = new(StringComparer.Ordinal)
-    {
-        ["string"] = "string", ["Guid"] = "Guid", ["int"] = "int", ["long"] = "long", ["byte"] = "byte", ["ulong"] = "ulong",
-        ["decimal"] = "decimal", ["double"] = "double", ["bool"] = "bool", ["char"] = "char", ["DateTime"] = "DateTime",
-        ["DateTimeOffset"] = "DateTimeOffset", ["DateOnly"] = "DateOnly", ["TimeOnly"] = "TimeOnly", ["TimeSpan"] = "TimeSpan",
-        ["enum"] = "PEnum", ["flags-enum"] = "PFlags", ["Uri"] = "Uri", ["NodaTime.Instant"] = "global::NodaTime.Instant",
-        ["own-record-class"] = "PRec",
-    };
-
-    public static string San(string s) => NotAlphanumeric().Replace(s, "_");
-
-    public static string Vo(string kind, string wrapped) => kind == "closed-set" ? "PSet" : $"V_{San(kind)}_{San(wrapped)}";
-
-    public static bool VoIsStruct(string kind) => kind is "record-struct" or "validated-struct";
-
-    [GeneratedRegex("[^A-Za-z0-9]")]
-    private static partial Regex NotAlphanumeric();
-}
-
-sealed class GeneratorError(string message) : Exception(message);
diff --git a/tools/probe/generators/rules.cs b/tools/probe/generators/rules.cs
deleted file mode 100644
index 8d712137..00000000
--- a/tools/probe/generators/rules.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-// Writes tools/probe/corpus/harness/RuleControllers.g.cs: the MVC controllers C03 and C05 run against, one action per
-// arity (a Fault of two or three sets) and response variant, routed c/{arity}/{variant}, each answering Cmp's errors.
-// The variants are those ComposedClaims.Variant names a row's http.response by and Cmp.MapMinimal maps on the minimal
-// side; the class names are what ComposedClaims hands the host (RuleApiController, RulePlainController).
-//
-//   dotnet run tools/probe/generators/rules.cs -- --out tools/probe/corpus/harness/RuleControllers.g.cs
-//
-// GeneratedHarnessTests in the conventions tests holds the committed file to this output.
-using System.Text;
-
-try
-{
-    File.WriteAllText(Arg(args, "--out"), Generate(), new UTF8Encoding(false));
-    return 0;
-}
-catch (GeneratorError e)
-{
-    Console.Error.WriteLine($"rules.cs: {e.Message}");
-    return 2;
-}
-
-static string Generate()
-{
-    // variant: the attribute it adds to the action (Cmp.Decorate's, as MVC declares it), and whether it answers KFault,
-    // whose Clash shares HFault's name, in place of GFault
-    (string Name, string Attribute, bool SameName)[] variants =
-    [
-        ("plain", "", false),
-        ("wo", ", WithoutFaults<HFault>(nameof(HFault.Bad))", false),
-        ("group", ", FaultStatus<HFault>(nameof(HFault.Clash), 422)", false),
-        ("declared", ", ProducesResponseType<ProblemDetails>(429)", false),
-        ("dup", "", true),
-    ];
-    var o = new List<string>
-    {
-        "// Generated by tools/probe/generators/rules.cs: controllers answering composed faults, one action per arity x response variant (C03, C05).",
-        "using CodoMetis.TypeKit;",
-        "using CodoMetis.TypeKit.AspNetCore;",
-        "using Microsoft.AspNetCore.Http.HttpResults;",
-        "using Microsoft.AspNetCore.Http;",
-        "using Microsoft.AspNetCore.Mvc;",
-        "namespace Probes;",
-        "public abstract class RuleCtlBase : ControllerBase",
-        "{",
-    };
-    foreach (var (name, attribute, sameName) in variants)
-    {
-        foreach (var arity in new[] { 2, 3 })
-        {
-            var second = sameName ? "KFault" : "GFault";
-            var faults = $"FaultProblem<HFault>, FaultProblem<{second}>" + (arity == 3 ? ", FaultProblem<SFault>" : "");
-            var method = (arity == 2 ? "Two" : "Three") + (sameName ? "K" : "");
-            o.Add($"    [HttpGet(\"c/{arity}/{name}\"){attribute}]");
-            o.Add($"    public Results<NoContent, {faults}> A{arity}{char.ToUpperInvariant(name[0])}{name[1..]}(int e) => Cmp.{method}(e).ToHttpResult();");
-        }
-    }
-    o.Add("}");
-    o.Add("[ApiController] public sealed class RuleApiController : RuleCtlBase { }");
-    o.Add("public sealed class RulePlainController : RuleCtlBase { }");
-    return string.Join("\n", o) + "\n";
-}
-
-static string Arg(string[] args, string name)
-{
-    var at = Array.IndexOf(args, name);
-    return at >= 0 && at + 1 < args.Length ? args[at + 1] : throw new GeneratorError($"{name} <path> is required");
-}
-
-sealed class GeneratorError(string message) : Exception(message);
diff --git a/tools/probe/generators/shapes.cs b/tools/probe/generators/shapes.cs
deleted file mode 100644
index 180afa84..00000000
--- a/tools/probe/generators/shapes.cs
+++ /dev/null
@@ -1,276 +0,0 @@
-// Writes tools/probe/corpus/harness/Shapes.g.cs, the probes' shape catalogue: one value object per
-// (shape.kind, shape.wrapped) of the axes file, the plain twin each is compared with, the registry of both, a
-// polymorphic base and derived type over each, and the source-generated context ProbeContext, which lists every
-// type a row holds a value object or its twin in: each shape (a struct one made nullable too, as http.nullability=nullable
-// declares it) at each shape.position in each shape.containing, and the
-// Option and Result over a value object that L06's rows hold under json.TypeInfoResolver=source-generated-context.
-//
-// One context, one declaration: System.Text.Json's generator runs once per declaration that carries [JsonSerializable], so
-// a second partial part of ProbeContext fails it. L06's carriers are listed from its rows, not for every shape: an Option and
-// two Results over every value object at every position would add some 16000 types and three minutes to the Samples' build
-// (measured 2026-10-17: 38 s before, 73 s with this context, 3 min 49 s with every carrier at every position).
-//
-//   dotnet run tools/probe/generators/shapes.cs -- --axes .claude/probe-axes.md --l06 tools/probe/corpus/rows/L06OffTheWireProbe.json.gz \
-//       --out tools/probe/corpus/harness/Shapes.g.cs
-//
-// The kinds, wrapped types, positions and containing types are the axes file's (its ```json probe-axes block); the
-// C# spelling of each wrapped type and its valid and refused samples are the table below, and a value the table does
-// not know is refused. GeneratedHarnessTests in the conventions tests holds the committed file to this output.
-//
-// The twin is the wrapped type as the value object holds it, without TypeKit: the same type at the value object's
-// nullability. A class value object over a value type admits null where its wrapped struct does not, so its twin is
-// the wrapped type made nullable (int? for a sealed record class over int); a struct value object over a value type,
-// and any value object over a class, faces the wrapped type itself. A struct value object over a class (string, Uri,
-// a record class) refuses a JSON null that its twin reads: no plain type refuses null there, and the claims cite it
-// (not-promised a-struct-refuses-a-json-null). The closed set travels as its member's name, so its twin is a string
-// (not-promised a-closed-set-is-a-string-enum, a-closed-set-key-is-its-name). The registry's Plain is the twin, and a
-// row's position and containing type are put around both alike (harness/Positions.cs, Pos.Twins).
-using System.IO.Compression;
-using System.Text;
-using System.Text.Json.Nodes;
-
-try
-{
-    var axes = AxesBlock(Arg(args, "--axes"));
-    var kinds = Values(axes, "shape.kind");
-    var wrapped = Values(axes, "shape.wrapped");
-    var positions = Values(axes, "shape.position");
-    var containing = Values(axes, "shape.containing");
-    var l06 = Rows(Arg(args, "--l06"));
-    File.WriteAllText(Arg(args, "--out"), Generate(kinds, wrapped, positions, containing, l06), new UTF8Encoding(false));
-    return 0;
-}
-catch (GeneratorError e)
-{
-    Console.Error.WriteLine($"shapes.cs: {e.Message}");
-    return 2;
-}
-
-static string Generate(IReadOnlyList<string> kinds, IReadOnlyList<string> wrappedKeys, IReadOnlyList<string> positions, IReadOnlyList<string> containing, List<Dictionary<string, string>> l06)
-{
-    var o = new List<string>
-    {
-        "// <auto-generated/> by tools/probe/generators/shapes.cs; probes' shape catalogue. Do not edit.",
-        "#nullable enable\n#pragma warning disable CMTK0014, CS8618, CS1591, CMTK0005, CMTK1000, CMTK0003",
-        "using System.Collections.Immutable;\nusing CodoMetis.TypeKit;\nusing CodoMetis.TypeKit.ValueObjects;\nusing CodoMetis.TypeKit.ClosedSets;\nusing System.Text.Json.Serialization;",
-        "namespace Probes.Shapes;",
-        "public enum PEnum { A, B, C }\n[Flags] public enum PFlags { P = 1, Q = 2, R = 4 }\npublic enum ShapeFault { Refused }",
-        "public sealed record PRec { public string A { get; init; } = \"\"; public int B { get; init; } }",
-        "public sealed partial class PSet : IClosedSet<PSet> { public static readonly PSet Alpha = new(); public static readonly PSet Beta = new(); }",
-    };
-
-    // One value object per kind and wrapped type; the closed set is the one PSet above.
-    var entries = new List<(string Kind, string WrappedKey, string Name, Wrapped W, Twin T)>();
-    foreach (var kind in kinds)
-    {
-        if (kind == "closed-set") continue;
-        foreach (var key in wrappedKeys)
-        {
-            var w = Wrapped.Of(key);
-            var n = $"V_{Ident(kind)}_{Ident(key)}";
-            o.Add(kind switch
-            {
-                "record-struct" => $"public readonly partial record struct {n} : IValue<{w.Type}>;",
-                "sealed-record-class" => $"public sealed partial record class {n} : IValue<{w.Type}>;",
-                "validated-struct" or "validated-class" =>
-                    $"public {(kind == "validated-struct" ? "readonly partial record struct" : "sealed partial record class")} {n} : IValidatedValue<{n}, {w.Type}, ShapeFault>\n{{\n" +
-                    $"    public static Result<{n}, ShapeFault> Create({w.Type} value) =>\n" +
-                    $"        EqualityComparer<{w.Type}>.Default.Equals(value, {w.Refused}) ? Result.Error(ShapeFault.Refused) : new {n}(value);\n}}",
-                _ => throw new GeneratorError($"shape.kind {kind} has no declaration here"),
-            });
-            entries.Add((kind, key, n, w, Twin.Of(kind, w)));
-        }
-    }
-
-    // A polymorphic base and derived type over each value object, PSet, and each twin. Their members are declared as the containers'
-    // are (Containers.g.cs), outside the nullable context, so a member admits null by its type alone on both sides, as the twin's
-    // nullability says, and json.RespectNullableAnnotations reads no annotation that one side has and the other does not.
-    o.Add("#nullable disable");
-    foreach (var e in entries) o.Add(Poly(e.Name, e.Name));
-    o.Add(Poly("PSet", "PSet"));
-    var twins = entries.Select(e => e.T).Append(Twin.ClosedSet).DistinctBy(t => t.Ident).ToList();
-    foreach (var t in twins)
-        o.Add($"[JsonPolymorphic] [JsonDerivedType(typeof(PDP_{t.Ident}), \"d\")] public abstract class PBP_{t.Ident} {{ }}\n" +
-              $"public sealed class PDP_{t.Ident} : PBP_{t.Ident} {{ public {t.Type} Value {{ get; set; }}{t.Initializer} }}");
-    o.Add("#nullable enable");
-
-    o.Add("public sealed record Entry(string Kind, string Wrapped, Type Vo, Type Plain, Func<object> Valid, Func<object?> RefusedFn, Type PolyBase, Type PolyDerived, Type PolyBasePlain, Type PolyDerivedPlain);");
-
-    // The registry: a refused sample only where Create refuses one.
-    o.Add("public static partial class Registry\n{\n    static partial void Fill(List<Entry> e)\n    {");
-    foreach (var (kind, key, n, w, t) in entries)
-    {
-        var refused = kind.StartsWith("validated", StringComparison.Ordinal) ? w.Refused : "null";
-        o.Add($"        e.Add(new Entry(\"{kind}\", \"{key}\", typeof({n}), typeof({t.Type}), () => {w.Valid}, () => {refused}, " +
-              $"typeof(PB_{n}), typeof(PD_{n}), typeof(PBP_{t.Ident}), typeof(PDP_{t.Ident})));");
-    }
-    o.Add($"        e.Add(new Entry(\"closed-set\", \"-\", typeof(PSet), typeof({Twin.ClosedSet.Type}), () => \"Alpha\", () => null, typeof(PB_PSet), typeof(PD_PSet), typeof(PBP_{Twin.ClosedSet.Ident}), typeof(PDP_{Twin.ClosedSet.Ident})));");
-    o.Add("    }\n}");
-
-    // The source-generated context: every value object and every twin at every position in every containing type, so a row
-    // under json.TypeInfoResolver=source-generated-context runs on the context alone, whatever shape it holds.
-    // a struct value object made nullable too: under http.nullability=nullable a row holds V? (and its twin T?) at its position
-    var structs = entries.Where(e => e.Kind is "record-struct" or "validated-struct").ToList();
-    var members = entries.Select(e => (Type: e.Name, Struct: e.Kind is "record-struct" or "validated-struct", Poly: $"PB_{e.Name}", Key: e.Name))
-        .Concat(structs.Select(e => (Type: e.Name + "?", Struct: true, Poly: $"PB_{e.Name}", Key: e.Name)))
-        .Append((Type: "PSet", Struct: false, Poly: "PB_PSet", Key: "PSet"))
-        .Concat(twins.Select(t => (Type: t.Type, Struct: t.Struct, Poly: $"PBP_{t.Ident}", Key: t.KeyType)))
-        .ToList();
-    var listed = new List<string>();
-    foreach (var m in members)
-    {
-        listed.Add(m.Type);
-        foreach (var position in positions)
-            if (position != "root")
-                foreach (var c in containing)
-                    listed.Add(Holder(position, c, m.Type, m.Struct, m.Poly, m.Key));
-    }
-    // L06's carriers, as its rows hold them under the context: the Option or Result over the value object, at the row's position in its
-    // containing type, its polymorphic stand-in L06's own (JsonFamilyShapes.g.cs, json-family.cs)
-    foreach (var r in l06.Where(r => r.GetValueOrDefault("json.TypeInfoResolver") == "source-generated-context"))
-    {
-        var kind = r["shape.kind"];
-        var v = kind == "closed-set" ? "PSet" : entries.FirstOrDefault(e => e.Kind == kind && e.WrappedKey == r["shape.wrapped"]).Name
-                ?? throw new GeneratorError($"L06's rows hold {kind} over {r["shape.wrapped"]}, which the axes' shapes do not");
-        var (key, carrier) = r["or.shape"] switch
-        {
-            "Option" => ("O", $"Option<{v}>"),
-            "Result-T-E" or "Task-of-Result" or "ValueTask-of-Result" => ("RTE", $"Result<{v}, ShapeFault>"),
-            "Result-E" => ("RE", $"Result<{v}>"),
-            var shape => throw new GeneratorError($"or.shape {shape} has no carrier here"),
-        };
-        var position = r["shape.position"];
-        listed.Add(position == "root" ? carrier : Holder(position, r["shape.containing"], carrier, true, $"global::Probes.Json.L06PB_{v}_{key}", carrier));
-    }
-    o.Add("[JsonSourceGenerationOptions]");
-    var i = 0;
-    foreach (var t in listed.Distinct(StringComparer.Ordinal))
-        // a generic, array or nullable type gets a name of its own (two would collide); a plain type keeps the serializer's
-        o.Add(t.Contains('<') || t.Contains('[') || t.EndsWith('?') ? $"[JsonSerializable(typeof({t}), TypeInfoPropertyName = \"T{i++}\")]" : $"[JsonSerializable(typeof({t}))]");
-    o.Add("public partial class ProbeContext : JsonSerializerContext { }");
-
-    return string.Join("\n", o) + "\n";
-}
-
-static string Poly(string name, string type) =>
-    $"[JsonPolymorphic] [JsonDerivedType(typeof(PD_{name}), \"d\")] public abstract class PB_{name} {{ }}\n" +
-    $"public sealed class PD_{name} : PB_{name} {{ public {type} Value {{ get; set; }} = default!; }}";
-
-// The type a row's position holds m in, as harness/Positions.cs builds it: m itself at the root, else a container of
-// Containers.g.cs around m, its list, array, dictionary, patch or polymorphic base. A dictionary key is never null, nor is
-// what a Patch<T> holds (T : notnull), so there a nullable twin is the type it holds (key).
-static string Holder(string position, string containing, string m, bool isStruct, string polyBase, string key)
-{
-    var style = position switch { "field" => "F", "record-ctor-parameter" => "C", "required-init" => "R", _ => "P" };
-    var member = position switch
-    {
-        "property" or "field" or "record-ctor-parameter" or "required-init" => m,
-        "nullable-property" => isStruct && !m.EndsWith('?') ? m + "?" : m,
-        "list-element" => $"List<{m}>",
-        "read-only-list-element" => $"IReadOnlyList<{m}>",
-        "array-element" => $"{m}[]",
-        "immutable-array-element" => $"ImmutableArray<{m}>",
-        "dictionary-key" => $"Dictionary<{key}, int>",
-        "dictionary-value" => $"Dictionary<string, {m}>",
-        "in-patch" => $"Patch<{key}>",
-        "polymorphic-derived-property" => polyBase,
-        _ => throw new GeneratorError($"shape.position {position} has no holder here"),
-    };
-    var n = containing switch
-    {
-        "class" or "record-class" or "struct" or "record-struct" or "generic-type" => containing.Replace('-', '_'),
-        _ => throw new GeneratorError($"shape.containing {containing} has no holder here"),
-    };
-    return containing == "generic-type" ? $"Cn_{n}_{style}<{member}, int>" : $"Cn_{n}_{style}<{member}>";
-}
-
-static string Ident(string s) => s.Replace('-', '_').Replace('.', '_');
-
-// A rows file of `prober rows`: gzipped JSON, {"claim": ..., "rows": [{"row": {axis: value}}, ...]}.
-static List<Dictionary<string, string>> Rows(string path)
-{
-    using var gzip = new GZipStream(File.OpenRead(path), CompressionMode.Decompress);
-    var rows = JsonNode.Parse(gzip)?["rows"] as JsonArray ?? throw new GeneratorError($"{path} has no rows");
-    return
-    [
-        .. rows.Select(r => (r?["row"] as JsonObject ?? throw new GeneratorError($"{path}: an entry without a row"))
-                   .ToDictionary(p => p.Key, p => p.Value?.GetValue<string>() ?? throw new GeneratorError($"{path}: {p.Key} is null"), StringComparer.Ordinal)),
-    ];
-}
-
-static string Arg(string[] args, string name)
-{
-    var at = Array.IndexOf(args, name);
-    return at >= 0 && at + 1 < args.Length ? args[at + 1] : throw new GeneratorError($"{name} <path> is required");
-}
-
-static JsonObject AxesBlock(string path)
-{
-    const string marker = "```json probe-axes";
-    var text = File.ReadAllText(path);
-    var at = text.IndexOf(marker, StringComparison.Ordinal);
-    if (at < 0) throw new GeneratorError($"{path} has no {marker} block");
-    var body = text[(at + marker.Length)..];
-    return JsonNode.Parse(body[..body.IndexOf("```", StringComparison.Ordinal)]) as JsonObject
-           ?? throw new GeneratorError($"the {marker} block of {path} is not a JSON object");
-}
-
-static List<string> Values(JsonObject block, string axis) =>
-    block["axes"]?[axis] is JsonArray values
-        ? [.. values.Select(v => v?.GetValue<string>() ?? throw new GeneratorError($"{axis} holds a null"))]
-        : throw new GeneratorError($"the axes file has no axis {axis}");
-
-/// <summary>A wrapped type: its C# spelling, a value Create keeps and the one it refuses.</summary>
-sealed record Wrapped(string Key, string Type, string Valid, string Refused)
-{
-    static readonly Dictionary<string, Wrapped> Table = new(StringComparer.Ordinal)
-    {
-        ["string"] = new("", "string", "\"alpha\"", "\"SECRET-7f3a\""),
-        ["Guid"] = new("", "Guid", "Guid.Parse(\"11111111-1111-1111-1111-111111111111\")", "Guid.Empty"),
-        ["int"] = new("", "int", "42", "-1"),
-        ["long"] = new("", "long", "4200000000L", "-1L"),
-        ["byte"] = new("", "byte", "(byte)7", "(byte)255"),
-        ["ulong"] = new("", "ulong", "4200000000UL", "0UL"),
-        ["decimal"] = new("", "decimal", "7.80m", "-1m"),
-        ["double"] = new("", "double", "1.5", "-1.0"),
-        ["bool"] = new("", "bool", "true", "false"),
-        ["char"] = new("", "char", "'a'", "'x'"),
-        ["DateTime"] = new("", "DateTime", "new DateTime(2026,10,15,8,30,0,DateTimeKind.Utc)", "DateTime.MinValue"),
-        ["DateTimeOffset"] = new("", "DateTimeOffset", "new DateTimeOffset(2026,10,15,8,30,0,TimeSpan.Zero)", "DateTimeOffset.MinValue"),
-        ["DateOnly"] = new("", "DateOnly", "new DateOnly(2026,10,15)", "DateOnly.MinValue"),
-        ["TimeOnly"] = new("", "TimeOnly", "new TimeOnly(8,30,15)", "TimeOnly.MinValue"),
-        ["TimeSpan"] = new("", "TimeSpan", "TimeSpan.FromMinutes(90)", "TimeSpan.MinValue"),
-        ["enum"] = new("", "PEnum", "PEnum.B", "(PEnum)99"),
-        ["flags-enum"] = new("", "PFlags", "PFlags.P | PFlags.Q", "(PFlags)0"),
-        ["Uri"] = new("", "Uri", "new Uri(\"https://example.com/a\")", "new Uri(\"https://example.com/refused\")"),
-        ["NodaTime.Instant"] = new("", "global::NodaTime.Instant", "global::NodaTime.Instant.FromUtc(2026,10,15,8,30)", "global::NodaTime.Instant.MinValue"),
-        ["own-record-class"] = new("", "PRec", "new PRec { A = \"x\", B = 1 }", "new PRec { A = \"refused\", B = 0 }"),
-    };
-
-    public static Wrapped Of(string key) =>
-        Table.TryGetValue(key, out var w) ? w with { Key = key } : throw new GeneratorError($"shape.wrapped {key} is not in shapes.cs's table");
-}
-
-/// <summary>
-/// A value object's twin: the wrapped type at the value object's nullability (see the head of this file), its identifier in
-/// the stand-ins' names, whether it is a struct, the type a dictionary key of it is, and its stand-in's initializer.
-/// </summary>
-sealed record Twin(string Type, string Ident, bool Struct, string KeyType, string Initializer)
-{
-    static readonly HashSet<string> Classes = new(StringComparer.Ordinal) { "string", "Uri", "PRec" };
-
-    /// <summary>The closed set's twin: the member's name, a string.</summary>
-    public static readonly Twin ClosedSet = new("string", "string_", false, "string", " = \"\";");
-
-    public static Twin Of(string kind, Wrapped w)
-    {
-        var valueType = !Classes.Contains(w.Type);
-        var classVo = kind is "sealed-record-class" or "validated-class";
-        var ident = w.Key.Replace('-', '_').Replace('.', '_');
-        return valueType && classVo
-            ? new($"{w.Type}?", ident + "_N", true, w.Type, "")
-            : new(w.Type, ident, valueType, w.Type, " = default!;");
-    }
-}
-
-sealed class GeneratorError(string message) : Exception(message);