@nicia-ai/typegraph 0.37.1 → 0.38.0

package/dist/{chunk-WOJMKB3N.cjs → chunk-NWYCOFEZ.cjs}

@@ -1,103 +1,25 @@
 'use strict';
 
-var chunkIPSVVTWT_cjs = require('./chunk-IPSVVTWT.cjs');
-var chunk3GH67G4Z_cjs = require('./chunk-3GH67G4Z.cjs');
-var chunk7YSP4V4R_cjs = require('./chunk-7YSP4V4R.cjs');
+var chunkZDH3DX3C_cjs = require('./chunk-ZDH3DX3C.cjs');
+var chunkGNPGGLAE_cjs = require('./chunk-GNPGGLAE.cjs');
+var chunkSVUKGWSN_cjs = require('./chunk-SVUKGWSN.cjs');
+var chunkO5H62ZWJ_cjs = require('./chunk-O5H62ZWJ.cjs');
+var chunkDDCYVIVV_cjs = require('./chunk-DDCYVIVV.cjs');
+var chunkNAUA4PW5_cjs = require('./chunk-NAUA4PW5.cjs');
+var chunkZ5QHVL5U_cjs = require('./chunk-Z5QHVL5U.cjs');
+var chunkX6RDQ5NB_cjs = require('./chunk-X6RDQ5NB.cjs');
+var chunkSJDMVITW_cjs = require('./chunk-SJDMVITW.cjs');
+var chunk764JHTLT_cjs = require('./chunk-764JHTLT.cjs');
 var chunkHAHNRASW_cjs = require('./chunk-HAHNRASW.cjs');
-var chunkBVRDGYXQ_cjs = require('./chunk-BVRDGYXQ.cjs');
-var drizzleOrm = require('drizzle-orm');
+var chunkSAFZ6JTI_cjs = require('./chunk-SAFZ6JTI.cjs');
+var chunkTDXIBCGY_cjs = require('./chunk-TDXIBCGY.cjs');
 var nanoid = require('nanoid');
 
