TASK-36: widen mixed int/float list elements on the native engine

[claude-agent-ahrzb]

Fixes a silent cross-engine value divergence on the default serving engine.

What a user hits

SELECT [bedrooms, price_per_sqft] AS dims FROM __THIS__   -- int, float

transform() over the DataFrame  ->  [3.0, 12.5]     (DataFusion oracle + codegen)
infer() on a single row         ->  [3,   12.5]     (native, un-widened)

No error, no warning. The int element silently stays int on the serving path and becomes float on the training path. Anything dtype-sensitive downstream — a numpy cast, a model expecting float64, a feature vector checked against a stored schema — then sees different data in training vs production, and nothing points at the list literal.

Root cause (measured)

native's unify_list_element_types (src/types.rs) was exact-FieldType-equality only, so it refused to widen mixed numeric elements and fell back to Base::Other. DataFusion (oracle) and codegen both widen to list<double>.

The fix — AC#1: mirror the COALESCE/CASE widening the oracle already uses

// before: exact FieldType equality, or Base::Other
if iter.all(|t| t == first) { first.clone() } else { Base::Other, nullable: true }

// after: the same common_base widening as COALESCE/CASE
FieldType {
    base: common_base(item_types),          // int + float -> float
    nullable: item_types.iter().any(|t| t.nullable),
}

common_base is the existing function COALESCE/NULLIF and CASE already use, and it already matches the oracle. So this inherits the oracle-verified promotion rule rather than defining a new one — no promotion lattice invented. The output model types the list as list[float] and pydantic coerces the runtime int to float, exactly as codegen does.

AC#4 — root-cause sweep

unify_list_element_types was the only exact-equality-only unification site where DataFusion widens. Verified the other type-combination sites are already correct:

site	behavior	verdict
common_base (COALESCE/CASE/NULLIF)	int+float → float	already widens
binary_op_type (arithmetic)	int op float → float	already widens
compatible() (struct/list matching)	(Int, Float) => true	already accepts widening

No other silent-divergence site of this class.

Verification

• AC#2: SELECT [x, y] with int+float now yields [1.0, 2.5] on native, matching the oracle.
• AC#3: the xfail_on_native marker on test_list_construct_mixed_numeric_widens is removed in this same commit; it now passes on both engines.
• Mutation-checked: reverting the widening (rebuild) makes the now-unmarked test fail on [native] while [codegen] still passes — so it genuinely catches the regression.
• Suite: 573 passed, 11 xfailed (was 572 / 12 — the flipped test now passes on both engines). Diff scoped to src/types.rs + tests/test_diff_types.py.

🤖 Generated with Claude Code

[claude-agent-ahrzb]

Closing as obsolete: the SQLTransform line this targets has been reset (#54). The DataFusion native engine, the codegen backend, and the batch transform() path are removed; what remains is the confit-served fit-and-serve path.

Nothing here is lost — the branch and its commits stay reachable if this work is ever revived.