@nicia-ai/typegraph 0.22.0 → 0.24.0

package/dist/index.cjs

@@ -1,7 +1,9 @@
 'use strict';
 
+var chunkHTGDWIDE_cjs = require('./chunk-HTGDWIDE.cjs');
 var chunkHRNQ3DVJ_cjs = require('./chunk-HRNQ3DVJ.cjs');
 var chunkWRWVWKQL_cjs = require('./chunk-WRWVWKQL.cjs');
+var chunkRNUNP5JD_cjs = require('./chunk-RNUNP5JD.cjs');
 var chunkO5PST6TB_cjs = require('./chunk-O5PST6TB.cjs');
 var chunk3JK66E3I_cjs = require('./chunk-3JK66E3I.cjs');
 var chunkUVZHTBZ5_cjs = require('./chunk-UVZHTBZ5.cjs');
@@ -1941,7 +1943,7 @@ function validateTableName(name, label) {
     );
   }
 }
-function quoteIdentifier(name) {
+function quoteIdentifier2(name) {
   return `"${name.replaceAll('"', '""')}"`;
 }
 function createSqlSchema(names = {}) {
@@ -1952,10 +1954,10 @@ function createSqlSchema(names = {}) {
   validateTableName(tables.fulltext, "fulltext");
   return {
     tables,
-    nodesTable: drizzleOrm.sql.raw(quoteIdentifier(tables.nodes)),
-    edgesTable: drizzleOrm.sql.raw(quoteIdentifier(tables.edges)),
-    embeddingsTable: drizzleOrm.sql.raw(quoteIdentifier(tables.embeddings)),
-    fulltextTable: drizzleOrm.sql.raw(quoteIdentifier(tables.fulltext))
+    nodesTable: drizzleOrm.sql.raw(quoteIdentifier2(tables.nodes)),
+    edgesTable: drizzleOrm.sql.raw(quoteIdentifier2(tables.edges)),
+    embeddingsTable: drizzleOrm.sql.raw(quoteIdentifier2(tables.embeddings)),
+    fulltextTable: drizzleOrm.sql.raw(quoteIdentifier2(tables.fulltext))
   };
 }
 var DEFAULT_SQL_SCHEMA = createSqlSchema();
@@ -1993,76 +1995,6 @@ function compileTypedJsonExtract(input) {
     }
   }
 }
