@nicia-ai/typegraph 0.11.1 → 0.13.0

package/dist/index.js

@@ -313,72 +313,6 @@ var core = {
   implies
 };
 
-// src/query/compiler/passes/recursive.ts
-function runRecursiveTraversalSelectionPass(ast) {
-  const variableLengthTraversal = ast.traversals.find(
-    (traversal) => traversal.variableLength !== void 0
-  );
-  if (variableLengthTraversal === void 0) {
-    throw new CompilerInvariantError("No variable-length traversal found");
-  }
-  if (ast.traversals.length > 1) {
-    throw new UnsupportedPredicateError(
-      "Variable-length traversals with multiple traversals are not yet supported. Please use a single variable-length traversal."
-    );
-  }
-  return variableLengthTraversal;
-}
-
-// src/query/compiler/passes/runner.ts
-function runCompilerPass(state, pass) {
-  const output = pass.execute(state);
-  return {
-    state: pass.update(state, output)
-  };
-}
-function compileTemporalFilter(options) {
-  const { mode, asOf, tableAlias, currentTimestamp } = options;
-  const prefix = tableAlias ? sql.raw(`${tableAlias}.`) : sql.raw("");
-  const deletedAt = sql`${prefix}deleted_at`;
-  const validFrom = sql`${prefix}valid_from`;
-  const validTo = sql`${prefix}valid_to`;
-  switch (mode) {
-    case "current": {
-      const now = currentTimestamp ?? sql`CURRENT_TIMESTAMP`;
-      return sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${now}) AND (${validTo} IS NULL OR ${validTo} > ${now})`;
-    }
-    case "asOf": {
-      const timestamp = asOf;
-      return sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${timestamp}) AND (${validTo} IS NULL OR ${validTo} > ${timestamp})`;
-    }
-    case "includeEnded": {
-      return sql`${deletedAt} IS NULL`;
-    }
-    case "includeTombstones": {
-      return sql.raw("1=1");
-    }
-  }
-}
-function extractTemporalOptions(ast, tableAlias) {
-  return {
-    mode: ast.temporalMode.mode,
-    asOf: ast.temporalMode.asOf,
-    tableAlias
-  };
-}
-
-// src/query/compiler/passes/temporal.ts
-function createTemporalFilterPass(ast, currentTimestamp) {
-  return {
-    forAlias(tableAlias) {
-      return compileTemporalFilter({
-        ...extractTemporalOptions(ast, tableAlias),
-        currentTimestamp
-      });
-    }
-  };
-}
-
 // src/query/subquery-utils.ts
 function normalizeValueType(valueType) {
   if (valueType === void 0 || valueType === "unknown") {
@@ -1465,1878 +1399,2477 @@ function extractVectorSimilarityPredicates(predicates) {
   return results;
 }
 
-// src/query/compiler/passes/vector.ts
-function runVectorPredicatePass(ast, dialect) {
-  const vectorPredicates = extractVectorSimilarityPredicates(ast.predicates);
-  if (vectorPredicates.length > 1) {
-    throw new UnsupportedPredicateError(
-      "Multiple vector similarity predicates in a single query are not supported"
+// src/query/compiler/predicate-utils.ts
+var EMPTY_PREDICATES = [];
+function buildPredicateIndexKey(alias, targetType) {
+  return `${alias}\0${targetType}`;
+}
+function resolvePredicateTargetType(predicate2) {
+  return predicate2.targetType === "edge" ? "edge" : "node";
+}
+function buildPredicateIndex(ast) {
+  const byAliasAndType = /* @__PURE__ */ new Map();
+  for (const predicate2 of ast.predicates) {
+    const key = buildPredicateIndexKey(
+      predicate2.targetAlias,
+      resolvePredicateTargetType(predicate2)
     );
+    const existing = byAliasAndType.get(key);
+    if (existing === void 0) {
+      byAliasAndType.set(key, [predicate2]);
+    } else {
+      existing.push(predicate2);
+    }
   }
-  const vectorPredicate = vectorPredicates[0];
-  if (vectorPredicate === void 0) {
-    return { vectorPredicate: void 0 };
+  return { byAliasAndType };
+}
+function getPredicatesForAlias(predicateIndex, alias, targetType) {
+  return predicateIndex.byAliasAndType.get(
+    buildPredicateIndexKey(alias, targetType)
+  ) ?? EMPTY_PREDICATES;
+}
+function compilePredicateClauses(predicates, predicateContext) {
+  return predicates.map(
+    (predicate2) => compilePredicateExpression(predicate2.expression, predicateContext)
+  );
+}
+function compileKindFilter(column, kinds) {
+  if (kinds.length === 0) {
+    return sql`1 = 0`;
   }
-  const vectorStrategy = dialect.capabilities.vectorPredicateStrategy;
-  if (vectorStrategy === "unsupported" || !dialect.supportsVectors) {
-    throw new UnsupportedPredicateError(
-      `Vector similarity predicates are not supported for dialect "${dialect.name}"`
-    );
+  if (kinds.length === 1) {
+    return sql`${column} = ${kinds[0]}`;
   }
-  if (!dialect.capabilities.vectorMetrics.includes(vectorPredicate.metric)) {
-    throw new UnsupportedPredicateError(
-      `Vector metric "${vectorPredicate.metric}" is not supported for dialect "${dialect.name}"`
-    );
+  return sql`${column} IN (${sql.join(
+    kinds.map((kind) => sql`${kind}`),
+    sql`, `
+  )})`;
+}
+function getNodeKindsForAlias(ast, alias) {
+  if (alias === ast.start.alias) {
+    return ast.start.kinds;
   }
-  if (!Number.isFinite(vectorPredicate.limit) || vectorPredicate.limit <= 0) {
-    throw new UnsupportedPredicateError(
-      `Vector predicate limit must be a positive finite number, got ${String(vectorPredicate.limit)}`
-    );
+  for (const traversal of ast.traversals) {
+    if (traversal.nodeAlias === alias) {
+      return traversal.nodeKinds;
+    }
   }
-  const { minScore } = vectorPredicate;
-  if (minScore !== void 0) {
-    if (!Number.isFinite(minScore)) {
-      throw new UnsupportedPredicateError(
-        `Vector minScore must be a finite number, got ${String(minScore)}`
-      );
+  throw new CompilerInvariantError(`Unknown traversal source alias: ${alias}`);
+}
+
+// src/query/compiler/emitter/plan-inspector.ts
+function collectPlanOperations(node, ops) {
+  ops.add(node.op);
+  switch (node.op) {
+    case "aggregate":
+    case "filter":
+    case "join":
+    case "limit_offset":
+    case "project":
+    case "recursive_expand":
+    case "sort":
+    case "vector_knn": {
+      collectPlanOperations(node.input, ops);
+      return;
     }
-    if (vectorPredicate.metric === "cosine" && (minScore < -1 || minScore > 1)) {
-      throw new UnsupportedPredicateError(
-        `Cosine minScore must be between -1 and 1, got ${String(minScore)}`
-      );
+    case "set_op": {
+      collectPlanOperations(node.left, ops);
+      collectPlanOperations(node.right, ops);
+      return;
+    }
+    case "scan": {
+      return;
     }
   }
-  return { vectorPredicate };
 }
-function resolveVectorAwareLimit(astLimit, vectorPredicate) {
-  if (vectorPredicate === void 0) {
-    return astLimit;
-  }
-  if (astLimit === void 0) {
-    return vectorPredicate.limit;
+function findUnaryNodeInProjectChain(rootNode, op) {
+  let currentNode = rootNode.input;
+  for (; ; ) {
+    if (currentNode.op === op) {
+      return currentNode;
+    }
+    switch (currentNode.op) {
+      case "aggregate":
+      case "filter":
+      case "join":
+      case "limit_offset":
+      case "recursive_expand":
+      case "sort":
+      case "vector_knn": {
+        currentNode = currentNode.input;
+        continue;
+      }
+      case "project":
+      case "scan":
+      case "set_op": {
+        return void 0;
+      }
+    }
   }
-  return Math.min(astLimit, vectorPredicate.limit);
 }
-
-// src/query/compiler/plan/lowering.ts
-function createPlanNodeIdFactory() {
-  let current = 0;
-  return function nextPlanNodeId() {
-    current += 1;
-    return `plan_${current.toString(36)}`;
+function inspectProjectPlan(logicalPlan) {
+  if (logicalPlan.root.op !== "project") {
+    throw new CompilerInvariantError(
+      `SQL emitter expected logical plan root to be "project", got "${logicalPlan.root.op}"`,
+      { component: "plan-inspector" }
+    );
+  }
+  const operations = /* @__PURE__ */ new Set();
+  collectPlanOperations(logicalPlan.root, operations);
+  const limitOffsetNode = findUnaryNodeInProjectChain(
+    logicalPlan.root,
+    "limit_offset"
+  );
+  const sortNode = findUnaryNodeInProjectChain(
+    logicalPlan.root,
+    "sort"
+  );
+  return {
+    hasAggregate: operations.has("aggregate"),
+    hasLimitOffset: operations.has("limit_offset"),
+    hasRecursiveExpand: operations.has("recursive_expand"),
+    hasSetOperation: operations.has("set_op"),
+    hasSort: operations.has("sort"),
+    hasVectorKnn: operations.has("vector_knn"),
+    limitOffsetNode,
+    rootProjectNode: logicalPlan.root,
+    sortNode
   };
 }
-function extractAggregateExpressions(ast) {
-  const aggregates = [];
-  for (const field2 of ast.projection.fields) {
-    if ("__type" in field2.source && field2.source.__type === "aggregate") {
-      aggregates.push(field2.source);
-    }
+function inspectStandardProjectPlan(logicalPlan) {
+  const shape = inspectProjectPlan(logicalPlan);
+  if (shape.hasSetOperation) {
+    throw new CompilerInvariantError(
+      'Standard SQL emitter does not support plans containing "set_op" nodes',
+      { component: "plan-inspector" }
+    );
   }
-  return aggregates;
+  if (shape.hasRecursiveExpand) {
+    throw new CompilerInvariantError(
+      'Standard SQL emitter does not support plans containing "recursive_expand" nodes',
+      { component: "plan-inspector" }
+    );
+  }
+  return shape;
 }
-function getAliasPredicates(ast, alias, predicateTargetType) {
-  return ast.predicates.filter((predicate2) => {
-    const targetType = predicate2.targetType ?? "node";
-    return predicate2.targetAlias === alias && targetType === predicateTargetType;
-  });
+function inspectRecursiveProjectPlan(logicalPlan) {
+  const shape = inspectProjectPlan(logicalPlan);
+  if (!shape.hasRecursiveExpand) {
+    throw new CompilerInvariantError(
+      'Recursive SQL emitter expected logical plan to contain a "recursive_expand" node',
+      { component: "plan-inspector" }
+    );
+  }
+  if (shape.hasSetOperation) {
+    throw new CompilerInvariantError(
+      'Recursive SQL emitter does not support plans containing "set_op" nodes',
+      { component: "plan-inspector" }
+    );
+  }
+  return shape;
 }
-function wrapWithAliasFilterNode(currentNode, ast, alias, predicateTargetType, nextPlanNodeId) {
-  const aliasPredicates = getAliasPredicates(ast, alias, predicateTargetType);
-  if (aliasPredicates.length === 0) {
-    return currentNode;
+function findTopLevelLimitOffsetNode(rootNode) {
+  let currentNode = rootNode;
+  for (; ; ) {
+    if (currentNode.op === "limit_offset") {
+      return currentNode;
+    }
+    switch (currentNode.op) {
+      case "aggregate":
+      case "filter":
+      case "join":
+      case "project":
+      case "recursive_expand":
+      case "sort":
+      case "vector_knn": {
+        currentNode = currentNode.input;
+        continue;
+      }
+      case "scan":
+      case "set_op": {
+        return void 0;
+      }
+    }
+  }
+}
+function findTopLevelSortNode(rootNode) {
+  let currentNode = rootNode;
+  for (; ; ) {
+    if (currentNode.op === "sort") {
+      return currentNode;
+    }
+    switch (currentNode.op) {
+      case "aggregate":
+      case "filter":
+      case "join":
+      case "limit_offset":
+      case "project":
+      case "recursive_expand":
+      case "vector_knn": {
+        currentNode = currentNode.input;
+        continue;
+      }
+      case "scan":
+      case "set_op": {
+        return void 0;
+      }
+    }
+  }
+}
+function inspectSetOperationPlan(logicalPlan) {
+  const operations = /* @__PURE__ */ new Set();
+  collectPlanOperations(logicalPlan.root, operations);
+  if (!operations.has("set_op")) {
+    throw new CompilerInvariantError(
+      'Set-operation SQL emitter expected logical plan to contain a "set_op" node',
+      { component: "plan-inspector" }
+    );
   }
+  const limitOffsetNode = findTopLevelLimitOffsetNode(logicalPlan.root);
+  const sortNode = findTopLevelSortNode(logicalPlan.root);
   return {
-    alias,
-    id: nextPlanNodeId(),
-    input: currentNode,
-    op: "filter",
-    predicateTargetType,
-    predicates: aliasPredicates.map((predicate2) => predicate2.expression)
+    hasLimitOffset: limitOffsetNode !== void 0,
+    hasSetOperation: true,
+    hasSort: sortNode !== void 0,
+    limitOffsetNode,
+    sortNode
   };
 }
-function appendAggregateSortLimitAndProjectNodes(currentNode, ast, nextPlanNodeId, limit, collapsedTraversalCteAlias) {
-  let node = currentNode;
-  const aggregateExpressions = extractAggregateExpressions(ast);
-  if (aggregateExpressions.length > 0 || ast.groupBy !== void 0 || ast.having !== void 0) {
-    const aggregateNode = {
-      aggregates: aggregateExpressions,
-      groupBy: ast.groupBy?.fields ?? [],
-      id: nextPlanNodeId(),
-      input: node,
-      op: "aggregate"
-    };
-    node = ast.having === void 0 ? aggregateNode : { ...aggregateNode, having: ast.having };
+function assertRecursiveEmitterClauseAlignment(logicalPlan, input) {
+  const planShape = inspectRecursiveProjectPlan(logicalPlan);
+  if (planShape.hasSort && input.orderBy === void 0) {
+    throw new CompilerInvariantError(
+      "Recursive SQL emitter expected ORDER BY clause for plan containing a sort node",
+      { component: "recursive-emitter" }
+    );
   }
-  if (ast.orderBy !== void 0 && ast.orderBy.length > 0) {
-    node = {
-      id: nextPlanNodeId(),
-      input: node,
-      op: "sort",
-      orderBy: ast.orderBy
-    };
+  if (!planShape.hasSort && input.orderBy !== void 0) {
+    throw new CompilerInvariantError(
+      "Recursive SQL emitter received ORDER BY clause for a plan without sort nodes",
+      { component: "recursive-emitter" }
+    );
   }
-  if (limit !== void 0 || ast.offset !== void 0) {
-    const limitOffsetNodeBase = {
-      id: nextPlanNodeId(),
-      input: node,
-      op: "limit_offset"
-    };
-    const hasLimit = limit !== void 0;
-    const hasOffset = ast.offset !== void 0;
-    if (hasLimit && hasOffset) {
-      node = {
-        ...limitOffsetNodeBase,
-        limit,
-        offset: ast.offset
-      };
-    } else if (hasLimit) {
-      node = { ...limitOffsetNodeBase, limit };
-    } else if (hasOffset) {
-      node = { ...limitOffsetNodeBase, offset: ast.offset };
-    } else {
+  if (planShape.hasLimitOffset && input.limitOffset === void 0) {
+    throw new CompilerInvariantError(
+      "Recursive SQL emitter expected LIMIT/OFFSET clause for plan containing a limit_offset node",
+      { component: "recursive-emitter" }
+    );
+  }
+  if (!planShape.hasLimitOffset && input.limitOffset !== void 0) {
+    throw new CompilerInvariantError(
+      "Recursive SQL emitter received LIMIT/OFFSET clause for a plan without limit_offset nodes",
+      { component: "recursive-emitter" }
+    );
+  }
+}
+function emitRecursiveQuerySql(input) {
+  assertRecursiveEmitterClauseAlignment(input.logicalPlan, input);
+  const parts = [
+    sql`WITH RECURSIVE`,
+    input.recursiveCte,
+    sql`SELECT ${input.projection}`,
+    sql`FROM recursive_cte`,
+    input.depthFilter
+  ];
+  if (input.orderBy !== void 0) {
+    parts.push(input.orderBy);
+  }
+  if (input.limitOffset !== void 0) {
+    parts.push(input.limitOffset);
+  }
+  return sql.join(parts, sql` `);
+}
+function assertSetOperationEmitterClauseAlignment(logicalPlan, suffixClauses) {
+  const shape = inspectSetOperationPlan(logicalPlan);
+  const hasSuffixClauses = suffixClauses !== void 0 && suffixClauses.length > 0;
+  if (!shape.hasSort && !shape.hasLimitOffset && hasSuffixClauses) {
+    throw new CompilerInvariantError(
+      "Set-operation SQL emitter received suffix clauses for a plan without top-level sort or limit_offset nodes",
+      { component: "set-operation-emitter" }
+    );
+  }
+  if (!hasSuffixClauses) {
+    if (shape.hasSort || shape.hasLimitOffset) {
       throw new CompilerInvariantError(
-        "limit_offset node requires limit or offset to be present"
+        "Set-operation SQL emitter expected suffix clauses for plan containing top-level sort or limit_offset nodes",
+        { component: "set-operation-emitter" }
       );
     }
+    return;
   }
-  const projectNodeBase = {
-    fields: ast.projection.fields,
-    id: nextPlanNodeId(),
-    input: node,
-    op: "project"
-  };
-  return collapsedTraversalCteAlias === void 0 ? projectNodeBase : {
-    ...projectNodeBase,
-    collapsedTraversalAlias: collapsedTraversalCteAlias
-  };
-}
-function lowerStandardQueryToLogicalPlanNode(input) {
-  const { ast, nextPlanNodeId } = input;
-  let currentNode = {
-    alias: ast.start.alias,
-    graphId: input.graphId,
-    id: nextPlanNodeId(),
-    kinds: ast.start.kinds,
-    op: "scan",
-    source: "nodes"
-  };
-  currentNode = wrapWithAliasFilterNode(
-    currentNode,
-    ast,
-    ast.start.alias,
-    "node",
-    nextPlanNodeId
-  );
-  for (const traversal of ast.traversals) {
-    currentNode = {
-      direction: traversal.direction,
-      edgeAlias: traversal.edgeAlias,
-      edgeKinds: traversal.edgeKinds,
-      id: nextPlanNodeId(),
-      input: currentNode,
-      inverseEdgeKinds: traversal.inverseEdgeKinds ?? [],
-      joinFromAlias: traversal.joinFromAlias,
-      joinType: traversal.optional ? "left" : "inner",
-      nodeAlias: traversal.nodeAlias,
-      nodeKinds: traversal.nodeKinds,
-      op: "join"
-    };
-    currentNode = wrapWithAliasFilterNode(
-      currentNode,
-      ast,
-      traversal.edgeAlias,
-      "edge",
-      nextPlanNodeId
-    );
-    currentNode = wrapWithAliasFilterNode(
-      currentNode,
-      ast,
-      traversal.nodeAlias,
-      "node",
-      nextPlanNodeId
+  const limitOffsetClauseCount = shape.limitOffsetNode === void 0 ? 0 : (shape.limitOffsetNode.limit === void 0 ? 0 : 1) + (shape.limitOffsetNode.offset === void 0 ? 0 : 1);
+  const expectedClauseCount = (shape.sortNode === void 0 ? 0 : 1) + limitOffsetClauseCount;
+  if (suffixClauses.length !== expectedClauseCount) {
+    throw new CompilerInvariantError(
+      `Set-operation SQL emitter expected ${String(expectedClauseCount)} top-level suffix clause(s) from logical plan, got ${String(suffixClauses.length)}`,
+      { component: "set-operation-emitter" }
     );
   }
-  if (input.vectorPredicate !== void 0) {
-    currentNode = {
-      id: nextPlanNodeId(),
-      input: currentNode,
-      op: "vector_knn",
-      predicate: input.vectorPredicate
-    };
-  }
-  return appendAggregateSortLimitAndProjectNodes(
-    currentNode,
-    ast,
-    nextPlanNodeId,
-    input.effectiveLimit,
-    input.collapsedTraversalCteAlias
-  );
 }
-function lowerRecursiveQueryToLogicalPlanNode(input) {
-  const { ast, nextPlanNodeId } = input;
-  const traversal = input.traversal ?? runRecursiveTraversalSelectionPass(input.ast);
-  let currentNode = {
-    alias: ast.start.alias,
-    graphId: input.graphId,
-    id: nextPlanNodeId(),
-    kinds: ast.start.kinds,
-    op: "scan",
-    source: "nodes"
-  };
-  currentNode = wrapWithAliasFilterNode(
-    currentNode,
-    ast,
-    ast.start.alias,
-    "node",
-    nextPlanNodeId
-  );
-  currentNode = {
-    edgeAlias: traversal.edgeAlias,
-    edgeKinds: traversal.edgeKinds,
-    id: nextPlanNodeId(),
-    input: currentNode,
-    inverseEdgeKinds: traversal.inverseEdgeKinds ?? [],
-    nodeAlias: traversal.nodeAlias,
-    nodeKinds: traversal.nodeKinds,
-    op: "recursive_expand",
-    traversal: traversal.variableLength
-  };
-  currentNode = wrapWithAliasFilterNode(
-    currentNode,
-    ast,
-    traversal.edgeAlias,
-    "edge",
-    nextPlanNodeId
-  );
-  currentNode = wrapWithAliasFilterNode(
-    currentNode,
-    ast,
-    traversal.nodeAlias,
-    "node",
-    nextPlanNodeId
-  );
-  return appendAggregateSortLimitAndProjectNodes(
-    currentNode,
-    ast,
-    nextPlanNodeId,
-    ast.limit
+function emitSetOperationQuerySql(input) {
+  assertSetOperationEmitterClauseAlignment(
+    input.logicalPlan,
+    input.suffixClauses
   );
+  const parts = [];
+  if (input.ctes !== void 0 && input.ctes.length > 0) {
+    parts.push(sql`WITH ${sql.join([...input.ctes], sql`, `)}`);
+  }
+  parts.push(input.baseQuery);
+  if (input.suffixClauses !== void 0 && input.suffixClauses.length > 0) {
+    parts.push(...input.suffixClauses);
+  }
+  return sql.join(parts, sql` `);
 }
-function lowerComposableQueryToLogicalPlanNode(query, dialect, graphId, nextPlanNodeId) {
-  if ("__type" in query) {
-    return lowerSetOperationToLogicalPlanNode(
-      query,
-      graphId,
-      dialect,
-      nextPlanNodeId
+function assertStandardEmitterClauseAlignment(logicalPlan, input) {
+  const planShape = inspectStandardProjectPlan(logicalPlan);
+  if (input.groupBy !== void 0 && !planShape.hasAggregate) {
+    throw new CompilerInvariantError(
+      "Standard SQL emitter received GROUP BY clause for a plan without aggregate nodes",
+      { component: "standard-emitter" }
     );
   }
-  const hasVariableLengthTraversal2 = query.traversals.some(
-    (traversal) => traversal.variableLength !== void 0
-  );
-  if (hasVariableLengthTraversal2) {
-    return lowerRecursiveQueryToLogicalPlanNode({
-      ast: query,
-      graphId,
-      nextPlanNodeId
-    });
+  if (input.having !== void 0 && !planShape.hasAggregate) {
+    throw new CompilerInvariantError(
+      "Standard SQL emitter received HAVING clause for a plan without aggregate nodes",
+      { component: "standard-emitter" }
+    );
   }
-  const vectorPredicate = runVectorPredicatePass(
-    query,
-    getDialect(dialect)
-  ).vectorPredicate;
-  const effectiveLimit = resolveVectorAwareLimit(query.limit, vectorPredicate);
-  const loweringInput = {
-    ast: query,
-    graphId,
-    nextPlanNodeId,
-    ...effectiveLimit === void 0 ? {} : { effectiveLimit },
-    ...vectorPredicate === void 0 ? {} : { vectorPredicate }
-  };
-  return lowerStandardQueryToLogicalPlanNode(loweringInput);
-}
-function lowerSetOperationToLogicalPlanNode(op, graphId, dialect, nextPlanNodeId) {
-  let currentNode = {
-    id: nextPlanNodeId(),
-    left: lowerComposableQueryToLogicalPlanNode(
-      op.left,
-      dialect,
-      graphId,
-      nextPlanNodeId
-    ),
-    op: "set_op",
-    operator: op.operator,
-    right: lowerComposableQueryToLogicalPlanNode(
-      op.right,
-      dialect,
-      graphId,
-      nextPlanNodeId
-    )
-  };
-  if (op.orderBy !== void 0 && op.orderBy.length > 0) {
-    currentNode = {
-      id: nextPlanNodeId(),
-      input: currentNode,
-      op: "sort",
-      orderBy: op.orderBy
-    };
+  const expectsOrderBy = planShape.hasSort || planShape.hasVectorKnn;
+  if (expectsOrderBy && input.orderBy === void 0) {
+    throw new CompilerInvariantError(
+      "Standard SQL emitter expected ORDER BY clause for plan containing a sort or vector_knn node",
+      { component: "standard-emitter" }
+    );
   }
-  if (op.limit !== void 0 || op.offset !== void 0) {
-    const limitOffsetBase = {
-      id: nextPlanNodeId(),
-      input: currentNode,
-      op: "limit_offset"
-    };
-    if (op.limit !== void 0 && op.offset !== void 0) {
-      currentNode = { ...limitOffsetBase, limit: op.limit, offset: op.offset };
-    } else if (op.limit === void 0) {
-      currentNode = { ...limitOffsetBase, offset: op.offset };
-    } else {
-      currentNode = { ...limitOffsetBase, limit: op.limit };
-    }
+  if (!expectsOrderBy && input.orderBy !== void 0) {
+    throw new CompilerInvariantError(
+      "Standard SQL emitter received ORDER BY clause for a plan without sort or vector_knn nodes",
+      { component: "standard-emitter" }
+    );
+  }
+  if (planShape.hasLimitOffset && input.limitOffset === void 0) {
+    throw new CompilerInvariantError(
+      "Standard SQL emitter expected LIMIT/OFFSET clause for plan containing a limit_offset node",
+      { component: "standard-emitter" }
+    );
+  }
+  if (!planShape.hasLimitOffset && input.limitOffset !== void 0) {
+    throw new CompilerInvariantError(
+      "Standard SQL emitter received LIMIT/OFFSET clause for a plan without limit_offset nodes",
+      { component: "standard-emitter" }
+    );
   }
-  return currentNode;
-}
-function lowerStandardQueryToLogicalPlan(input) {
-  const nextPlanNodeId = createPlanNodeIdFactory();
-  return {
-    metadata: {
-      dialect: input.dialect,
-      graphId: input.graphId
-    },
-    root: lowerStandardQueryToLogicalPlanNode({
-      ...input,
-      nextPlanNodeId
-    })
-  };
-}
-function lowerRecursiveQueryToLogicalPlan(input) {
-  const nextPlanNodeId = createPlanNodeIdFactory();
-  return {
-    metadata: {
-      dialect: input.dialect,
-      graphId: input.graphId
-    },
-    root: lowerRecursiveQueryToLogicalPlanNode({
-      ...input,
-      nextPlanNodeId
-    })
-  };
 }
-function lowerSetOperationToLogicalPlan(input) {
-  const nextPlanNodeId = createPlanNodeIdFactory();
-  return {
-    metadata: {
-      dialect: input.dialect,
-      graphId: input.graphId
-    },
-    root: lowerSetOperationToLogicalPlanNode(
-      input.op,
-      input.graphId,
-      input.dialect,
-      nextPlanNodeId
-    )
-  };
+function emitStandardQuerySql(input) {
+  assertStandardEmitterClauseAlignment(input.logicalPlan, input);
+  const parts = [];
+  if (input.ctes.length > 0) {
+    parts.push(sql`WITH ${sql.join([...input.ctes], sql`, `)}`);
+  }
+  parts.push(sql`SELECT ${input.projection}`, input.fromClause);
+  if (input.groupBy !== void 0) {
+    parts.push(input.groupBy);
+  }
+  if (input.having !== void 0) {
+    parts.push(input.having);
+  }
+  if (input.orderBy !== void 0) {
+    parts.push(input.orderBy);
+  }
+  if (input.limitOffset !== void 0) {
+    parts.push(input.limitOffset);
+  }
+  return sql.join(parts, sql` `);
 }
 
-// src/query/compiler/emitter/plan-inspector.ts
-function collectPlanOperations(node, ops) {
-  ops.add(node.op);
-  switch (node.op) {
-    case "aggregate":
-    case "filter":
-    case "join":
-    case "limit_offset":
-    case "project":
-    case "recursive_expand":
-    case "sort":
-    case "vector_knn": {
-      collectPlanOperations(node.input, ops);
-      return;
+// src/query/compiler/typed-json-extract.ts
+function compileTypedJsonExtract(input) {
+  const { column, dialect, pointer, valueType } = input;
+  const fallback = input.fallback ?? "json";
+  switch (valueType) {
+    case "string": {
+      return dialect.jsonExtractText(column, pointer);
     }
-    case "set_op": {
-      collectPlanOperations(node.left, ops);
-      collectPlanOperations(node.right, ops);
-      return;
+    case "number": {
+      return dialect.jsonExtractNumber(column, pointer);
     }
-    case "scan": {
-      return;
+    case "boolean": {
+      return dialect.jsonExtractBoolean(column, pointer);
     }
-  }
-}
-function findUnaryNodeInProjectChain(rootNode, op) {
-  let currentNode = rootNode.input;
-  for (; ; ) {
-    if (currentNode.op === op) {
-      return currentNode;
+    case "date": {
+      return dialect.jsonExtractDate(column, pointer);
     }
-    switch (currentNode.op) {
-      case "aggregate":
-      case "filter":
-      case "join":
-      case "limit_offset":
-      case "recursive_expand":
-      case "sort":
-      case "vector_knn": {
-        currentNode = currentNode.input;
-        continue;
-      }
-      case "project":
-      case "scan":
-      case "set_op": {
-        return void 0;
-      }
+    case "array":
+    case "object":
+    case "embedding":
+    case "unknown":
+    case void 0: {
+      return fallback === "text" ? dialect.jsonExtractText(column, pointer) : dialect.jsonExtract(column, pointer);
+    }
+    default: {
+      return fallback === "text" ? dialect.jsonExtractText(column, pointer) : dialect.jsonExtract(column, pointer);
     }
   }
 }
-function inspectProjectPlan(logicalPlan) {
-  if (logicalPlan.root.op !== "project") {
-    throw new CompilerInvariantError(
-      `SQL emitter expected logical plan root to be "project", got "${logicalPlan.root.op}"`,
-      { component: "plan-inspector" }
-    );
-  }
-  const operations = /* @__PURE__ */ new Set();
-  collectPlanOperations(logicalPlan.root, operations);
-  const limitOffsetNode = findUnaryNodeInProjectChain(
-    logicalPlan.root,
-    "limit_offset"
-  );
-  const sortNode = findUnaryNodeInProjectChain(
-    logicalPlan.root,
-    "sort"
-  );
-  return {
-    hasAggregate: operations.has("aggregate"),
-    hasLimitOffset: operations.has("limit_offset"),
-    hasRecursiveExpand: operations.has("recursive_expand"),
-    hasSetOperation: operations.has("set_op"),
-    hasSort: operations.has("sort"),
-    hasVectorKnn: operations.has("vector_knn"),
-    limitOffsetNode,
-    rootProjectNode: logicalPlan.root,
-    sortNode
-  };
+var NODE_COLUMNS = [
+  "id",
+  "kind",
+  "props",
+  "version",
+  "valid_from",
+  "valid_to",
+  "created_at",
+  "updated_at",
+  "deleted_at"
+];
+var EDGE_COLUMNS = [
+  "id",
+  "kind",
+  "from_id",
+  "to_id",
+  "props",
+  "valid_from",
+  "valid_to",
+  "created_at",
+  "updated_at",
+  "deleted_at"
+];
+var EMPTY_REQUIRED_COLUMNS = /* @__PURE__ */ new Set();
+function quoteIdentifier(identifier) {
+  return sql.raw(`"${identifier.replaceAll('"', '""')}"`);
 }
-function inspectStandardProjectPlan(logicalPlan) {
-  const shape = inspectProjectPlan(logicalPlan);
-  if (shape.hasSetOperation) {
-    throw new CompilerInvariantError(
-      'Standard SQL emitter does not support plans containing "set_op" nodes',
-      { component: "plan-inspector" }
-    );
-  }
-  if (shape.hasRecursiveExpand) {
-    throw new CompilerInvariantError(
-      'Standard SQL emitter does not support plans containing "recursive_expand" nodes',
-      { component: "plan-inspector" }
-    );
-  }
-  return shape;
+function shouldProjectColumn(requiredColumns, column, alwaysRequiredColumns) {
+  if (alwaysRequiredColumns?.has(column)) return true;
+  if (requiredColumns === void 0) return true;
+  return requiredColumns.has(column);
 }
-function inspectRecursiveProjectPlan(logicalPlan) {
-  const shape = inspectProjectPlan(logicalPlan);
-  if (!shape.hasRecursiveExpand) {
-    throw new CompilerInvariantError(
-      'Recursive SQL emitter expected logical plan to contain a "recursive_expand" node',
-      { component: "plan-inspector" }
-    );
-  }
-  if (shape.hasSetOperation) {
-    throw new CompilerInvariantError(
-      'Recursive SQL emitter does not support plans containing "set_op" nodes',
-      { component: "plan-inspector" }
-    );
+function addRequiredColumn(requiredColumnsByAlias, alias, column) {
+  const existing = requiredColumnsByAlias.get(alias);
+  if (existing) {
+    existing.add(column);
+    return;
   }
-  return shape;
+  requiredColumnsByAlias.set(alias, /* @__PURE__ */ new Set([column]));
 }
-function findTopLevelLimitOffsetNode(rootNode) {
-  let currentNode = rootNode;
-  for (; ; ) {
-    if (currentNode.op === "limit_offset") {
-      return currentNode;
-    }
-    switch (currentNode.op) {
-      case "aggregate":
-      case "filter":
-      case "join":
-      case "project":
-      case "recursive_expand":
-      case "sort":
-      case "vector_knn": {
-        currentNode = currentNode.input;
-        continue;
-      }
-      case "scan":
-      case "set_op": {
-        return void 0;
-      }
-    }
-  }
+function markFieldRefAsRequired(requiredColumnsByAlias, field2) {
+  const column = field2.path[0];
+  if (column === void 0) return;
+  addRequiredColumn(requiredColumnsByAlias, field2.alias, column);
 }
-function findTopLevelSortNode(rootNode) {
-  let currentNode = rootNode;
-  for (; ; ) {
-    if (currentNode.op === "sort") {
-      return currentNode;
-    }
-    switch (currentNode.op) {
-      case "aggregate":
-      case "filter":
-      case "join":
-      case "limit_offset":
-      case "project":
-      case "recursive_expand":
-      case "vector_knn": {
-        currentNode = currentNode.input;
-        continue;
-      }
-      case "scan":
-      case "set_op": {
-        return void 0;
-      }
-    }
+function mapSelectiveSystemFieldToColumn(field2) {
+  if (field2 === "fromId") return "from_id";
+  if (field2 === "toId") return "to_id";
+  if (field2.startsWith("meta.")) {
+    return field2.slice(5).replaceAll(/([A-Z])/g, "_$1").toLowerCase();
   }
+  return field2;
 }
-function inspectSetOperationPlan(logicalPlan) {
-  const operations = /* @__PURE__ */ new Set();
-  collectPlanOperations(logicalPlan.root, operations);
-  if (!operations.has("set_op")) {
-    throw new CompilerInvariantError(
-      'Set-operation SQL emitter expected logical plan to contain a "set_op" node',
-      { component: "plan-inspector" }
+function markSelectiveFieldAsRequired(requiredColumnsByAlias, field2) {
+  if (field2.isSystemField) {
+    addRequiredColumn(
+      requiredColumnsByAlias,
+      field2.alias,
+      mapSelectiveSystemFieldToColumn(field2.field)
     );
+    return;
   }
-  const limitOffsetNode = findTopLevelLimitOffsetNode(logicalPlan.root);
-  const sortNode = findTopLevelSortNode(logicalPlan.root);
-  return {
-    hasLimitOffset: limitOffsetNode !== void 0,
-    hasSetOperation: true,
-    hasSort: sortNode !== void 0,
-    limitOffsetNode,
-    sortNode
-  };
+  addRequiredColumn(requiredColumnsByAlias, field2.alias, "props");
 }
-function assertRecursiveEmitterClauseAlignment(logicalPlan, input) {
-  const planShape = inspectRecursiveProjectPlan(logicalPlan);
-  if (planShape.hasSort && input.orderBy === void 0) {
-    throw new CompilerInvariantError(
-      "Recursive SQL emitter expected ORDER BY clause for plan containing a sort node",
-      { component: "recursive-emitter" }
-    );
-  }
-  if (!planShape.hasSort && input.orderBy !== void 0) {
-    throw new CompilerInvariantError(
-      "Recursive SQL emitter received ORDER BY clause for a plan without sort nodes",
-      { component: "recursive-emitter" }
-    );
-  }
-  if (planShape.hasLimitOffset && input.limitOffset === void 0) {
-    throw new CompilerInvariantError(
-      "Recursive SQL emitter expected LIMIT/OFFSET clause for plan containing a limit_offset node",
-      { component: "recursive-emitter" }
-    );
-  }
-  if (!planShape.hasLimitOffset && input.limitOffset !== void 0) {
-    throw new CompilerInvariantError(
-      "Recursive SQL emitter received LIMIT/OFFSET clause for a plan without limit_offset nodes",
-      { component: "recursive-emitter" }
-    );
+function isIdFieldRef(field2) {
+  return field2.path.length === 1 && field2.path[0] === "id" && field2.jsonPointer === void 0;
+}
+function isAggregateExpr(source) {
+  return "__type" in source && source.__type === "aggregate";
+}
+
+// src/query/compiler/emitter/standard-builders.ts
+function compileColumnReference(tableAlias, column) {
+  if (tableAlias === void 0) {
+    return sql.raw(column);
   }
+  return sql`${sql.raw(tableAlias)}.${sql.raw(column)}`;
 }
-function emitRecursiveQuerySql(input) {
-  assertRecursiveEmitterClauseAlignment(input.logicalPlan, input);
-  const parts = [
-    sql`WITH RECURSIVE`,
-    input.recursiveCte,
-    sql`SELECT ${input.projection}`,
-    sql`FROM recursive_cte`,
-    input.depthFilter
+function compileNodeSelectColumns(tableAlias, alias, requiredColumns) {
+  return NODE_COLUMNS.filter(
+    (column) => column === "id" || column === "kind" || shouldProjectColumn(requiredColumns, column)
+  ).map(
+    (column) => sql`${compileColumnReference(tableAlias, column)} AS ${sql.raw(`${alias}_${column}`)}`
+  );
+}
+function compileEdgeSelectColumns(tableAlias, alias, requiredColumns) {
+  return EDGE_COLUMNS.filter(
+    (column) => shouldProjectColumn(requiredColumns, column)
+  ).map(
+    (column) => sql`${compileColumnReference(tableAlias, column)} AS ${sql.raw(`${alias}_${column}`)}`
+  );
+}
+function buildStandardStartCte(input) {
+  const { ast, ctx, graphId, predicateIndex, requiredColumnsByAlias } = input;
+  const alias = ast.start.alias;
+  const kinds = ast.start.kinds;
+  const kindFilter = compileKindFilter(sql.raw("kind"), kinds);
+  const temporalFilter = input.temporalFilterPass.forAlias();
+  const cteContext = { ...ctx, cteColumnPrefix: "" };
+  const predicateClauses = compilePredicateClauses(
+    getPredicatesForAlias(predicateIndex, alias, "node"),
+    cteContext
+  );
+  const whereClauses = [
+    sql`graph_id = ${graphId}`,
+    kindFilter,
+    temporalFilter,
+    ...predicateClauses
+  ];
+  const effectiveRequiredColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(alias) ?? EMPTY_REQUIRED_COLUMNS : void 0;
+  return sql`
+    cte_${sql.raw(alias)} AS (
+      SELECT ${sql.join(
+    compileNodeSelectColumns(void 0, alias, effectiveRequiredColumns),
+    sql`, `
+  )}
+      FROM ${ctx.schema.nodesTable}
+      WHERE ${sql.join(whereClauses, sql` AND `)}
+    )
+  `;
+}
+function buildStandardTraversalCte(input) {
+  const {
+    ast,
+    carryForwardPreviousColumns,
+    ctx,
+    graphId,
+    materializeCte,
+    predicateIndex,
+    requiredColumnsByAlias,
+    temporalFilterPass,
+    traversalIndex,
+    traversalLimit
+  } = input;
+  const traversal = ast.traversals[traversalIndex];
+  const traversalLimitValue = traversalIndex === ast.traversals.length - 1 ? traversalLimit : void 0;
+  const previousNodeKinds = getNodeKindsForAlias(ast, traversal.joinFromAlias);
+  const directEdgeKinds = [...new Set(traversal.edgeKinds)];
+  const inverseEdgeKinds = traversal.inverseEdgeKinds === void 0 ? [] : [...new Set(traversal.inverseEdgeKinds)];
+  const nodeKinds = traversal.nodeKinds;
+  const nodeKindFilter = compileKindFilter(sql.raw("n.kind"), nodeKinds);
+  const edgeTemporalFilter = temporalFilterPass.forAlias("e");
+  const nodeTemporalFilter = temporalFilterPass.forAlias("n");
+  const nodeCteContext = {
+    ...ctx,
+    cteColumnPrefix: "n"
+  };
+  const nodePredicateClauses = compilePredicateClauses(
+    getPredicatesForAlias(predicateIndex, traversal.nodeAlias, "node"),
+    nodeCteContext
+  );
+  const edgeCteContext = {
+    ...ctx,
+    cteColumnPrefix: "e"
+  };
+  const edgePredicateClauses = compilePredicateClauses(
+    getPredicatesForAlias(predicateIndex, traversal.edgeAlias, "edge"),
+    edgeCteContext
+  );
+  const baseWhereClauses = [
+    sql`e.graph_id = ${graphId}`,
+    nodeKindFilter,
+    edgeTemporalFilter,
+    nodeTemporalFilter,
+    ...nodePredicateClauses,
+    ...edgePredicateClauses
+  ];
+  const previousAlias = traversal.joinFromAlias;
+  const edgeAlias = traversal.edgeAlias;
+  const nodeAlias = traversal.nodeAlias;
+  const requiredNodeColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(nodeAlias) ?? EMPTY_REQUIRED_COLUMNS : void 0;
+  const requiredEdgeColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(edgeAlias) ?? EMPTY_REQUIRED_COLUMNS : void 0;
+  const previousRowColumns = carryForwardPreviousColumns ? [sql`cte_${sql.raw(previousAlias)}.*`] : [
+    sql`cte_${sql.raw(previousAlias)}.${sql.raw(previousAlias)}_id AS ${sql.raw(previousAlias)}_id`,
+    sql`cte_${sql.raw(previousAlias)}.${sql.raw(previousAlias)}_kind AS ${sql.raw(previousAlias)}_kind`
+  ];
+  const selectColumns = [
+    ...previousRowColumns,
+    ...compileEdgeSelectColumns("e", edgeAlias, requiredEdgeColumns),
+    ...compileNodeSelectColumns("n", nodeAlias, requiredNodeColumns)
+  ];
+  const cteMaterialization = materializeCte ? sql`MATERIALIZED ` : sql``;
+  function compileTraversalBranch(branch) {
+    const whereClauses = [
+      ...baseWhereClauses,
+      compileKindFilter(sql.raw("e.kind"), branch.edgeKinds),
+      compileKindFilter(
+        sql.raw(`e.${branch.joinKindField}`),
+        previousNodeKinds
+      ),
+      compileKindFilter(sql.raw(`e.${branch.targetKindField}`), nodeKinds)
+    ];
+    if (branch.duplicateGuard !== void 0) {
+      whereClauses.push(branch.duplicateGuard);
+    }
+    return sql`
+      SELECT ${sql.join(selectColumns, sql`, `)}
+      FROM cte_${sql.raw(previousAlias)}
+      JOIN ${ctx.schema.edgesTable} e ON cte_${sql.raw(previousAlias)}.${sql.raw(previousAlias)}_id = e.${sql.raw(branch.joinField)}
+        AND cte_${sql.raw(previousAlias)}.${sql.raw(previousAlias)}_kind = e.${sql.raw(branch.joinKindField)}
+      JOIN ${ctx.schema.nodesTable} n ON n.graph_id = e.graph_id
+        AND n.id = e.${sql.raw(branch.targetField)}
+        AND n.kind = e.${sql.raw(branch.targetKindField)}
+      WHERE ${sql.join(whereClauses, sql` AND `)}
+    `;
+  }
+  const directJoinField = traversal.direction === "out" ? "from_id" : "to_id";
+  const directTargetField = traversal.direction === "out" ? "to_id" : "from_id";
+  const directJoinKindField = traversal.direction === "out" ? "from_kind" : "to_kind";
+  const directTargetKindField = traversal.direction === "out" ? "to_kind" : "from_kind";
+  const directBranch = compileTraversalBranch({
+    edgeKinds: directEdgeKinds,
+    joinField: directJoinField,
+    joinKindField: directJoinKindField,
+    targetField: directTargetField,
+    targetKindField: directTargetKindField
+  });
+  if (inverseEdgeKinds.length === 0) {
+    if (traversalLimitValue !== void 0) {
+      return sql`
+        cte_${sql.raw(nodeAlias)} AS ${cteMaterialization}(
+          SELECT * FROM (
+            ${directBranch}
+          ) AS traversal_rows
+          LIMIT ${traversalLimitValue}
+        )
+      `;
+    }
+    return sql`
+      cte_${sql.raw(nodeAlias)} AS ${cteMaterialization}(
+        ${directBranch}
+      )
+    `;
+  }
+  const inverseJoinField = traversal.direction === "out" ? "to_id" : "from_id";
+  const inverseTargetField = traversal.direction === "out" ? "from_id" : "to_id";
+  const inverseJoinKindField = traversal.direction === "out" ? "to_kind" : "from_kind";
+  const inverseTargetKindField = traversal.direction === "out" ? "from_kind" : "to_kind";
+  const overlappingKinds = inverseEdgeKinds.filter(
+    (kind) => directEdgeKinds.includes(kind)
+  );
+  const duplicateGuard = overlappingKinds.length > 0 ? sql`NOT (e.from_id = e.to_id AND ${compileKindFilter(
+    sql.raw("e.kind"),
+    overlappingKinds
+  )})` : void 0;
+  const inverseBranch = compileTraversalBranch({
+    duplicateGuard,
+    edgeKinds: inverseEdgeKinds,
+    joinField: inverseJoinField,
+    joinKindField: inverseJoinKindField,
+    targetField: inverseTargetField,
+    targetKindField: inverseTargetKindField
+  });
+  if (traversalLimitValue !== void 0) {
+    return sql`
+      cte_${sql.raw(nodeAlias)} AS ${cteMaterialization}(
+        SELECT * FROM (
+          ${directBranch}
+          UNION ALL
+          ${inverseBranch}
+        ) AS traversal_rows
+        LIMIT ${traversalLimitValue}
+      )
+    `;
+  }
+  return sql`
+    cte_${sql.raw(nodeAlias)} AS ${cteMaterialization}(
+      ${directBranch}
+      UNION ALL
+      ${inverseBranch}
+    )
+  `;
+}
+function compileAggregateExprFromSource(expr, dialect) {
+  const { field: field2 } = expr;
+  const fn = expr.function;
+  switch (fn) {
+    case "count":
+    case "countDistinct":
+    case "sum":
+    case "avg":
+    case "min":
+    case "max": {
+      const cteAlias = `cte_${field2.alias}`;
+      const column = compileFieldValue(
+        field2,
+        dialect,
+        field2.valueType,
+        cteAlias
+      );
+      if (fn === "countDistinct") {
+        return sql`COUNT(DISTINCT ${column})`;
+      }
+      return sql`${sql.raw(fn.toUpperCase())}(${column})`;
+    }
+    default: {
+      throw new UnsupportedPredicateError(
+        `Unknown aggregate function: ${String(fn)}`
+      );
+    }
+  }
+}
+function compileProjectedSource(field2, dialect) {
+  if (isAggregateExpr(field2.source)) {
+    return compileAggregateExprFromSource(field2.source, dialect);
+  }
+  const cteAlias = field2.cteAlias ?? `cte_${field2.source.alias}`;
+  return compileFieldValue(
+    field2.source,
+    dialect,
+    field2.source.valueType,
+    cteAlias
+  );
+}
+function buildStandardProjection(input) {
+  const { ast, collapsedTraversalCteAlias, dialect } = input;
+  if (ast.selectiveFields && ast.selectiveFields.length > 0) {
+    return compileSelectiveProjection(
+      ast.selectiveFields,
+      dialect,
+      ast,
+      collapsedTraversalCteAlias
+    );
+  }
+  const fields = ast.projection.fields;
+  if (fields.length === 0) {
+    return sql.raw("*");
+  }
+  const projectedFields = fields.map((field2) => {
+    const source = compileProjectedSource(field2, dialect);
+    return sql`${source} AS ${quoteIdentifier(field2.outputName)}`;
+  });
+  return sql.join(projectedFields, sql`, `);
+}
+function compileSelectiveProjection(fields, dialect, ast, collapsedTraversalCteAlias) {
+  const aliasToCte = /* @__PURE__ */ new Map([
+    [ast.start.alias, `cte_${ast.start.alias}`]
+  ]);
+  for (const traversal of ast.traversals) {
+    aliasToCte.set(traversal.nodeAlias, `cte_${traversal.nodeAlias}`);
+    aliasToCte.set(traversal.edgeAlias, `cte_${traversal.nodeAlias}`);
+  }
+  const columns = fields.map((field2) => {
+    const cteAlias = collapsedTraversalCteAlias ?? aliasToCte.get(field2.alias) ?? `cte_${field2.alias}`;
+    if (field2.isSystemField) {
+      const dbColumn = mapSelectiveSystemFieldToColumn(field2.field);
+      return sql`${sql.raw(cteAlias)}.${sql.raw(`${field2.alias}_${dbColumn}`)} AS ${quoteIdentifier(field2.outputName)}`;
+    }
+    const propsColumn = `${field2.alias}_props`;
+    const column = sql`${sql.raw(cteAlias)}.${sql.raw(propsColumn)}`;
+    const pointer = jsonPointer([field2.field]);
+    const extracted = compileTypedJsonExtract({
+      column,
+      dialect,
+      pointer,
+      valueType: field2.valueType
+    });
+    return sql`${extracted} AS ${quoteIdentifier(field2.outputName)}`;
+  });
+  return sql.join(columns, sql`, `);
+}
+function buildStandardFromClause(input) {
+  const { ast, collapsedTraversalCteAlias, vectorPredicate } = input;
+  if (collapsedTraversalCteAlias !== void 0) {
+    return sql`FROM ${sql.raw(collapsedTraversalCteAlias)}`;
+  }
+  const startAlias = ast.start.alias;
+  const fromClause = sql`FROM cte_${sql.raw(startAlias)}`;
+  const joins = [];
+  for (const traversal of ast.traversals) {
+    const cteAlias = `cte_${traversal.nodeAlias}`;
+    const previousAlias = traversal.joinFromAlias;
+    const joinType = traversal.optional ? "LEFT JOIN" : "INNER JOIN";
+    joins.push(
+      sql`${sql.raw(joinType)} ${sql.raw(cteAlias)} ON ${sql.raw(cteAlias)}.${sql.raw(previousAlias)}_id = cte_${sql.raw(previousAlias)}.${sql.raw(previousAlias)}_id AND ${sql.raw(cteAlias)}.${sql.raw(previousAlias)}_kind = cte_${sql.raw(previousAlias)}.${sql.raw(previousAlias)}_kind`
+    );
+  }
+  if (vectorPredicate) {
+    const nodeAlias = vectorPredicate.field.alias;
+    joins.push(
+      sql`INNER JOIN cte_embeddings ON cte_embeddings.node_id = cte_${sql.raw(nodeAlias)}.${sql.raw(nodeAlias)}_id`
+    );
+  }
+  return joins.length === 0 ? fromClause : sql`${fromClause} ${sql.join(joins, sql` `)}`;
+}
+function buildStandardOrderBy(input) {
+  const { ast, collapsedTraversalCteAlias, dialect } = input;
+  if (!ast.orderBy || ast.orderBy.length === 0) {
+    return void 0;
+  }
+  const parts = [];
+  for (const orderSpec of ast.orderBy) {
+    const valueType = orderSpec.field.valueType;
+    if (valueType === "array" || valueType === "object") {
+      throw new UnsupportedPredicateError(
+        "Ordering by JSON arrays or objects is not supported"
+      );
+    }
+    const cteAlias = collapsedTraversalCteAlias ?? `cte_${orderSpec.field.alias}`;
+    const field2 = compileFieldValue(
+      orderSpec.field,
+      dialect,
+      valueType,
+      cteAlias
+    );
+    const direction = sql.raw(orderSpec.direction.toUpperCase());
+    const nulls = orderSpec.nulls ?? (orderSpec.direction === "asc" ? "last" : "first");
+    const nullsDirection = sql.raw(nulls === "first" ? "DESC" : "ASC");
+    parts.push(
+      sql`(${field2} IS NULL) ${nullsDirection}`,
+      sql`${field2} ${direction}`
+    );
+  }
+  return sql`ORDER BY ${sql.join(parts, sql`, `)}`;
+}
+function fieldRefKey(field2) {
+  const pointer = field2.jsonPointer ?? "";
+  return `${field2.alias}:${field2.path.join(".")}:${pointer}`;
+}
+function buildStandardGroupBy(input) {
+  const { ast, dialect } = input;
+  if (!ast.groupBy || ast.groupBy.fields.length === 0) {
+    return void 0;
+  }
+  const seenKeys = /* @__PURE__ */ new Set();
+  const allFields = [];
+  for (const projectedField of ast.projection.fields) {
+    if (projectedField.source.__type === "field_ref") {
+      const key = fieldRefKey(projectedField.source);
+      if (!seenKeys.has(key)) {
+        seenKeys.add(key);
+        allFields.push(projectedField.source);
+      }
+    }
+  }
+  for (const field2 of ast.groupBy.fields) {
+    const key = fieldRefKey(field2);
+    if (!seenKeys.has(key)) {
+      seenKeys.add(key);
+      allFields.push(field2);
+    }
+  }
+  if (allFields.length === 0) {
+    return void 0;
+  }
+  const parts = allFields.map(
+    (field2) => compileFieldValue(field2, dialect, field2.valueType, `cte_${field2.alias}`)
+  );
+  return sql`GROUP BY ${sql.join(parts, sql`, `)}`;
+}
+function buildStandardHaving(input) {
+  const { ast, ctx } = input;
+  if (!ast.having) {
+    return void 0;
+  }
+  const condition = compilePredicateExpression(ast.having, ctx);
+  return sql`HAVING ${condition}`;
+}
+function buildStandardEmbeddingsCte(input) {
+  const { ctx, graphId, vectorPredicate } = input;
+  const { dialect } = ctx;
+  const { field: field2, metric, minScore, queryEmbedding } = vectorPredicate;
+  const fieldPath = field2.jsonPointer ? field2.jsonPointer : field2.path.length > 1 && field2.path[0] === "props" ? `/${field2.path.slice(1).join("/")}` : `/${field2.path.join("/")}`;
+  const distanceExpr = dialect.vectorDistance(
+    sql.raw("embedding"),
+    queryEmbedding,
+    metric
+  );
+  const conditions = [
+    sql`graph_id = ${graphId}`,
+    sql`field_path = ${fieldPath}`
   ];
-  if (input.orderBy !== void 0) {
-    parts.push(input.orderBy);
+  if (minScore !== void 0) {
+    conditions.push(
+      compileVectorMinScoreCondition(distanceExpr, metric, minScore)
+    );
+  }
+  const scoreExpr = compileVectorScoreExpression(distanceExpr, metric);
+  return sql`
+    cte_embeddings AS (
+      SELECT
+        node_id,
+        ${distanceExpr} AS distance,
+        ${scoreExpr} AS score
+      FROM ${ctx.schema.embeddingsTable}
+      WHERE ${sql.join(conditions, sql` AND `)}
+      ORDER BY ${distanceExpr} ASC
+    )
+  `;
+}
+function compileVectorScoreExpression(distanceExpr, metric) {
+  switch (metric) {
+    case "cosine": {
+      return sql`(1.0 - ${distanceExpr})`;
+    }
+    case "l2":
+    case "inner_product": {
+      return distanceExpr;
+    }
+  }
+}
+function compileVectorMinScoreCondition(distanceExpr, metric, minScore) {
+  switch (metric) {
+    case "cosine": {
+      const threshold = 1 - minScore;
+      return sql`${distanceExpr} <= ${threshold}`;
+    }
+    case "l2": {
+      return sql`${distanceExpr} <= ${minScore}`;
+    }
+    case "inner_product": {
+      const negativeThreshold = -minScore;
+      return sql`${distanceExpr} <= ${negativeThreshold}`;
+    }
+  }
+}
+function buildStandardVectorOrderBy(input) {
+  const { ast, dialect } = input;
+  const distanceOrder = sql`cte_embeddings.distance ASC`;
+  const additionalOrders = [];
+  if (ast.orderBy && ast.orderBy.length > 0) {
+    for (const orderSpec of ast.orderBy) {
+      const valueType = orderSpec.field.valueType;
+      if (valueType === "array" || valueType === "object") {
+        throw new UnsupportedPredicateError(
+          "Ordering by JSON arrays or objects is not supported"
+        );
+      }
+      const cteAlias = `cte_${orderSpec.field.alias}`;
+      const field2 = compileFieldValue(
+        orderSpec.field,
+        dialect,
+        valueType,
+        cteAlias
+      );
+      const direction = sql.raw(orderSpec.direction.toUpperCase());
+      const nulls = orderSpec.nulls ?? (orderSpec.direction === "asc" ? "last" : "first");
+      const nullsDirection = sql.raw(nulls === "first" ? "DESC" : "ASC");
+      additionalOrders.push(
+        sql`(${field2} IS NULL) ${nullsDirection}`,
+        sql`${field2} ${direction}`
+      );
+    }
+  }
+  const allOrders = [distanceOrder, ...additionalOrders];
+  return sql`ORDER BY ${sql.join(allOrders, sql`, `)}`;
+}
+function buildLimitOffsetClause(input) {
+  const { limit, offset } = input;
+  const parts = [];
+  if (limit !== void 0) {
+    parts.push(sql`LIMIT ${limit}`);
+  }
+  if (offset !== void 0) {
+    parts.push(sql`OFFSET ${offset}`);
+  }
+  return parts.length > 0 ? sql.join(parts, sql` `) : void 0;
+}
+
+// src/query/compiler/passes/recursive.ts
+function runRecursiveTraversalSelectionPass(ast) {
+  const variableLengthTraversal = ast.traversals.find(
+    (traversal) => traversal.variableLength !== void 0
+  );
+  if (variableLengthTraversal === void 0) {
+    throw new CompilerInvariantError("No variable-length traversal found");
+  }
+  if (ast.traversals.length > 1) {
+    throw new UnsupportedPredicateError(
+      "Variable-length traversals with multiple traversals are not yet supported. Please use a single variable-length traversal."
+    );
+  }
+  return variableLengthTraversal;
+}
+
+// src/query/compiler/passes/runner.ts
+function runCompilerPass(state, pass) {
+  const output = pass.execute(state);
+  return {
+    state: pass.update(state, output)
+  };
+}
+function compileTemporalFilter(options) {
+  const { mode, asOf, tableAlias, currentTimestamp } = options;
+  const prefix = tableAlias ? sql.raw(`${tableAlias}.`) : sql.raw("");
+  const deletedAt = sql`${prefix}deleted_at`;
+  const validFrom = sql`${prefix}valid_from`;
+  const validTo = sql`${prefix}valid_to`;
+  switch (mode) {
+    case "current": {
+      const now = currentTimestamp ?? sql`CURRENT_TIMESTAMP`;
+      return sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${now}) AND (${validTo} IS NULL OR ${validTo} > ${now})`;
+    }
+    case "asOf": {
+      const timestamp = asOf;
+      return sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${timestamp}) AND (${validTo} IS NULL OR ${validTo} > ${timestamp})`;
+    }
+    case "includeEnded": {
+      return sql`${deletedAt} IS NULL`;
+    }
+    case "includeTombstones": {
+      return sql.raw("1=1");
+    }
+  }
+}
+function extractTemporalOptions(ast, tableAlias) {
+  return {
+    mode: ast.temporalMode.mode,
+    asOf: ast.temporalMode.asOf,
+    tableAlias
+  };
+}
+
+// src/query/compiler/passes/temporal.ts
+function createTemporalFilterPass(ast, currentTimestamp) {
+  return {
+    forAlias(tableAlias) {
+      return compileTemporalFilter({
+        ...extractTemporalOptions(ast, tableAlias),
+        currentTimestamp
+      });
+    }
+  };
+}
+
+// src/query/compiler/passes/vector.ts
+function runVectorPredicatePass(ast, dialect) {
+  const vectorPredicates = extractVectorSimilarityPredicates(ast.predicates);
+  if (vectorPredicates.length > 1) {
+    throw new UnsupportedPredicateError(
+      "Multiple vector similarity predicates in a single query are not supported"
+    );
+  }
+  const vectorPredicate = vectorPredicates[0];
+  if (vectorPredicate === void 0) {
+    return { vectorPredicate: void 0 };
+  }
+  const vectorStrategy = dialect.capabilities.vectorPredicateStrategy;
+  if (vectorStrategy === "unsupported" || !dialect.supportsVectors) {
+    throw new UnsupportedPredicateError(
+      `Vector similarity predicates are not supported for dialect "${dialect.name}"`
+    );
+  }
+  if (!dialect.capabilities.vectorMetrics.includes(vectorPredicate.metric)) {
+    throw new UnsupportedPredicateError(
+      `Vector metric "${vectorPredicate.metric}" is not supported for dialect "${dialect.name}"`
+    );
+  }
+  if (!Number.isFinite(vectorPredicate.limit) || vectorPredicate.limit <= 0) {
+    throw new UnsupportedPredicateError(
+      `Vector predicate limit must be a positive finite number, got ${String(vectorPredicate.limit)}`
+    );
+  }
+  const { minScore } = vectorPredicate;
+  if (minScore !== void 0) {
+    if (!Number.isFinite(minScore)) {
+      throw new UnsupportedPredicateError(
+        `Vector minScore must be a finite number, got ${String(minScore)}`
+      );
+    }
+    if (vectorPredicate.metric === "cosine" && (minScore < -1 || minScore > 1)) {
+      throw new UnsupportedPredicateError(
+        `Cosine minScore must be between -1 and 1, got ${String(minScore)}`
+      );
+    }
+  }
+  return { vectorPredicate };
+}
+function resolveVectorAwareLimit(astLimit, vectorPredicate) {
+  if (vectorPredicate === void 0) {
+    return astLimit;
+  }
+  if (astLimit === void 0) {
+    return vectorPredicate.limit;
+  }
+  return Math.min(astLimit, vectorPredicate.limit);
+}
+
+// src/query/compiler/plan/lowering.ts
+function createPlanNodeIdFactory() {
+  let current = 0;
+  return function nextPlanNodeId() {
+    current += 1;
+    return `plan_${current.toString(36)}`;
+  };
+}
+function extractAggregateExpressions(ast) {
+  const aggregates = [];
+  for (const field2 of ast.projection.fields) {
+    if ("__type" in field2.source && field2.source.__type === "aggregate") {
+      aggregates.push(field2.source);
+    }
   }
-  if (input.limitOffset !== void 0) {
-    parts.push(input.limitOffset);
+  return aggregates;
+}
+function getAliasPredicates(ast, alias, predicateTargetType) {
+  return ast.predicates.filter((predicate2) => {
+    const targetType = predicate2.targetType ?? "node";
+    return predicate2.targetAlias === alias && targetType === predicateTargetType;
+  });
+}
+function wrapWithAliasFilterNode(currentNode, ast, alias, predicateTargetType, nextPlanNodeId) {
+  const aliasPredicates = getAliasPredicates(ast, alias, predicateTargetType);
+  if (aliasPredicates.length === 0) {
+    return currentNode;
   }
-  return sql.join(parts, sql` `);
+  return {
+    alias,
+    id: nextPlanNodeId(),
+    input: currentNode,
+    op: "filter",
+    predicateTargetType,
+    predicates: aliasPredicates.map((predicate2) => predicate2.expression)
+  };
 }
-function assertSetOperationEmitterClauseAlignment(logicalPlan, suffixClauses) {
-  const shape = inspectSetOperationPlan(logicalPlan);
-  const hasSuffixClauses = suffixClauses !== void 0 && suffixClauses.length > 0;
-  if (!shape.hasSort && !shape.hasLimitOffset && hasSuffixClauses) {
-    throw new CompilerInvariantError(
-      "Set-operation SQL emitter received suffix clauses for a plan without top-level sort or limit_offset nodes",
-      { component: "set-operation-emitter" }
-    );
+function appendAggregateSortLimitAndProjectNodes(currentNode, ast, nextPlanNodeId, limit, collapsedTraversalCteAlias) {
+  let node = currentNode;
+  const aggregateExpressions = extractAggregateExpressions(ast);
+  if (aggregateExpressions.length > 0 || ast.groupBy !== void 0 || ast.having !== void 0) {
+    const aggregateNode = {
+      aggregates: aggregateExpressions,
+      groupBy: ast.groupBy?.fields ?? [],
+      id: nextPlanNodeId(),
+      input: node,
+      op: "aggregate"
+    };
+    node = ast.having === void 0 ? aggregateNode : { ...aggregateNode, having: ast.having };
   }
-  if (!hasSuffixClauses) {
-    if (shape.hasSort || shape.hasLimitOffset) {
+  if (ast.orderBy !== void 0 && ast.orderBy.length > 0) {
+    node = {
+      id: nextPlanNodeId(),
+      input: node,
+      op: "sort",
+      orderBy: ast.orderBy
+    };
+  }
+  if (limit !== void 0 || ast.offset !== void 0) {
+    const limitOffsetNodeBase = {
+      id: nextPlanNodeId(),
+      input: node,
+      op: "limit_offset"
+    };
+    const hasLimit = limit !== void 0;
+    const hasOffset = ast.offset !== void 0;
+    if (hasLimit && hasOffset) {
+      node = {
+        ...limitOffsetNodeBase,
+        limit,
+        offset: ast.offset
+      };
+    } else if (hasLimit) {
+      node = { ...limitOffsetNodeBase, limit };
+    } else if (hasOffset) {
+      node = { ...limitOffsetNodeBase, offset: ast.offset };
+    } else {
       throw new CompilerInvariantError(
-        "Set-operation SQL emitter expected suffix clauses for plan containing top-level sort or limit_offset nodes",
-        { component: "set-operation-emitter" }
+        "limit_offset node requires limit or offset to be present"
       );
     }
-    return;
-  }
-  const limitOffsetClauseCount = shape.limitOffsetNode === void 0 ? 0 : (shape.limitOffsetNode.limit === void 0 ? 0 : 1) + (shape.limitOffsetNode.offset === void 0 ? 0 : 1);
-  const expectedClauseCount = (shape.sortNode === void 0 ? 0 : 1) + limitOffsetClauseCount;
-  if (suffixClauses.length !== expectedClauseCount) {
-    throw new CompilerInvariantError(
-      `Set-operation SQL emitter expected ${String(expectedClauseCount)} top-level suffix clause(s) from logical plan, got ${String(suffixClauses.length)}`,
-      { component: "set-operation-emitter" }
-    );
   }
+  const projectNodeBase = {
+    fields: ast.projection.fields,
+    id: nextPlanNodeId(),
+    input: node,
+    op: "project"
+  };
+  return collapsedTraversalCteAlias === void 0 ? projectNodeBase : {
+    ...projectNodeBase,
+    collapsedTraversalAlias: collapsedTraversalCteAlias
+  };
 }
-function emitSetOperationQuerySql(input) {
-  assertSetOperationEmitterClauseAlignment(
-    input.logicalPlan,
-    input.suffixClauses
+function lowerStandardQueryToLogicalPlanNode(input) {
+  const { ast, nextPlanNodeId } = input;
+  let currentNode = {
+    alias: ast.start.alias,
+    graphId: input.graphId,
+    id: nextPlanNodeId(),
+    kinds: ast.start.kinds,
+    op: "scan",
+    source: "nodes"
+  };
+  currentNode = wrapWithAliasFilterNode(
+    currentNode,
+    ast,
+    ast.start.alias,
+    "node",
+    nextPlanNodeId
   );
-  const parts = [];
-  if (input.ctes !== void 0 && input.ctes.length > 0) {
-    parts.push(sql`WITH ${sql.join([...input.ctes], sql`, `)}`);
-  }
-  parts.push(input.baseQuery);
-  if (input.suffixClauses !== void 0 && input.suffixClauses.length > 0) {
-    parts.push(...input.suffixClauses);
-  }
-  return sql.join(parts, sql` `);
-}
-function assertStandardEmitterClauseAlignment(logicalPlan, input) {
-  const planShape = inspectStandardProjectPlan(logicalPlan);
-  if (input.groupBy !== void 0 && !planShape.hasAggregate) {
-    throw new CompilerInvariantError(
-      "Standard SQL emitter received GROUP BY clause for a plan without aggregate nodes",
-      { component: "standard-emitter" }
-    );
-  }
-  if (input.having !== void 0 && !planShape.hasAggregate) {
-    throw new CompilerInvariantError(
-      "Standard SQL emitter received HAVING clause for a plan without aggregate nodes",
-      { component: "standard-emitter" }
+  for (const traversal of ast.traversals) {
+    currentNode = {
+      direction: traversal.direction,
+      edgeAlias: traversal.edgeAlias,
+      edgeKinds: traversal.edgeKinds,
+      id: nextPlanNodeId(),
+      input: currentNode,
+      inverseEdgeKinds: traversal.inverseEdgeKinds ?? [],
+      joinFromAlias: traversal.joinFromAlias,
+      joinType: traversal.optional ? "left" : "inner",
+      nodeAlias: traversal.nodeAlias,
+      nodeKinds: traversal.nodeKinds,
+      op: "join"
+    };
+    currentNode = wrapWithAliasFilterNode(
+      currentNode,
+      ast,
+      traversal.edgeAlias,
+      "edge",
+      nextPlanNodeId
     );
-  }
-  const expectsOrderBy = planShape.hasSort || planShape.hasVectorKnn;
-  if (expectsOrderBy && input.orderBy === void 0) {
-    throw new CompilerInvariantError(
-      "Standard SQL emitter expected ORDER BY clause for plan containing a sort or vector_knn node",
-      { component: "standard-emitter" }
+    currentNode = wrapWithAliasFilterNode(
+      currentNode,
+      ast,
+      traversal.nodeAlias,
+      "node",
+      nextPlanNodeId
     );
   }
-  if (!expectsOrderBy && input.orderBy !== void 0) {
-    throw new CompilerInvariantError(
-      "Standard SQL emitter received ORDER BY clause for a plan without sort or vector_knn nodes",
-      { component: "standard-emitter" }
-    );
+  if (input.vectorPredicate !== void 0) {
+    currentNode = {
+      id: nextPlanNodeId(),
+      input: currentNode,
+      op: "vector_knn",
+      predicate: input.vectorPredicate
+    };
   }
-  if (planShape.hasLimitOffset && input.limitOffset === void 0) {
-    throw new CompilerInvariantError(
-      "Standard SQL emitter expected LIMIT/OFFSET clause for plan containing a limit_offset node",
-      { component: "standard-emitter" }
+  return appendAggregateSortLimitAndProjectNodes(
+    currentNode,
+    ast,
+    nextPlanNodeId,
+    input.effectiveLimit,
+    input.collapsedTraversalCteAlias
+  );
+}
+function lowerRecursiveQueryToLogicalPlanNode(input) {
+  const { ast, nextPlanNodeId } = input;
+  const traversal = input.traversal ?? runRecursiveTraversalSelectionPass(input.ast);
+  let currentNode = {
+    alias: ast.start.alias,
+    graphId: input.graphId,
+    id: nextPlanNodeId(),
+    kinds: ast.start.kinds,
+    op: "scan",
+    source: "nodes"
+  };
+  currentNode = wrapWithAliasFilterNode(
+    currentNode,
+    ast,
+    ast.start.alias,
+    "node",
+    nextPlanNodeId
+  );
+  currentNode = {
+    edgeAlias: traversal.edgeAlias,
+    edgeKinds: traversal.edgeKinds,
+    id: nextPlanNodeId(),
+    input: currentNode,
+    inverseEdgeKinds: traversal.inverseEdgeKinds ?? [],
+    nodeAlias: traversal.nodeAlias,
+    nodeKinds: traversal.nodeKinds,
+    op: "recursive_expand",
+    traversal: traversal.variableLength
+  };
+  currentNode = wrapWithAliasFilterNode(
+    currentNode,
+    ast,
+    traversal.edgeAlias,
+    "edge",
+    nextPlanNodeId
+  );
+  currentNode = wrapWithAliasFilterNode(
+    currentNode,
+    ast,
+    traversal.nodeAlias,
+    "node",
+    nextPlanNodeId
+  );
+  return appendAggregateSortLimitAndProjectNodes(
+    currentNode,
+    ast,
+    nextPlanNodeId,
+    ast.limit
+  );
+}
+function lowerComposableQueryToLogicalPlanNode(query, dialect, graphId, nextPlanNodeId) {
+  if ("__type" in query) {
+    return lowerSetOperationToLogicalPlanNode(
+      query,
+      graphId,
+      dialect,
+      nextPlanNodeId
     );
   }
-  if (!planShape.hasLimitOffset && input.limitOffset !== void 0) {
-    throw new CompilerInvariantError(
-      "Standard SQL emitter received LIMIT/OFFSET clause for a plan without limit_offset nodes",
-      { component: "standard-emitter" }
-    );
+  const hasVariableLengthTraversal2 = query.traversals.some(
+    (traversal) => traversal.variableLength !== void 0
+  );
+  if (hasVariableLengthTraversal2) {
+    return lowerRecursiveQueryToLogicalPlanNode({
+      ast: query,
+      graphId,
+      nextPlanNodeId
+    });
   }
+  const vectorPredicate = runVectorPredicatePass(
+    query,
+    getDialect(dialect)
+  ).vectorPredicate;
+  const effectiveLimit = resolveVectorAwareLimit(query.limit, vectorPredicate);
+  const loweringInput = {
+    ast: query,
+    graphId,
+    nextPlanNodeId,
+    ...effectiveLimit === void 0 ? {} : { effectiveLimit },
+    ...vectorPredicate === void 0 ? {} : { vectorPredicate }
+  };
+  return lowerStandardQueryToLogicalPlanNode(loweringInput);
 }
-function emitStandardQuerySql(input) {
-  assertStandardEmitterClauseAlignment(input.logicalPlan, input);
-  const parts = [];
-  if (input.ctes.length > 0) {
-    parts.push(sql`WITH ${sql.join([...input.ctes], sql`, `)}`);
-  }
-  parts.push(sql`SELECT ${input.projection}`, input.fromClause);
-  if (input.groupBy !== void 0) {
-    parts.push(input.groupBy);
-  }
-  if (input.having !== void 0) {
-    parts.push(input.having);
-  }
-  if (input.orderBy !== void 0) {
-    parts.push(input.orderBy);
-  }
-  if (input.limitOffset !== void 0) {
-    parts.push(input.limitOffset);
+function lowerSetOperationToLogicalPlanNode(op, graphId, dialect, nextPlanNodeId) {
+  let currentNode = {
+    id: nextPlanNodeId(),
+    left: lowerComposableQueryToLogicalPlanNode(
+      op.left,
+      dialect,
+      graphId,
+      nextPlanNodeId
+    ),
+    op: "set_op",
+    operator: op.operator,
+    right: lowerComposableQueryToLogicalPlanNode(
+      op.right,
+      dialect,
+      graphId,
+      nextPlanNodeId
+    )
+  };
+  if (op.orderBy !== void 0 && op.orderBy.length > 0) {
+    currentNode = {
+      id: nextPlanNodeId(),
+      input: currentNode,
+      op: "sort",
+      orderBy: op.orderBy
+    };
   }
-  return sql.join(parts, sql` `);
-}
-var EMPTY_PREDICATES = [];
-function buildPredicateIndexKey(alias, targetType) {
-  return `${alias}\0${targetType}`;
-}
-function resolvePredicateTargetType(predicate2) {
-  return predicate2.targetType === "edge" ? "edge" : "node";
-}
-function buildPredicateIndex(ast) {
-  const byAliasAndType = /* @__PURE__ */ new Map();
-  for (const predicate2 of ast.predicates) {
-    const key = buildPredicateIndexKey(
-      predicate2.targetAlias,
-      resolvePredicateTargetType(predicate2)
-    );
-    const existing = byAliasAndType.get(key);
-    if (existing === void 0) {
-      byAliasAndType.set(key, [predicate2]);
+  if (op.limit !== void 0 || op.offset !== void 0) {
+    const limitOffsetBase = {
+      id: nextPlanNodeId(),
+      input: currentNode,
+      op: "limit_offset"
+    };
+    if (op.limit !== void 0 && op.offset !== void 0) {
+      currentNode = { ...limitOffsetBase, limit: op.limit, offset: op.offset };
+    } else if (op.limit === void 0) {
+      currentNode = { ...limitOffsetBase, offset: op.offset };
     } else {
-      existing.push(predicate2);
+      currentNode = { ...limitOffsetBase, limit: op.limit };
     }
   }
-  return { byAliasAndType };
-}
-function getPredicatesForAlias(predicateIndex, alias, targetType) {
-  return predicateIndex.byAliasAndType.get(
-    buildPredicateIndexKey(alias, targetType)
-  ) ?? EMPTY_PREDICATES;
+  return currentNode;
 }
-function compilePredicateClauses(predicates, predicateContext) {
-  return predicates.map(
-    (predicate2) => compilePredicateExpression(predicate2.expression, predicateContext)
-  );
+function lowerStandardQueryToLogicalPlan(input) {
+  const nextPlanNodeId = createPlanNodeIdFactory();
+  return {
+    metadata: {
+      dialect: input.dialect,
+      graphId: input.graphId
+    },
+    root: lowerStandardQueryToLogicalPlanNode({
+      ...input,
+      nextPlanNodeId
+    })
+  };
 }
-function compileKindFilter(column, kinds) {
-  if (kinds.length === 0) {
-    return sql`1 = 0`;
-  }
-  if (kinds.length === 1) {
-    return sql`${column} = ${kinds[0]}`;
-  }
-  return sql`${column} IN (${sql.join(
-    kinds.map((kind) => sql`${kind}`),
-    sql`, `
-  )})`;
+function lowerRecursiveQueryToLogicalPlan(input) {
+  const nextPlanNodeId = createPlanNodeIdFactory();
+  return {
+    metadata: {
+      dialect: input.dialect,
+      graphId: input.graphId
+    },
+    root: lowerRecursiveQueryToLogicalPlanNode({
+      ...input,
+      nextPlanNodeId
+    })
+  };
 }
-function getNodeKindsForAlias(ast, alias) {
-  if (alias === ast.start.alias) {
-    return ast.start.kinds;
-  }
-  for (const traversal of ast.traversals) {
-    if (traversal.nodeAlias === alias) {
-      return traversal.nodeKinds;
-    }
-  }
-  throw new CompilerInvariantError(`Unknown traversal source alias: ${alias}`);
+function lowerSetOperationToLogicalPlan(input) {
+  const nextPlanNodeId = createPlanNodeIdFactory();
+  return {
+    metadata: {
+      dialect: input.dialect,
+      graphId: input.graphId
+    },
+    root: lowerSetOperationToLogicalPlanNode(
+      input.op,
+      input.graphId,
+      input.dialect,
+      nextPlanNodeId
+    )
+  };
 }
 
-// src/query/compiler/typed-json-extract.ts
-function compileTypedJsonExtract(input) {
-  const { column, dialect, pointer, valueType } = input;
-  const fallback = input.fallback ?? "json";
-  switch (valueType) {
-    case "string": {
-      return dialect.jsonExtractText(column, pointer);
-    }
-    case "number": {
-      return dialect.jsonExtractNumber(column, pointer);
-    }
-    case "boolean": {
-      return dialect.jsonExtractBoolean(column, pointer);
+// src/query/compiler/recursive.ts
+var MAX_RECURSIVE_DEPTH = 100;
+var MAX_EXPLICIT_RECURSIVE_DEPTH = 1e3;
+var NO_ALWAYS_REQUIRED_COLUMNS = /* @__PURE__ */ new Set();
+function runRecursiveQueryPassPipeline(ast, graphId, ctx) {
+  let state = {
+    ast,
+    ctx,
+    graphId,
+    logicalPlan: void 0,
+    requiredColumnsByAlias: void 0,
+    temporalFilterPass: void 0,
+    traversal: void 0
+  };
+  const recursiveTraversalPass = runCompilerPass(state, {
+    name: "recursive_traversal",
+    execute(currentState) {
+      return runRecursiveTraversalSelectionPass(currentState.ast);
+    },
+    update(currentState, traversal) {
+      return {
+        ...currentState,
+        traversal
+      };
     }
-    case "date": {
-      return dialect.jsonExtractDate(column, pointer);
+  });
+  state = recursiveTraversalPass.state;
+  const temporalPass = runCompilerPass(state, {
+    name: "temporal_filters",
+    execute(currentState) {
+      return createTemporalFilterPass(
+        currentState.ast,
+        currentState.ctx.dialect.currentTimestamp()
+      );
+    },
+    update(currentState, temporalFilterPass) {
+      return {
+        ...currentState,
+        temporalFilterPass
+      };
     }
-    case "array":
-    case "object":
-    case "embedding":
-    case "unknown":
-    case void 0: {
-      return fallback === "text" ? dialect.jsonExtractText(column, pointer) : dialect.jsonExtract(column, pointer);
+  });
+  state = temporalPass.state;
+  const columnPruningPass = runCompilerPass(state, {
+    name: "column_pruning",
+    execute(currentState) {
+      const traversal = currentState.traversal;
+      if (traversal === void 0) {
+        throw new CompilerInvariantError(
+          "Recursive traversal pass did not select traversal"
+        );
+      }
+      return collectRequiredColumnsByAlias(currentState.ast, traversal);
+    },
+    update(currentState, requiredColumnsByAlias) {
+      return {
+        ...currentState,
+        requiredColumnsByAlias
+      };
     }
-    default: {
-      return fallback === "text" ? dialect.jsonExtractText(column, pointer) : dialect.jsonExtract(column, pointer);
+  });
+  state = columnPruningPass.state;
+  const logicalPlanPass = runCompilerPass(state, {
+    name: "logical_plan",
+    execute(currentState) {
+      const loweringInput = {
+        ast: currentState.ast,
+        dialect: currentState.ctx.dialect.name,
+        graphId: currentState.graphId,
+        ...currentState.traversal === void 0 ? {} : { traversal: currentState.traversal }
+      };
+      return lowerRecursiveQueryToLogicalPlan(loweringInput);
+    },
+    update(currentState, logicalPlan) {
+      return {
+        ...currentState,
+        logicalPlan
+      };
     }
-  }
-}
-var NODE_COLUMNS = [
-  "id",
-  "kind",
-  "props",
-  "version",
-  "valid_from",
-  "valid_to",
-  "created_at",
-  "updated_at",
-  "deleted_at"
-];
-var EDGE_COLUMNS = [
-  "id",
-  "kind",
-  "from_id",
-  "to_id",
-  "props",
-  "valid_from",
-  "valid_to",
-  "created_at",
-  "updated_at",
-  "deleted_at"
-];
-var EMPTY_REQUIRED_COLUMNS = /* @__PURE__ */ new Set();
-function quoteIdentifier(identifier) {
-  return sql.raw(`"${identifier.replaceAll('"', '""')}"`);
-}
-function shouldProjectColumn(requiredColumns, column, alwaysRequiredColumns) {
-  if (alwaysRequiredColumns?.has(column)) return true;
-  if (requiredColumns === void 0) return true;
-  return requiredColumns.has(column);
-}
-function addRequiredColumn(requiredColumnsByAlias, alias, column) {
-  const existing = requiredColumnsByAlias.get(alias);
-  if (existing) {
-    existing.add(column);
-    return;
-  }
-  requiredColumnsByAlias.set(alias, /* @__PURE__ */ new Set([column]));
+  });
+  state = logicalPlanPass.state;
+  return state;
 }
-function markFieldRefAsRequired(requiredColumnsByAlias, field2) {
-  const column = field2.path[0];
-  if (column === void 0) return;
-  addRequiredColumn(requiredColumnsByAlias, field2.alias, column);
+function compileVariableLengthQuery(ast, graphId, ctx) {
+  const strategy = ctx.dialect.capabilities.recursiveQueryStrategy;
+  const handler = RECURSIVE_QUERY_STRATEGY_HANDLERS[strategy];
+  return handler(ast, graphId, ctx);
 }
-function mapSelectiveSystemFieldToColumn(field2) {
-  if (field2 === "fromId") return "from_id";
-  if (field2 === "toId") return "to_id";
-  if (field2.startsWith("meta.")) {
-    return field2.slice(5).replaceAll(/([A-Z])/g, "_$1").toLowerCase();
+var RECURSIVE_QUERY_STRATEGY_HANDLERS = {
+  recursive_cte: compileVariableLengthQueryWithRecursiveCteStrategy
+};
+function compileVariableLengthQueryWithRecursiveCteStrategy(ast, graphId, ctx) {
+  const passState = runRecursiveQueryPassPipeline(ast, graphId, ctx);
+  const { dialect } = ctx;
+  const {
+    logicalPlan,
+    requiredColumnsByAlias,
+    temporalFilterPass,
+    traversal: vlTraversal
+  } = passState;
+  if (temporalFilterPass === void 0) {
+    throw new CompilerInvariantError(
+      "Temporal filter pass did not initialize temporal state"
+    );
   }
-  return field2;
-}
-function markSelectiveFieldAsRequired(requiredColumnsByAlias, field2) {
-  if (field2.isSystemField) {
-    addRequiredColumn(
-      requiredColumnsByAlias,
-      field2.alias,
-      mapSelectiveSystemFieldToColumn(field2.field)
+  if (logicalPlan === void 0) {
+    throw new CompilerInvariantError(
+      "Logical plan pass did not initialize plan state"
     );
-    return;
   }
-  addRequiredColumn(requiredColumnsByAlias, field2.alias, "props");
-}
-function isIdFieldRef(field2) {
-  return field2.path.length === 1 && field2.path[0] === "id" && field2.jsonPointer === void 0;
-}
-function isAggregateExpr(source) {
-  return "__type" in source && source.__type === "aggregate";
-}
-
-// src/query/compiler/emitter/standard-builders.ts
-function compileColumnReference(tableAlias, column) {
-  if (tableAlias === void 0) {
-    return sql.raw(column);
+  if (vlTraversal === void 0) {
+    throw new CompilerInvariantError(
+      "Recursive traversal pass did not select traversal"
+    );
   }
-  return sql`${sql.raw(tableAlias)}.${sql.raw(column)}`;
-}
-function compileNodeSelectColumns(tableAlias, alias, requiredColumns) {
-  return NODE_COLUMNS.filter(
-    (column) => column === "id" || column === "kind" || shouldProjectColumn(requiredColumns, column)
-  ).map(
-    (column) => sql`${compileColumnReference(tableAlias, column)} AS ${sql.raw(`${alias}_${column}`)}`
-  );
-}
-function compileEdgeSelectColumns(tableAlias, alias, requiredColumns) {
-  return EDGE_COLUMNS.filter(
-    (column) => shouldProjectColumn(requiredColumns, column)
-  ).map(
-    (column) => sql`${compileColumnReference(tableAlias, column)} AS ${sql.raw(`${alias}_${column}`)}`
-  );
-}
-function buildStandardStartCte(input) {
-  const { ast, ctx, graphId, predicateIndex, requiredColumnsByAlias } = input;
-  const alias = ast.start.alias;
-  const kinds = ast.start.kinds;
-  const kindFilter = compileKindFilter(sql.raw("kind"), kinds);
-  const temporalFilter = input.temporalFilterPass.forAlias();
-  const cteContext = { ...ctx, cteColumnPrefix: "" };
-  const predicateClauses = compilePredicateClauses(
-    getPredicatesForAlias(predicateIndex, alias, "node"),
-    cteContext
-  );
-  const whereClauses = [
-    sql`graph_id = ${graphId}`,
-    kindFilter,
-    temporalFilter,
-    ...predicateClauses
-  ];
-  const effectiveRequiredColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(alias) ?? EMPTY_REQUIRED_COLUMNS : void 0;
-  return sql`
-    cte_${sql.raw(alias)} AS (
-      SELECT ${sql.join(
-    compileNodeSelectColumns(void 0, alias, effectiveRequiredColumns),
-    sql`, `
-  )}
-      FROM ${ctx.schema.nodesTable}
-      WHERE ${sql.join(whereClauses, sql` AND `)}
-    )
-  `;
-}
-function buildStandardTraversalCte(input) {
-  const {
+  const recursiveCte = compileRecursiveCte(
     ast,
-    carryForwardPreviousColumns,
-    ctx,
+    vlTraversal,
     graphId,
-    materializeCte,
-    predicateIndex,
+    ctx,
     requiredColumnsByAlias,
-    temporalFilterPass,
-    traversalIndex,
-    traversalLimit
-  } = input;
-  const traversal = ast.traversals[traversalIndex];
-  const traversalLimitValue = traversalIndex === ast.traversals.length - 1 ? traversalLimit : void 0;
-  const previousNodeKinds = getNodeKindsForAlias(ast, traversal.joinFromAlias);
+    temporalFilterPass
+  );
+  const projection = compileRecursiveProjection(ast, vlTraversal, dialect);
+  const minDepth = vlTraversal.variableLength.minDepth;
+  const depthFilter = minDepth > 0 ? sql`WHERE depth >= ${minDepth}` : sql.raw("");
+  const orderBy = compileRecursiveOrderBy(ast, dialect);
+  const limitOffset = compileLimitOffset(ast);
+  return emitRecursiveQuerySql({
+    depthFilter,
+    ...limitOffset === void 0 ? {} : { limitOffset },
+    logicalPlan,
+    ...orderBy === void 0 ? {} : { orderBy },
+    projection,
+    recursiveCte
+  });
+}
+function hasVariableLengthTraversal(ast) {
+  return ast.traversals.some((t) => t.variableLength !== void 0);
+}
+function compileRecursiveCte(ast, traversal, graphId, ctx, requiredColumnsByAlias, temporalFilterPass) {
+  const { dialect } = ctx;
+  const startAlias = ast.start.alias;
+  const startKinds = ast.start.kinds;
+  const nodeAlias = traversal.nodeAlias;
   const directEdgeKinds = [...new Set(traversal.edgeKinds)];
   const inverseEdgeKinds = traversal.inverseEdgeKinds === void 0 ? [] : [...new Set(traversal.inverseEdgeKinds)];
+  const forceWorktableOuterJoinOrder = dialect.capabilities.forceRecursiveWorktableOuterJoinOrder;
   const nodeKinds = traversal.nodeKinds;
-  const nodeKindFilter = compileKindFilter(sql.raw("n.kind"), nodeKinds);
+  const previousNodeKinds = [.../* @__PURE__ */ new Set([...startKinds, ...nodeKinds])];
+  const direction = traversal.direction;
+  const vl = traversal.variableLength;
+  const shouldEnforceCycleCheck = vl.cyclePolicy !== "allow";
+  const shouldTrackPath = shouldEnforceCycleCheck || vl.pathAlias !== void 0;
+  const recursiveJoinRequiredColumns = /* @__PURE__ */ new Set(["id"]);
+  if (previousNodeKinds.length > 1) {
+    recursiveJoinRequiredColumns.add("kind");
+  }
+  const requiredStartColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(startAlias) ?? EMPTY_REQUIRED_COLUMNS : void 0;
+  const requiredNodeColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(nodeAlias) ?? EMPTY_REQUIRED_COLUMNS : void 0;
+  const startColumnsFromBase = compileNodeSelectColumnsFromTable(
+    "n0",
+    startAlias,
+    requiredStartColumns,
+    NO_ALWAYS_REQUIRED_COLUMNS
+  );
+  const startColumnsFromRecursive = compileNodeSelectColumnsFromRecursiveRow(
+    startAlias,
+    requiredStartColumns,
+    NO_ALWAYS_REQUIRED_COLUMNS
+  );
+  const nodeColumnsFromBase = compileNodeSelectColumnsFromTable(
+    "n0",
+    nodeAlias,
+    requiredNodeColumns,
+    recursiveJoinRequiredColumns
+  );
+  const nodeColumnsFromRecursive = compileNodeSelectColumnsFromTable(
+    "n",
+    nodeAlias,
+    requiredNodeColumns,
+    recursiveJoinRequiredColumns
+  );
+  const startKindFilter = compileKindFilter2(startKinds, "n0.kind");
+  const nodeKindFilter = compileKindFilter2(nodeKinds, "n.kind");
+  const startTemporalFilter = temporalFilterPass.forAlias("n0");
   const edgeTemporalFilter = temporalFilterPass.forAlias("e");
   const nodeTemporalFilter = temporalFilterPass.forAlias("n");
-  const nodeCteContext = {
-    ...ctx,
-    cteColumnPrefix: "n"
-  };
-  const nodePredicateClauses = compilePredicateClauses(
-    getPredicatesForAlias(predicateIndex, traversal.nodeAlias, "node"),
-    nodeCteContext
-  );
-  const edgeCteContext = {
-    ...ctx,
-    cteColumnPrefix: "e"
-  };
-  const edgePredicateClauses = compilePredicateClauses(
-    getPredicatesForAlias(predicateIndex, traversal.edgeAlias, "edge"),
-    edgeCteContext
+  const startContext = { ...ctx, cteColumnPrefix: "" };
+  const startPredicates = compileNodePredicates(ast, startAlias, startContext);
+  const edgeContext = { ...ctx, cteColumnPrefix: "e" };
+  const edgePredicates = compileEdgePredicates(
+    ast,
+    traversal.edgeAlias,
+    edgeContext
+  );
+  const targetContext = { ...ctx, cteColumnPrefix: "n" };
+  const targetNodePredicates = compileNodePredicates(
+    ast,
+    nodeAlias,
+    targetContext
   );
+  if (vl.maxDepth > MAX_EXPLICIT_RECURSIVE_DEPTH) {
+    throw new UnsupportedPredicateError(
+      `Recursive traversal maxHops(${vl.maxDepth}) exceeds maximum explicit depth of ${MAX_EXPLICIT_RECURSIVE_DEPTH}`
+    );
+  }
+  const effectiveMaxDepth = vl.maxDepth > 0 ? vl.maxDepth : MAX_RECURSIVE_DEPTH;
+  const maxDepthCondition = sql`r.depth < ${effectiveMaxDepth}`;
+  const cycleCheck = shouldEnforceCycleCheck ? dialect.cycleCheck(sql.raw("n.id"), sql.raw("r.path")) : void 0;
+  const initialPath = shouldTrackPath ? dialect.initializePath(sql.raw("n0.id")) : void 0;
+  const pathExtension = shouldTrackPath ? dialect.extendPath(sql.raw("r.path"), sql.raw("n.id")) : void 0;
   const baseWhereClauses = [
+    sql`n0.graph_id = ${graphId}`,
+    startKindFilter,
+    startTemporalFilter,
+    ...startPredicates
+  ];
+  const recursiveBaseWhereClauses = [
     sql`e.graph_id = ${graphId}`,
     nodeKindFilter,
     edgeTemporalFilter,
     nodeTemporalFilter,
-    ...nodePredicateClauses,
-    ...edgePredicateClauses
-  ];
-  const previousAlias = traversal.joinFromAlias;
-  const edgeAlias = traversal.edgeAlias;
-  const nodeAlias = traversal.nodeAlias;
-  const requiredNodeColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(nodeAlias) ?? EMPTY_REQUIRED_COLUMNS : void 0;
-  const requiredEdgeColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(edgeAlias) ?? EMPTY_REQUIRED_COLUMNS : void 0;
-  const previousRowColumns = carryForwardPreviousColumns ? [sql`cte_${sql.raw(previousAlias)}.*`] : [
-    sql`cte_${sql.raw(previousAlias)}.${sql.raw(previousAlias)}_id AS ${sql.raw(previousAlias)}_id`,
-    sql`cte_${sql.raw(previousAlias)}.${sql.raw(previousAlias)}_kind AS ${sql.raw(previousAlias)}_kind`
-  ];
-  const selectColumns = [
-    ...previousRowColumns,
-    ...compileEdgeSelectColumns("e", edgeAlias, requiredEdgeColumns),
-    ...compileNodeSelectColumns("n", nodeAlias, requiredNodeColumns)
+    maxDepthCondition
   ];
-  const cteMaterialization = materializeCte ? sql`MATERIALIZED ` : sql``;
-  function compileTraversalBranch(branch) {
-    const whereClauses = [
-      ...baseWhereClauses,
-      compileKindFilter(sql.raw("e.kind"), branch.edgeKinds),
-      compileKindFilter(
-        sql.raw(`e.${branch.joinKindField}`),
-        previousNodeKinds
-      ),
-      compileKindFilter(sql.raw(`e.${branch.targetKindField}`), nodeKinds)
+  if (cycleCheck !== void 0) {
+    recursiveBaseWhereClauses.push(cycleCheck);
+  }
+  recursiveBaseWhereClauses.push(...edgePredicates, ...targetNodePredicates);
+  function compileRecursiveBranch2(branch) {
+    const recursiveFilterClauses = [
+      ...recursiveBaseWhereClauses,
+      compileKindFilter2(branch.edgeKinds, "e.kind"),
+      compileKindFilter2(previousNodeKinds, `e.${branch.joinKindField}`),
+      compileKindFilter2(nodeKinds, `e.${branch.targetKindField}`)
     ];
     if (branch.duplicateGuard !== void 0) {
-      whereClauses.push(branch.duplicateGuard);
-    }
-    return sql`
-      SELECT ${sql.join(selectColumns, sql`, `)}
-      FROM cte_${sql.raw(previousAlias)}
-      JOIN ${ctx.schema.edgesTable} e ON cte_${sql.raw(previousAlias)}.${sql.raw(previousAlias)}_id = e.${sql.raw(branch.joinField)}
-        AND cte_${sql.raw(previousAlias)}.${sql.raw(previousAlias)}_kind = e.${sql.raw(branch.joinKindField)}
-      JOIN ${ctx.schema.nodesTable} n ON n.graph_id = e.graph_id
-        AND n.id = e.${sql.raw(branch.targetField)}
-        AND n.kind = e.${sql.raw(branch.targetKindField)}
-      WHERE ${sql.join(whereClauses, sql` AND `)}
-    `;
-  }
-  const directJoinField = traversal.direction === "out" ? "from_id" : "to_id";
-  const directTargetField = traversal.direction === "out" ? "to_id" : "from_id";
-  const directJoinKindField = traversal.direction === "out" ? "from_kind" : "to_kind";
-  const directTargetKindField = traversal.direction === "out" ? "to_kind" : "from_kind";
-  const directBranch = compileTraversalBranch({
-    edgeKinds: directEdgeKinds,
-    joinField: directJoinField,
-    joinKindField: directJoinKindField,
-    targetField: directTargetField,
-    targetKindField: directTargetKindField
-  });
-  if (inverseEdgeKinds.length === 0) {
-    if (traversalLimitValue !== void 0) {
-      return sql`
-        cte_${sql.raw(nodeAlias)} AS ${cteMaterialization}(
-          SELECT * FROM (
-            ${directBranch}
-          ) AS traversal_rows
-          LIMIT ${traversalLimitValue}
-        )
-      `;
+      recursiveFilterClauses.push(branch.duplicateGuard);
     }
-    return sql`
-      cte_${sql.raw(nodeAlias)} AS ${cteMaterialization}(
-        ${directBranch}
-      )
-    `;
-  }
-  const inverseJoinField = traversal.direction === "out" ? "to_id" : "from_id";
-  const inverseTargetField = traversal.direction === "out" ? "from_id" : "to_id";
-  const inverseJoinKindField = traversal.direction === "out" ? "to_kind" : "from_kind";
-  const inverseTargetKindField = traversal.direction === "out" ? "from_kind" : "to_kind";
-  const overlappingKinds = inverseEdgeKinds.filter(
-    (kind) => directEdgeKinds.includes(kind)
-  );
-  const duplicateGuard = overlappingKinds.length > 0 ? sql`NOT (e.from_id = e.to_id AND ${compileKindFilter(
-    sql.raw("e.kind"),
-    overlappingKinds
-  )})` : void 0;
-  const inverseBranch = compileTraversalBranch({
-    duplicateGuard,
-    edgeKinds: inverseEdgeKinds,
-    joinField: inverseJoinField,
-    joinKindField: inverseJoinKindField,
-    targetField: inverseTargetField,
-    targetKindField: inverseTargetKindField
-  });
-  if (traversalLimitValue !== void 0) {
-    return sql`
-      cte_${sql.raw(nodeAlias)} AS ${cteMaterialization}(
-        SELECT * FROM (
-          ${directBranch}
-          UNION ALL
-          ${inverseBranch}
-        ) AS traversal_rows
-        LIMIT ${traversalLimitValue}
-      )
-    `;
-  }
-  return sql`
-    cte_${sql.raw(nodeAlias)} AS ${cteMaterialization}(
-      ${directBranch}
-      UNION ALL
-      ${inverseBranch}
-    )
-  `;
-}
-function compileAggregateExprFromSource(expr, dialect) {
-  const { field: field2 } = expr;
-  const fn = expr.function;
-  switch (fn) {
-    case "count":
-    case "countDistinct":
-    case "sum":
-    case "avg":
-    case "min":
-    case "max": {
-      const cteAlias = `cte_${field2.alias}`;
-      const column = compileFieldValue(
-        field2,
-        dialect,
-        field2.valueType,
-        cteAlias
-      );
-      if (fn === "countDistinct") {
-        return sql`COUNT(DISTINCT ${column})`;
-      }
-      return sql`${sql.raw(fn.toUpperCase())}(${column})`;
+    const recursiveSelectColumns = [
+      ...startColumnsFromRecursive,
+      ...nodeColumnsFromRecursive,
+      sql`r.depth + 1 AS depth`
+    ];
+    if (pathExtension !== void 0) {
+      recursiveSelectColumns.push(sql`${pathExtension} AS path`);
     }
-    default: {
-      throw new UnsupportedPredicateError(
-        `Unknown aggregate function: ${String(fn)}`
+    const recursiveJoinClauses = [
+      sql`e.${sql.raw(branch.joinField)} = r.${sql.raw(nodeAlias)}_id`
+    ];
+    if (previousNodeKinds.length > 1) {
+      recursiveJoinClauses.push(
+        sql`e.${sql.raw(branch.joinKindField)} = r.${sql.raw(nodeAlias)}_kind`
       );
     }
+    if (forceWorktableOuterJoinOrder) {
+      const recursiveWhereClauses = [
+        ...recursiveJoinClauses,
+        ...recursiveFilterClauses
+      ];
+      return sql`
+        SELECT ${sql.join(recursiveSelectColumns, sql`, `)}
+        FROM recursive_cte r
+        CROSS JOIN ${ctx.schema.edgesTable} e
+        JOIN ${ctx.schema.nodesTable} n ON n.graph_id = e.graph_id
+          AND n.id = e.${sql.raw(branch.targetField)}
+          AND n.kind = e.${sql.raw(branch.targetKindField)}
+        WHERE ${sql.join(recursiveWhereClauses, sql` AND `)}
+      `;
+    }
+    return sql`
+      SELECT ${sql.join(recursiveSelectColumns, sql`, `)}
+      FROM recursive_cte r
+      JOIN ${ctx.schema.edgesTable} e ON ${sql.join(recursiveJoinClauses, sql` AND `)}
+      JOIN ${ctx.schema.nodesTable} n ON n.graph_id = e.graph_id
+        AND n.id = e.${sql.raw(branch.targetField)}
+        AND n.kind = e.${sql.raw(branch.targetKindField)}
+      WHERE ${sql.join(recursiveFilterClauses, sql` AND `)}
+    `;
   }
-}
-function compileProjectedSource(field2, dialect) {
-  if (isAggregateExpr(field2.source)) {
-    return compileAggregateExprFromSource(field2.source, dialect);
-  }
-  const cteAlias = field2.cteAlias ?? `cte_${field2.source.alias}`;
-  return compileFieldValue(
-    field2.source,
-    dialect,
-    field2.source.valueType,
-    cteAlias
-  );
-}
-function buildStandardProjection(input) {
-  const { ast, collapsedTraversalCteAlias, dialect } = input;
-  if (ast.selectiveFields && ast.selectiveFields.length > 0) {
-    return compileSelectiveProjection(
-      ast.selectiveFields,
-      dialect,
-      ast,
-      collapsedTraversalCteAlias
-    );
-  }
-  const fields = ast.projection.fields;
-  if (fields.length === 0) {
-    return sql.raw("*");
-  }
-  const projectedFields = fields.map((field2) => {
-    const source = compileProjectedSource(field2, dialect);
-    return sql`${source} AS ${quoteIdentifier(field2.outputName)}`;
-  });
-  return sql.join(projectedFields, sql`, `);
-}
-function compileSelectiveProjection(fields, dialect, ast, collapsedTraversalCteAlias) {
-  const aliasToCte = /* @__PURE__ */ new Map([
-    [ast.start.alias, `cte_${ast.start.alias}`]
-  ]);
-  for (const traversal of ast.traversals) {
-    aliasToCte.set(traversal.nodeAlias, `cte_${traversal.nodeAlias}`);
-    aliasToCte.set(traversal.edgeAlias, `cte_${traversal.nodeAlias}`);
-  }
-  const columns = fields.map((field2) => {
-    const cteAlias = collapsedTraversalCteAlias ?? aliasToCte.get(field2.alias) ?? `cte_${field2.alias}`;
-    if (field2.isSystemField) {
-      const dbColumn = mapSelectiveSystemFieldToColumn(field2.field);
-      return sql`${sql.raw(cteAlias)}.${sql.raw(`${field2.alias}_${dbColumn}`)} AS ${quoteIdentifier(field2.outputName)}`;
-    }
-    const propsColumn = `${field2.alias}_props`;
-    const column = sql`${sql.raw(cteAlias)}.${sql.raw(propsColumn)}`;
-    const pointer = jsonPointer([field2.field]);
-    const extracted = compileTypedJsonExtract({
-      column,
-      dialect,
-      pointer,
-      valueType: field2.valueType
-    });
-    return sql`${extracted} AS ${quoteIdentifier(field2.outputName)}`;
-  });
-  return sql.join(columns, sql`, `);
-}
-function buildStandardFromClause(input) {
-  const { ast, collapsedTraversalCteAlias, vectorPredicate } = input;
-  if (collapsedTraversalCteAlias !== void 0) {
-    return sql`FROM ${sql.raw(collapsedTraversalCteAlias)}`;
-  }
-  const startAlias = ast.start.alias;
-  const fromClause = sql`FROM cte_${sql.raw(startAlias)}`;
-  const joins = [];
-  for (const traversal of ast.traversals) {
-    const cteAlias = `cte_${traversal.nodeAlias}`;
-    const previousAlias = traversal.joinFromAlias;
-    const joinType = traversal.optional ? "LEFT JOIN" : "INNER JOIN";
-    joins.push(
-      sql`${sql.raw(joinType)} ${sql.raw(cteAlias)} ON ${sql.raw(cteAlias)}.${sql.raw(previousAlias)}_id = cte_${sql.raw(previousAlias)}.${sql.raw(previousAlias)}_id AND ${sql.raw(cteAlias)}.${sql.raw(previousAlias)}_kind = cte_${sql.raw(previousAlias)}.${sql.raw(previousAlias)}_kind`
+  const directJoinField = direction === "out" ? "from_id" : "to_id";
+  const directTargetField = direction === "out" ? "to_id" : "from_id";
+  const directJoinKindField = direction === "out" ? "from_kind" : "to_kind";
+  const directTargetKindField = direction === "out" ? "to_kind" : "from_kind";
+  const directBranch = compileRecursiveBranch2({
+    joinField: directJoinField,
+    targetField: directTargetField,
+    joinKindField: directJoinKindField,
+    targetKindField: directTargetKindField,
+    edgeKinds: directEdgeKinds
+  });
+  function compileInverseRecursiveBranch() {
+    const inverseJoinField = direction === "out" ? "to_id" : "from_id";
+    const inverseTargetField = direction === "out" ? "from_id" : "to_id";
+    const inverseJoinKindField = direction === "out" ? "to_kind" : "from_kind";
+    const inverseTargetKindField = direction === "out" ? "from_kind" : "to_kind";
+    const overlappingKinds = inverseEdgeKinds.filter(
+      (kind) => directEdgeKinds.includes(kind)
     );
+    const duplicateGuard = overlappingKinds.length > 0 ? sql`NOT (e.from_id = e.to_id AND ${compileKindFilter2(overlappingKinds, "e.kind")})` : void 0;
+    const inverseBranch = compileRecursiveBranch2({
+      joinField: inverseJoinField,
+      targetField: inverseTargetField,
+      joinKindField: inverseJoinKindField,
+      targetKindField: inverseTargetKindField,
+      edgeKinds: inverseEdgeKinds,
+      duplicateGuard
+    });
+    return sql`
+      ${directBranch}
+      UNION ALL
+      ${inverseBranch}
+    `;
   }
-  if (vectorPredicate) {
-    const nodeAlias = vectorPredicate.field.alias;
-    joins.push(
-      sql`INNER JOIN cte_embeddings ON cte_embeddings.node_id = cte_${sql.raw(nodeAlias)}.${sql.raw(nodeAlias)}_id`
-    );
+  const recursiveBranchSql = inverseEdgeKinds.length === 0 ? directBranch : compileInverseRecursiveBranch();
+  const baseSelectColumns = [
+    ...startColumnsFromBase,
+    ...nodeColumnsFromBase,
+    sql`0 AS depth`
+  ];
+  if (initialPath !== void 0) {
+    baseSelectColumns.push(sql`${initialPath} AS path`);
   }
-  return joins.length === 0 ? fromClause : sql`${fromClause} ${sql.join(joins, sql` `)}`;
+  return sql`
+    recursive_cte AS (
+      -- Base case: starting nodes
+      SELECT ${sql.join(baseSelectColumns, sql`, `)}
+      FROM ${ctx.schema.nodesTable} n0
+      WHERE ${sql.join(baseWhereClauses, sql` AND `)}
+
+      UNION ALL
+
+      -- Recursive case: follow edges
+      ${recursiveBranchSql}
+    )
+  `;
 }
-function buildStandardOrderBy(input) {
-  const { ast, collapsedTraversalCteAlias, dialect } = input;
-  if (!ast.orderBy || ast.orderBy.length === 0) {
-    return void 0;
-  }
-  const parts = [];
-  for (const orderSpec of ast.orderBy) {
-    const valueType = orderSpec.field.valueType;
-    if (valueType === "array" || valueType === "object") {
-      throw new UnsupportedPredicateError(
-        "Ordering by JSON arrays or objects is not supported"
-      );
-    }
-    const cteAlias = collapsedTraversalCteAlias ?? `cte_${orderSpec.field.alias}`;
-    const field2 = compileFieldValue(
-      orderSpec.field,
-      dialect,
-      valueType,
-      cteAlias
-    );
-    const direction = sql.raw(orderSpec.direction.toUpperCase());
-    const nulls = orderSpec.nulls ?? (orderSpec.direction === "asc" ? "last" : "first");
-    const nullsDirection = sql.raw(nulls === "first" ? "DESC" : "ASC");
-    parts.push(
-      sql`(${field2} IS NULL) ${nullsDirection}`,
-      sql`${field2} ${direction}`
-    );
-  }
-  return sql`ORDER BY ${sql.join(parts, sql`, `)}`;
+function compileKindFilter2(kinds, columnExpr) {
+  return compileKindFilter(sql.raw(columnExpr), kinds);
 }
-function fieldRefKey(field2) {
-  const pointer = field2.jsonPointer ?? "";
-  return `${field2.alias}:${field2.path.join(".")}:${pointer}`;
+function compileNodePredicates(ast, alias, ctx) {
+  return ast.predicates.filter((p) => p.targetAlias === alias && p.targetType !== "edge").map((p) => compilePredicateExpression(p.expression, ctx));
 }
-function buildStandardGroupBy(input) {
-  const { ast, dialect } = input;
-  if (!ast.groupBy || ast.groupBy.fields.length === 0) {
+function compileEdgePredicates(ast, edgeAlias, ctx) {
+  return ast.predicates.filter((p) => p.targetAlias === edgeAlias && p.targetType === "edge").map((p) => compilePredicateExpression(p.expression, ctx));
+}
+function collectRequiredColumnsByAlias(ast, traversal) {
+  const selectiveFields = ast.selectiveFields;
+  if (selectiveFields === void 0 || selectiveFields.length === 0) {
     return void 0;
   }
-  const seenKeys = /* @__PURE__ */ new Set();
-  const allFields = [];
-  for (const projectedField of ast.projection.fields) {
-    if (projectedField.source.__type === "field_ref") {
-      const key = fieldRefKey(projectedField.source);
-      if (!seenKeys.has(key)) {
-        seenKeys.add(key);
-        allFields.push(projectedField.source);
-      }
-    }
+  const requiredColumnsByAlias = /* @__PURE__ */ new Map();
+  const previousNodeKinds = [
+    .../* @__PURE__ */ new Set([...ast.start.kinds, ...traversal.nodeKinds])
+  ];
+  addRequiredColumn(requiredColumnsByAlias, traversal.nodeAlias, "id");
+  if (previousNodeKinds.length > 1) {
+    addRequiredColumn(requiredColumnsByAlias, traversal.nodeAlias, "kind");
   }
-  for (const field2 of ast.groupBy.fields) {
-    const key = fieldRefKey(field2);
-    if (!seenKeys.has(key)) {
-      seenKeys.add(key);
-      allFields.push(field2);
-    }
+  for (const field2 of selectiveFields) {
+    markSelectiveFieldAsRequired(requiredColumnsByAlias, field2);
   }
-  if (allFields.length === 0) {
-    return void 0;
+  if (ast.orderBy) {
+    for (const orderSpec of ast.orderBy) {
+      markFieldRefAsRequired(requiredColumnsByAlias, orderSpec.field);
+    }
   }
-  const parts = allFields.map(
-    (field2) => compileFieldValue(field2, dialect, field2.valueType, `cte_${field2.alias}`)
+  return requiredColumnsByAlias;
+}
+function compileNodeSelectColumnsFromTable(tableAlias, alias, requiredColumns, alwaysRequiredColumns) {
+  return NODE_COLUMNS.filter(
+    (column) => shouldProjectColumn(requiredColumns, column, alwaysRequiredColumns)
+  ).map(
+    (column) => sql`${sql.raw(tableAlias)}.${sql.raw(column)} AS ${sql.raw(`${alias}_${column}`)}`
   );
-  return sql`GROUP BY ${sql.join(parts, sql`, `)}`;
 }
-function buildStandardHaving(input) {
-  const { ast, ctx } = input;
-  if (!ast.having) {
-    return void 0;
-  }
-  const condition = compilePredicateExpression(ast.having, ctx);
-  return sql`HAVING ${condition}`;
+function compileNodeSelectColumnsFromRecursiveRow(alias, requiredColumns, alwaysRequiredColumns) {
+  return NODE_COLUMNS.filter(
+    (column) => shouldProjectColumn(requiredColumns, column, alwaysRequiredColumns)
+  ).map((column) => {
+    const projected = `${alias}_${column}`;
+    return sql`r.${sql.raw(projected)} AS ${sql.raw(projected)}`;
+  });
 }
-function buildStandardEmbeddingsCte(input) {
-  const { ctx, graphId, vectorPredicate } = input;
-  const { dialect } = ctx;
-  const { field: field2, metric, minScore, queryEmbedding } = vectorPredicate;
-  const fieldPath = field2.jsonPointer ? field2.jsonPointer : field2.path.length > 1 && field2.path[0] === "props" ? `/${field2.path.slice(1).join("/")}` : `/${field2.path.join("/")}`;
-  const distanceExpr = dialect.vectorDistance(
-    sql.raw("embedding"),
-    queryEmbedding,
-    metric
-  );
-  const conditions = [
-    sql`graph_id = ${graphId}`,
-    sql`field_path = ${fieldPath}`
-  ];
-  if (minScore !== void 0) {
-    conditions.push(
-      compileVectorMinScoreCondition(distanceExpr, metric, minScore)
+function compileRecursiveProjection(ast, traversal, dialect) {
+  if (ast.selectiveFields && ast.selectiveFields.length > 0) {
+    return compileRecursiveSelectiveProjection(
+      ast.selectiveFields,
+      ast,
+      traversal,
+      dialect
     );
   }
-  const scoreExpr = compileVectorScoreExpression(distanceExpr, metric);
-  return sql`
-    cte_embeddings AS (
-      SELECT
-        node_id,
-        ${distanceExpr} AS distance,
-        ${scoreExpr} AS score
-      FROM ${ctx.schema.embeddingsTable}
-      WHERE ${sql.join(conditions, sql` AND `)}
-      ORDER BY ${distanceExpr} ASC
-    )
-  `;
-}
-function compileVectorScoreExpression(distanceExpr, metric) {
-  switch (metric) {
-    case "cosine": {
-      return sql`(1.0 - ${distanceExpr})`;
-    }
-    case "l2":
-    case "inner_product": {
-      return distanceExpr;
-    }
+  const startAlias = ast.start.alias;
+  const nodeAlias = traversal.nodeAlias;
+  const vl = traversal.variableLength;
+  const fields = [
+    // Start alias fields with metadata
+    sql`${sql.raw(startAlias)}_id`,
+    sql`${sql.raw(startAlias)}_kind`,
+    sql`${sql.raw(startAlias)}_props`,
+    sql`${sql.raw(startAlias)}_version`,
+    sql`${sql.raw(startAlias)}_valid_from`,
+    sql`${sql.raw(startAlias)}_valid_to`,
+    sql`${sql.raw(startAlias)}_created_at`,
+    sql`${sql.raw(startAlias)}_updated_at`,
+    sql`${sql.raw(startAlias)}_deleted_at`,
+    // Node alias fields with metadata
+    sql`${sql.raw(nodeAlias)}_id`,
+    sql`${sql.raw(nodeAlias)}_kind`,
+    sql`${sql.raw(nodeAlias)}_props`,
+    sql`${sql.raw(nodeAlias)}_version`,
+    sql`${sql.raw(nodeAlias)}_valid_from`,
+    sql`${sql.raw(nodeAlias)}_valid_to`,
+    sql`${sql.raw(nodeAlias)}_created_at`,
+    sql`${sql.raw(nodeAlias)}_updated_at`,
+    sql`${sql.raw(nodeAlias)}_deleted_at`
+  ];
+  if (vl.depthAlias !== void 0) {
+    fields.push(sql`depth AS ${quoteIdentifier(vl.depthAlias)}`);
+  }
+  if (vl.pathAlias !== void 0) {
+    fields.push(sql`path AS ${quoteIdentifier(vl.pathAlias)}`);
   }
+  return sql.join(fields, sql`, `);
 }
-function compileVectorMinScoreCondition(distanceExpr, metric, minScore) {
-  switch (metric) {
-    case "cosine": {
-      const threshold = 1 - minScore;
-      return sql`${distanceExpr} <= ${threshold}`;
-    }
-    case "l2": {
-      return sql`${distanceExpr} <= ${minScore}`;
+function compileRecursiveSelectiveProjection(fields, ast, traversal, dialect) {
+  const allowedAliases = /* @__PURE__ */ new Set([ast.start.alias, traversal.nodeAlias]);
+  const columns = fields.map((field2) => {
+    if (!allowedAliases.has(field2.alias)) {
+      throw new UnsupportedPredicateError(
+        `Selective projection for recursive traversals does not support alias "${field2.alias}"`
+      );
     }
-    case "inner_product": {
-      const negativeThreshold = -minScore;
-      return sql`${distanceExpr} <= ${negativeThreshold}`;
+    if (field2.isSystemField) {
+      const dbColumn = mapSelectiveSystemFieldToColumn(field2.field);
+      return sql`${sql.raw(`${field2.alias}_${dbColumn}`)} AS ${quoteIdentifier(field2.outputName)}`;
     }
+    const column = sql.raw(`${field2.alias}_props`);
+    const extracted = compileTypedJsonExtract({
+      column,
+      dialect,
+      pointer: jsonPointer([field2.field]),
+      valueType: field2.valueType
+    });
+    return sql`${extracted} AS ${quoteIdentifier(field2.outputName)}`;
+  });
+  const vl = traversal.variableLength;
+  if (vl.depthAlias !== void 0) {
+    columns.push(sql`depth AS ${quoteIdentifier(vl.depthAlias)}`);
   }
-}
-function buildStandardVectorOrderBy(input) {
-  const { ast, dialect } = input;
-  const distanceOrder = sql`cte_embeddings.distance ASC`;
-  const additionalOrders = [];
-  if (ast.orderBy && ast.orderBy.length > 0) {
-    for (const orderSpec of ast.orderBy) {
-      const valueType = orderSpec.field.valueType;
-      if (valueType === "array" || valueType === "object") {
-        throw new UnsupportedPredicateError(
-          "Ordering by JSON arrays or objects is not supported"
-        );
-      }
-      const cteAlias = `cte_${orderSpec.field.alias}`;
-      const field2 = compileFieldValue(
-        orderSpec.field,
-        dialect,
-        valueType,
-        cteAlias
-      );
-      const direction = sql.raw(orderSpec.direction.toUpperCase());
-      const nulls = orderSpec.nulls ?? (orderSpec.direction === "asc" ? "last" : "first");
-      const nullsDirection = sql.raw(nulls === "first" ? "DESC" : "ASC");
-      additionalOrders.push(
-        sql`(${field2} IS NULL) ${nullsDirection}`,
-        sql`${field2} ${direction}`
-      );
-    }
+  if (vl.pathAlias !== void 0) {
+    columns.push(sql`path AS ${quoteIdentifier(vl.pathAlias)}`);
   }
-  const allOrders = [distanceOrder, ...additionalOrders];
-  return sql`ORDER BY ${sql.join(allOrders, sql`, `)}`;
+  return sql.join(columns, sql`, `);
 }
-function buildLimitOffsetClause(input) {
-  const { limit, offset } = input;
-  const parts = [];
-  if (limit !== void 0) {
-    parts.push(sql`LIMIT ${limit}`);
-  }
-  if (offset !== void 0) {
-    parts.push(sql`OFFSET ${offset}`);
+function compileRecursiveOrderBy(ast, dialect) {
+  if (!ast.orderBy || ast.orderBy.length === 0) {
+    return void 0;
   }
-  return parts.length > 0 ? sql.join(parts, sql` `) : void 0;
-}
-
-// src/query/compiler/recursive.ts
-var MAX_RECURSIVE_DEPTH = 100;
-var MAX_EXPLICIT_RECURSIVE_DEPTH = 1e3;
-var NO_ALWAYS_REQUIRED_COLUMNS = /* @__PURE__ */ new Set();
-function runRecursiveQueryPassPipeline(ast, graphId, ctx) {
-  let state = {
-    ast,
-    ctx,
-    graphId,
-    logicalPlan: void 0,
-    requiredColumnsByAlias: void 0,
-    temporalFilterPass: void 0,
-    traversal: void 0
-  };
-  const recursiveTraversalPass = runCompilerPass(state, {
-    name: "recursive_traversal",
-    execute(currentState) {
-      return runRecursiveTraversalSelectionPass(currentState.ast);
-    },
-    update(currentState, traversal) {
-      return {
-        ...currentState,
-        traversal
-      };
-    }
-  });
-  state = recursiveTraversalPass.state;
-  const temporalPass = runCompilerPass(state, {
-    name: "temporal_filters",
-    execute(currentState) {
-      return createTemporalFilterPass(
-        currentState.ast,
-        currentState.ctx.dialect.currentTimestamp()
+  const parts = [];
+  for (const orderSpec of ast.orderBy) {
+    const valueType = orderSpec.field.valueType;
+    if (valueType === "array" || valueType === "object") {
+      throw new UnsupportedPredicateError(
+        "Ordering by JSON arrays or objects is not supported"
       );
-    },
-    update(currentState, temporalFilterPass) {
-      return {
-        ...currentState,
-        temporalFilterPass
-      };
     }
-  });
-  state = temporalPass.state;
-  const columnPruningPass = runCompilerPass(state, {
-    name: "column_pruning",
-    execute(currentState) {
-      const traversal = currentState.traversal;
-      if (traversal === void 0) {
-        throw new CompilerInvariantError(
-          "Recursive traversal pass did not select traversal"
-        );
-      }
-      return collectRequiredColumnsByAlias(currentState.ast, traversal);
-    },
-    update(currentState, requiredColumnsByAlias) {
-      return {
-        ...currentState,
-        requiredColumnsByAlias
-      };
-    }
-  });
-  state = columnPruningPass.state;
-  const logicalPlanPass = runCompilerPass(state, {
-    name: "logical_plan",
-    execute(currentState) {
-      const loweringInput = {
-        ast: currentState.ast,
-        dialect: currentState.ctx.dialect.name,
-        graphId: currentState.graphId,
-        ...currentState.traversal === void 0 ? {} : { traversal: currentState.traversal }
-      };
-      return lowerRecursiveQueryToLogicalPlan(loweringInput);
-    },
-    update(currentState, logicalPlan) {
-      return {
-        ...currentState,
-        logicalPlan
-      };
-    }
-  });
-  state = logicalPlanPass.state;
-  return state;
-}
-function compileVariableLengthQuery(ast, graphId, ctx) {
-  const strategy = ctx.dialect.capabilities.recursiveQueryStrategy;
-  const handler = RECURSIVE_QUERY_STRATEGY_HANDLERS[strategy];
-  return handler(ast, graphId, ctx);
-}
-var RECURSIVE_QUERY_STRATEGY_HANDLERS = {
-  recursive_cte: compileVariableLengthQueryWithRecursiveCteStrategy
-};
-function compileVariableLengthQueryWithRecursiveCteStrategy(ast, graphId, ctx) {
-  const passState = runRecursiveQueryPassPipeline(ast, graphId, ctx);
-  const { dialect } = ctx;
-  const {
-    logicalPlan,
-    requiredColumnsByAlias,
-    temporalFilterPass,
-    traversal: vlTraversal
-  } = passState;
-  if (temporalFilterPass === void 0) {
-    throw new CompilerInvariantError(
-      "Temporal filter pass did not initialize temporal state"
+    const field2 = compileFieldValue(orderSpec.field, dialect, valueType);
+    const direction = sql.raw(orderSpec.direction.toUpperCase());
+    const nulls = orderSpec.nulls ?? (orderSpec.direction === "asc" ? "last" : "first");
+    const nullsDirection = sql.raw(nulls === "first" ? "DESC" : "ASC");
+    parts.push(
+      sql`(${field2} IS NULL) ${nullsDirection}`,
+      sql`${field2} ${direction}`
     );
   }
-  if (logicalPlan === void 0) {
-    throw new CompilerInvariantError(
-      "Logical plan pass did not initialize plan state"
-    );
+  return sql`ORDER BY ${sql.join(parts, sql`, `)}`;
+}
+function compileLimitOffset(ast) {
+  const parts = [];
+  if (ast.limit !== void 0) {
+    parts.push(sql`LIMIT ${ast.limit}`);
   }
-  if (vlTraversal === void 0) {
-    throw new CompilerInvariantError(
-      "Recursive traversal pass did not select traversal"
-    );
+  if (ast.offset !== void 0) {
+    parts.push(sql`OFFSET ${ast.offset}`);
   }
-  const recursiveCte = compileRecursiveCte(
-    ast,
-    vlTraversal,
-    graphId,
-    ctx,
-    requiredColumnsByAlias,
-    temporalFilterPass
-  );
-  const projection = compileRecursiveProjection(ast, vlTraversal, dialect);
-  const minDepth = vlTraversal.variableLength.minDepth;
-  const depthFilter = minDepth > 0 ? sql`WHERE depth >= ${minDepth}` : sql.raw("");
-  const orderBy = compileRecursiveOrderBy(ast, dialect);
-  const limitOffset = compileLimitOffset(ast);
-  return emitRecursiveQuerySql({
-    depthFilter,
-    ...limitOffset === void 0 ? {} : { limitOffset },
-    logicalPlan,
-    ...orderBy === void 0 ? {} : { orderBy },
-    projection,
-    recursiveCte
-  });
-}
-function hasVariableLengthTraversal(ast) {
-  return ast.traversals.some((t) => t.variableLength !== void 0);
+  return parts.length > 0 ? sql.join(parts, sql` `) : void 0;
 }
-function compileRecursiveCte(ast, traversal, graphId, ctx, requiredColumnsByAlias, temporalFilterPass) {
-  const { dialect } = ctx;
-  const startAlias = ast.start.alias;
-  const startKinds = ast.start.kinds;
-  const nodeAlias = traversal.nodeAlias;
-  const directEdgeKinds = [...new Set(traversal.edgeKinds)];
-  const inverseEdgeKinds = traversal.inverseEdgeKinds === void 0 ? [] : [...new Set(traversal.inverseEdgeKinds)];
-  const forceWorktableOuterJoinOrder = dialect.capabilities.forceRecursiveWorktableOuterJoinOrder;
-  const nodeKinds = traversal.nodeKinds;
-  const previousNodeKinds = [.../* @__PURE__ */ new Set([...startKinds, ...nodeKinds])];
-  const direction = traversal.direction;
-  const vl = traversal.variableLength;
-  const shouldEnforceCycleCheck = vl.cyclePolicy !== "allow";
-  const shouldTrackPath = shouldEnforceCycleCheck || vl.pathAlias !== void 0;
-  const recursiveJoinRequiredColumns = /* @__PURE__ */ new Set(["id"]);
-  if (previousNodeKinds.length > 1) {
-    recursiveJoinRequiredColumns.add("kind");
+var DEFAULT_TABLE_NAMES = {
+  nodes: "typegraph_nodes",
+  edges: "typegraph_edges",
+  embeddings: "typegraph_node_embeddings"
+};
+var MAX_IDENTIFIER_LENGTH = 63;
+var VALID_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_$]*$/i;
+function validateTableName(name, label) {
+  if (!name || name.length === 0) {
+    throw new ConfigurationError(`${label} table name cannot be empty`);
   }
-  const requiredStartColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(startAlias) ?? EMPTY_REQUIRED_COLUMNS : void 0;
-  const requiredNodeColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(nodeAlias) ?? EMPTY_REQUIRED_COLUMNS : void 0;
-  const startColumnsFromBase = compileNodeSelectColumnsFromTable(
-    "n0",
-    startAlias,
-    requiredStartColumns,
-    NO_ALWAYS_REQUIRED_COLUMNS
-  );
-  const startColumnsFromRecursive = compileNodeSelectColumnsFromRecursiveRow(
-    startAlias,
-    requiredStartColumns,
-    NO_ALWAYS_REQUIRED_COLUMNS
-  );
-  const nodeColumnsFromBase = compileNodeSelectColumnsFromTable(
-    "n0",
-    nodeAlias,
-    requiredNodeColumns,
-    recursiveJoinRequiredColumns
-  );
-  const nodeColumnsFromRecursive = compileNodeSelectColumnsFromTable(
-    "n",
-    nodeAlias,
-    requiredNodeColumns,
-    recursiveJoinRequiredColumns
-  );
-  const startKindFilter = compileKindFilter2(startKinds, "n0.kind");
-  const nodeKindFilter = compileKindFilter2(nodeKinds, "n.kind");
-  const startTemporalFilter = temporalFilterPass.forAlias("n0");
-  const edgeTemporalFilter = temporalFilterPass.forAlias("e");
-  const nodeTemporalFilter = temporalFilterPass.forAlias("n");
-  const startContext = { ...ctx, cteColumnPrefix: "" };
-  const startPredicates = compileNodePredicates(ast, startAlias, startContext);
-  const edgeContext = { ...ctx, cteColumnPrefix: "e" };
-  const edgePredicates = compileEdgePredicates(
-    ast,
-    traversal.edgeAlias,
-    edgeContext
-  );
-  const targetContext = { ...ctx, cteColumnPrefix: "n" };
-  const targetNodePredicates = compileNodePredicates(
-    ast,
-    nodeAlias,
-    targetContext
-  );
-  if (vl.maxDepth > MAX_EXPLICIT_RECURSIVE_DEPTH) {
-    throw new UnsupportedPredicateError(
-      `Recursive traversal maxHops(${vl.maxDepth}) exceeds maximum explicit depth of ${MAX_EXPLICIT_RECURSIVE_DEPTH}`
+  if (name.length > MAX_IDENTIFIER_LENGTH) {
+    throw new ConfigurationError(
+      `${label} table name exceeds maximum length of ${MAX_IDENTIFIER_LENGTH} characters`
     );
   }
-  const effectiveMaxDepth = vl.maxDepth > 0 ? vl.maxDepth : MAX_RECURSIVE_DEPTH;
-  const maxDepthCondition = sql`r.depth < ${effectiveMaxDepth}`;
-  const cycleCheck = shouldEnforceCycleCheck ? dialect.cycleCheck(sql.raw("n.id"), sql.raw("r.path")) : void 0;
-  const initialPath = shouldTrackPath ? dialect.initializePath(sql.raw("n0.id")) : void 0;
-  const pathExtension = shouldTrackPath ? dialect.extendPath(sql.raw("r.path"), sql.raw("n.id")) : void 0;
-  const baseWhereClauses = [
-    sql`n0.graph_id = ${graphId}`,
-    startKindFilter,
-    startTemporalFilter,
-    ...startPredicates
-  ];
-  const recursiveBaseWhereClauses = [
-    sql`e.graph_id = ${graphId}`,
-    nodeKindFilter,
-    edgeTemporalFilter,
-    nodeTemporalFilter,
-    maxDepthCondition
-  ];
-  if (cycleCheck !== void 0) {
-    recursiveBaseWhereClauses.push(cycleCheck);
+  if (!VALID_IDENTIFIER_PATTERN.test(name)) {
+    throw new ConfigurationError(
+      `${label} table name "${name}" is not a valid SQL identifier. Table names must start with a letter or underscore and contain only letters, digits, underscores, or dollar signs.`
+    );
   }
-  recursiveBaseWhereClauses.push(...edgePredicates, ...targetNodePredicates);
-  function compileRecursiveBranch2(branch) {
-    const recursiveFilterClauses = [
-      ...recursiveBaseWhereClauses,
-      compileKindFilter2(branch.edgeKinds, "e.kind"),
-      compileKindFilter2(previousNodeKinds, `e.${branch.joinKindField}`),
-      compileKindFilter2(nodeKinds, `e.${branch.targetKindField}`)
-    ];
-    if (branch.duplicateGuard !== void 0) {
-      recursiveFilterClauses.push(branch.duplicateGuard);
+}
+function quoteIdentifier2(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+function createSqlSchema(names = {}) {
+  const tables = { ...DEFAULT_TABLE_NAMES, ...names };
+  validateTableName(tables.nodes, "nodes");
+  validateTableName(tables.edges, "edges");
+  validateTableName(tables.embeddings, "embeddings");
+  return {
+    tables,
+    nodesTable: sql.raw(quoteIdentifier2(tables.nodes)),
+    edgesTable: sql.raw(quoteIdentifier2(tables.edges)),
+    embeddingsTable: sql.raw(quoteIdentifier2(tables.embeddings))
+  };
+}
+var DEFAULT_SQL_SCHEMA = createSqlSchema();
+
+// src/query/execution/value-decoder.ts
+function nullToUndefined(value) {
+  return value === null ? void 0 : value;
+}
+function decodeSelectedValue(value, typeInfo) {
+  const normalized = nullToUndefined(value);
+  if (normalized === void 0) return void 0;
+  if (typeInfo === void 0) {
+    return normalized;
+  }
+  return decodeByValueType(normalized, typeInfo.valueType);
+}
+function decodeByValueType(value, valueType) {
+  switch (valueType) {
+    case "boolean": {
+      if (typeof value === "boolean") return value;
+      if (typeof value === "number") return value !== 0;
+      if (typeof value === "string") {
+        if (value === "0") return false;
+        if (value === "1") return true;
+        if (value.toLowerCase() === "true") return true;
+        if (value.toLowerCase() === "false") return false;
+      }
+      return Boolean(value);
     }
-    const recursiveSelectColumns = [
-      ...startColumnsFromRecursive,
-      ...nodeColumnsFromRecursive,
-      sql`r.depth + 1 AS depth`
-    ];
-    if (pathExtension !== void 0) {
-      recursiveSelectColumns.push(sql`${pathExtension} AS path`);
+    case "number": {
+      if (typeof value === "number") return value;
+      if (typeof value === "string") {
+        const parsed = Number(value);
+        return Number.isNaN(parsed) ? value : parsed;
+      }
+      return value;
     }
-    const recursiveJoinClauses = [
-      sql`e.${sql.raw(branch.joinField)} = r.${sql.raw(nodeAlias)}_id`
-    ];
-    if (previousNodeKinds.length > 1) {
-      recursiveJoinClauses.push(
-        sql`e.${sql.raw(branch.joinKindField)} = r.${sql.raw(nodeAlias)}_kind`
-      );
+    case "array":
+    case "object":
+    case "embedding": {
+      if (typeof value !== "string") return value;
+      const trimmed = value.trim();
+      const looksJson = trimmed.startsWith("[") || trimmed.startsWith("{");
+      if (!looksJson) return value;
+      try {
+        return JSON.parse(trimmed);
+      } catch {
+        return value;
+      }
     }
-    if (forceWorktableOuterJoinOrder) {
-      const recursiveWhereClauses = [
-        ...recursiveJoinClauses,
-        ...recursiveFilterClauses
-      ];
-      return sql`
-        SELECT ${sql.join(recursiveSelectColumns, sql`, `)}
-        FROM recursive_cte r
-        CROSS JOIN ${ctx.schema.edgesTable} e
-        JOIN ${ctx.schema.nodesTable} n ON n.graph_id = e.graph_id
-          AND n.id = e.${sql.raw(branch.targetField)}
-          AND n.kind = e.${sql.raw(branch.targetKindField)}
-        WHERE ${sql.join(recursiveWhereClauses, sql` AND `)}
-      `;
+    case "string":
+    case "date":
+    case "unknown": {
+      return value;
+    }
+    default: {
+      return value;
     }
-    return sql`
-      SELECT ${sql.join(recursiveSelectColumns, sql`, `)}
-      FROM recursive_cte r
-      JOIN ${ctx.schema.edgesTable} e ON ${sql.join(recursiveJoinClauses, sql` AND `)}
-      JOIN ${ctx.schema.nodesTable} n ON n.graph_id = e.graph_id
-        AND n.id = e.${sql.raw(branch.targetField)}
-        AND n.kind = e.${sql.raw(branch.targetKindField)}
-      WHERE ${sql.join(recursiveFilterClauses, sql` AND `)}
-    `;
   }
-  const directJoinField = direction === "out" ? "from_id" : "to_id";
-  const directTargetField = direction === "out" ? "to_id" : "from_id";
-  const directJoinKindField = direction === "out" ? "from_kind" : "to_kind";
-  const directTargetKindField = direction === "out" ? "to_kind" : "from_kind";
-  const directBranch = compileRecursiveBranch2({
-    joinField: directJoinField,
-    targetField: directTargetField,
-    joinKindField: directJoinKindField,
-    targetKindField: directTargetKindField,
-    edgeKinds: directEdgeKinds
-  });
-  function compileInverseRecursiveBranch() {
-    const inverseJoinField = direction === "out" ? "to_id" : "from_id";
-    const inverseTargetField = direction === "out" ? "from_id" : "to_id";
-    const inverseJoinKindField = direction === "out" ? "to_kind" : "from_kind";
-    const inverseTargetKindField = direction === "out" ? "from_kind" : "to_kind";
-    const overlappingKinds = inverseEdgeKinds.filter(
-      (kind) => directEdgeKinds.includes(kind)
+}
+
+// src/store/reserved-keys.ts
+var RESERVED_NODE_KEYS2 = /* @__PURE__ */ new Set([
+  "id",
+  "kind",
+  "meta"
+]);
+var RESERVED_EDGE_KEYS2 = /* @__PURE__ */ new Set([
+  "id",
+  "kind",
+  "meta",
+  "fromKind",
+  "fromId",
+  "toKind",
+  "toId"
+]);
+var PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+function validateProjectionField(field2, entityType, kind) {
+  const reserved = entityType === "node" ? RESERVED_NODE_KEYS2 : RESERVED_EDGE_KEYS2;
+  if (reserved.has(field2)) {
+    throw new ConfigurationError(
+      `Projection field "${field2}" on ${entityType} kind "${kind}" conflicts with a reserved structural key`,
+      { field: field2, kind, entityType, reservedKeys: [...reserved] },
+      {
+        suggestion: `Remove "${field2}" from the projection. Structural fields (${[...reserved].join(", ")}) are included automatically when relevant.`
+      }
     );
-    const duplicateGuard = overlappingKinds.length > 0 ? sql`NOT (e.from_id = e.to_id AND ${compileKindFilter2(overlappingKinds, "e.kind")})` : void 0;
-    const inverseBranch = compileRecursiveBranch2({
-      joinField: inverseJoinField,
-      targetField: inverseTargetField,
-      joinKindField: inverseJoinKindField,
-      targetKindField: inverseTargetKindField,
-      edgeKinds: inverseEdgeKinds,
-      duplicateGuard
-    });
-    return sql`
-      ${directBranch}
-      UNION ALL
-      ${inverseBranch}
-    `;
   }
-  const recursiveBranchSql = inverseEdgeKinds.length === 0 ? directBranch : compileInverseRecursiveBranch();
-  const baseSelectColumns = [
-    ...startColumnsFromBase,
-    ...nodeColumnsFromBase,
-    sql`0 AS depth`
-  ];
-  if (initialPath !== void 0) {
-    baseSelectColumns.push(sql`${initialPath} AS path`);
+  if (PROTOTYPE_POLLUTION_KEYS.has(field2)) {
+    throw new ConfigurationError(
+      `Projection field "${field2}" on ${entityType} kind "${kind}" is not allowed`,
+      { field: field2, kind, entityType },
+      {
+        suggestion: `"${field2}" cannot be used as a projection field name.`
+      }
+    );
   }
-  return sql`
-    recursive_cte AS (
-      -- Base case: starting nodes
-      SELECT ${sql.join(baseSelectColumns, sql`, `)}
-      FROM ${ctx.schema.nodesTable} n0
-      WHERE ${sql.join(baseWhereClauses, sql` AND `)}
-
-      UNION ALL
+}
+function filterReservedKeys(props, reservedKeys) {
+  const filtered = {};
+  for (const [key, value] of Object.entries(props)) {
+    if (!reservedKeys.has(key)) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
 
-      -- Recursive case: follow edges
-      ${recursiveBranchSql}
-    )
-  `;
+// src/store/row-mappers.ts
+function nullToUndefined2(value) {
+  return value === null ? void 0 : value;
 }
-function compileKindFilter2(kinds, columnExpr) {
-  return compileKindFilter(sql.raw(columnExpr), kinds);
+function rowToNode(row) {
+  const rawProps = JSON.parse(row.props);
+  const props = filterReservedKeys(rawProps, RESERVED_NODE_KEYS2);
+  return {
+    kind: row.kind,
+    id: row.id,
+    meta: rowToNodeMeta(row),
+    ...props
+  };
 }
-function compileNodePredicates(ast, alias, ctx) {
-  return ast.predicates.filter((p) => p.targetAlias === alias && p.targetType !== "edge").map((p) => compilePredicateExpression(p.expression, ctx));
+function rowToNodeMeta(row) {
+  return {
+    version: row.version,
+    validFrom: nullToUndefined2(row.valid_from),
+    validTo: nullToUndefined2(row.valid_to),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    deletedAt: nullToUndefined2(row.deleted_at)
+  };
 }
-function compileEdgePredicates(ast, edgeAlias, ctx) {
-  return ast.predicates.filter((p) => p.targetAlias === edgeAlias && p.targetType === "edge").map((p) => compilePredicateExpression(p.expression, ctx));
+function rowToEdge(row) {
+  const rawProps = JSON.parse(row.props);
+  const props = filterReservedKeys(rawProps, RESERVED_EDGE_KEYS2);
+  return {
+    id: row.id,
+    kind: row.kind,
+    fromKind: row.from_kind,
+    fromId: row.from_id,
+    toKind: row.to_kind,
+    toId: row.to_id,
+    meta: rowToEdgeMeta(row),
+    ...props
+  };
 }
-function collectRequiredColumnsByAlias(ast, traversal) {
-  const selectiveFields = ast.selectiveFields;
-  if (selectiveFields === void 0 || selectiveFields.length === 0) {
-    return void 0;
-  }
-  const requiredColumnsByAlias = /* @__PURE__ */ new Map();
-  const previousNodeKinds = [
-    .../* @__PURE__ */ new Set([...ast.start.kinds, ...traversal.nodeKinds])
-  ];
-  addRequiredColumn(requiredColumnsByAlias, traversal.nodeAlias, "id");
-  if (previousNodeKinds.length > 1) {
-    addRequiredColumn(requiredColumnsByAlias, traversal.nodeAlias, "kind");
+function rowToEdgeMeta(row) {
+  return {
+    validFrom: nullToUndefined2(row.valid_from),
+    validTo: nullToUndefined2(row.valid_to),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    deletedAt: nullToUndefined2(row.deleted_at)
+  };
+}
+
+// src/store/subgraph.ts
+var DEFAULT_SUBGRAPH_MAX_DEPTH = 10;
+var MAX_PG_IDENTIFIER_LENGTH = 63;
+function fnv1aBase36(input) {
+  let hash = 2166136261;
+  for (const character of input) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint === void 0) continue;
+    hash ^= codePoint;
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+var TEXT_ENCODER = new TextEncoder();
+function truncateToBytes(value, maxBytes) {
+  const encoded = TEXT_ENCODER.encode(value);
+  if (encoded.byteLength <= maxBytes) return value;
+  let end = maxBytes;
+  while (end > 0 && encoded[end] >= 128 && encoded[end] < 192) {
+    end--;
+  }
+  return new TextDecoder().decode(encoded.slice(0, end));
+}
+function projectionAlias(entityPrefix, kind, field2) {
+  const prefix = entityPrefix === "node" ? "sg_n" : "sg_e";
+  const hash = fnv1aBase36(`${kind}\0${field2}`);
+  const fixedBytes = prefix.length + 1 + 1 + hash.length;
+  const maxKindBytes = MAX_PG_IDENTIFIER_LENGTH - fixedBytes;
+  const truncatedKind = truncateToBytes(kind, maxKindBytes);
+  return `${prefix}_${truncatedKind}_${hash}`;
+}
+function normalizeProps(value) {
+  return typeof value === "string" ? value : JSON.stringify(value ?? {});
+}
+function defineSubgraphProject(_graph) {
+  return (project) => project;
+}
+async function executeSubgraph(params) {
+  const { options } = params;
+  if (options.edges.length === 0) {
+    return { nodes: [], edges: [] };
   }
-  for (const field2 of selectiveFields) {
-    markSelectiveFieldAsRequired(requiredColumnsByAlias, field2);
+  const maxDepth = Math.min(
+    options.maxDepth ?? DEFAULT_SUBGRAPH_MAX_DEPTH,
+    MAX_RECURSIVE_DEPTH
+  );
+  const ctx = {
+    graphId: params.graphId,
+    rootId: params.rootId,
+    edgeKinds: options.edges,
+    maxDepth,
+    includeKinds: options.includeKinds,
+    excludeRoot: options.excludeRoot ?? false,
+    direction: options.direction ?? "out",
+    cyclePolicy: options.cyclePolicy ?? "prevent",
+    dialect: params.dialect,
+    schema: params.schema ?? DEFAULT_SQL_SCHEMA,
+    backend: params.backend
+  };
+  const schemaIntrospector = getSubgraphSchemaIntrospector(params.graph);
+  const nodeProjectionPlan = buildProjectionPlan(
+    getIncludedNodeKinds(params.graph, options.includeKinds),
+    options.project?.nodes,
+    (kind, field2) => schemaIntrospector.getFieldTypeInfo(kind, field2),
+    "node"
+  );
+  const edgeProjectionPlan = buildProjectionPlan(
+    dedupeStrings(options.edges),
+    options.project?.edges,
+    (kind, field2) => schemaIntrospector.getEdgeFieldTypeInfo(kind, field2),
+    "edge"
+  );
+  const reachableCte = buildReachableCte(ctx);
+  const includedIdsCte = buildIncludedIdsCte(ctx);
+  const [nodeRows, edgeRows] = await Promise.all([
+    fetchSubgraphNodes(ctx, reachableCte, includedIdsCte, nodeProjectionPlan),
+    fetchSubgraphEdges(ctx, reachableCte, includedIdsCte, edgeProjectionPlan)
+  ]);
+  const nodes = nodeRows.map(
+    (row) => mapSubgraphNodeRow(row, nodeProjectionPlan)
+  );
+  const edges = edgeRows.map(
+    (row) => mapSubgraphEdgeRow(row, edgeProjectionPlan)
+  );
+  return {
+    nodes,
+    edges
+  };
+}
+var introspectorCache = /* @__PURE__ */ new WeakMap();
+function getSubgraphSchemaIntrospector(graph) {
+  const cached = introspectorCache.get(graph);
+  if (cached !== void 0) return cached;
+  const nodeKinds = new Map(
+    Object.entries(graph.nodes).map(([kind, definition]) => [
+      kind,
+      { schema: definition.type.schema }
+    ])
+  );
+  const edgeKinds = new Map(
+    Object.entries(graph.edges).map(([kind, definition]) => [
+      kind,
+      { schema: definition.type.schema }
+    ])
+  );
+  const introspector = createSchemaIntrospector(nodeKinds, edgeKinds);
+  introspectorCache.set(graph, introspector);
+  return introspector;
+}
+function buildProjectionPlan(kinds, projectionMap, resolveFieldType, entityPrefix) {
+  const projectedKinds = /* @__PURE__ */ new Map();
+  const fullKinds = [];
+  for (const kind of kinds) {
+    const selection = projectionMap?.[kind];
+    if (selection === void 0) {
+      fullKinds.push(kind);
+      continue;
+    }
+    projectedKinds.set(
+      kind,
+      buildKindProjectionPlan(kind, selection, resolveFieldType, entityPrefix)
+    );
   }
-  if (ast.orderBy) {
-    for (const orderSpec of ast.orderBy) {
-      markFieldRefAsRequired(requiredColumnsByAlias, orderSpec.field);
+  return { fullKinds, projectedKinds };
+}
+function buildKindProjectionPlan(kind, selection, resolveFieldType, entityPrefix) {
+  const propertyFields = /* @__PURE__ */ new Map();
+  let includeMeta = false;
+  for (const field2 of selection) {
+    if (field2 === "meta") {
+      includeMeta = true;
+      continue;
+    }
+    validateProjectionField(field2, entityPrefix, kind);
+    if (!propertyFields.has(field2)) {
+      propertyFields.set(field2, {
+        field: field2,
+        outputName: projectionAlias(entityPrefix, kind, field2),
+        typeInfo: resolveFieldType(kind, field2)
+      });
     }
   }
-  return requiredColumnsByAlias;
+  return {
+    includeMeta,
+    propertyFields: [...propertyFields.values()]
+  };
 }
-function compileNodeSelectColumnsFromTable(tableAlias, alias, requiredColumns, alwaysRequiredColumns) {
-  return NODE_COLUMNS.filter(
-    (column) => shouldProjectColumn(requiredColumns, column, alwaysRequiredColumns)
-  ).map(
-    (column) => sql`${sql.raw(tableAlias)}.${sql.raw(column)} AS ${sql.raw(`${alias}_${column}`)}`
-  );
+function getIncludedNodeKinds(graph, includeKinds) {
+  if (includeKinds === void 0 || includeKinds.length === 0) {
+    return Object.keys(graph.nodes);
+  }
+  return dedupeStrings(includeKinds);
 }
-function compileNodeSelectColumnsFromRecursiveRow(alias, requiredColumns, alwaysRequiredColumns) {
-  return NODE_COLUMNS.filter(
-    (column) => shouldProjectColumn(requiredColumns, column, alwaysRequiredColumns)
-  ).map((column) => {
-    const projected = `${alias}_${column}`;
-    return sql`r.${sql.raw(projected)} AS ${sql.raw(projected)}`;
-  });
+function dedupeStrings(values) {
+  return [...new Set(values)];
 }
-function compileRecursiveProjection(ast, traversal, dialect) {
-  if (ast.selectiveFields && ast.selectiveFields.length > 0) {
-    return compileRecursiveSelectiveProjection(
-      ast.selectiveFields,
-      ast,
-      traversal,
-      dialect
-    );
+function buildReachableCte(ctx) {
+  const shouldTrackPath = ctx.cyclePolicy === "prevent";
+  const edgeKindFilter = compileKindFilter(sql.raw("e.kind"), ctx.edgeKinds);
+  const initialPath = shouldTrackPath ? ctx.dialect.initializePath(sql.raw("n.id")) : void 0;
+  const pathExtension = shouldTrackPath ? ctx.dialect.extendPath(sql.raw("r.path"), sql.raw("n.id")) : void 0;
+  const cycleCheck = shouldTrackPath ? ctx.dialect.cycleCheck(sql.raw("n.id"), sql.raw("r.path")) : void 0;
+  const baseColumns = [sql`n.id`, sql`n.kind`, sql`0 AS depth`];
+  if (initialPath !== void 0) {
+    baseColumns.push(sql`${initialPath} AS path`);
   }
-  const startAlias = ast.start.alias;
-  const nodeAlias = traversal.nodeAlias;
-  const vl = traversal.variableLength;
-  const fields = [
-    // Start alias fields with metadata
-    sql`${sql.raw(startAlias)}_id`,
-    sql`${sql.raw(startAlias)}_kind`,
-    sql`${sql.raw(startAlias)}_props`,
-    sql`${sql.raw(startAlias)}_version`,
-    sql`${sql.raw(startAlias)}_valid_from`,
-    sql`${sql.raw(startAlias)}_valid_to`,
-    sql`${sql.raw(startAlias)}_created_at`,
-    sql`${sql.raw(startAlias)}_updated_at`,
-    sql`${sql.raw(startAlias)}_deleted_at`,
-    // Node alias fields with metadata
-    sql`${sql.raw(nodeAlias)}_id`,
-    sql`${sql.raw(nodeAlias)}_kind`,
-    sql`${sql.raw(nodeAlias)}_props`,
-    sql`${sql.raw(nodeAlias)}_version`,
-    sql`${sql.raw(nodeAlias)}_valid_from`,
-    sql`${sql.raw(nodeAlias)}_valid_to`,
-    sql`${sql.raw(nodeAlias)}_created_at`,
-    sql`${sql.raw(nodeAlias)}_updated_at`,
-    sql`${sql.raw(nodeAlias)}_deleted_at`
+  const baseCase = sql`SELECT ${sql.join(baseColumns, sql`, `)} FROM ${ctx.schema.nodesTable} n WHERE n.graph_id = ${ctx.graphId} AND n.id = ${ctx.rootId} AND n.deleted_at IS NULL`;
+  const recursiveColumns = [
+    sql`n.id`,
+    sql`n.kind`,
+    sql`r.depth + 1 AS depth`
   ];
-  if (vl.depthAlias !== void 0) {
-    fields.push(sql`depth AS ${quoteIdentifier(vl.depthAlias)}`);
+  if (pathExtension !== void 0) {
+    recursiveColumns.push(sql`${pathExtension} AS path`);
+  }
+  const recursiveWhereClauses = [
+    sql`e.graph_id = ${ctx.graphId}`,
+    edgeKindFilter,
+    sql`e.deleted_at IS NULL`,
+    sql`n.deleted_at IS NULL`,
+    sql`r.depth < ${ctx.maxDepth}`
+  ];
+  if (cycleCheck !== void 0) {
+    recursiveWhereClauses.push(cycleCheck);
+  }
+  const forceWorktableOuterJoinOrder = ctx.dialect.capabilities.forceRecursiveWorktableOuterJoinOrder;
+  const recursiveCase = ctx.direction === "both" ? compileBidirectionalBranch({
+    recursiveColumns,
+    whereClauses: recursiveWhereClauses,
+    forceWorktableOuterJoinOrder,
+    schema: ctx.schema
+  }) : compileRecursiveBranch({
+    recursiveColumns,
+    whereClauses: recursiveWhereClauses,
+    joinField: "from_id",
+    targetField: "to_id",
+    targetKindField: "to_kind",
+    forceWorktableOuterJoinOrder,
+    schema: ctx.schema
+  });
+  return sql`WITH RECURSIVE reachable AS (${baseCase} UNION ALL ${recursiveCase})`;
+}
+function compileRecursiveBranch(params) {
+  const columns = [...params.recursiveColumns];
+  const selectClause = sql`SELECT ${sql.join(columns, sql`, `)}`;
+  const nodeJoin = sql`JOIN ${params.schema.nodesTable} n ON n.graph_id = e.graph_id AND n.id = e.${sql.raw(params.targetField)} AND n.kind = e.${sql.raw(params.targetKindField)}`;
+  if (params.forceWorktableOuterJoinOrder) {
+    const allWhere = [
+      ...params.whereClauses,
+      sql`e.${sql.raw(params.joinField)} = r.id`
+    ];
+    return sql`${selectClause} FROM reachable r CROSS JOIN ${params.schema.edgesTable} e ${nodeJoin} WHERE ${sql.join(allWhere, sql` AND `)}`;
+  }
+  const where = [...params.whereClauses];
+  return sql`${selectClause} FROM reachable r JOIN ${params.schema.edgesTable} e ON e.${sql.raw(params.joinField)} = r.id ${nodeJoin} WHERE ${sql.join(where, sql` AND `)}`;
+}
+function compileBidirectionalBranch(params) {
+  const columns = [...params.recursiveColumns];
+  const selectClause = sql`SELECT ${sql.join(columns, sql`, `)}`;
+  const nodeJoin = sql`JOIN ${params.schema.nodesTable} n ON n.graph_id = e.graph_id AND ((e.to_id = r.id AND n.id = e.from_id AND n.kind = e.from_kind) OR (e.from_id = r.id AND n.id = e.to_id AND n.kind = e.to_kind))`;
+  if (params.forceWorktableOuterJoinOrder) {
+    const allWhere = [
+      ...params.whereClauses,
+      sql`(e.from_id = r.id OR e.to_id = r.id)`
+    ];
+    return sql`${selectClause} FROM reachable r CROSS JOIN ${params.schema.edgesTable} e ${nodeJoin} WHERE ${sql.join(allWhere, sql` AND `)}`;
+  }
+  return sql`${selectClause} FROM reachable r JOIN ${params.schema.edgesTable} e ON (e.from_id = r.id OR e.to_id = r.id) ${nodeJoin} WHERE ${sql.join([...params.whereClauses], sql` AND `)}`;
+}
+function buildIncludedIdsCte(ctx) {
+  const filters = [];
+  if (ctx.includeKinds !== void 0 && ctx.includeKinds.length > 0) {
+    filters.push(compileKindFilter(sql.raw("kind"), ctx.includeKinds));
   }
-  if (vl.pathAlias !== void 0) {
-    fields.push(sql`path AS ${quoteIdentifier(vl.pathAlias)}`);
+  if (ctx.excludeRoot) {
+    filters.push(sql`id != ${ctx.rootId}`);
   }
-  return sql.join(fields, sql`, `);
+  const whereClause = filters.length > 0 ? sql` WHERE ${sql.join(filters, sql` AND `)}` : sql``;
+  return sql`, included_ids AS (SELECT DISTINCT id FROM reachable${whereClause})`;
 }
-function compileRecursiveSelectiveProjection(fields, ast, traversal, dialect) {
-  const allowedAliases = /* @__PURE__ */ new Set([ast.start.alias, traversal.nodeAlias]);
-  const columns = fields.map((field2) => {
-    if (!allowedAliases.has(field2.alias)) {
-      throw new UnsupportedPredicateError(
-        `Selective projection for recursive traversals does not support alias "${field2.alias}"`
-      );
-    }
-    if (field2.isSystemField) {
-      const dbColumn = mapSelectiveSystemFieldToColumn(field2.field);
-      return sql`${sql.raw(`${field2.alias}_${dbColumn}`)} AS ${quoteIdentifier(field2.outputName)}`;
-    }
-    const column = sql.raw(`${field2.alias}_props`);
-    const extracted = compileTypedJsonExtract({
-      column,
-      dialect,
-      pointer: jsonPointer([field2.field]),
-      valueType: field2.valueType
-    });
-    return sql`${extracted} AS ${quoteIdentifier(field2.outputName)}`;
-  });
-  const vl = traversal.variableLength;
-  if (vl.depthAlias !== void 0) {
-    columns.push(sql`depth AS ${quoteIdentifier(vl.depthAlias)}`);
+async function fetchSubgraphNodes(ctx, reachableCte, includedIdsCte, projectionPlan) {
+  const columns = [
+    sql`n.kind`,
+    sql`n.id`,
+    buildFullPropsColumn("n", projectionPlan),
+    ...buildMetadataColumns("n", projectionPlan, [
+      "version",
+      "valid_from",
+      "valid_to",
+      "created_at",
+      "updated_at",
+      "deleted_at"
+    ]),
+    ...buildProjectedPropertyColumns("n", projectionPlan, ctx.dialect)
+  ];
+  const query = sql`${reachableCte}${includedIdsCte} SELECT ${sql.join(columns, sql`, `)} FROM ${ctx.schema.nodesTable} n WHERE n.graph_id = ${ctx.graphId} AND n.id IN (SELECT id FROM included_ids)`;
+  return ctx.backend.execute(query);
+}
+async function fetchSubgraphEdges(ctx, reachableCte, includedIdsCte, projectionPlan) {
+  const edgeKindFilter = compileKindFilter(sql.raw("e.kind"), ctx.edgeKinds);
+  const columns = [
+    sql`e.id`,
+    sql`e.kind`,
+    sql`e.from_kind`,
+    sql`e.from_id`,
+    sql`e.to_kind`,
+    sql`e.to_id`,
+    buildFullPropsColumn("e", projectionPlan),
+    ...buildMetadataColumns("e", projectionPlan, [
+      "valid_from",
+      "valid_to",
+      "created_at",
+      "updated_at",
+      "deleted_at"
+    ]),
+    ...buildProjectedPropertyColumns("e", projectionPlan, ctx.dialect)
+  ];
+  const query = sql`${reachableCte}${includedIdsCte} SELECT ${sql.join(columns, sql`, `)} FROM ${ctx.schema.edgesTable} e WHERE e.graph_id = ${ctx.graphId} AND ${edgeKindFilter} AND e.deleted_at IS NULL AND e.from_id IN (SELECT id FROM included_ids) AND e.to_id IN (SELECT id FROM included_ids)`;
+  return ctx.backend.execute(query);
+}
+function buildMetadataColumns(alias, plan, columns) {
+  if (plan.projectedKinds.size === 0) {
+    return columns.map((col) => sql`${sql.raw(`${alias}.${col}`)}`);
   }
-  if (vl.pathAlias !== void 0) {
-    columns.push(sql`path AS ${quoteIdentifier(vl.pathAlias)}`);
+  const metaKinds = [...plan.fullKinds];
+  for (const [kind, kindPlan] of plan.projectedKinds) {
+    if (kindPlan.includeMeta) metaKinds.push(kind);
   }
-  return sql.join(columns, sql`, `);
-}
-function compileRecursiveOrderBy(ast, dialect) {
-  if (!ast.orderBy || ast.orderBy.length === 0) {
-    return void 0;
+  if (metaKinds.length === 0) {
+    return columns.map((col) => sql`NULL AS ${sql.raw(col)}`);
   }
-  const parts = [];
-  for (const orderSpec of ast.orderBy) {
-    const valueType = orderSpec.field.valueType;
-    if (valueType === "array" || valueType === "object") {
-      throw new UnsupportedPredicateError(
-        "Ordering by JSON arrays or objects is not supported"
-      );
-    }
-    const field2 = compileFieldValue(orderSpec.field, dialect, valueType);
-    const direction = sql.raw(orderSpec.direction.toUpperCase());
-    const nulls = orderSpec.nulls ?? (orderSpec.direction === "asc" ? "last" : "first");
-    const nullsDirection = sql.raw(nulls === "first" ? "DESC" : "ASC");
-    parts.push(
-      sql`(${field2} IS NULL) ${nullsDirection}`,
-      sql`${field2} ${direction}`
-    );
+  if (metaKinds.length === plan.fullKinds.length + plan.projectedKinds.size) {
+    return columns.map((col) => sql`${sql.raw(`${alias}.${col}`)}`);
   }
-  return sql`ORDER BY ${sql.join(parts, sql`, `)}`;
+  const filter = compileKindFilter(sql.raw(`${alias}.kind`), metaKinds);
+  return columns.map(
+    (col) => sql`CASE WHEN ${filter} THEN ${sql.raw(`${alias}.${col}`)} ELSE NULL END AS ${sql.raw(col)}`
+  );
 }
-function compileLimitOffset(ast) {
-  const parts = [];
-  if (ast.limit !== void 0) {
-    parts.push(sql`LIMIT ${ast.limit}`);
+function buildFullPropsColumn(alias, plan) {
+  if (plan.projectedKinds.size === 0) {
+    return sql`${sql.raw(`${alias}.props`)} AS props`;
   }
-  if (ast.offset !== void 0) {
-    parts.push(sql`OFFSET ${ast.offset}`);
+  if (plan.fullKinds.length === 0) {
+    return sql`NULL AS props`;
   }
-  return parts.length > 0 ? sql.join(parts, sql` `) : void 0;
+  const filter = compileKindFilter(sql.raw(`${alias}.kind`), plan.fullKinds);
+  return sql`CASE WHEN ${filter} THEN ${sql.raw(`${alias}.props`)} ELSE NULL END AS props`;
 }
-var DEFAULT_TABLE_NAMES = {
-  nodes: "typegraph_nodes",
-  edges: "typegraph_edges",
-  embeddings: "typegraph_node_embeddings"
-};
-var MAX_IDENTIFIER_LENGTH = 63;
-var VALID_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_$]*$/i;
-function validateTableName(name, label) {
-  if (!name || name.length === 0) {
-    throw new ConfigurationError(`${label} table name cannot be empty`);
-  }
-  if (name.length > MAX_IDENTIFIER_LENGTH) {
-    throw new ConfigurationError(
-      `${label} table name exceeds maximum length of ${MAX_IDENTIFIER_LENGTH} characters`
-    );
+function buildProjectedPropertyColumns(alias, plan, dialect) {
+  const columns = [];
+  for (const [kind, kindPlan] of plan.projectedKinds.entries()) {
+    for (const fieldPlan of kindPlan.propertyFields) {
+      const extracted = compileTypedJsonExtract({
+        column: sql.raw(`${alias}.props`),
+        dialect,
+        pointer: jsonPointer([fieldPlan.field]),
+        valueType: fieldPlan.typeInfo?.valueType
+      });
+      columns.push(
+        sql`CASE WHEN ${sql.raw(alias)}.kind = ${kind} THEN ${extracted} ELSE NULL END AS ${quoteIdentifier(fieldPlan.outputName)}`
+      );
+    }
   }
-  if (!VALID_IDENTIFIER_PATTERN.test(name)) {
-    throw new ConfigurationError(
-      `${label} table name "${name}" is not a valid SQL identifier. Table names must start with a letter or underscore and contain only letters, digits, underscores, or dollar signs.`
+  return columns;
+}
+function applyProjectedFields(target, row, kindPlan) {
+  for (const fieldPlan of kindPlan.propertyFields) {
+    target[fieldPlan.field] = decodeSelectedValue(
+      row[fieldPlan.outputName],
+      fieldPlan.typeInfo
     );
   }
 }
-function quoteIdentifier2(name) {
-  return `"${name.replaceAll('"', '""')}"`;
-}
-function createSqlSchema(names = {}) {
-  const tables = { ...DEFAULT_TABLE_NAMES, ...names };
-  validateTableName(tables.nodes, "nodes");
-  validateTableName(tables.edges, "edges");
-  validateTableName(tables.embeddings, "embeddings");
-  return {
-    tables,
-    nodesTable: sql.raw(quoteIdentifier2(tables.nodes)),
-    edgesTable: sql.raw(quoteIdentifier2(tables.edges)),
-    embeddingsTable: sql.raw(quoteIdentifier2(tables.embeddings))
+function mapSubgraphNodeRow(row, projectionPlan) {
+  const kindPlan = projectionPlan.projectedKinds.get(row.kind);
+  if (kindPlan === void 0) {
+    return rowToNode({
+      ...row,
+      props: normalizeProps(row.props)
+    });
+  }
+  const projectedNode = {
+    kind: row.kind,
+    id: row.id
+  };
+  if (kindPlan.includeMeta) {
+    projectedNode.meta = rowToNodeMeta(row);
+  }
+  applyProjectedFields(projectedNode, row, kindPlan);
+  return projectedNode;
+}
+function mapSubgraphEdgeRow(row, projectionPlan) {
+  const kindPlan = projectionPlan.projectedKinds.get(row.kind);
+  if (kindPlan === void 0) {
+    return rowToEdge({
+      ...row,
+      props: normalizeProps(row.props)
+    });
+  }
+  const projectedEdge = {
+    id: row.id,
+    kind: row.kind,
+    fromKind: row.from_kind,
+    fromId: row.from_id,
+    toKind: row.to_kind,
+    toId: row.to_id
   };
+  if (kindPlan.includeMeta) {
+    projectedEdge.meta = rowToEdgeMeta(row);
+  }
+  applyProjectedFields(projectedEdge, row, kindPlan);
+  return projectedEdge;
 }
-var DEFAULT_SQL_SCHEMA = createSqlSchema();
 var OPERATOR_MAP = {
   union: "UNION",
   unionAll: "UNION ALL",
@@ -4705,9 +5238,9 @@ function transformPathColumns(rows, state, _dialect) {
   }
   return changed ? result : rows;
 }
-var RESERVED_NODE_KEYS2 = /* @__PURE__ */ new Set(["id", "kind", "meta"]);
-var RESERVED_EDGE_KEYS2 = /* @__PURE__ */ new Set(["id", "kind", "fromId", "toId", "meta"]);
-function nullToUndefined(value) {
+var RESERVED_NODE_KEYS3 = /* @__PURE__ */ new Set(["id", "kind", "meta"]);
+var RESERVED_EDGE_KEYS3 = /* @__PURE__ */ new Set(["id", "kind", "fromId", "toId", "meta"]);
+function nullToUndefined3(value) {
   return value === null ? void 0 : value;
 }
 function assignPropsExcludingReserved(target, props, reservedKeys) {
@@ -4723,13 +5256,13 @@ function buildSelectableNode(row, alias) {
   const propsRaw = row[`${alias}_props`];
   const rawProps = typeof propsRaw === "string" ? JSON.parse(propsRaw) : propsRaw ?? {};
   const version = row[`${alias}_version`];
-  const validFrom = nullToUndefined(
+  const validFrom = nullToUndefined3(
     row[`${alias}_valid_from`]
   );
-  const validTo = nullToUndefined(row[`${alias}_valid_to`]);
+  const validTo = nullToUndefined3(row[`${alias}_valid_to`]);
   const createdAt = row[`${alias}_created_at`];
   const updatedAt = row[`${alias}_updated_at`];
-  const deletedAt = nullToUndefined(
+  const deletedAt = nullToUndefined3(
     row[`${alias}_deleted_at`]
   );
   const result = {
@@ -4744,7 +5277,7 @@ function buildSelectableNode(row, alias) {
       deletedAt
     }
   };
-  assignPropsExcludingReserved(result, rawProps, RESERVED_NODE_KEYS2);
+  assignPropsExcludingReserved(result, rawProps, RESERVED_NODE_KEYS3);
   return result;
 }
 function buildSelectableNodeOrUndefined(row, alias) {
@@ -4764,13 +5297,13 @@ function buildSelectableEdge(row, alias) {
   const toId = row[`${alias}_to_id`];
   const propsRaw = row[`${alias}_props`];
   const rawProps = typeof propsRaw === "string" ? JSON.parse(propsRaw) : propsRaw ?? {};
-  const validFrom = nullToUndefined(
+  const validFrom = nullToUndefined3(
     row[`${alias}_valid_from`]
   );
-  const validTo = nullToUndefined(row[`${alias}_valid_to`]);
+  const validTo = nullToUndefined3(row[`${alias}_valid_to`]);
   const createdAt = row[`${alias}_created_at`];
   const updatedAt = row[`${alias}_updated_at`];
-  const deletedAt = nullToUndefined(
+  const deletedAt = nullToUndefined3(
     row[`${alias}_deleted_at`]
   );
   const result = {
@@ -4786,7 +5319,7 @@ function buildSelectableEdge(row, alias) {
       deletedAt
     }
   };
-  assignPropsExcludingReserved(result, rawProps, RESERVED_EDGE_KEYS2);
+  assignPropsExcludingReserved(result, rawProps, RESERVED_EDGE_KEYS3);
   return result;
 }
 function buildSelectContext(row, startAlias, traversals) {
@@ -5172,63 +5705,6 @@ function getPlaceholderForValueType(valueType, mode) {
   }
 }
 
-// src/query/execution/value-decoder.ts
-function nullToUndefined2(value) {
-  return value === null ? void 0 : value;
-}
-function decodeSelectedValue(value, typeInfo) {
-  const normalized = nullToUndefined2(value);
-  if (normalized === void 0) return void 0;
-  if (typeInfo === void 0) {
-    return normalized;
-  }
-  return decodeByValueType(normalized, typeInfo.valueType);
-}
-function decodeByValueType(value, valueType) {
-  switch (valueType) {
-    case "boolean": {
-      if (typeof value === "boolean") return value;
-      if (typeof value === "number") return value !== 0;
-      if (typeof value === "string") {
-        if (value === "0") return false;
-        if (value === "1") return true;
-        if (value.toLowerCase() === "true") return true;
-        if (value.toLowerCase() === "false") return false;
-      }
-      return Boolean(value);
-    }
-    case "number": {
-      if (typeof value === "number") return value;
-      if (typeof value === "string") {
-        const parsed = Number(value);
-        return Number.isNaN(parsed) ? value : parsed;
-      }
-      return value;
-    }
-    case "array":
-    case "object":
-    case "embedding": {
-      if (typeof value !== "string") return value;
-      const trimmed = value.trim();
-      const looksJson = trimmed.startsWith("[") || trimmed.startsWith("{");
-      if (!looksJson) return value;
-      try {
-        return JSON.parse(trimmed);
-      } catch {
-        return value;
-      }
-    }
-    case "string":
-    case "date":
-    case "unknown": {
-      return value;
-    }
-    default: {
-      return value;
-    }
-  }
-}
-
 // src/query/execution/selective-result-mapper.ts
 var MissingSelectiveFieldError = class extends Error {
   alias;
@@ -5397,12 +5873,12 @@ function buildRequiredAliasValue(row, plan) {
     }
   };
   for (const field2 of plan.systemFields) {
-    base[field2.field] = nullToUndefined2(row[field2.outputName]);
+    base[field2.field] = nullToUndefined(row[field2.outputName]);
   }
   if (plan.metaFields.length > 0) {
     const meta = {};
     for (const field2 of plan.metaFields) {
-      meta[field2.metaKey] = nullToUndefined2(row[field2.outputName]);
+      meta[field2.metaKey] = nullToUndefined(row[field2.outputName]);
     }
     base.meta = createGuardedProxy(meta, `${plan.alias}.meta`);
   }
@@ -6369,24 +6845,102 @@ var ExecutableQuery = class _ExecutableQuery {
     if (optimizedResult !== void 0) {
       return optimizedResult;
     }
-    const compiled = this.compile();
-    const rawRows = await this.#config.backend.execute(compiled);
-    this.#config.dialect ?? "sqlite";
-    const rows = transformPathColumns(rawRows, this.#state);
-    return mapResults(
-      rows,
-      this.#state.startAlias,
-      this.#state.traversals,
-      this.#selectFn
-    );
+    const compiled = this.compile();
+    const rawRows = await this.#config.backend.execute(compiled);
+    this.#config.dialect ?? "sqlite";
+    const rows = transformPathColumns(rawRows, this.#state);
+    return mapResults(
+      rows,
+      this.#state.startAlias,
+      this.#state.traversals,
+      this.#selectFn
+    );
+  }
+  /**
+   * Executes the query against a provided backend.
+   *
+   * Used by `store.batch()` to run multiple queries over a single connection
+   * (e.g., within a transaction). The full compile → execute → transform
+   * pipeline runs identically to `execute()`, but against the given backend.
+   */
+  async executeOn(backend) {
+    if (hasParameterReferences(this.toAst())) {
+      throw new Error(
+        "Query contains param() references. Use .prepare().execute({...}) instead of .execute()."
+      );
+    }
+    const optimizedResult = await this.#tryOptimizedExecutionOn(backend);
+    if (optimizedResult !== void 0) {
+      return optimizedResult;
+    }
+    const compiled = this.compile();
+    const rawRows = await backend.execute(compiled);
+    this.#config.dialect ?? "sqlite";
+    const rows = transformPathColumns(rawRows, this.#state);
+    return mapResults(
+      rows,
+      this.#state.startAlias,
+      this.#state.traversals,
+      this.#selectFn
+    );
+  }
+  /**
+   * Attempts optimized execution by tracking which fields the select callback accesses.
+   *
+   * Returns undefined if optimization is not possible (callback uses method calls,
+   * computations, or returns whole nodes).
+   */
+  async #tryOptimizedExecution() {
+    const selectiveFields = this.#getSelectiveFieldsForExecute();
+    if (selectiveFields === void 0) {
+      return void 0;
+    }
+    let compiled;
+    if (this.#cachedOptimizedCompiled === NOT_COMPUTED) {
+      const baseAst = buildQueryAst(this.#config, this.#state);
+      const selectiveAst = {
+        ...baseAst,
+        selectiveFields
+      };
+      compiled = compileQuery(
+        selectiveAst,
+        this.#config.graphId,
+        this.#compileOptions()
+      );
+      this.#cachedOptimizedCompiled = compiled;
+    } else {
+      compiled = this.#cachedOptimizedCompiled;
+    }
+    const rawSelectiveRows = await this.#requireBackend().execute(compiled);
+    this.#config.dialect ?? "sqlite";
+    const rows = transformPathColumns(rawSelectiveRows, this.#state);
+    try {
+      return mapSelectiveResults(
+        rows,
+        this.#state,
+        selectiveFields,
+        this.#config.schemaIntrospector,
+        this.#selectFn
+      );
+    } catch (error) {
+      if (error instanceof MissingSelectiveFieldError) {
+        this.#cachedSelectiveFieldsForExecute = void 0;
+        this.#cachedOptimizedCompiled = NOT_COMPUTED;
+        return void 0;
+      }
+      if (error instanceof UnsupportedPredicateError) {
+        this.#cachedSelectiveFieldsForExecute = void 0;
+        this.#cachedOptimizedCompiled = NOT_COMPUTED;
+        return void 0;
+      }
+      throw error;
+    }
   }
   /**
-   * Attempts optimized execution by tracking which fields the select callback accesses.
-   *
-   * Returns undefined if optimization is not possible (callback uses method calls,
-   * computations, or returns whole nodes).
+   * Attempts optimized execution against a provided backend.
+   * Mirror of #tryOptimizedExecution but delegates to the given backend.
    */
-  async #tryOptimizedExecution() {
+  async #tryOptimizedExecutionOn(backend) {
     const selectiveFields = this.#getSelectiveFieldsForExecute();
     if (selectiveFields === void 0) {
       return void 0;
@@ -6407,7 +6961,7 @@ var ExecutableQuery = class _ExecutableQuery {
     } else {
       compiled = this.#cachedOptimizedCompiled;
     }
-    const rawSelectiveRows = await this.#requireBackend().execute(compiled);
+    const rawSelectiveRows = await backend.execute(compiled);
     this.#config.dialect ?? "sqlite";
     const rows = transformPathColumns(rawSelectiveRows, this.#state);
     try {
@@ -6682,7 +7236,7 @@ var ExecutableQuery = class _ExecutableQuery {
           throw new MissingSelectiveFieldError(alias, fieldName);
         }
         const aliasObject2 = this.#getOrCreateAliasObject(cursorContext, alias);
-        aliasObject2[fieldName] = nullToUndefined2(row[outputName2]);
+        aliasObject2[fieldName] = nullToUndefined(row[outputName2]);
         continue;
       }
       const segments = parseJsonPointer(jsonPointer2);
@@ -8065,6 +8619,29 @@ var UnionableQuery = class _UnionableQuery {
     }
     return rows;
   }
+  /**
+   * Executes the combined query against a provided backend.
+   *
+   * Used by `store.batch()` to run multiple queries over a single connection.
+   */
+  async executeOn(backend) {
+    if (composableQueryHasParameterReferences(this.toAst())) {
+      throw new Error(
+        "Query contains param() references. Use .prepare().execute({...}) instead of .execute()."
+      );
+    }
+    const compiled = this.compile();
+    const rows = await backend.execute(compiled);
+    if (this.#state.selectFn && this.#state.startAlias) {
+      return mapResults(
+        rows,
+        this.#state.startAlias,
+        this.#state.traversals ?? [],
+        this.#state.selectFn
+      );
+    }
+    return rows;
+  }
 };
 
 // src/query/builder/aggregates.ts
@@ -8342,6 +8919,35 @@ function createEdgeCollection(config) {
     executeHardDelete: executeEdgeHardDelete2,
     matchesTemporalMode
   } = config;
+  const mapRows = (rows) => rows.map((row) => narrowEdge(rowToEdge2(row)));
+  async function findEdgesFrom(from, target) {
+    const rows = await target.findEdgesByKind({
+      graphId,
+      kind,
+      fromKind: from.kind,
+      fromId: from.id,
+      excludeDeleted: true
+    });
+    return mapRows(rows);
+  }
+  async function findEdgesTo(to, target) {
+    const rows = await target.findEdgesByKind({
+      graphId,
+      kind,
+      toKind: to.kind,
+      toId: to.id,
+      excludeDeleted: true
+    });
+    return mapRows(rows);
+  }
+  function buildFindByEndpointsOptions(options) {
+    const result = {};
+    if (options?.matchOn !== void 0)
+      result.matchOn = options.matchOn;
+    if (options?.props !== void 0)
+      result.props = options.props;
+    return result;
+  }
   return {
     async create(from, to, props, options) {
       const result = await executeEdgeCreate2(
@@ -8397,24 +9003,32 @@ function createEdgeCollection(config) {
       return narrowEdge(result);
     },
     async findFrom(from) {
-      const rows = await backend.findEdgesByKind({
-        graphId,
-        kind,
-        fromKind: from.kind,
-        fromId: from.id,
-        excludeDeleted: true
-      });
-      return rows.map((row) => narrowEdge(rowToEdge2(row)));
+      return findEdgesFrom(from, backend);
     },
     async findTo(to) {
-      const rows = await backend.findEdgesByKind({
-        graphId,
-        kind,
-        toKind: to.kind,
-        toId: to.id,
-        excludeDeleted: true
-      });
-      return rows.map((row) => narrowEdge(rowToEdge2(row)));
+      return findEdgesTo(to, backend);
+    },
+    batchFindFrom(from) {
+      return { executeOn: (target) => findEdgesFrom(from, target) };
+    },
+    batchFindTo(to) {
+      return { executeOn: (target) => findEdgesTo(to, target) };
+    },
+    batchFindByEndpoints(from, to, options) {
+      return {
+        executeOn: async (target) => {
+          const result = await config.executeFindByEndpoints(
+            kind,
+            from.kind,
+            from.id,
+            to.kind,
+            to.id,
+            target,
+            buildFindByEndpointsOptions(options)
+          );
+          return result === void 0 ? [] : [narrowEdge(result)];
+        }
+      };
     },
     async delete(id) {
       await executeEdgeDelete2(id, backend);
@@ -8448,7 +9062,7 @@ function createEdgeCollection(config) {
       if (options?.limit !== void 0) params.limit = options.limit;
       if (options?.offset !== void 0) params.offset = options.offset;
       const rows = await backend.findEdgesByKind(params);
-      return rows.map((row) => narrowEdge(rowToEdge2(row)));
+      return mapRows(rows);
     },
     async count(options) {
       const mode = options?.temporalMode ?? defaultTemporalMode;
@@ -8577,11 +9191,6 @@ function createEdgeCollection(config) {
       await deleteAll(backend);
     },
     async findByEndpoints(from, to, options) {
-      const findOptions = {};
-      if (options?.matchOn !== void 0)
-        findOptions.matchOn = options.matchOn;
-      if (options?.props !== void 0)
-        findOptions.props = options.props;
       const result = await config.executeFindByEndpoints(
         kind,
         from.kind,
@@ -8589,7 +9198,7 @@ function createEdgeCollection(config) {
         to.kind,
         to.id,
         backend,
-        findOptions
+        buildFindByEndpointsOptions(options)
       );
       return result === void 0 ? void 0 : narrowEdge(result);
     },
@@ -9285,67 +9894,6 @@ async function checkCardinalityConstraint(ctx, edgeKind, cardinality, fromKind,
   }
 }
 
-// src/store/row-mappers.ts
-var RESERVED_NODE_KEYS3 = /* @__PURE__ */ new Set(["id", "kind", "meta"]);
-function nullToUndefined3(value) {
-  return value === null ? void 0 : value;
-}
-function filterReservedKeys(props, reservedKeys) {
-  const filtered = {};
-  for (const [key, value] of Object.entries(props)) {
-    if (!reservedKeys.has(key)) {
-      filtered[key] = value;
-    }
-  }
-  return filtered;
-}
-function rowToNode(row) {
-  const rawProps = JSON.parse(row.props);
-  const props = filterReservedKeys(rawProps, RESERVED_NODE_KEYS3);
-  return {
-    kind: row.kind,
-    id: row.id,
-    meta: {
-      version: row.version,
-      validFrom: nullToUndefined3(row.valid_from),
-      validTo: nullToUndefined3(row.valid_to),
-      createdAt: row.created_at,
-      updatedAt: row.updated_at,
-      deletedAt: nullToUndefined3(row.deleted_at)
-    },
-    ...props
-  };
-}
-var RESERVED_EDGE_KEYS3 = /* @__PURE__ */ new Set([
-  "id",
-  "kind",
-  "meta",
-  "fromKind",
-  "fromId",
-  "toKind",
-  "toId"
-]);
-function rowToEdge(row) {
-  const rawProps = JSON.parse(row.props);
-  const props = filterReservedKeys(rawProps, RESERVED_EDGE_KEYS3);
-  return {
-    id: row.id,
-    kind: row.kind,
-    fromKind: row.from_kind,
-    fromId: row.from_id,
-    toKind: row.to_kind,
-    toId: row.to_id,
-    meta: {
-      validFrom: nullToUndefined3(row.valid_from),
-      validTo: nullToUndefined3(row.valid_to),
-      createdAt: row.created_at,
-      updatedAt: row.updated_at,
-      deletedAt: nullToUndefined3(row.deleted_at)
-    },
-    ...props
-  };
-}
-
 // src/store/operations/edge-operations.ts
 function getEdgeRegistration(graph, kind) {
   const registration = graph.edges[kind];
@@ -11219,142 +11767,6 @@ async function executeNodeBulkGetOrCreateByConstraint(ctx, kind, constraintName,
   }
   return results;
 }
-var DEFAULT_SUBGRAPH_MAX_DEPTH = 10;
-function normalizeProps(value) {
-  return typeof value === "string" ? value : JSON.stringify(value ?? {});
-}
-async function executeSubgraph(params) {
-  const { options } = params;
-  if (options.edges.length === 0) {
-    return { nodes: [], edges: [] };
-  }
-  const maxDepth = Math.min(
-    options.maxDepth ?? DEFAULT_SUBGRAPH_MAX_DEPTH,
-    MAX_RECURSIVE_DEPTH
-  );
-  const ctx = {
-    graphId: params.graphId,
-    rootId: params.rootId,
-    edgeKinds: options.edges,
-    maxDepth,
-    includeKinds: options.includeKinds,
-    excludeRoot: options.excludeRoot ?? false,
-    direction: options.direction ?? "out",
-    cyclePolicy: options.cyclePolicy ?? "prevent",
-    dialect: params.dialect,
-    schema: params.schema ?? DEFAULT_SQL_SCHEMA,
-    backend: params.backend
-  };
-  const reachableCte = buildReachableCte(ctx);
-  const includedIdsCte = buildIncludedIdsCte(ctx);
-  const [nodeRows, edgeRows] = await Promise.all([
-    fetchSubgraphNodes(ctx, reachableCte, includedIdsCte),
-    fetchSubgraphEdges(ctx, reachableCte, includedIdsCte)
-  ]);
-  const nodes = nodeRows.map(
-    (row) => rowToNode({ ...row, props: normalizeProps(row.props) })
-  );
-  const edges = edgeRows.map(
-    (row) => rowToEdge({ ...row, props: normalizeProps(row.props) })
-  );
-  return {
-    nodes,
-    edges
-  };
-}
-function buildReachableCte(ctx) {
-  const shouldTrackPath = ctx.cyclePolicy === "prevent";
-  const edgeKindFilter = compileKindFilter(sql.raw("e.kind"), ctx.edgeKinds);
-  const initialPath = shouldTrackPath ? ctx.dialect.initializePath(sql.raw("n.id")) : void 0;
-  const pathExtension = shouldTrackPath ? ctx.dialect.extendPath(sql.raw("r.path"), sql.raw("n.id")) : void 0;
-  const cycleCheck = shouldTrackPath ? ctx.dialect.cycleCheck(sql.raw("n.id"), sql.raw("r.path")) : void 0;
-  const baseColumns = [sql`n.id`, sql`n.kind`, sql`0 AS depth`];
-  if (initialPath !== void 0) {
-    baseColumns.push(sql`${initialPath} AS path`);
-  }
-  const baseCase = sql`SELECT ${sql.join(baseColumns, sql`, `)} FROM ${ctx.schema.nodesTable} n WHERE n.graph_id = ${ctx.graphId} AND n.id = ${ctx.rootId} AND n.deleted_at IS NULL`;
-  const recursiveColumns = [
-    sql`n.id`,
-    sql`n.kind`,
-    sql`r.depth + 1 AS depth`
-  ];
-  if (pathExtension !== void 0) {
-    recursiveColumns.push(sql`${pathExtension} AS path`);
-  }
-  const recursiveWhereClauses = [
-    sql`e.graph_id = ${ctx.graphId}`,
-    edgeKindFilter,
-    sql`e.deleted_at IS NULL`,
-    sql`n.deleted_at IS NULL`,
-    sql`r.depth < ${ctx.maxDepth}`
-  ];
-  if (cycleCheck !== void 0) {
-    recursiveWhereClauses.push(cycleCheck);
-  }
-  const forceWorktableOuterJoinOrder = ctx.dialect.capabilities.forceRecursiveWorktableOuterJoinOrder;
-  const recursiveCase = ctx.direction === "both" ? compileBidirectionalBranch({
-    recursiveColumns,
-    whereClauses: recursiveWhereClauses,
-    forceWorktableOuterJoinOrder,
-    schema: ctx.schema
-  }) : compileRecursiveBranch({
-    recursiveColumns,
-    whereClauses: recursiveWhereClauses,
-    joinField: "from_id",
-    targetField: "to_id",
-    targetKindField: "to_kind",
-    forceWorktableOuterJoinOrder,
-    schema: ctx.schema
-  });
-  return sql`WITH RECURSIVE reachable AS (${baseCase} UNION ALL ${recursiveCase})`;
-}
-function compileRecursiveBranch(params) {
-  const columns = [...params.recursiveColumns];
-  const selectClause = sql`SELECT ${sql.join(columns, sql`, `)}`;
-  const nodeJoin = sql`JOIN ${params.schema.nodesTable} n ON n.graph_id = e.graph_id AND n.id = e.${sql.raw(params.targetField)} AND n.kind = e.${sql.raw(params.targetKindField)}`;
-  if (params.forceWorktableOuterJoinOrder) {
-    const allWhere = [
-      ...params.whereClauses,
-      sql`e.${sql.raw(params.joinField)} = r.id`
-    ];
-    return sql`${selectClause} FROM reachable r CROSS JOIN ${params.schema.edgesTable} e ${nodeJoin} WHERE ${sql.join(allWhere, sql` AND `)}`;
-  }
-  const where = [...params.whereClauses];
-  return sql`${selectClause} FROM reachable r JOIN ${params.schema.edgesTable} e ON e.${sql.raw(params.joinField)} = r.id ${nodeJoin} WHERE ${sql.join(where, sql` AND `)}`;
-}
-function compileBidirectionalBranch(params) {
-  const columns = [...params.recursiveColumns];
-  const selectClause = sql`SELECT ${sql.join(columns, sql`, `)}`;
-  const nodeJoin = sql`JOIN ${params.schema.nodesTable} n ON n.graph_id = e.graph_id AND ((e.to_id = r.id AND n.id = e.from_id AND n.kind = e.from_kind) OR (e.from_id = r.id AND n.id = e.to_id AND n.kind = e.to_kind))`;
-  if (params.forceWorktableOuterJoinOrder) {
-    const allWhere = [
-      ...params.whereClauses,
-      sql`(e.from_id = r.id OR e.to_id = r.id)`
-    ];
-    return sql`${selectClause} FROM reachable r CROSS JOIN ${params.schema.edgesTable} e ${nodeJoin} WHERE ${sql.join(allWhere, sql` AND `)}`;
-  }
-  return sql`${selectClause} FROM reachable r JOIN ${params.schema.edgesTable} e ON (e.from_id = r.id OR e.to_id = r.id) ${nodeJoin} WHERE ${sql.join([...params.whereClauses], sql` AND `)}`;
-}
-function buildIncludedIdsCte(ctx) {
-  const filters = [];
-  if (ctx.includeKinds !== void 0 && ctx.includeKinds.length > 0) {
-    filters.push(compileKindFilter(sql.raw("kind"), ctx.includeKinds));
-  }
-  if (ctx.excludeRoot) {
-    filters.push(sql`id != ${ctx.rootId}`);
-  }
-  const whereClause = filters.length > 0 ? sql` WHERE ${sql.join(filters, sql` AND `)}` : sql``;
-  return sql`, included_ids AS (SELECT DISTINCT id FROM reachable${whereClause})`;
-}
-async function fetchSubgraphNodes(ctx, reachableCte, includedIdsCte) {
-  const query = sql`${reachableCte}${includedIdsCte} SELECT n.kind, n.id, n.props, n.version, n.valid_from, n.valid_to, n.created_at, n.updated_at, n.deleted_at FROM ${ctx.schema.nodesTable} n WHERE n.graph_id = ${ctx.graphId} AND n.id IN (SELECT id FROM included_ids)`;
-  return ctx.backend.execute(query);
-}
-async function fetchSubgraphEdges(ctx, reachableCte, includedIdsCte) {
-  const edgeKindFilter = compileKindFilter(sql.raw("e.kind"), ctx.edgeKinds);
-  const query = sql`${reachableCte}${includedIdsCte} SELECT e.id, e.kind, e.from_kind, e.from_id, e.to_kind, e.to_id, e.props, e.valid_from, e.valid_to, e.created_at, e.updated_at, e.deleted_at FROM ${ctx.schema.edgesTable} e WHERE e.graph_id = ${ctx.graphId} AND ${edgeKindFilter} AND e.deleted_at IS NULL AND e.from_id IN (SELECT id FROM included_ids) AND e.to_id IN (SELECT id FROM included_ids)`;
-  return ctx.backend.execute(query);
-}
 
 // src/store/store.ts
 var Store = class {
@@ -11558,6 +11970,46 @@ var Store = class {
   query() {
     return this.#createQueryForBackend(this.#backend);
   }
+  // === Batch Query Execution ===
+  /**
+   * Executes multiple queries over a single connection with snapshot consistency.
+   *
+   * Acquires one connection via an implicit transaction, executes each query
+   * sequentially on that connection, and returns a typed tuple of results.
+   * Each query preserves its own result type, projection, filtering,
+   * sorting, and pagination.
+   *
+   * Read-only — use `bulkCreate`, `bulkInsert`, etc. for write batching.
+   *
+   * @example
+   * ```typescript
+   * const [people, companies] = await store.batch(
+   *   store.query()
+   *     .from("Person", "p")
+   *     .select((ctx) => ({ id: ctx.p.id, name: ctx.p.name })),
+   *   store.query()
+   *     .from("Company", "c")
+   *     .select((ctx) => ({ id: ctx.c.id, name: ctx.c.name }))
+   *     .orderBy("c", "name", "asc")
+   *     .limit(5),
+   * );
+   * // people:    readonly { id: string; name: string }[]
+   * // companies: readonly { id: string; name: string }[]
+   * ```
+   *
+   * @param queries - Two or more executable queries (from `.select()` or set operations)
+   * @returns A tuple with per-query typed results, preserving input order
+   */
+  async batch(...queries) {
+    return this.#backend.transaction(async (txBackend) => {
+      const results = [];
+      for (const query of queries) {
+        const result = await query.executeOn(txBackend);
+        results.push(result);
+      }
+      return results;
+    });
+  }
   // === Subgraph Extraction ===
   /**
    * Extracts a typed subgraph by traversing from a root node.
@@ -11583,6 +12035,7 @@ var Store = class {
    */
   async subgraph(rootId, options) {
     return executeSubgraph({
+      graph: this.#graph,
       graphId: this.graphId,
       rootId,
       backend: this.#backend,
@@ -11762,6 +12215,6 @@ async function createStoreWithSchema(graph, backend, options) {
   return [store, result];
 }
 
-export { DEFAULT_SQL_SCHEMA, ExecutableAggregateQuery, ExecutableQuery, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, PreparedQuery, QueryBuilder, UnionableQuery, avg, broader, composeFragments, core, count, countDistinct, createExternalRef, createFragment, createQueryBuilder, createSqlSchema, createStore, createStoreWithSchema, defineEdge, defineNode, differentFrom, disjointWith, equivalentTo, exists, externalRef, field, fieldRef, generateId, getExternalRefTable, hasPart, having, havingEq, havingGt, havingGte, havingLt, havingLte, implies, inSubquery, inverseOf, isExternalRefSchema, isParameterRef, limitFragment, max, metaEdge, min, narrower, notExists, notInSubquery, offsetFragment, orderByFragment, param, partOf, relatedTo, sameAs, subClassOf, sum };
+export { DEFAULT_SQL_SCHEMA, ExecutableAggregateQuery, ExecutableQuery, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, PreparedQuery, QueryBuilder, UnionableQuery, avg, broader, composeFragments, core, count, countDistinct, createExternalRef, createFragment, createQueryBuilder, createSqlSchema, createStore, createStoreWithSchema, defineEdge, defineNode, defineSubgraphProject, differentFrom, disjointWith, equivalentTo, exists, externalRef, field, fieldRef, generateId, getExternalRefTable, hasPart, having, havingEq, havingGt, havingGte, havingLt, havingLte, implies, inSubquery, inverseOf, isExternalRefSchema, isParameterRef, limitFragment, max, metaEdge, min, narrower, notExists, notInSubquery, offsetFragment, orderByFragment, param, partOf, relatedTo, sameAs, subClassOf, sum };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map