@nicia-ai/typegraph 0.37.1 → 0.38.0

package/dist/{chunk-VKGKDOKR.js → chunk-RQPRCEIO.js}

@@ -1,101 +1,23 @@
-import { asCompiledRowsSql, createBackendOverlay, isPresent, asCompiledStatementSql, rowPropsToObject, groupBy, chunk, sqlValueList, rowPropsToJsonText } from './chunk-44TA22QT.js';
-import { validateCanonicalIsoDate, withRecordedRelationsPrecondition, nowIso } from './chunk-XGPUQ56G.js';
-import { MAX_PG_IDENTIFIER_LENGTH, sqlNull } from './chunk-OHMP6N2J.js';
+import { groupBy, chunk } from './chunk-35S6P5ZU.js';
+import { createBackendOverlay, rowPropsToObject, rowPropsToJsonText } from './chunk-PZHC5GCD.js';
+import { RECORDED_MAX } from './chunk-J6IJARLG.js';
+import { withRecordedRelationsPrecondition } from './chunk-KFLXWVUJ.js';
+import { nowIso } from './chunk-I6FX7AAG.js';
+import { MAX_PG_IDENTIFIER_LENGTH } from './chunk-2EBMPJBO.js';
+import { likeEscapeClause, LIKE_ESCAPE_CHARACTER } from './chunk-DDCIXXOO.js';
+import { typeGraphGlobalSymbol, sql, asCompiledRowsSql, isSqlFragment, asCompiledStatementSql } from './chunk-6XDBRDZE.js';
+import { resolveFieldTypeInfoAtJsonPointer } from './chunk-SNXVDZAJ.js';
+import { requireDefined, isPresent } from './chunk-QMQLUA66.js';
 import { resolveEmbeddingFields, getSearchableFields, DEFAULT_SEARCHABLE_LANGUAGE } from './chunk-PC2UBAUB.js';
-import { ConfigurationError, ValidationError, CardinalityError, EndpointError, DisjointError, UniquenessError, RestrictedDeleteError } from './chunk-5PNMDJ7J.js';
-import { sql } from 'drizzle-orm';
+import { ConfigurationError, UnsupportedPredicateError, CompilerInvariantError, CardinalityError, EndpointError, DisjointError, UniquenessError, RestrictedDeleteError } from './chunk-DPNA466P.js';
+import { normalizeJsonPointer, joinJsonPointers, jsonPointer } from './chunk-G6Q5UM7U.js';
 import { nanoid } from 'nanoid';
 
