# Material3 adapter scan-roots for KetoyVM Phase A.
#
# This is the ONLY hand-edited surface in the adapter pipeline. The KSP
# processor (`:ketoy-ksp-processor`) reads this file, resolves each FQ
# name against the real Compose / Material3 / Foundation / Coil
# declarations on the build classpath, and emits:
#
#   - GeneratedAdapters.kt           — KBCComposableAdapter per composable
#   - GeneratedConstructorAdapters.kt — KBCConstructorAdapter per constructor
#   - META-INF/ketoy/adapter-catalog.bin — binary catalog (validator + emitter input)
#
# Adding a new component is: (a) reserve a stable Short ID in
# KBCAdapterIds / KBCConstructorIds, (b) add the matching line below,
# (c) ./gradlew :ketoy-adapters-material3:kspRelease.
#
# IDs are stable forever; never re-assign. App-specific adapters use the
# 0x4000+ range (see KBCAdapterIds.APP_SPECIFIC_START) registered through
# a host-side scan-roots file in the host's adapter module.
#
# ── Overload disambiguation ─────────────────────────────────────────────
# Many Compose / Material3 entry points have multiple overloads. Scan-roots
# accept an optional `(<typeFq>, <typeFq>, ...)` after the FQ name to pick
# a specific overload. The list is matched as a positional PREFIX —
# candidates whose first N params equal the listed types win. Empty `()`
# matches the zero-arg overload only. KSP exposes function-type params
# as their synthetic stdlib FQ (e.g. `kotlin.Function0`, `kotlin.Function1`),
# so disambiguators referring to lambda-typed params spell those out.

