# Changelog

## Score

- CAI 60 → 59 (-1.5)
- Rubric changed (rubric-2026.10.1 → rubric-2026.10.5) — scores are not directly comparable.

## Lenses

- Code Health 72 → 72 (-0.0)
- Architecture 89 → 90 (+1.8)
- Maturity 56 → 51 (-4.5)
- Readiness 53 → 53 (+0.0)
- Security 78 → 78 (+0.0)
- Performance 77 → 76 (-0.6)

## Resolved (4)

- Duplicated block (10–11 lines × 2) (core/shared/src/main/scala-3/fabric/rw/CompileRW.scala)
- Duplicated block (16 lines × 2) (core/shared/src/main/scala-3/fabric/rw/CompileRW.scala)
- Off-boarding risk: anonymized user #1
- Workflow token permissions not restricted

## New (7)

- CompileRW.genPolyRW (cyclomatic 18) (core/shared/src/main/scala-3/fabric/rw/CompileRW.scala)
- Duplicated block (10–11 lines × 2) (core/shared/src/main/scala-3/fabric/rw/CompileRW.scala)
- Duplicated block (8 lines × 2) (core/shared/src/main/scala-3/fabric/rw/CompileRW.scala)
- Off-boarding risk: anonymized user #1
- Workflow token permissions not restricted (.github/workflows/ci.yml)
- Workflow token permissions not restricted (.github/workflows/clean.yml)
- Workflow token permissions not restricted (.github/workflows/release-drafter.yml)

## Changes since last survey

- 3 commits — 3 feature/other, 0 fixes

## By area

- core/shared — 3 commits

## Notable commits

- change: @unknownCase on an enum or sealed trait whose other cases are all parameterless keeps the type written as plain strings. Such a type was written as strings until a case was marked, and marking one moved it to the object form, so every declared case's wire value and the type's Definition changed. The derivation now writes each declared case as the string it has without the marked case (an enum's Parent.Case, a sealed trait's class-chain name), reads it by that name or, as before, its leaf name, decodes any other string into the marked case and writes that case back as the same string; the Definition names only the declared cases, each a null value, as before. UnknownStringCaseRW is the runtime RW. Quoted and inline code builds pairs as tuples instead of with ->, since Scala 3.10 deprecates Predef.ArrowAssoc and reported it at every derivation site inlined from CompileRW (lines 531 and 723 among them). UnknownCaseSpec passes (18); coreJVM 204, ioJVM 28 and 2.13 coreJVM 143 pass.
- change: A derived enum or sealed trait can mark one case @unknownCase to receive any discriminator the type does not declare, so a stored value whose case has since been removed still decodes instead of failing the whole read. The marked case is a case class with exactly one field, a String, which receives the discriminator read; it is written back under that same discriminator, so a value read this way and stored again still names its original case and reads back the same; it has no discriminator of its own and is left out of the type's Definition. A value that is not an object, or has no discriminator, still fails, and a type without the annotation still refuses an unknown discriminator. The derivation refuses a marked case of any other shape, and more than one marked case, at compile time. Scala 3 only (the Scala 2 derivation has no polymorphic sealed traits). UnknownCaseSpec covers an enum and a sealed trait under @typeField, a removed case with and without fields, one nested in a stored record, the definition, and the compile-time refusals; seven of its ten cases failed before.
- change: UnknownCaseSpec, failing first: an enum whose cases are all parameterless but the one marked @unknownCase is written as an object ({"type": ...}) rather than the plain string the same enum is written as without the marked case, so marking a catch-all case changes the wire format of every declared case and the type's Definition (each case becomes an empty object instead of a null value). The new cases expect every declared case written and read as its plain string (and by its leaf name), an unknown string decoded into the marked case and written back as the same string, the same inside a stored record, the definition of the enum without the marked case, and a non-string still refused; a sealed trait of case objects with a marked case class likewise. Eight of the eighteen fail.