@nicia-ai/typegraph 0.11.0 → 0.12.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") {
@@ -581,6 +515,10 @@ function baseFieldBuilder(field2) {
 function stringField(field2) {
   return {
     ...baseFieldBuilder(field2),
+    gt: (value) => comparison("gt", field2, value),
+    gte: (value) => comparison("gte", field2, value),
+    lt: (value) => comparison("lt", field2, value),
+    lte: (value) => comparison("lte", field2, value),
     contains: (pattern) => stringOp("contains", field2, pattern),
     startsWith: (pattern) => stringOp("startsWith", field2, pattern),
     endsWith: (pattern) => stringOp("endsWith", field2, pattern),
@@ -1461,627 +1399,310 @@ 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"
-    );
-  }
-  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}"`
+// 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);
+    }
   }
-  if (!Number.isFinite(vectorPredicate.limit) || vectorPredicate.limit <= 0) {
-    throw new UnsupportedPredicateError(
-      `Vector predicate limit must be a positive finite number, got ${String(vectorPredicate.limit)}`
-    );
+  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 { 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)}`
-      );
-    }
+  if (kinds.length === 1) {
+    return sql`${column} = ${kinds[0]}`;
   }
-  return { vectorPredicate };
+  return sql`${column} IN (${sql.join(
+    kinds.map((kind) => sql`${kind}`),
+    sql`, `
+  )})`;
 }
-function resolveVectorAwareLimit(astLimit, vectorPredicate) {
-  if (vectorPredicate === void 0) {
-    return astLimit;
+function getNodeKindsForAlias(ast, alias) {
+  if (alias === ast.start.alias) {
+    return ast.start.kinds;
   }
-  if (astLimit === void 0) {
-    return vectorPredicate.limit;
+  for (const traversal of ast.traversals) {
+    if (traversal.nodeAlias === alias) {
+      return traversal.nodeKinds;
+    }
   }
-  return Math.min(astLimit, vectorPredicate.limit);
+  throw new CompilerInvariantError(`Unknown traversal source alias: ${alias}`);
 }
 
-// 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);
+// 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;
+    }
+    case "set_op": {
+      collectPlanOperations(node.left, ops);
+      collectPlanOperations(node.right, ops);
+      return;
+    }
+    case "scan": {
+      return;
     }
   }
-  return aggregates;
 }
-function getAliasPredicates(ast, alias, predicateTargetType) {
-  return ast.predicates.filter((predicate2) => {
-    const targetType = predicate2.targetType ?? "node";
-    return predicate2.targetAlias === alias && targetType === predicateTargetType;
-  });
+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;
+      }
+    }
+  }
 }
-function wrapWithAliasFilterNode(currentNode, ast, alias, predicateTargetType, nextPlanNodeId) {
-  const aliasPredicates = getAliasPredicates(ast, alias, predicateTargetType);
-  if (aliasPredicates.length === 0) {
-    return currentNode;
+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 {
-    alias,
-    id: nextPlanNodeId(),
-    input: currentNode,
-    op: "filter",
-    predicateTargetType,
-    predicates: aliasPredicates.map((predicate2) => predicate2.expression)
-  };
-}
-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 (ast.orderBy !== void 0 && ast.orderBy.length > 0) {
-    node = {
-      id: nextPlanNodeId(),
-      input: node,
-      op: "sort",
-      orderBy: ast.orderBy
-    };
+    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 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 (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(
-        "limit_offset node requires limit or offset to be present"
-      );
-    }
+  if (shape.hasRecursiveExpand) {
+    throw new CompilerInvariantError(
+      'Standard SQL emitter does not support plans containing "recursive_expand" nodes',
+      { component: "plan-inspector" }
+    );
   }
-  const projectNodeBase = {
-    fields: ast.projection.fields,
-    id: nextPlanNodeId(),
-    input: node,
-    op: "project"
-  };
-  return collapsedTraversalCteAlias === void 0 ? projectNodeBase : {
-    ...projectNodeBase,
-    collapsedTraversalAlias: collapsedTraversalCteAlias
-  };
+  return shape;
 }
-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
+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" }
     );
-    currentNode = wrapWithAliasFilterNode(
-      currentNode,
-      ast,
-      traversal.nodeAlias,
-      "node",
-      nextPlanNodeId
+  }
+  if (shape.hasSetOperation) {
+    throw new CompilerInvariantError(
+      'Recursive SQL emitter does not support plans containing "set_op" nodes',
+      { component: "plan-inspector" }
     );
   }
-  if (input.vectorPredicate !== void 0) {
-    currentNode = {
-      id: nextPlanNodeId(),
-      input: currentNode,
-      op: "vector_knn",
-      predicate: input.vectorPredicate
-    };
+  return shape;
+}
+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;
+      }
+    }
   }
-  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 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 lowerComposableQueryToLogicalPlanNode(query, dialect, graphId, nextPlanNodeId) {
-  if ("__type" in query) {
-    return lowerSetOperationToLogicalPlanNode(
-      query,
-      graphId,
-      dialect,
-      nextPlanNodeId
+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 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 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
-    };
-  }
-  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 };
-    }
-  }
-  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();
+  const limitOffsetNode = findTopLevelLimitOffsetNode(logicalPlan.root);
+  const sortNode = findTopLevelSortNode(logicalPlan.root);
   return {
-    metadata: {
-      dialect: input.dialect,
-      graphId: input.graphId
-    },
-    root: lowerSetOperationToLogicalPlanNode(
-      input.op,
-      input.graphId,
-      input.dialect,
-      nextPlanNodeId
-    )
+    hasLimitOffset: limitOffsetNode !== void 0,
+    hasSetOperation: true,
+    hasSort: sortNode !== void 0,
+    limitOffsetNode,
+    sortNode
   };
 }
-
-// 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;
-    }
-    case "set_op": {
-      collectPlanOperations(node.left, ops);
-      collectPlanOperations(node.right, ops);
-      return;
-    }
-    case "scan": {
-      return;
-    }
-  }
-}
-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;
-      }
-    }
+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" }
+    );
   }
-}
-function inspectProjectPlan(logicalPlan) {
-  if (logicalPlan.root.op !== "project") {
+  if (!planShape.hasSort && input.orderBy !== void 0) {
     throw new CompilerInvariantError(
-      `SQL emitter expected logical plan root to be "project", got "${logicalPlan.root.op}"`,
-      { component: "plan-inspector" }
+      "Recursive SQL emitter received ORDER BY clause for a plan without sort nodes",
+      { component: "recursive-emitter" }
     );
   }
-  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 inspectStandardProjectPlan(logicalPlan) {
-  const shape = inspectProjectPlan(logicalPlan);
-  if (shape.hasSetOperation) {
+  if (planShape.hasLimitOffset && input.limitOffset === void 0) {
     throw new CompilerInvariantError(
-      'Standard SQL emitter does not support plans containing "set_op" nodes',
-      { component: "plan-inspector" }
+      "Recursive SQL emitter expected LIMIT/OFFSET clause for plan containing a limit_offset node",
+      { component: "recursive-emitter" }
     );
   }
-  if (shape.hasRecursiveExpand) {
+  if (!planShape.hasLimitOffset && input.limitOffset !== void 0) {
     throw new CompilerInvariantError(
-      'Standard SQL emitter does not support plans containing "recursive_expand" nodes',
-      { component: "plan-inspector" }
+      "Recursive SQL emitter received LIMIT/OFFSET clause for a plan without limit_offset nodes",
+      { component: "recursive-emitter" }
     );
   }
-  return shape;
 }
-function inspectRecursiveProjectPlan(logicalPlan) {
-  const shape = inspectProjectPlan(logicalPlan);
-  if (!shape.hasRecursiveExpand) {
+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(
-      'Recursive SQL emitter expected logical plan to contain a "recursive_expand" node',
-      { component: "plan-inspector" }
+      "Set-operation SQL emitter received suffix clauses for a plan without top-level sort or limit_offset nodes",
+      { component: "set-operation-emitter" }
     );
   }
-  if (shape.hasSetOperation) {
+  if (!hasSuffixClauses) {
+    if (shape.hasSort || shape.hasLimitOffset) {
+      throw new CompilerInvariantError(
+        "Set-operation SQL emitter expected suffix clauses for plan containing top-level sort or limit_offset nodes",
+        { component: "set-operation-emitter" }
+      );
+    }
+    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(
-      'Recursive SQL emitter does not support plans containing "set_op" nodes',
-      { component: "plan-inspector" }
-    );
-  }
-  return shape;
-}
-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 {
-    hasLimitOffset: limitOffsetNode !== void 0,
-    hasSetOperation: true,
-    hasSort: sortNode !== void 0,
-    limitOffsetNode,
-    sortNode
-  };
-}
-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 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(
-        "Set-operation SQL emitter expected suffix clauses for plan containing top-level sort or limit_offset nodes",
-        { component: "set-operation-emitter" }
-      );
-    }
-    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" }
+      `Set-operation SQL emitter expected ${String(expectedClauseCount)} top-level suffix clause(s) from logical plan, got ${String(suffixClauses.length)}`,
+      { component: "set-operation-emitter" }
     );
   }
 }
@@ -2161,62 +1782,6 @@ function emitStandardQuerySql(input) {
   }
   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]);
-    } else {
-      existing.push(predicate2);
-    }
-  }
-  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`;
-  }
-  if (kinds.length === 1) {
-    return sql`${column} = ${kinds[0]}`;
-  }
-  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;
-  }
-  for (const traversal of ast.traversals) {
-    if (traversal.nodeAlias === alias) {
-      return traversal.nodeKinds;
-    }
-  }
-  throw new CompilerInvariantError(`Unknown traversal source alias: ${alias}`);
-}
 
 // src/query/compiler/typed-json-extract.ts
 function compileTypedJsonExtract(input) {
@@ -2806,254 +2371,695 @@ function buildLimitOffsetClause(input) {
   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
+// 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)
   };
-  const recursiveTraversalPass = runCompilerPass(state, {
-    name: "recursive_traversal",
-    execute(currentState) {
-      return runRecursiveTraversalSelectionPass(currentState.ast);
-    },
-    update(currentState, traversal) {
-      return {
-        ...currentState,
-        traversal
-      };
+}
+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})`;
     }
-  });
-  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 "asOf": {
+      const timestamp = asOf;
+      return sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${timestamp}) AND (${validTo} IS NULL OR ${validTo} > ${timestamp})`;
     }