# ── Composables ─────────────────────────────────────────────────────────
# Layout
# Material3.Text has String + AnnotatedString overloads, AND multiple
# String overloads (with/without onTextLayout, with/without inlineContent).
# Disambiguate to the canonical String form using the trailing params:
# String + Modifier + Color + TextUnit (covers the typical 17-param shape
# the hand-rolled adapter targeted). Going one wider than `(kotlin.String)`
# alone, which prefix-matches 2+ overloads.
# Text — Material3 ships two overloads sharing a 14-param prefix. The 17-arg
# overload (with `minLines: Int` at position 14) is the post-1.5 API; the
# 16-arg deprecated form has `onTextLayout: (TextLayoutResult) -> Unit` at
# position 14 instead. Disambiguate by spelling out 15 leading types — when
# position 14 is `kotlin.Int`, only the new overload matches. Trailing
# nullability markers (`?`) match Compose's nullable defaults exactly so
# the per-position FQ comparison stays precise.
composable=androidx.compose.material3.Text(kotlin.String, androidx.compose.ui.Modifier, androidx.compose.ui.graphics.Color, androidx.compose.ui.unit.TextUnit, androidx.compose.ui.text.font.FontStyle?, androidx.compose.ui.text.font.FontWeight?, androidx.compose.ui.text.font.FontFamily?, androidx.compose.ui.unit.TextUnit, androidx.compose.ui.text.style.TextDecoration?, androidx.compose.ui.text.style.TextAlign?, androidx.compose.ui.unit.TextUnit, androidx.compose.ui.text.style.TextOverflow, kotlin.Boolean, kotlin.Int, kotlin.Int):0x0001
composable=androidx.compose.foundation.layout.Column:0x0002
composable=androidx.compose.foundation.layout.Row:0x0003
composable=androidx.compose.foundation.layout.Box:0x0004
# LazyColumn / LazyRow (ADR-0009 Phase B, structured fast-path B′). Content is
# `LazyListScope.() -> Unit` → classified ContentSlot(LazyListScope); the
# compiler lowers a flat `item { } / items(list) { x -> }` body into a
# KBCValue.LazyContent and the generated adapter replays it against the real
# LazyListScope (see AdapterCodegen.appendLazyListContentBody +
# KBCParamSet.getLazyContent). Foundation 1.8 ships two overloads sharing an
# 8-param prefix (…, userScrollEnabled: Boolean); the current one adds
# `overscrollEffect: OverscrollEffect?` at position 8 before `content`, the
# deprecated one has `content` there. The 9-type prefix ending in
# `OverscrollEffect?` picks the current overload uniquely. state
# (LazyListState) / contentPadding (PaddingValues) / flingBehavior /
# overscrollEffect are UnsupportedFallback → omitted → Compose defaults
# (rememberLazyListState() gives automatic scroll/fling for free).
composable=androidx.compose.foundation.lazy.LazyColumn(androidx.compose.ui.Modifier, androidx.compose.foundation.lazy.LazyListState, androidx.compose.foundation.layout.PaddingValues, kotlin.Boolean, androidx.compose.foundation.layout.Arrangement.Vertical, androidx.compose.ui.Alignment.Horizontal, androidx.compose.foundation.gestures.FlingBehavior, kotlin.Boolean, androidx.compose.foundation.OverscrollEffect?):0x0005
composable=androidx.compose.foundation.lazy.LazyRow(androidx.compose.ui.Modifier, androidx.compose.foundation.lazy.LazyListState, androidx.compose.foundation.layout.PaddingValues, kotlin.Boolean, androidx.compose.foundation.layout.Arrangement.Horizontal, androidx.compose.ui.Alignment.Vertical, androidx.compose.foundation.gestures.FlingBehavior, kotlin.Boolean, androidx.compose.foundation.OverscrollEffect?):0x0006
composable=androidx.compose.material3.Scaffold:0x0007
# Material3.Surface has both clickable (onClick: () -> Unit, ...) and
# non-clickable (modifier: Modifier, ...) overloads — pick the
# non-clickable one so register 0 stays the modifier.
composable=androidx.compose.material3.Surface(androidx.compose.ui.Modifier):0x0008
# Material3.Card non-clickable overload (modifier-first). Spelling out
# the full 6-param signature so KSP resolves shape, colors, elevation,
# and border to register-passthrough getters — Shape and CardColors etc.
# are classified via REGISTER_PASSTHROUGH_TYPES in ParamKindClassifier.
composable=androidx.compose.material3.Card(androidx.compose.ui.Modifier, androidx.compose.ui.graphics.Shape, androidx.compose.material3.CardColors, androidx.compose.material3.CardElevation, androidx.compose.foundation.BorderStroke?, kotlin.Function1):0x0009
composable=androidx.compose.foundation.layout.Spacer:0x000B
# HorizontalDivider / VerticalDivider (Material3). Both have a single
# (modifier, thickness: Dp, color: Color) signature — no disambiguator needed.
# thickness + color carry non-trivial Compose defaults (DividerDefaults.*), so
# both are honour-default-wrapped below; an omitted thickness would otherwise
# resolve to 0.dp (invisible line) and an omitted color to Color.Unspecified.
# The `color` argument accepts `themeColor("name")` like any other Color slot,
# so a divider follows the host's dark/light theme via the KBCColorResolver.
composable=androidx.compose.material3.HorizontalDivider:0x001A
composable=androidx.compose.material3.VerticalDivider:0x0029
# FlowRow / FlowColumn (ADR-0009 Phase A). foundation-layout 1.7.x ships a
# single overload of each (modifier, horizontal/verticalArrangement,
# maxItemsInEach*, maxLines, overflow, content) — no disambiguator needed.
# `content` is `@Composable FlowRowScope.() -> Unit`; FlowRowScope : RowScope
# (FlowColumnScope : ColumnScope), so the classifier maps the slot to
# SlotScope.RowScope / ColumnScope and the generated adapter publishes the
# real flow scope through LocalKBCLayoutScope for `Modifier.weight(...)`
# resolution (see ParamKindClassifier.SCOPE_BY_RECEIVER_FQ). `overflow`
# (FlowRowOverflow / FlowColumnOverflow) is UnsupportedFallback → omitted →
# Compose's `*Overflow.Clip` default applies. Both are @ExperimentalLayoutApi;
# the generated file opts in via AdapterCodegen.EXPERIMENTAL_OPT_INS.
composable=androidx.compose.foundation.layout.FlowRow:0x0025
composable=androidx.compose.foundation.layout.FlowColumn:0x0026
# LazyVerticalGrid / LazyHorizontalGrid (ADR-0009 Phase D, LazyGridScope receiver
# bridge). Content is `LazyGridScope.() -> Unit` → classified
# ContentSlot(LazyGridScope); the compiler always emits it as the general
# receiver bridge (no flat fast-path for grids) and the generated adapter runs it
# via KBCParamSet.applyGridScope against the real LazyGridScope (see
# AdapterCodegen.appendLazyGridContentBody + KBCComposeEngine.executeGridScope).
# foundation 1.7.5 ships a single overload of each (columns/rows: GridCells,
# modifier, state, contentPadding, reverseLayout, vertical/horizontalArrangement,
# flingBehavior, userScrollEnabled, content) — no disambiguator needed. `columns`
# / `rows` (GridCells) is REGISTER_PASSTHROUGH → read from a CONSTRUCT_JVM
# register holding the source-side `GridCells.Fixed(n)` etc. state
# (LazyGridState) / contentPadding (PaddingValues) / flingBehavior are
# UnsupportedFallback → omitted → Compose defaults (rememberLazyGridState() gives
# automatic scroll/fling for free).
composable=androidx.compose.foundation.lazy.grid.LazyVerticalGrid:0x0022
composable=androidx.compose.foundation.lazy.grid.LazyHorizontalGrid:0x0027
# Pagers — foundation HorizontalPager / VerticalPager (single, stable overload in
# foundation 1.7.x). The required `state: PagerState` cannot be authored by a KBC
# program, so the generated adapter HOISTS `rememberPagerState(pageCount = { … })`
# in its @Composable body (ParamKind.PagerState → AdapterCodegen.pagerStateParam).
# The count is recovered from the author's `rememberPagerState(pageCount = { N })`
# at the call site — the encoder extracts the `pageCount` lambda and emits it as a
# `() -> Int` KBC function read at runtime via getPageCount, so the count tracks
# the backing data reactively. `pageContent: PagerScope.(page: Int) -> Unit` is a
# ContentSlot(PagerScope); the page index is forwarded into the KBC content lambda
# via getItemContentSlot. `contentPadding`/`pageSize`/`flingBehavior`/`key`/… are
# UnsupportedFallback → omitted → Compose defaults.
composable=androidx.compose.foundation.pager.HorizontalPager:0x0023
composable=androidx.compose.foundation.pager.VerticalPager:0x002A
# Buttons & interaction
composable=androidx.compose.material3.Button:0x000C
composable=androidx.compose.material3.IconButton:0x000F
# Text input — TextField has String, AnnotatedString, and TextFieldValue
# overloads; pick the String one.
composable=androidx.compose.material3.TextField(kotlin.String):0x0012
# Selection
composable=androidx.compose.material3.Checkbox:0x0014
composable=androidx.compose.material3.Switch:0x0016
# Dialogs — Material3 AlertDialog. Two overloads share the `onDismissRequest` first
# param: the text-based one `(onDismissRequest, confirmButton, modifier, dismissButton,
# icon, title, text, shape, containerColor, …)` and a custom-content one
# `(onDismissRequest, modifier, properties, content)`. The disambiguator pins the
# text-based overload by requiring the 2nd param to be a function (`confirmButton:
# @Composable () -> Unit` = kotlin.Function0), which the content overload (2nd param
# Modifier) fails. `onDismissRequest: () -> Unit` is a plain callback → getLambda;
# `confirmButton` / `dismissButton` / `icon` / `title` / `text` are `@Composable () ->
# Unit` slots → getContentSlot. shape + the four content colors + tonalElevation carry
# AlertDialogDefaults.* defaults, honour-default-wrapped below (an omitted containerColor
# would otherwise resolve to Color.Unspecified); `containerColor` accepts `themeColor("name")`.
# `properties` (DialogProperties) is UnsupportedFallback → omitted → default.
composable=androidx.compose.material3.AlertDialog(kotlin.Function0, kotlin.Function0):0x0020
# Media — Coil's AsyncImage has overloads for both `transform/onState` and
# `placeholder/error/fallback/onLoading/onSuccess/onError` shapes; pick
# the painters-and-callbacks one (the more common Compose-side shape).
# AsyncImage — Coil ships a 14-arg and a 16-arg overload sharing a 14-param
# prefix. The 16-arg form (with `clipToBounds: Boolean` at position 14 and
# `equalityDelegate: EqualityDelegate` at position 15) is the current API.
# Spelling out 15 entries — `kotlin.Boolean` at the new position 14 — picks
# the 16-arg overload, and the 14-arg candidate is ruled out by the size
# check (params.size >= signature.size). Nullability markers track Coil's
# nullable defaults precisely.
composable=coil.compose.AsyncImage(kotlin.Any?, kotlin.String?, androidx.compose.ui.Modifier, androidx.compose.ui.graphics.painter.Painter?, androidx.compose.ui.graphics.painter.Painter?, androidx.compose.ui.graphics.painter.Painter?, kotlin.Function1?, kotlin.Function1?, kotlin.Function1?, androidx.compose.ui.Alignment, androidx.compose.ui.layout.ContentScale, kotlin.Float, androidx.compose.ui.graphics.ColorFilter?, androidx.compose.ui.graphics.FilterQuality, kotlin.Boolean):0x0018

