fix(migration): use format:off to preserve Scala 2 macro syntax

Author: 987Nabil

.sisyphus/boulder.json

@@ -0,0 +1,8 @@
+{
+  "active_plan": "/Users/nabil_abdel-hafeez/zio-repos/zio-blocks/.sisyphus/plans/migration-intersection-types.md",
+  "started_at": "2026-02-05T07:10:09.878Z",
+  "session_ids": [
+    "ses_3fc335044ffeSVftcfPVKtg1Xd"
+  ],
+  "plan_name": "migration-intersection-types"
+}

.sisyphus/notepads/migration-fieldname-fix/learnings.md

@@ -0,0 +1,39 @@
+# Learnings: Literal Type Preservation in Scala 3 Macros
+
+## Problem
+When using `.asType` on an `AndType` containing a `ConstantType(StringConstant("fieldName"))`, the literal type gets widened to `String`. This breaks type-level tracking of field names in the migration builder.
+
+## Root Cause
+Scala 3's `.asType` method normalizes types, and literal types in intersection types get widened to their base type. For example:
+```scala
+val fieldNameType = ConstantType(StringConstant("age"))
+val singletonType = Symbol.requiredClass("scala.Singleton").typeRef
+val singletonBound = AndType(fieldNameType, singletonType)
+
+singletonBound.asType match {
+  case '[newTp] => // newTp is String, NOT "age" & Singleton!
+}
+```
+
+## Solution
+Use a phantom type wrapper `FieldName[N <: String & Singleton]` to preserve literal types:
+```scala
+sealed trait FieldName[N <: String & Singleton]
+
+// In macro:
+val fieldNameType = ConstantType(StringConstant("age"))
+val fieldNameWrapped = TypeRepr.of[FieldName].appliedTo(fieldNameType)
+val newTPType = AndType(TypeRepr.of[TP], fieldNameWrapped)
+
+newTPType.asType match {
+  case '[newTp] => // newTp correctly contains FieldName["age"]
+}
+```
+
+## Why This Works
+1. `FieldName[N]` is a proper type constructor
+2. When using `TypeRepr.of[FieldName].appliedTo(fieldNameType)`, the type argument is preserved
+3. The extraction logic can pattern match on `AppliedType(tycon, List(field))` to get the literal
+
+## Key Insight
+Direct literal types in intersection types don't survive `.asType`, but type constructor applications do. This is a fundamental limitation of Scala 3 macro type handling.

.sisyphus/notepads/migration-intersection-types/decisions.md

@@ -0,0 +1,40 @@
+# Decisions: Migration Intersection Types Refactoring
+
+## Decision 1: Use FieldName Wrapper Type
+
+**Context**: Direct intersection types with literal types (`Any & "fieldName"`) don't preserve the literal type through Scala 3's macro system.
+
+**Decision**: Introduce a `FieldName[N <: String & Singleton]` sealed trait to wrap literal types.
+
+**Rationale**:
+- Preserves literal type information through the type system
+- Works with both Scala 3.3.7 and 3.7.4
+- Minimal runtime overhead (phantom type)
+- Clean extraction pattern in validation macros
+
+**Alternatives Considered**:
+1. Keep using tuples - rejected because the goal was to simplify with intersection types
+2. Use match types - more complex and not necessary
+3. Direct `AndType` construction - doesn't preserve literal types
+
+## Decision 2: Use `Any` as Empty Type Instead of `EmptyTuple`
+
+**Context**: Need a base type for the intersection chain.
+
+**Decision**: Use `Any` as the starting type for `SourceHandled` and `TargetProvided`.
+
+**Rationale**:
+- `Any & X` simplifies to `X` in Scala's type system
+- Works naturally with intersection types
+- No special handling needed for the empty case
+
+## Decision 3: Construct Types at TypeRepr Level
+
+**Context**: Need to build intersection types in macros.
+
+**Decision**: Use `TypeRepr.of[FieldName].appliedTo(fieldNameType)` and `AndType(...)` to construct types.
+
+**Rationale**:
+- Preserves literal type information
+- Works with `asType` to get a usable type variable
+- Consistent pattern across all macro methods

.sisyphus/notepads/migration-intersection-types/learnings.md

@@ -0,0 +1,55 @@
+# Learnings: Migration Intersection Types Refactoring
+
+## Key Challenge: Literal Type Widening in Scala 3 Macros
+
+When using `ConstantType(StringConstant(fieldName)).asType` in Scala 3 macros, the resulting type variable gets widened to `String` instead of preserving the literal type (e.g., `"age"`).
+
+### What Didn't Work
+
+1. **Direct intersection with literal type**: `TP & fn` where `fn` is captured from `asType` - the literal type gets widened to `String`.
+
+2. **Constructing AndType directly**: `AndType(TypeRepr.of[TP], fieldNameType).asType` - same widening issue.
+
+3. **Type alias with intersection**: `type AddField[T, F] = T & F` - the literal type still gets widened when passed through the type system.
+
+### What Worked: Wrapper Type Pattern
+
+The solution is to wrap the literal type in a phantom type that preserves it:
+
+```scala
+sealed trait FieldName[N <: String & Singleton]
+type AddField[T, F <: String & Singleton] = T & FieldName[F]
+```
+
+In the macros, construct the type as:
+```scala
+val fieldNameType = ConstantType(StringConstant(fieldName))
+val fieldNameWrapped = TypeRepr.of[FieldName].appliedTo(fieldNameType)
+val newTPType = AndType(TypeRepr.of[TP], fieldNameWrapped)
+```
+
+The `FieldName[N]` wrapper preserves the literal type because:
+1. The literal type is stored as a type parameter to `FieldName`
+2. When `asType` is called on the `AppliedType`, the type parameter is preserved
+3. The validation macro can extract the literal type by pattern matching on `AppliedType(tycon, List(field))` where `tycon.typeSymbol.name == "FieldName"`
+
+### Why Tuples Worked Originally
+
+The original tuple-based approach (`Tuple.Concat[TP, fn *: EmptyTuple]`) worked because:
+1. `Tuple.Concat` is a type-level computation that the compiler evaluates lazily
+2. The literal type `fn` is used as a type argument in a type expression
+3. The compiler preserves literal types in type-level computations
+
+### Extraction Pattern
+
+To extract field names from the intersection type:
+```scala
+def extract(tpe: TypeRepr): Set[String] = tpe.dealias match {
+  case AndType(left, right) => extract(left) ++ extract(right)
+  case ConstantType(StringConstant(s)) => Set(s)
+  case t if t =:= TypeRepr.of[Any] => Set.empty
+  case AppliedType(tycon, List(field)) if tycon.typeSymbol.name == "FieldName" =>
+    extract(field)
+  case _ => Set.empty
+}
+```