-// src/core/temporal.ts
-var RECORDED_MAX = "9999-12-31T23:59:59.999Z";
-function assertValidRecordedInstant(value, path) {
-  validateCanonicalIsoDate(value, path);
-  if (value >= RECORDED_MAX) {
-    throw new ValidationError(
-      `${path} must be before the recorded-time open sentinel ${RECORDED_MAX}.`,
-      {
-        issues: [
-          {
-            path,
-            message: `Expected a timestamp before ${RECORDED_MAX}, got "${value}"`
-          }
-        ]
-      },
-      {
-        suggestion: "Use a real recorded-time commit instant, not the open-interval sentinel."
-      }
-    );
-  }
-}
-function asRecordedInstant(value) {
-  assertValidRecordedInstant(value, "asRecordedInstant");
-  return value;
-}
-function resolveReadCoordinate(mode, asOf, suggestion) {
-  if (mode !== "asOf" && asOf !== void 0) {
-    throw new ValidationError(
-      `Temporal mode "${mode}" does not take an asOf timestamp.`,
-      {
-        issues: [
-          {
-            path: "asOf",
-            message: `asOf is only valid with mode "asOf", not "${mode}"`
-          }
-        ]
-      },
-      {
-        suggestion: 'Pin an instant with store.asOf(timestamp) or store.view({ mode: "asOf", asOf }); drop asOf for other modes.'
-      }
-    );
-  }
-  assertValidAsOf(
-    mode,
-    asOf,
-    suggestion === void 0 ? void 0 : { suggestion }
-  );
-  return { valid: asOf === void 0 ? { mode } : { mode, asOf } };
-}
-function withRecordedCoordinate(coordinate, recordedAsOf) {
-  assertValidRecordedInstant(recordedAsOf, "asOfRecorded");
-  return {
-    ...coordinate,
-    recorded: { asOf: recordedAsOf }
-  };
-}
-function assertValidAsOf(mode, asOf, options) {
-  if (mode === "asOf" && asOf === void 0) {
-    throw new ValidationError(
-      'Temporal mode "asOf" requires a timestamp',
-      {
-        issues: [
-          { path: "asOf", message: "Timestamp is required for asOf mode" }
-        ]
-      },
-      {
-        suggestion: options?.suggestion ?? 'Provide an ISO-8601 timestamp for asOf mode, e.g. "2026-01-01T00:00:00.000Z".'
-      }
-    );
-  }
-  if (asOf !== void 0) {
-    validateCanonicalIsoDate(asOf, "asOf");
-  }
-}
-function describeCoordinate(coordinate) {
-  const { mode, asOf } = coordinate.valid;
-  const valid = asOf === void 0 ? `mode "${mode}"` : `mode "${mode}" asOf ${asOf}`;
-  return coordinate.recorded === void 0 ? valid : `${valid}, recorded asOf ${coordinate.recorded.asOf}`;
-}
-function coordinateContext(coordinate) {
-  const { mode, asOf } = coordinate.valid;
-  return {
-    temporalMode: mode,
-    ...asOf !== void 0 && { asOf },
-    ...coordinate.recorded === void 0 ? {} : { recordedAsOf: coordinate.recorded.asOf }
-  };
-}
-var SqlSchemaDescriptor = class {
-  // Private field gives SqlSchema nominal identity; runtime checks use instanceof.
-  #brand = true;
+// src/query/compiler/schema.ts
+var SQL_SCHEMA_BRAND = typeGraphGlobalSymbol("sql-schema-v1");
+var SqlSchema = class {
+};
+var SqlSchemaDescriptor = class extends SqlSchema {
   tables;
   nodesTable;
   edgesTable;
@@ -105,6 +27,13 @@ var SqlSchemaDescriptor = class {
   revisionOriginsTable;
   fulltextTable;
   constructor(fields) {
+    super();
+    Object.defineProperty(this, SQL_SCHEMA_BRAND, {
+      configurable: false,
+      enumerable: false,
+      value: true,
+      writable: false
+    });
     this.tables = fields.tables;
     this.nodesTable = fields.nodesTable;
     this.edgesTable = fields.edgesTable;
@@ -113,7 +42,6 @@ var SqlSchemaDescriptor = class {
     this.recordedClockTable = fields.recordedClockTable;
     this.revisionOriginsTable = fields.revisionOriginsTable;
     this.fulltextTable = fields.fulltextTable;
-    void this.#brand;
     Object.freeze(this);
   }
 };
@@ -155,14 +83,13 @@ function validateTableName(name, label) {
     );
   }
 }
-function quoteIdentifier(name) {
-  return `"${name.replaceAll('"', '""')}"`;
-}
 function freezeSqlSchema(fields) {
   return new SqlSchemaDescriptor(fields);
 }
 function isSqlSchema(schema) {
-  return schema instanceof SqlSchemaDescriptor && Object.isFrozen(schema);
+  if (typeof schema !== "object" || schema === null) return false;
+  const candidate = schema;
+  return candidate[SQL_SCHEMA_BRAND] === true && typeof candidate["tables"] === "object" && candidate["tables"] !== null && Object.isFrozen(candidate["tables"]) && isSqlFragment(candidate["nodesTable"]) && isSqlFragment(candidate["edgesTable"]) && isSqlFragment(candidate["recordedNodesTable"]) && isSqlFragment(candidate["recordedEdgesTable"]) && isSqlFragment(candidate["recordedClockTable"]) && isSqlFragment(candidate["revisionOriginsTable"]) && isSqlFragment(candidate["fulltextTable"]) && Object.isFrozen(candidate);
 }
 function requireSqlSchema(schema, surface = "SqlSchema") {
   if (isSqlSchema(schema)) return schema;
@@ -186,20 +113,20 @@ function createSqlSchema(names = {}) {
   validateTableName(tables.uniques, "uniques");
   return freezeSqlSchema({
     tables: Object.freeze(tables),
-    nodesTable: sql.raw(quoteIdentifier(tables.nodes)),
-    edgesTable: sql.raw(quoteIdentifier(tables.edges)),
-    recordedNodesTable: sql.raw(quoteIdentifier(tables.recordedNodes)),
-    recordedEdgesTable: sql.raw(quoteIdentifier(tables.recordedEdges)),
-    recordedClockTable: sql.raw(quoteIdentifier(tables.recordedClock)),
-    revisionOriginsTable: sql.raw(quoteIdentifier(tables.revisionOrigins)),
-    fulltextTable: sql.raw(quoteIdentifier(tables.fulltext))
+    nodesTable: sql.identifier(tables.nodes),
+    edgesTable: sql.identifier(tables.edges),
+    recordedNodesTable: sql.identifier(tables.recordedNodes),
+    recordedEdgesTable: sql.identifier(tables.recordedEdges),
+    recordedClockTable: sql.identifier(tables.recordedClock),
+    revisionOriginsTable: sql.identifier(tables.revisionOrigins),
+    fulltextTable: sql.identifier(tables.fulltext)
   });
 }
-var EXTERNAL_RECORDED_READ_SOURCE = /* @__PURE__ */ Symbol(
-  "ExternalRecordedReadSource"
+var EXTERNAL_RECORDED_READ_SOURCE = typeGraphGlobalSymbol(
+  "external-recorded-read-source-v1"
 );
-var TYPEGRAPH_RECORDED_READ_SOURCE = /* @__PURE__ */ Symbol(
-  "TypeGraphRecordedReadSource"
+var TYPEGRAPH_RECORDED_READ_SOURCE = typeGraphGlobalSymbol(
+  "typegraph-recorded-read-source-v1"
 );
 function recordedRelation(options) {
   const schema = requireSqlSchema(options.schema, "recordedRelation schema");
@@ -289,9 +216,663 @@ var ALIAS_CTE_PREFIX = "cte_";
 var EMBEDDINGS_CTE_ALIAS = "cte_embeddings";
 var FULLTEXT_CTE_ALIAS = "cte_fulltext";
 var HYBRID_CANDIDATES_CTE_ALIAS = "cte_relevance_candidates";
+
+// src/store/types.ts
+var AUTO_REFRESH_STATISTICS_ROW_THRESHOLD = 1e3;
+var TRANSACTION_RUNTIME = typeGraphGlobalSymbol(
+  "transaction-runtime-v1"
+);
+
+// src/store/runtime-port.ts
+var STORE_RUNTIME = typeGraphGlobalSymbol("store-runtime-v1");
+function storeRuntime(store) {
+  const runtime = store[STORE_RUNTIME];
+  if (runtime === void 0) {
+    throw new TypeError(
+      "Cannot access this Store's runtime port. The Store may come from an incompatible TypeGraph version."
+    );
+  }
+  return runtime;
+}
+function storeBackend(store) {
+  return storeRuntime(store).backend;
+}
+function transactionBackend(transaction) {
+  const runtime = transaction[TRANSACTION_RUNTIME];
+  if (runtime === void 0) {
+    throw new TypeError(
+      "Cannot access this transaction's runtime port. The transaction may come from an incompatible TypeGraph version."
+    );
+  }
+  return runtime.backend;
+}
+function transactionNodeOperationHookRunner(transaction) {
+  const runtime = transaction[TRANSACTION_RUNTIME];
+  if (runtime === void 0) {
+    throw new TypeError(
+      "Cannot access this transaction's runtime port. The transaction may come from an incompatible TypeGraph version."
+    );
+  }
+  return runtime.runNodeOperationHooks;
+}
+
+// src/query/compiler/temporal.ts
+var pinnedReadInstant;
+function withPinnedReadInstant(emit) {
+  if (pinnedReadInstant !== void 0) return emit();
+  pinnedReadInstant = nowIso();
+  try {
+    return emit();
+  } finally {
+    pinnedReadInstant = void 0;
+  }
+}
+function currentReadInstant() {
+  return sql`${pinnedReadInstant ?? nowIso()}`;
+}
+var CURRENT_READ_INSTANT_PLACEHOLDER = "__typegraph_current_read_instant__";
+function currentReadInstantPlaceholder() {
+  return sql`${sql.placeholder(CURRENT_READ_INSTANT_PLACEHOLDER)}`;
+}
+function currentReadInstantFor(mode) {
+  return mode === "placeholder" ? currentReadInstantPlaceholder() : currentReadInstant();
+}
+function compileTemporalFilter(options) {
+  const { mode, asOf, tableAlias, currentTimestamp, recordedAsOf } = 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`;
+  const validFilter = (() => {
+    switch (mode) {
+      case "current": {
+        const now = recordedAsOf === void 0 ? currentTimestamp ?? currentReadInstant() : sql`${recordedAsOf}`;
+        return sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${now}) AND (${validTo} IS NULL OR ${validTo} > ${now})`;
+      }
+      case "asOf": {
+        if (asOf === void 0) {
+          throw new Error(
+            `asOf timestamp is required for temporal mode "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");
+      }
+    }
+  })();
+  if (recordedAsOf === void 0) return validFilter;
+  const recordedFrom = sql`${prefix}recorded_from`;
+  const recordedTo = sql`${prefix}recorded_to`;
+  return sql`(${validFilter}) AND ${recordedFrom} <= ${recordedAsOf} AND ${recordedAsOf} < ${recordedTo}`;
+}
+function extractTemporalOptions(ast, tableAlias) {
+  return {
+    mode: ast.temporalMode.mode,
+    asOf: ast.temporalMode.asOf,
+    recordedAsOf: ast.recordedAsOf,
+    tableAlias
+  };
+}
+
+// src/query/subquery-utils.ts
+function normalizeValueType(valueType) {
+  if (valueType === void 0 || valueType === "unknown") {
+    return void 0;
+  }
+  return valueType;
+}
+function isUnsupportedInSubqueryValueType(valueType) {
+  const normalized = normalizeValueType(valueType);
+  return normalized === "array" || normalized === "object" || normalized === "embedding";
+}
+function isInSubqueryTypeCompatible(left, right) {
+  const normalizedLeft = normalizeValueType(left);
+  const normalizedRight = normalizeValueType(right);
+  if (normalizedLeft === void 0 || normalizedRight === void 0) {
+    return true;
+  }
+  return normalizedLeft === normalizedRight;
+}
+function getAggregateValueType(aggregate) {
+  switch (aggregate.function) {
+    case "count":
+    case "countDistinct":
+    case "sum":
+    case "avg": {
+      return "number";
+    }
+    case "min":
+    case "max": {
+      return normalizeValueType(aggregate.field.valueType);
+    }
+  }
+}
+function getProjectedValueTypes(subquery) {
+  if (subquery.selectiveFields && subquery.selectiveFields.length > 0) {
+    return subquery.selectiveFields.map(
+      (field) => normalizeValueType(field.valueType)
+    );
+  }
+  return subquery.projection.fields.map((field) => {
+    if (field.source.__type === "aggregate") {
+      return getAggregateValueType(field.source);
+    }
+    return normalizeValueType(field.source.valueType);
+  });
+}
+function getSubqueryColumnCount(subquery) {
+  return getProjectedValueTypes(subquery).length;
+}
+function getSingleSubqueryColumnValueType(subquery) {
+  const valueTypes = getProjectedValueTypes(subquery);
+  if (valueTypes.length !== 1) {
+    return void 0;
+  }
+  return valueTypes[0];
+}
+
+// src/query/predicates.ts
+function predicate(expr) {
+  return {
+    __expr: expr,
+    and: (other) => predicate({
+      __type: "and",
+      predicates: [expr, other.__expr]
+    }),
+    or: (other) => predicate({
+      __type: "or",
+      predicates: [expr, other.__expr]
+    }),
+    not: () => predicate({
+      __type: "not",
+      predicate: expr
+    })
+  };
+}
+function param(name) {
+  if (name === CURRENT_READ_INSTANT_PLACEHOLDER) {
+    throw new ConfigurationError(
+      `Parameter name "${name}" is reserved for internal use`,
+      { parameterName: name }
+    );
+  }
+  return { __type: "parameter", name };
+}
+function isParameterRef(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return value.__type === "parameter";
+}
+function fieldRef(alias, path, options) {
+  return {
+    __type: "field_ref",
+    alias,
+    path,
+    ...options?.jsonPointer !== void 0 && {
+      jsonPointer: options.jsonPointer
+    },
+    ...options?.valueType !== void 0 && { valueType: options.valueType },
+    ...options?.elementType !== void 0 && {
+      elementType: options.elementType
+    }
+  };
+}
+function coerceLiteralValue(value) {
+  if (value instanceof Date) {
+    return value;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  throw new Error(`Unsupported literal value type: ${typeof value}`);
+}
+function inferLiteralValueType(value) {
+  if (typeof value === "string") {
+    return "string";
+  }
+  if (typeof value === "number") {
+    return "number";
+  }
+  return "boolean";
+}
+function literal(value) {
+  if (value instanceof Date) {
+    return { __type: "literal", value: value.toISOString(), valueType: "date" };
+  }
+  const valueType = inferLiteralValueType(value);
+  return {
+    __type: "literal",
+    value,
+    valueType
+  };
+}
+function comparison(op, field, value) {
+  if (isParameterRef(value)) {
+    const expr2 = {
+      __type: "comparison",
+      op,
+      left: field,
+      right: value
+    };
+    return predicate(expr2);
+  }
+  const coercedValue = coerceLiteralValue(value);
+  const expr = {
+    __type: "comparison",
+    op,
+    left: field,
+    right: literal(coercedValue)
+  };
+  return predicate(expr);
+}
+function inComparison(op, field, values) {
+  const literals = values.map((value) => literal(coerceLiteralValue(value)));
+  const expr = {
+    __type: "comparison",
+    op,
+    left: field,
+    right: literals
+  };
+  return predicate(expr);
+}
+function stringOp(op, field, pattern) {
+  if (isParameterRef(pattern)) {
+    const expr2 = {
+      __type: "string_op",
+      op,
+      field,
+      pattern
+    };
+    return predicate(expr2);
+  }
+  const expr = {
+    __type: "string_op",
+    op,
+    field,
+    pattern
+  };
+  return predicate(expr);
+}
+function nullCheck(op, field) {
+  const expr = {
+    __type: "null_check",
+    op,
+    field
+  };
+  return predicate(expr);
+}
+function between(field, lower, upper) {
+  const expr = {
+    __type: "between",
+    field,
+    lower: isParameterRef(lower) ? lower : literal(lower),
+    upper: isParameterRef(upper) ? upper : literal(upper)
+  };
+  return predicate(expr);
+}
+function baseFieldBuilder(field) {
+  return {
+    eq: (value) => comparison("eq", field, value),
+    neq: (value) => comparison("neq", field, value),
+    isNull: () => nullCheck("isNull", field),
+    isNotNull: () => nullCheck("isNotNull", field),
+    in: (values) => inComparison("in", field, values),
+    notIn: (values) => inComparison("notIn", field, values)
+  };
+}
+function stringField(field) {
+  return {
+    ...baseFieldBuilder(field),
+    gt: (value) => comparison("gt", field, value),
+    gte: (value) => comparison("gte", field, value),
+    lt: (value) => comparison("lt", field, value),
+    lte: (value) => comparison("lte", field, value),
+    contains: (pattern) => stringOp("contains", field, pattern),
+    startsWith: (pattern) => stringOp("startsWith", field, pattern),
+    endsWith: (pattern) => stringOp("endsWith", field, pattern),
+    like: (pattern) => stringOp("like", field, pattern),
+    ilike: (pattern) => stringOp("ilike", field, pattern)
+  };
+}
+var DEFAULT_FULLTEXT_MATCH_K = 50;
+function createFulltextAccessor(alias, hasSearchableField) {
+  return {
+    matches: (query, k, options) => {
+      if (!hasSearchableField()) {
+        throw new UnsupportedPredicateError(
+          `Cannot call .$fulltext.matches() on alias "${alias}" \u2014 its node kind has no fields declared with searchable(). Add at least one: \`title: searchable({ language: "english" })\`.`
+        );
+      }
+      return fulltextMatch(
+        fieldRef(alias, ["$fulltext"]),
+        query,
+        k ?? DEFAULT_FULLTEXT_MATCH_K,
+        options
+      );
+    }
+  };
+}
+function fulltextMatch(field, query, limit, options) {
+  if (!Number.isFinite(limit) || limit <= 0) {
+    throw new UnsupportedPredicateError(
+      `matches() limit must be a positive finite number, got ${String(limit)}`
+    );
+  }
+  const expr = {
+    __type: "fulltext_match",
+    field,
+    query,
+    mode: options?.mode ?? "websearch",
+    limit,
+    ...options?.language === void 0 ? {} : { language: options.language },
+    ...options?.minScore === void 0 ? {} : { minScore: options.minScore }
+  };
+  return predicate(expr);
+}
+function numberField(field) {
+  return {
+    ...baseFieldBuilder(field),
+    gt: (value) => comparison("gt", field, value),
+    gte: (value) => comparison("gte", field, value),
+    lt: (value) => comparison("lt", field, value),
+    lte: (value) => comparison("lte", field, value),
+    between: (lower, upper) => between(field, lower, upper)
+  };
+}
+function dateField(field) {
+  return {
+    ...baseFieldBuilder(field),
+    gt: (value) => comparison("gt", field, value),
+    gte: (value) => comparison("gte", field, value),
+    lt: (value) => comparison("lt", field, value),
+    lte: (value) => comparison("lte", field, value),
+    between: (lower, upper) => between(field, lower, upper)
+  };
+}
+function baseField(field) {
+  return baseFieldBuilder(field);
+}
+function arrayOp(op, field, values, length) {
+  const expr = {
+    __type: "array_op",
+    op,
+    field,
+    ...values !== void 0 && {
+      values: values.map((value) => literal(coerceLiteralValue(value)))
+    },
+    ...length !== void 0 && { length }
+  };
+  return predicate(expr);
+}
+function arrayField(field) {
+  return {
+    ...baseFieldBuilder(field),
+    contains: (value) => arrayOp("contains", field, [value]),
+    containsAll: (values) => arrayOp("containsAll", field, values),
+    containsAny: (values) => arrayOp("containsAny", field, values),
+    isEmpty: () => arrayOp("isEmpty", field),
+    isNotEmpty: () => arrayOp("isNotEmpty", field),
+    lengthEq: (length) => arrayOp("lengthEq", field, void 0, length),
+    lengthGt: (length) => arrayOp("lengthGt", field, void 0, length),
+    lengthGte: (length) => arrayOp("lengthGte", field, void 0, length),
+    lengthLt: (length) => arrayOp("lengthLt", field, void 0, length),
+    lengthLte: (length) => arrayOp("lengthLte", field, void 0, length)
+  };
+}
+function vectorSimilarity(field, queryEmbedding, limit, options) {
+  const expr = {
+    __type: "vector_similarity",
+    field,
+    queryEmbedding,
+    // Leave metric unset when the caller didn't specify one, so the compiler
+    // resolves the field's declared metric per kind. Defaulting to "cosine"
+    // here would mis-rank l2/inner_product fields and bypass their ANN index.
+    ...options?.metric !== void 0 && { metric: options.metric },
+    limit,
+    ...options?.minScore !== void 0 && { minScore: options.minScore },
+    ...options?.approximate !== void 0 && {
+      approximate: options.approximate
+    }
+  };
+  return predicate(expr);
+}
+function embeddingField(field) {
+  return {
+    ...baseFieldBuilder(field),
+    similarTo: (queryEmbedding, k, options) => vectorSimilarity(field, queryEmbedding, k, options)
+  };
+}
+function buildFieldBuilderForTypeInfo(field, typeInfo) {
+  if (!typeInfo) {
+    return baseField(field);
+  }
+  switch (typeInfo.valueType) {
+    case "string": {
+      return stringField(field);
+    }
+    case "number": {
+      return numberField(field);
+    }
+    case "boolean": {
+      return baseField(field);
+    }
+    case "date": {
+      return dateField(field);
+    }
+    case "array": {
+      return arrayField(field);
+    }
+    case "object": {
+      return objectField(field, { typeInfo });
+    }
+    case "embedding": {
+      return embeddingField(field);
+    }
+    case "unknown": {
+      return baseField(field);
+    }
+  }
+}
+function resolvePointerTypeInfo(typeInfo, pointer) {
+  return resolveFieldTypeInfoAtJsonPointer(typeInfo, pointer);
+}
+function objectOp(op, field, pointer, value, options) {
+  const expr = {
+    __type: "object_op",
+    op,
+    field,
+    pointer,
+    ...value !== void 0 && {
+      value: literal(coerceLiteralValue(value))
+    },
+    ...options?.valueType !== void 0 && { valueType: options.valueType },
+    ...options?.elementType !== void 0 && {
+      elementType: options.elementType
+    }
+  };
+  return predicate(expr);
+}
+function objectField(field, options) {
+  const basePointer = field.jsonPointer;
+  return {
+    ...baseFieldBuilder(field),
+    get: (key) => {
+      const pointer = jsonPointer([key]);
+      const nestedPointer = joinJsonPointers(basePointer, pointer);
+      const resolved = resolvePointerTypeInfo(options?.typeInfo, pointer);
+      const nestedRef = fieldRef(field.alias, field.path, {
+        jsonPointer: nestedPointer,
+        ...resolved?.valueType !== void 0 && {
+          valueType: resolved.valueType
+        },
+        ...resolved?.elementType !== void 0 && {
+          elementType: resolved.elementType
+        }
+      });
+      return buildFieldBuilderForTypeInfo(nestedRef, resolved);
+    },
+    hasKey: (key) => {
+      const pointer = jsonPointer([key]);
+      resolvePointerTypeInfo(options?.typeInfo, pointer);
+      return objectOp("hasKey", field, pointer);
+    },
+    hasPath: (pointer) => {
+      const normalized = normalizeJsonPointer(pointer);
+      resolvePointerTypeInfo(options?.typeInfo, normalized);
+      return objectOp("hasPath", field, normalized);
+    },
+    pathEquals: (pointer, value) => {
+      const normalized = normalizeJsonPointer(pointer);
+      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
+      if (resolved && (resolved.valueType === "array" || resolved.valueType === "object")) {
+        throw new Error("pathEquals is only supported for scalar JSON values");
+      }
+      const predicateOptions = resolved?.valueType === void 0 ? void 0 : { valueType: resolved.valueType };
+      return objectOp("pathEquals", field, normalized, value, predicateOptions);
+    },
+    pathContains: (pointer, value) => {
+      const normalized = normalizeJsonPointer(pointer);
+      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
+      if (resolved && resolved.valueType !== "array") {
+        throw new Error("pathContains is only supported for JSON array values");
+      }
+      const predicateOptions = resolved?.elementType === void 0 ? void 0 : { elementType: resolved.elementType };
+      return objectOp(
+        "pathContains",
+        field,
+        normalized,
+        value,
+        predicateOptions
+      );
+    },
+    pathIsNull: (pointer) => {
+      const normalized = normalizeJsonPointer(pointer);
+      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
+      const predicateOptions = resolved?.valueType === void 0 ? void 0 : { valueType: resolved.valueType };
+      return objectOp(
+        "pathIsNull",
+        field,
+        normalized,
+        void 0,
+        predicateOptions
+      );
+    },
+    pathIsNotNull: (pointer) => {
+      const normalized = normalizeJsonPointer(pointer);
+      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
+      const predicateOptions = resolved?.valueType === void 0 ? void 0 : { valueType: resolved.valueType };
+      return objectOp(
+        "pathIsNotNull",
+        field,
+        normalized,
+        void 0,
+        predicateOptions
+      );
+    },
+    field: (pointer) => {
+      const normalized = normalizeJsonPointer(pointer);
+      const nestedPointer = joinJsonPointers(basePointer, normalized);
+      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
+      const nestedRef = fieldRef(field.alias, field.path, {
+        jsonPointer: nestedPointer,
+        ...resolved?.valueType !== void 0 && {
+          valueType: resolved.valueType
+        },
+        ...resolved?.elementType !== void 0 && {
+          elementType: resolved.elementType
+        }
+      });
+      return buildFieldBuilderForTypeInfo(nestedRef, resolved);
+    }
+  };
+}
+function exists(subquery) {
+  const expr = {
+    __type: "exists",
+    subquery,
+    negated: false
+  };
+  return predicate(expr);
+}
+function notExists(subquery) {
+  const expr = {
+    __type: "exists",
+    subquery,
+    negated: true
+  };
+  return predicate(expr);
+}
+function inSubquery(field, subquery) {
+  assertSingleColumnSubquery(subquery);
+  assertCompatibleSubqueryValueTypes(field, subquery);
+  const expr = {
+    __type: "in_subquery",
+    field,
+    subquery,
+    negated: false
+  };
+  return predicate(expr);
+}
+function notInSubquery(field, subquery) {
+  assertSingleColumnSubquery(subquery);
+  assertCompatibleSubqueryValueTypes(field, subquery);
+  const expr = {
+    __type: "in_subquery",
+    field,
+    subquery,
+    negated: true
+  };
+  return predicate(expr);
+}
+function assertSingleColumnSubquery(subquery) {
+  const columnCount = getSubqueryColumnCount(subquery);
+  if (columnCount === 1) return;
+  throw new UnsupportedPredicateError(
+    `IN/NOT IN subquery must project exactly 1 column, but got ${columnCount}`,
+    { subqueryColumnCount: columnCount },
+    {
+      suggestion: "Use aggregate() with exactly one projected field for scalar IN/NOT IN subqueries."
+    }
+  );
+}
+function assertCompatibleSubqueryValueTypes(field, subquery) {
+  const fieldValueType = field.valueType;
+  const subqueryValueType = getSingleSubqueryColumnValueType(subquery);
+  const resolvedValueType = fieldValueType ?? subqueryValueType;
+  if (isUnsupportedInSubqueryValueType(resolvedValueType)) {
+    throw new UnsupportedPredicateError(
+      `IN/NOT IN subquery does not support ${String(resolvedValueType)} values`,
+      { valueType: resolvedValueType },
+      {
+        suggestion: "Use scalar fields (string/number/boolean/date) in IN/NOT IN predicates."
+      }
+    );
+  }
+  if (isInSubqueryTypeCompatible(fieldValueType, subqueryValueType)) {
+    return;
+  }
+  throw new UnsupportedPredicateError(
+    `IN/NOT IN type mismatch: field type "${String(fieldValueType)}" does not match subquery column type "${String(subqueryValueType)}"`,
+    {
+      fieldValueType,
+      subqueryValueType
+    }
+  );
+}
 function generateId() {
   return nanoid();
 }
+
+// src/store/recorded-capture/guards.ts
+var RECORDED_ISOLATION_REQUIRES_POSTGRES_CHECK = {
+  postgres: true,
+  sqlite: false
+};
 function requireRecordedSchema(target) {
   if (target.tableNames === void 0) {
     throw new ConfigurationError(
@@ -332,7 +913,7 @@ function isSupportedRecordedIsolationLevel(isolationLevel) {
   return isolationLevel === void 0 || isolationLevel === "read_committed" || isolationLevel === "read_uncommitted";
 }
 function assertRequestedRecordedIsolation(backend, options) {
-  if (backend.dialect !== "postgres") return;
+  if (!RECORDED_ISOLATION_REQUIRES_POSTGRES_CHECK[backend.dialect]) return;
   if (options?.accessMode === "read_only") return;
   const isolationLevel = options?.isolationLevel;
   if (isSupportedRecordedIsolationLevel(isolationLevel)) return;
@@ -343,7 +924,7 @@ function normalizeIsolationLevel(value) {
   return value.replaceAll(" ", "_").toLowerCase();
 }
 async function assertRecordedCaptureTransactionIsolation(target, options) {
-  if (target.dialect !== "postgres") return;
+  if (!RECORDED_ISOLATION_REQUIRES_POSTGRES_CHECK[target.dialect]) return;
   if (options?.accessMode === "read_only") return;
   const rows = await target.execute(
     asCompiledRowsSql(sql`
@@ -390,57 +971,12 @@ function revisionTrackingUnsafeRawWriteError(surface) {
     }
   );
 }
-function failHistoryUnsafeSqlRef() {
+function throwHistoryUnsafeSqlAccess() {
   throw historyUnsafeRawWriteError("tx.sql");
 }
-function failRevisionTrackingUnsafeSqlRef() {
+function throwRevisionTrackingUnsafeSqlAccess() {
   throw revisionTrackingUnsafeRawWriteError("tx.sql");
 }
-function createHistoryUnsafeSqlRef() {
-  return createUnsafeSqlRef(failHistoryUnsafeSqlRef);
-}
-function createRevisionTrackingUnsafeSqlRef() {
-  return createUnsafeSqlRef(failRevisionTrackingUnsafeSqlRef);
-}
-function createUnsafeSqlRef(fail) {
-  return new Proxy(
-    function unsafeSqlRef() {
-      return fail();
-    },
-    {
-      get() {
-        return fail();
-      },
-      apply() {
-        return fail();
-      },
-      set() {
-        return fail();
-      },
-      defineProperty() {
-        return fail();
-      },
-      deleteProperty() {
-        return fail();
-      },
-      // Enumeration / inspection traps too, so spreading (`{...tx.sql}`),
-      // `Object.keys`, `in`, and prototype reads also fail loudly rather than
-      // silently yielding an empty object that reads as "no raw handle".
-      has() {
-        return fail();
-      },
-      ownKeys() {
-        return fail();
-      },
-      getOwnPropertyDescriptor() {
-        return fail();
-      },
-      getPrototypeOf() {
-        return fail();
-      }
-    }
-  );
-}
 function rawWriteGuards(target, prefix) {
   return {
     ...target.executeStatement === void 0 ? {} : {
@@ -541,6 +1077,10 @@ var RECORDED_MIN = "1970-01-01T00:00:00.000Z";
 var RECORDED_MAX_TIME = new Date(RECORDED_MAX).getTime();
 var RECORDED_CLOCK_ADVISORY_LOCK_NAMESPACE = "typegraph:recorded-clock";
 var RECORDED_GRAPH_WRITE_ADVISORY_LOCK_NAMESPACE = "typegraph:recorded-graph-write";
+var USES_RECORDED_GRAPH_ADVISORY_LOCK = {
+  postgres: true,
+  sqlite: false
+};
 function graphAdvisoryLockSql(namespace, graphId) {
   return sql`
     SELECT pg_advisory_xact_lock(
@@ -578,7 +1118,9 @@ async function acquireRecordedGraphWriteLock(target, graphId) {
   );
 }
 async function lockRecordedGraphWrite(target, graphId, memo) {
-  if (target.dialect !== "postgres") return graphWriteLockEvidence();
+  if (!USES_RECORDED_GRAPH_ADVISORY_LOCK[target.dialect]) {
+    return graphWriteLockEvidence();
+  }
   const effectiveMemo = memo ?? recordedGraphLockMemos.get(target);
   if (effectiveMemo === void 0) {
     await acquireRecordedGraphWriteLock(target, graphId);
@@ -620,7 +1162,9 @@ function clockTimestampMs(value) {
   const offsetMatch = OFFSET_DATETIME_PATTERN.exec(value);
   if (offsetMatch) {
     const [, date, time, offset] = offsetMatch;
-    return Date.parse(`${date}T${time}${normalizeOffsetDesignator(offset)}`);
+    return Date.parse(
+      `${date}T${time}${normalizeOffsetDesignator(requireDefined(offset))}`
+    );
   }
   return Date.parse(value);
 }
@@ -709,21 +1253,29 @@ async function writeRecordedClock(target, schema, graphId, recordedAt) {
   );
 }
 async function lockRecordedClock(target, schema, graphId, ownsWriteLock) {
-  if (target.dialect === "postgres") {
-    await target.execute(
-      asCompiledRowsSql(recordedClockAdvisoryLockSql(graphId))
-    );
-    return;
+  switch (target.dialect) {
+    case "postgres": {
+      await target.execute(
+        asCompiledRowsSql(recordedClockAdvisoryLockSql(graphId))
+      );
+      return;
+    }
+    case "sqlite": {
+      if (ownsWriteLock) return;
+      await executeStatement(
+        target,
+        sql`
+          INSERT INTO ${schema.recordedClockTable} (graph_id, recorded_at)
+          VALUES (${graphId}, ${RECORDED_MIN})
+          ON CONFLICT (graph_id) DO UPDATE SET recorded_at = recorded_at
+        `
+      );
+      return;
+    }
+    default: {
+      target.dialect;
+    }
   }
-  if (ownsWriteLock) return;
-  await executeStatement(
-    target,
-    sql`
-      INSERT INTO ${schema.recordedClockTable} (graph_id, recorded_at)
-      VALUES (${graphId}, ${RECORDED_MIN})
-      ON CONFLICT (graph_id) DO UPDATE SET recorded_at = recorded_at
-    `
-  );
 }
 async function allocateRecordedCommit(target, schema, graphId, ownsWriteLock, previousRevision) {
   await lockRecordedClock(target, schema, graphId, ownsWriteLock);
@@ -752,21 +1304,125 @@ async function advanceRevisionClock(target, schema, graphId, ownsWriteLock, prev
   );
 }
 
+// src/backend/graph-backend-projection.ts
+var GRAPH_BACKEND_PROJECTION_KEYS = [
+  "dialect",
+  "capabilities",
+  "tableNames",
+  "fulltextStrategy",
+  "vectorStrategy",
+  "insertNode",
+  "insertNodeNoReturn",
+  "insertNodesBatch",
+  "insertNodesBatchReturning",
+  "updateNode",
+  "deleteNode",
+  "hardDeleteNode",
+  "getNode",
+  "getNodes",
+  "insertEdge",
+  "insertEdgeNoReturn",
+  "insertEdgesBatch",
+  "insertEdgesBatchReturning",
+  "updateEdge",
+  "deleteEdge",
+  "hardDeleteEdge",
+  "deleteEdgesBatch",
+  "hardDeleteEdgesBatch",
+  "getEdge",
+  "getEdges",
+  "countEdgesFrom",
+  "edgeExistsBetween",
+  "findEdgesConnectedTo",
+  "findNodesByKind",
+  "countNodesByKind",
+  "findEdgesByKind",
+  "countEdgesByKind",
+  "insertUnique",
+  "insertUniqueBatch",
+  "deleteUnique",
+  "checkUnique",
+  "checkUniqueBatch",
+  "getActiveSchema",
+  "getSchemaVersion",
+  "commitSchemaVersion",
+  "setActiveVersion",
+  "upsertEmbedding",
+  "upsertEmbeddingBatch",
+  "deleteEmbedding",
+  "vectorSearch",
+  "createVectorIndex",
+  "dropVectorIndex",
+  "hybridSearch",
+  "upsertFulltext",
+  "deleteFulltext",
+  "upsertFulltextBatch",
+  "deleteFulltextBatch",
+  "fulltextSearch",
+  "ensureIndexMaterializationsTable",
+  "ensureRevisionOriginsTable",
+  "getIndexMaterialization",
+  "getIndexMaterializations",
+  "recordIndexMaterialization",
+  "claimIndexMaterialization",
+  "releaseIndexMaterializationClaim",
+  "ensureContributionMaterializationsTable",
+  "getContributionMaterialization",
+  "recordContributionMaterialization",
+  "assertRuntimeContributionsInitialized",
+  "ensureKindRemovalsTable",
+  "getPendingKindRemovals",
+  "getAllKindRemovals",
+  "recordKindRemoval",
+  "ensureReconciliationMarkersTable",
+  "ensureRuntimeContributions",
+  "ensureVectorSlotContribution",
+  "ensureVectorSlotContributions",
+  "assertVectorSlotInitialized",
+  "assertVectorSlotsInitialized",
+  "deleteVectorSlotContribution",
+  "ensureFulltextTable",
+  "getReconciliationMarker",
+  "setReconciliationMarker",
+  "clearGraph",
+  "bootstrapTables",
+  "refreshStatistics",
+  "trustedImport",
+  "execute",
+  "executeStatement",
+  "executeTemporaryStatement",
+  "executeRaw",
+  "compileSql",
+  "executeDdl",
+  "transaction",
+  "close"
+];
+function projectBackendMembers(backend, keys) {
+  const entries = keys.flatMap((key) => {
+    if (!Reflect.has(backend, key)) return [];
+    return [[key, Reflect.get(backend, key)]];
+  });
+  return Object.fromEntries(entries);
+}
+function createGraphBackendProjection(backend) {
+  return projectBackendMembers(backend, GRAPH_BACKEND_PROJECTION_KEYS);
+}
+
 // src/store/insert-dispatch.ts
 function nodeInsertDispatch(backend) {
   return {
     one: (params) => backend.insertNode(params),
-    oneNoReturn: backend.insertNodeNoReturn === void 0 ? void 0 : (params) => backend.insertNodeNoReturn(params),
-    batch: backend.insertNodesBatch === void 0 ? void 0 : (params) => backend.insertNodesBatch(params),
-    batchReturning: backend.insertNodesBatchReturning === void 0 ? void 0 : (params) => backend.insertNodesBatchReturning(params)
+    oneNoReturn: backend.insertNodeNoReturn === void 0 ? void 0 : (params) => requireDefined(backend.insertNodeNoReturn)(params),
+    batch: backend.insertNodesBatch === void 0 ? void 0 : (params) => requireDefined(backend.insertNodesBatch)(params),
+    batchReturning: backend.insertNodesBatchReturning === void 0 ? void 0 : (params) => requireDefined(backend.insertNodesBatchReturning)(params)
   };
 }
 function edgeInsertDispatch(backend) {
   return {
     one: (params) => backend.insertEdge(params),
-    oneNoReturn: backend.insertEdgeNoReturn === void 0 ? void 0 : (params) => backend.insertEdgeNoReturn(params),
-    batch: backend.insertEdgesBatch === void 0 ? void 0 : (params) => backend.insertEdgesBatch(params),
-    batchReturning: backend.insertEdgesBatchReturning === void 0 ? void 0 : (params) => backend.insertEdgesBatchReturning(params)
+    oneNoReturn: backend.insertEdgeNoReturn === void 0 ? void 0 : (params) => requireDefined(backend.insertEdgeNoReturn)(params),
+    batch: backend.insertEdgesBatch === void 0 ? void 0 : (params) => requireDefined(backend.insertEdgesBatch)(params),
+    batchReturning: backend.insertEdgesBatchReturning === void 0 ? void 0 : (params) => requireDefined(backend.insertEdgesBatchReturning)(params)
   };
 }
 async function runInsertNoReturn(dispatch, params) {
@@ -797,6 +1453,680 @@ async function runInsertBatchReturning(dispatch, params) {
   return rows;
 }
 
+// src/query/compiler/predicates.ts
+var COMPARISON_OP_SQL = {
+  eq: "=",
+  neq: "!=",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<="
+};
+function compileFieldColumn(field, cteAlias, cteColumnPrefix) {
+  if (cteColumnPrefix !== void 0) {
+    const qualifier2 = cteColumnPrefix === "" ? "" : `${cteColumnPrefix}.`;
+    if (field.path.length === 1 && field.path[0] === "id") {
+      return sql.raw(`${qualifier2}id`);
+    }
+    if (field.path.length === 1 && field.path[0] === "kind") {
+      return sql.raw(`${qualifier2}kind`);
+    }
+    if (field.path.length > 0 && field.path[0] === "props") {
+      return sql.raw(`${qualifier2}props`);
+    }
+    return sql.raw(`${qualifier2}${field.path.join("_")}`);
+  }
+  const prefix = field.alias;
+  const qualifier = cteAlias ? `${cteAlias}.` : "";
+  if (field.path.length === 1 && field.path[0] === "id") {
+    return sql.raw(`${qualifier}${prefix}_id`);
+  }
+  if (field.path.length === 1 && field.path[0] === "kind") {
+    return sql.raw(`${qualifier}${prefix}_kind`);
+  }
+  if (field.path.length > 0 && field.path[0] === "props") {
+    return sql.raw(`${qualifier}${prefix}_props`);
+  }
+  return sql.raw(`${qualifier}${prefix}_${field.path.join("_")}`);
+}
+function getFieldPointer(field) {
+  if (field.jsonPointer !== void 0) {
+    return field.jsonPointer;
+  }
+  if (field.path.length > 1 && field.path[0] === "props") {
+    return jsonPointer(field.path.slice(1));
+  }
+  return void 0;
+}
+function isJsonField(field) {
+  return field.path.length > 0 && field.path[0] === "props";
+}
+function normalizeValueType2(valueType) {
+  if (!valueType || valueType === "unknown") {
+    return void 0;
+  }
+  return valueType;
+}
+function compileFieldValue(field, dialect, valueType, cteAlias, pointerOverride, cteColumnPrefix) {
+  const resolved = normalizeValueType2(valueType);
+  const column = compileFieldColumn(field, cteAlias, cteColumnPrefix);
+  if (!isJsonField(field)) {
+    return column;
+  }
+  const pointer = pointerOverride ?? getFieldPointer(field);
+  if (!pointer || pointer === "") {
+    return column;
+  }
+  switch (resolved) {
+    case "number": {
+      return dialect.jsonExtractNumber(column, pointer);
+    }
+    case "boolean": {
+      return dialect.jsonExtractBoolean(column, pointer);
+    }
+    case "date": {
+      return dialect.jsonExtractDate(column, pointer);
+    }
+    case "array":
+    case "object":
+    case "embedding": {
+      return dialect.jsonExtract(column, pointer);
+    }
+    case "string":
+    case "unknown":
+    case void 0: {
+      return dialect.jsonExtractText(column, pointer);
+    }
+  }
+}
+function compileFieldTextValue(field, dialect, cteAlias, pointerOverride, cteColumnPrefix) {
+  const column = compileFieldColumn(field, cteAlias, cteColumnPrefix);
+  if (!isJsonField(field)) {
+    return column;
+  }
+  const pointer = getFieldPointer(field);
+  if (!pointer || pointer === "") {
+    return column;
+  }
+  return dialect.jsonExtractText(column, pointer);
+}
+function compileFieldJsonValue(field, dialect, cteAlias, pointerOverride, cteColumnPrefix) {
+  const column = compileFieldColumn(field, cteAlias, cteColumnPrefix);
+  if (!isJsonField(field)) {
+    return column;
+  }
+  const pointer = pointerOverride ?? getFieldPointer(field);
+  if (!pointer || pointer === "") {
+    return column;
+  }
+  return dialect.jsonExtract(column, pointer);
+}
+function resolveLiteralValueTypes(literals) {
+  const resolved = /* @__PURE__ */ new Set();
+  for (const literal2 of literals) {
+    const valueType = normalizeValueType2(literal2.valueType);
+    if (valueType) {
+      resolved.add(valueType);
+    }
+  }
+  if (resolved.size > 1) {
+    throw new UnsupportedPredicateError(
+      "Mixed literal value types are not supported in predicates",
+      { valueTypes: [...resolved] }
+    );
+  }
+  return resolved.values().next().value;
+}
+function resolveComparisonValueType(field, right) {
+  if (isParameterRef(right)) {
+    return normalizeValueType2(right.valueType) ?? normalizeValueType2(field.valueType);
+  }
+  const literals = Array.isArray(right) ? right : [right];
+  const literalType = resolveLiteralValueTypes(literals);
+  const fieldType = normalizeValueType2(field.valueType);
+  if (fieldType === "date" && literalType === "string") {
+    return fieldType;
+  }
+  if (literalType) {
+    return literalType;
+  }
+  return fieldType;
+}
+function resolvePredicateValueType(preferred, literal2) {
+  const normalizedPreferred = normalizeValueType2(preferred);
+  if (normalizedPreferred) {
+    return normalizedPreferred;
+  }
+  return literal2 ? normalizeValueType2(literal2.valueType) : void 0;
+}
+function convertValueForSql(value, dialect) {
+  return dialect.bindValue(value);
+}
+function compileStringPattern(op, pattern) {
+  const escaped = pattern.replaceAll(
+    LIKE_ESCAPE_CHARACTER,
+    `${LIKE_ESCAPE_CHARACTER}${LIKE_ESCAPE_CHARACTER}`
+  ).replaceAll("%", `${LIKE_ESCAPE_CHARACTER}%`).replaceAll("_", `${LIKE_ESCAPE_CHARACTER}_`);
+  switch (op) {
+    case "contains": {
+      return `%${escaped}%`;
+    }
+    case "startsWith": {
+      return `${escaped}%`;
+    }
+    case "endsWith": {
+      return `%${escaped}`;
+    }
+    case "like":
+    case "ilike": {
+      return pattern;
+    }
+    default: {
+      return escaped;
+    }
+  }
+}
+function escapeLikePatternParameter(parameter) {
+  const doubledEscape = `${LIKE_ESCAPE_CHARACTER}${LIKE_ESCAPE_CHARACTER}`;
+  return sql`REPLACE(REPLACE(REPLACE(${parameter}, ${LIKE_ESCAPE_CHARACTER}, ${doubledEscape}), '%', ${`${LIKE_ESCAPE_CHARACTER}%`}), '_', ${`${LIKE_ESCAPE_CHARACTER}_`})`;
+}
+function compileParameterizedStringPattern(op, parameter) {
+  switch (op) {
+    case "contains": {
+      const escaped = escapeLikePatternParameter(parameter);
+      return sql`'%' || ${escaped} || '%'`;
+    }
+    case "startsWith": {
+      const escaped = escapeLikePatternParameter(parameter);
+      return sql`${escaped} || '%'`;
+    }
+    case "endsWith": {
+      const escaped = escapeLikePatternParameter(parameter);
+      return sql`'%' || ${escaped}`;
+    }
+    case "like":
+    case "ilike": {
+      return parameter;
+    }
+    default: {
+      return escapeLikePatternParameter(parameter);
+    }
+  }
+}
+function compilePredicateExpression(expr, ctx) {
+  const { dialect } = ctx;
+  const cteColumnPrefix = ctx.cteColumnPrefix;
+  switch (expr.__type) {
+    case "comparison": {
+      return compileComparisonPredicate(expr, dialect, cteColumnPrefix);
+    }
+    case "string_op": {
+      const field = compileFieldTextValue(
+        expr.field,
+        dialect,
+        void 0,
+        void 0,
+        cteColumnPrefix
+      );
+      if (isParameterRef(expr.pattern)) {
+        const placeholder = sql`${sql.placeholder(expr.pattern.name)}`;
+        const pattern2 = compileParameterizedStringPattern(expr.op, placeholder);
+        if (expr.op === "ilike" || expr.op === "contains" || expr.op === "startsWith" || expr.op === "endsWith") {
+          return dialect.ilike(field, pattern2);
+        }
+        return sql`${field} LIKE ${pattern2} ${likeEscapeClause}`;
+      }
+      const pattern = compileStringPattern(expr.op, expr.pattern);
+      if (expr.op === "ilike" || expr.op === "contains" || expr.op === "startsWith" || expr.op === "endsWith") {
+        return dialect.ilike(field, pattern);
+      }
+      return sql`${field} LIKE ${pattern} ${likeEscapeClause}`;
+    }
+    case "null_check": {
+      const field = compileFieldTextValue(
+        expr.field,
+        dialect,
+        void 0,
+        void 0,
+        cteColumnPrefix
+      );
+      return expr.op === "isNull" ? sql`${field} IS NULL` : sql`${field} IS NOT NULL`;
+    }
+    case "between": {
+      const lowerIsParam = isParameterRef(expr.lower);
+      const upperIsParam = isParameterRef(expr.upper);
+      const boundsForType = [];
+      if (!lowerIsParam) boundsForType.push(expr.lower);
+      if (!upperIsParam) boundsForType.push(expr.upper);
+      const valueType = boundsForType.length > 0 ? resolveComparisonValueType(expr.field, boundsForType) : normalizeValueType2(expr.field.valueType);
+      if (valueType === "array" || valueType === "object") {
+        throw new UnsupportedPredicateError(
+          "Between comparisons are not supported for JSON arrays or objects"
+        );
+      }
+      const field = compileFieldValue(
+        expr.field,
+        dialect,
+        valueType,
+        void 0,
+        void 0,
+        cteColumnPrefix
+      );
+      const lower = lowerIsParam ? sql.placeholder(expr.lower.name) : convertValueForSql(expr.lower.value, dialect);
+      const upper = upperIsParam ? sql.placeholder(expr.upper.name) : convertValueForSql(expr.upper.value, dialect);
+      return sql`${field} BETWEEN ${lower} AND ${upper}`;
+    }
+    case "and": {
+      const parts = expr.predicates.map(
+        (p) => compilePredicateExpression(p, ctx)
+      );
+      return sql`(${sql.join(parts, sql` AND `)})`;
+    }
+    case "or": {
+      const parts = expr.predicates.map(
+        (p) => compilePredicateExpression(p, ctx)
+      );
+      return sql`(${sql.join(parts, sql` OR `)})`;
+    }
+    case "not": {
+      const inner = compilePredicateExpression(expr.predicate, ctx);
+      return sql`NOT (${inner})`;
+    }
+    case "array_op": {
+      return compileArrayPredicate(expr, dialect, cteColumnPrefix);
+    }
+    case "object_op": {
+      return compileObjectPredicate(expr, dialect, cteColumnPrefix);
+    }
+    case "aggregate_comparison": {
+      return compileAggregatePredicate(expr, dialect);
+    }
+    case "exists": {
+      return compileExistsSubquery(expr, ctx);
+    }
+    case "in_subquery": {
+      return compileInSubquery(expr, ctx);
+    }
+    case "vector_similarity":
+    case "fulltext_match": {
+      return STRUCTURAL_PREDICATE_NOOP;
+    }
+  }
+}
+var STRUCTURAL_PREDICATE_NOOP = sql.raw("1=1");
+function compileComparisonPredicate(expr, dialect, cteColumnPrefix) {
+  if (isParameterRef(expr.right)) {
+    const parameterValueType = normalizeValueType2(expr.right.valueType) ?? normalizeValueType2(expr.left.valueType);
+    const left2 = compileFieldValue(
+      expr.left,
+      dialect,
+      parameterValueType,
+      void 0,
+      void 0,
+      cteColumnPrefix
+    );
+    const opSql2 = COMPARISON_OP_SQL[expr.op];
+    if (!opSql2) {
+      throw new UnsupportedPredicateError(
+        `Comparison operation "${expr.op}" is not supported for parameterized predicates`
+      );
+    }
+    return sql`${left2} ${sql.raw(opSql2)} ${sql.placeholder(expr.right.name)}`;
+  }
+  const valueType = resolveComparisonValueType(expr.left, expr.right);
+  if (valueType === "array" || valueType === "object") {
+    throw new UnsupportedPredicateError(
+      `Comparison operation "${expr.op}" is not supported for ${valueType} values`
+    );
+  }
+  const left = compileFieldValue(
+    expr.left,
+    dialect,
+    valueType,
+    void 0,
+    void 0,
+    cteColumnPrefix
+  );
+  if (expr.op === "in" || expr.op === "notIn") {
+    const values = Array.isArray(expr.right) ? expr.right : [expr.right];
+    if (values.length === 0) {
+      return expr.op === "in" ? sql.raw("1=0") : sql.raw("1=1");
+    }
+    const convertedValues = values.map(
+      (value) => convertValueForSql(value.value, dialect)
+    );
+    return dialect.inList(left, convertedValues, expr.op === "notIn");
+  }
+  const right = expr.right;
+  const rightValue = Array.isArray(right) ? requireDefined(right[0]) : right;
+  const convertedRight = convertValueForSql(rightValue.value, dialect);
+  const opSql = COMPARISON_OP_SQL[expr.op];
+  if (!opSql) {
+    throw new UnsupportedPredicateError(
+      `Comparison operation "${expr.op}" is not supported`
+    );
+  }
+  return sql`${left} ${sql.raw(opSql)} ${convertedRight}`;
+}
+function compileArrayPredicate(expr, dialect, cteColumnPrefix) {
+  const field = compileFieldJsonValue(
+    expr.field,
+    dialect,
+    void 0,
+    void 0,
+    cteColumnPrefix
+  );
+  const values = expr.values?.map((v) => convertValueForSql(v.value, dialect)) ?? [];
+  switch (expr.op) {
+    case "isEmpty": {
+      return sql`(${field} IS NULL OR ${dialect.jsonArrayLength(field)} = 0)`;
+    }
+    case "isNotEmpty": {
+      return sql`(${field} IS NOT NULL AND ${dialect.jsonArrayLength(field)} > 0)`;
+    }
+    case "lengthEq": {
+      return sql`${dialect.jsonArrayLength(field)} = ${expr.length}`;
+    }
+    case "lengthGt": {
+      return sql`${dialect.jsonArrayLength(field)} > ${expr.length}`;
+    }
+    case "lengthGte": {
+      return sql`${dialect.jsonArrayLength(field)} >= ${expr.length}`;
+    }
+    case "lengthLt": {
+      return sql`${dialect.jsonArrayLength(field)} < ${expr.length}`;
+    }
+    case "lengthLte": {
+      return sql`${dialect.jsonArrayLength(field)} <= ${expr.length}`;
+    }
+    case "contains": {
+      const value = values[0];
+      if (value === void 0) {
+        return sql.raw("1=0");
+      }
+      return dialect.jsonArrayContains(field, value);
+    }
+    case "containsAll": {
+      return dialect.jsonArrayContainsAll(field, values);
+    }
+    case "containsAny": {
+      return dialect.jsonArrayContainsAny(field, values);
+    }
+  }
+}
+function compileObjectPredicate(expr, dialect, cteColumnPrefix) {
+  const basePointer = getFieldPointer(expr.field);
+  const pointer = joinJsonPointers(basePointer, expr.pointer);
+  const column = compileFieldColumn(expr.field, void 0, cteColumnPrefix);
+  switch (expr.op) {
+    case "hasKey":
+    case "hasPath": {
+      return dialect.jsonHasPath(column, pointer);
+    }
+    case "pathEquals": {
+      if (!expr.value) {
+        throw new UnsupportedPredicateError(
+          "pathEquals requires a comparison value"
+        );
+      }
+      const valueType = resolvePredicateValueType(expr.valueType, expr.value);
+      if (valueType === "array" || valueType === "object") {
+        throw new UnsupportedPredicateError(
+          "pathEquals is not supported for JSON arrays or objects"
+        );
+      }
+      const left = compileFieldValue(
+        expr.field,
+        dialect,
+        valueType,
+        void 0,
+        pointer,
+        cteColumnPrefix
+      );
+      return sql`${left} = ${convertValueForSql(expr.value.value, dialect)}`;
+    }
+    case "pathContains": {
+      if (!expr.value) {
+        throw new UnsupportedPredicateError(
+          "pathContains requires a comparison value"
+        );
+      }
+      const arrayField2 = compileFieldJsonValue(
+        expr.field,
+        dialect,
+        void 0,
+        pointer,
+        cteColumnPrefix
+      );
+      return dialect.jsonArrayContains(
+        arrayField2,
+        convertValueForSql(expr.value.value, dialect)
+      );
+    }
+    case "pathIsNull": {
+      return dialect.jsonPathIsNull(column, pointer);
+    }
+    case "pathIsNotNull": {
+      return dialect.jsonPathIsNotNull(column, pointer);
+    }
+  }
+}
+function compileAggregatePredicate(expr, dialect) {
+  const aggregate = compileAggregateExpr(expr.aggregate, dialect);
+  const op = COMPARISON_OP_SQL[expr.op];
+  if (!op) {
+    throw new UnsupportedPredicateError(
+      `Comparison operation "${expr.op}" is not supported for aggregate predicates`
+    );
+  }
+  const convertedValue = convertValueForSql(expr.value.value, dialect);
+  return sql`${aggregate} ${sql.raw(op)} ${convertedValue}`;
+}
+function compileAggregateExpr(expr, dialect) {
+  const cteAlias = `cte_${expr.field.alias}`;
+  const field = compileFieldValue(
+    expr.field,
+    dialect,
+    expr.field.valueType,
+    cteAlias
+  );
+  switch (expr.function) {
+    case "count": {
+      return sql`COUNT(${field})`;
+    }
+    case "countDistinct": {
+      return sql`COUNT(DISTINCT ${field})`;
+    }
+    case "sum": {
+      return sql`SUM(${field})`;
+    }
+    case "avg": {
+      return sql`AVG(${field})`;
+    }
+    case "min": {
+      return sql`MIN(${field})`;
+    }
+    case "max": {
+      return sql`MAX(${field})`;
+    }
+    default: {
+      throw new UnsupportedPredicateError(
+        `Unknown aggregate function: ${expr.function}`
+      );
+    }
+  }
+}
+function compileExistsSubquery(expr, ctx) {
+  if (expr.subquery.graphId === void 0) {
+    throw new UnsupportedPredicateError("EXISTS subquery must have a graphId");
+  }
+  const subSql = ctx.compileQuery(expr.subquery, expr.subquery.graphId);
+  return expr.negated ? sql`NOT EXISTS (${subSql})` : sql`EXISTS (${subSql})`;
+}
+function compileInSubquery(expr, ctx) {
+  const subqueryColumnCount = getSubqueryColumnCount(expr.subquery);
+  if (subqueryColumnCount !== 1) {
+    throw new UnsupportedPredicateError(
+      `IN/NOT IN subquery must project exactly 1 column, but got ${subqueryColumnCount}`,
+      { subqueryColumnCount }
+    );
+  }
+  const fieldValueType = normalizeValueType2(expr.field.valueType);
+  const subqueryValueType = getSingleSubqueryColumnValueType(expr.subquery);
+  const resolvedValueType = fieldValueType ?? subqueryValueType;
+  if (isUnsupportedInSubqueryValueType(resolvedValueType)) {
+    throw new UnsupportedPredicateError(
+      `IN/NOT IN subquery does not support ${String(resolvedValueType)} values`,
+      { valueType: resolvedValueType }
+    );
+  }
+  if (!isInSubqueryTypeCompatible(fieldValueType, subqueryValueType)) {
+    throw new UnsupportedPredicateError(
+      `IN/NOT IN type mismatch: field type "${String(fieldValueType)}" does not match subquery column type "${String(subqueryValueType)}"`,
+      {
+        fieldValueType,
+        subqueryValueType
+      }
+    );
+  }
+  const valueType = fieldValueType ?? subqueryValueType;
+  if (expr.subquery.graphId === void 0) {
+    throw new UnsupportedPredicateError(
+      "IN/NOT IN subquery must have a graphId"
+    );
+  }
+  const fieldSql = compileFieldValue(
+    expr.field,
+    ctx.dialect,
+    valueType,
+    void 0,
+    void 0,
+    ctx.cteColumnPrefix
+  );
+  const subSql = ctx.compileQuery(expr.subquery, expr.subquery.graphId);
+  return expr.negated ? sql`${fieldSql} NOT IN (${subSql})` : sql`${fieldSql} IN (${subSql})`;
+}
+function extractStructuralPredicates(predicates, isMatch, rejectionMessage) {
+  const results = [];
+  function visit(expr, inDisallowedBranch) {
+    if (isMatch(expr)) {
+      if (inDisallowedBranch) {
+        throw new UnsupportedPredicateError(rejectionMessage);
+      }
+      results.push(expr);
+      return;
+    }
+    switch (expr.__type) {
+      case "and": {
+        for (const child of expr.predicates) visit(child, inDisallowedBranch);
+        return;
+      }
+      case "or": {
+        for (const child of expr.predicates) visit(child, true);
+        return;
+      }
+      case "not": {
+        visit(expr.predicate, true);
+        return;
+      }
+      case "comparison":
+      case "string_op":
+      case "null_check":
+      case "between":
+      case "array_op":
+      case "object_op":
+      case "aggregate_comparison":
+      case "exists":
+      case "in_subquery":
+      case "vector_similarity":
+      case "fulltext_match": {
+        return;
+      }
+    }
+  }
+  for (const pred of predicates) visit(pred.expression, false);
+  return results;
+}
+function extractVectorSimilarityPredicates(predicates) {
+  return extractStructuralPredicates(
+    predicates,
+    (expr) => expr.__type === "vector_similarity",
+    "Vector similarity predicates cannot be nested under OR or NOT. Use top-level AND combinations instead."
+  );
+}
+function extractFulltextMatchPredicates(predicates) {
+  return extractStructuralPredicates(
+    predicates,
+    (expr) => expr.__type === "fulltext_match",
+    "Fulltext match predicates cannot be nested under OR or NOT. Use top-level AND combinations instead."
+  );
+}
+
+// src/query/compiler/predicate-utils.ts
+var EMPTY_PREDICATES = [];
+function sqlValueList(values) {
+  return sql.join(
+    values.map((value) => sql`${value}`),
+    sql`, `
+  );
+}
+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 (${sqlValueList(kinds)})`;
+}
+function getNodeKindsForAlias(ast, alias) {
+  if (alias === ast.start.alias) {
+    return ast.start.kinds;
+  }
+  for (const traversal of ast.traversals) {
+    if (traversal.nodeAlias === alias) {
+      return traversal.nodeKinds;
+    }
+  }
+  throw new CompilerInvariantError(`Unknown traversal source alias: ${alias}`);
+}
+function getHybridTargetAlias(vectorPredicate, fulltextPredicate) {
+  if (!vectorPredicate || !fulltextPredicate) return void 0;
+  return vectorPredicate.field.alias === fulltextPredicate.field.alias ? vectorPredicate.field.alias : void 0;
+}
+
 // src/store/row-fetch.ts
 async function getRowsByIds(ids, policy) {
   const rowsById = /* @__PURE__ */ new Map();
@@ -819,7 +2149,7 @@ async function getRowsByIds(ids, policy) {
 // src/store/edge-fetch.ts
 async function getEdgeRowsByIds(backend, graphId, ids) {
   return getRowsByIds(ids, {
-    batch: backend.getEdges === void 0 ? void 0 : (batchIds) => backend.getEdges(graphId, batchIds),
+    batch: backend.getEdges === void 0 ? void 0 : (batchIds) => requireDefined(backend.getEdges)(graphId, batchIds),
     one: (id) => backend.getEdge(graphId, id)
   });
 }
@@ -827,10 +2157,12 @@ async function getEdgeRowsByIds(backend, graphId, ids) {
 // src/store/node-fetch.ts
 async function getNodeRowsByIds(backend, graphId, kind, ids) {
   return getRowsByIds(ids, {
-    batch: backend.getNodes === void 0 ? void 0 : (batchIds) => backend.getNodes(graphId, kind, batchIds),
+    batch: backend.getNodes === void 0 ? void 0 : (batchIds) => requireDefined(backend.getNodes)(graphId, kind, batchIds),
     one: (id) => backend.getNode(graphId, kind, id)
   });
 }
+
+// src/store/recorded-capture/relations.ts
 var RECORDED_HISTORY_META = "{}";
 var RECORDED_NODE_COLUMNS = [
   "history_id",
@@ -894,6 +2226,9 @@ function recordedChunkSize(target, columnCount) {
   const budget = recordedBindParamBudget(target);
   return Math.max(1, Math.floor(budget / columnCount));
 }
+function sqlNull(value) {
+  return value === void 0 ? sql.raw("NULL") : sql`${value}`;
+}
 function recordedCommonCells() {
   return {
     history_id: () => sql`${generateId()}`,
@@ -1416,7 +2751,7 @@ function createRecordedTransactionBackend(target, session, schema) {
       async deleteEdgesBatch(params) {
         session.assertOpen();
         await lockGraph(params.graphId);
-        await target.deleteEdgesBatch(params);
+        await requireDefined(target.deleteEdgesBatch)(params);
         for (const id of params.ids) {
           session.touchEdge(params.graphId, id);
         }
@@ -1426,7 +2761,7 @@ function createRecordedTransactionBackend(target, session, schema) {
       async hardDeleteEdgesBatch(params) {
         session.assertOpen();
         await lockGraph(params.graphId);
-        await target.hardDeleteEdgesBatch(params);
+        await requireDefined(target.hardDeleteEdgesBatch)(params);
         for (const id of params.ids) {
           session.touchEdge(params.graphId, id);
         }
@@ -1463,7 +2798,8 @@ async function runCapturedAutocommit(backend, schema, fn, options) {
 function createRecordedBackend(backend, schema) {
   assertCapturableBackend(backend);
   const capture = (fn) => runCapturedAutocommit(backend, schema, fn);
-  return createBackendOverlay(backend, {
+  const projectedBackend = createGraphBackendProjection(backend);
+  return createBackendOverlay(projectedBackend, {
     ...rawWriteGuards(backend, "backend"),
     async insertNode(params) {
       return capture((target) => target.insertNode(params));
@@ -1533,12 +2869,16 @@ function createRecordedBackend(backend, schema) {
     },
     ...backend.deleteEdgesBatch === void 0 ? {} : {
       async deleteEdgesBatch(params) {
-        await capture((target) => target.deleteEdgesBatch(params));
+        await capture(
+          (target) => requireDefined(target.deleteEdgesBatch)(params)
+        );
       }
     },
     ...backend.hardDeleteEdgesBatch === void 0 ? {} : {
       async hardDeleteEdgesBatch(params) {
-        await capture((target) => target.hardDeleteEdgesBatch(params));
+        await capture(
+          (target) => requireDefined(target.hardDeleteEdgesBatch)(params)
+        );
       }
     },
     async transaction(fn, options) {
@@ -1549,18 +2889,11 @@ function createRecordedBackend(backend, schema) {
         await assertRecordedCaptureTransactionIsolation(target, backendOptions);
         const readOnly = backendOptions?.accessMode === "read_only";
         const scope = createRecordedTransactionScope(target, schema, !readOnly);
-        const result = await fn(scope.backend, createHistoryUnsafeSqlRef());
+        const result = await fn(scope.backend);
         const instants = await scope.flush();
         observer?.(instants);
         return result;
       }, backendOptions);
-    },
-    ...backend.adoptTransaction === void 0 ? {} : {
-      adoptTransaction(externalTx) {
-        throw recordedCaptureRequiresCallbackTransactionError({
-          externalTxType: typeof externalTx
-        });
-      }
     }
   });
 }
@@ -1823,8 +3156,8 @@ function checkWherePredicate(constraint, props) {
     return true;
   }
   const predicateBuilder = buildPredicateContext(props);
-  const predicate = constraint.where(predicateBuilder);
-  return evaluatePredicate(predicate, props);
+  const predicate2 = constraint.where(predicateBuilder);
+  return evaluatePredicate(predicate2, props);
 }
 function buildPredicateContext(props) {
   const context = {};
@@ -1844,11 +3177,11 @@ function buildPredicateContext(props) {
   }
   return context;
 }
-function evaluatePredicate(predicate, props) {
-  if (typeof predicate !== "object" || predicate === null || !("__type" in predicate)) {
+function evaluatePredicate(predicate2, props) {
+  if (typeof predicate2 !== "object" || predicate2 === null || !("__type" in predicate2)) {
     return true;
   }
-  const pred = predicate;
+  const pred = predicate2;
   if (pred.__type !== "unique_predicate") {
     return true;
   }
@@ -2159,7 +3492,7 @@ async function enforceNodeDeleteBehavior(ctx, args, backend, policy) {
     case "disconnect": {
       const batchDelete = args.mode === "hard" ? backend.hardDeleteEdgesBatch : backend.deleteEdgesBatch;
       if (batchDelete !== void 0) {
-        await batchDelete.call(backend, {
+        await batchDelete({
           graphId: ctx.graphId,
           ids: connectedEdges.map((edge) => edge.id)
         });
@@ -2350,6 +3683,6 @@ async function applyNodeResurrect(ctx, args, backend) {
   return row;
 }
 
-export { ALIAS_CTE_PREFIX, DEFAULT_SQL_SCHEMA, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS, advanceRevisionClock, applyNodeHardDelete, applyNodeInsertSideEffects, applyNodeInsertSideEffectsBatch, applyNodeResurrect, applyNodeSoftDelete, applyNodeUpdate, asRecordedInstant, assertRecordedCaptureTransactionIsolation, assertRevisionTrackableBackend, assertValidRecordedInstant, checkCardinality, checkDisjointness, checkUniqueEdge, checkUniquenessConstraints, checkWherePredicate, closeRecordedHardDeletedKind, computeFulltextContent, computeUniqueKey, coordinateContext, createHistoryUnsafeSqlRef, createNodeWriteContext, createRecordedBackend, createRecordedReadBinding, createRecordedTransactionScope, createRevisionTrackingUnsafeSqlRef, createSqlSchema, createUniquenessContext, describeCoordinate, edgeInsertDispatch, ensureRevisionOrigin, generateId, getEdgeRowsByIds, getEmbeddingFields, getKindsForUniquenessCheck, getNodeRowsByIds, lockRecordedGraphWrite, nodeInsertDispatch, readRecordedClock, readRevisionOrigin, recordedBindParamBudget, recordedCaptureRequiresCallbackTransactionError, recordedReadSchemaFor, recordedReadSqlSchema, recordedRelation, requireExternalRecordedReadSource, requireRecordedReadBinding, requireSqlSchema, resolveReadCoordinate, runInsertBatch, runInsertBatchReturning, runInsertNoReturn, uncapturedGraphWriteLock, validateEdgeEndpoints, vectorSlotKey, withRecordedCoordinate, withRecordedFlushObserver };
-//# sourceMappingURL=chunk-VKGKDOKR.js.map
-//# sourceMappingURL=chunk-VKGKDOKR.js.map
+export { ALIAS_CTE_PREFIX, AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, CURRENT_READ_INSTANT_PLACEHOLDER, DEFAULT_SQL_SCHEMA, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS, STORE_RUNTIME, TRANSACTION_RUNTIME, advanceRevisionClock, applyNodeHardDelete, applyNodeInsertSideEffects, applyNodeInsertSideEffectsBatch, applyNodeResurrect, applyNodeSoftDelete, applyNodeUpdate, arrayField, assertRecordedCaptureTransactionIsolation, assertRevisionTrackableBackend, baseField, buildFieldBuilderForTypeInfo, buildPredicateIndex, checkCardinality, checkDisjointness, checkUniqueEdge, checkUniquenessConstraints, checkWherePredicate, closeRecordedHardDeletedKind, compileFieldValue, compileKindFilter, compilePredicateClauses, compilePredicateExpression, compileTemporalFilter, computeFulltextContent, computeUniqueKey, createFulltextAccessor, createGraphBackendProjection, createNodeWriteContext, createRecordedBackend, createRecordedReadBinding, createRecordedTransactionScope, createSqlSchema, createUniquenessContext, currentReadInstant, currentReadInstantFor, dateField, edgeInsertDispatch, ensureRevisionOrigin, exists, extractFulltextMatchPredicates, extractTemporalOptions, extractVectorSimilarityPredicates, fieldRef, generateId, getEdgeRowsByIds, getEmbeddingFields, getFieldPointer, getHybridTargetAlias, getKindsForUniquenessCheck, getNodeKindsForAlias, getNodeRowsByIds, getPredicatesForAlias, inSubquery, isParameterRef, lockRecordedGraphWrite, nodeInsertDispatch, notExists, notInSubquery, numberField, objectField, param, projectBackendMembers, readRecordedClock, readRevisionOrigin, recordedBindParamBudget, recordedCaptureRequiresCallbackTransactionError, recordedReadSchemaFor, recordedReadSqlSchema, recordedRelation, requireExternalRecordedReadSource, requireRecordedReadBinding, requireSqlSchema, runInsertBatch, runInsertBatchReturning, runInsertNoReturn, sqlValueList, storeBackend, storeRuntime, stringField, throwHistoryUnsafeSqlAccess, throwRevisionTrackingUnsafeSqlAccess, transactionBackend, transactionNodeOperationHookRunner, uncapturedGraphWriteLock, validateEdgeEndpoints, vectorSlotKey, withPinnedReadInstant, withRecordedFlushObserver };
+//# sourceMappingURL=chunk-RQPRCEIO.js.map
+//# sourceMappingURL=chunk-RQPRCEIO.js.map