-  });
-  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
-      };
+    case "includeEnded": {
+      return sql`${deletedAt} IS NULL`;
     }
-  });
-  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
-      };
+    case "includeTombstones": {
+      return sql.raw("1=1");
     }
-  });
-  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);
+function extractTemporalOptions(ast, tableAlias) {
+  return {
+    mode: ast.temporalMode.mode,
+    asOf: ast.temporalMode.asOf,
+    tableAlias
+  };
 }
-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"
+
+// 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"
     );
   }
-  if (logicalPlan === void 0) {
-    throw new CompilerInvariantError(
-      "Logical plan pass did not initialize plan state"
-    );
+  const vectorPredicate = vectorPredicates[0];
+  if (vectorPredicate === void 0) {
+    return { vectorPredicate: void 0 };
   }
-  if (vlTraversal === void 0) {
-    throw new CompilerInvariantError(
-      "Recursive traversal pass did not select traversal"
+  const vectorStrategy = dialect.capabilities.vectorPredicateStrategy;
+  if (vectorStrategy === "unsupported" || !dialect.supportsVectors) {
+    throw new UnsupportedPredicateError(
+      `Vector similarity predicates are not supported for dialect "${dialect.name}"`
     );
   }
-  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);
-}
-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");
-  }
-  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) {
+  if (!dialect.capabilities.vectorMetrics.includes(vectorPredicate.metric)) {
     throw new UnsupportedPredicateError(
-      `Recursive traversal maxHops(${vl.maxDepth}) exceeds maximum explicit depth of ${MAX_EXPLICIT_RECURSIVE_DEPTH}`
+      `Vector metric "${vectorPredicate.metric}" is not supported for dialect "${dialect.name}"`
     );
   }
-  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 (!Number.isFinite(vectorPredicate.limit) || vectorPredicate.limit <= 0) {
+    throw new UnsupportedPredicateError(
+      `Vector predicate limit must be a positive finite number, got ${String(vectorPredicate.limit)}`
+    );
   }
-  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);
+  const { minScore } = vectorPredicate;
+  if (minScore !== void 0) {
+    if (!Number.isFinite(minScore)) {
+      throw new UnsupportedPredicateError(
+        `Vector minScore must be a finite number, got ${String(minScore)}`
+      );
     }
-    const recursiveSelectColumns = [
-      ...startColumnsFromRecursive,
-      ...nodeColumnsFromRecursive,
-      sql`r.depth + 1 AS depth`
-    ];
-    if (pathExtension !== void 0) {
-      recursiveSelectColumns.push(sql`${pathExtension} AS path`);
+    if (vectorPredicate.metric === "cosine" && (minScore < -1 || minScore > 1)) {
+      throw new UnsupportedPredicateError(
+        `Cosine minScore must be between -1 and 1, got ${String(minScore)}`
+      );
     }
-    const recursiveJoinClauses = [
+  }
+  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);
+    }
+  }
+  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 {
+    alias,
+    id: nextPlanNodeId(),
+    input: currentNode,
+    op: "filter",
+    predicateTargetType,
+    predicates: aliasPredicates.map((predicate2) => predicate2.expression)
+  };
+}
+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 (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(
+        "limit_offset node requires limit or offset to be present"
+      );
+    }
+  }
+  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
+    );
+  }
+  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 lowerComposableQueryToLogicalPlanNode(query, dialect, graphId, nextPlanNodeId) {
+  if ("__type" in query) {
+    return lowerSetOperationToLogicalPlanNode(
+      query,
+      graphId,
+      dialect,
+      nextPlanNodeId
+    );
+  }
+  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 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
+    };
+  }
+  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 };
+    }
+  }
+  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
+    )
+  };
+}
+
+// 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()
+      );
+    },
+    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"
+    );
+  }
+  if (logicalPlan === void 0) {
+    throw new CompilerInvariantError(
+      "Logical plan pass did not initialize plan state"
+    );
+  }
+  if (vlTraversal === void 0) {
+    throw new CompilerInvariantError(
+      "Recursive traversal pass did not select traversal"
+    );
+  }
+  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);
+}
+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");
+  }
+  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}`
+    );
+  }
+  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);
+  }
+  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);
+    }
+    const recursiveSelectColumns = [
+      ...startColumnsFromRecursive,
+      ...nodeColumnsFromRecursive,
+      sql`r.depth + 1 AS depth`
+    ];
+    if (pathExtension !== void 0) {
+      recursiveSelectColumns.push(sql`${pathExtension} AS path`);
+    }
+    const recursiveJoinClauses = [
       sql`e.${sql.raw(branch.joinField)} = r.${sql.raw(nodeAlias)}_id`
     ];
     if (previousNodeKinds.length > 1) {
@@ -3061,278 +3067,809 @@ function compileRecursiveCte(ast, traversal, graphId, ctx, requiredColumnsByAlia
         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 `)}
