leangraph 1.1.0 → 1.1.1

package/dist/translator.js

@@ -3541,51 +3541,51 @@ export class Translator {
                     if (isUndirected2) {
                         // Undirected: traverse in both directions
                         if (edgeType2) {
-                            cte2 = `, ${pathCteName2}(start_id, end_id, depth, edge_ids) AS (
-  SELECT id, id, 0, json_array() FROM nodes
+                            cte2 = `, ${pathCteName2}(start_id, end_id, depth, edge_ids, row_num) AS (
+  SELECT id, id, 0, json_array(), ROW_NUMBER() OVER () FROM nodes
   UNION ALL
-  SELECT p.start_id, CASE WHEN p.end_id = e.source_id THEN e.target_id ELSE e.source_id END, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties)))
+  SELECT p.start_id, CASE WHEN p.end_id = e.source_id THEN e.target_id ELSE e.source_id END, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties))), p.row_num + 1
   FROM ${pathCteName2} p
   JOIN edges e ON (p.end_id = e.source_id OR p.end_id = e.target_id)
-  WHERE p.depth < ? AND e.type = ? AND NOT EXISTS (SELECT 1 FROM json_each(p.edge_ids) WHERE json_extract(value, '$.id') = e.id)
+  WHERE p.depth < ? AND e.type = ? AND NOT EXISTS (SELECT 1 FROM json_each(p.edge_ids) WHERE json_extract(value, '$.id') = e.id) AND p.row_num < ?
 )`;
-                            allParams.push(maxHops2, edgeType2);
+                            allParams.push(maxHops2, edgeType2, earlyTerminationLimit);
                         }
                         else {
-                            cte2 = `, ${pathCteName2}(start_id, end_id, depth, edge_ids) AS (
-  SELECT id, id, 0, json_array() FROM nodes
+                            cte2 = `, ${pathCteName2}(start_id, end_id, depth, edge_ids, row_num) AS (
+  SELECT id, id, 0, json_array(), ROW_NUMBER() OVER () FROM nodes
   UNION ALL
-  SELECT p.start_id, CASE WHEN p.end_id = e.source_id THEN e.target_id ELSE e.source_id END, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties)))
+  SELECT p.start_id, CASE WHEN p.end_id = e.source_id THEN e.target_id ELSE e.source_id END, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties))), p.row_num + 1
   FROM ${pathCteName2} p
   JOIN edges e ON (p.end_id = e.source_id OR p.end_id = e.target_id)
-  WHERE p.depth < ? AND NOT EXISTS (SELECT 1 FROM json_each(p.edge_ids) WHERE json_extract(value, '$.id') = e.id)
+  WHERE p.depth < ? AND NOT EXISTS (SELECT 1 FROM json_each(p.edge_ids) WHERE json_extract(value, '$.id') = e.id) AND p.row_num < ?
 )`;
-                            allParams.push(maxHops2);
+                            allParams.push(maxHops2, earlyTerminationLimit);
                         }
                     }
                     else {
                         // Directed
                         if (edgeType2) {
-                            cte2 = `, ${pathCteName2}(start_id, end_id, depth, edge_ids) AS (
-  SELECT id, id, 0, json_array() FROM nodes
+                            cte2 = `, ${pathCteName2}(start_id, end_id, depth, edge_ids, row_num) AS (
+  SELECT id, id, 0, json_array(), ROW_NUMBER() OVER () FROM nodes
   UNION ALL
-  SELECT p.start_id, e.target_id, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties)))
+  SELECT p.start_id, e.target_id, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties))), p.row_num + 1
   FROM ${pathCteName2} p
   JOIN edges e ON p.end_id = e.source_id
-  WHERE p.depth < ? AND e.type = ?
+  WHERE p.depth < ? AND e.type = ? AND p.row_num < ?
 )`;
-                            allParams.push(maxHops2, edgeType2);
+                            allParams.push(maxHops2, edgeType2, earlyTerminationLimit);
                         }
                         else {
-                            cte2 = `, ${pathCteName2}(start_id, end_id, depth, edge_ids) AS (
-  SELECT id, id, 0, json_array() FROM nodes
+                            cte2 = `, ${pathCteName2}(start_id, end_id, depth, edge_ids, row_num) AS (
+  SELECT id, id, 0, json_array(), ROW_NUMBER() OVER () FROM nodes
   UNION ALL
-  SELECT p.start_id, e.target_id, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties)))
+  SELECT p.start_id, e.target_id, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties))), p.row_num + 1
   FROM ${pathCteName2} p
   JOIN edges e ON p.end_id = e.source_id
-  WHERE p.depth < ?
+  WHERE p.depth < ? AND p.row_num < ?
 )`;
-                            allParams.push(maxHops2);
+                            allParams.push(maxHops2, earlyTerminationLimit);
                         }
                     }
                 }
@@ -3593,55 +3593,55 @@ export class Translator {
                     if (isUndirected2) {
                         // Undirected: traverse in both directions
                         if (edgeType2) {
-                            cte2 = `, ${pathCteName2}(start_id, end_id, depth, edge_ids) AS (
-  SELECT source_id, target_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))) FROM edges WHERE type = ?
+                            cte2 = `, ${pathCteName2}(start_id, end_id, depth, edge_ids, row_num) AS (
+  SELECT source_id, target_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))), ROW_NUMBER() OVER () FROM edges WHERE type = ?
   UNION ALL
-  SELECT target_id, source_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))) FROM edges WHERE type = ?
+  SELECT target_id, source_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))), ROW_NUMBER() OVER () FROM edges WHERE type = ?
   UNION ALL
-  SELECT p.start_id, CASE WHEN p.end_id = e.source_id THEN e.target_id ELSE e.source_id END, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties)))
+  SELECT p.start_id, CASE WHEN p.end_id = e.source_id THEN e.target_id ELSE e.source_id END, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties))), p.row_num + 1
   FROM ${pathCteName2} p
   JOIN edges e ON (p.end_id = e.source_id OR p.end_id = e.target_id)
-  WHERE p.depth < ? AND e.type = ? AND NOT EXISTS (SELECT 1 FROM json_each(p.edge_ids) WHERE json_extract(value, '$.id') = e.id)
+  WHERE p.depth < ? AND e.type = ? AND NOT EXISTS (SELECT 1 FROM json_each(p.edge_ids) WHERE json_extract(value, '$.id') = e.id) AND p.row_num < ?
 )`;
-                            allParams.push(edgeType2, edgeType2, maxHops2, edgeType2);
+                            allParams.push(edgeType2, edgeType2, maxHops2, edgeType2, earlyTerminationLimit);
                         }
                         else {
-                            cte2 = `, ${pathCteName2}(start_id, end_id, depth, edge_ids) AS (
-  SELECT source_id, target_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))) FROM edges
+                            cte2 = `, ${pathCteName2}(start_id, end_id, depth, edge_ids, row_num) AS (
+  SELECT source_id, target_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))), ROW_NUMBER() OVER () FROM edges
   UNION ALL
-  SELECT target_id, source_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))) FROM edges
+  SELECT target_id, source_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))), ROW_NUMBER() OVER () FROM edges
   UNION ALL
-  SELECT p.start_id, CASE WHEN p.end_id = e.source_id THEN e.target_id ELSE e.source_id END, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties)))
+  SELECT p.start_id, CASE WHEN p.end_id = e.source_id THEN e.target_id ELSE e.source_id END, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties))), p.row_num + 1
   FROM ${pathCteName2} p
   JOIN edges e ON (p.end_id = e.source_id OR p.end_id = e.target_id)
-  WHERE p.depth < ? AND NOT EXISTS (SELECT 1 FROM json_each(p.edge_ids) WHERE json_extract(value, '$.id') = e.id)
+  WHERE p.depth < ? AND NOT EXISTS (SELECT 1 FROM json_each(p.edge_ids) WHERE json_extract(value, '$.id') = e.id) AND p.row_num < ?
 )`;