-// src/core/temporal.ts
-var RECORDED_MAX = "9999-12-31T23:59:59.999Z";
-function assertValidRecordedInstant(value, path) {
-  chunk3GH67G4Z_cjs.validateCanonicalIsoDate(value, path);
-  if (value >= RECORDED_MAX) {
-    throw new chunkBVRDGYXQ_cjs.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 chunkBVRDGYXQ_cjs.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 chunkBVRDGYXQ_cjs.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) {
-    chunk3GH67G4Z_cjs.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 = chunkX6RDQ5NB_cjs.typeGraphGlobalSymbol("sql-schema-v1");
+var SqlSchema = class {
+};
+var SqlSchemaDescriptor = class extends SqlSchema {
   tables;
   nodesTable;
   edgesTable;
@@ -107,6 +29,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;
@@ -115,7 +44,6 @@ var SqlSchemaDescriptor = class {
     this.recordedClockTable = fields.recordedClockTable;
     this.revisionOriginsTable = fields.revisionOriginsTable;
     this.fulltextTable = fields.fulltextTable;
-    void this.#brand;
     Object.freeze(this);
   }
 };
@@ -144,31 +72,30 @@ function resolveTableNames(names) {
 var VALID_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_$]*$/i;
 function validateTableName(name, label) {
   if (!name || name.length === 0) {
-    throw new chunkBVRDGYXQ_cjs.ConfigurationError(`${label} table name cannot be empty`);
+    throw new chunkSAFZ6JTI_cjs.ConfigurationError(`${label} table name cannot be empty`);
   }
-  if (name.length > chunk7YSP4V4R_cjs.MAX_PG_IDENTIFIER_LENGTH) {
-    throw new chunkBVRDGYXQ_cjs.ConfigurationError(
-      `${label} table name exceeds maximum length of ${chunk7YSP4V4R_cjs.MAX_PG_IDENTIFIER_LENGTH} characters`
+  if (name.length > chunkNAUA4PW5_cjs.MAX_PG_IDENTIFIER_LENGTH) {
+    throw new chunkSAFZ6JTI_cjs.ConfigurationError(
+      `${label} table name exceeds maximum length of ${chunkNAUA4PW5_cjs.MAX_PG_IDENTIFIER_LENGTH} characters`
     );
   }
   if (!VALID_IDENTIFIER_PATTERN.test(name)) {
-    throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+    throw new chunkSAFZ6JTI_cjs.ConfigurationError(
       `${label} table name "${name}" is not a valid SQL identifier. Table names must start with a letter or underscore and contain only letters, digits, underscores, or dollar signs.`
     );
   }
 }
-function 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"]) && chunkX6RDQ5NB_cjs.isSqlFragment(candidate["nodesTable"]) && chunkX6RDQ5NB_cjs.isSqlFragment(candidate["edgesTable"]) && chunkX6RDQ5NB_cjs.isSqlFragment(candidate["recordedNodesTable"]) && chunkX6RDQ5NB_cjs.isSqlFragment(candidate["recordedEdgesTable"]) && chunkX6RDQ5NB_cjs.isSqlFragment(candidate["recordedClockTable"]) && chunkX6RDQ5NB_cjs.isSqlFragment(candidate["revisionOriginsTable"]) && chunkX6RDQ5NB_cjs.isSqlFragment(candidate["fulltextTable"]) && Object.isFrozen(candidate);
 }
 function requireSqlSchema(schema, surface = "SqlSchema") {
   if (isSqlSchema(schema)) return schema;
-  throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+  throw new chunkSAFZ6JTI_cjs.ConfigurationError(
     `${surface} must be created with createSqlSchema(...).`,
     { code: "INVALID_SQL_SCHEMA", surface },
     {
@@ -188,20 +115,20 @@ function createSqlSchema(names = {}) {
   validateTableName(tables.uniques, "uniques");
   return freezeSqlSchema({
     tables: Object.freeze(tables),
-    nodesTable: drizzleOrm.sql.raw(quoteIdentifier(tables.nodes)),
-    edgesTable: drizzleOrm.sql.raw(quoteIdentifier(tables.edges)),
-    recordedNodesTable: drizzleOrm.sql.raw(quoteIdentifier(tables.recordedNodes)),
-    recordedEdgesTable: drizzleOrm.sql.raw(quoteIdentifier(tables.recordedEdges)),
-    recordedClockTable: drizzleOrm.sql.raw(quoteIdentifier(tables.recordedClock)),
-    revisionOriginsTable: drizzleOrm.sql.raw(quoteIdentifier(tables.revisionOrigins)),
-    fulltextTable: drizzleOrm.sql.raw(quoteIdentifier(tables.fulltext))
+    nodesTable: chunkX6RDQ5NB_cjs.sql.identifier(tables.nodes),
+    edgesTable: chunkX6RDQ5NB_cjs.sql.identifier(tables.edges),
+    recordedNodesTable: chunkX6RDQ5NB_cjs.sql.identifier(tables.recordedNodes),
+    recordedEdgesTable: chunkX6RDQ5NB_cjs.sql.identifier(tables.recordedEdges),
+    recordedClockTable: chunkX6RDQ5NB_cjs.sql.identifier(tables.recordedClock),
+    revisionOriginsTable: chunkX6RDQ5NB_cjs.sql.identifier(tables.revisionOrigins),
+    fulltextTable: chunkX6RDQ5NB_cjs.sql.identifier(tables.fulltext)
   });
 }
-var EXTERNAL_RECORDED_READ_SOURCE = /* @__PURE__ */ Symbol(
-  "ExternalRecordedReadSource"
+var EXTERNAL_RECORDED_READ_SOURCE = chunkX6RDQ5NB_cjs.typeGraphGlobalSymbol(
+  "external-recorded-read-source-v1"
 );
-var TYPEGRAPH_RECORDED_READ_SOURCE = /* @__PURE__ */ Symbol(
-  "TypeGraphRecordedReadSource"
+var TYPEGRAPH_RECORDED_READ_SOURCE = chunkX6RDQ5NB_cjs.typeGraphGlobalSymbol(
+  "typegraph-recorded-read-source-v1"
 );
 function recordedRelation(options) {
   const schema = requireSqlSchema(options.schema, "recordedRelation schema");
@@ -214,7 +141,7 @@ function recordedRelation(options) {
 function requireExternalRecordedReadSource(source) {
   if (source === void 0) return void 0;
   if (isExternalRecordedReadSource(source)) return source;
-  throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+  throw new chunkSAFZ6JTI_cjs.ConfigurationError(
     "recordedRead must be created with recordedRelation({ schema }).",
     { code: "INVALID_RECORDED_READ_SOURCE" },
     {
@@ -238,7 +165,7 @@ function createRecordedReadBinding(schema) {
 function requireRecordedReadBinding(binding, surface) {
   if (isRecordedReadBinding(binding)) return binding;
   if (binding !== void 0) {
-    throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+    throw new chunkSAFZ6JTI_cjs.ConfigurationError(
       "Recorded-time reads require a recorded read relation created by TypeGraph.",
       { code: "INVALID_RECORDED_READ_BINDING", surface },
       {
@@ -246,7 +173,7 @@ function requireRecordedReadBinding(binding, surface) {
       }
     );
   }
-  throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+  throw new chunkSAFZ6JTI_cjs.ConfigurationError(
     "Recorded-time reads require a recorded read relation.",
     { code: "RECORDED_READ_REQUIRES_BINDING", surface },
     {
@@ -291,12 +218,666 @@ 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 = chunkX6RDQ5NB_cjs.typeGraphGlobalSymbol(
+  "transaction-runtime-v1"
+);
+
+// src/store/runtime-port.ts
+var STORE_RUNTIME = chunkX6RDQ5NB_cjs.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 = chunkDDCYVIVV_cjs.nowIso();
+  try {
+    return emit();
+  } finally {
+    pinnedReadInstant = void 0;
+  }
+}
+function currentReadInstant() {
+  return chunkX6RDQ5NB_cjs.sql`${pinnedReadInstant ?? chunkDDCYVIVV_cjs.nowIso()}`;
+}
+var CURRENT_READ_INSTANT_PLACEHOLDER = "__typegraph_current_read_instant__";
+function currentReadInstantPlaceholder() {
+  return chunkX6RDQ5NB_cjs.sql`${chunkX6RDQ5NB_cjs.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 ? chunkX6RDQ5NB_cjs.sql.raw(`${tableAlias}.`) : chunkX6RDQ5NB_cjs.sql.raw("");
+  const deletedAt = chunkX6RDQ5NB_cjs.sql`${prefix}deleted_at`;
+  const validFrom = chunkX6RDQ5NB_cjs.sql`${prefix}valid_from`;
+  const validTo = chunkX6RDQ5NB_cjs.sql`${prefix}valid_to`;
+  const validFilter = (() => {
+    switch (mode) {
+      case "current": {
+        const now = recordedAsOf === void 0 ? currentTimestamp ?? currentReadInstant() : chunkX6RDQ5NB_cjs.sql`${recordedAsOf}`;
+        return chunkX6RDQ5NB_cjs.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 chunkX6RDQ5NB_cjs.sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${timestamp}) AND (${validTo} IS NULL OR ${validTo} > ${timestamp})`;
+      }
+      case "includeEnded": {
+        return chunkX6RDQ5NB_cjs.sql`${deletedAt} IS NULL`;
+      }
+      case "includeTombstones": {
+        return chunkX6RDQ5NB_cjs.sql.raw("1=1");
+      }
+    }
+  })();
+  if (recordedAsOf === void 0) return validFilter;
+  const recordedFrom = chunkX6RDQ5NB_cjs.sql`${prefix}recorded_from`;
+  const recordedTo = chunkX6RDQ5NB_cjs.sql`${prefix}recorded_to`;
+  return chunkX6RDQ5NB_cjs.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 chunkSAFZ6JTI_cjs.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 chunkSAFZ6JTI_cjs.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 chunkSAFZ6JTI_cjs.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 chunkSJDMVITW_cjs.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 = chunkTDXIBCGY_cjs.jsonPointer([key]);
+      const nestedPointer = chunkTDXIBCGY_cjs.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 = chunkTDXIBCGY_cjs.jsonPointer([key]);
+      resolvePointerTypeInfo(options?.typeInfo, pointer);
+      return objectOp("hasKey", field, pointer);
+    },
+    hasPath: (pointer) => {
+      const normalized = chunkTDXIBCGY_cjs.normalizeJsonPointer(pointer);
+      resolvePointerTypeInfo(options?.typeInfo, normalized);
+      return objectOp("hasPath", field, normalized);
+    },
+    pathEquals: (pointer, value) => {
+      const normalized = chunkTDXIBCGY_cjs.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 = chunkTDXIBCGY_cjs.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 = chunkTDXIBCGY_cjs.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 = chunkTDXIBCGY_cjs.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 = chunkTDXIBCGY_cjs.normalizeJsonPointer(pointer);
+      const nestedPointer = chunkTDXIBCGY_cjs.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 chunkSAFZ6JTI_cjs.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 chunkSAFZ6JTI_cjs.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 chunkSAFZ6JTI_cjs.UnsupportedPredicateError(
+    `IN/NOT IN type mismatch: field type "${String(fieldValueType)}" does not match subquery column type "${String(subqueryValueType)}"`,
+    {
+      fieldValueType,
+      subqueryValueType
+    }
+  );
+}
 function generateId() {
   return nanoid.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 chunkBVRDGYXQ_cjs.ConfigurationError(
+    throw new chunkSAFZ6JTI_cjs.ConfigurationError(
       "Recorded-time capture requires the backend to expose tableNames.",
       { dialect: target.dialect },
       {
@@ -308,7 +889,7 @@ function requireRecordedSchema(target) {
 }
 function requireCaptureStatements(target) {
   if (target.executeStatement === void 0) {
-    throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+    throw new chunkSAFZ6JTI_cjs.ConfigurationError(
       "Recorded-time capture requires backend.executeStatement support on the transaction backend.",
       { dialect: target.dialect },
       {
@@ -319,10 +900,10 @@ function requireCaptureStatements(target) {
 }
 async function executeStatement(target, query) {
   requireCaptureStatements(target);
-  await target.executeStatement(chunkIPSVVTWT_cjs.asCompiledStatementSql(query));
+  await target.executeStatement(chunkX6RDQ5NB_cjs.asCompiledStatementSql(query));
 }
 function unsupportedPostgresIsolationError(isolationLevel) {
-  return new chunkBVRDGYXQ_cjs.ConfigurationError(
+  return new chunkSAFZ6JTI_cjs.ConfigurationError(
     "Recorded-time capture on PostgreSQL requires read_committed isolation.",
     { isolationLevel: isolationLevel ?? "unknown" },
     {
@@ -334,7 +915,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;
@@ -345,10 +926,10 @@ 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(
-    chunkIPSVVTWT_cjs.asCompiledRowsSql(drizzleOrm.sql`
+    chunkX6RDQ5NB_cjs.asCompiledRowsSql(chunkX6RDQ5NB_cjs.sql`
       SELECT current_setting('transaction_isolation') AS transaction_isolation
     `)
   );
@@ -359,7 +940,7 @@ async function assertRecordedCaptureTransactionIsolation(target, options) {
   throw unsupportedPostgresIsolationError(isolationLevel);
 }
 function recordedCaptureRequiresCallbackTransactionError(details = {}) {
-  return new chunkBVRDGYXQ_cjs.ConfigurationError(
+  return new chunkSAFZ6JTI_cjs.ConfigurationError(
     "withTransaction() has no recorded-time capture flush point when history is enabled.",
     {
       ...details,
@@ -371,7 +952,7 @@ function recordedCaptureRequiresCallbackTransactionError(details = {}) {
   );
 }
 function historyUnsafeRawWriteError(surface) {
-  return new chunkBVRDGYXQ_cjs.ConfigurationError(
+  return new chunkSAFZ6JTI_cjs.ConfigurationError(
     `${surface} is not available when history capture is enabled because raw SQL writes bypass recorded-time capture.`,
     {
       code: "RECORDED_CAPTURE_RAW_SQL_DISABLED"
@@ -382,7 +963,7 @@ function historyUnsafeRawWriteError(surface) {
   );
 }
 function revisionTrackingUnsafeRawWriteError(surface) {
-  return new chunkBVRDGYXQ_cjs.ConfigurationError(
+  return new chunkSAFZ6JTI_cjs.ConfigurationError(
     `${surface} is not available when revision tracking is enabled because raw SQL writes bypass the revision anchor.`,
     {
       code: "REVISION_TRACKING_RAW_SQL_DISABLED"
@@ -392,57 +973,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 ? {} : {
@@ -463,7 +999,7 @@ function rawWriteGuards(target, prefix) {
 }
 function assertCapturableBackend(backend) {
   if (!backend.capabilities.transactions) {
-    throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+    throw new chunkSAFZ6JTI_cjs.ConfigurationError(
       "history: true requires a backend with transaction support.",
       { dialect: backend.dialect },
       {
@@ -472,7 +1008,7 @@ function assertCapturableBackend(backend) {
     );
   }
   if (backend.executeStatement === void 0) {
-    throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+    throw new chunkSAFZ6JTI_cjs.ConfigurationError(
       "history: true requires a backend that supports executeStatement.",
       { dialect: backend.dialect },
       {
@@ -481,7 +1017,7 @@ function assertCapturableBackend(backend) {
     );
   }
   if (backend.capabilities.returning === false) {
-    throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+    throw new chunkSAFZ6JTI_cjs.ConfigurationError(
       "history: true requires a backend that supports UPDATE \u2026 RETURNING.",
       { dialect: backend.dialect },
       {
@@ -490,7 +1026,7 @@ function assertCapturableBackend(backend) {
     );
   }
   if (backend.tableNames === void 0) {
-    throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+    throw new chunkSAFZ6JTI_cjs.ConfigurationError(
       "history: true requires a backend that exposes tableNames.",
       { dialect: backend.dialect },
       {
@@ -501,7 +1037,7 @@ function assertCapturableBackend(backend) {
 }
 function assertRevisionTrackableBackend(backend) {
   if (!backend.capabilities.transactions) {
-    throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+    throw new chunkSAFZ6JTI_cjs.ConfigurationError(
       "revisionTracking: true requires a backend with transaction support.",
       { dialect: backend.dialect },
       {
@@ -510,7 +1046,7 @@ function assertRevisionTrackableBackend(backend) {
     );
   }
   if (backend.executeStatement === void 0) {
-    throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+    throw new chunkSAFZ6JTI_cjs.ConfigurationError(
       "revisionTracking: true requires a backend that supports executeStatement.",
       { dialect: backend.dialect },
       {
@@ -519,7 +1055,7 @@ function assertRevisionTrackableBackend(backend) {
     );
   }
   if (backend.tableNames === void 0) {
-    throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+    throw new chunkSAFZ6JTI_cjs.ConfigurationError(
       "revisionTracking: true requires a backend that exposes tableNames.",
       { dialect: backend.dialect },
       {
@@ -528,7 +1064,7 @@ function assertRevisionTrackableBackend(backend) {
     );
   }
   if (backend.ensureRevisionOriginsTable === void 0) {
-    throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+    throw new chunkSAFZ6JTI_cjs.ConfigurationError(
       "revisionTracking: true requires a backend that can bootstrap revision origins.",
       { dialect: backend.dialect },
       {
@@ -540,11 +1076,15 @@ function assertRevisionTrackableBackend(backend) {
 
 // src/store/recorded-capture/clock.ts
 var RECORDED_MIN = "1970-01-01T00:00:00.000Z";
-var RECORDED_MAX_TIME = new Date(RECORDED_MAX).getTime();
+var RECORDED_MAX_TIME = new Date(chunkSVUKGWSN_cjs.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 drizzleOrm.sql`
+  return chunkX6RDQ5NB_cjs.sql`
     SELECT pg_advisory_xact_lock(
       hashtext(${namespace}),
       hashtext(${graphId})
@@ -576,11 +1116,13 @@ function registerRecordedGraphLockMemo(backend, memo) {
 }
 async function acquireRecordedGraphWriteLock(target, graphId) {
   await target.execute(
-    chunkIPSVVTWT_cjs.asCompiledRowsSql(recordedGraphWriteAdvisoryLockSql(graphId))
+    chunkX6RDQ5NB_cjs.asCompiledRowsSql(recordedGraphWriteAdvisoryLockSql(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);
@@ -600,7 +1142,7 @@ async function lockRecordedGraphWrite(target, graphId, memo) {
   return graphWriteLockEvidence();
 }
 function failInvalidClockTimestamp(value) {
-  throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+  throw new chunkSAFZ6JTI_cjs.ConfigurationError(
     "Recorded clock row contained an invalid timestamp",
     { value }
   );
@@ -622,7 +1164,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(chunk764JHTLT_cjs.requireDefined(offset))}`
+    );
   }
   return Date.parse(value);
 }
@@ -639,12 +1183,12 @@ function toCanonicalIso(value) {
   return failInvalidClockTimestamp(value);
 }
 function nextRecordedCommitTime(previous) {
-  const wallTime = Date.parse(chunk3GH67G4Z_cjs.nowIso());
+  const wallTime = Date.parse(chunkDDCYVIVV_cjs.nowIso());
   return previous === void 0 ? wallTime : Math.max(wallTime, Date.parse(previous) + 1);
 }
 async function readRecordedClock(target, schema, graphId) {
   const rows = await target.execute(
-    chunkIPSVVTWT_cjs.asCompiledRowsSql(drizzleOrm.sql`
+    chunkX6RDQ5NB_cjs.asCompiledRowsSql(chunkX6RDQ5NB_cjs.sql`
       SELECT recorded_at
       FROM ${schema.recordedClockTable}
       WHERE graph_id = ${graphId}
@@ -655,7 +1199,7 @@ async function readRecordedClock(target, schema, graphId) {
 }
 async function readRevisionOrigin(target, schema, graphId) {
   const rows = await target.execute(
-    chunkIPSVVTWT_cjs.asCompiledRowsSql(drizzleOrm.sql`
+    chunkX6RDQ5NB_cjs.asCompiledRowsSql(chunkX6RDQ5NB_cjs.sql`
       SELECT origin
       FROM ${schema.revisionOriginsTable}
       WHERE graph_id = ${graphId}
@@ -664,7 +1208,7 @@ async function readRevisionOrigin(target, schema, graphId) {
   const first = rows[0];
   if (first === void 0) return void 0;
   if (typeof first.origin !== "string" || first.origin.length === 0) {
-    throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+    throw new chunkSAFZ6JTI_cjs.ConfigurationError(
       "Revision origin row contained an invalid origin",
       { graphId, origin: first.origin }
     );
@@ -674,7 +1218,7 @@ async function readRevisionOrigin(target, schema, graphId) {
 async function ensureRevisionOrigin(target, schema, graphId) {
   const ensureTable = target.ensureRevisionOriginsTable;
   if (ensureTable === void 0) {
-    throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+    throw new chunkSAFZ6JTI_cjs.ConfigurationError(
       "Revision tracking requires a backend that can bootstrap revision origins.",
       { dialect: target.dialect },
       {
@@ -687,7 +1231,7 @@ async function ensureRevisionOrigin(target, schema, graphId) {
   if (existing !== void 0) return existing;
   await executeStatement(
     target,
-    drizzleOrm.sql`
+    chunkX6RDQ5NB_cjs.sql`
       INSERT INTO ${schema.revisionOriginsTable} (graph_id, origin)
       VALUES (${graphId}, ${generateId()})
       ON CONFLICT (graph_id) DO NOTHING
@@ -695,7 +1239,7 @@ async function ensureRevisionOrigin(target, schema, graphId) {
   );
   const origin = await readRevisionOrigin(target, schema, graphId);
   if (origin !== void 0) return origin;
-  throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+  throw new chunkSAFZ6JTI_cjs.ConfigurationError(
     "Revision origin was not persisted after initialization.",
     { graphId, dialect: target.dialect }
   );
@@ -703,7 +1247,7 @@ async function ensureRevisionOrigin(target, schema, graphId) {
 async function writeRecordedClock(target, schema, graphId, recordedAt) {
   await executeStatement(
     target,
-    drizzleOrm.sql`
+    chunkX6RDQ5NB_cjs.sql`
       INSERT INTO ${schema.recordedClockTable} (graph_id, recorded_at)
       VALUES (${graphId}, ${recordedAt})
       ON CONFLICT (graph_id) DO UPDATE SET recorded_at = ${recordedAt}
@@ -711,29 +1255,37 @@ async function writeRecordedClock(target, schema, graphId, recordedAt) {
   );
 }
 async function lockRecordedClock(target, schema, graphId, ownsWriteLock) {
-  if (target.dialect === "postgres") {
-    await target.execute(
-      chunkIPSVVTWT_cjs.asCompiledRowsSql(recordedClockAdvisoryLockSql(graphId))
-    );
-    return;
+  switch (target.dialect) {
+    case "postgres": {
+      await target.execute(
+        chunkX6RDQ5NB_cjs.asCompiledRowsSql(recordedClockAdvisoryLockSql(graphId))
+      );
+      return;
+    }
+    case "sqlite": {
+      if (ownsWriteLock) return;
+      await executeStatement(
+        target,
+        chunkX6RDQ5NB_cjs.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,
-    drizzleOrm.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);
   const previous = previousRevision ?? await readRecordedClock(target, schema, graphId);
   const recordedCommitTime = nextRecordedCommitTime(previous);
   if (!Number.isFinite(recordedCommitTime) || recordedCommitTime >= RECORDED_MAX_TIME) {
-    throw new chunkBVRDGYXQ_cjs.ConfigurationError(
-      `Recorded commit clock reached the open sentinel ${RECORDED_MAX}`,
+    throw new chunkSAFZ6JTI_cjs.ConfigurationError(
+      `Recorded commit clock reached the open sentinel ${chunkSVUKGWSN_cjs.RECORDED_MAX}`,
       { graphId, recordedCommitTime },
       {
         suggestion: "Use a graph with a normal recorded-time clock; the open sentinel is reserved for relation intervals."
@@ -754,21 +1306,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) => chunk764JHTLT_cjs.requireDefined(backend.insertNodeNoReturn)(params),
+    batch: backend.insertNodesBatch === void 0 ? void 0 : (params) => chunk764JHTLT_cjs.requireDefined(backend.insertNodesBatch)(params),
+    batchReturning: backend.insertNodesBatchReturning === void 0 ? void 0 : (params) => chunk764JHTLT_cjs.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) => chunk764JHTLT_cjs.requireDefined(backend.insertEdgeNoReturn)(params),
+    batch: backend.insertEdgesBatch === void 0 ? void 0 : (params) => chunk764JHTLT_cjs.requireDefined(backend.insertEdgesBatch)(params),
+    batchReturning: backend.insertEdgesBatchReturning === void 0 ? void 0 : (params) => chunk764JHTLT_cjs.requireDefined(backend.insertEdgesBatchReturning)(params)
   };
 }
 async function runInsertNoReturn(dispatch, params) {
@@ -799,6 +1455,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 chunkX6RDQ5NB_cjs.sql.raw(`${qualifier2}id`);
+    }
+    if (field.path.length === 1 && field.path[0] === "kind") {
+      return chunkX6RDQ5NB_cjs.sql.raw(`${qualifier2}kind`);
+    }
+    if (field.path.length > 0 && field.path[0] === "props") {
+      return chunkX6RDQ5NB_cjs.sql.raw(`${qualifier2}props`);
+    }
+    return chunkX6RDQ5NB_cjs.sql.raw(`${qualifier2}${field.path.join("_")}`);
+  }
+  const prefix = field.alias;
+  const qualifier = cteAlias ? `${cteAlias}.` : "";
+  if (field.path.length === 1 && field.path[0] === "id") {
+    return chunkX6RDQ5NB_cjs.sql.raw(`${qualifier}${prefix}_id`);
+  }
+  if (field.path.length === 1 && field.path[0] === "kind") {
+    return chunkX6RDQ5NB_cjs.sql.raw(`${qualifier}${prefix}_kind`);
+  }
+  if (field.path.length > 0 && field.path[0] === "props") {
+    return chunkX6RDQ5NB_cjs.sql.raw(`${qualifier}${prefix}_props`);
+  }
+  return chunkX6RDQ5NB_cjs.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 chunkTDXIBCGY_cjs.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 chunkSAFZ6JTI_cjs.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(
+    chunkZ5QHVL5U_cjs.LIKE_ESCAPE_CHARACTER,
+    `${chunkZ5QHVL5U_cjs.LIKE_ESCAPE_CHARACTER}${chunkZ5QHVL5U_cjs.LIKE_ESCAPE_CHARACTER}`
+  ).replaceAll("%", `${chunkZ5QHVL5U_cjs.LIKE_ESCAPE_CHARACTER}%`).replaceAll("_", `${chunkZ5QHVL5U_cjs.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 = `${chunkZ5QHVL5U_cjs.LIKE_ESCAPE_CHARACTER}${chunkZ5QHVL5U_cjs.LIKE_ESCAPE_CHARACTER}`;
+  return chunkX6RDQ5NB_cjs.sql`REPLACE(REPLACE(REPLACE(${parameter}, ${chunkZ5QHVL5U_cjs.LIKE_ESCAPE_CHARACTER}, ${doubledEscape}), '%', ${`${chunkZ5QHVL5U_cjs.LIKE_ESCAPE_CHARACTER}%`}), '_', ${`${chunkZ5QHVL5U_cjs.LIKE_ESCAPE_CHARACTER}_`})`;
+}
+function compileParameterizedStringPattern(op, parameter) {
+  switch (op) {
+    case "contains": {
+      const escaped = escapeLikePatternParameter(parameter);
+      return chunkX6RDQ5NB_cjs.sql`'%' || ${escaped} || '%'`;
+    }
+    case "startsWith": {
+      const escaped = escapeLikePatternParameter(parameter);
+      return chunkX6RDQ5NB_cjs.sql`${escaped} || '%'`;
+    }
+    case "endsWith": {
+      const escaped = escapeLikePatternParameter(parameter);
+      return chunkX6RDQ5NB_cjs.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 = chunkX6RDQ5NB_cjs.sql`${chunkX6RDQ5NB_cjs.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 chunkX6RDQ5NB_cjs.sql`${field} LIKE ${pattern2} ${chunkZ5QHVL5U_cjs.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 chunkX6RDQ5NB_cjs.sql`${field} LIKE ${pattern} ${chunkZ5QHVL5U_cjs.likeEscapeClause}`;
+    }
+    case "null_check": {
+      const field = compileFieldTextValue(
+        expr.field,
+        dialect,
+        void 0,
+        void 0,
+        cteColumnPrefix
+      );
+      return expr.op === "isNull" ? chunkX6RDQ5NB_cjs.sql`${field} IS NULL` : chunkX6RDQ5NB_cjs.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 chunkSAFZ6JTI_cjs.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 ? chunkX6RDQ5NB_cjs.sql.placeholder(expr.lower.name) : convertValueForSql(expr.lower.value, dialect);
+      const upper = upperIsParam ? chunkX6RDQ5NB_cjs.sql.placeholder(expr.upper.name) : convertValueForSql(expr.upper.value, dialect);
+      return chunkX6RDQ5NB_cjs.sql`${field} BETWEEN ${lower} AND ${upper}`;
+    }
+    case "and": {
+      const parts = expr.predicates.map(
+        (p) => compilePredicateExpression(p, ctx)
+      );
+      return chunkX6RDQ5NB_cjs.sql`(${chunkX6RDQ5NB_cjs.sql.join(parts, chunkX6RDQ5NB_cjs.sql` AND `)})`;
+    }
+    case "or": {
+      const parts = expr.predicates.map(
+        (p) => compilePredicateExpression(p, ctx)
+      );
+      return chunkX6RDQ5NB_cjs.sql`(${chunkX6RDQ5NB_cjs.sql.join(parts, chunkX6RDQ5NB_cjs.sql` OR `)})`;
+    }
+    case "not": {
+      const inner = compilePredicateExpression(expr.predicate, ctx);
+      return chunkX6RDQ5NB_cjs.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 = chunkX6RDQ5NB_cjs.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 chunkSAFZ6JTI_cjs.UnsupportedPredicateError(
+        `Comparison operation "${expr.op}" is not supported for parameterized predicates`
+      );
+    }
+    return chunkX6RDQ5NB_cjs.sql`${left2} ${chunkX6RDQ5NB_cjs.sql.raw(opSql2)} ${chunkX6RDQ5NB_cjs.sql.placeholder(expr.right.name)}`;
+  }
+  const valueType = resolveComparisonValueType(expr.left, expr.right);
+  if (valueType === "array" || valueType === "object") {
+    throw new chunkSAFZ6JTI_cjs.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" ? chunkX6RDQ5NB_cjs.sql.raw("1=0") : chunkX6RDQ5NB_cjs.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) ? chunk764JHTLT_cjs.requireDefined(right[0]) : right;
+  const convertedRight = convertValueForSql(rightValue.value, dialect);
+  const opSql = COMPARISON_OP_SQL[expr.op];
+  if (!opSql) {
+    throw new chunkSAFZ6JTI_cjs.UnsupportedPredicateError(
+      `Comparison operation "${expr.op}" is not supported`
+    );
+  }
+  return chunkX6RDQ5NB_cjs.sql`${left} ${chunkX6RDQ5NB_cjs.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 chunkX6RDQ5NB_cjs.sql`(${field} IS NULL OR ${dialect.jsonArrayLength(field)} = 0)`;
+    }
+    case "isNotEmpty": {
+      return chunkX6RDQ5NB_cjs.sql`(${field} IS NOT NULL AND ${dialect.jsonArrayLength(field)} > 0)`;
+    }
+    case "lengthEq": {
+      return chunkX6RDQ5NB_cjs.sql`${dialect.jsonArrayLength(field)} = ${expr.length}`;
+    }
+    case "lengthGt": {
+      return chunkX6RDQ5NB_cjs.sql`${dialect.jsonArrayLength(field)} > ${expr.length}`;
+    }
+    case "lengthGte": {
+      return chunkX6RDQ5NB_cjs.sql`${dialect.jsonArrayLength(field)} >= ${expr.length}`;
+    }
+    case "lengthLt": {
+      return chunkX6RDQ5NB_cjs.sql`${dialect.jsonArrayLength(field)} < ${expr.length}`;
+    }
+    case "lengthLte": {
+      return chunkX6RDQ5NB_cjs.sql`${dialect.jsonArrayLength(field)} <= ${expr.length}`;
+    }
+    case "contains": {
+      const value = values[0];
+      if (value === void 0) {
+        return chunkX6RDQ5NB_cjs.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 = chunkTDXIBCGY_cjs.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 chunkSAFZ6JTI_cjs.UnsupportedPredicateError(
+          "pathEquals requires a comparison value"
+        );
+      }
+      const valueType = resolvePredicateValueType(expr.valueType, expr.value);
+      if (valueType === "array" || valueType === "object") {
+        throw new chunkSAFZ6JTI_cjs.UnsupportedPredicateError(
+          "pathEquals is not supported for JSON arrays or objects"
+        );
+      }
+      const left = compileFieldValue(
+        expr.field,
+        dialect,
+        valueType,
+        void 0,
+        pointer,
+        cteColumnPrefix
+      );
+      return chunkX6RDQ5NB_cjs.sql`${left} = ${convertValueForSql(expr.value.value, dialect)}`;
+    }
+    case "pathContains": {
+      if (!expr.value) {
+        throw new chunkSAFZ6JTI_cjs.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 chunkSAFZ6JTI_cjs.UnsupportedPredicateError(
+      `Comparison operation "${expr.op}" is not supported for aggregate predicates`
+    );
+  }
+  const convertedValue = convertValueForSql(expr.value.value, dialect);
+  return chunkX6RDQ5NB_cjs.sql`${aggregate} ${chunkX6RDQ5NB_cjs.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 chunkX6RDQ5NB_cjs.sql`COUNT(${field})`;
+    }
+    case "countDistinct": {
+      return chunkX6RDQ5NB_cjs.sql`COUNT(DISTINCT ${field})`;
+    }
+    case "sum": {
+      return chunkX6RDQ5NB_cjs.sql`SUM(${field})`;
+    }
+    case "avg": {
+      return chunkX6RDQ5NB_cjs.sql`AVG(${field})`;
+    }
+    case "min": {
+      return chunkX6RDQ5NB_cjs.sql`MIN(${field})`;
+    }
+    case "max": {
+      return chunkX6RDQ5NB_cjs.sql`MAX(${field})`;
+    }
+    default: {
+      throw new chunkSAFZ6JTI_cjs.UnsupportedPredicateError(
+        `Unknown aggregate function: ${expr.function}`
+      );
+    }
+  }
+}
+function compileExistsSubquery(expr, ctx) {
+  if (expr.subquery.graphId === void 0) {
+    throw new chunkSAFZ6JTI_cjs.UnsupportedPredicateError("EXISTS subquery must have a graphId");
+  }
+  const subSql = ctx.compileQuery(expr.subquery, expr.subquery.graphId);
+  return expr.negated ? chunkX6RDQ5NB_cjs.sql`NOT EXISTS (${subSql})` : chunkX6RDQ5NB_cjs.sql`EXISTS (${subSql})`;
+}
+function compileInSubquery(expr, ctx) {
+  const subqueryColumnCount = getSubqueryColumnCount(expr.subquery);
+  if (subqueryColumnCount !== 1) {
+    throw new chunkSAFZ6JTI_cjs.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 chunkSAFZ6JTI_cjs.UnsupportedPredicateError(
+      `IN/NOT IN subquery does not support ${String(resolvedValueType)} values`,
+      { valueType: resolvedValueType }
+    );
+  }
+  if (!isInSubqueryTypeCompatible(fieldValueType, subqueryValueType)) {
+    throw new chunkSAFZ6JTI_cjs.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 chunkSAFZ6JTI_cjs.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 ? chunkX6RDQ5NB_cjs.sql`${fieldSql} NOT IN (${subSql})` : chunkX6RDQ5NB_cjs.sql`${fieldSql} IN (${subSql})`;
+}
+function extractStructuralPredicates(predicates, isMatch, rejectionMessage) {
+  const results = [];
+  function visit(expr, inDisallowedBranch) {
+    if (isMatch(expr)) {
+      if (inDisallowedBranch) {
+        throw new chunkSAFZ6JTI_cjs.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 chunkX6RDQ5NB_cjs.sql.join(
+    values.map((value) => chunkX6RDQ5NB_cjs.sql`${value}`),
+    chunkX6RDQ5NB_cjs.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 chunkX6RDQ5NB_cjs.sql`1 = 0`;
+  }
+  if (kinds.length === 1) {
+    return chunkX6RDQ5NB_cjs.sql`${column} = ${kinds[0]}`;
+  }
+  return chunkX6RDQ5NB_cjs.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 chunkSAFZ6JTI_cjs.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();
@@ -821,7 +2151,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) => chunk764JHTLT_cjs.requireDefined(backend.getEdges)(graphId, batchIds),
     one: (id) => backend.getEdge(graphId, id)
   });
 }
@@ -829,10 +2159,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) => chunk764JHTLT_cjs.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",
@@ -875,13 +2207,13 @@ var RECORDED_EDGE_COLUMNS = [
   "tx_id",
   "meta"
 ];
-var RECORDED_NODE_COLUMN_LIST = drizzleOrm.sql.raw(RECORDED_NODE_COLUMNS.join(", "));
-var RECORDED_EDGE_COLUMN_LIST = drizzleOrm.sql.raw(RECORDED_EDGE_COLUMNS.join(", "));
+var RECORDED_NODE_COLUMN_LIST = chunkX6RDQ5NB_cjs.sql.raw(RECORDED_NODE_COLUMNS.join(", "));
+var RECORDED_EDGE_COLUMN_LIST = chunkX6RDQ5NB_cjs.sql.raw(RECORDED_EDGE_COLUMNS.join(", "));
 var RECORDED_BIND_PARAM_BUDGET = 900;
 function recordedBindParamBudget(target) {
   const budget = target.capabilities.maxBindParameters ?? RECORDED_BIND_PARAM_BUDGET;
   if (!Number.isSafeInteger(budget) || budget < 1) {
-    throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+    throw new chunkSAFZ6JTI_cjs.ConfigurationError(
       `backend capabilities.maxBindParameters must be a positive integer, got: ${String(budget)}`,
       {
         code: "INVALID_BACKEND_CAPABILITY",
@@ -896,42 +2228,45 @@ function recordedChunkSize(target, columnCount) {
   const budget = recordedBindParamBudget(target);
   return Math.max(1, Math.floor(budget / columnCount));
 }
+function sqlNull(value) {
+  return value === void 0 ? chunkX6RDQ5NB_cjs.sql.raw("NULL") : chunkX6RDQ5NB_cjs.sql`${value}`;
+}
 function recordedCommonCells() {
   return {
-    history_id: () => drizzleOrm.sql`${generateId()}`,
-    graph_id: (row) => drizzleOrm.sql`${row.graph_id}`,
-    id: (row) => drizzleOrm.sql`${row.id}`,
-    kind: (row) => drizzleOrm.sql`${row.kind}`,
-    props: (row) => drizzleOrm.sql`${chunkIPSVVTWT_cjs.rowPropsToJsonText(row.props)}`,
-    valid_from: (row) => drizzleOrm.sql`${chunk7YSP4V4R_cjs.sqlNull(row.valid_from)}`,
-    valid_to: (row) => drizzleOrm.sql`${chunk7YSP4V4R_cjs.sqlNull(row.valid_to)}`,
-    created_at: (row) => drizzleOrm.sql`${row.created_at}`,
-    updated_at: (row) => drizzleOrm.sql`${row.updated_at}`,
-    deleted_at: (row) => drizzleOrm.sql`${chunk7YSP4V4R_cjs.sqlNull(row.deleted_at)}`,
-    recorded_from: (_row, recordedCommit) => drizzleOrm.sql`${recordedCommit}`,
-    recorded_to: () => drizzleOrm.sql`${RECORDED_MAX}`,
-    op: (_row, _recordedCommit, operation) => drizzleOrm.sql`${operation}`,
-    schema_version: () => drizzleOrm.sql`NULL`,
-    tx_id: () => drizzleOrm.sql`NULL`,
-    meta: () => drizzleOrm.sql`${RECORDED_HISTORY_META}`
+    history_id: () => chunkX6RDQ5NB_cjs.sql`${generateId()}`,
+    graph_id: (row) => chunkX6RDQ5NB_cjs.sql`${row.graph_id}`,
+    id: (row) => chunkX6RDQ5NB_cjs.sql`${row.id}`,
+    kind: (row) => chunkX6RDQ5NB_cjs.sql`${row.kind}`,
+    props: (row) => chunkX6RDQ5NB_cjs.sql`${chunkGNPGGLAE_cjs.rowPropsToJsonText(row.props)}`,
+    valid_from: (row) => chunkX6RDQ5NB_cjs.sql`${sqlNull(row.valid_from)}`,
+    valid_to: (row) => chunkX6RDQ5NB_cjs.sql`${sqlNull(row.valid_to)}`,
+    created_at: (row) => chunkX6RDQ5NB_cjs.sql`${row.created_at}`,
+    updated_at: (row) => chunkX6RDQ5NB_cjs.sql`${row.updated_at}`,
+    deleted_at: (row) => chunkX6RDQ5NB_cjs.sql`${sqlNull(row.deleted_at)}`,
+    recorded_from: (_row, recordedCommit) => chunkX6RDQ5NB_cjs.sql`${recordedCommit}`,
+    recorded_to: () => chunkX6RDQ5NB_cjs.sql`${chunkSVUKGWSN_cjs.RECORDED_MAX}`,
+    op: (_row, _recordedCommit, operation) => chunkX6RDQ5NB_cjs.sql`${operation}`,
+    schema_version: () => chunkX6RDQ5NB_cjs.sql`NULL`,
+    tx_id: () => chunkX6RDQ5NB_cjs.sql`NULL`,
+    meta: () => chunkX6RDQ5NB_cjs.sql`${RECORDED_HISTORY_META}`
   };
 }
 var recordedNodeCells = {
   ...recordedCommonCells(),
-  version: (row) => drizzleOrm.sql`${row.version}`
+  version: (row) => chunkX6RDQ5NB_cjs.sql`${row.version}`
 };
 var recordedEdgeCells = {
   ...recordedCommonCells(),
-  from_kind: (row) => drizzleOrm.sql`${row.from_kind}`,
-  from_id: (row) => drizzleOrm.sql`${row.from_id}`,
-  to_kind: (row) => drizzleOrm.sql`${row.to_kind}`,
-  to_id: (row) => drizzleOrm.sql`${row.to_id}`
+  from_kind: (row) => chunkX6RDQ5NB_cjs.sql`${row.from_kind}`,
+  from_id: (row) => chunkX6RDQ5NB_cjs.sql`${row.from_id}`,
+  to_kind: (row) => chunkX6RDQ5NB_cjs.sql`${row.to_kind}`,
+  to_id: (row) => chunkX6RDQ5NB_cjs.sql`${row.to_id}`
 };
 function recordedValuesTuple(columns, cells, row, recordedCommit, operation) {
   const tuple = columns.map(
     (column) => cells[column](row, recordedCommit, operation)
   );
-  return drizzleOrm.sql`(${drizzleOrm.sql.join(tuple, drizzleOrm.sql`, `)})`;
+  return chunkX6RDQ5NB_cjs.sql`(${chunkX6RDQ5NB_cjs.sql.join(tuple, chunkX6RDQ5NB_cjs.sql`, `)})`;
 }
 async function insertRecordedRows(target, table, columnList, columns, cells, inserts, recordedCommit) {
   if (inserts.length === 0) return;
@@ -946,9 +2281,9 @@ async function insertRecordedRows(target, table, columnList, columns, cells, ins
   );
   await executeStatement(
     target,
-    drizzleOrm.sql`
+    chunkX6RDQ5NB_cjs.sql`
       INSERT INTO ${table} (${columnList})
-      VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
+      VALUES ${chunkX6RDQ5NB_cjs.sql.join(values, chunkX6RDQ5NB_cjs.sql`, `)}
     `
   );
 }
@@ -993,22 +2328,22 @@ function entityKey(entity) {
   }
 }
 async function closeOpenReturning(target, table, graphId, ids, recordedCommit, kind) {
-  const kindFilter = kind === void 0 ? drizzleOrm.sql`` : drizzleOrm.sql`AND kind = ${kind}`;
+  const kindFilter = kind === void 0 ? chunkX6RDQ5NB_cjs.sql`` : chunkX6RDQ5NB_cjs.sql`AND kind = ${kind}`;
   const rows = await target.execute(
-    chunkIPSVVTWT_cjs.asCompiledRowsSql(drizzleOrm.sql`
+    chunkX6RDQ5NB_cjs.asCompiledRowsSql(chunkX6RDQ5NB_cjs.sql`
       UPDATE ${table}
       SET recorded_to = ${recordedCommit}
       WHERE graph_id = ${graphId}
         ${kindFilter}
-        AND recorded_to = ${RECORDED_MAX}
-        AND id IN (${chunkIPSVVTWT_cjs.sqlValueList(ids)})
+        AND recorded_to = ${chunkSVUKGWSN_cjs.RECORDED_MAX}
+        AND id IN (${sqlValueList(ids)})
       RETURNING id, deleted_at
     `)
   );
-  return new Map(rows.map((row) => [row.id, chunkIPSVVTWT_cjs.isPresent(row.deleted_at)]));
+  return new Map(rows.map((row) => [row.id, chunk764JHTLT_cjs.isPresent(row.deleted_at)]));
 }
 function recordedOp(hadOpenRow, priorRowWasTombstone, after) {
-  if (chunkIPSVVTWT_cjs.isPresent(after.deleted_at)) return "delete";
+  if (chunk764JHTLT_cjs.isPresent(after.deleted_at)) return "delete";
   if (!hadOpenRow || priorRowWasTombstone) return "create";
   return "update";
 }
@@ -1045,7 +2380,7 @@ function recordedInsertsFor(afterById, closed) {
 async function flushNodes(target, schema, graphId, entities, recordedCommit) {
   const chunkSize = recordedNodeChunkSize(target);
   for (const [kind, group] of groupNodesByKind(entities)) {
-    for (const entityChunk of chunkIPSVVTWT_cjs.chunk(group, chunkSize)) {
+    for (const entityChunk of chunkZDH3DX3C_cjs.chunk(group, chunkSize)) {
       const ids = entityChunk.map((entity) => entity.id);
       const closed = await closeOpenReturning(
         target,
@@ -1070,7 +2405,7 @@ async function flushNodes(target, schema, graphId, entities, recordedCommit) {
 }
 async function flushEdges(target, schema, graphId, entities, recordedCommit) {
   const chunkSize = recordedEdgeChunkSize(target);
-  for (const entityChunk of chunkIPSVVTWT_cjs.chunk(entities, chunkSize)) {
+  for (const entityChunk of chunkZDH3DX3C_cjs.chunk(entities, chunkSize)) {
     const ids = entityChunk.map((entity) => entity.id);
     const closed = await closeOpenReturning(
       target,
@@ -1094,24 +2429,24 @@ async function flushEdges(target, schema, graphId, entities, recordedCommit) {
 async function closeOpenByKind(target, table, graphId, kind, recordedCommit) {
   await executeStatement(
     target,
-    drizzleOrm.sql`
+    chunkX6RDQ5NB_cjs.sql`
       UPDATE ${table}
       SET recorded_to = ${recordedCommit}
       WHERE graph_id = ${graphId}
         AND kind = ${kind}
-        AND recorded_to = ${RECORDED_MAX}
+        AND recorded_to = ${chunkSVUKGWSN_cjs.RECORDED_MAX}
     `
   );
 }
 async function closeOpenEdgesByNodeKind(target, schema, graphId, nodeKind, recordedCommit) {
   await executeStatement(
     target,
-    drizzleOrm.sql`
+    chunkX6RDQ5NB_cjs.sql`
       UPDATE ${schema.recordedEdgesTable}
       SET recorded_to = ${recordedCommit}
       WHERE graph_id = ${graphId}
         AND (from_kind = ${nodeKind} OR to_kind = ${nodeKind})
-        AND recorded_to = ${RECORDED_MAX}
+        AND recorded_to = ${chunkSVUKGWSN_cjs.RECORDED_MAX}
     `
   );
 }
@@ -1149,7 +2484,7 @@ async function closeRecordedHardDeletedKind(target, schema, graphId, removal, ow
 }
 async function queryConnectedEdgeIds(target, schema, params) {
   const rows = await target.execute(
-    chunkIPSVVTWT_cjs.asCompiledRowsSql(drizzleOrm.sql`
+    chunkX6RDQ5NB_cjs.asCompiledRowsSql(chunkX6RDQ5NB_cjs.sql`
       SELECT id
       FROM ${schema.edgesTable}
       WHERE graph_id = ${params.graphId}
@@ -1197,7 +2532,7 @@ function edgeRowIdentityKey(row) {
   return edgeIdentityKey(row.graph_id, row.id);
 }
 function recordedCaptureSealedError(details) {
-  return new chunkBVRDGYXQ_cjs.ConfigurationError(
+  return new chunkSAFZ6JTI_cjs.ConfigurationError(
     "Recorded-time capture session is sealed: a graph write happened after the transaction's capture was flushed.",
     details,
     {
@@ -1230,7 +2565,7 @@ function createRecordedCaptureSession() {
     },
     async flush(target, schema, ownsWriteLock) {
       if (sealed) {
-        throw new chunkBVRDGYXQ_cjs.ConfigurationError(
+        throw new chunkSAFZ6JTI_cjs.ConfigurationError(
           "Recorded-time capture session was already flushed.",
           {},
           {
@@ -1241,7 +2576,7 @@ function createRecordedCaptureSession() {
       sealed = true;
       if (touched.size === 0) return /* @__PURE__ */ new Map();
       const recordedByGraph = /* @__PURE__ */ new Map();
-      const byGraph = chunkIPSVVTWT_cjs.groupBy(touched.values(), (entity) => entity.graphId);
+      const byGraph = chunkZDH3DX3C_cjs.groupBy(touched.values(), (entity) => entity.graphId);
       for (const [graphId, entities] of byGraph) {
         const recordedCommit = await allocateRecordedCommit(
           target,
@@ -1279,7 +2614,7 @@ function createRecordedTransactionBackend(target, session, schema) {
       await lockRecordedGraphWrite(target, graphId, graphLocks);
     }
   }
-  const overlay = chunkIPSVVTWT_cjs.createBackendOverlay(target, {
+  const overlay = chunkGNPGGLAE_cjs.createBackendOverlay(target, {
     ...rawWriteGuards(target, "tx.backend"),
     async insertNode(params) {
       session.assertOpen();
@@ -1418,7 +2753,7 @@ function createRecordedTransactionBackend(target, session, schema) {
       async deleteEdgesBatch(params) {
         session.assertOpen();
         await lockGraph(params.graphId);
-        await target.deleteEdgesBatch(params);
+        await chunk764JHTLT_cjs.requireDefined(target.deleteEdgesBatch)(params);
         for (const id of params.ids) {
           session.touchEdge(params.graphId, id);
         }
@@ -1428,7 +2763,7 @@ function createRecordedTransactionBackend(target, session, schema) {
       async hardDeleteEdgesBatch(params) {
         session.assertOpen();
         await lockGraph(params.graphId);
-        await target.hardDeleteEdgesBatch(params);
+        await chunk764JHTLT_cjs.requireDefined(target.hardDeleteEdgesBatch)(params);
         for (const id of params.ids) {
           session.touchEdge(params.graphId, id);
         }
@@ -1445,7 +2780,7 @@ function createRecordedTransactionScope(target, schema, ownsWriteLock = false) {
   return {
     backend: createRecordedTransactionBackend(target, session, resolvedSchema),
     async flush() {
-      return chunk3GH67G4Z_cjs.withRecordedRelationsPrecondition(
+      return chunkO5H62ZWJ_cjs.withRecordedRelationsPrecondition(
         session.flush(target, resolvedSchema, ownsWriteLock),
         { dialect: target.dialect, surface: "capture-flush" }
       );
@@ -1465,7 +2800,8 @@ async function runCapturedAutocommit(backend, schema, fn, options) {
 function createRecordedBackend(backend, schema) {
   assertCapturableBackend(backend);
   const capture = (fn) => runCapturedAutocommit(backend, schema, fn);
-  return chunkIPSVVTWT_cjs.createBackendOverlay(backend, {
+  const projectedBackend = createGraphBackendProjection(backend);
+  return chunkGNPGGLAE_cjs.createBackendOverlay(projectedBackend, {
     ...rawWriteGuards(backend, "backend"),
     async insertNode(params) {
       return capture((target) => target.insertNode(params));
@@ -1535,12 +2871,16 @@ function createRecordedBackend(backend, schema) {
     },
     ...backend.deleteEdgesBatch === void 0 ? {} : {
       async deleteEdgesBatch(params) {
-        await capture((target) => target.deleteEdgesBatch(params));
+        await capture(
+          (target) => chunk764JHTLT_cjs.requireDefined(target.deleteEdgesBatch)(params)
+        );
       }
     },
     ...backend.hardDeleteEdgesBatch === void 0 ? {} : {
       async hardDeleteEdgesBatch(params) {
-        await capture((target) => target.hardDeleteEdgesBatch(params));
+        await capture(
+          (target) => chunk764JHTLT_cjs.requireDefined(target.hardDeleteEdgesBatch)(params)
+        );
       }
     },
     async transaction(fn, options) {
@@ -1551,18 +2891,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
-        });
-      }
     }
   });
 }
@@ -1825,8 +3158,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 = {};
@@ -1846,11 +3179,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;
   }
@@ -1858,7 +3191,7 @@ function evaluatePredicate(predicate, props) {
   if (pred.op === "isNull") {
     return value === null || value === void 0;
   }
-  return chunkIPSVVTWT_cjs.isPresent(value);
+  return chunk764JHTLT_cjs.isPresent(value);
 }
 function getKindsForUniquenessCheck(baseKind, scope, registry) {
   if (scope === "kind") {
@@ -1887,7 +3220,7 @@ function checkCardinality(edgeKind, fromKind, fromId, cardinality, existingEdgeC
     }
     case "one": {
       if (existingEdgeCount > 0) {
-        return new chunkBVRDGYXQ_cjs.CardinalityError({
+        return new chunkSAFZ6JTI_cjs.CardinalityError({
           edgeKind,
           fromKind,
           fromId,
@@ -1902,7 +3235,7 @@ function checkCardinality(edgeKind, fromKind, fromId, cardinality, existingEdgeC
     }
     case "oneActive": {
       if (hasActiveEdge) {
-        return new chunkBVRDGYXQ_cjs.CardinalityError({
+        return new chunkSAFZ6JTI_cjs.CardinalityError({
           edgeKind,
           fromKind,
           fromId,
@@ -1916,7 +3249,7 @@ function checkCardinality(edgeKind, fromKind, fromId, cardinality, existingEdgeC
 }
 function checkUniqueEdge(edgeKind, fromKind, fromId, _toKind, _toId, existingCount) {
   if (existingCount > 0) {
-    return new chunkBVRDGYXQ_cjs.CardinalityError({
+    return new chunkSAFZ6JTI_cjs.CardinalityError({
       edgeKind,
       fromKind,
       fromId,
@@ -1929,7 +3262,7 @@ function checkUniqueEdge(edgeKind, fromKind, fromId, _toKind, _toId, existingCou
 function validateEdgeEndpoints(edgeKind, fromKind, toKind, registration, registry) {
   const validFromKinds = registration.from.map((node) => node.kind);
   if (!registry.isAssignableToAny(fromKind, validFromKinds)) {
-    return new chunkBVRDGYXQ_cjs.EndpointError({
+    return new chunkSAFZ6JTI_cjs.EndpointError({
       edgeKind,
       endpoint: "from",
       actualKind: fromKind,
@@ -1938,7 +3271,7 @@ function validateEdgeEndpoints(edgeKind, fromKind, toKind, registration, registr
   }
   const validToKinds = registration.to.map((node) => node.kind);
   if (!registry.isAssignableToAny(toKind, validToKinds)) {
-    return new chunkBVRDGYXQ_cjs.EndpointError({
+    return new chunkSAFZ6JTI_cjs.EndpointError({
       edgeKind,
       endpoint: "to",
       actualKind: toKind,
@@ -1950,7 +3283,7 @@ function validateEdgeEndpoints(edgeKind, fromKind, toKind, registration, registr
 function checkDisjointness(nodeId, nodeKind, existingKinds, registry) {
   for (const existingKind of existingKinds) {
     if (registry.areDisjoint(nodeKind, existingKind)) {
-      return new chunkBVRDGYXQ_cjs.DisjointError({
+      return new chunkSAFZ6JTI_cjs.DisjointError({
         nodeId,
         attemptedKind: nodeKind,
         conflictingKind: existingKind
@@ -1987,7 +3320,7 @@ async function checkUniquenessConstraints(ctx, kind, id, props, constraints) {
         key
       });
       if (existing && existing.node_id !== id) {
-        throw new chunkBVRDGYXQ_cjs.UniquenessError({
+        throw new chunkSAFZ6JTI_cjs.UniquenessError({
           constraintName: constraint.name,
           kind: kindToCheck,
           existingId: existing.node_id,
@@ -2093,7 +3426,7 @@ async function updateUniquenessEntries(ctx, kind, id, oldProps, newProps, constr
           key: newKey
         });
         if (existing && existing.node_id !== id) {
-          throw new chunkBVRDGYXQ_cjs.UniquenessError({
+          throw new chunkSAFZ6JTI_cjs.UniquenessError({
             constraintName: constraint.name,
             kind: kindToCheck,
             existingId: existing.node_id,
@@ -2150,7 +3483,7 @@ async function enforceNodeDeleteBehavior(ctx, args, backend, policy) {
   if (connectedEdges.length === 0) return;
   switch (behavior) {
     case "restrict": {
-      throw new chunkBVRDGYXQ_cjs.RestrictedDeleteError({
+      throw new chunkSAFZ6JTI_cjs.RestrictedDeleteError({
         nodeKind: args.kind,
         nodeId: args.id,
         edgeCount: connectedEdges.length,
@@ -2161,7 +3494,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)
         });
@@ -2223,7 +3556,7 @@ async function applyNodeInsertSideEffectsBatch(ctx, items, backend) {
   );
 }
 function parseRowProps(row) {
-  return chunkIPSVVTWT_cjs.rowPropsToObject(row.props);
+  return chunkGNPGGLAE_cjs.rowPropsToObject(row.props);
 }
 async function applyNodeUpdate(ctx, args, backend) {
   const { kind, id } = args.existing;
@@ -2353,10 +3686,14 @@ async function applyNodeResurrect(ctx, args, backend) {
 }
 
 exports.ALIAS_CTE_PREFIX = ALIAS_CTE_PREFIX;
+exports.AUTO_REFRESH_STATISTICS_ROW_THRESHOLD = AUTO_REFRESH_STATISTICS_ROW_THRESHOLD;
+exports.CURRENT_READ_INSTANT_PLACEHOLDER = CURRENT_READ_INSTANT_PLACEHOLDER;
 exports.DEFAULT_SQL_SCHEMA = DEFAULT_SQL_SCHEMA;
 exports.EMBEDDINGS_CTE_ALIAS = EMBEDDINGS_CTE_ALIAS;
 exports.FULLTEXT_CTE_ALIAS = FULLTEXT_CTE_ALIAS;
 exports.HYBRID_CANDIDATES_CTE_ALIAS = HYBRID_CANDIDATES_CTE_ALIAS;
+exports.STORE_RUNTIME = STORE_RUNTIME;
+exports.TRANSACTION_RUNTIME = TRANSACTION_RUNTIME;
 exports.advanceRevisionClock = advanceRevisionClock;
 exports.applyNodeHardDelete = applyNodeHardDelete;
 exports.applyNodeInsertSideEffects = applyNodeInsertSideEffects;
@@ -2364,37 +3701,62 @@ exports.applyNodeInsertSideEffectsBatch = applyNodeInsertSideEffectsBatch;
 exports.applyNodeResurrect = applyNodeResurrect;
 exports.applyNodeSoftDelete = applyNodeSoftDelete;
 exports.applyNodeUpdate = applyNodeUpdate;
-exports.asRecordedInstant = asRecordedInstant;
+exports.arrayField = arrayField;
 exports.assertRecordedCaptureTransactionIsolation = assertRecordedCaptureTransactionIsolation;
 exports.assertRevisionTrackableBackend = assertRevisionTrackableBackend;
-exports.assertValidRecordedInstant = assertValidRecordedInstant;
+exports.baseField = baseField;
+exports.buildFieldBuilderForTypeInfo = buildFieldBuilderForTypeInfo;
+exports.buildPredicateIndex = buildPredicateIndex;
 exports.checkCardinality = checkCardinality;
 exports.checkDisjointness = checkDisjointness;
 exports.checkUniqueEdge = checkUniqueEdge;
 exports.checkUniquenessConstraints = checkUniquenessConstraints;
 exports.checkWherePredicate = checkWherePredicate;
 exports.closeRecordedHardDeletedKind = closeRecordedHardDeletedKind;
+exports.compileFieldValue = compileFieldValue;
+exports.compileKindFilter = compileKindFilter;
+exports.compilePredicateClauses = compilePredicateClauses;
+exports.compilePredicateExpression = compilePredicateExpression;
+exports.compileTemporalFilter = compileTemporalFilter;
 exports.computeFulltextContent = computeFulltextContent;
 exports.computeUniqueKey = computeUniqueKey;
-exports.coordinateContext = coordinateContext;
-exports.createHistoryUnsafeSqlRef = createHistoryUnsafeSqlRef;
+exports.createFulltextAccessor = createFulltextAccessor;
+exports.createGraphBackendProjection = createGraphBackendProjection;
 exports.createNodeWriteContext = createNodeWriteContext;
 exports.createRecordedBackend = createRecordedBackend;
 exports.createRecordedReadBinding = createRecordedReadBinding;
 exports.createRecordedTransactionScope = createRecordedTransactionScope;
-exports.createRevisionTrackingUnsafeSqlRef = createRevisionTrackingUnsafeSqlRef;
 exports.createSqlSchema = createSqlSchema;
 exports.createUniquenessContext = createUniquenessContext;
-exports.describeCoordinate = describeCoordinate;
+exports.currentReadInstant = currentReadInstant;
+exports.currentReadInstantFor = currentReadInstantFor;
+exports.dateField = dateField;
 exports.edgeInsertDispatch = edgeInsertDispatch;
 exports.ensureRevisionOrigin = ensureRevisionOrigin;
+exports.exists = exists;
+exports.extractFulltextMatchPredicates = extractFulltextMatchPredicates;
+exports.extractTemporalOptions = extractTemporalOptions;
+exports.extractVectorSimilarityPredicates = extractVectorSimilarityPredicates;
+exports.fieldRef = fieldRef;
 exports.generateId = generateId;
 exports.getEdgeRowsByIds = getEdgeRowsByIds;
 exports.getEmbeddingFields = getEmbeddingFields;
+exports.getFieldPointer = getFieldPointer;
+exports.getHybridTargetAlias = getHybridTargetAlias;
 exports.getKindsForUniquenessCheck = getKindsForUniquenessCheck;
+exports.getNodeKindsForAlias = getNodeKindsForAlias;
 exports.getNodeRowsByIds = getNodeRowsByIds;
+exports.getPredicatesForAlias = getPredicatesForAlias;
+exports.inSubquery = inSubquery;
+exports.isParameterRef = isParameterRef;
 exports.lockRecordedGraphWrite = lockRecordedGraphWrite;
 exports.nodeInsertDispatch = nodeInsertDispatch;
+exports.notExists = notExists;
+exports.notInSubquery = notInSubquery;
+exports.numberField = numberField;
+exports.objectField = objectField;
+exports.param = param;
+exports.projectBackendMembers = projectBackendMembers;
 exports.readRecordedClock = readRecordedClock;
 exports.readRevisionOrigin = readRevisionOrigin;
 exports.recordedBindParamBudget = recordedBindParamBudget;
@@ -2405,14 +3767,21 @@ exports.recordedRelation = recordedRelation;
 exports.requireExternalRecordedReadSource = requireExternalRecordedReadSource;
 exports.requireRecordedReadBinding = requireRecordedReadBinding;
 exports.requireSqlSchema = requireSqlSchema;
-exports.resolveReadCoordinate = resolveReadCoordinate;
 exports.runInsertBatch = runInsertBatch;
 exports.runInsertBatchReturning = runInsertBatchReturning;
 exports.runInsertNoReturn = runInsertNoReturn;
+exports.sqlValueList = sqlValueList;
+exports.storeBackend = storeBackend;
+exports.storeRuntime = storeRuntime;
+exports.stringField = stringField;
+exports.throwHistoryUnsafeSqlAccess = throwHistoryUnsafeSqlAccess;
+exports.throwRevisionTrackingUnsafeSqlAccess = throwRevisionTrackingUnsafeSqlAccess;
+exports.transactionBackend = transactionBackend;
+exports.transactionNodeOperationHookRunner = transactionNodeOperationHookRunner;
 exports.uncapturedGraphWriteLock = uncapturedGraphWriteLock;
 exports.validateEdgeEndpoints = validateEdgeEndpoints;
 exports.vectorSlotKey = vectorSlotKey;
-exports.withRecordedCoordinate = withRecordedCoordinate;
+exports.withPinnedReadInstant = withPinnedReadInstant;
 exports.withRecordedFlushObserver = withRecordedFlushObserver;
-//# sourceMappingURL=chunk-WOJMKB3N.cjs.map
-//# sourceMappingURL=chunk-WOJMKB3N.cjs.map
+//# sourceMappingURL=chunk-NWYCOFEZ.cjs.map
+//# sourceMappingURL=chunk-NWYCOFEZ.cjs.map