-      `;
+    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 `)}
+    `;
+  }
+  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}
+    `;
+  }
+  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 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 compileKindFilter2(kinds, columnExpr) {
+  return compileKindFilter(sql.raw(columnExpr), kinds);
+}
+function compileNodePredicates(ast, alias, ctx) {
+  return ast.predicates.filter((p) => p.targetAlias === alias && p.targetType !== "edge").map((p) => compilePredicateExpression(p.expression, ctx));
+}
+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 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 selectiveFields) {
+    markSelectiveFieldAsRequired(requiredColumnsByAlias, field2);
+  }
+  if (ast.orderBy) {
+    for (const orderSpec of ast.orderBy) {
+      markFieldRefAsRequired(requiredColumnsByAlias, orderSpec.field);
+    }
+  }
+  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}`)}`
+  );
+}
+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 compileRecursiveProjection(ast, traversal, dialect) {
+  if (ast.selectiveFields && ast.selectiveFields.length > 0) {
+    return compileRecursiveSelectiveProjection(
+      ast.selectiveFields,
+      ast,
+      traversal,
+      dialect
+    );
+  }
+  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 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)}`;
     }
-    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
+    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)}`;
   });
-  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 vl = traversal.variableLength;
+  if (vl.depthAlias !== void 0) {
+    columns.push(sql`depth AS ${quoteIdentifier(vl.depthAlias)}`);
+  }
+  if (vl.pathAlias !== void 0) {
+    columns.push(sql`path AS ${quoteIdentifier(vl.pathAlias)}`);
+  }
+  return sql.join(columns, sql`, `);
+}
+function compileRecursiveOrderBy(ast, dialect) {
+  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 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}`
+    );
+  }
+  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 (ast.offset !== void 0) {
+    parts.push(sql`OFFSET ${ast.offset}`);
+  }
+  return parts.length > 0 ? sql.join(parts, sql` `) : void 0;
+}
+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`
+    );
+  }
+  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.`
+    );
+  }
+}
+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);
+    }
+    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/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.`
+      }
+    );
+  }
+  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.`
+      }
     );
-    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`);
+}
+function filterReservedKeys(props, reservedKeys) {
+  const filtered = {};
+  for (const [key, value] of Object.entries(props)) {
+    if (!reservedKeys.has(key)) {
+      filtered[key] = value;
+    }
   }
-  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
+  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`);
   }
-  if (vl.pathAlias !== void 0) {
-    fields.push(sql`path AS ${quoteIdentifier(vl.pathAlias)}`);
+  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.join(fields, sql`, `);
+  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 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)}`);
+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) {
-    columns.push(sql`path AS ${quoteIdentifier(vl.pathAlias)}`);
+  if (ctx.excludeRoot) {
+    filters.push(sql`id != ${ctx.rootId}`);
   }
-  return sql.join(columns, 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 compileRecursiveOrderBy(ast, dialect) {
-  if (!ast.orderBy || ast.orderBy.length === 0) {
-    return void 0;
+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}`)}`);
   }
-  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}`
-    );
+  const metaKinds = [...plan.fullKinds];
+  for (const [kind, kindPlan] of plan.projectedKinds) {
+    if (kindPlan.includeMeta) metaKinds.push(kind);
   }
-  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 (metaKinds.length === 0) {
+    return columns.map((col) => sql`NULL AS ${sql.raw(col)}`);
   }
-  if (ast.offset !== void 0) {
-    parts.push(sql`OFFSET ${ast.offset}`);
+  if (metaKinds.length === plan.fullKinds.length + plan.projectedKinds.size) {
+    return columns.map((col) => sql`${sql.raw(`${alias}.${col}`)}`);
   }
-  return parts.length > 0 ? sql.join(parts, sql` `) : void 0;
+  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)}`
+  );
 }
