@nicia-ai/typegraph 0.21.0 → 0.22.0

package/dist/index.cjs

@@ -3,7 +3,7 @@
 var chunkHRNQ3DVJ_cjs = require('./chunk-HRNQ3DVJ.cjs');
 var chunkWRWVWKQL_cjs = require('./chunk-WRWVWKQL.cjs');
 var chunkO5PST6TB_cjs = require('./chunk-O5PST6TB.cjs');
-var chunkFQCQM3KG_cjs = require('./chunk-FQCQM3KG.cjs');
+var chunk3JK66E3I_cjs = require('./chunk-3JK66E3I.cjs');
 var chunkUVZHTBZ5_cjs = require('./chunk-UVZHTBZ5.cjs');
 var zod = require('zod');
 var drizzleOrm = require('drizzle-orm');
@@ -1930,9 +1930,9 @@ function validateTableName(name, label) {
   if (!name || name.length === 0) {
     throw new chunkO5PST6TB_cjs.ConfigurationError(`${label} table name cannot be empty`);
   }
-  if (name.length > chunkFQCQM3KG_cjs.MAX_PG_IDENTIFIER_LENGTH) {
+  if (name.length > chunk3JK66E3I_cjs.MAX_PG_IDENTIFIER_LENGTH) {
     throw new chunkO5PST6TB_cjs.ConfigurationError(
-      `${label} table name exceeds maximum length of ${chunkFQCQM3KG_cjs.MAX_PG_IDENTIFIER_LENGTH} characters`
+      `${label} table name exceeds maximum length of ${chunk3JK66E3I_cjs.MAX_PG_IDENTIFIER_LENGTH} characters`
     );
   }
   if (!VALID_IDENTIFIER_PATTERN.test(name)) {
@@ -2104,6 +2104,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 ? drizzleOrm.sql`NOT MATERIALIZED ` : drizzleOrm.sql``;
   const kindFilter = compileKindFilter(drizzleOrm.sql.raw("kind"), kinds);
   const temporalFilter = input.temporalFilterPass.forAlias();
   const cteContext = { ...ctx, cteColumnPrefix: "" };
@@ -2118,14 +2119,19 @@ function buildStandardStartCte(input) {
     ...predicateClauses
   ];
   const effectiveRequiredColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(alias) ?? EMPTY_REQUIRED_COLUMNS : void 0;
+  const limitClause = input.limitOffset === void 0 ? drizzleOrm.sql`` : input.limitOffset.offset === void 0 ? drizzleOrm.sql`
+        LIMIT ${input.limitOffset.limit}
+      ` : drizzleOrm.sql`
+      LIMIT ${input.limitOffset.limit} OFFSET ${input.limitOffset.offset}
+    `;
   return drizzleOrm.sql`
-    cte_${drizzleOrm.sql.raw(alias)} AS (
+    cte_${drizzleOrm.sql.raw(alias)} AS ${cteMaterialization}(
       SELECT ${drizzleOrm.sql.join(
     compileNodeSelectColumns(void 0, alias, effectiveRequiredColumns),
     drizzleOrm.sql`, `
   )}
       FROM ${ctx.schema.nodesTable}
-      WHERE ${drizzleOrm.sql.join(whereClauses, drizzleOrm.sql` AND `)}
+      WHERE ${drizzleOrm.sql.join(whereClauses, drizzleOrm.sql` AND `)}${limitClause}
     )
   `;
 }
@@ -2189,7 +2195,7 @@ function buildStandardTraversalCte(input) {
     ...compileEdgeSelectColumns("e", edgeAlias, requiredEdgeColumns),
     ...compileNodeSelectColumns("n", nodeAlias, requiredNodeColumns)
   ];
-  const cteMaterialization = materializeCte ? drizzleOrm.sql`MATERIALIZED ` : drizzleOrm.sql``;
+  const cteMaterialization = materializeCte ? drizzleOrm.sql`MATERIALIZED ` : ctx.dialect.capabilities.emitNotMaterializedHint ? drizzleOrm.sql`NOT MATERIALIZED ` : drizzleOrm.sql``;
   function compileTraversalBranch(branch) {
     const whereClauses = [
       ...baseWhereClauses,
@@ -3170,7 +3176,7 @@ function lowerComposableQueryToLogicalPlanNode(query, dialect, graphId, nextPlan
       nextPlanNodeId
     });
   }
-  const dialectAdapter = chunkFQCQM3KG_cjs.getDialect(dialect);
+  const dialectAdapter = chunk3JK66E3I_cjs.getDialect(dialect);
   const vectorPredicate = runVectorPredicatePass(
     query,
     dialectAdapter
@@ -4000,9 +4006,9 @@ function truncateToBytes(value, maxBytes) {
 }
 function projectionAlias(entityPrefix, kind, field2) {
   const prefix = entityPrefix === "node" ? "sg_n" : "sg_e";
-  const hash = chunkFQCQM3KG_cjs.fnv1aBase36(`${kind}\0${field2}`);
+  const hash = chunk3JK66E3I_cjs.fnv1aBase36(`${kind}\0${field2}`);
   const fixedBytes = prefix.length + 1 + 1 + hash.length;
-  const maxKindBytes = chunkFQCQM3KG_cjs.MAX_PG_IDENTIFIER_LENGTH - fixedBytes;
+  const maxKindBytes = chunk3JK66E3I_cjs.MAX_PG_IDENTIFIER_LENGTH - fixedBytes;
   const truncatedKind = truncateToBytes(kind, maxKindBytes);
   return `${prefix}_${truncatedKind}_${hash}`;
 }
@@ -5245,7 +5251,7 @@ function compileSetOperation2(op, graphId, options = "sqlite") {
   );
 }
 function resolveDialectAdapter(dialect, fulltextStrategy) {
-  const baseAdapter = chunkFQCQM3KG_cjs.getDialect(dialect);
+  const baseAdapter = chunk3JK66E3I_cjs.getDialect(dialect);
   if (fulltextStrategy === void 0 || fulltextStrategy === baseAdapter.fulltext) {
     return baseAdapter;
   }
@@ -5279,8 +5285,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)) {
@@ -5289,26 +5297,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) {
@@ -5316,15 +5333,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;
@@ -5350,34 +5375,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 = [
     drizzleOrm.sql`e.graph_id = ${graphId}`,
     compileKindFilter(drizzleOrm.sql.raw("e.kind"), edgeKinds),
     compileKindFilter(drizzleOrm.sql.raw(`e.${joinKindField}`), previousNodeKinds),
     compileKindFilter(drizzleOrm.sql.raw(`e.${targetKindField}`), nodeKinds),
-    compileKindFilter(drizzleOrm.sql.raw("n.kind"), nodeKinds),
     edgeTemporalFilter,
-    nodeTemporalFilter,
-    ...nodePredicateClauses,
-    ...edgePredicateClauses
+    ...edgePredicateClauses,
+    // INNER JOIN mode: node-side filters in WHERE constrain every aggregate.
+    ...requiresNodeJoin && useInnerJoin ? [
+      compileKindFilter(drizzleOrm.sql.raw("n.kind"), nodeKinds),
+      nodeTemporalFilter,
+      ...nodePredicateClauses
+    ] : []
   ];
+  const nodeJoinOnClauses = requiresNodeJoin ? useInnerJoin ? (
+    // INNER JOIN: only the key conditions; filters live in WHERE.
+    [
+      drizzleOrm.sql`n.graph_id = e.graph_id`,
+      drizzleOrm.sql`n.id = e.${drizzleOrm.sql.raw(targetField)}`,
+      drizzleOrm.sql`n.kind = e.${drizzleOrm.sql.raw(targetKindField)}`
+    ]
+  ) : [
+    drizzleOrm.sql`n.graph_id = e.graph_id`,
+    drizzleOrm.sql`n.id = e.${drizzleOrm.sql.raw(targetField)}`,
+    drizzleOrm.sql`n.kind = e.${drizzleOrm.sql.raw(targetKindField)}`,
+    compileKindFilter(drizzleOrm.sql.raw("n.kind"), nodeKinds),
+    nodeTemporalFilter
+  ] : [];
   const aggregateColumns = [];
-  if (requiresCount) {
-    aggregateColumns.push(drizzleOrm.sql`COUNT(n.id) AS ${drizzleOrm.sql.raw(countColumn)}`);
+  if (requiresNodeCount) {
+    aggregateColumns.push(drizzleOrm.sql`COUNT(n.id) AS ${drizzleOrm.sql.raw(nodeCountColumn)}`);
+  }
+  if (requiresNodeCountDistinct) {
+    aggregateColumns.push(
+      drizzleOrm.sql`COUNT(DISTINCT n.id) AS ${drizzleOrm.sql.raw(nodeCountDistinctColumn)}`
+    );
+  }
+  if (requiresEdgeCount) {
+    aggregateColumns.push(drizzleOrm.sql`COUNT(e.id) AS ${drizzleOrm.sql.raw(edgeCountColumn)}`);
   }
-  if (requiresCountDistinct) {
+  if (requiresEdgeCountDistinct) {
     aggregateColumns.push(
-      drizzleOrm.sql`COUNT(DISTINCT n.id) AS ${drizzleOrm.sql.raw(countDistinctColumn)}`
+      drizzleOrm.sql`COUNT(DISTINCT e.id) AS ${drizzleOrm.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 ? drizzleOrm.sql`
+        ${drizzleOrm.sql.raw(targetNodeJoinKeyword)} ${ctx.schema.nodesTable} n ON ${drizzleOrm.sql.join(nodeJoinOnClauses, drizzleOrm.sql` AND `)}
+      ` : drizzleOrm.sql``;
   const countCte = drizzleOrm.sql`
     ${drizzleOrm.sql.raw(countCteAlias)} AS (
       SELECT
@@ -5386,16 +5445,20 @@ function compileCountAggregateFastPath(ast, graphId, ctx, logicalPlan, requiredC
         ${drizzleOrm.sql.join(aggregateColumns, drizzleOrm.sql`, `)}
       FROM cte_${drizzleOrm.sql.raw(previousAlias)}
       JOIN ${ctx.schema.edgesTable} e ON cte_${drizzleOrm.sql.raw(previousAlias)}.${drizzleOrm.sql.raw(previousAliasIdColumn)} = e.${drizzleOrm.sql.raw(joinField)}
-        AND cte_${drizzleOrm.sql.raw(previousAlias)}.${drizzleOrm.sql.raw(previousAliasKindColumn)} = e.${drizzleOrm.sql.raw(joinKindField)}
-      JOIN ${ctx.schema.nodesTable} n ON n.graph_id = e.graph_id
-        AND n.id = e.${drizzleOrm.sql.raw(targetField)}
-        AND n.kind = e.${drizzleOrm.sql.raw(targetKindField)}
+        AND cte_${drizzleOrm.sql.raw(previousAlias)}.${drizzleOrm.sql.raw(previousAliasKindColumn)} = e.${drizzleOrm.sql.raw(joinKindField)}${targetNodeJoin}
       WHERE ${drizzleOrm.sql.join(whereClauses, drizzleOrm.sql` AND `)}
       GROUP BY
         cte_${drizzleOrm.sql.raw(previousAlias)}.${drizzleOrm.sql.raw(previousAliasIdColumn)},
         cte_${drizzleOrm.sql.raw(previousAlias)}.${drizzleOrm.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 = drizzleOrm.sql.join(
     ast.projection.fields.map((projectedField) => {
       const source = projectedField.source;
@@ -5408,7 +5471,7 @@ function compileCountAggregateFastPath(ast, graphId, ctx, logicalPlan, requiredC
         );
         return drizzleOrm.sql`${value} AS ${quoteIdentifier2(projectedField.outputName)}`;
       }
-      const projectedCountColumn = source.function === "countDistinct" ? countDistinctColumn : countColumn;
+      const projectedCountColumn = resolveCountColumn(source);
       const countValue = drizzleOrm.sql`${drizzleOrm.sql.raw(countCteAlias)}.${drizzleOrm.sql.raw(projectedCountColumn)}`;
       const aggregateValue = traversal.optional ? drizzleOrm.sql`COALESCE(${countValue}, 0)` : countValue;
       return drizzleOrm.sql`${aggregateValue} AS ${quoteIdentifier2(projectedField.outputName)}`;
@@ -5423,19 +5486,29 @@ function compileCountAggregateFastPath(ast, graphId, ctx, logicalPlan, requiredC
       AND ${drizzleOrm.sql.raw(countCteAlias)}.${drizzleOrm.sql.raw(previousAliasKindColumn)} = cte_${drizzleOrm.sql.raw(previousAlias)}.${drizzleOrm.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
 };
@@ -5776,14 +5849,14 @@ function generateId() {
 
 // src/utils/path.ts
 function parseSqlitePath(path) {
-  const emptyPath = `${chunkFQCQM3KG_cjs.SQLITE_PATH_DELIMITER}${chunkFQCQM3KG_cjs.SQLITE_PATH_DELIMITER}`;
+  const emptyPath = `${chunk3JK66E3I_cjs.SQLITE_PATH_DELIMITER}${chunk3JK66E3I_cjs.SQLITE_PATH_DELIMITER}`;
   if (!path || path === emptyPath) return [];
   const trimmed = path.slice(1, -1);
   if (trimmed === "") return [];
-  return trimmed.split(chunkFQCQM3KG_cjs.SQLITE_PATH_DELIMITER);
+  return trimmed.split(chunk3JK66E3I_cjs.SQLITE_PATH_DELIMITER);
 }
 function isSqlitePath(value) {
-  return typeof value === "string" && value.startsWith(chunkFQCQM3KG_cjs.SQLITE_PATH_DELIMITER) && value.endsWith(chunkFQCQM3KG_cjs.SQLITE_PATH_DELIMITER);
+  return typeof value === "string" && value.startsWith(chunk3JK66E3I_cjs.SQLITE_PATH_DELIMITER) && value.endsWith(chunk3JK66E3I_cjs.SQLITE_PATH_DELIMITER);
 }
 function normalizePath(value) {
   if (Array.isArray(value)) {
@@ -5798,12 +5871,12 @@ function normalizePath(value) {
   return [];
 }
 function isPostgresTextArray(value) {
-  return typeof value === "string" && value.startsWith(chunkFQCQM3KG_cjs.PG_ARRAY_START) && value.endsWith(chunkFQCQM3KG_cjs.PG_ARRAY_END);
+  return typeof value === "string" && value.startsWith(chunk3JK66E3I_cjs.PG_ARRAY_START) && value.endsWith(chunk3JK66E3I_cjs.PG_ARRAY_END);
 }
 function parsePostgresTextArray(value) {
   const inner = value.slice(1, -1);
   if (inner === "") return [];
-  return inner.split(chunkFQCQM3KG_cjs.PG_PATH_ELEMENT_SEPARATOR);
+  return inner.split(chunk3JK66E3I_cjs.PG_PATH_ELEMENT_SEPARATOR);
 }
 
 // src/query/execution/result-mapper.ts
@@ -6040,7 +6113,7 @@ async function* createStreamIterable(batchSize, paginate) {
   }
 }
 function getStreamBatchSize(options) {
-  return options?.batchSize ?? chunkFQCQM3KG_cjs.DEFAULT_STREAM_BATCH_SIZE;
+  return options?.batchSize ?? chunk3JK66E3I_cjs.DEFAULT_STREAM_BATCH_SIZE;
 }
 
 // src/query/execution/field-tracker.ts
@@ -6122,7 +6195,7 @@ function createNodeTrackingProxy(alias, kindNames, tracker, options) {
           return getPlaceholderForSystemField(property, options.mode);
         }
         if (property === "meta") {
-          for (const key of chunkFQCQM3KG_cjs.NODE_META_KEYS) {
+          for (const key of chunk3JK66E3I_cjs.NODE_META_KEYS) {
             tracker.record(alias, `meta.${key}`, true);
           }
           return buildNodeMetaPlaceholder(options.mode);
@@ -6155,7 +6228,7 @@ function createEdgeTrackingProxy(alias, edgeKindNames, tracker, options) {
           return getPlaceholderForSystemField(property, options.mode);
         }
         if (property === "meta") {
-          for (const key of chunkFQCQM3KG_cjs.EDGE_META_KEYS) {
+          for (const key of chunk3JK66E3I_cjs.EDGE_META_KEYS) {
             tracker.record(alias, `meta.${key}`, true);
           }
           return buildEdgeMetaPlaceholder(options.mode);
@@ -6924,7 +6997,7 @@ function substituteParameters(ast, bindings) {
   };
 }
 function fillPlaceholders(params, bindings, dialect) {
-  const adapter = chunkFQCQM3KG_cjs.getDialect(dialect);
+  const adapter = chunk3JK66E3I_cjs.getDialect(dialect);
   return params.map((parameter) => {
     if (parameter instanceof drizzleOrm.Placeholder) {
       const name = parameter.name;
@@ -8019,7 +8092,7 @@ var ExecutableQuery = class _ExecutableQuery {
       );
     }
     const isBackward = options.last !== void 0 || options.before !== void 0;
-    const limit = options.first ?? options.last ?? chunkFQCQM3KG_cjs.DEFAULT_PAGINATION_LIMIT;
+    const limit = options.first ?? options.last ?? chunk3JK66E3I_cjs.DEFAULT_PAGINATION_LIMIT;
     const cursor = options.after ?? options.before;
     let cursorData;
     if (cursor) {
@@ -9360,6 +9433,12 @@ function countDistinct(alias, field2) {
     }
   };
 }
+function countEdges(edgeAlias) {
+  return count(edgeAlias);
+}
+function countDistinctEdges(edgeAlias) {
+  return countDistinct(edgeAlias);
+}
 function sum(alias, field2) {
   return {
     __type: "aggregate",
@@ -9765,7 +9844,7 @@ function createGraphAlgorithms(params) {
   const ctx = {
     graphId: params.graphId,
     backend: params.backend,
-    dialect: chunkFQCQM3KG_cjs.getDialect(params.backend.dialect),
+    dialect: chunk3JK66E3I_cjs.getDialect(params.backend.dialect),
     schema: params.schema ?? (params.backend.tableNames ? createSqlSchema(params.backend.tableNames) : createSqlSchema()),
     defaultTemporalMode: params.defaultTemporalMode
   };
@@ -13495,7 +13574,7 @@ var Store = class {
       graphId: this.graphId,
       rootId,
       backend: this.#backend,
-      dialect: chunkFQCQM3KG_cjs.getDialect(this.#backend.dialect),
+      dialect: chunk3JK66E3I_cjs.getDialect(this.#backend.dialect),
       schema: this.#schema,
       options
     });
@@ -13807,11 +13886,11 @@ Object.defineProperty(exports, "isUserRecoverable", {
 });
 Object.defineProperty(exports, "fts5Strategy", {
   enumerable: true,
-  get: function () { return chunkFQCQM3KG_cjs.fts5Strategy; }
+  get: function () { return chunk3JK66E3I_cjs.fts5Strategy; }
 });
 Object.defineProperty(exports, "tsvectorStrategy", {
   enumerable: true,
-  get: function () { return chunkFQCQM3KG_cjs.tsvectorStrategy; }
+  get: function () { return chunk3JK66E3I_cjs.tsvectorStrategy; }
 });
 Object.defineProperty(exports, "DEFAULT_SEARCHABLE_LANGUAGE", {
   enumerable: true,
@@ -13876,6 +13955,8 @@ exports.composeFragments = composeFragments;
 exports.core = core;
 exports.count = count;
 exports.countDistinct = countDistinct;
+exports.countDistinctEdges = countDistinctEdges;
+exports.countEdges = countEdges;
 exports.createExternalRef = createExternalRef;
 exports.createFragment = createFragment;
 exports.createQueryBuilder = createQueryBuilder;