@nicia-ai/typegraph 0.21.0 → 0.22.0

package/dist/index.d.cts

@@ -480,6 +480,50 @@ declare function count(alias: string, field?: string): AggregateExpr;
  * @param field - Optional field to count distinct values of
  */
 declare function countDistinct(alias: string, field?: string): AggregateExpr;
+/**
+ * Creates a COUNT aggregate expression over an edge alias.
+ *
+ * Counts edges directly, without joining back to the target node table.
+ * This has different semantics from `count(targetAlias)`:
+ *
+ * - `countEdges(edgeAlias)` — counts live edges, regardless of target-node
+ *   temporal state. If a target node's `validTo` is in the past while its
+ *   incident edges are still live, those edges are still counted.
+ * - `count(targetAlias)` — counts edges whose target node is currently
+ *   valid under the query's temporal mode.
+ *
+ * For the common case ("how many follow relationships does this user
+ * have?") the edge-count semantics is what you want, and the compiler
+ * can skip the target-node join entirely — measurably faster on
+ * full-graph aggregates where the join dominates cost.
+ *
+ * @example
+ * ```typescript
+ * store
+ *   .query()
+ *   .from("User", "u")
+ *   .optionalTraverse("follows", "e", { expand: "none" })
+ *   .to("User", "target")
+ *   .groupByNode("u")
+ *   .aggregate({
+ *     name: field("u", "name"),
+ *     // counts edges — skips the target-node join
+ *     followCount: countEdges("e"),
+ *   })
+ *   .execute();
+ * ```
+ */
+declare function countEdges(edgeAlias: string): AggregateExpr;
+/**
+ * Creates a COUNT DISTINCT aggregate expression over an edge alias.
+ * See {@link countEdges} for semantics.
+ *
+ * Distinct-on-edge-id is equivalent to `countEdges` when the query
+ * surface produces each edge exactly once, but stays meaningful under
+ * polymorphic expansions and ontology-driven edge fan-outs where the
+ * same edge can appear multiple times in the join output.
+ */
+declare function countDistinctEdges(edgeAlias: string): AggregateExpr;
 /**
  * Creates a SUM aggregate expression.
  *
@@ -722,4 +766,4 @@ type IdConfig = Readonly<{
     edgeIdGenerator: IdGenerator;
 }>;
 
-export { AliasMap, type DefineEdgeOptions, type DefineNodeOptions, EdgeType, type ExternalRefSchema, type ExternalRefValue, FieldRef, type FlexibleQueryFragment, GraphDef, type IdConfig, type IdGenerator, InferenceType, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, MetaEdge, type MetaEdgeOptions, NodeType, OntologyRelation, QueryBuilder, type QueryFragment, type TraversalFragment, avg, broader, composeFragments, core, count, countDistinct, createExternalRef, createFragment, createQueryBuilder, defineEdge, defineNode, differentFrom, disjointWith, equivalentTo, externalRef, field, generateId, getExternalRefTable, hasPart, having, havingEq, havingGt, havingGte, havingLt, havingLte, implies, inverseOf, isExternalRefSchema, limitFragment, max, metaEdge, min, narrower, offsetFragment, orderByFragment, partOf, relatedTo, sameAs, subClassOf, sum };
+export { AliasMap, type DefineEdgeOptions, type DefineNodeOptions, EdgeType, type ExternalRefSchema, type ExternalRefValue, FieldRef, type FlexibleQueryFragment, GraphDef, type IdConfig, type IdGenerator, InferenceType, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, MetaEdge, type MetaEdgeOptions, NodeType, OntologyRelation, QueryBuilder, type QueryFragment, type TraversalFragment, avg, broader, composeFragments, core, count, countDistinct, countDistinctEdges, countEdges, createExternalRef, createFragment, createQueryBuilder, defineEdge, defineNode, differentFrom, disjointWith, equivalentTo, externalRef, field, generateId, getExternalRefTable, hasPart, having, havingEq, havingGt, havingGte, havingLt, havingLte, implies, inverseOf, isExternalRefSchema, limitFragment, max, metaEdge, min, narrower, offsetFragment, orderByFragment, partOf, relatedTo, sameAs, subClassOf, sum };

package/dist/index.d.ts

@@ -480,6 +480,50 @@ declare function count(alias: string, field?: string): AggregateExpr;
  * @param field - Optional field to count distinct values of
  */
 declare function countDistinct(alias: string, field?: string): AggregateExpr;