# TopAppBar — Material3 ships two overloads sharing a 4-leading-param prefix
# (title, modifier, navigationIcon, actions). The post-1.2 overload adds
# `expandedHeight: Dp` at position 4; the deprecated overload has
# `windowInsets: WindowInsets` there. Disambiguate with the 5-position prefix
# ending in `Dp` to pick the current overload. `TopAppBarColors`,
# `WindowInsets`, and `TopAppBarScrollBehavior?` aren't classifier-mapped —
# they fall through to UnsupportedFallback, the codegen omits them, and
# Compose's source-declared defaults (theme-driven) apply at runtime.
# `@ExperimentalMaterial3Api` — user source must `@OptIn(ExperimentalMaterial3Api::class)`.
composable=androidx.compose.material3.TopAppBar(kotlin.Function0, androidx.compose.ui.Modifier, kotlin.Function0, kotlin.Function1, androidx.compose.ui.unit.Dp):0x001D

# Icon — Material3 ships three overloads keyed on the icon source type
# (ImageVector / Painter / ImageBitmap). Pick the ImageVector overload (used
# by `Icons.Filled.Settings` and friends — see ADR-0002 Phase A·E item 5).
# The encoder produces KBCValue.StringLiteral carrying the canonical icon FQ
# (e.g. `androidx.compose.material.icons.filled.Settings`); the runtime
# resolver (`KBCImageVectorResolver` injected via KetoyConfig from the host)
# maps it back to the ImageVector. R8 safety: hosts register icons via
# direct compile-time references to icon objects, so the icon classes are
# kept transitively without any -keep rules.
composable=androidx.compose.material3.Icon(androidx.compose.ui.graphics.vector.ImageVector, kotlin.String?, androidx.compose.ui.Modifier, androidx.compose.ui.graphics.Color):0x0019

# Image — Foundation's `Image(Painter, ...)` overload. Painter is intentionally
# NOT in `ParamKindClassifier.TOKEN_TYPE_FQS` (adding it globally would change
# AsyncImage's `placeholder/error/fallback: Painter?` semantics — currently
# UnsupportedFallback so omitted, the Painter? defaults to null). Image opts
# in to Painter dispatch via `paramResolver=` below. KBC source-side
# `painterResource(R.drawable.X)` is atomic-collapsed by KBCValueEncoder to
# `KBCValue.StringLiteral("X")`; the runtime resolves through host-supplied
# `KBCDrawableResolver` (registered via `MaterialDrawableResolver` DSL on
# KetoyConfig). `painter` is required+non-null in Compose's signature, so
# the runtime getter (`KBCParamSet.getPainter`) returns a transparent
# `PlaceholderPainter` when no override is encoded — no Elvis chain needed
# at the codegen call site.
composable=androidx.compose.foundation.Image(androidx.compose.ui.graphics.painter.Painter, kotlin.String?, androidx.compose.ui.Modifier, androidx.compose.ui.Alignment, androidx.compose.ui.layout.ContentScale, kotlin.Float, androidx.compose.ui.graphics.ColorFilter?):0x0024

# Canvas (ADR-0010 Phase A). Foundation's `Canvas(modifier, onDraw)` — a single
# overload, no disambiguator. `onDraw` is `DrawScope.() -> Unit` → classified
# ContentSlot(DrawScope) (ParamKindClassifier.SCOPE_BY_RECEIVER_FQ); the compiler
# lowers the draw body to a scoped-receiver KBC function (the DrawScope is bound
# at r0, exactly like the Lazy* receiver bridge) and the generated adapter runs
# it via KBCParamSet.applyDrawScope against the real DrawScope
# (AdapterCodegen.appendDrawScopeContentBody + KBCComposeEngine.executeDrawScope).
# Inside the body, geometry / density intrinsics (size / center / toPx) lower to
# INVOKE_SCOPED_RESULT; draw commands (drawRect, drawArc, …) are a later Canvas
# phase. `modifier` is the only other param (register 0).
composable=androidx.compose.foundation.Canvas:0x0028