-                            allParams.push(maxHops2);
+                            allParams.push(maxHops2, earlyTerminationLimit);
                         }
                     }
                     else {
                         // Directed
                         if (edgeType2) {
-                            cte2 = `, ${pathCteName2}(start_id, end_id, depth, edge_ids) AS (
-  SELECT source_id, target_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))) FROM edges WHERE type = ?
+                            cte2 = `, ${pathCteName2}(start_id, end_id, depth, edge_ids, row_num) AS (
+  SELECT source_id, target_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))), ROW_NUMBER() OVER () FROM edges WHERE type = ?
   UNION ALL
-  SELECT p.start_id, e.target_id, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties)))
+  SELECT p.start_id, e.target_id, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties))), p.row_num + 1
   FROM ${pathCteName2} p
   JOIN edges e ON p.end_id = e.source_id
-  WHERE p.depth < ? AND e.type = ?
+  WHERE p.depth < ? AND e.type = ? AND p.row_num < ?
 )`;
-                            allParams.push(edgeType2, maxHops2, edgeType2);
+                            allParams.push(edgeType2, maxHops2, edgeType2, earlyTerminationLimit);
                         }
                         else {
-                            cte2 = `, ${pathCteName2}(start_id, end_id, depth, edge_ids) AS (
-  SELECT source_id, target_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))) FROM edges
+                            cte2 = `, ${pathCteName2}(start_id, end_id, depth, edge_ids, row_num) AS (
+  SELECT source_id, target_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))), ROW_NUMBER() OVER () FROM edges
   UNION ALL
-  SELECT p.start_id, e.target_id, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties)))
+  SELECT p.start_id, e.target_id, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties))), p.row_num + 1
   FROM ${pathCteName2} p
   JOIN edges e ON p.end_id = e.source_id
-  WHERE p.depth < ?
+  WHERE p.depth < ? AND p.row_num < ?
 )`;
-                            allParams.push(maxHops2);
+                            allParams.push(maxHops2, earlyTerminationLimit);
                         }
                     }
                 }
@@ -4079,7 +4079,7 @@ export class Translator {
                     return { sql: "?", params: [expr.value] };
                 }
                 if (typeof expr.value === "boolean") {
-                    return { sql: expr.value ? "1" : "0", params };
+                    return { sql: expr.value ? "json('true')" : "json('false')", params };
                 }
                 if (expr.value === null) {
                     return { sql: "NULL", params };
@@ -5409,6 +5409,16 @@ END FROM (SELECT json_group_array(${valueExpr}) as sv))`,
                     }
                     throw new Error("sqrt requires an argument");
                 }
+                // SIGN: returns -1, 0, or 1 based on the sign of the number
+                if (expr.functionName === "SIGN") {
+                    if (expr.args && expr.args.length > 0) {
+                        const argResult = this.translateFunctionArg(expr.args[0]);
+                        tables.push(...argResult.tables);
+                        params.push(...argResult.params);
+                        return { sql: `SIGN(${argResult.sql})`, tables, params };
+                    }
+                    throw new Error("sign requires an argument");
+                }
                 // RAND: random float between 0 and 1
                 if (expr.functionName === "RAND") {
                     // SQLite's RANDOM() returns integer between -9223372036854775808 and 9223372036854775807
@@ -7858,7 +7868,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                         // Strip JSON quotes if input is wrapped in "" (from toString() output)
                         const argResult = this.translateExpression(arg);
                         tables.push(...argResult.tables);
-                        params.push(...argResult.params, ...argResult.params);
+                        params.push(...argResult.params);
                         return {
                             sql: `(SELECT CASE WHEN _d IS NULL THEN NULL ELSE CASE
                 WHEN substr(_d, 1, 1) = '"' AND substr(_d, length(_d), 1) = '"'
@@ -8187,16 +8197,25 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                         const listResult = this.translateExpression(listArg);
                         const indexResult = this.translateExpression(indexArg);
                         tables.push(...listResult.tables, ...indexResult.tables);
-                        params.push(...listResult.params, ...indexResult.params);
                         // For map access with string key, use json_extract with the key
                         // For list access with integer index, use json_extract with array index
                         if (isContainerMap || isStringExpression(resolvedIndexArg)) {
                             // Map access: use key directly
+                            params.push(...listResult.params, ...indexResult.params);
                             return { sql: `json_extract(${listResult.sql}, '$.' || ${indexResult.sql})`, tables, params };
                         }
                         // Use -> operator with array index to preserve JSON types (booleans, etc.)
                         // Cast index to integer to avoid "0.0" in JSON path
-                        return { sql: `(${listResult.sql}) -> ('$[' || CAST(${indexResult.sql} AS INTEGER) || ']')`, tables, params };
+                        // Handle negative indices by converting to positive using json_array_length
+                        // Cypher: list[-1] gets last element, list[-2] gets second to last, etc.
+                        const idxCast = `CAST(${indexResult.sql} AS INTEGER)`;
+                        // SQL expression uses: list (for ->), idx (for CASE condition), list (for json_array_length), idx (for + in THEN), idx (for ELSE)
+                        params.push(...listResult.params, ...indexResult.params, ...listResult.params, ...indexResult.params, ...indexResult.params);
+                        return {
+                            sql: `(${listResult.sql}) -> ('$[' || (CASE WHEN ${idxCast} < 0 THEN json_array_length(${listResult.sql}) + ${idxCast} ELSE ${idxCast} END) || ']')`,
+                            tables,
+                            params
+                        };
                     }
                     throw new Error("INDEX requires list and index arguments");
                 }
@@ -8335,8 +8354,14 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 if (Array.isArray(expr.value)) {
                     return this.translateArrayLiteral(expr.value);
                 }