+/**
+ * Creates a COUNT aggregate expression over an edge alias.
+ *
+ * Counts edges directly, without joining back to the target node table.
+ * This has different semantics from `count(targetAlias)`:
+ *
+ * - `countEdges(edgeAlias)` — counts live edges, regardless of target-node
+ *   temporal state. If a target node's `validTo` is in the past while its
+ *   incident edges are still live, those edges are still counted.
+ * - `count(targetAlias)` — counts edges whose target node is currently
+ *   valid under the query's temporal mode.
+ *
+ * For the common case ("how many follow relationships does this user
+ * have?") the edge-count semantics is what you want, and the compiler
+ * can skip the target-node join entirely — measurably faster on
+ * full-graph aggregates where the join dominates cost.
+ *
+ * @example
+ * ```typescript
+ * store
+ *   .query()
+ *   .from("User", "u")
+ *   .optionalTraverse("follows", "e", { expand: "none" })
+ *   .to("User", "target")
+ *   .groupByNode("u")
+ *   .aggregate({
+ *     name: field("u", "name"),
+ *     // counts edges — skips the target-node join
+ *     followCount: countEdges("e"),
+ *   })
+ *   .execute();
+ * ```
+ */
+declare function countEdges(edgeAlias: string): AggregateExpr;
+/**
+ * Creates a COUNT DISTINCT aggregate expression over an edge alias.
+ * See {@link countEdges} for semantics.
+ *
+ * Distinct-on-edge-id is equivalent to `countEdges` when the query
+ * surface produces each edge exactly once, but stays meaningful under
+ * polymorphic expansions and ontology-driven edge fan-outs where the
+ * same edge can appear multiple times in the join output.
+ */
+declare function countDistinctEdges(edgeAlias: string): AggregateExpr;
 /**
  * Creates a SUM aggregate expression.
  *
@@ -722,4 +766,4 @@ type IdConfig = Readonly<{
     edgeIdGenerator: IdGenerator;
 }>;
 
-export { AliasMap, type DefineEdgeOptions, type DefineNodeOptions, EdgeType, type ExternalRefSchema, type ExternalRefValue, FieldRef, type FlexibleQueryFragment, GraphDef, type IdConfig, type IdGenerator, InferenceType, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, MetaEdge, type MetaEdgeOptions, NodeType, OntologyRelation, QueryBuilder, type QueryFragment, type TraversalFragment, avg, broader, composeFragments, core, count, countDistinct, createExternalRef, createFragment, createQueryBuilder, defineEdge, defineNode, differentFrom, disjointWith, equivalentTo, externalRef, field, generateId, getExternalRefTable, hasPart, having, havingEq, havingGt, havingGte, havingLt, havingLte, implies, inverseOf, isExternalRefSchema, limitFragment, max, metaEdge, min, narrower, offsetFragment, orderByFragment, partOf, relatedTo, sameAs, subClassOf, sum };
+export { AliasMap, type DefineEdgeOptions, type DefineNodeOptions, EdgeType, type ExternalRefSchema, type ExternalRefValue, FieldRef, type FlexibleQueryFragment, GraphDef, type IdConfig, type IdGenerator, InferenceType, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, MetaEdge, type MetaEdgeOptions, NodeType, OntologyRelation, QueryBuilder, type QueryFragment, type TraversalFragment, avg, broader, composeFragments, core, count, countDistinct, countDistinctEdges, countEdges, createExternalRef, createFragment, createQueryBuilder, defineEdge, defineNode, differentFrom, disjointWith, equivalentTo, externalRef, field, generateId, getExternalRefTable, hasPart, having, havingEq, havingGt, havingGte, havingLt, havingLte, implies, inverseOf, isExternalRefSchema, limitFragment, max, metaEdge, min, narrower, offsetFragment, orderByFragment, partOf, relatedTo, sameAs, subClassOf, sum };

package/dist/index.js

@@ -4,8 +4,8 @@ import { NODE_TYPE_BRAND, EDGE_TYPE_BRAND, nowIso, validateOptionalIsoDate, getN
 export { defineGraph, getEdgeKinds, getNodeKinds, isEdgeType, isEdgeTypeWithEndpoints, isGraphDef, isNodeType } from './chunk-RS5OLGEW.js';
 import { ConfigurationError, UnsupportedPredicateError, ValidationError, CompilerInvariantError, KindNotFoundError, DatabaseOperationError, EdgeNotFoundError, NodeConstraintNotFoundError, RestrictedDeleteError, NodeNotFoundError, EndpointNotFoundError, UniquenessError, CardinalityError, EndpointError, DisjointError } from './chunk-WFMTAEEN.js';
 export { BackendDisposedError, CardinalityError, CompilerInvariantError, ConfigurationError, DatabaseOperationError, DisjointError, EdgeNotFoundError, EndpointError, EndpointNotFoundError, KindNotFoundError, MigrationError, NodeConstraintNotFoundError, NodeNotFoundError, RestrictedDeleteError, SchemaMismatchError, TypeGraphError, UniquenessError, UnsupportedPredicateError, ValidationError, VersionConflictError, getErrorSuggestion, isConstraintError, isSystemError, isTypeGraphError, isUserRecoverable } from './chunk-WFMTAEEN.js';
-import { MAX_PG_IDENTIFIER_LENGTH, DEFAULT_PAGINATION_LIMIT, getDialect, DEFAULT_STREAM_BATCH_SIZE, NODE_META_KEYS, EDGE_META_KEYS, SQLITE_PATH_DELIMITER, PG_ARRAY_START, PG_ARRAY_END, PG_PATH_ELEMENT_SEPARATOR, fnv1aBase36 } from './chunk-4XNE2JG3.js';
-export { fts5Strategy, tsvectorStrategy } from './chunk-4XNE2JG3.js';
+import { MAX_PG_IDENTIFIER_LENGTH, DEFAULT_PAGINATION_LIMIT, getDialect, DEFAULT_STREAM_BATCH_SIZE, NODE_META_KEYS, EDGE_META_KEYS, SQLITE_PATH_DELIMITER, PG_ARRAY_START, PG_ARRAY_END, PG_PATH_ELEMENT_SEPARATOR, fnv1aBase36 } from './chunk-753F33CV.js';
+export { fts5Strategy, tsvectorStrategy } from './chunk-753F33CV.js';
 import { jsonPointer, parseJsonPointer, createSchemaIntrospector, normalizeJsonPointer, joinJsonPointers, resolveFieldTypeInfoAtJsonPointer, getSearchableMetadata, DEFAULT_SEARCHABLE_LANGUAGE, getEmbeddingDimensions, isEmbeddingSchema } from './chunk-EYELZHKY.js';
 export { DEFAULT_SEARCHABLE_LANGUAGE, MAX_JSON_POINTER_DEPTH, embedding, getEmbeddingDimensions, getSearchableMetadata, isEmbeddingSchema, isSearchableSchema, joinJsonPointers, jsonPointer, normalizeJsonPointer, parseJsonPointer, searchable } from './chunk-EYELZHKY.js';
 import { z } from 'zod';
@@ -2107,6 +2107,7 @@ function buildStandardStartCte(input) {
   const { ast, ctx, graphId, predicateIndex, requiredColumnsByAlias } = input;
   const alias = ast.start.alias;
   const kinds = ast.start.kinds;
+  const cteMaterialization = ctx.dialect.capabilities.emitNotMaterializedHint ? sql`NOT MATERIALIZED ` : sql``;
   const kindFilter = compileKindFilter(sql.raw("kind"), kinds);
   const temporalFilter = input.temporalFilterPass.forAlias();
   const cteContext = { ...ctx, cteColumnPrefix: "" };
@@ -2121,14 +2122,19 @@ function buildStandardStartCte(input) {
     ...predicateClauses
   ];
   const effectiveRequiredColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(alias) ?? EMPTY_REQUIRED_COLUMNS : void 0;
+  const limitClause = input.limitOffset === void 0 ? sql`` : input.limitOffset.offset === void 0 ? sql`
+        LIMIT ${input.limitOffset.limit}
+      ` : sql`
+      LIMIT ${input.limitOffset.limit} OFFSET ${input.limitOffset.offset}
+    `;
   return sql`
-    cte_${sql.raw(alias)} AS (
+    cte_${sql.raw(alias)} AS ${cteMaterialization}(
       SELECT ${sql.join(
     compileNodeSelectColumns(void 0, alias, effectiveRequiredColumns),
     sql`, `
   )}
       FROM ${ctx.schema.nodesTable}
-      WHERE ${sql.join(whereClauses, sql` AND `)}
+      WHERE ${sql.join(whereClauses, sql` AND `)}${limitClause}
     )
   `;
 }
@@ -2192,7 +2198,7 @@ function buildStandardTraversalCte(input) {
     ...compileEdgeSelectColumns("e", edgeAlias, requiredEdgeColumns),
     ...compileNodeSelectColumns("n", nodeAlias, requiredNodeColumns)
   ];
-  const cteMaterialization = materializeCte ? sql`MATERIALIZED ` : sql``;
+  const cteMaterialization = materializeCte ? sql`MATERIALIZED ` : ctx.dialect.capabilities.emitNotMaterializedHint ? sql`NOT MATERIALIZED ` : sql``;
   function compileTraversalBranch(branch) {
     const whereClauses = [
       ...baseWhereClauses,
@@ -5282,8 +5288,10 @@ function resolveCountAggregateFastPath(ast) {
   if (groupField.alias !== ast.start.alias || !isIdFieldRef(groupField)) {
     return void 0;
   }
-  let requiresCount = false;
-  let requiresCountDistinct = false;
+  let requiresNodeCount = false;
+  let requiresNodeCountDistinct = false;
+  let requiresEdgeCount = false;
+  let requiresEdgeCountDistinct = false;
   for (const projectedField of ast.projection.fields) {
     const source = projectedField.source;
     if (!isAggregateExpr(source)) {
@@ -5292,26 +5300,35 @@ function resolveCountAggregateFastPath(ast) {
       }
       continue;
     }
-    if (source.field.alias !== traversal.nodeAlias || !isIdFieldRef(source.field)) {
+    if (!isIdFieldRef(source.field)) {
+      return void 0;
+    }
+    const isNodeTarget = source.field.alias === traversal.nodeAlias;
+    const isEdgeTarget = source.field.alias === traversal.edgeAlias;
+    if (!isNodeTarget && !isEdgeTarget) {
       return void 0;
     }
     if (source.function === "count") {
-      requiresCount = true;
+      if (isNodeTarget) requiresNodeCount = true;
+      else requiresEdgeCount = true;
       continue;
     }
     if (source.function === "countDistinct") {
-      requiresCountDistinct = true;
+      if (isNodeTarget) requiresNodeCountDistinct = true;
+      else requiresEdgeCountDistinct = true;
       continue;
     }
     return void 0;
   }
-  if (!requiresCount && !requiresCountDistinct) {
+  if (!requiresNodeCount && !requiresNodeCountDistinct && !requiresEdgeCount && !requiresEdgeCountDistinct) {
     return void 0;
   }
   return {
     traversal,
-    requiresCount,
-    requiresCountDistinct
+    requiresNodeCount,
+    requiresNodeCountDistinct,
+    requiresEdgeCount,
+    requiresEdgeCountDistinct
   };
 }
 function compileCountAggregateFastPath(ast, graphId, ctx, logicalPlan, requiredColumnsByAlias, predicateIndex, temporalFilterPass) {
@@ -5319,15 +5336,23 @@ function compileCountAggregateFastPath(ast, graphId, ctx, logicalPlan, requiredC
   if (!plan) {
     return void 0;
   }
-  const { traversal, requiresCount, requiresCountDistinct } = plan;
+  const {
+    traversal,
+    requiresNodeCount,
+    requiresNodeCountDistinct,
+    requiresEdgeCount,
+    requiresEdgeCountDistinct
+  } = plan;
   const { dialect } = ctx;
   const startAlias = ast.start.alias;
   const previousAlias = traversal.joinFromAlias;
   const previousAliasIdColumn = `${previousAlias}_id`;
   const previousAliasKindColumn = `${previousAlias}_kind`;
   const countCteAlias = `cte_${traversal.nodeAlias}_counts`;
-  const countColumn = `${traversal.nodeAlias}_count`;
-  const countDistinctColumn = `${traversal.nodeAlias}_count_distinct`;
+  const nodeCountColumn = `${traversal.nodeAlias}_count`;
+  const nodeCountDistinctColumn = `${traversal.nodeAlias}_count_distinct`;
+  const edgeCountColumn = `${traversal.edgeAlias}_count`;
+  const edgeCountDistinctColumn = `${traversal.edgeAlias}_count_distinct`;
   const previousNodeKinds = getNodeKindsForAlias(ast, traversal.joinFromAlias);
   const edgeKinds = [...new Set(traversal.edgeKinds)];
   const nodeKinds = traversal.nodeKinds;
@@ -5353,34 +5378,68 @@ function compileCountAggregateFastPath(ast, graphId, ctx, logicalPlan, requiredC
   const targetField = traversal.direction === "out" ? "to_id" : "from_id";
   const joinKindField = traversal.direction === "out" ? "from_kind" : "to_kind";
   const targetKindField = traversal.direction === "out" ? "to_kind" : "from_kind";
+  const hasNodePredicates = nodePredicateClauses.length > 0;
+  const requiresNodeJoin = requiresNodeCount || requiresNodeCountDistinct || hasNodePredicates;
+  const useInnerJoin = hasNodePredicates;
   const whereClauses = [
     sql`e.graph_id = ${graphId}`,
     compileKindFilter(sql.raw("e.kind"), edgeKinds),
     compileKindFilter(sql.raw(`e.${joinKindField}`), previousNodeKinds),
     compileKindFilter(sql.raw(`e.${targetKindField}`), nodeKinds),
-    compileKindFilter(sql.raw("n.kind"), nodeKinds),
     edgeTemporalFilter,
-    nodeTemporalFilter,
-    ...nodePredicateClauses,
-    ...edgePredicateClauses
+    ...edgePredicateClauses,
+    // INNER JOIN mode: node-side filters in WHERE constrain every aggregate.
+    ...requiresNodeJoin && useInnerJoin ? [
+      compileKindFilter(sql.raw("n.kind"), nodeKinds),
+      nodeTemporalFilter,
+      ...nodePredicateClauses
+    ] : []
   ];
+  const nodeJoinOnClauses = requiresNodeJoin ? useInnerJoin ? (
+    // INNER JOIN: only the key conditions; filters live in WHERE.
+    [
+      sql`n.graph_id = e.graph_id`,
+      sql`n.id = e.${sql.raw(targetField)}`,
+      sql`n.kind = e.${sql.raw(targetKindField)}`
+    ]
+  ) : [
+    sql`n.graph_id = e.graph_id`,
+    sql`n.id = e.${sql.raw(targetField)}`,
+    sql`n.kind = e.${sql.raw(targetKindField)}`,
+    compileKindFilter(sql.raw("n.kind"), nodeKinds),
+    nodeTemporalFilter
+  ] : [];
   const aggregateColumns = [];
-  if (requiresCount) {
-    aggregateColumns.push(sql`COUNT(n.id) AS ${sql.raw(countColumn)}`);
+  if (requiresNodeCount) {
+    aggregateColumns.push(sql`COUNT(n.id) AS ${sql.raw(nodeCountColumn)}`);
+  }
+  if (requiresNodeCountDistinct) {
+    aggregateColumns.push(
+      sql`COUNT(DISTINCT n.id) AS ${sql.raw(nodeCountDistinctColumn)}`
+    );
+  }
+  if (requiresEdgeCount) {
+    aggregateColumns.push(sql`COUNT(e.id) AS ${sql.raw(edgeCountColumn)}`);
   }
-  if (requiresCountDistinct) {
+  if (requiresEdgeCountDistinct) {
     aggregateColumns.push(
-      sql`COUNT(DISTINCT n.id) AS ${sql.raw(countDistinctColumn)}`
+      sql`COUNT(DISTINCT e.id) AS ${sql.raw(edgeCountDistinctColumn)}`
     );
   }
+  const startCteLimit = traversal.optional && ast.orderBy === void 0 && ast.limit !== void 0 ? { limit: ast.limit, offset: ast.offset } : void 0;
   const startCte = buildStandardStartCte({
     ast,
     ctx,
     graphId,
     predicateIndex,
     requiredColumnsByAlias,
-    temporalFilterPass
+    temporalFilterPass,
+    ...startCteLimit === void 0 ? {} : { limitOffset: startCteLimit }
   });
+  const targetNodeJoinKeyword = useInnerJoin ? "JOIN" : "LEFT JOIN";
+  const targetNodeJoin = requiresNodeJoin ? sql`
+        ${sql.raw(targetNodeJoinKeyword)} ${ctx.schema.nodesTable} n ON ${sql.join(nodeJoinOnClauses, sql` AND `)}
+      ` : sql``;
   const countCte = sql`
     ${sql.raw(countCteAlias)} AS (
       SELECT
@@ -5389,16 +5448,20 @@ function compileCountAggregateFastPath(ast, graphId, ctx, logicalPlan, requiredC
         ${sql.join(aggregateColumns, sql`, `)}
       FROM cte_${sql.raw(previousAlias)}
       JOIN ${ctx.schema.edgesTable} e ON cte_${sql.raw(previousAlias)}.${sql.raw(previousAliasIdColumn)} = e.${sql.raw(joinField)}
-        AND cte_${sql.raw(previousAlias)}.${sql.raw(previousAliasKindColumn)} = e.${sql.raw(joinKindField)}
-      JOIN ${ctx.schema.nodesTable} n ON n.graph_id = e.graph_id
-        AND n.id = e.${sql.raw(targetField)}
-        AND n.kind = e.${sql.raw(targetKindField)}
+        AND cte_${sql.raw(previousAlias)}.${sql.raw(previousAliasKindColumn)} = e.${sql.raw(joinKindField)}${targetNodeJoin}
       WHERE ${sql.join(whereClauses, sql` AND `)}
       GROUP BY
         cte_${sql.raw(previousAlias)}.${sql.raw(previousAliasIdColumn)},
         cte_${sql.raw(previousAlias)}.${sql.raw(previousAliasKindColumn)}
     )
   `;
+  function resolveCountColumn(source) {
+    const isEdge = source.field.alias === traversal.edgeAlias;
+    if (source.function === "countDistinct") {
+      return isEdge ? edgeCountDistinctColumn : nodeCountDistinctColumn;
+    }
+    return isEdge ? edgeCountColumn : nodeCountColumn;
+  }
   const projection = sql.join(
     ast.projection.fields.map((projectedField) => {
       const source = projectedField.source;
@@ -5411,7 +5474,7 @@ function compileCountAggregateFastPath(ast, graphId, ctx, logicalPlan, requiredC
         );
         return sql`${value} AS ${quoteIdentifier2(projectedField.outputName)}`;
       }
-      const projectedCountColumn = source.function === "countDistinct" ? countDistinctColumn : countColumn;
+      const projectedCountColumn = resolveCountColumn(source);
       const countValue = sql`${sql.raw(countCteAlias)}.${sql.raw(projectedCountColumn)}`;
       const aggregateValue = traversal.optional ? sql`COALESCE(${countValue}, 0)` : countValue;
       return sql`${aggregateValue} AS ${quoteIdentifier2(projectedField.outputName)}`;
@@ -5426,19 +5489,29 @@ function compileCountAggregateFastPath(ast, graphId, ctx, logicalPlan, requiredC
       AND ${sql.raw(countCteAlias)}.${sql.raw(previousAliasKindColumn)} = cte_${sql.raw(previousAlias)}.${sql.raw(previousAliasKindColumn)}
   `;
   const orderBy = buildStandardOrderBy({ ast, dialect });
-  const limitOffset = buildLimitOffsetClause({
-    limit: ast.limit,
-    offset: ast.offset
-  });
+  const emittedLogicalPlan = startCteLimit === void 0 ? logicalPlan : stripLimitOffsetFromPlan(logicalPlan);
+  const limitOffset = startCteLimit === void 0 ? buildLimitOffsetClause({ limit: ast.limit, offset: ast.offset }) : void 0;
   return emitStandardQuerySql({
     ctes: [startCte, countCte],
     fromClause,
     ...orderBy === void 0 ? {} : { orderBy },
     ...limitOffset === void 0 ? {} : { limitOffset },
-    logicalPlan,
+    logicalPlan: emittedLogicalPlan,
     projection
   });
 }
+function stripLimitOffsetFromPlan(plan) {
+  return { ...plan, root: stripLimitOffsetFromPlanNode(plan.root) };
+}
+function stripLimitOffsetFromPlanNode(node) {
+  if (node.op === "limit_offset") {
+    return stripLimitOffsetFromPlanNode(node.input);
+  }
+  if ("input" in node) {
+    return { ...node, input: stripLimitOffsetFromPlanNode(node.input) };
+  }
+  return node;
+}
 var STANDARD_QUERY_STRATEGY_HANDLERS = {
   cte_project: compileStandardQueryWithCteStrategy
 };
@@ -9363,6 +9436,12 @@ function countDistinct(alias, field2) {
     }
   };
 }
+function countEdges(edgeAlias) {
+  return count(edgeAlias);
+}
+function countDistinctEdges(edgeAlias) {
+  return countDistinct(edgeAlias);
+}
 function sum(alias, field2) {
   return {
     __type: "aggregate",
@@ -13676,6 +13755,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, StoreSearch, 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 };
+export { DEFAULT_SQL_SCHEMA, ExecutableAggregateQuery, ExecutableQuery, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, PreparedQuery, QueryBuilder, StoreSearch, UnionableQuery, avg, broader, composeFragments, core, count, countDistinct, countDistinctEdges, countEdges, 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