-var NODE_COLUMNS = [
-  "id",
-  "kind",
-  "props",
-  "version",
-  "valid_from",
-  "valid_to",
-  "created_at",
-  "updated_at",
-  "deleted_at"
-];
-var EDGE_COLUMNS = [
-  "id",
-  "kind",
-  "from_id",
-  "to_id",
-  "props",
-  "valid_from",
-  "valid_to",
-  "created_at",
-  "updated_at",
-  "deleted_at"
-];
-var EMPTY_REQUIRED_COLUMNS = /* @__PURE__ */ new Set();
-function quoteIdentifier2(identifier) {
-  return drizzleOrm.sql.raw(`"${identifier.replaceAll('"', '""')}"`);
-}
-function shouldProjectColumn(requiredColumns, column, alwaysRequiredColumns) {
-  if (alwaysRequiredColumns?.has(column)) return true;
-  if (requiredColumns === void 0) return true;
-  return requiredColumns.has(column);
-}
-function addRequiredColumn(requiredColumnsByAlias, alias, column) {
-  const existing = requiredColumnsByAlias.get(alias);
-  if (existing) {
-    existing.add(column);
-    return;
-  }
-  requiredColumnsByAlias.set(alias, /* @__PURE__ */ new Set([column]));
-}
-function markFieldRefAsRequired(requiredColumnsByAlias, field2) {
-  const column = field2.path[0];
-  if (column === void 0) return;
-  addRequiredColumn(requiredColumnsByAlias, field2.alias, column);
-}
-function mapSelectiveSystemFieldToColumn(field2) {
-  if (field2 === "fromId") return "from_id";
-  if (field2 === "toId") return "to_id";
-  if (field2.startsWith("meta.")) {
-    return field2.slice(5).replaceAll(/([A-Z])/g, "_$1").toLowerCase();
-  }
-  return field2;
-}
-function markSelectiveFieldAsRequired(requiredColumnsByAlias, field2) {
-  if (field2.isSystemField) {
-    addRequiredColumn(
-      requiredColumnsByAlias,
-      field2.alias,
-      mapSelectiveSystemFieldToColumn(field2.field)
-    );
-    return;
-  }
-  addRequiredColumn(requiredColumnsByAlias, field2.alias, "props");
-}
-function isIdFieldRef(field2) {
-  return field2.path.length === 1 && field2.path[0] === "id" && field2.jsonPointer === void 0;
-}
-function isAggregateExpr(source) {
-  return "__type" in source && source.__type === "aggregate";
-}
 
 // src/query/compiler/emitter/standard-builders.ts
 function compileColumnReference(tableAlias, column) {
@@ -2072,7 +2004,7 @@ function compileColumnReference(tableAlias, column) {
   return drizzleOrm.sql`${drizzleOrm.sql.raw(tableAlias)}.${drizzleOrm.sql.raw(column)}`;
 }
 function qualifyColumn(owner, name) {
-  return drizzleOrm.sql`${quoteIdentifier2(owner)}.${quoteIdentifier2(name)}`;
+  return drizzleOrm.sql`${chunkHTGDWIDE_cjs.quoteIdentifier(owner)}.${chunkHTGDWIDE_cjs.quoteIdentifier(name)}`;
 }
 var SCOPED_RELEVANCE_NODES_ALIAS = "scoped_relevance_nodes";
 function buildScopedNodeIdsSubquery(nodeAlias) {
@@ -2082,20 +2014,20 @@ function buildScopedNodeIdsSubquery(nodeAlias) {
         SELECT DISTINCT
           ${qualifyColumn(cteAlias, `${nodeAlias}_id`)} AS node_id,
           ${qualifyColumn(cteAlias, `${nodeAlias}_kind`)} AS node_kind
-        FROM ${quoteIdentifier2(cteAlias)}
+        FROM ${chunkHTGDWIDE_cjs.quoteIdentifier(cteAlias)}
       ) AS ${drizzleOrm.sql.raw(SCOPED_RELEVANCE_NODES_ALIAS)}
   `;
 }
 function compileNodeSelectColumns(tableAlias, alias, requiredColumns) {
-  return NODE_COLUMNS.filter(
-    (column) => column === "id" || column === "kind" || shouldProjectColumn(requiredColumns, column)
+  return chunkHTGDWIDE_cjs.NODE_COLUMNS.filter(
+    (column) => column === "id" || column === "kind" || chunkHTGDWIDE_cjs.shouldProjectColumn(requiredColumns, column)
   ).map(
     (column) => drizzleOrm.sql`${compileColumnReference(tableAlias, column)} AS ${drizzleOrm.sql.raw(`${alias}_${column}`)}`
   );
 }
 function compileEdgeSelectColumns(tableAlias, alias, requiredColumns) {
-  return EDGE_COLUMNS.filter(
-    (column) => shouldProjectColumn(requiredColumns, column)
+  return chunkHTGDWIDE_cjs.EDGE_COLUMNS.filter(
+    (column) => chunkHTGDWIDE_cjs.shouldProjectColumn(requiredColumns, column)
   ).map(
     (column) => drizzleOrm.sql`${compileColumnReference(tableAlias, column)} AS ${drizzleOrm.sql.raw(`${alias}_${column}`)}`
   );
@@ -2118,7 +2050,7 @@ function buildStandardStartCte(input) {
     temporalFilter,
     ...predicateClauses
   ];
-  const effectiveRequiredColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(alias) ?? EMPTY_REQUIRED_COLUMNS : void 0;
+  const effectiveRequiredColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(alias) ?? chunkHTGDWIDE_cjs.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`
@@ -2184,8 +2116,8 @@ function buildStandardTraversalCte(input) {
   const previousAlias = traversal.joinFromAlias;
   const edgeAlias = traversal.edgeAlias;
   const nodeAlias = traversal.nodeAlias;
-  const requiredNodeColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(nodeAlias) ?? EMPTY_REQUIRED_COLUMNS : void 0;
-  const requiredEdgeColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(edgeAlias) ?? EMPTY_REQUIRED_COLUMNS : void 0;
+  const requiredNodeColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(nodeAlias) ?? chunkHTGDWIDE_cjs.EMPTY_REQUIRED_COLUMNS : void 0;
+  const requiredEdgeColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(edgeAlias) ?? chunkHTGDWIDE_cjs.EMPTY_REQUIRED_COLUMNS : void 0;
   const previousRowColumns = carryForwardPreviousColumns ? [drizzleOrm.sql`cte_${drizzleOrm.sql.raw(previousAlias)}.*`] : [
     drizzleOrm.sql`cte_${drizzleOrm.sql.raw(previousAlias)}.${drizzleOrm.sql.raw(previousAlias)}_id AS ${drizzleOrm.sql.raw(previousAlias)}_id`,
     drizzleOrm.sql`cte_${drizzleOrm.sql.raw(previousAlias)}.${drizzleOrm.sql.raw(previousAlias)}_kind AS ${drizzleOrm.sql.raw(previousAlias)}_kind`
@@ -2317,7 +2249,7 @@ function compileAggregateExprFromSource(expr, dialect) {
   }
 }
 function compileProjectedSource(field2, dialect) {
-  if (isAggregateExpr(field2.source)) {
+  if (chunkHTGDWIDE_cjs.isAggregateExpr(field2.source)) {
     return compileAggregateExprFromSource(field2.source, dialect);
   }
   const cteAlias = field2.cteAlias ?? `cte_${field2.source.alias}`;
@@ -2344,7 +2276,7 @@ function buildStandardProjection(input) {
   }
   const projectedFields = fields.map((field2) => {
     const source = compileProjectedSource(field2, dialect);
-    return drizzleOrm.sql`${source} AS ${quoteIdentifier2(field2.outputName)}`;
+    return drizzleOrm.sql`${source} AS ${chunkHTGDWIDE_cjs.quoteIdentifier(field2.outputName)}`;
   });
   return drizzleOrm.sql.join(projectedFields, drizzleOrm.sql`, `);
 }
@@ -2363,8 +2295,8 @@ function compileSelectiveProjection(fields, dialect, ast, collapsedTraversalCteA
   const columns = fields.map((field2) => {
     const cteAlias = collapsedTraversalCteAlias ?? aliasToCte.get(field2.alias) ?? `cte_${field2.alias}`;
     if (field2.isSystemField) {
-      const dbColumn = mapSelectiveSystemFieldToColumn(field2.field);
-      return drizzleOrm.sql`${drizzleOrm.sql.raw(cteAlias)}.${drizzleOrm.sql.raw(`${field2.alias}_${dbColumn}`)} AS ${quoteIdentifier2(field2.outputName)}`;
+      const dbColumn = chunkHTGDWIDE_cjs.mapSelectiveSystemFieldToColumn(field2.field);
+      return drizzleOrm.sql`${drizzleOrm.sql.raw(cteAlias)}.${drizzleOrm.sql.raw(`${field2.alias}_${dbColumn}`)} AS ${chunkHTGDWIDE_cjs.quoteIdentifier(field2.outputName)}`;
     }
     const propsColumn = `${field2.alias}_props`;
     const column = drizzleOrm.sql`${drizzleOrm.sql.raw(cteAlias)}.${drizzleOrm.sql.raw(propsColumn)}`;
@@ -2375,7 +2307,7 @@ function compileSelectiveProjection(fields, dialect, ast, collapsedTraversalCteA
       pointer,
       valueType: field2.valueType
     });
-    return drizzleOrm.sql`${extracted} AS ${quoteIdentifier2(field2.outputName)}`;
+    return drizzleOrm.sql`${extracted} AS ${chunkHTGDWIDE_cjs.quoteIdentifier(field2.outputName)}`;
   });
   return drizzleOrm.sql.join(columns, drizzleOrm.sql`, `);
 }
@@ -3445,8 +3377,8 @@ function compileRecursiveCte(ast, traversal, graphId, ctx, requiredColumnsByAlia
   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 requiredStartColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(startAlias) ?? chunkHTGDWIDE_cjs.EMPTY_REQUIRED_COLUMNS : void 0;
+  const requiredNodeColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(nodeAlias) ?? chunkHTGDWIDE_cjs.EMPTY_REQUIRED_COLUMNS : void 0;
   const startColumnsFromBase = compileNodeSelectColumnsFromTable(
     "n0",
     startAlias,
@@ -3642,30 +3574,30 @@ function collectRequiredColumnsByAlias(ast, traversal) {
   const previousNodeKinds = [
     .../* @__PURE__ */ new Set([...ast.start.kinds, ...traversal.nodeKinds])
   ];
-  addRequiredColumn(requiredColumnsByAlias, traversal.nodeAlias, "id");
+  chunkHTGDWIDE_cjs.addRequiredColumn(requiredColumnsByAlias, traversal.nodeAlias, "id");
   if (previousNodeKinds.length > 1) {
-    addRequiredColumn(requiredColumnsByAlias, traversal.nodeAlias, "kind");
+    chunkHTGDWIDE_cjs.addRequiredColumn(requiredColumnsByAlias, traversal.nodeAlias, "kind");
   }
   for (const field2 of selectiveFields) {
-    markSelectiveFieldAsRequired(requiredColumnsByAlias, field2);
+    chunkHTGDWIDE_cjs.markSelectiveFieldAsRequired(requiredColumnsByAlias, field2);
   }
   if (ast.orderBy) {
     for (const orderSpec of ast.orderBy) {
-      markFieldRefAsRequired(requiredColumnsByAlias, orderSpec.field);
+      chunkHTGDWIDE_cjs.markFieldRefAsRequired(requiredColumnsByAlias, orderSpec.field);
     }
   }
   return requiredColumnsByAlias;
 }
 function compileNodeSelectColumnsFromTable(tableAlias, alias, requiredColumns, alwaysRequiredColumns) {
-  return NODE_COLUMNS.filter(
-    (column) => shouldProjectColumn(requiredColumns, column, alwaysRequiredColumns)
+  return chunkHTGDWIDE_cjs.NODE_COLUMNS.filter(
+    (column) => chunkHTGDWIDE_cjs.shouldProjectColumn(requiredColumns, column, alwaysRequiredColumns)
   ).map(
     (column) => drizzleOrm.sql`${drizzleOrm.sql.raw(tableAlias)}.${drizzleOrm.sql.raw(column)} AS ${drizzleOrm.sql.raw(`${alias}_${column}`)}`
   );
 }
 function compileNodeSelectColumnsFromRecursiveRow(alias, requiredColumns, alwaysRequiredColumns) {
-  return NODE_COLUMNS.filter(
-    (column) => shouldProjectColumn(requiredColumns, column, alwaysRequiredColumns)
+  return chunkHTGDWIDE_cjs.NODE_COLUMNS.filter(
+    (column) => chunkHTGDWIDE_cjs.shouldProjectColumn(requiredColumns, column, alwaysRequiredColumns)
   ).map((column) => {
     const projected = `${alias}_${column}`;
     return drizzleOrm.sql`r.${drizzleOrm.sql.raw(projected)} AS ${drizzleOrm.sql.raw(projected)}`;
@@ -3706,10 +3638,10 @@ function compileRecursiveProjection(ast, traversal, dialect) {
     drizzleOrm.sql`${drizzleOrm.sql.raw(nodeAlias)}_deleted_at`
   ];
   if (vl.depthAlias !== void 0) {
-    fields.push(drizzleOrm.sql`depth AS ${quoteIdentifier2(vl.depthAlias)}`);
+    fields.push(drizzleOrm.sql`depth AS ${chunkHTGDWIDE_cjs.quoteIdentifier(vl.depthAlias)}`);
   }
   if (vl.pathAlias !== void 0) {
-    fields.push(drizzleOrm.sql`path AS ${quoteIdentifier2(vl.pathAlias)}`);
+    fields.push(drizzleOrm.sql`path AS ${chunkHTGDWIDE_cjs.quoteIdentifier(vl.pathAlias)}`);
   }
   return drizzleOrm.sql.join(fields, drizzleOrm.sql`, `);
 }
@@ -3722,8 +3654,8 @@ function compileRecursiveSelectiveProjection(fields, ast, traversal, dialect) {
       );
     }
     if (field2.isSystemField) {
-      const dbColumn = mapSelectiveSystemFieldToColumn(field2.field);
-      return drizzleOrm.sql`${drizzleOrm.sql.raw(`${field2.alias}_${dbColumn}`)} AS ${quoteIdentifier2(field2.outputName)}`;
+      const dbColumn = chunkHTGDWIDE_cjs.mapSelectiveSystemFieldToColumn(field2.field);
+      return drizzleOrm.sql`${drizzleOrm.sql.raw(`${field2.alias}_${dbColumn}`)} AS ${chunkHTGDWIDE_cjs.quoteIdentifier(field2.outputName)}`;
     }
     const column = drizzleOrm.sql.raw(`${field2.alias}_props`);
     const extracted = compileTypedJsonExtract({
@@ -3732,14 +3664,14 @@ function compileRecursiveSelectiveProjection(fields, ast, traversal, dialect) {
       pointer: chunkUVZHTBZ5_cjs.jsonPointer([field2.field]),
       valueType: field2.valueType
     });
-    return drizzleOrm.sql`${extracted} AS ${quoteIdentifier2(field2.outputName)}`;
+    return drizzleOrm.sql`${extracted} AS ${chunkHTGDWIDE_cjs.quoteIdentifier(field2.outputName)}`;
   });
   const vl = traversal.variableLength;
   if (vl.depthAlias !== void 0) {
-    columns.push(drizzleOrm.sql`depth AS ${quoteIdentifier2(vl.depthAlias)}`);
+    columns.push(drizzleOrm.sql`depth AS ${chunkHTGDWIDE_cjs.quoteIdentifier(vl.depthAlias)}`);
   }
   if (vl.pathAlias !== void 0) {
-    columns.push(drizzleOrm.sql`path AS ${quoteIdentifier2(vl.pathAlias)}`);
+    columns.push(drizzleOrm.sql`path AS ${chunkHTGDWIDE_cjs.quoteIdentifier(vl.pathAlias)}`);
   }
   return drizzleOrm.sql.join(columns, drizzleOrm.sql`, `);
 }
@@ -4254,7 +4186,7 @@ function buildProjectedPropertyColumns(alias, plan, dialect) {
         valueType: fieldPlan.typeInfo?.valueType
       });
       columns.push(
-        drizzleOrm.sql`CASE WHEN ${drizzleOrm.sql.raw(alias)}.kind = ${kind} THEN ${extracted} ELSE NULL END AS ${quoteIdentifier2(fieldPlan.outputName)}`
+        drizzleOrm.sql`CASE WHEN ${drizzleOrm.sql.raw(alias)}.kind = ${kind} THEN ${extracted} ELSE NULL END AS ${chunkHTGDWIDE_cjs.quoteIdentifier(fieldPlan.outputName)}`
       );
     }
   }
@@ -4839,7 +4771,7 @@ function isColumnPruningEnabled(ast) {
 function markPredicateFieldsAsRequired(requiredColumnsByAlias, expression) {
   switch (expression.__type) {
     case "comparison": {
-      markFieldRefAsRequired(requiredColumnsByAlias, expression.left);
+      chunkHTGDWIDE_cjs.markFieldRefAsRequired(requiredColumnsByAlias, expression.left);
       return;
     }
     case "string_op":
@@ -4847,7 +4779,7 @@ function markPredicateFieldsAsRequired(requiredColumnsByAlias, expression) {
     case "between":
     case "array_op":
     case "object_op": {
-      markFieldRefAsRequired(requiredColumnsByAlias, expression.field);
+      chunkHTGDWIDE_cjs.markFieldRefAsRequired(requiredColumnsByAlias, expression.field);
       return;
     }
     case "and":
@@ -4865,22 +4797,22 @@ function markPredicateFieldsAsRequired(requiredColumnsByAlias, expression) {
       return;
     }
     case "aggregate_comparison": {
-      markFieldRefAsRequired(
+      chunkHTGDWIDE_cjs.markFieldRefAsRequired(
         requiredColumnsByAlias,
         expression.aggregate.field
       );
       return;
     }
     case "in_subquery": {
-      markFieldRefAsRequired(requiredColumnsByAlias, expression.field);
+      chunkHTGDWIDE_cjs.markFieldRefAsRequired(requiredColumnsByAlias, expression.field);
       return;
     }
     case "vector_similarity": {
-      markFieldRefAsRequired(requiredColumnsByAlias, expression.field);
+      chunkHTGDWIDE_cjs.markFieldRefAsRequired(requiredColumnsByAlias, expression.field);
       return;
     }
     case "fulltext_match": {
-      markFieldRefAsRequired(requiredColumnsByAlias, expression.field);
+      chunkHTGDWIDE_cjs.markFieldRefAsRequired(requiredColumnsByAlias, expression.field);
       return;
     }
     case "exists": {
@@ -4890,33 +4822,33 @@ function markPredicateFieldsAsRequired(requiredColumnsByAlias, expression) {
 }
 function collectRequiredColumnsByAlias2(ast) {
   const requiredColumnsByAlias = /* @__PURE__ */ new Map();
-  addRequiredColumn(requiredColumnsByAlias, ast.start.alias, "id");
+  chunkHTGDWIDE_cjs.addRequiredColumn(requiredColumnsByAlias, ast.start.alias, "id");
   for (const traversal of ast.traversals) {
-    addRequiredColumn(requiredColumnsByAlias, traversal.nodeAlias, "id");
+    chunkHTGDWIDE_cjs.addRequiredColumn(requiredColumnsByAlias, traversal.nodeAlias, "id");
   }
   if (ast.selectiveFields && ast.selectiveFields.length > 0) {
     for (const field2 of ast.selectiveFields) {
-      markSelectiveFieldAsRequired(requiredColumnsByAlias, field2);
+      chunkHTGDWIDE_cjs.markSelectiveFieldAsRequired(requiredColumnsByAlias, field2);
     }
   } else {
     for (const projectedField of ast.projection.fields) {
       const source = projectedField.source;
       if (source.__type === "field_ref") {
-        markFieldRefAsRequired(requiredColumnsByAlias, source);
+        chunkHTGDWIDE_cjs.markFieldRefAsRequired(requiredColumnsByAlias, source);
       } else {
-        addRequiredColumn(requiredColumnsByAlias, source.field.alias, "id");
-        markFieldRefAsRequired(requiredColumnsByAlias, source.field);
+        chunkHTGDWIDE_cjs.addRequiredColumn(requiredColumnsByAlias, source.field.alias, "id");
+        chunkHTGDWIDE_cjs.markFieldRefAsRequired(requiredColumnsByAlias, source.field);
       }
     }
   }
   if (ast.groupBy) {
     for (const field2 of ast.groupBy.fields) {
-      markFieldRefAsRequired(requiredColumnsByAlias, field2);
+      chunkHTGDWIDE_cjs.markFieldRefAsRequired(requiredColumnsByAlias, field2);
     }
   }
   if (ast.orderBy) {
     for (const orderSpec of ast.orderBy) {
-      markFieldRefAsRequired(requiredColumnsByAlias, orderSpec.field);
+      chunkHTGDWIDE_cjs.markFieldRefAsRequired(requiredColumnsByAlias, orderSpec.field);
     }
   }
   if (ast.having) {
@@ -4930,7 +4862,7 @@ function collectRequiredColumnsByAlias2(ast) {
 function hasIdEqualityPredicate(expression, alias) {
   switch (expression.__type) {
     case "comparison": {
-      return expression.op === "eq" && expression.left.alias === alias && isIdFieldRef(expression.left);
+      return expression.op === "eq" && expression.left.alias === alias && chunkHTGDWIDE_cjs.isIdFieldRef(expression.left);
     }
     case "and": {
       return expression.predicates.some(
@@ -5282,7 +5214,7 @@ function resolveCountAggregateFastPath(ast) {
     return void 0;
   }
   const groupField = ast.groupBy.fields[0];
-  if (groupField.alias !== ast.start.alias || !isIdFieldRef(groupField)) {
+  if (groupField.alias !== ast.start.alias || !chunkHTGDWIDE_cjs.isIdFieldRef(groupField)) {
     return void 0;
   }
   let requiresNodeCount = false;
@@ -5291,13 +5223,13 @@ function resolveCountAggregateFastPath(ast) {
   let requiresEdgeCountDistinct = false;
   for (const projectedField of ast.projection.fields) {
     const source = projectedField.source;
-    if (!isAggregateExpr(source)) {
+    if (!chunkHTGDWIDE_cjs.isAggregateExpr(source)) {
       if (source.alias !== ast.start.alias) {
         return void 0;
       }
       continue;
     }
-    if (!isIdFieldRef(source.field)) {
+    if (!chunkHTGDWIDE_cjs.isIdFieldRef(source.field)) {
       return void 0;
     }
     const isNodeTarget = source.field.alias === traversal.nodeAlias;
@@ -5462,19 +5394,19 @@ function compileCountAggregateFastPath(ast, graphId, ctx, logicalPlan, requiredC
   const projection = drizzleOrm.sql.join(
     ast.projection.fields.map((projectedField) => {
       const source = projectedField.source;
-      if (!isAggregateExpr(source)) {
+      if (!chunkHTGDWIDE_cjs.isAggregateExpr(source)) {
         const value = compileFieldValue(
           source,
           dialect,
           source.valueType,
           `cte_${source.alias}`
         );
-        return drizzleOrm.sql`${value} AS ${quoteIdentifier2(projectedField.outputName)}`;
+        return drizzleOrm.sql`${value} AS ${chunkHTGDWIDE_cjs.quoteIdentifier(projectedField.outputName)}`;
       }
       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)}`;
+      return drizzleOrm.sql`${aggregateValue} AS ${chunkHTGDWIDE_cjs.quoteIdentifier(projectedField.outputName)}`;
     }),
     drizzleOrm.sql`, `
   );
@@ -12784,17 +12716,17 @@ async function rebuildFulltextIndex(ctx, nodeKind, options) {
       if (remaining > 0 && pageResult.skippedIds.length > 0) {
         skippedIds.push(...pageResult.skippedIds.slice(0, remaining));
       }
-      await backend.transaction(async (tx) => {
+      const writePage = async (target) => {
         if (pageResult.toUpsert.length > 0) {
-          if (tx.upsertFulltextBatch) {
-            await tx.upsertFulltextBatch({
+          if (target.upsertFulltextBatch) {
+            await target.upsertFulltextBatch({
               graphId: ctx.graphId,
               nodeKind: kind,
               rows: pageResult.toUpsert
             });
-          } else if (tx.upsertFulltext) {
+          } else if (target.upsertFulltext) {
             for (const item of pageResult.toUpsert) {
-              await tx.upsertFulltext({
+              await target.upsertFulltext({
                 graphId: ctx.graphId,
                 nodeKind: kind,
                 nodeId: item.nodeId,
@@ -12805,15 +12737,15 @@ async function rebuildFulltextIndex(ctx, nodeKind, options) {
           }
         }
         if (pageResult.toDelete.length > 0) {
-          if (tx.deleteFulltextBatch) {
-            await tx.deleteFulltextBatch({
+          if (target.deleteFulltextBatch) {
+            await target.deleteFulltextBatch({
               graphId: ctx.graphId,
               nodeKind: kind,
               nodeIds: pageResult.toDelete
             });
-          } else if (tx.deleteFulltext) {
+          } else if (target.deleteFulltext) {
             for (const nodeId of pageResult.toDelete) {
-              await tx.deleteFulltext({
+              await target.deleteFulltext({
                 graphId: ctx.graphId,
                 nodeKind: kind,
                 nodeId
@@ -12821,7 +12753,8 @@ async function rebuildFulltextIndex(ctx, nodeKind, options) {
             }
           }
         }
-      });
+      };
+      await chunkRNUNP5JD_cjs.runOptionallyInTransaction(backend, writePage);
       processed += rows.length;
       upserted += pageResult.toUpsert.length;
       cleared += pageResult.toDelete.length;
@@ -13503,12 +13436,19 @@ var Store = class {
   }
   // === Batch Query Execution ===
   /**
-   * Executes multiple queries over a single connection with snapshot consistency.
+   * Executes multiple queries and returns a typed tuple of results.
+   *
+   * Each query preserves its own result type, projection, filtering, sorting,
+   * and pagination.
    *
-   * 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.
+   * **Snapshot consistency is conditional.** When
+   * `backend.capabilities.transactions` is `true`, queries run sequentially
+   * on a single connection inside an implicit transaction and observe the
+   * same database snapshot. When transactions are unavailable
+   * (Cloudflare D1, `drizzle-orm/neon-http`), queries run sequentially over
+   * independent connections and may observe writes that landed between them.
+   * Branch on `backend.capabilities.transactions` if you need a guaranteed
+   * snapshot.
    *
    * Read-only — use `bulkCreate`, `bulkInsert`, etc. for write batching.
    *
@@ -13532,10 +13472,10 @@ var Store = class {
    * @returns A tuple with per-query typed results, preserving input order
    */
   async batch(...queries) {
-    return this.#backend.transaction(async (txBackend) => {
+    return chunkRNUNP5JD_cjs.runOptionallyInTransaction(this.#backend, async (target) => {
       const results = [];
       for (const query of queries) {
-        const result = await query.executeOn(txBackend);
+        const result = await query.executeOn(target);
         results.push(result);
       }
       return results;
@@ -13599,8 +13539,26 @@ var Store = class {
    *   );
    * });
    * ```
+   *
+   * **Backends without transactions.** When `backend.capabilities.transactions`
+   * is `false` (Cloudflare D1, `drizzle-orm/neon-http`), this method runs the
+   * callback against the same backend used outside `transaction()` — writes
+   * are applied as they happen and a thrown error does **not** roll back
+   * earlier writes inside the callback. Branch on
+   * `backend.capabilities.transactions` if you require atomicity:
+   *
+   * ```typescript
+   * if (backend.capabilities.transactions) {
+   *   await store.transaction(async (tx) => { ... });
+   * } else {
+   *   // sequential, non-atomic — handle partial-failure recovery yourself
+   * }
+   * ```
    */
   async transaction(fn) {
+    if (!this.#backend.capabilities.transactions) {
+      return fn({ nodes: this.nodes, edges: this.edges });
+    }
     return this.#backend.transaction(async (txBackend) => {
       const txNodeOperations = {
         ...this.#nodeOperations,
@@ -13648,6 +13606,36 @@ var Store = class {
     this.#search = void 0;
   }
   // === Lifecycle ===
+  /**
+   * Refreshes the backend's query-planner statistics.
+   *
+   * Call this once after a large initial import or bulk backfill. The
+   * planner uses table statistics to choose between TypeGraph's
+   * multi-column indexes; without fresh stats a forward traversal can
+   * pick a reverse index and run an order of magnitude slower than
+   * needed. Autovacuum / background statistics will catch up
+   * eventually, but calling this explicitly after a bulk load gives
+   * you correct latencies immediately.
+   *
+   * Implementations:
+   * - SQLite runs `ANALYZE`, populating `sqlite_stat1`
+   * - PostgreSQL runs `ANALYZE` on the TypeGraph-managed tables
+   *
+   * Costs a few tens of milliseconds at the sizes this library is
+   * designed for. Safe to call at any time.
+   *
+   * @example
+   * ```typescript
+   * // After a bulk import
+   * for (const batch of batches) {
+   *   await store.nodes.Document.bulkCreate(batch);
+   * }
+   * await store.refreshStatistics();
+   * ```
+   */
+  async refreshStatistics() {
+    await this.#backend.refreshStatistics();
+  }
   /**
    * Closes the store and releases underlying resources.
    *