-                // Convert booleans to 1/0 for SQLite
-                const value = expr.value === true ? 1 : expr.value === false ? 0 : expr.value;
+                // Return JSON booleans to preserve boolean type in results
+                if (expr.value === true) {
+                    return { sql: "json('true')", tables, params };
+                }
+                if (expr.value === false) {
+                    return { sql: "json('false')", tables, params };
+                }
+                const value = expr.value;
                 // Preserve float-literal formatting (e.g., 0.0, -0.0, 1.0) so SQLite treats them as REAL.
                 if (typeof value === "number" && expr.numberLiteralKind === "float" && expr.raw) {
                     return { sql: expr.raw, tables, params };
@@ -8377,8 +8402,29 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
             case "patternComprehension": {
                 return this.translatePatternComprehension(expr);
             }
+            case "existsPattern": {
+                return this.translateExistsPattern(expr);
+            }
             case "listPredicate": {
-                return this.translateListPredicate(expr);
+                // Wrap list predicate result with cypher_to_json_bool for proper boolean output in RETURN
+                // translateListPredicate returns 0/1 for SQLite WHERE compatibility
+                const result = this.translateListPredicate(expr);
+                return {
+                    sql: `cypher_to_json_bool(${result.sql})`,
+                    tables: result.tables,
+                    params: result.params,
+                };
+            }
+            case "reduce": {
+                return this.translateReduceExpression(expr);
+            }
+            case "filter": {
+                // filter(x IN list WHERE cond) - same as list comprehension without map expression
+                return this.translateFilterExpression(expr);
+            }
+            case "extract": {
+                // extract(x IN list | expr) - same as list comprehension without filter
+                return this.translateExtractExpression(expr);
             }
             case "unary": {
                 return this.translateUnaryExpression(expr);
@@ -8472,7 +8518,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 if (listExpr.type === "literal" && Array.isArray(listExpr.value)) {
                     const values = listExpr.value;
                     if (values.length === 0) {
-                        return { sql: "0", tables, params }; // false for empty list
+                        return { sql: "json('false')", tables, params }; // false for empty list
                     }
                     // Check if RHS contains complex types (nested arrays/objects)
                     const rhsHasComplexTypes = values.some(containsComplexTypes);
@@ -8503,7 +8549,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                                 // If LHS contains null, finding a JSON match means comparing null=null → return NULL
                                 params.push(rhsJson, lhsJson);
                                 return {
-                                    sql: `CASE WHEN EXISTS(SELECT 1 FROM json_each(?) WHERE json(value) = json(?)) THEN NULL ELSE 0 END`,
+                                    sql: `CASE WHEN EXISTS(SELECT 1 FROM json_each(?) WHERE json(value) = json(?)) THEN NULL ELSE json('false') END`,
                                     tables,
                                     params,
                                 };
@@ -8512,7 +8558,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                                 // If RHS has top-level null and no match, return NULL
                                 params.push(rhsJson, lhsJson);
                                 return {
-                                    sql: `CASE WHEN EXISTS(SELECT 1 FROM json_each(?) WHERE json(value) = json(?)) THEN 1 ELSE NULL END`,
+                                    sql: `CASE WHEN EXISTS(SELECT 1 FROM json_each(?) WHERE json(value) = json(?)) THEN json('true') ELSE NULL END`,
                                     tables,
                                     params,
                                 };
@@ -8528,7 +8574,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                                 params.push(lhsJson, rhsJson);
                                 return {
                                     sql: `(SELECT CASE 
-                    WHEN EXISTS(SELECT 1 FROM json_each(rhs_param.v) WHERE json(value) = json(lhs_param.v)) THEN 1
+                    WHEN EXISTS(SELECT 1 FROM json_each(rhs_param.v) WHERE json(value) = json(lhs_param.v)) THEN json('true')
                     WHEN EXISTS(
                       SELECT 1 FROM (
                         SELECT rhs.rowid,
@@ -8542,7 +8588,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                         GROUP BY rhs.rowid
                       ) WHERE mismatches = 0 AND nulls > 0
                     ) THEN NULL
-                    ELSE 0
+                    ELSE json('false')
                   END FROM (SELECT ? AS v) AS lhs_param, (SELECT ? AS v) AS rhs_param)`,
                                     tables,
                                     params,
@@ -8551,7 +8597,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                             // No null semantics needed - simple JSON comparison
                             params.push(rhsJson, lhsJson);
                             return {
-                                sql: `EXISTS(SELECT 1 FROM json_each(?) WHERE json(value) = json(?))`,
+                                sql: `cypher_to_json_bool(EXISTS(SELECT 1 FROM json_each(?) WHERE json(value) = json(?)))`,
                                 tables,
                                 params,
                             };
@@ -8564,47 +8610,63 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                         // So rhsJson comes first (for json_each), then leftResult.params (for leftResult.sql)
                         params.push(rhsJson);
                         params.push(...leftResult.params);
-                        // When LHS is a scalar expression (like comparison result), don't use json() wrapper
-                        // because SQLite UDF returns real type and json(0.0) != json(0) 
-                        // Use direct value comparison which handles int/real equality correctly
+                        // When LHS is a scalar expression (like comparison result), use cypher_bool_eq
+                        // to handle type mismatches between JSON boolean strings ('true'/'false') and integers (1/0)
                         const useDirectComparison = !leftIsComplex;
                         if (rhsHasTopLevelNull) {
                             if (useDirectComparison) {
+                                // Check for exact match first, then check for null comparison
                                 return {
-                                    sql: `CASE WHEN EXISTS(SELECT 1 FROM json_each(?) WHERE value = ${leftResult.sql}) THEN 1 ELSE NULL END`,
+                                    sql: `CASE WHEN EXISTS(SELECT 1 FROM json_each(?) WHERE cypher_bool_eq(value, ${leftResult.sql}) = 1) THEN json('true') WHEN EXISTS(SELECT 1 FROM json_each(?) WHERE cypher_bool_eq(value, ${leftResult.sql}) IS NULL) THEN NULL ELSE json('false') END`,
                                     tables,
-                                    params,
+                                    params: [...params, ...params], // Duplicate for two json_each usages
                                 };
                             }
                             return {
-                                sql: `CASE WHEN EXISTS(SELECT 1 FROM json_each(?) WHERE json(value) = json(${leftResult.sql})) THEN 1 ELSE NULL END`,
+                                sql: `CASE WHEN EXISTS(SELECT 1 FROM json_each(?) WHERE json(value) = json(${leftResult.sql})) THEN json('true') ELSE NULL END`,
                                 tables,
                                 params,
                             };
                         }
                         if (useDirectComparison) {
                             return {
-                                sql: `EXISTS(SELECT 1 FROM json_each(?) WHERE value = ${leftResult.sql})`,
+                                sql: `cypher_to_json_bool(EXISTS(SELECT 1 FROM json_each(?) WHERE cypher_bool_eq(value, ${leftResult.sql})))`,
                                 tables,
                                 params,
                             };
                         }
                         return {
-                            sql: `EXISTS(SELECT 1 FROM json_each(?) WHERE json(value) = json(${leftResult.sql}))`,
+                            sql: `cypher_to_json_bool(EXISTS(SELECT 1 FROM json_each(?) WHERE json(value) = json(${leftResult.sql})))`,
                             tables,
                             params,
                         };
                     }
-                    // Simple scalar values - translate LHS and use SQL IN clause
+                    // Simple scalar values - use json_each with cypher_bool_eq for type-safe comparison
+                    // This handles cases where LHS is json('true') (string) and RHS values are integers (1, 0)
                     const leftResult = this.translateExpression(leftExpr);
                     tables.push(...leftResult.tables);
-                    params.push(...leftResult.params);
-                    const placeholders = values.map(() => "?").join(", ");
-                    params.push(...toSqliteParams(values));
+                    const rhsJson = JSON.stringify(values);
                     // Wrap left side in extra parentheses to ensure correct precedence (e.g., NOT has lower precedence than IN in SQL)
                     const leftSql = leftExpr.type === "unary" ? `(${leftResult.sql})` : leftResult.sql;
+                    // Cypher null semantics: if RHS has top-level null and no exact match is found, return null
+                    // e.g., null IN [null] returns null (unknown), not false
+                    // e.g., 1 IN [2, null] returns null (unknown) because null could be 1
+                    if (hasTopLevelNull(values)) {
+                        // IMPORTANT: params order must match SQL placeholder order
+                        // SQL: json_each(?) ... ${leftSql} ... json_each(?) ... cypher_bool_eq(${leftSql}, value)
+                        params.push(rhsJson, ...leftResult.params, rhsJson, ...leftResult.params);
+                        return {
+                            sql: `CASE WHEN EXISTS(SELECT 1 FROM json_each(?) WHERE value = ${leftSql}) THEN json('true') WHEN EXISTS(SELECT 1 FROM json_each(?) WHERE cypher_bool_eq(${leftSql}, value) IS NULL) THEN NULL ELSE json('false') END`,
+                            tables,
+                            params,
+                        };
+                    }
+                    // IMPORTANT: params order must match SQL placeholder order
+                    // SQL: json_each(?) ... cypher_bool_eq(${leftSql}, value)
+                    // So rhsJson comes first (for json_each), then leftResult.params (for ${leftSql})
+                    params.push(rhsJson, ...leftResult.params);
                     return {
-                        sql: `(${leftSql} IN (${placeholders}))`,
+                        sql: `cypher_to_json_bool(EXISTS(SELECT 1 FROM json_each(?) WHERE cypher_bool_eq(${leftSql}, value)))`,
                         tables,
                         params,
                     };
@@ -8613,7 +8675,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                     const paramValue = this.ctx.paramValues[listExpr.name];
                     if (Array.isArray(paramValue)) {
                         if (paramValue.length === 0) {
-                            return { sql: "0", tables, params }; // false for empty list
+                            return { sql: "json('false')", tables, params }; // false for empty list
                         }
                         // Check if RHS contains complex types
                         const rhsHasComplexTypes = paramValue.some(containsComplexTypes);
@@ -8626,7 +8688,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                                 const lhsJson = JSON.stringify(leftExpr.value);
                                 params.push(rhsJson, lhsJson);
                                 return {
-                                    sql: `EXISTS(SELECT 1 FROM json_each(?) WHERE json(value) = json(?))`,
+                                    sql: `cypher_to_json_bool(EXISTS(SELECT 1 FROM json_each(?) WHERE json(value) = json(?)))`,
                                     tables,
                                     params,
                                 };
@@ -8636,7 +8698,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                             params.push(...leftResult.params);
                             params.push(rhsJson);
                             return {
-                                sql: `EXISTS(SELECT 1 FROM json_each(?) WHERE json(value) = json(${leftResult.sql}))`,
+                                sql: `cypher_to_json_bool(EXISTS(SELECT 1 FROM json_each(?) WHERE json(value) = json(${leftResult.sql})))`,
                                 tables,
                                 params,
                             };
@@ -8650,7 +8712,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                         // Wrap left side in extra parentheses to ensure correct precedence (e.g., NOT has lower precedence than IN in SQL)
                         const leftSql = leftExpr.type === "unary" ? `(${leftResult.sql})` : leftResult.sql;
                         return {
-                            sql: `(${leftSql} IN (${placeholders}))`,
+                            sql: `cypher_to_json_bool(${leftSql} IN (${placeholders}))`,
                             tables,
                             params,
                         };
@@ -8667,7 +8729,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                     params.push(...listResult.params);
                     params.push(lhsJson);
                     return {
-                        sql: `EXISTS(SELECT 1 FROM json_each(${listResult.sql}) WHERE json(value) = json(?))`,
+                        sql: `cypher_to_json_bool(EXISTS(SELECT 1 FROM json_each(${listResult.sql}) WHERE json(value) = json(?)))`,
                         tables,
                         params,
                     };
@@ -8680,7 +8742,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                     params.push(...listResult.params);
                     params.push(...leftResult.params);
                     return {
-                        sql: `EXISTS(SELECT 1 FROM json_each(${listResult.sql}) WHERE json(value) = json(${leftResult.sql}))`,
+                        sql: `cypher_to_json_bool(EXISTS(SELECT 1 FROM json_each(${listResult.sql}) WHERE json(value) = json(${leftResult.sql})))`,
                         tables,
                         params,
                     };
@@ -8694,7 +8756,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 // Wrap left side in extra parentheses to ensure correct precedence (e.g., NOT has lower precedence than IN in SQL)
                 const leftSql = leftExpr.type === "unary" ? `(${leftResult.sql})` : leftResult.sql;
                 return {
-                    sql: `(${leftSql} IN (SELECT value FROM json_each(${listResult.sql})))`,
+                    sql: `cypher_to_json_bool(${leftSql} IN (SELECT value FROM json_each(${listResult.sql})))`,
                     tables,
                     params,
                 };
@@ -8717,7 +8779,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 if (stringOp === "CONTAINS") {
                     // INSTR returns position (1-based) if found, 0 if not found
                     return {
-                        sql: `CASE WHEN ${isString(leftResult.sql)} AND ${isString(rightResult.sql)} THEN INSTR(${leftResult.sql}, ${rightResult.sql}) > 0 ELSE NULL END`,
+                        sql: `CASE WHEN ${isString(leftResult.sql)} AND ${isString(rightResult.sql)} THEN cypher_to_json_bool(INSTR(${leftResult.sql}, ${rightResult.sql}) > 0) ELSE NULL END`,
                         tables,
                         // leftResult.sql appears 3 times, rightResult.sql appears 3 times
                         params: [...leftResult.params, ...leftResult.params, ...rightResult.params, ...rightResult.params, ...leftResult.params, ...rightResult.params],
@@ -8726,7 +8788,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 else if (stringOp === "STARTS WITH") {
                     // Use SUBSTR for case-sensitive prefix match
                     return {
-                        sql: `CASE WHEN ${isString(leftResult.sql)} AND ${isString(rightResult.sql)} THEN SUBSTR(${leftResult.sql}, 1, LENGTH(${rightResult.sql})) = ${rightResult.sql} ELSE NULL END`,
+                        sql: `CASE WHEN ${isString(leftResult.sql)} AND ${isString(rightResult.sql)} THEN cypher_to_json_bool(SUBSTR(${leftResult.sql}, 1, LENGTH(${rightResult.sql})) = ${rightResult.sql}) ELSE NULL END`,
                         tables,
                         // leftResult.sql appears 3 times, rightResult.sql appears 5 times
                         params: [...leftResult.params, ...leftResult.params, ...rightResult.params, ...rightResult.params, ...leftResult.params, ...rightResult.params, ...rightResult.params],
@@ -8736,7 +8798,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                     // ENDS WITH
                     // Use CASE to handle: 1) type check 2) empty suffix edge case, 3) case-sensitive suffix match
                     return {
-                        sql: `CASE WHEN NOT (${isString(leftResult.sql)} AND ${isString(rightResult.sql)}) THEN NULL WHEN LENGTH(${rightResult.sql}) = 0 THEN 1 ELSE SUBSTR(${leftResult.sql}, -LENGTH(${rightResult.sql})) = ${rightResult.sql} END`,
+                        sql: `CASE WHEN NOT (${isString(leftResult.sql)} AND ${isString(rightResult.sql)}) THEN NULL WHEN LENGTH(${rightResult.sql}) = 0 THEN json('true') ELSE cypher_to_json_bool(SUBSTR(${leftResult.sql}, -LENGTH(${rightResult.sql})) = ${rightResult.sql}) END`,
                         tables,
                         // leftResult.sql appears 4 times, rightResult.sql appears 6 times
                         params: [...leftResult.params, ...leftResult.params, ...rightResult.params, ...rightResult.params, ...rightResult.params, ...leftResult.params, ...rightResult.params, ...rightResult.params],
@@ -8970,7 +9032,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
             // Use custom cypher_and/cypher_or functions for proper JSON boolean handling
             const func = expr.operator === "AND" ? "cypher_and" : "cypher_or";
             return {
-                sql: `${func}(${leftResult.sql}, ${rightResult.sql})`,
+                sql: `cypher_to_json_bool(${func}(${leftResult.sql}, ${rightResult.sql}))`,
                 tables,
                 params,
             };
@@ -8983,13 +9045,11 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
             const leftSql = leftResult.sql;
             const rightSql = rightResult.sql;
             // XOR with NULL semantics: (a XOR b) = (a AND NOT b) OR (NOT a AND b)
-            // This naturally handles NULL: if a is NULL, (a AND NOT b) is NULL or FALSE, (NOT a AND b) is NULL or FALSE
-            // NULL OR NULL = NULL, NULL OR FALSE = NULL, so result is NULL when either input is NULL
+            // Use cypher_* functions to handle both JSON booleans and integers properly
             // Note: params are duplicated because the formula uses each operand twice:
-            // ((left AND NOT right) OR (NOT left AND right))
             const xorParams = [...leftResult.params, ...rightResult.params, ...leftResult.params, ...rightResult.params];
             return {
-                sql: `((${leftSql} AND NOT ${rightSql}) OR (NOT ${leftSql} AND ${rightSql}))`,
+                sql: `cypher_to_json_bool(cypher_or(cypher_and(${leftSql}, cypher_not(${rightSql})), cypher_and(cypher_not(${leftSql}), ${rightSql})))`,
                 tables,
                 params: xorParams,
             };
@@ -9614,8 +9674,13 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 if (Array.isArray(expr.value)) {
                     return this.translateArrayLiteral(expr.value);
                 }
-                const value = expr.value === true ? 1 : expr.value === false ? 0 : expr.value;
-                params.push(value);
+                if (expr.value === true) {
+                    return { sql: "json('true')", params };
+                }
+                if (expr.value === false) {
+                    return { sql: "json('false')", params };
+                }
+                params.push(expr.value);
                 return { sql: "?", params };
             case "property": {
                 // Use subquery to get property from the created node
@@ -9746,22 +9811,23 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
         if (leftCouldBeNaN || rightCouldBeNaN) {
             const op = expr.comparisonOperator;
             // For = and <>, NaN semantics always apply (return false/true respectively)
+            // Note: The expression appears twice in the CASE, so we need to duplicate params
             if (op === "=") {
                 // NaN = anything is false (including NaN = NaN)
-                // If the comparison returns NULL (because of NaN), return false (0)
+                // If the comparison returns NULL (because of NaN), return false
                 return {
-                    sql: `COALESCE((${leftSql} ${op} ${rightSql}), 0)`,
+                    sql: `CASE WHEN (${leftSql} ${op} ${rightSql}) IS NULL THEN json('false') WHEN (${leftSql} ${op} ${rightSql}) THEN json('true') ELSE json('false') END`,
                     tables,
-                    params,
+                    params: [...params, ...params],
                 };
             }
             else if (op === "<>") {
                 // NaN <> anything is true (including NaN <> NaN)
-                // If the comparison returns NULL (because of NaN), return true (1)
+                // If the comparison returns NULL (because of NaN), return true
                 return {
-                    sql: `COALESCE((${leftSql} ${op} ${rightSql}), 1)`,
+                    sql: `CASE WHEN (${leftSql} ${op} ${rightSql}) IS NULL THEN json('true') WHEN (${leftSql} ${op} ${rightSql}) THEN json('true') ELSE json('false') END`,
                     tables,
-                    params,
+                    params: [...params, ...params],
                 };
             }
             else {
@@ -9775,9 +9841,9 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 else {
                     // NaN compared to numeric via range operators returns false
                     return {
-                        sql: `COALESCE((${leftSql} ${op} ${rightSql}), 0)`,
+                        sql: `CASE WHEN (${leftSql} ${op} ${rightSql}) IS NULL THEN json('false') WHEN (${leftSql} ${op} ${rightSql}) THEN json('true') ELSE json('false') END`,
                         tables,
-                        params,
+                        params: [...params, ...params],
                     };
                 }
             }
@@ -9796,7 +9862,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
             };
             const func = opToFunc[expr.comparisonOperator];
             return {
-                sql: `${func}(${leftSql}, ${rightSql})`,
+                sql: `cypher_to_json_bool(${func}(${leftSql}, ${rightSql}))`,
                 tables,
                 params,
             };
@@ -9809,7 +9875,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
         if ((expr.comparisonOperator === "=" || expr.comparisonOperator === "<>") && needsCypherEquals) {
             if (expr.comparisonOperator === "=") {
                 return {
-                    sql: `cypher_equals(${leftSql}, ${rightSql})`,
+                    sql: `cypher_to_json_bool(cypher_equals(${leftSql}, ${rightSql}))`,
                     tables,
                     params,
                 };
@@ -9818,14 +9884,31 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 // <> is NOT equals: invert the result, but preserve null
                 // We need to duplicate params because cypher_equals appears twice in the SQL
                 return {
-                    sql: `CASE WHEN cypher_equals(${leftSql}, ${rightSql}) IS NULL THEN NULL WHEN cypher_equals(${leftSql}, ${rightSql}) = 1 THEN 0 ELSE 1 END`,
+                    sql: `CASE WHEN cypher_equals(${leftSql}, ${rightSql}) IS NULL THEN NULL WHEN cypher_equals(${leftSql}, ${rightSql}) = 1 THEN json('false') ELSE json('true') END`,
                     tables,
                     params: [...params, ...params],
                 };
             }
         }
+        // For equality comparisons, use cypher_bool_eq to handle mixed boolean representations
+        // (JSON boolean strings 'true'/'false' vs SQLite integers 1/0)
+        if (expr.comparisonOperator === "=") {
+            return {
+                sql: `cypher_to_json_bool(cypher_bool_eq(${leftSql}, ${rightSql}))`,
+                tables,
+                params,
+            };
+        }
+        if (expr.comparisonOperator === "<>") {
+            // <> is NOT equals: use cypher_bool_eq and invert the result
+            return {
+                sql: `cypher_to_json_bool(CASE WHEN cypher_bool_eq(${leftSql}, ${rightSql}) IS NULL THEN NULL ELSE 1 - cypher_bool_eq(${leftSql}, ${rightSql}) END)`,
+                tables,
+                params: [...params, ...params], // Duplicate params for the two uses
+            };
+        }
         return {
-            sql: `(${leftSql} ${expr.comparisonOperator} ${rightSql})`,
+            sql: `cypher_to_json_bool(${leftSql} ${expr.comparisonOperator} ${rightSql})`,
             tables,
             params,
         };
@@ -9952,6 +10035,197 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
         params.push(...mapParams, ...listResult.params, ...filterParams);
         return { sql, tables, params };
     }
+    /**
+     * Translate a reduce expression.
+     * Syntax: reduce(acc = init, x IN list | expr)
+     *
+     * Uses a recursive CTE to iterate through the list and accumulate a value.
+     *
+     * Example: reduce(acc = 0, x IN [1,2,3,4] | acc + x) returns 10
+     */
+    translateReduceExpression(expr) {
+        const tables = [];
+        const params = [];
+        const accumulator = expr.accumulator;
+        const initialValue = expr.initialValue;
+        const variable = expr.variable;
+        const listExpr = expr.listExpr;
+        const reduceExpr = expr.reduceExpr;
+        // Translate the initial value
+        const initResult = this.translateExpression(initialValue);
+        tables.push(...initResult.tables);
+        // Translate the source list expression
+        const listResult = this.translateExpression(listExpr);
+        tables.push(...listResult.tables);
+        // Build the reduce expression with variable substitutions
+        // Replace accumulator with "__red__.acc" and variable with "__red_elem.value"
+        const reduceResult = this.translateReduceBodyExpr(reduceExpr, accumulator, variable, "__red__", "__red_elem");
+        // Build recursive CTE:
+        // WITH RECURSIVE __red__(idx, acc) AS (
+        //   SELECT 0, <init>
+        //   UNION ALL
+        //   SELECT idx + 1, <reduceExpr>
+        //   FROM __red__, json_each(<list>) AS __red_elem__
+        //   WHERE __red__.idx = __red_elem__.key
+        // )
+        // SELECT acc FROM __red__ ORDER BY idx DESC LIMIT 1
+        const sql = `(WITH RECURSIVE __red__(idx, acc) AS (
+      SELECT 0, ${initResult.sql}
+      UNION ALL
+      SELECT __red__.idx + 1, ${reduceResult.sql}
+      FROM __red__, json_each(${listResult.sql}) AS __red_elem
+      WHERE __red__.idx = __red_elem.key
+    )
+    SELECT acc FROM __red__ ORDER BY idx DESC LIMIT 1)`;
+        // Params order: init params, then list params (once for each occurrence), then reduce params
+        params.push(...initResult.params, ...listResult.params, ...reduceResult.params);
+        return { sql, tables, params };
+    }
+    /**
+     * Translate a filter expression.
+     * Syntax: filter(x IN list WHERE predicate)
+     *
+     * Returns a list of elements that satisfy the predicate.
+     * Equivalent to list comprehension [x IN list WHERE predicate] without mapping.
+     */
+    translateFilterExpression(expr) {
+        const tables = [];
+        const params = [];
+        const variable = expr.variable;
+        const listExpr = expr.listExpr;
+        const filterCondition = expr.filterCondition;
+        // Translate the source list expression
+        const listResult = this.translateExpression(listExpr);
+        tables.push(...listResult.tables);
+        // Wrap the source expression for json_each
+        let sourceExpr = listResult.sql;
+        if (listExpr.type === "property") {
+            // For property access, use json_extract 
+            const varInfo = this.ctx.variables.get(listExpr.variable);
+            if (varInfo) {
+                sourceExpr = `json_extract(${varInfo.alias}.properties, '$.${listExpr.property}')`;
+            }
+        }
+        // Build the WHERE clause from the filter condition
+        const filterResult = this.translateListComprehensionCondition(filterCondition, variable, "__flt__");
+        const filterParams = filterResult.params;
+        const whereClause = ` WHERE ${filterResult.sql}`;
+        // Build the final SQL using json_group_array
+        const sql = `(SELECT json_group_array(__flt__.value) FROM json_each(${sourceExpr}) AS __flt__${whereClause})`;
+        // Params must match SQL order: source params, then filter params
+        params.push(...listResult.params, ...filterParams);
+        return { sql, tables, params };
+    }
+    /**
+     * Translate an extract expression.
+     * Syntax: extract(x IN list | expr)
+     *
+     * Returns a list of mapped values.
+     * Equivalent to list comprehension [x IN list | expr] without filtering.
+     */
+    translateExtractExpression(expr) {
+        const tables = [];
+        const params = [];
+        const variable = expr.variable;
+        const listExpr = expr.listExpr;
+        const mapExpr = expr.mapExpr;
+        // Translate the source list expression
+        const listResult = this.translateExpression(listExpr);
+        tables.push(...listResult.tables);
+        // Wrap the source expression for json_each
+        let sourceExpr = listResult.sql;
+        if (listExpr.type === "property") {
+            // For property access, use json_extract 
+            const varInfo = this.ctx.variables.get(listExpr.variable);
+            if (varInfo) {
+                sourceExpr = `json_extract(${varInfo.alias}.properties, '$.${listExpr.property}')`;
+            }
+        }
+        // Translate the map expression
+        const mapResult = this.translateListComprehensionExpr(mapExpr, variable, "__ext__");
+        const mapParams = mapResult.params;
+        const selectExpr = mapResult.sql;
+        // Build the final SQL using json_group_array
+        const sql = `(SELECT json_group_array(${selectExpr}) FROM json_each(${sourceExpr}) AS __ext__)`;
+        // Params must match SQL order: select params, then source params
+        params.push(...mapParams, ...listResult.params);
+        return { sql, tables, params };
+    }
+    /**
+     * Translate an expression within a reduce body, substituting variables.
+     */
+    translateReduceBodyExpr(expr, accVar, iterVar, tableAlias, elemAlias) {
+        const params = [];
+        switch (expr.type) {
+            case "variable": {
+                if (expr.variable === accVar) {
+                    return { sql: `${tableAlias}.acc`, params };
+                }
+                if (expr.variable === iterVar) {
+                    return { sql: `${elemAlias}.value`, params };
+                }
+                // Other variables - use the standard translation
+                const varInfo = this.ctx.variables.get(expr.variable);
+                if (varInfo) {
+                    return { sql: `${varInfo.alias}.${expr.property || "id"}`, params };
+                }
+                return { sql: expr.variable, params };
+            }
+            case "property": {
+                if (expr.variable === iterVar) {
+                    // Property access on the iterator variable: x.name
+                    return { sql: `json_extract(${elemAlias}.value, '$.${expr.property}')`, params };
+                }
+                if (expr.variable === accVar) {
+                    // Property access on accumulator (if acc is an object)
+                    return { sql: `json_extract(${tableAlias}.acc, '$.${expr.property}')`, params };
+                }
+                // Standard property translation
+                const varInfo = this.ctx.variables.get(expr.variable);
+                if (varInfo) {
+                    return { sql: `json_extract(${varInfo.alias}.properties, '$.${expr.property}')`, params };
+                }
+                return { sql: `json_extract(${expr.variable}, '$.${expr.property}')`, params };
+            }
+            case "literal": {
+                if (expr.value === null)
+                    return { sql: "NULL", params };
+                if (typeof expr.value === "boolean")
+                    return { sql: expr.value ? "json('true')" : "json('false')", params };
+                if (typeof expr.value === "number")
+                    return { sql: String(expr.value), params };
+                if (typeof expr.value === "string") {
+                    params.push(expr.value);
+                    return { sql: "?", params };
+                }
+                if (Array.isArray(expr.value)) {
+                    return { sql: `json('${JSON.stringify(expr.value)}')`, params };
+                }
+                return { sql: `json('${JSON.stringify(expr.value)}')`, params };
+            }
+            case "binary": {
+                const left = this.translateReduceBodyExpr(expr.left, accVar, iterVar, tableAlias, elemAlias);
+                const right = this.translateReduceBodyExpr(expr.right, accVar, iterVar, tableAlias, elemAlias);
+                params.push(...left.params, ...right.params);
+                return { sql: `(${left.sql} ${expr.operator} ${right.sql})`, params };
+            }
+            case "function": {
+                const funcName = expr.functionName.toUpperCase();
+                const args = expr.args || [];
+                const argResults = args.map(arg => this.translateReduceBodyExpr(arg, accVar, iterVar, tableAlias, elemAlias));
+                for (const arg of argResults) {
+                    params.push(...arg.params);
+                }
+                const argsSql = argResults.map(r => r.sql).join(", ");
+                return { sql: `${funcName}(${argsSql})`, params };
+            }
+            default: {
+                // For other expression types, fall back to standard translation
+                const result = this.translateExpression(expr);
+                return { sql: result.sql, params: result.params };
+            }
+        }
+    }
     /**
      * Translate a pattern comprehension expression.
      * Syntax: [(pattern) WHERE filterCondition | mapExpr]
@@ -10097,6 +10371,118 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
         tables.push(boundVarInfo.alias);
         return { sql, tables, params };
     }
+    /**
+     * Translate an exists() pattern expression.
+     * Returns true if the pattern has at least one match, false otherwise.
+     *
+     * Example: exists((p)-[:KNOWS]->()) returns true if node p has any outgoing KNOWS edges
+     */
+    translateExistsPattern(expr) {
+        const tables = [];
+        const params = [];
+        const patterns = expr.patterns;
+        // Pattern structure: patterns from parsePatternChain
+        // The first element is always a NodePattern or RelationshipPattern
+        const firstPattern = patterns[0];
+        const isRelPattern = (p) => {
+            return typeof p === "object" && p !== null && "edge" in p;
+        };
+        let startVar;
+        let relPattern;
+        let startNodePattern;
+        let targetNodePattern;
+        if (isRelPattern(firstPattern)) {
+            // First pattern is a RelationshipPattern
+            relPattern = firstPattern;
+            startNodePattern = relPattern.source;
+            targetNodePattern = relPattern.target;
+            startVar = startNodePattern.variable;
+        }
+        else {
+            // First pattern is a NodePattern, look for RelationshipPattern in rest
+            startNodePattern = firstPattern;
+            startVar = startNodePattern.variable;
+            for (let i = 1; i < patterns.length; i++) {
+                if (isRelPattern(patterns[i])) {
+                    relPattern = patterns[i];
+                    targetNodePattern = relPattern.target;
+                    break;
+                }
+            }
+        }
+        if (!startVar) {
+            throw new Error("exists() pattern must start with a bound variable");
+        }
+        // Get the bound variable info from outer context
+        const boundVarInfo = this.ctx.variables.get(startVar);
+        if (!boundVarInfo) {
+            throw new Error(`Unknown variable in exists() pattern: ${startVar}`);
+        }
+        if (!relPattern) {
+            throw new Error("exists() pattern must include a relationship pattern");
+        }
+        // Build the correlated subquery
+        const edgeAlias = `__ex_e_${this.ctx.aliasCounter++}`;
+        const targetAlias = `__ex_t_${this.ctx.aliasCounter++}`;
+        const edge = relPattern.edge;
+        // Build edge type filter
+        const edgeTypes = edge.types || (edge.type ? [edge.type] : []);
+        let edgeTypeFilter = "";
+        const edgeTypeParams = [];
+        if (edgeTypes.length > 0) {
+            const typeConditions = edgeTypes.map((t) => `${edgeAlias}.type = ?`);
+            edgeTypeFilter = ` AND (${typeConditions.join(" OR ")})`;
+            edgeTypeParams.push(...edgeTypes);
+        }
+        // Build direction filter
+        let directionFilter = "";
+        const direction = edge.direction || "right";
+        if (direction === "right") {
+            directionFilter = `${edgeAlias}.source_id = ${boundVarInfo.alias}.id`;
+        }
+        else if (direction === "left") {
+            directionFilter = `${edgeAlias}.target_id = ${boundVarInfo.alias}.id`;
+        }
+        else {
+            // "none" means either direction
+            directionFilter = `(${edgeAlias}.source_id = ${boundVarInfo.alias}.id OR ${edgeAlias}.target_id = ${boundVarInfo.alias}.id)`;
+        }
+        // Build target node filter if labels specified
+        let targetFilter = "";
+        const targetFilterParams = [];
+        if (targetNodePattern && targetNodePattern.label) {
+            const labels = Array.isArray(targetNodePattern.label)
+                ? targetNodePattern.label
+                : [targetNodePattern.label];
+            const labelConditions = labels.map((l) => `EXISTS(SELECT 1 FROM json_each(${targetAlias}.label) WHERE value = ?)`);
+            targetFilter = ` AND ${labelConditions.join(" AND ")}`;
+            targetFilterParams.push(...labels);
+        }
+        // Build the from clause
+        let fromClause = `edges ${edgeAlias}`;
+        if (targetNodePattern && (targetNodePattern.label || targetNodePattern.variable)) {
+            // Need to join with nodes for target filtering
+            let targetJoin;
+            if (direction === "right") {
+                targetJoin = `${edgeAlias}.target_id = ${targetAlias}.id`;
+            }
+            else if (direction === "left") {
+                targetJoin = `${edgeAlias}.source_id = ${targetAlias}.id`;
+            }
+            else {
+                // For undirected, target is the "other" node
+                targetJoin = `(CASE WHEN ${edgeAlias}.source_id = ${boundVarInfo.alias}.id THEN ${edgeAlias}.target_id ELSE ${edgeAlias}.source_id END) = ${targetAlias}.id`;
+            }
+            fromClause = `edges ${edgeAlias} JOIN nodes ${targetAlias} ON ${targetJoin}`;
+        }
+        // Build the EXISTS subquery and wrap result for proper boolean output
+        const sql = `cypher_to_json_bool(EXISTS(SELECT 1 FROM ${fromClause} WHERE ${directionFilter}${edgeTypeFilter}${targetFilter}))`;
+        // Params must be in SQL order: edgeType, then targetFilter
+        params.push(...edgeTypeParams, ...targetFilterParams);
+        // Add outer table reference
+        tables.push(boundVarInfo.alias);
+        return { sql, tables, params };
+    }
     /**
      * Translate an expression within a pattern comprehension.
      */
@@ -10225,9 +10611,14 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 if (expr.value === null) {
                     return { sql: "NULL", params };
                 }
-                // Convert booleans to 1/0 for SQLite (SQLite can only bind numbers, strings, bigints, buffers, and null)
-                const literalValue = expr.value === true ? 1 : expr.value === false ? 0 : expr.value;
-                params.push(literalValue);
+                // Use 0/1 for booleans in list comprehension context (used in WHERE clauses)
+                if (expr.value === true) {
+                    return { sql: "1", params };
+                }
+                if (expr.value === false) {
+                    return { sql: "0", params };
+                }
+                params.push(expr.value);
                 return { sql: "?", params };
             case "parameter": {
                 const paramValue = this.ctx.paramValues[expr.name];
@@ -10352,10 +10743,34 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
             }
             case "expression": {
                 // Handle bare expressions used as boolean conditions (e.g., all(x IN list WHERE x))
+                // Need to convert JSON boolean strings to integers for SQLite WHERE clause evaluation
+                // JSON booleans in collected arrays are stored as strings "true"/"false" which SQLite
+                // treats as falsy (value 0) since they're not integers
                 const exprResult = this.translateListComprehensionExpr(condition.left, compVar, tableAlias, scopes);
+                // Wrap with CASE to handle JSON boolean strings, integers, and regular values
+                // - JSON "true" string -> 1
+                // - JSON "false" string -> 0
+                // - JSON true literal (rarely occurs) -> 1
+                // - JSON false literal (rarely occurs) -> 0
+                // - Integer 1 -> 1 (already truthy)
+                // - Integer 0 -> 0 (already falsy)
+                // - NULL -> NULL
+                // - Other truthy values pass through
+                const wrappedSql = `(CASE WHEN ${exprResult.sql} = 'true' OR ${exprResult.sql} = 1 OR ${exprResult.sql} IS TRUE THEN 1 WHEN ${exprResult.sql} = 'false' OR ${exprResult.sql} = 0 OR ${exprResult.sql} IS FALSE THEN 0 WHEN ${exprResult.sql} IS NULL THEN NULL ELSE ${exprResult.sql} END)`;
+                // Need to duplicate params for each use of exprResult.sql (6 uses total)
+                const allParams = [
+                    ...exprResult.params, // first condition check (= 'true')
+                    ...exprResult.params, // second condition check (= 1)
+                    ...exprResult.params, // third condition check (IS TRUE)
+                    ...exprResult.params, // fourth condition check (= 'false')
+                    ...exprResult.params, // fifth condition check (= 0)
+                    ...exprResult.params, // sixth condition check (IS FALSE)
+                    ...exprResult.params, // seventh condition check (IS NULL)
+                    ...exprResult.params, // ELSE fallback
+                ];
                 return {
-                    sql: exprResult.sql,
-                    params: exprResult.params,
+                    sql: wrappedSql,
+                    params: allParams,
                 };
             }
             case "listPredicate": {
@@ -10790,7 +11205,7 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
             params.push(...operandResult.params);
             // Use custom cypher_not function that properly handles JSON booleans and integers
             return {
-                sql: `cypher_not(${operandResult.sql})`,
+                sql: `cypher_to_json_bool(cypher_not(${operandResult.sql}))`,
                 tables,
                 params,
             };
@@ -10816,6 +11231,15 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                         params: [...left.params, ...right.params],
                     };
                 }
+                // For equality comparisons involving CASE expressions (which return json('true')/json('false')),
+                // use cypher_bool_eq to handle JSON boolean vs integer comparison
+                if (condition.operator === "=" &&
+                    (condition.left?.type === "case" || condition.right?.type === "case")) {
+                    return {
+                        sql: `cypher_bool_eq(${left.sql}, ${right.sql})`,
+                        params: [...left.params, ...right.params],
+                    };
+                }
                 return {
                     sql: `${left.sql} ${condition.operator} ${right.sql}`,
                     params: [...left.params, ...right.params],
@@ -10874,6 +11298,15 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                     params: [...left.params, ...right.params, ...right.params, ...left.params, ...right.params, ...right.params],
                 };
             }
+            case "regex": {
+                const left = this.translateWhereExpression(condition.left);
+                const right = this.translateWhereExpression(condition.right);
+                // Use cypher_regex custom function for regex matching
+                return {
+                    sql: `cypher_regex(${left.sql}, ${right.sql})`,
+                    params: [...left.params, ...right.params],
+                };
+            }
             case "isNull": {
                 const left = this.translateWhereExpression(condition.left);
                 return {
@@ -11730,6 +12163,11 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                     params: [],
                 };
             }
+            case "case": {
+                // CASE expression in WHERE clause
+                const result = this.translateCaseExpression(expr);
+                return { sql: result.sql, params: result.params };
+            }
             default:
                 throw new Error(`Unknown expression type in WHERE: ${expr.type}`);
         }
@@ -11758,7 +12196,14 @@ SELECT COALESCE(json_group_array(CAST(n AS INTEGER)), json_array()) FROM r)`,
                 };
             }
             case "literal": {
-                const value = expr.value === true ? 1 : expr.value === false ? 0 : expr.value;
+                // Return JSON booleans to preserve boolean type in results
+                if (expr.value === true) {
+                    return { sql: "json('true')", tables, params };
+                }
+                if (expr.value === false) {
+                    return { sql: "json('false')", tables, params };
+                }
+                const value = expr.value;
                 if (typeof value === "number" && expr.numberLiteralKind === "float" && expr.raw) {
                     return { sql: expr.raw, tables, params };
                 }