# ── Sheets ──────────────────────────────────────────────────────────────
# ModalBottomSheet — Material3's modal bottom sheet (login sheets, pickers,
# etc.). `content` is `@Composable ColumnScope.() -> Unit` → ContentSlot(
# ColumnScope) (SCOPE_BY_RECEIVER_FQ), so `Modifier.weight(...)` and column
# arrangement resolve inside the sheet body just like FlowColumn.
# `onDismissRequest: () -> Unit` is a plain callback → getLambda. Show/hide is
# host/KBC-state driven: the KBC author conditionally emits `ModalBottomSheet {
# ... }` and clears the flag from `onDismissRequest`; the expand animation is
# automatic. Disambiguate by the first param being a function (`onDismissRequest`
# = kotlin.Function0), matching the current overload. `sheetState` (SheetState),
# `dragHandle` (@Composable (() -> Unit)?), `contentWindowInsets`, and
# `properties` fall through UnsupportedFallback → omitted → Compose defaults
# (`rememberModalBottomSheetState()` gives the expand/collapse behaviour for
# free, the drag handle renders by default). `shape` / `sheetMaxWidth` / the
# container / content / scrim colours carry non-trivial BottomSheetDefaults
# defaults → honour-default-wrapped below (an omitted sheetMaxWidth would
# otherwise be 0.dp = zero-width sheet, an omitted containerColor transparent).
# `containerColor` / `scrimColor` accept `themeColor("name")`.
# `@ExperimentalMaterial3Api` — the generated file opts in via
# AdapterCodegen.EXPERIMENTAL_OPT_INS.
# Two overloads share a 10-param prefix (…, dragHandle: @Composable (() -> Unit)?);
# the current one has `contentWindowInsets: @Composable () -> WindowInsets`
# (kotlin.Function0) at position 11, the deprecated one `windowInsets: WindowInsets`
# there. The 11-type prefix ending in kotlin.Function0 picks the current overload.
composable=androidx.compose.material3.ModalBottomSheet(kotlin.Function0, androidx.compose.ui.Modifier, androidx.compose.material3.SheetState, androidx.compose.ui.unit.Dp, androidx.compose.ui.graphics.Shape, androidx.compose.ui.graphics.Color, androidx.compose.ui.graphics.Color, androidx.compose.ui.unit.Dp, androidx.compose.ui.graphics.Color, kotlin.Function0?, kotlin.Function0):0x0021

# ── Constructors ────────────────────────────────────────────────────────
# TextStyle deferred — multiple overloads share the same 8-leading-param
# prefix `(Color, TextUnit, FontWeight, FontStyle, ...)`, so prefix
# matching reports "ambiguous — matched 5 constructors". A unique-prefix
# disambiguator would need to spell out enough trailing params to
# discriminate, but the canonical 18-param TextStyle constructor includes
# types (FontSynthesis, BaselineShift, TextGeometricTransform, LocaleList,
# Shadow, TextDirection, TextIndent) the classifier doesn't recognise.
# Phase A·E will either widen the classifier or add an exact-arity match
# mode to the disambiguator. Sample app doesn't construct TextStyle
# directly, so Phase A·5 ships without it.
# constructor=androidx.compose.ui.text.TextStyle(...):0x0001
constructor=androidx.compose.foundation.text.KeyboardOptions:0x0004
constructor=androidx.compose.foundation.text.KeyboardActions:0x0005
# RoundedCornerShape — the user-friendly `RoundedCornerShape(corner: Dp)`
# form is a top-level FACTORY FUNCTION (not a class constructor); the class
# itself takes 4 `CornerSize` values which the classifier doesn't model.
# Phase A·E item 2 adds the `factory=` line type — KsCatalogBuilder resolves
# the FQ to a top-level KSFunctionDeclaration, and the catalog records
# `FactoryShape.TopLevelFactory(callableFq = typeFqName)` so the generated
# adapter emits `RoundedCornerShape(p.getDp(0))` instead of `Class(...)`.
# RoundedCornerShape ships four user-friendly factory overloads producing
# the same `androidx.compose.foundation.shape.RoundedCornerShape` type.
# The multi-overload catalog (Phase A·F) lets all four coexist under the
# same type FQ; the compiler-plugin resolver disambiguates by the resolved
# IR function's value-parameter type signature.
factory=androidx.compose.foundation.shape.RoundedCornerShape(androidx.compose.ui.unit.Dp):0x0007
factory=androidx.compose.foundation.shape.RoundedCornerShape(kotlin.Int):0x0021
factory=androidx.compose.foundation.shape.RoundedCornerShape(androidx.compose.ui.unit.Dp, androidx.compose.ui.unit.Dp, androidx.compose.ui.unit.Dp, androidx.compose.ui.unit.Dp):0x0022
factory=androidx.compose.foundation.shape.RoundedCornerShape(kotlin.Int, kotlin.Int, kotlin.Int, kotlin.Int):0x0023
# GridCells (ADR-0009 Phase D) — the `columns` of LazyVerticalGrid / `rows` of
# LazyHorizontalGrid. The sealed `GridCells` supertype is REGISTER_PASSTHROUGH;
# its concrete subclasses are plain class constructors, each with its own ID.
# Source `GridCells.Fixed(2)` / `Adaptive(120.dp)` / `FixedSize(64.dp)` lowers to
# CONSTRUCT_JVM and the grid adapter reads the register via getGridCells.
constructor=androidx.compose.foundation.lazy.grid.GridCells.Fixed:0x0024
constructor=androidx.compose.foundation.lazy.grid.GridCells.Adaptive:0x0025
constructor=androidx.compose.foundation.lazy.grid.GridCells.FixedSize:0x0026
# Canvas geometry / graphics value types (ADR-0010 Phase B). Draw-command
# argument types. Offset / Size / CornerRadius are inline value classes built
# via top-level FACTORY functions (`Offset(x, y)`), so they use `factory=` (the
# function FQ equals the returned value-class FQ — same shape as RoundedCornerShape).
# Stroke is a plain class → `constructor=`. Source `Offset(cx, cy)` /
# `Stroke(width = …, cap = StrokeCap.Round)` lowers to CONSTRUCT_JVM; the draw
# command then reads the register via KBCParamSet.getOffset / getDrawStyle / etc.
# Stroke.cap (StrokeCap) / join (StrokeJoin) are classifier Tokens →
# getStrokeCap / getStrokeJoin (with Butt / Miter getter defaults);
# pathEffect (PathEffect?) is UnsupportedFallback → omitted → Compose's null
# default (gradients / path effects are a later Canvas phase).
factory=androidx.compose.ui.geometry.Offset(kotlin.Float, kotlin.Float):0x000A
factory=androidx.compose.ui.geometry.Size(kotlin.Float, kotlin.Float):0x0027
factory=androidx.compose.ui.geometry.CornerRadius(kotlin.Float, kotlin.Float):0x0028
# Stroke gains a `pathEffect: PathEffect?` param in Phase C — it now classifies
# as register-passthrough (ParamKindClassifier) so `Stroke(pathEffect =
# PathEffect.dashPathEffect(...))` reads the CONSTRUCT_JVM register via
# KBCParamSet.getPathEffect (nullable → no Elvis fallback). No signature change.
constructor=androidx.compose.ui.graphics.drawscope.Stroke:0x0029
# Canvas Phase C value types (ADR-0010 §C/§D). `Rect(left,top,right,bottom)` is a
# plain 4-Float class constructor (consumed by Path.arcTo / addRect / addOval).
# `Path()` is the no-arg top-level builder factory (same `factory=` shape as
# Offset — function FQ equals the returned `Path` interface FQ).
constructor=androidx.compose.ui.geometry.Rect(kotlin.Float, kotlin.Float, kotlin.Float, kotlin.Float):0x002A
factory=androidx.compose.ui.graphics.Path():0x002B
# Brush gradient factories (ADR-0010 §C — gradients). `Brush.Companion.<gradient>`
# member factories; the `colors: List<Color>` param opts into KBCParamSet.getColorList
# via the `paramResolver=` entries below (the global classifier leaves List as
# UnsupportedFallback). Disambiguate the List<Color> overload from the
# vararg-`Pair<Float,Color>` overload by the leading `kotlin.collections.List`
# param type. start/end/radius default to 0f / POSITIVE_INFINITY (paramDefault=
# below); `center` (radial) / `tileMode` are UnsupportedFallback → Compose
# defaults. These factories are NOT @Composable → synchronous CONSTRUCT_JVM.
objectFactory=androidx.compose.ui.graphics.Brush.Companion.linearGradient(kotlin.collections.List, androidx.compose.ui.geometry.Offset, androidx.compose.ui.geometry.Offset, androidx.compose.ui.graphics.TileMode):0x002C
objectFactory=androidx.compose.ui.graphics.Brush.Companion.horizontalGradient(kotlin.collections.List, kotlin.Float, kotlin.Float, androidx.compose.ui.graphics.TileMode):0x002D
objectFactory=androidx.compose.ui.graphics.Brush.Companion.verticalGradient(kotlin.collections.List, kotlin.Float, kotlin.Float, androidx.compose.ui.graphics.TileMode):0x002E
objectFactory=androidx.compose.ui.graphics.Brush.Companion.radialGradient(kotlin.collections.List, androidx.compose.ui.geometry.Offset, kotlin.Float, androidx.compose.ui.graphics.TileMode):0x002F
# PathEffect factories (ADR-0010 §C). `PathEffect.Companion.dashPathEffect`
# (intervals: FloatArray → KBCParamSet.getFloatArray via paramResolver=) /
# `cornerPathEffect(radius: Float)`. Both non-@Composable → synchronous.
objectFactory=androidx.compose.ui.graphics.PathEffect.Companion.dashPathEffect(kotlin.FloatArray, kotlin.Float):0x0030
objectFactory=androidx.compose.ui.graphics.PathEffect.Companion.cornerPathEffect(kotlin.Float):0x0031
# PasswordVisualTransformation deferred — primary constructor is now
# `(mask: Char = '•')`. Phase A·E item 4 added `kotlin.Char` to the
# primitive classifier and `KBCParamSet.getChar`, but no consumer in the
# sample-app references the typed mask, so the entry stays commented to
# keep the catalog footprint minimal until a real call site appears.
# constructor=androidx.compose.ui.text.input.PasswordVisualTransformation():0x000F

