fix(varlen): T-0309 — RETURN of varlen rel emits JSON array of edges

Variable-length pattern bindings `[r*N..M]` reference a recursive CTE
whose alias has columns start_id/end_id/depth/path_ids/visited — not
edge fields. The previous RETURN projector emitted a single-edge JSON
template (`json_object('id', alias.id, 'type', alias.type, ...)`),
producing 'no such column: _gql_default_alias_N.id' for every
varlen-rel projection.

Three coordinated changes:

1. transform_match.c (line ~1145): when registering a varlen rel
   variable, stamp `transform_var->cte_name` with the CTE name. This
   marks the var as varlen-bound so downstream code branches
   appropriately.

2. transform_return.c (line ~956): in the AST_NODE_IDENTIFIER edge-
   variable projector, branch on `evar->cte_name`. When set, emit:

       (SELECT json_group_array(json_object('id', e.id, 'type', e.type, ...))
        FROM edges e WHERE e.id IN (SELECT CAST(value AS INTEGER)
                                    FROM json_each('[' || alias.path_ids || ']'))
        ORDER BY instr(',' || alias.path_ids || ',', ',' || e.id || ','))

   instead of the single-edge template. Path-order preservation via
   `instr` on the comma-separated path_ids string.

3. executor_match.c + extension.c: build_query_results identifies
   varlen edge vars (`evar->cte_name`) and skips the single-edge re-
   fetch (atoll(value) → fetch by id), leaving `result->data[row][col]`
   as the verbatim JSON array text. The result renderer in
   extension.c then falls back to text data when agtype_data is NULL
   (gated on the pointer being NULL, not on agtype_value_to_string
   returning NULL — that function returns 'null' for NULL input).

Result rendering (verified manually):

  MATCH (a)-[r*1..1]->(b) RETURN r
  => [{"r": [{"id":1,"type":"T",...}]}]                     (was: error)

  MATCH (a)-[r*1..2]->(b) RETURN r over a->b->c
  => 4 rows: [[T1]], [[T1,T2]], [[T2]], [[]]                (was: error)

  MATCH ()-[r:T]->() RETURN r
  => [{"r": {"id":1,"type":"T",...}}]                       (unchanged — non-varlen)

TCK delta: pass=3458 -> 3461 (+3), errors=84 -> 79 (-5), fails=284
-> 286 (+2). The 5 `_gql_default_alias` errors that flipped:
- Match4 [1] Handling fixed-length variable length pattern
- Match9 [1] Variable length relationship variables are lists of relationships
- (+ 3 others that moved error → pass or error → fail)

944/944 unit, functional clean.

Author: Dylan Bobby Storey

src/backend/executor/executor_match.c

