Repository navigation
v0.25.0
Pre-release[0.25.0] - 2026-10-20
Calor 0.25 is an interoperability release. It changes how the C# → Calor converter
(calor convert, calor migrate, the MCP tools and the CSharpToCalorConverter library)
handles six groups of everyday C#: ref/out/in arguments, interpolated strings, local
functions, iterator properties, array expressions, and the reports of what stays C#. The
language gains native local functions and two new errors (Calor0211, Calor0212). The
website gains a guide to converting C#, and CI now compiles its examples.
These notes were frozen with the release candidate on 2026-10-20, before the 0.25 acceptance
review (A1, #1430). A release can publish only after that review accepts the candidate, and
the notes cannot change after the freeze. At the freeze:
- Nothing was released. There was no v0.25.0 tag, NuGet package or GitHub release. The
newest release on NuGet was 0.24.0. - No family was ready. The 0.25 scope packet (the frozen cases each of the six converter
families must pass) recorded 0 of 6 as ready. A family is ready only when its cases pass on the
frozen candidate and the maintainer approves. The results below were measured before the freeze. - 0.24's checks had to pass again. The 0.24 evidence review (#1408) ended
MILESTONE-FAILED
(see 0.24.0), so this candidate must re-pass 0.24's proof, provenance and release checks on its
own commit. No 0.24 approval or record is reused. - The candidate was re-frozen once. The first candidate, frozen on 2026-10-19, did not pass
that re-proof. Its determinism run (the same tests repeated on five platforms, with the results
compared) found no disagreement, but one slow macOS runner hit its 50-minute limit, so the run
was incomplete. The re-proof also found that one interpolated-string case (F2-INTERP-09) had
registered corpus counts measured before the other families merged, and that one iterator case
(F4-ITER-04) cannot be measured on any command. The maintainer amended all three: the macOS
limit is now 70 minutes, the counts are re-registered to the candidate, and F4-ITER-04 is
recorded as not measured. The candidate was re-frozen on 2026-10-20, and the re-proof must pass
on it. - The three release-process gaps from 0.24 were closed. #1545, #1546 and #1547 closed on
2026-10-19, before the freeze (see "Release process" below). Acceptance requires them closed. - Independence is reduced. OpenAI Codex reviewed each change, and the maintainer approved
and merged it. No reviewer independent of the two took part, so every 0.25 evidence claim is
at most bounded. - Known open defects. A private base-class member named
@defaultmakes a converted
out varfail to compile withCS0122(#1573); the failure is loud, not silent. Reading a
field of a struct array element still needs--permissive-effects.
This release publishes no new benchmark results.
Added
- Native local functions (#847). A
§Fwritten inside a§For§MTbody is a local
function. Calor emits it in place as a C#staticlocal function. Its name is visible in
the whole body, before the declaration too, and a bare call such as§C{Add}names it
even when the class has a methodAdd. It cannot capture the enclosing locals,
parameters orthis; a capture is a compile error (CS8421). Its body's effects are
charged to the enclosing callable. Other placements and shapes (nested in a block,
§E, contracts, type parameters, refinement types,§PROOF,§YIELD) are rejected
with the new diagnosticCalor0211. So is a use as a value in a position whose effect
row Calor does not check, such as inside??, an array or a qualified store. See
"Local Functions" on the website's structure-tags syntax reference page.
ref, out and in arguments are checked before C# generation (#943)
Calor already had §A{ref} x, §A{out} x and §A{in} x. This release follows the
contract in docs/plans/v0.25-refout-contract.md (#1427).
- New error
Calor0212(InvalidByReferenceOperand). Passing something C# cannot pass by
reference is now a Calor error: a literal, a computed value such as(+ v 1), a call
result, a property, an indexer element,this, a readonly field outside its constructor,
or aninparameter passed asreforout. Before, these failed only when the generated
C# was compiled (Calor1002). - More valid operands compile. An array element (
§A{ref} §IDX{arr} 1) and a field
through a receiver (§A{ref} k.n) now compile in module functions too.§A{out} _is a
discard in module functions. It is rejected withCalor0212when a variable named_is
in scope, because C# would write to that variable. - Writes through
ref/outare charged as effects. Passing an array element, a field
through a receiver, or a dotted path asreforoutnow chargesmut, the same as
§ASSIGNto it. Before, a function declared§E{alloc}could write an array element
throughrefwithout declaringmut. That was an effect laundering bug: a write the effect
checker did not see. Code with this bug now fails withCalor0410; addmutto§E{...}. - Null checks on parameters that may share storage end earlier. In a function with two or
more by-reference parameters, writing one ends a null check on the others. With one or more
by-reference parameters, any call, construction, or field, element or property read ends it
too. Code that relied on the old behavior now reportsCalor0272. calor convertkeeps by-reference identity.Bump(ref pts[0].X)on an array of
structs now passes the element's field itself, so the callee's write is kept.
C#out var nbecomes a mutable binding declared just before the statement, when it
appears in an expression statement such asint.TryParse(s, out var n);, a local
declaration, areturn, or anifcondition directly in a block, its type is known, and
its name clashes with nothing in scope. The binding starts atdefault, so the next line is
never read as its value. Other forms, including chained assignments and code with a member
nameddefault, keep their statement or member as C#. Before, anout varinside?:became
inline§CS{...}, and one in awhileheader was declared outside the loop.- Shapes without a native form stay C#. These are ref locals and ref returns (block or
=>bodied), conditional refs,scopedandref readonlyparameters,this ref/this in
extension calls, by-reference delegates and lambdas, by-reference constructor and indexer
arguments, calls that omitin, and method-genericout Tparameters. A flow attribute
such as[NotNullWhen]on anoutparameter is copied to the native declaration but has
no effect on Calor's null checks. A C#refargument to aninparameter now converts to
§A{in}. calor feature-checkchanges.out-varis nowPartial, because only the forms above
are lowered. Theref-parameterandout-parameterentries no longer suggest tuples or
Result<T, E>, andin-parameternames the call sites that stay C#.ref-expressionand
multidim-arrayno longer claim that every form converts.- Effect on converted real-world code. Over the three vendored corpora (MediatR, Serilog,
FluentValidation), 33 more members and types are kept as C#. In 31, anout varcannot be
lowered: the one-file conversion cannot resolve its type, it sits in a lambda, or part of its
statement already stays C#. The other 2 declare a method-genericout Tparameter. Before,
most of the first group became an untyped binding that failed withCalor0250. The number of
expressions the binder visits over the corpora drops from 35,177 to 34,371 (2.3%). That count
includes references the converter generates and expressions kept as C#, so it does not measure
how much converts natively. 10 more of 364 modules now get through binding to effect checking.
These are checked by tests that compile every case in the contract, and by convert, compile
and run comparisons on the CLI, calor migrate and MCP conversion paths. All 57 Calor cases
in the contract now hold. One registered witness (D1-LV-03) had declared a property named
i32 by mistake, so it could not show the property refusal; a contract amendment corrected it,
and it now reports Calor0212. One case stays open: a struct array element's field read still
needs --permissive-effects. The 0.25 scope packet records this family as in progress, not ready.
Interpolated strings keep their C# target type (#906)
- Overload selection is kept. In C#,
Kind($"k={x}")can callKind(FormattableString)
instead ofKind(object), depending on the interpolated string's target type.calor convert
now wrapsFormattableStringandIFormattabletargets in an explicit cast, so the converted
program calls the same overload. Before, a method whose only overload took a
FormattableStringmade the converted Calor fail to compile, and the CLI fell back to keeping
the whole class as C#. - Custom interpolated-string handlers are kept as C# at conversion time. A call such as
Log($"a{x}b"), whereLogtakes an[InterpolatedStringHandler]type, keeps its enclosing
statement or member as C# interop on every surface. Before, MCPcalor_convertproduced a
Calor string argument that the compiler then rejected (Calor0208). - Edge targets are kept as C# instead of miscompiled.
FormattableString.Invariant($"text")
(aFormattableStringtarget with no holes) andLog($"a{x}" + $"b{y}")(a concatenation
passed to a handler) keep their enclosing statement or member as C# interop. - Holes outside the native subset are marked as C#. Holes made of names, string, character,
boolandintliterals,doubleliterals with a fractional part, dotted member access,
operators,nameof,typeof, and calls with a dotted target and positional arguments convert
natively. A digit-only hole such as{1}is written${INT:1}, because${1}reads back as
literal text. Other holes, such as{items[i]},{x?.Name}or
{obj.GetType().Name}, now keep their original C# text as§CS{...}inside the hole and are
counted as interop. Before, the converter mixed C# and Calor syntax in such holes, which could
produce C# that did not compile. - Hole evaluation order is kept. A hole containing a string literal, such as
$"q={Tag("t")}", is no longer moved into a temporary ahead of the statement. That move ran
Tagbefore earlier arguments and even when an enclosing?:skipped the string. - Holes are analyzed. A call written in C# form inside a hole, such as
"${Console.ReadLine()}", is now an ordinary call, so effect checking sees it. A pure (§E{})
function containing it now fails withCalor0410(undeclared effect). Before, it compiled with
only theCalor0419warning that its effects were assumed. Holes in other forms still get
that warning. This can turn existing code that compiled with a warning into an error; declare
the effect to fix it. - Diagnostics point at the hole. An error inside a hole, such as an undefined name, is now
reported at the hole's line and column instead of line 1, column 1. string-interpolationis nowPartialincalor feature-check, because handler targets
are not converted natively. New entries:string-interpolation-to-string(Full),
string-interpolation-formattableandstring-interpolation-hole(Partial), and
string-interpolation-handlerandstring-interpolation-formattable-constant
(NotSupported).
These are checked by convert, compile and run tests that compare the converted program's output
with the original C# on the CLI and MCP conversion settings, including de-DE and fr-FR
formatting. The 0.25 scope packet records this family as in progress, not ready.
Conversion reports name the path that kept each member as C# (#1144)
When the C# → Calor converter cannot produce working Calor for a member, it keeps the
original C# in a §CSHARP block. Reports now say which mechanism did that, on every
conversion surface: calor convert, calor migrate, the MCP tools calor_convert,
calor_migrate and calor_batch, and the CSharpToCalorConverter library.
- Fixed: a wrong label.
calor convertprinted "(N via --passthrough fallback)" for every
rescued member, even when you had not passed--passthrough. The rescue is on by default
on the command line. The line now reads, for example,
Preservation paths: 2 by automatic rescue (round-trip-failure: 2; no passthrough request needed). - New: path and trigger fields. Each recorded loss now has
path(interop,rescue,
passthrough,lossyordropped). Rescues and passthroughs also havetrigger
(parse-failure,round-trip-failureorunsupported-construct) andenabledBy(the
default or option that allowed it). A new per-fileconversionPathsobject (schema
version 1) gives the outcome (native,preserved,lossyorrefused), a count per
path, the triggers, and whether rescue and passthrough were on. All fields are additive;
existing fields and counts are unchanged. - Fixed: a custom module name disabled the rescue. With MCP
calor_convert, a
moduleName(or aninputPath, which derives one) stopped the rescue from finding a
global-namespace type's original C#, so the call failed.calor_batchwith
moduleNameOverridehad the same problem. These now rescue like other calls. - Fixed:
calor_convertwithmode: "roundtrip"ignoredpassthroughOnError. It now
honours it, like theconvertandvalidatemodes, and its result gains alossSummary. - Changed: a
calor_batchabort is now JSON. WithskipOnError: false, the abort used to
return only an error sentence. It now returns JSON with that sentence inerror, plus
preservationPathsand each file'sconversionPaths;isErroris stilltrue. - Unchanged, now documented: defaults differ by surface.
calor convertrescues members
that fail the C# round trip by default;calor_convertand the library do not, and say
so in their reports (rescueUnusableMembers: false).calor migrate,calor_migrateand
calor_batchrescue only members whose Calor does not parse.calor_batchdoes so even
withpassthroughOnError; the other two have no passthrough option. No default changed
in this release.
Changed
- C# local functions convert natively when they are non-capturing (#847). Before,
every member with a local function was preserved as a§CSHARPblock, and its callers
needed--permissive-effectsto compile. Now a local function declared directly in a
method body, without capture, attributes, type parameters,async/unsafe/extern,
yield, nested local functions orref/out/in/params/default parameters,
becomes a nested§Fin the same method. The three registered cases (F3-LOCAL-01 to 03)
convert natively on all 8 measured surfaces, compile with default options and print
the same result as the original. Capturing, generic, async and iterator local
functions are still preserved as§CSHARPand reported aslocal-function. The
local-functionfeature is nowPartialinstead ofNotSupported.
Fixed
-
--format json --verbosenow keeps stdout a single JSON document. Three commands
printed--verboseprogress text to stdout before the JSON envelope, so a program that
parsed stdout failed.calor converton a C# file printedConverted N nodesand member
counts;calor verifyprinted compiler phase lines such asLexer produced N tokens;
andcalor benchmark <directory>printedBenchmarked: <name>. In JSON mode this text
now goes to stderr, as the rest of the human-readable report already did. The JSON
content and text-mode output do not change. Tests pin the same contract for every
command that has both--formatand--verbose: the root compile command,convert,
format,lint,verify,ids check,assess,analyze-convertibility,
benchmarkandwatch(one JSON document per stdout line). (calor migratehas no--formatoption; its JSON report goes to a file.) -
calor assessandcalor coverageno longer sayrefandoutparameters are
unsupported. Since #943 they convert natively, but the migration analyzer behind these
commands (and MCP's analysis tools) still described them as "not yet supported", and
out varthe same way. The descriptions now say what converts and which shapes stay C#
(for example ref returns, method-genericref T, and anout varinside a lambda). The
constructs are still listed, with the same names and counts, because those shapes keep
part of a file as C#. Scores do not change. -
Expression-bodied compound assignments keep their operator.
void M() => Log += s;
was converted toLog = swith no reported loss. It now converts to a compound
assignment (§ASSIGNis no longer used for+=,-=, and so on in this position). -
A local or parameter now shadows a same-named function in calls. In
§C{Add} §A 1 §/C, if the innermost declaration namedAddis a local or a parameter
(for example aFunc<i32, i32>), the binder now treats the call as a delegate
invocation, as C# does. It used to resolveAddto a same-named class method or
module function, so overload errors and effect charges came from the wrong callee. -
C# → Calor conversion turned whole-number
doubleliterals into integers (#1528).
double r = n / 2.0;converted to(/ n 2), which is integer division whennis anint.
The converter now writes2.0, so the division stays floating-point. The same fix covers
attribute arguments ([Kind(2.0)]no longer picks anintoverload) and keeps
default(float)anddefault(decimal)at their own width (SINGLE:0,DEC:0). -
C# iterator properties and indexers no longer convert to illegal Calor (#1139). A getter
that usesyield returnoryield breakis a C# iterator accessor. Calor has none:
§YIELDinside a§GETis errorCalor0209. The converter used to emit exactly that. Only
the CLI's post-conversion rescue hid it; the MCPcalor_converttool and the library API
returned Calor that failed to compile. Now the converter keeps the whole member as a
§CSHARPblock and reports aniterator-accessorloss. The output is the same on
calor convert,calor migrate, MCPcalor_convertand the library, with or without
passthrough, and it compiles with default options. Laziness,finallyon dispose, and
exception timing match the original in 2 of 2 registered fixtures on 6 surfaces (3 CLI, 3
MCP). With--no-fallbackthe conversion fails and names the feature. One registered case is
not measured: the three FluentValidation test modules with project references. Single-file
conversion refuses them because their references (xUnit, project types) cannot be resolved, and
project migration writes nothing because it refuses the whole project over unrelated files. Iterator methods
still convert natively to§YIELD. See "Iterator Properties and Indexers" on the
calor convertdocs page. -
C# 13 partial properties and indexers are preserved instead of breaking the build. Calor
has no partial members, so a defining declaration such aspublic partial int Q { get; }
used to become a second, auto-implemented property (C# errorCS0102). The converter now
keeps everypartialproperty or indexer declaration as§CSHARPand reports a
partial-propertyloss, oriterator-accessorwhen any part in the same file yields. Parts
split across files are each preserved, but only parts in the same file share the
iterator-accessorlabel. -
Arithmetic on named refinement types (#1515). A named refinement type is declared with
§RTYPE, for example§RTYPE{r1:NatInt:i32} (>= # INT:0). Before this fix, the type checker
rejected arithmetic on such a value withCalor0202, because it did not unwrapNatIntto its
base typei32. Inline refinements (§I{i32:x} | (>= # INT:0)) already worked. Now operators
see a named refinement as its base type:+ - * / %, unary minus, comparisons, bitwise and
shift operators, logical operators on aboolrefinement, and loop bounds. The result has the
base type, not the refinement, becauseNatInt - NatIntcan be negative. The exception is
increment and decrement (inc,dec,post-inc,post-dec) of a variable: they keep the
refined type, because the write back into the variable is itself checked. Incrementing a
collection element or field gives the base type. Writing a result
back into a refined variable or return is still checked: you get the same verification
obligation and runtime guard as with an inline refinement. Binding a plain base value with
§B{x:NatInt}is still rejected by the type checker, as before. -
decimalarithmetic result type. The type checker typeddecimal + decimalasi32. It
now types it asdecimal, as C# does. So§B{x:i32} (+ a b)withdecimaloperands is now a
type error (Calor0202) instead of a failure in the generated C#. A nested mix such as
(+ (+ a b) f)with anf64operand is now rejected like the directdecimal + f64case.
When the other operand is a type the checker does not model, such as a class with its own+
operator, the checker still leaves the result to the C# compiler. -
A
§PROOFcan now refer to a§Blocal (#1516).§PROOFstates a fact the compiler
tries to prove; when it succeeds, the obligation is discharged and the runtime check is
removed. Before this fix, any§PROOFthat named a local, such as
§B{newBalance:i32} (- balance amount)then§PROOF{p1} (>= newBalance INT:0), was reported
Unsupportedwith "Unknown variable", even when it was easy to prove. The solver now uses the
local's defining expression, but only when that is exactly the local's value at the proof:- the local is immutable (
§B, not§B{~...}), bound once, and never reassigned or passed byref; - its binding runs on every path to the proof (it comes earlier in the same block, or in a block
that encloses the proof); - its definition uses only literals, operators, parameters the function never changes, and
other locals that meet these rules.
The solver also refuses a local whose C# name collides with another variable (
a-bandab
both becomeab). It refuses all locals in a function when a refinement predicate (a
§RTYPEor parameter refinement) does more than compare names and literals, or when the
module declares operator overloads. In these cases, code the solver cannot see could change
the local.Any other local still makes the proof
Unsupported, and the runtime check stays. The message
now says which local and why, for example "local 'm' is mutable". If the proof needs the
local's definition to finish without integer overflow, it is reportedAssumed, not
discharged, and the runtime check stays. - the local is immutable (
A task-first guide to converting C# (#1429)
A new website guide, "Converting C#: What Stays C# and Why",
walks through the C# features the 0.25 converter changes: ref/out/in calls such as
TryParse and TryGetValue, interpolated-string target types, local functions, arrays in
expressions, and iterator properties. For each one it shows real converter output, what stays C#,
and what the report says. Each converted block on the page is checked in CI against the
converter's actual output, and each complete program among them is also compiled. The convert, migrate, MCP, feature-check, self-check and
structured-output pages now state each surface's defaults (calor convert rescues round-trip
failures by default; MCP calor_convert needs passthroughOnError: true; project migration
never rescues them), how to read native and interop counts, and what a partial or refused
conversion returns.
Corrections found while checking the pages against the converter:
- Four
#943defects, fixed in the same release (see the#943entry):out varin a call
statement failed the C# round trip, an expression-bodied ref return lost itsref, four
calor feature-checkdescriptions did not match the converter, andref a[Next()]was
reported asin-parameter.yield-return(methods only) is still a listed gap. docs/cli/feature-check.mdno longer listsstring-interpolationas fully supported, and its
example now shows current output.
Website examples are now checked in CI (#1143)
calor self-check docs now reads website/content/**/*.mdx, not only docs/. It already runs
on every pull request, so a wrong website example now fails CI.
- Complete programs compile. A
calorcode block whose first line starts with§Mis
compiled the waycalor --input file.calrcompiles it, including the check of the generated
C#. It must report no errors. 49 programs on 96 pages are checked. - Failing examples say how they fail. An example meant to fail is labelled with its
diagnostic codes, for exampleexpect=Calor0272. The check fails if the compiler reports any
other error or warning code, or if the text around the example does not name the code.
Multi-file examples are compiled together withgroup=. - Quoted compiler output is real or labelled. A block marked
outputmust match the
diagnostics the example above it produces. Output that is not checked, such ascalor query
results and MCP responses, is markedillustrative, and the site now shows it as "Example
output (not checked)". A block that looks like tool output and has neither label fails. - Diagnostic codes, keywords and versions. Website pages now get the same checks as
docs/: every citedCalorNNNNcode exists, every§keyword exists, and no page
hardcodes the current version. The changelog page is excluded because it records past
releases.
The new check found 11 website examples that did not compile. This change fixes them:
- 3 in the nullability guide were intentional failures; they are now labelled.
- 4 used old syntax:
§IFwithout an ID (2), a C# line inside a Calor block, and←
annotations inside code. - 2 in the cross-module effects guide used undefined types and a call with a missing argument,
and could only be compiled as a pair. They are now one consistent two-file example, and its
quoted output is checked. - 2 refinement-type examples did arithmetic on named refinement types (
§RTYPE), which the
type checker then rejected (Calor0202). They were rewritten with inline refinements. A later
fix in this release (#1515, under "Fixed") makes that arithmetic type-check.
The 0.25 baseline counted 13 failures; the other 2 were method fragments (§MT), which are not
complete programs. This change also fixes 5 stale keyword references in prose (§FOREACH twice,
§MATCH, §CAST, §WHILE) and replaced
an invented error format on the compile page with real, checked output. The MCP walkthrough
in the dependent-types tutorial showed a response its example could not produce; it now shows
responses captured from the MCP server. The refinement-type pages now say that a default
calor compile does not run the obligation solver (the calor_refine MCP tool does). New findings use
Calor1332–Calor1334.
C# array expressions (#1132)
- C# array expressions now convert to native Calor and keep C# evaluation order (#1132).
An array created inside an expression (areturn, a call argument, a?:branch, or a field
or property initializer) now converts to Calor instead of being kept as C#. Before, the
converter wrotereturn new T[,] { … }as a block bound to a name that the generated C# never
declared, so the C# failed to compile (CS0103,CS0201). Arrays in a?:branch did not
parse. In both cases, the only thing that saved the conversion was the post-conversion rescue
(§CSHARP, which keeps the original C# verbatim).- Elements are evaluated once, left to right, where the C# had them. The unselected
?:branch
and the right operand of&&/||are still skipped. Before, elements, sizes and arguments
could be moved into temporaries that ran before earlier parts of the same statement. For
example,int[] a = { x, SetX(), x }read the newxin slot 0, andnew int[n, Next()]
readnafterNext()ran. - New Calor forms: an inline
§ARR2D{id:id:T} §ROW … §/ARR2D{id}, a sized§ARR2Dwith
§ROWlines for rank 3 and up (§ARR2D{id:id:i32:2:1:2}), and(§IDX2D g i j).Memberfor
a member of an element. Jagged arrays keep their element type and rank order
(new int[2][],new int[,][]). A bareT[,] g = { … }initializer is a rectangular array.
new[] { F(), G() }keeps its element type instead of becomingobject[].new T[0]and
{ }create fresh arrays instead of sharingArray.Empty<T>(). - Names the converter generates (
_hoist000,arr2d004) skip every identifier in the source
and in the other files of a project migration. A user local named_hoist000is no longer
rebound (Calor0260). - Some shapes cannot be written in place. They stay C# and are reported as a conversion loss.
An assignment used as an element, index or size is reported as
conditional-expression-hoisting; before, it ran twice. An element that Calor writes as a
block is reported asarray-element-block. That covers a collection initializer such as
{ new List<int> { 1 }, 2 }, which before lost the list and produced a one-element array.
It also covers a multi-line element such as an anonymous object in a rectangular array row. - Effect checking: the elements of
§ARR2Drows are now charged. Before, they were not
inferred, so a row could hide an effect its function did not declare. Effects of array
members such asGetLengthandRankare unchanged. On a receiver typed as an array
(i32[],i32[,]) they are still unknown calls, so a function that calls one reports
Calor0410(an effect used but not declared) unless it declares that effect or is compiled
with--permissive-effects. Two cases resolve through Calor's built-in effect manifests
instead, as before: a receiver declared asSystem.Array, and an array whose element type
is in a namespace the manifests give a default (for exampleSystem.Threading.Tasks.ValueTask[]).
- Elements are evaluated once, left to right, where the C# had them. The unselected
Release process
These change how Calor is published, not the compiler. The release gate (#1410) lets a release
publish only with an adjudication identity: the accepted commit plus the hash of its record.
- #1545. Publishing to NuGet now uses nuget.org Trusted Publishing: the publish job exchanges a
short-lived GitHub OpenID Connect token for a NuGet key, and no NuGet API key is stored in
GitHub. The trusted-publishing policy requires thenuget-releaseenvironment, which onlymain
can use, so the publish workflow kept in an older tag cannot obtain a key. On 2026-10-19 the
read-only settings check (scripts/check_release_credentials.py --live) reported the gap
closed; one setting, the Actions workflow permissions, was confirmed by a recorded maintainer
attestation because the API does not expose it to the check. - #1546. The gate checks on every run that this notes section in the candidate hashes to the
adjudicated notes (G014). So these notes had to be final at the freeze. - #1547. Publishing a release no longer publishes benchmark results. That needs a separate
manual run and an approval in the acceptance record (G015). - The release jobs install exactly .NET SDK 10.0.401, and the website no longer fetches its fonts
from Google Fonts at build time. - The release jobs also run the C# compiler on that SDK's own .NET runtime (10.0.12). The compiler
records its runtime version in every debug-symbol file, and that changes the compiled assembly's
identity, so package bytes depended on which newer runtime the build machine had. The jobs now
remove any newer 10.0 runtime from their private install and fail if one remains.