fix(kyo): brace the valuePrism extension so stryker4s can mutate the module

[kryptt]

What breaks

On an unmodified tree, sbt mutationAll (build.sbt:1108, project kyoIntegration; stryker)
aborts before it can score anything — kyoIntegration is the only module in the sweep that
does this:

[info] Setting up mutated environment...
[info] 67 mutant(s) generated. Of which 15 mutant(s) are excluded.
[error] -- Error: …/kyo/target/stryker4s-17530133119958744035/src/main/scala/dev/constructive/eo/kyo/schema/StructureOptics.scala:364:0
[error] 364 |def valuePrism(using Frame): optics.MendTearPrism[Value, Value, A, A] = {
[error]     |^^^
[error]     |Extension without extension methods
[error] -- [E006] Not Found Error: …/StructureOptics.scala:364:64
[error] 364 |def valuePrism(using Frame): optics.MendTearPrism[Value, Value, A, A] = {
[error]     |                                                                ^
[error]     |                                                     Not found: type A
[error] -- [E006] Not Found Error: …/StructureOptics.scala:365:15
[error] 365 |  given Schema[A] = self
[error]     |               ^
[error]     |               Not found: type A
[error] -- [E006] Not Found Error: …/StructureOptics.scala:365:20
[error] 365 |  given Schema[A] = self
[error]     |                    ^^^^
[error]     |                    Not found: self
[error] 7 errors found
[error] (Compile / compileIncremental) Compilation failed
[info] Attempting to remove 7 mutant(s) that gave a compile error...
[info] 7 mutant(s) gave a compiler error. They will be marked as such in the report.
[error] No mutants were removed in …/kyo/src/main/scala/dev/constructive/eo/kyo/schema/StructureOptics.scala even though there were 7 compile errors.
[error] stryker4s.exception.UnableToFixCompilerErrorsException: Unable to remove non-compiling mutants in the mutated files. As a work-around you can exclude them in the stryker.conf. Please report this issue at https://github.com/stryker-mutator/stryker4s/issues
[error] src/main/scala/dev/constructive/eo/kyo/schema/StructureOptics.scala: 'Extension without extension methods'
[error] src/main/scala/dev/constructive/eo/kyo/schema/StructureOptics.scala: 'Not found: type A'   (×4)
[error] src/main/scala/dev/constructive/eo/kyo/schema/StructureOptics.scala: 'Not found: self'
[error] (stryker) stryker4s.exception.UnableToFixCompilerErrorsException: …

The breakage is structural, not a bad mutant, so stryker's mutant-removal recovery has nothing
to remove ("No mutants were removed … even though there were 7 compile errors") and the whole
module run dies. Reproduced twice, byte-identical.

Root cause

stryker4s 0.20.3 re-prints every file it mutates through scalameta. StructureOptics.scala
ended with a single-method significant-indentation extension clause whose Scaladoc sits
inside the clause, on the method:

extension [A](self: Schema[A])

  /** Prism between the untyped `Structure.Value` tree and `A` … */
  def valuePrism(using Frame): optics.MendTearPrism[Value, Value, A, A] =
    given Schema[A] = self
    …

A one-method extension body is not a Term.Block, so the printer emits the one-line form
extension (…) def f = …. The method's leading Scaladoc is replayed verbatim between the two,
which forces a newline and lands def in column 0. Captured from the live sandbox
(kyo/target/stryker4s-<id>/…/StructureOptics.scala, lines 352-367):

end StructureValues
extension [A](self: Schema[A]) 
/** Prism between the untyped `Structure.Value` tree and `A` — the typed ↔ untyped face beside
    * [[prism(Schema)]] (bytes) and [[stringPrism(Schema)]] (String), built on the public
    …
    */
def valuePrism(using Frame): optics.MendTearPrism[Value, Value, A, A] = {
  given Schema[A] = self
  Prism[Value, A](v => Structure.decode[A](v).foldError(Right(_), _ => Left(v)), a => Structure.encode(a))
}

The extension clause is left with no method (Extension without extension methods), and
def valuePrism becomes a top-level def where A and self are unbound
(Not found: type A, Not found: self). Exactly the three reported errors.

The fix, and why this one

Braces around the extension body. extension (…) { … } parses the body as a Term.Block, the
printer emits extension (…) { … }, and the newline before def is harmless.

Alternatives considered:

Option	Verdict
Braces around the body	Chosen. Bytecode-identical no-op, keeps the Scaladoc on the method it documents, and is structurally robust — it forces the Term.Block printing path regardless of what else might precede the def.
Hoist the Scaladoc above extension	Works (verified: identical 38.46% / 83.33% score) and is the pattern the avro / circe / jsoniter clauses already use — which is exactly why they have never tripped. Rejected because it detaches a substantial doc comment from the method it documents (valuePrism would render with no Scaladoc), and it only works while nothing else forces a newline before the def.
Add a second method to the clause	Rejected: invents public API to dodge a printer bug, and is fragile — the failure returns the moment the clause is back to one method.
File exclusion in stryker.conf	Rejected: loses coverage of the one file in the module that actually scores (20 of the 24 kills come from it). Noted for the record: the repo has no stryker4s.conf at all — stryker is configured entirely through ThisBuild settings in build.sbt (strykerReporters, strykerThresholdsBreak, strykerExcludedMutations), so this option would also mean introducing a new config file.

Semantic identity

Compiled before and after, same JDK, same compiler flags:

• javap -p -c over StructureOptics$package / StructureOptics$package$ — byte-for-byte identical, no diff at all.
• javap -p -c -v over every class the file produces — the only deltas are 13 LineNumberTable
  entries, all shifted by exactly +13 (the 13 comment lines added), and the TASTY attribute
  checksum (which changes for every class in a source file whenever the file's text changes).
  No instruction, signature, member, or constant-pool-semantic difference.
• sbt kyoIntegration/test unchanged: 12 + 23 + 27 + 30 examples, 0 failures, 0 errors.

Before / after

	mutants	Killed	Survived	NoCoverage	Ignored	score
before	67 generated	—	—	—	—	module unmutatable — run aborts
after	67	20	4	28	15	38.46% total / 83.33% of covered

From kyo/target/stryker4s-report/1789735393824/report.json (schema v2). Matches the figure an
earlier throwaway experiment reported. Per file:

• schema/StructureOptics.scala — 20 Killed, 4 Survived
• RecordIsoMacro.scala — 28 NoCoverage, 15 Ignored (macro code: expands at compile time, so
  mutants leave no runtime footprint — the same caveat already documented for generics)

Sibling-risk audit

This is a Scala 3 significant-indentation re-printing bug, so every other extension clause is a
potential latent copy. Audited all 60 extension clauses across every module (main + test):

• 17 are braced, multi-method, or already one-line → the printer emits a Term.Block, safe by construction.

• 43 are single-method significant-indentation clauses — but the trigger is the comment position,
  not the method count. 38 of them carry their Scaladoc above the extension keyword
  (AvroJson, AvroPrism, AvroTraversal, AvroJsoniter, JsonPrism, JsonTraversal,
  JsoniterPrism, JsoniterTraversal, MultiFocus, Optic, Direct, Forget), so the printer's
  one-line form stays on one line. Confirmed empirically, not by inspection: the completed sweep
  reports for avro (614 mutants), circe (86), core (234), jsoniter (420), laws, schemes,
  schemes-laws, generics, zio all ran to completion with mutants in those very files
  (AvroJsoniter.scala 64, MultiFocus.scala 55, JsoniterTraversal.scala 17, AvroTraversal.scala 16).

• 5 latent copies remain, all in kyo, all the exact broken shape (single method, Scaladoc
  inside the clause):

  • kyo/…/KyoOptics.scala:34 (Env.focus), :42 (Layer.focus)
  • kyo/…/schema/SchemaOptics.scala:29 (Focus.lens), :35 (Focus.toOptional), :47 (Focus.traversal)

  They are latent, not broken: stryker only re-prints files that contain at least one mutant, and
  KyoOptics.scala, RecordOptics.scala and SchemaOptics.scala currently generate zero
  mutants. Left alone deliberately — nothing demonstrably breaks today, and pre-emptively bracing
  five clauses would be a style rewrite against a hypothetical. They become real the moment a
  mutatable expression lands in one of those files; this PR's comment block is the breadcrumb.

Follow-ups (not in this PR)

• kyo can now be added to the QA page. It has never appeared in
  site/docs/quality-assurance.md — partly because the module could not be scored, and partly
  because site/tools/gen-qa-report.py's hardcoded MUTATION_MODULES list stops at jsoniter
  (zio is missing too). Adding ("kyo", "kyo", "") there will make the next quality.yml run
  render the row.

• Upstream: this is a stryker4s source-re-printing bug, worth filing at
  stryker-mutator/stryker4s. A standalone minimal reproducer was built and verified (one sbt
  project, sbt-stryker4s 0.20.3, Scala 3.3.6, munit, one source file):

  package example
  
  object Mutated:
    // A mutatable expression SOMEWHERE in the file: this is what makes
    // stryker4s re-print the file at all.
    def clamp(i: Int): Int = if i > 0 then i else 0
  
  extension [A](self: List[A])
  
    /** A leading Scaladoc on the ONLY method of a significant-indentation
      * `extension` clause. The method body itself must contain no mutant, so
      * that scalameta replays its original tokens (comment included) instead
      * of re-synthesising them.
      */
    def sizeTwice: Int = self.length * 2

  sbt stryker re-prints it to target/stryker4s-<id>/src/main/scala/example/Bug.scala as:

  extension [A](self: List[A]) 
  /** A leading Scaladoc on the ONLY method of a significant-indentation
      * `extension` clause. …
      */
  def sizeTwice: Int = self.length * 2

  → Extension without extension methods + Not found: self, then
  UnableToFixCompilerErrorsException (exit 1).

  Five conditions, all necessary — each isolated by a passing control run:

  1. the file contains at least one mutant (otherwise it is never re-printed);
  2. the extension clause uses significant indentation (braces ⇒ passes, 40.0%);
  3. the clause has exactly one method (2+ methods make the body a Term.Block ⇒ braces ⇒ passes);
  4. that method is not itself mutated — if it is, its Origin is dropped, the printer
     re-synthesises it, the comment is discarded and def stays on the extension line ⇒ passes;
  5. that method carries a leading comment inside the clause (comment removed ⇒ passes, 40.0%).

Gates

All on Temurin JDK 25.0.3 (JAVA_HOME=/usr/lib/jvm/openjdk-bin-25) — the kyo module needs
JDK 25 and silently leaves the root aggregate below it.

Gate	Result
sbt "print kyoIntegration/name"	✅ cats-eo-kyo (module present)
sbt "++ 3" compile test (root aggregate)	✅ [success] 105 s — kyo was in it: KyoOpticsSpec, RecordOpticsSpec, SchemaOpticsSpec, StructureOpticsSpec all ran, 0 failures across every module
sbt kyoIntegration/test	✅ 12 + 23 + 27 + 30 examples, 0 failure, 0 error
sbt benchmarks/compile	✅ [success]
sbt mimaReportBinaryIssues	✅ [success]
sbt "docs/mdoc; docs/laikaSite"	✅ [success]
sbt "scalafixAll; scalafmtAll" then sbt "scalafmtCheckAll; scalafixAll --check"	✅ clean (scalafmt added one blank line before the closing brace; folded into the commit)
project kyoIntegration; stryker	✅ completes — 20 K / 4 S / 28 NC / 15 I

🤖 Generated with Claude Code

https://claude.ai/code/session_0194EHFR4NamCpTHiqy7B74V

[github-actions]

🚀 Cloudflare Pages preview for fix/kyo-stryker-extension-indentation is live:

https://f3414393.cats-eo-docs.pages.dev

Branch alias: https://fix-kyo-stryker-extension-in.cats-eo-docs.pages.dev

_{Built from commit f6bef97f06f92354cdde0a382a52184cfae3aa2e · updated on every push.}

[github-actions]

Benchmark A/B

Allocation (B/op) — authoritative

Benchmark	params	base	head	Δ
KyoDiBench.eoMapGet	-	0.0	0.0	-0.2%
KyoDiBench.handMapGet	-	0.0	0.0	+0.2%
KyoDiBench.handEnvUse	-	304.0	304.0	+0.0%
KyoDiBench.eoEnvFocus	-	312.0	312.0	-0.0%
KyoDiBench.eoVarUpdateFocus	-	200.0	200.0	-0.0%
KyoDiBench.eoMapDrillModify	-	216.0	216.0	+0.0%
KyoDiBench.handVarUpdate	-	184.0	184.0	+0.0%
KyoDiBench.handMapDrillModify	-	216.0	216.0	-0.0%

Timing (ns/op) — directional only, same-VM but shared runner

Benchmark	params	base	head	Δ
KyoDiBench.handEnvUse	-	60.7	69.6	+14.6%
KyoDiBench.eoEnvFocus	-	67.1	62.7	-6.6%
KyoDiBench.eoVarUpdateFocus	-	56.8	54.6	-3.9%
KyoDiBench.eoMapDrillModify	-	40.7	42.0	+3.3%
KyoDiBench.handVarUpdate	-	50.5	51.4	+1.7%
KyoDiBench.handMapDrillModify	-	35.8	35.7	-0.5%
KyoDiBench.eoMapGet	-	2.8	2.8	-0.1%
KyoDiBench.handMapGet	-	2.2	2.2	-0.0%

_{base_sha: 75c7eaa712a23c7503b51858dcdfc61347e600c8 · head_sha: f6bef97f06f92354cdde0a382a52184cfae3aa2e · jdk: temurin-21 · runner: ubuntu-22.04 · jmh_params: -i 3 -wi 2 -f 1 -t 1 -foe true -prof gc -rf json · profile: pr:-i3-wi2-f1-t1-gc}