# ── Material3 *Defaults composable factories (objectFactory=) ───────────
# Member functions on Material3's named `*Defaults` objects (CardDefaults,
# ButtonDefaults, …) that are themselves `@Composable` — they read
# `MaterialTheme.colorScheme.*` etc. KSP detects the `@Composable`
# annotation on the resolved declaration and the catalog records
# `FactoryShape.CompanionFactory(isComposable = true)`. ConstructorCodegen
# emits a `KBCComposableConstructorAdapter` whose trailing lambda is
# `@Composable`; the runtime defers construction to the compose engine's
# pending-effect queue (KBCComposeEngine.applyComposableConstruct) so the
# factory body executes inside an active composition.
#
# Step 6 of PLAN_OBJECT_MEMBER_FACTORY.md ships CardDefaults.cardColors
# end-to-end as the proof point. Step 8 fans out to the other shapes.
#
# Adding a new objectFactory= entry is a 4-step recipe:
#   1. Reserve a stable Short ID in `KBCConstructorIds` (use the
#      0x0012-0x0020 reserved Material3 *Defaults block).
#   2. Add a single `objectFactory=<Owner>.<method>(<sig>):<id>` line below.
#      The signature disambiguator is required when the *Defaults member has
#      multiple overloads (almost always — Material3 ships a no-arg + a
#      max-args version of every factory; KSP picks the first declared
#      without disambiguation, which is usually the no-arg one and silently
#      drops the user's overrides).
#   3. Bump `EXPECTED_CONSTRUCTOR_COUNT` in `GeneratedCatalogStructuralTest`
#      and add a `STABLE_CONSTRUCTOR_ANCHORS` row.
#   4. (Optional) If a downstream composable adapter needs to consume the
#      factory's return type as a typed param (e.g. Card consumes CardColors
#      via `KBCParamSet.getCardColors`), confirm a typed getter exists on
#      `KBCParamSet` and a `KBCParamGetters.CONSTRUCTED_OBJECT_GETTERS`
#      entry maps the FQ to the getter name.
#
# Per-factory typed getters on KBCParamSet AND `REGISTER_PASSTHROUGH_TYPES`
# entries in `ParamKindClassifier` are the gating items for fanout to
# `ButtonDefaults.buttonColors` (returns ButtonColors), `TextFieldDefaults.colors`
# (returns TextFieldColors), and the 17 other Material3 *Defaults
# namespaces. The catalog + dispatch infrastructure is already in place;
# expanding to each new namespace is mechanical work driven by per-factory
# usage in real KBC source.
objectFactory=androidx.compose.material3.CardDefaults.cardColors(androidx.compose.ui.graphics.Color, androidx.compose.ui.graphics.Color, androidx.compose.ui.graphics.Color, androidx.compose.ui.graphics.Color):0x0012

