feat(schema)!: broadcast semantics for mixed select and context-dependent orderBy expressions

[kudima03]

Summary

Closes #52 together with #59. Stacked on #59: this PR targets feat/grouped-select-single-value. Once #59 merges, it retargets to main.

1. Broadcast semantics for a mixed select without groupBy (docs only)

#52 flagged select: [field, sum(...)] without groupBy as a query whose result is undefined. This PR doesn't reject it; it gives it a defined meaning, using the broadcast model that each* operators already follow:

• At least one array-returning item (a field or an each* column): N rows, where N comes from from + joins + where. Every single-value item is repeated on each row. If N = 0, the result is empty.
• Only single-value items: one row (samples 06 and 09).
• Aggregates see all N rows: they're computed before distinct and pagination.

New sample 22_select_broadcast.json: order fields plus sum(total_amount) as grand_total and eachDivide(total_amount, sum(total_amount)) as share_of_total.

2. orderBy keys follow the query context (breaking)

orderBy sorts result rows, so its key has to produce one value per result row. Before this PR it only accepted fields, which allowed ambiguous grouped sorts (a field has no single value per group) and gave no way to sort by a computed value.

Now every item is one shape, orderByItem = { expression, direction }, and the allowed kind of expression follows the context. This is the same split as where / having and as select with and without groupBy:

Query	A result row is	expression must be	Enforced by
without groupBy	a row	arrayReturning: field, each* (single-value is allowed but has no effect)	no restriction
with groupBy	a group	singleValueReturning: aggregate, arithmetic over aggregates	root dependentSchemas

In LINQ terms: items.OrderByDescending(i => i.UnitPrice * i.Quantity) and .GroupBy(o => o.UserId).OrderByDescending(g => g.Sum(o => o.Total) / g.Count()).

• A field is simply an array-returning expression; the { field } form is gone.
• There are no alias references. To sort by a computed select column, you repeat the expression, which keeps validation strict.
• To sort groups by a key, wrap it in an aggregate (min_string(users.name)) until Add order-sensitive aggregates firstElement / lastElement with per-aggregate orderBy #61 adds firstElement.
• Sample 12 sorts by sum(total_amount) desc, then min_string(users.name) asc.
• New sample 23_order_by_computed.json: order items sorted by eachMultiply(unit_price, quantity) desc, then id.

Verification

All 23 samples validate. Scenario checks for orderBy:

Scenario	Result
grouped, aggregate	valid
grouped, divide(sum, count)	valid
grouped, field	invalid
grouped, eachMultiply	invalid
ungrouped, field	valid
ungrouped, eachMultiply	valid
ungrouped, aggregate (constant, has no effect)	valid
ungrouped, scalar (constant, has no effect)	valid
old { field } form	invalid
invalid direction	invalid

Breaking change

orderBy items use { "expression": X } in place of { "field": X }, in every query. Grouped queries must sort by a single-value expression. The release needs a major bump.

Follow-up

Order-sensitive aggregates (firstElement / lastElement, each with its own orderBy) are tracked in a separate issue. firstElement(key) would also let groups be sorted by keys of any type, including uuid and boolean.

🤖 Generated with Claude Code