-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`);
+function buildFullPropsColumn(alias, plan) {
+  if (plan.projectedKinds.size === 0) {
+    return sql`${sql.raw(`${alias}.props`)} AS props`;
   }
-  if (name.length > MAX_IDENTIFIER_LENGTH) {
-    throw new ConfigurationError(
-      `${label} table name exceeds maximum length of ${MAX_IDENTIFIER_LENGTH} characters`
-    );
+  if (plan.fullKinds.length === 0) {
+    return sql`NULL AS props`;
   }
-  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.`
-    );
+  const filter = compileKindFilter(sql.raw(`${alias}.kind`), plan.fullKinds);
+  return sql`CASE WHEN ${filter} THEN ${sql.raw(`${alias}.props`)} ELSE NULL END AS props`;
+}
+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)}`
+      );
+    }
   }
+  return columns;
 }
-function quoteIdentifier2(name) {
-  return `"${name.replaceAll('"', '""')}"`;
+function applyProjectedFields(target, row, kindPlan) {
+  for (const fieldPlan of kindPlan.propertyFields) {
+    target[fieldPlan.field] = decodeSelectedValue(
+      row[fieldPlan.outputName],
+      fieldPlan.typeInfo
+    );
+  }
 }
-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",
@@ -4701,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) {
@@ -4719,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 = {
@@ -4740,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) {
@@ -4760,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 = {
@@ -4782,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) {
@@ -4938,6 +5475,10 @@ var FieldAccessTracker = class {
   #fields = /* @__PURE__ */ new Map();
   record(alias, field2, isSystemField) {
     const key = `${alias}\0${field2}`;
+    const existing = this.#fields.get(key);
+    if (existing !== void 0 && existing.isSystemField && !isSystemField) {
+      return;
+    }
     this.#fields.set(key, { alias, field: field2, isSystemField });
   }
   getAccessedFields() {
@@ -5164,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;
@@ -5389,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`);
   }
@@ -6361,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;
@@ -6399,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 {
@@ -6619,6 +7181,10 @@ var ExecutableQuery = class _ExecutableQuery {
   #recordOrderByFieldsForPagination(tracker) {
     for (const spec of this.#state.orderBy) {
       const field2 = spec.field;
+      if (field2.path.length === 1 && field2.path[0] !== "props" && field2.jsonPointer === void 0) {
+        tracker.record(field2.alias, field2.path[0], true);
+        continue;
+      }
       if (field2.path.length !== 1 || field2.path[0] !== "props") {
         return false;
       }
@@ -6659,7 +7225,19 @@ var ExecutableQuery = class _ExecutableQuery {
       const alias = spec.field.alias;
       const jsonPointer2 = spec.field.jsonPointer;
       if (jsonPointer2 === void 0) {
-        throw new MissingSelectiveFieldError(alias, "orderBy");
+        if (spec.field.path.length !== 1) {
+          throw new MissingSelectiveFieldError(alias, "orderBy");
+        }
+        const fieldName = spec.field.path[0];
+        const outputName2 = outputNameByAliasField.get(
+          `${alias}\0${fieldName}`
+        );
+        if (outputName2 === void 0) {
+          throw new MissingSelectiveFieldError(alias, fieldName);
+        }
+        const aliasObject2 = this.#getOrCreateAliasObject(cursorContext, alias);
+        aliasObject2[fieldName] = nullToUndefined(row[outputName2]);
+        continue;
       }
       const segments = parseJsonPointer(jsonPointer2);
       if (segments.length === 0) {
@@ -6682,14 +7260,7 @@ var ExecutableQuery = class _ExecutableQuery {
           continue;
         }
       }
-      let aliasObject;
-      const existing = cursorContext[alias];
-      if (typeof existing === "object" && existing !== null) {
-        aliasObject = existing;
-      } else {
-        aliasObject = {};
-        cursorContext[alias] = aliasObject;
-      }
+      const aliasObject = this.#getOrCreateAliasObject(cursorContext, alias);
       const kindNames = this.#getNodeKindNamesForAlias(alias);
       const typeInfo = kindNames ? this.#config.schemaIntrospector.getSharedFieldTypeInfo(
         kindNames,
@@ -6716,6 +7287,15 @@ var ExecutableQuery = class _ExecutableQuery {
     }
     return cursorContext;
   }
+  #getOrCreateAliasObject(cursorContext, alias) {
+    const existing = cursorContext[alias];
+    if (typeof existing === "object" && existing !== null) {
+      return existing;
+    }
+    const created = {};
+    cursorContext[alias] = created;
+    return created;
+  }
   #getNodeKindNamesForAlias(alias) {
     if (alias === this.#state.startAlias) {
       return this.#state.startKinds;
@@ -7543,9 +8123,12 @@ var QueryBuilder = class _QueryBuilder {
    * Orders results.
    */
   orderBy(alias, field2, direction = "asc") {
-    const kindNames = this.#getKindNamesForAlias(alias);
-    const typeInfo = kindNames ? this.#config.schemaIntrospector.getSharedFieldTypeInfo(kindNames, field2) : void 0;
-    const orderSpec = {
+    const isSystem = field2 === "id" || field2 === "kind";
+    const typeInfo = isSystem ? void 0 : this.#getOrderByTypeInfo(alias, field2);
+    const orderSpec = isSystem ? {
+      field: fieldRef(alias, [field2], { valueType: "string" }),
+      direction
+    } : {
       field: fieldRef(alias, ["props"], {
         jsonPointer: jsonPointer([field2]),
         valueType: typeInfo?.valueType,
@@ -7559,6 +8142,10 @@ var QueryBuilder = class _QueryBuilder {
     };
     return new _QueryBuilder(this.#config, newState);
   }
+  #getOrderByTypeInfo(alias, field2) {
+    const kindNames = this.#getKindNamesForAlias(alias);
+    return kindNames ? this.#config.schemaIntrospector.getSharedFieldTypeInfo(kindNames, field2) : void 0;
+  }
   /**
    * Limits the number of results.
    */
@@ -8032,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
@@ -9252,67 +9862,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];
@@ -11186,142 +11735,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 {
@@ -11525,6 +11938,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.
@@ -11550,6 +12003,7 @@ var Store = class {
    */
   async subgraph(rootId, options) {
     return executeSubgraph({
+      graph: this.#graph,
       graphId: this.graphId,
       rootId,
       backend: this.#backend,
@@ -11729,6 +12183,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