# CardDefaults.cardElevation — parallel to cardColors. Returns CardElevation
# (already in the constructor-getter catalog as `getCardElevation`). 6-Dp
# overload accepts defaultElevation / pressedElevation / focusedElevation /
# hoveredElevation / draggedElevation / disabledElevation. Demonstrates the
# fan-out pattern with non-Color params; identical wiring to the cardColors
# entry at the catalog and codegen layers.
objectFactory=androidx.compose.material3.CardDefaults.cardElevation(androidx.compose.ui.unit.Dp, androidx.compose.ui.unit.Dp, androidx.compose.ui.unit.Dp, androidx.compose.ui.unit.Dp, androidx.compose.ui.unit.Dp, androidx.compose.ui.unit.Dp):0x0013

# ButtonDefaults.buttonColors — 4-Color factory (containerColor / contentColor /
# disabledContainerColor / disabledContentColor). Returns ButtonColors.
objectFactory=androidx.compose.material3.ButtonDefaults.buttonColors(androidx.compose.ui.graphics.Color, androidx.compose.ui.graphics.Color, androidx.compose.ui.graphics.Color, androidx.compose.ui.graphics.Color):0x0014
# ButtonDefaults.buttonElevation — 5-Dp factory (defaultElevation / pressedElevation /
# focusedElevation / hoveredElevation / disabledElevation). Returns ButtonElevation.
objectFactory=androidx.compose.material3.ButtonDefaults.buttonElevation(androidx.compose.ui.unit.Dp, androidx.compose.ui.unit.Dp, androidx.compose.ui.unit.Dp, androidx.compose.ui.unit.Dp, androidx.compose.ui.unit.Dp):0x0015

# TopAppBarDefaults.topAppBarColors — 4-Color factory (containerColor /
# scrolledContainerColor / navigationIconContentColor / titleContentColor —
# the 5-arg signature also has actionIconContentColor at the tail; pick
# the 4-arg prefix). Returns TopAppBarColors. The 5-Color overload is
# `(Color, Color, Color, Color, Color)`; KSP picks the first match among
# overloads sharing the leading FQ-name prefix, so add the trailing
# disambiguator if both 4-arg and 5-arg shapes appear in your Material3
# version.
objectFactory=androidx.compose.material3.TopAppBarDefaults.topAppBarColors(androidx.compose.ui.graphics.Color, androidx.compose.ui.graphics.Color, androidx.compose.ui.graphics.Color, androidx.compose.ui.graphics.Color, androidx.compose.ui.graphics.Color):0x0020

