fix(gfql): the indexed bypass and the named-middle rewrite must not discard rows() params

[lmeyerov]

Stacked on #1788 (base = fix/gfql-rows-table-named-middle). The table half of this
only becomes reachable once #1788 lands; the attach_prop_aliases half is independent
and reproduces on master today.

What I went looking for

The generalized question behind #1788: where else does a rewrite or fast path silently
discard an explicit request the caller made? Two more instances, both around the same
two functions #1788 touched, neither caught by its cases.

1. The indexed bindings bypass ignored table — wrong values

The bypass exists to skip the canonical traversal, so whatever it hands the suffix is
the pre-traversal graph. That is sound for a bindings table (the indexed path bag already
is the answer) but not for rows(table='edges'), which then reads the full edge frame.

	scan path	indexed path (index_policy='force')
(a {id:1})-[r]->(b) + rows(table='edges')	3 rows	12 rows — the whole graph
same, undirected	4 rows	12 rows
… + select(['type'])	[A,A,A]	every edge type in the graph

pandas, cuDF and native polars alike. No error. It survives a following projection, so it
is wrong values, not schema noise.

_plan_indexed_middle (generic) and _try_indexed_middle_polars (native polars) declined
for source / alias_endpoints / alias_prefilters but not for a non-default table.
Both now do, keyed on != "nodes" for the same reason #1788's guard is — rows() defaults
table to "nodes" and always emits it, so is None would disable the bypass outright.

Why #1788 didn't see it: before that fix, the rewrite converted the call on the indexed
and the scan path, so the two agreed — on the wrong table. Making the scan path right is
what exposed the indexed one reading the whole graph. This is the same class as the
already-shipped "indexed bypass could return every node for rows() over an unnamed
pattern", one param over.

2. Both rewrites threw away the caller's other rows() params

suffix = [rows_fn(binding_ops=...)] + suffix[1:] builds a fresh call rather than
adding binding_ops to the one the caller wrote, so every param the rewrite has no opinion
about is dropped. Observable for attach_prop_aliases (the #1711 projection pushdown):

g.gfql([n({'id':1}, name='a'), e_forward(name='r'), n(name='b'),
        rows(attach_prop_aliases=['a'])])          # -> attaches b.id, b.kind too
g.gfql([rows(binding_ops=<those three ops>, attach_prop_aliases=['a'])])   # -> does not

Same query, same bindings, different output schema — decided only by how it was spelled.
alias_prefilters was dropped the same way. Both are now carried through, on both surfaces.
Cypher is unaffected either way: gfql_unified always emits attach_prop_aliases with
binding_ops, so the rewrite never fired on those plans.

3. Found but NOT fixed — pinned by a strict xfail

The native polars row op calls its bindings builder with binding_ops and
attach_prop_aliases only, so alias_prefilters never reaches it, while the generic path
threads it into _gfql_binding_ops_row_table. Measured on the same fixture:
pandas/cuDF 5 rows, polars 12 for an identical query.

Not fixed here because the hint is documented as advisory — the Cypher lowering that
emits it always keeps the equivalent post-join filter, so Cypher answers agree across
engines and only the pushdown is lost; honouring it natively means porting the whole
prefilter evaluator, which is a feature, not this fix. Hand-written GFQL passing it without
a post-filter does get engine-dependent row counts. xfail(strict=True) so whoever
ports it is told to delete the marker rather than leaving a stale "known gap".

Tests

21 cases across pandas / cuDF / native polars: the leak on both middle directions, the leak
surviving a select, the param carry-through by schema and by value, and the negative
side — a bare rows() over a named middle must still engage the bypass, asserted on the
index trace rather than on the answer, because the answer is identical either way and that
is exactly what would make "just never take the bypass" pass silently.

Mutation-checked per surface, all four guards independently:

mutation	fails	other engines
drop generic table guard	6 (pandas + cuDF)	polars green
drop polars table guard	3 (polars)	pandas + cuDF green
revert generic param carry	2 (pandas + cuDF)	polars green
revert polars param carry	1 (polars)	pandas + cuDF green

Verification

All in-container on dgx-spark. graphistry/tests/compute with --gpus all:

• master 3f2128ea: 9 failed, 7020 passed, 90 skipped, 15 xfailed
• this branch: 9 failed, 7050 passed, 90 skipped, 16 xfailed

Identical 9-failure set (pre-existing igraph/cuDF round-trip + dask coercion). +30 = the
10 cases #1788 adds plus my 20; +1 xfail is the polars gap above. ruff clean; mypy 173
errors before and after, in the same 12 files — neither changed file appears.

🤖 Generated with Claude Code

https://claude.ai/code/session_015YsqAZQLbqjSDrYSFz2GoB