@@ -418,6 +418,16 @@ int build_query_results(cypher_executor *executor, sqlite3_stmt *stmt, cypher_re
                             /* Parse the JSON array of element IDs and build path object */
                             result->agtype_data[current_row][col] = build_path_from_ids(executor, ctx, ident->name, value);
                         } else if (ctx && transform_var_is_edge(ctx->var_ctx, ident->name)) {
+                            /* T-0309: varlen-bound edge vars hold a JSON array
+                             * of edge objects (the RETURN projector emitted
+                             * json_group_array). Skip the single-edge
+                             * interpretation; leave the value as the text
+                             * column so the renderer outputs it verbatim. */
+                            transform_var *_evar = transform_var_lookup_edge(ctx->var_ctx, ident->name);
+                            if (_evar && _evar->cte_name && value[0] == '[') {
+                                /* No agtype conversion — text result will be
+                                 * rendered as the JSON array. */
+                            } else
                             /* Check if value is already a JSON object (from new RETURN format) */
                             if (value[0] == '{') {
                                 /* Parse the JSON object directly */

src/backend/transform/transform_match.c

@@ -1149,6 +1149,13 @@ static int generate_relationship_match(cypher_transform_context *ctx, cypher_rel
         char cte_name[64];
         snprintf(cte_name, sizeof(cte_name), "_varlen_path_%d", rel_index);
 
+        /* T-0309: mark this rel variable as varlen-bound so the RETURN
+         * projector emits a list-of-edges JSON array (and the result
+         * builder skips single-edge re-fetch). */
+        if (rel->variable) {
+            transform_var_set_cte(ctx->var_ctx, rel->variable, cte_name);
+        }
+
         /* Generate the recursive CTE (added to unified builder) */
         if (generate_varlen_cte(ctx, rel, source_alias, target_alias, cte_name) < 0) {
             ctx->has_error = true;

src/backend/transform/transform_return.c

@@ -954,6 +954,39 @@ int transform_expression(cypher_transform_context *ctx, ast_node *expr)
                                 alias, alias, alias, alias, alias);
                             }
                         } else if (transform_var_is_edge(ctx->var_ctx, id->name)) {
+                            /* T-0309: varlen-bound edge variable holds a path
+                             * of edges (CTE alias has columns start_id/end_id/
+                             * depth/path_ids/visited, not edge fields). Emit
+                             * a JSON array constructed from path_ids — one
+                             * edge JSON per id, in path order. */
+                            transform_var *evar = transform_var_lookup_edge(ctx->var_ctx, id->name);
+                            if (evar && evar->cte_name) {
+                                append_sql(ctx,
+                                  "(SELECT json_group_array(json_object("
+                                    "'id', e.id, "
+                                    "'type', e.type, "
+                                    "'startNodeId', e.source_id, "
+                                    "'endNodeId', e.target_id, "
+                                    "'properties', COALESCE((SELECT json_group_object(pk.key, COALESCE("
+                                      "(SELECT ept.value FROM edge_props_text ept WHERE ept.edge_id = e.id AND ept.key_id = pk.id), "
+                                      "(SELECT epi.value FROM edge_props_int epi WHERE epi.edge_id = e.id AND epi.key_id = pk.id), "
+                                      "(SELECT epr.value FROM edge_props_real epr WHERE epr.edge_id = e.id AND epr.key_id = pk.id), "
+                                      "(SELECT epb.value FROM edge_props_bool epb WHERE epb.edge_id = e.id AND epb.key_id = pk.id), "
+                                      "(SELECT json(epj.value) FROM edge_props_json epj WHERE epj.edge_id = e.id AND epj.key_id = pk.id))) "
+                                      "FROM property_keys pk WHERE "
+                                        "EXISTS (SELECT 1 FROM edge_props_text WHERE edge_id = e.id AND key_id = pk.id) OR "
+                                        "EXISTS (SELECT 1 FROM edge_props_int WHERE edge_id = e.id AND key_id = pk.id) OR "
+                                        "EXISTS (SELECT 1 FROM edge_props_real WHERE edge_id = e.id AND key_id = pk.id) OR "
+                                        "EXISTS (SELECT 1 FROM edge_props_bool WHERE edge_id = e.id AND key_id = pk.id) OR "
+                                        "EXISTS (SELECT 1 FROM edge_props_json WHERE edge_id = e.id AND key_id = pk.id)"
+                                      "), json('{}'))"
+                                  ")) "
+                                  "FROM edges e WHERE e.id IN ("
+                                    "SELECT CAST(value AS INTEGER) FROM json_each('[' || %s.path_ids || ']')"
+                                  ") ORDER BY instr(',' || %s.path_ids || ',', ',' || e.id || ','))",
+                                  alias, alias);
+                                goto edge_alias_projection_done;
+                            }
                             /* Edge variable - return full relationship object,
                              * or NULL when the row came from an OPTIONAL MATCH
                              * miss (LEFT JOIN with no match → alias.id IS NULL). */
@@ -980,6 +1013,7 @@ int transform_expression(cypher_transform_context *ctx, ast_node *expr)
                             alias, alias, alias, alias,
                             alias, alias, alias, alias, alias,
                             alias, alias, alias, alias, alias);
+                            edge_alias_projection_done: ;
                         } else {
                             /* This is a node variable - return full node object,
                              * or NULL when the row came from an OPTIONAL MATCH

src/extension.c

@@ -147,19 +147,26 @@ static void graphqlite_cypher_func(sqlite3_context *context, int argc, sqlite3_v
         if (result->row_count > 0 && result->use_agtype && result->agtype_data) {
             /* Use AGE-compatible format */
             if (result->row_count == 1 && result->column_count == 1) {
-                /* Single result - wrap with column name for consistent format */
-                char *agtype_str = agtype_value_to_string(result->agtype_data[0][0]);
-                if (agtype_str) {
+                /* Single result - wrap with column name for consistent format.
+                 * T-0309: when agtype cell is unset (varlen edge JSON array
+                 * lives in result->data verbatim), agtype_value_to_string(NULL)
+                 * returns 'null' — we want the text data instead. */
+                int use_text_fallback = (result->agtype_data[0][0] == NULL &&
+                                          result->data && result->data[0] && result->data[0][0]);
+                char *agtype_str = use_text_fallback ? NULL : agtype_value_to_string(result->agtype_data[0][0]);
+                const char *text_val = use_text_fallback ? result->data[0][0] : NULL;
+                if (agtype_str || text_val) {
+                    const char *render = agtype_str ? agtype_str : text_val;
                     const char *col_name = (result->column_names && result->column_names[0])
                         ? result->column_names[0] : "result";
-                    int json_size = strlen(agtype_str) + strlen(col_name) + 32;
+                    int json_size = strlen(render) + strlen(col_name) + 32;
                     char *json_result = malloc(json_size);
                     if (json_result) {
-                        snprintf(json_result, json_size, "[{\"%s\": %s}]", col_name, agtype_str);
+                        snprintf(json_result, json_size, "[{\"%s\": %s}]", col_name, render);
                         sqlite3_result_text(context, json_result, -1, SQLITE_TRANSIENT);
                         free(json_result);
                     } else {
-                        sqlite3_result_text(context, agtype_str, -1, SQLITE_TRANSIENT);
+                        sqlite3_result_text(context, render, -1, SQLITE_TRANSIENT);
                     }
                     free(agtype_str);
                 } else {
@@ -176,6 +183,9 @@ static void graphqlite_cypher_func(sqlite3_context *context, int argc, sqlite3_v
                                 buffer_size += strlen(temp_str) + 20;
                                 free(temp_str);
                             }
+                        } else if (result->data && result->data[row] && result->data[row][col]) {
+                            /* T-0309: include text fallback data in sizing. */
+                            buffer_size += strlen(result->data[row][col]) + 20;
                         }
                     }
                 }
@@ -203,13 +213,25 @@ static void graphqlite_cypher_func(sqlite3_context *context, int argc, sqlite3_v
                             offset += snprintf(json_result + offset, buffer_size - offset, "result");
                         }
                         offset += snprintf(json_result + offset, buffer_size - offset, "\":");
-                        char *agtype_str = agtype_value_to_string(result->agtype_data[row][0]);
-                        if (agtype_str) {
-                            size_t slen = strlen(agtype_str);
-                            if (offset + slen < buffer_size) { memcpy(json_result + offset, agtype_str, slen); offset += slen; }
-                            free(agtype_str);
+                        /* T-0309: when agtype cell unset (varlen edge JSON
+                         * array in result->data), fall back to text data
+                         * verbatim. agtype_value_to_string(NULL) returns
+                         * 'null' — so the fallback must check the agtype
+                         * pointer itself, not the rendered string. */
+                        if (result->agtype_data[row][0] == NULL &&
+                            result->data && result->data[row] && result->data[row][0]) {
+                            const char *txt = result->data[row][0];
+                            size_t slen = strlen(txt);
+                            if (offset + slen < buffer_size) { memcpy(json_result + offset, txt, slen); offset += slen; }
                         } else {
-                            offset += snprintf(json_result + offset, buffer_size - offset, "null");
+                            char *agtype_str = agtype_value_to_string(result->agtype_data[row][0]);
+                            if (agtype_str) {
+                                size_t slen = strlen(agtype_str);
+                                if (offset + slen < buffer_size) { memcpy(json_result + offset, agtype_str, slen); offset += slen; }
+                                free(agtype_str);
+                            } else {
+                                offset += snprintf(json_result + offset, buffer_size - offset, "null");
+                            }
                         }
                         offset += snprintf(json_result + offset, buffer_size - offset, "}");
                     } else {
@@ -230,13 +252,24 @@ static void graphqlite_cypher_func(sqlite3_context *context, int argc, sqlite3_v
                             }
                             offset += snprintf(json_result + offset, buffer_size - offset, "\":");
 
-                            char *agtype_str = agtype_value_to_string(result->agtype_data[row][col]);
-                            if (agtype_str) {
-                                size_t slen = strlen(agtype_str);
-                                if (offset + slen < buffer_size) { memcpy(json_result + offset, agtype_str, slen); offset += slen; }
-                                free(agtype_str);
+                            /* T-0309: agtype_value_to_string(NULL) returns
+                             * 'null' — so the text-fallback path must be
+                             * gated on agtype_data being NULL, not the
+                             * return value. */
+                            if (result->agtype_data[row][col] == NULL &&
+                                result->data && result->data[row] && result->data[row][col]) {
+                                const char *txt = result->data[row][col];
+                                size_t slen = strlen(txt);
+                                if (offset + slen < buffer_size) { memcpy(json_result + offset, txt, slen); offset += slen; }
                             } else {
-                                offset += snprintf(json_result + offset, buffer_size - offset, "null");
+                                char *agtype_str = agtype_value_to_string(result->agtype_data[row][col]);
+                                if (agtype_str) {
+                                    size_t slen = strlen(agtype_str);
+                                    if (offset + slen < buffer_size) { memcpy(json_result + offset, agtype_str, slen); offset += slen; }
+                                    free(agtype_str);
+                                } else {
+                                    offset += snprintf(json_result + offset, buffer_size - offset, "null");
+                                }
                             }
                         }
                         offset += snprintf(json_result + offset, buffer_size - offset, "}");