# ── Primitive default-expression overrides ──────────────────────────────
# Used when KSP1 cannot reach the Compose-declared default. Most params
# don't need an entry; the type-based fallback is correct. The entries
# below are the exact set the hand-rolled Phase-A adapters carried.
paramDefault=androidx.compose.material3.Text.softWrap=true
paramDefault=androidx.compose.material3.Text.maxLines=Int.MAX_VALUE
paramDefault=androidx.compose.material3.Text.minLines=1
# TextField — minLines / maxLines default to 1 / Int.MAX_VALUE. Material3's
# heightInLines modifier throws "both minLines 0 and maxLines 0 must be greater
# than zero" when an omitted value resolves to the getInt type-zero (0). Mirrors
# Text.minLines / Text.maxLines.
paramDefault=androidx.compose.material3.TextField.minLines=1
paramDefault=androidx.compose.material3.TextField.maxLines=Int.MAX_VALUE
paramDefault=androidx.compose.foundation.layout.Box.propagateMinConstraints=false
paramDefault=androidx.compose.material3.Button.enabled=true
paramDefault=androidx.compose.material3.IconButton.enabled=true
paramDefault=androidx.compose.material3.Checkbox.enabled=true
paramDefault=androidx.compose.material3.Switch.enabled=true
paramDefault=androidx.compose.material3.TextField.enabled=true
paramDefault=androidx.compose.material3.OutlinedTextField.enabled=true
# TopAppBar.expandedHeight defaults to TopAppBarDefaults.TopAppBarExpandedHeight
# (~64.dp). Without an honour-default wrap, KBC source that omits this param
# resolves to `0.dp` (the type-zero fallback) and the bar collapses to zero
# height — making the entire app bar invisible while the Scaffold still
# layouts around it.
paramDefault=androidx.compose.material3.TopAppBar.expandedHeight=androidx.compose.material3.TopAppBarDefaults.TopAppBarExpandedHeight
# Image — alpha defaults to DefaultAlpha (1.0f, top-level const in
# androidx.compose.ui.graphics). Without honour-default + paramDefault the
# encoder would emit 0f when omitted and the image would render fully
# transparent.
paramDefault=androidx.compose.foundation.Image.alpha=androidx.compose.ui.graphics.DefaultAlpha
# AsyncImage (Coil) — alpha defaults to DefaultAlpha (1.0f). Without honour-default an
# omitted alpha reads 0f (the getFloat type-zero fallback) and every remote image renders
# fully transparent (invisible). Mirrors foundation Image.alpha.
paramDefault=coil.compose.AsyncImage.alpha=androidx.compose.ui.graphics.DefaultAlpha
# Image — alignment defaults to Alignment.Center (Compose's source default).
# `KBCParamSet.getContentAlignment` falls back to Alignment.TopStart for the
# Default case, which is wrong for Image specifically. Honour-default routes
# through this paramDefault entry to Alignment.Center.
paramDefault=androidx.compose.foundation.Image.alignment=androidx.compose.ui.Alignment.Center
# HorizontalDivider / VerticalDivider — thickness + color default to
# DividerDefaults.Thickness / DividerDefaults.color. Without honour-default the
# encoder emits 0.dp (invisible) / Color.Unspecified when omitted.
paramDefault=androidx.compose.material3.HorizontalDivider.thickness=androidx.compose.material3.DividerDefaults.Thickness
paramDefault=androidx.compose.material3.HorizontalDivider.color=androidx.compose.material3.DividerDefaults.color
paramDefault=androidx.compose.material3.VerticalDivider.thickness=androidx.compose.material3.DividerDefaults.Thickness
paramDefault=androidx.compose.material3.VerticalDivider.color=androidx.compose.material3.DividerDefaults.color
# AlertDialog — shape + the four content colors + tonalElevation default to
# AlertDialogDefaults.* (all @Composable-read from the theme; the adapter is
# @Composable so calling them is fine). Without honour-default an omitted
# containerColor resolves to Color.Unspecified (transparent dialog) and shape to a
# zero corner. The KBC author sets only what it customises (typically containerColor
# via themeColor); everything else falls back to these theme defaults.
paramDefault=androidx.compose.material3.AlertDialog.shape=androidx.compose.material3.AlertDialogDefaults.shape
paramDefault=androidx.compose.material3.AlertDialog.containerColor=androidx.compose.material3.AlertDialogDefaults.containerColor
paramDefault=androidx.compose.material3.AlertDialog.iconContentColor=androidx.compose.material3.AlertDialogDefaults.iconContentColor
paramDefault=androidx.compose.material3.AlertDialog.titleContentColor=androidx.compose.material3.AlertDialogDefaults.titleContentColor
paramDefault=androidx.compose.material3.AlertDialog.textContentColor=androidx.compose.material3.AlertDialogDefaults.textContentColor
paramDefault=androidx.compose.material3.AlertDialog.tonalElevation=androidx.compose.material3.AlertDialogDefaults.TonalElevation
# ModalBottomSheet — shape / sheetMaxWidth / container / content / scrim colours
# default to BottomSheetDefaults.*. Without honour-default an omitted sheetMaxWidth
# is 0.dp (zero-width sheet), an omitted containerColor Color.Unspecified
# (transparent), shape a zero corner. contentColor defaults to the theme's
# on-container colour via contentColorFor(...).
paramDefault=androidx.compose.material3.ModalBottomSheet.shape=androidx.compose.material3.BottomSheetDefaults.ExpandedShape
paramDefault=androidx.compose.material3.ModalBottomSheet.sheetMaxWidth=androidx.compose.material3.BottomSheetDefaults.SheetMaxWidth
paramDefault=androidx.compose.material3.ModalBottomSheet.containerColor=androidx.compose.material3.BottomSheetDefaults.ContainerColor
paramDefault=androidx.compose.material3.ModalBottomSheet.contentColor=androidx.compose.material3.contentColorFor(androidx.compose.material3.BottomSheetDefaults.ContainerColor)
paramDefault=androidx.compose.material3.ModalBottomSheet.scrimColor=androidx.compose.material3.BottomSheetDefaults.ScrimColor
# FlowRow / FlowColumn — maxItemsInEach* and maxLines default to Int.MAX_VALUE.
# Without honour-default the encoder emits 0 when omitted and the layout shows
# zero items per line (collapsed). Mirrors Text.maxLines.
paramDefault=androidx.compose.foundation.layout.FlowRow.maxItemsInEachRow=Int.MAX_VALUE
paramDefault=androidx.compose.foundation.layout.FlowRow.maxLines=Int.MAX_VALUE
paramDefault=androidx.compose.foundation.layout.FlowColumn.maxItemsInEachColumn=Int.MAX_VALUE
paramDefault=androidx.compose.foundation.layout.FlowColumn.maxLines=Int.MAX_VALUE
# LazyColumn / LazyRow — userScrollEnabled defaults to true. Without honour-
# default the encoder emits false when omitted and the list can't scroll.
paramDefault=androidx.compose.foundation.lazy.LazyColumn.userScrollEnabled=true
paramDefault=androidx.compose.foundation.lazy.LazyRow.userScrollEnabled=true
# HorizontalPager / VerticalPager — userScrollEnabled defaults to true; without
# honour-default the encoder emits false when omitted and the pager can't swipe.
paramDefault=androidx.compose.foundation.pager.HorizontalPager.userScrollEnabled=true
paramDefault=androidx.compose.foundation.pager.VerticalPager.userScrollEnabled=true
# LazyVerticalGrid / LazyHorizontalGrid — userScrollEnabled defaults to true.
paramDefault=androidx.compose.foundation.lazy.grid.LazyVerticalGrid.userScrollEnabled=true
paramDefault=androidx.compose.foundation.lazy.grid.LazyHorizontalGrid.userScrollEnabled=true
# CornerRadius.y defaults to x (Compose: `CornerRadius(x, y = x)`). The default
# expression references param 0's getter so `CornerRadius(8f)` → both radii = 8f.
# This drives the getter's 2nd-arg default directly (NOT the isDefaulted /
# honour-default path — value-class inline factories have no $default bitfield),
# so it is intentionally NOT paired with a paramHonourDefault entry below.
paramDefault=androidx.compose.ui.geometry.CornerRadius.y=p.getFloat(0)
# Stroke.miter defaults to DefaultMiter (4.0f) in Compose; without this the
# type-zero fallback (0f) would clip mitred joins.
paramDefault=androidx.compose.ui.graphics.drawscope.Stroke.miter=4f
# Brush gradient end coordinate (horizontal/vertical) and radial radius default
# to Float.POSITIVE_INFINITY (Compose lets the brush span the full draw area);
# start coords default to 0f (the getFloat type-zero fallback). Without these the
# omitted Float end reads 0f and the gradient collapses to a single line. The
# linear gradient's Offset start/end (and the radial center) are
# UnsupportedFallback → omitted → Compose's own Offset defaults apply.
paramDefault=androidx.compose.ui.graphics.Brush.Companion.horizontalGradient.endX=Float.POSITIVE_INFINITY
paramDefault=androidx.compose.ui.graphics.Brush.Companion.verticalGradient.endY=Float.POSITIVE_INFINITY
paramDefault=androidx.compose.ui.graphics.Brush.Companion.radialGradient.radius=Float.POSITIVE_INFINITY

# ── Param transforms (Phase A·D) ────────────────────────────────────────
# Wraps the typed-getter read with `let { value -> <expr> }`. Use FQ names
# in the expression — KotlinPoet doesn't auto-import from transforms.
paramTransform=androidx.compose.material3.Text.maxLines=value.coerceAtLeast(1)
paramTransform=androidx.compose.material3.Text.minLines=value.coerceAtLeast(1)
paramTransform=androidx.compose.ui.text.TextStyle.textAlign=value ?: androidx.compose.ui.text.style.TextAlign.Unspecified

# ── Honour-$default bitfield reads (Phase A·D) ──────────────────────────
# Generates `if (p.isDefaulted(idx)) <default> else <typedRead>`. The
# default resolves to the matching `paramDefault=` entry above; otherwise
# the type-zero fallback. Required for params whose Compose source default
# is non-zero (true / Int.MAX_VALUE / 1) — the encoder marks "not
# explicitly set" via the $default bitfield, and the runtime adapter must
# honour that marker so the user's source default applies.
paramHonourDefault=androidx.compose.material3.Text.softWrap
paramHonourDefault=androidx.compose.material3.Text.maxLines
paramHonourDefault=androidx.compose.material3.Text.minLines
paramHonourDefault=androidx.compose.material3.TextField.minLines
paramHonourDefault=androidx.compose.material3.TextField.maxLines
paramHonourDefault=androidx.compose.material3.Button.enabled
paramHonourDefault=androidx.compose.material3.IconButton.enabled
paramHonourDefault=androidx.compose.material3.Checkbox.enabled
paramHonourDefault=androidx.compose.material3.Switch.enabled
paramHonourDefault=androidx.compose.material3.TextField.enabled
paramHonourDefault=androidx.compose.material3.OutlinedTextField.enabled
paramHonourDefault=androidx.compose.material3.TopAppBar.expandedHeight
paramHonourDefault=androidx.compose.foundation.Image.alpha
paramHonourDefault=coil.compose.AsyncImage.alpha
paramHonourDefault=androidx.compose.foundation.Image.alignment
paramHonourDefault=androidx.compose.material3.HorizontalDivider.thickness
paramHonourDefault=androidx.compose.material3.HorizontalDivider.color
paramHonourDefault=androidx.compose.material3.VerticalDivider.thickness
paramHonourDefault=androidx.compose.material3.VerticalDivider.color
paramHonourDefault=androidx.compose.material3.AlertDialog.shape
paramHonourDefault=androidx.compose.material3.AlertDialog.containerColor
paramHonourDefault=androidx.compose.material3.AlertDialog.iconContentColor
paramHonourDefault=androidx.compose.material3.AlertDialog.titleContentColor
paramHonourDefault=androidx.compose.material3.AlertDialog.textContentColor
paramHonourDefault=androidx.compose.material3.AlertDialog.tonalElevation
paramHonourDefault=androidx.compose.material3.ModalBottomSheet.shape
paramHonourDefault=androidx.compose.material3.ModalBottomSheet.sheetMaxWidth
paramHonourDefault=androidx.compose.material3.ModalBottomSheet.containerColor
paramHonourDefault=androidx.compose.material3.ModalBottomSheet.contentColor
paramHonourDefault=androidx.compose.material3.ModalBottomSheet.scrimColor
paramHonourDefault=androidx.compose.foundation.layout.FlowRow.maxItemsInEachRow
paramHonourDefault=androidx.compose.foundation.layout.FlowRow.maxLines
paramHonourDefault=androidx.compose.foundation.layout.FlowColumn.maxItemsInEachColumn
paramHonourDefault=androidx.compose.foundation.layout.FlowColumn.maxLines
paramHonourDefault=androidx.compose.foundation.lazy.LazyColumn.userScrollEnabled
paramHonourDefault=androidx.compose.foundation.lazy.LazyRow.userScrollEnabled
paramHonourDefault=androidx.compose.foundation.pager.HorizontalPager.userScrollEnabled
paramHonourDefault=androidx.compose.foundation.pager.VerticalPager.userScrollEnabled
paramHonourDefault=androidx.compose.foundation.lazy.grid.LazyVerticalGrid.userScrollEnabled
paramHonourDefault=androidx.compose.foundation.lazy.grid.LazyHorizontalGrid.userScrollEnabled

# ── Param resolvers (ADR-0002 Phase A·E item 5 / Phase B) ───────────────
# Per-(composable, param) typed-getter override. Opts an adapter into a
# `KBCParamSet` getter for a type the global classifier intentionally leaves
# as UnsupportedFallback (adding it globally would regress already-shipped
# adapters that rely on the omit-on-fallback path).
# Image.painter dispatches through `KBCParamSet.getPainter`, which routes
# `KBCValue.StringLiteral("foo")` through the host's `KBCDrawableResolver`
# and falls back to a transparent PlaceholderPainter when unresolved.
paramResolver=androidx.compose.foundation.Image.painter=getPainter
# Image.colorFilter dispatches through `KBCParamSet.getColorFilter`, which
# wraps an encoded tint colour (literal ColorARGB or a runtime/theme Register
# colour) into `ColorFilter.tint(color)`, or passes through a register-held
# ColorFilter. Null (unspecified) renders the image untinted.
paramResolver=androidx.compose.foundation.Image.colorFilter=getColorFilter
# Canvas Phase C — gradient color lists + dash intervals. The global classifier
# leaves `List` / `FloatArray` as UnsupportedFallback (mapping them globally
# would mis-route unrelated adapter params), so these factories opt in
# per-param. `colors: List<Color>` → getColorList (maps the register list's
# ARGB Ints back to Color); `intervals: FloatArray` → getFloatArray. These
# resolvers are consumed by ConstructorReadExpressions (the constructor-codegen
# counterpart of AdapterCodegen.rawReadExpression).
paramResolver=androidx.compose.ui.graphics.Brush.Companion.linearGradient.colors=getColorList
paramResolver=androidx.compose.ui.graphics.Brush.Companion.horizontalGradient.colors=getColorList
paramResolver=androidx.compose.ui.graphics.Brush.Companion.verticalGradient.colors=getColorList
paramResolver=androidx.compose.ui.graphics.Brush.Companion.radialGradient.colors=getColorList
paramResolver=androidx.compose.ui.graphics.PathEffect.Companion.dashPathEffect.intervals=getFloatArray
