@nicia-ai/typegraph 0.37.0 → 0.38.0

package/dist/chunk-44TA22QT.js

@@ -1,1478 +0,0 @@
-import { nowIso } from './chunk-XGPUQ56G.js';
-import { likeEscapeClause, LIKE_ESCAPE_CHARACTER } from './chunk-OHMP6N2J.js';
-import { resolveFieldTypeInfoAtJsonPointer } from './chunk-SNXVDZAJ.js';
-import { ConfigurationError, UnsupportedPredicateError, CompilerInvariantError } from './chunk-5PNMDJ7J.js';
-import { normalizeJsonPointer, joinJsonPointers, jsonPointer } from './chunk-G6Q5UM7U.js';
-import { sql } from 'drizzle-orm';
-
-// src/backend/types.ts
-function normalizeGraphAnalyticsCapabilities(capabilities) {
-  if (capabilities.graphAnalytics?.supported !== true || capabilities.transactions && capabilities.windowFunctions && capabilities.returning !== false) {
-    return capabilities;
-  }
-  return {
-    ...capabilities,
-    graphAnalytics: { ...capabilities.graphAnalytics, supported: false }
-  };
-}
-function rowPropsToObject(props) {
-  return typeof props === "string" ? JSON.parse(props) : props;
-}
-function rowPropsToJsonText(props) {
-  return typeof props === "string" ? props : JSON.stringify(props);
-}
-function isLiveNodeRow(row) {
-  return row.deleted_at === void 0;
-}
-function isTombstonedNodeRow(row) {
-  return row.deleted_at !== void 0;
-}
-var INTERNAL_TEMPORARY_WRITES = /* @__PURE__ */ Symbol(
-  "typegraph.internalTemporaryWrites"
-);
-function createBackendOverlay(target, overlay) {
-  const boundTargetMethods = /* @__PURE__ */ new Map();
-  function hasOverlayProperty(property) {
-    return Object.hasOwn(overlay, property);
-  }
-  function targetValue(targetObject, property) {
-    const value = Reflect.get(targetObject, property, targetObject);
-    if (typeof value !== "function") return value;
-    const cached = boundTargetMethods.get(property);
-    if (cached !== void 0) return cached;
-    const method = value;
-    const bound = method.bind(targetObject);
-    boundTargetMethods.set(property, bound);
-    return bound;
-  }
-  return new Proxy(target, {
-    get(targetObject, property) {
-      if (hasOverlayProperty(property)) {
-        return Reflect.get(overlay, property, overlay);
-      }
-      return targetValue(targetObject, property);
-    },
-    has(targetObject, property) {
-      return hasOverlayProperty(property) || Reflect.has(targetObject, property);
-    },
-    ownKeys(targetObject) {
-      return [
-        .../* @__PURE__ */ new Set([
-          ...Reflect.ownKeys(targetObject),
-          ...Reflect.ownKeys(overlay)
-        ])
-      ];
-    },
-    getOwnPropertyDescriptor(targetObject, property) {
-      if (hasOverlayProperty(property)) {
-        const descriptor = Reflect.getOwnPropertyDescriptor(overlay, property);
-        if (descriptor === void 0) return;
-        return { ...descriptor, configurable: true };
-      }
-      return Reflect.getOwnPropertyDescriptor(targetObject, property);
-    },
-    set(targetObject, property, value) {
-      if (hasOverlayProperty(property)) {
-        return Reflect.set(overlay, property, value, overlay);
-      }
-      return Reflect.set(targetObject, property, value, targetObject);
-    },
-    defineProperty(targetObject, property, attributes) {
-      if (hasOverlayProperty(property)) {
-        return Reflect.defineProperty(overlay, property, attributes);
-      }
-      return Reflect.defineProperty(targetObject, property, attributes);
-    },
-    deleteProperty(targetObject, property) {
-      if (hasOverlayProperty(property)) {
-        return Reflect.deleteProperty(overlay, property);
-      }
-      return Reflect.deleteProperty(targetObject, property);
-    }
-  });
-}
-function wrapWithManagedClose(backend, teardown) {
-  let isClosed = false;
-  return createBackendOverlay(backend, {
-    async close() {
-      if (isClosed) return;
-      isClosed = true;
-      await backend.close();
-      await teardown();
-    }
-  });
-}
-async function runOptionallyInTransaction(backend, fn, fallback) {
-  if ("transaction" in backend && backend.capabilities.transactions) {
-    return backend.transaction((tx) => fn(tx));
-  }
-  return fn(fallback ?? backend);
-}
-var SQLITE_MAX_BIND_PARAMETERS = 999;
-var MODERN_SQLITE_MAX_BIND_PARAMETERS = 32766;
-var D1_MAX_BIND_PARAMETERS = 100;
-var DURABLE_OBJECT_MAX_BIND_PARAMETERS = 100;
-var POSTGRES_MAX_BIND_PARAMETERS = 65535;
-var SQLITE_CAPABILITIES = {
-  transactions: true,
-  // SQLite supports transactions
-  windowFunctions: true,
-  // SQLite has supported window functions since 3.25.0
-  returning: true,
-  // SQLite has supported RETURNING since 3.35.0
-  maxBindParameters: SQLITE_MAX_BIND_PARAMETERS,
-  // Generic SQLite builds do not guarantee ENABLE_MATH_FUNCTIONS. The local
-  // better-sqlite3 factory overrides this flag for its bundled build contract.
-  graphAnalytics: { supported: true, mathFunctions: false }
-};
-var POSTGRES_CAPABILITIES = {
-  transactions: true,
-  // PostgreSQL supports transactions
-  windowFunctions: true,
-  // PostgreSQL supports ROW_NUMBER() and related windows
-  returning: true,
-  // PostgreSQL has supported RETURNING since 8.2
-  maxBindParameters: POSTGRES_MAX_BIND_PARAMETERS,
-  graphAnalytics: { supported: true, mathFunctions: true }
-};
-
-// src/query/sql-intent.ts
-function asCompiledRowsSql(query) {
-  return query;
-}
-function asCompiledSelectSql(query) {
-  return asCompiledRowsSql(query);
-}
-function asCompiledStatementSql(query) {
-  return query;
-}
-function asCompiledTemporaryStatementSql(query) {
-  return query;
-}
-var forceCustomPlanQueries = /* @__PURE__ */ new WeakSet();
-function markForceCustomPlan(query) {
-  forceCustomPlanQueries.add(query);
-}
-function shouldForceCustomPlan(query) {
-  return forceCustomPlanQueries.has(query);
-}
-var annIndexScanQueries = /* @__PURE__ */ new WeakMap();
-function markAnnIndexScan(query, indexTypes) {
-  annIndexScanQueries.set(query, indexTypes);
-}
-function annIndexScanTypes(query) {
-  return annIndexScanQueries.get(query);
-}
-function isRawExecutable(query) {
-  return !shouldForceCustomPlan(query) && annIndexScanTypes(query) === void 0;
-}
-var pinnedReadInstant;
-function withPinnedReadInstant(emit) {
-  if (pinnedReadInstant !== void 0) return emit();
-  pinnedReadInstant = nowIso();
-  try {
-    return emit();
-  } finally {
-    pinnedReadInstant = void 0;
-  }
-}
-function currentReadInstant() {
-  return sql`${pinnedReadInstant ?? nowIso()}`;
-}
-var CURRENT_READ_INSTANT_PLACEHOLDER = "__typegraph_current_read_instant__";
-function currentReadInstantPlaceholder() {
-  return sql`${sql.placeholder(CURRENT_READ_INSTANT_PLACEHOLDER)}`;
-}
-function currentReadInstantFor(mode) {
-  return mode === "placeholder" ? currentReadInstantPlaceholder() : currentReadInstant();
-}
-function compileTemporalFilter(options) {
-  const { mode, asOf, tableAlias, currentTimestamp, recordedAsOf } = options;
-  const prefix = tableAlias ? sql.raw(`${tableAlias}.`) : sql.raw("");
-  const deletedAt = sql`${prefix}deleted_at`;
-  const validFrom = sql`${prefix}valid_from`;
-  const validTo = sql`${prefix}valid_to`;
-  const validFilter = (() => {
-    switch (mode) {
-      case "current": {
-        const now = recordedAsOf === void 0 ? currentTimestamp ?? currentReadInstant() : sql`${recordedAsOf}`;
-        return sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${now}) AND (${validTo} IS NULL OR ${validTo} > ${now})`;
-      }
-      case "asOf": {
-        if (asOf === void 0) {
-          throw new Error(
-            `asOf timestamp is required for temporal mode "asOf"`
-          );
-        }
-        const timestamp = asOf;
-        return sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${timestamp}) AND (${validTo} IS NULL OR ${validTo} > ${timestamp})`;
-      }
-      case "includeEnded": {
-        return sql`${deletedAt} IS NULL`;
-      }
-      case "includeTombstones": {
-        return sql.raw("1=1");
-      }
-    }
-  })();
-  if (recordedAsOf === void 0) return validFilter;
-  const recordedFrom = sql`${prefix}recorded_from`;
-  const recordedTo = sql`${prefix}recorded_to`;
-  return sql`(${validFilter}) AND ${recordedFrom} <= ${recordedAsOf} AND ${recordedAsOf} < ${recordedTo}`;
-}
-function extractTemporalOptions(ast, tableAlias) {
-  return {
-    mode: ast.temporalMode.mode,
-    asOf: ast.temporalMode.asOf,
-    recordedAsOf: ast.recordedAsOf,
-    tableAlias
-  };
-}
-
-// src/query/subquery-utils.ts
-function normalizeValueType(valueType) {
-  if (valueType === void 0 || valueType === "unknown") {
-    return void 0;
-  }
-  return valueType;
-}
-function isUnsupportedInSubqueryValueType(valueType) {
-  const normalized = normalizeValueType(valueType);
-  return normalized === "array" || normalized === "object" || normalized === "embedding";
-}
-function isInSubqueryTypeCompatible(left, right) {
-  const normalizedLeft = normalizeValueType(left);
-  const normalizedRight = normalizeValueType(right);
-  if (normalizedLeft === void 0 || normalizedRight === void 0) {
-    return true;
-  }
-  return normalizedLeft === normalizedRight;
-}
-function getAggregateValueType(aggregate) {
-  switch (aggregate.function) {
-    case "count":
-    case "countDistinct":
-    case "sum":
-    case "avg": {
-      return "number";
-    }
-    case "min":
-    case "max": {
-      return normalizeValueType(aggregate.field.valueType);
-    }
-  }
-}
-function getProjectedValueTypes(subquery) {
-  if (subquery.selectiveFields && subquery.selectiveFields.length > 0) {
-    return subquery.selectiveFields.map(
-      (field) => normalizeValueType(field.valueType)
-    );
-  }
-  return subquery.projection.fields.map((field) => {
-    if (field.source.__type === "aggregate") {
-      return getAggregateValueType(field.source);
-    }
-    return normalizeValueType(field.source.valueType);
-  });
-}
-function getSubqueryColumnCount(subquery) {
-  return getProjectedValueTypes(subquery).length;
-}
-function getSingleSubqueryColumnValueType(subquery) {
-  const valueTypes = getProjectedValueTypes(subquery);
-  if (valueTypes.length !== 1) {
-    return void 0;
-  }
-  return valueTypes[0];
-}
-
-// src/query/predicates.ts
-function predicate(expr) {
-  return {
-    __expr: expr,
-    and: (other) => predicate({
-      __type: "and",
-      predicates: [expr, other.__expr]
-    }),
-    or: (other) => predicate({
-      __type: "or",
-      predicates: [expr, other.__expr]
-    }),
-    not: () => predicate({
-      __type: "not",
-      predicate: expr
-    })
-  };
-}
-function param(name) {
-  if (name === CURRENT_READ_INSTANT_PLACEHOLDER) {
-    throw new ConfigurationError(
-      `Parameter name "${name}" is reserved for internal use`,
-      { parameterName: name }
-    );
-  }
-  return { __type: "parameter", name };
-}
-function isParameterRef(value) {
-  if (typeof value !== "object" || value === null) return false;
-  return value.__type === "parameter";
-}
-function fieldRef(alias, path, options) {
-  return {
-    __type: "field_ref",
-    alias,
-    path,
-    ...options?.jsonPointer !== void 0 && {
-      jsonPointer: options.jsonPointer
-    },
-    ...options?.valueType !== void 0 && { valueType: options.valueType },
-    ...options?.elementType !== void 0 && {
-      elementType: options.elementType
-    }
-  };
-}
-function coerceLiteralValue(value) {
-  if (value instanceof Date) {
-    return value;
-  }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  throw new Error(`Unsupported literal value type: ${typeof value}`);
-}
-function inferLiteralValueType(value) {
-  if (typeof value === "string") {
-    return "string";
-  }
-  if (typeof value === "number") {
-    return "number";
-  }
-  return "boolean";
-}
-function literal(value) {
-  if (value instanceof Date) {
-    return { __type: "literal", value: value.toISOString(), valueType: "date" };
-  }
-  const valueType = inferLiteralValueType(value);
-  return {
-    __type: "literal",
-    value,
-    valueType
-  };
-}
-function comparison(op, field, value) {
-  if (isParameterRef(value)) {
-    const expr2 = {
-      __type: "comparison",
-      op,
-      left: field,
-      right: value
-    };
-    return predicate(expr2);
-  }
-  const coercedValue = coerceLiteralValue(value);
-  const expr = {
-    __type: "comparison",
-    op,
-    left: field,
-    right: literal(coercedValue)
-  };
-  return predicate(expr);
-}
-function inComparison(op, field, values) {
-  const literals = values.map((value) => literal(coerceLiteralValue(value)));
-  const expr = {
-    __type: "comparison",
-    op,
-    left: field,
-    right: literals
-  };
-  return predicate(expr);
-}
-function stringOp(op, field, pattern) {
-  if (isParameterRef(pattern)) {
-    const expr2 = {
-      __type: "string_op",
-      op,
-      field,
-      pattern
-    };
-    return predicate(expr2);
-  }
-  const expr = {
-    __type: "string_op",
-    op,
-    field,
-    pattern
-  };
-  return predicate(expr);
-}
-function nullCheck(op, field) {
-  const expr = {
-    __type: "null_check",
-    op,
-    field
-  };
-  return predicate(expr);
-}
-function between(field, lower, upper) {
-  const expr = {
-    __type: "between",
-    field,
-    lower: isParameterRef(lower) ? lower : literal(lower),
-    upper: isParameterRef(upper) ? upper : literal(upper)
-  };
-  return predicate(expr);
-}
-function baseFieldBuilder(field) {
-  return {
-    eq: (value) => comparison("eq", field, value),
-    neq: (value) => comparison("neq", field, value),
-    isNull: () => nullCheck("isNull", field),
-    isNotNull: () => nullCheck("isNotNull", field),
-    in: (values) => inComparison("in", field, values),
-    notIn: (values) => inComparison("notIn", field, values)
-  };
-}
-function stringField(field) {
-  return {
-    ...baseFieldBuilder(field),
-    gt: (value) => comparison("gt", field, value),
-    gte: (value) => comparison("gte", field, value),
-    lt: (value) => comparison("lt", field, value),
-    lte: (value) => comparison("lte", field, value),
-    contains: (pattern) => stringOp("contains", field, pattern),
-    startsWith: (pattern) => stringOp("startsWith", field, pattern),
-    endsWith: (pattern) => stringOp("endsWith", field, pattern),
-    like: (pattern) => stringOp("like", field, pattern),
-    ilike: (pattern) => stringOp("ilike", field, pattern)
-  };
-}
-var DEFAULT_FULLTEXT_MATCH_K = 50;
-function createFulltextAccessor(alias, hasSearchableField) {
-  return {
-    matches: (query, k, options) => {
-      if (!hasSearchableField()) {
-        throw new UnsupportedPredicateError(
-          `Cannot call .$fulltext.matches() on alias "${alias}" \u2014 its node kind has no fields declared with searchable(). Add at least one: \`title: searchable({ language: "english" })\`.`
-        );
-      }
-      return fulltextMatch(
-        fieldRef(alias, ["$fulltext"]),
-        query,
-        k ?? DEFAULT_FULLTEXT_MATCH_K,
-        options
-      );
-    }
-  };
-}
-function fulltextMatch(field, query, limit, options) {
-  if (!Number.isFinite(limit) || limit <= 0) {
-    throw new UnsupportedPredicateError(
-      `matches() limit must be a positive finite number, got ${String(limit)}`
-    );
-  }
-  const expr = {
-    __type: "fulltext_match",
-    field,
-    query,
-    mode: options?.mode ?? "websearch",
-    limit,
-    ...options?.language === void 0 ? {} : { language: options.language },
-    ...options?.minScore === void 0 ? {} : { minScore: options.minScore }
-  };
-  return predicate(expr);
-}
-function numberField(field) {
-  return {
-    ...baseFieldBuilder(field),
-    gt: (value) => comparison("gt", field, value),
-    gte: (value) => comparison("gte", field, value),
-    lt: (value) => comparison("lt", field, value),
-    lte: (value) => comparison("lte", field, value),
-    between: (lower, upper) => between(field, lower, upper)
-  };
-}
-function dateField(field) {
-  return {
-    ...baseFieldBuilder(field),
-    gt: (value) => comparison("gt", field, value),
-    gte: (value) => comparison("gte", field, value),
-    lt: (value) => comparison("lt", field, value),
-    lte: (value) => comparison("lte", field, value),
-    between: (lower, upper) => between(field, lower, upper)
-  };
-}
-function baseField(field) {
-  return baseFieldBuilder(field);
-}
-function arrayOp(op, field, values, length) {
-  const expr = {
-    __type: "array_op",
-    op,
-    field,
-    ...values !== void 0 && {
-      values: values.map((value) => literal(coerceLiteralValue(value)))
-    },
-    ...length !== void 0 && { length }
-  };
-  return predicate(expr);
-}
-function arrayField(field) {
-  return {
-    ...baseFieldBuilder(field),
-    contains: (value) => arrayOp("contains", field, [value]),
-    containsAll: (values) => arrayOp("containsAll", field, values),
-    containsAny: (values) => arrayOp("containsAny", field, values),
-    isEmpty: () => arrayOp("isEmpty", field),
-    isNotEmpty: () => arrayOp("isNotEmpty", field),
-    lengthEq: (length) => arrayOp("lengthEq", field, void 0, length),
-    lengthGt: (length) => arrayOp("lengthGt", field, void 0, length),
-    lengthGte: (length) => arrayOp("lengthGte", field, void 0, length),
-    lengthLt: (length) => arrayOp("lengthLt", field, void 0, length),
-    lengthLte: (length) => arrayOp("lengthLte", field, void 0, length)
-  };
-}
-function vectorSimilarity(field, queryEmbedding, limit, options) {
-  const expr = {
-    __type: "vector_similarity",
-    field,
-    queryEmbedding,
-    // Leave metric unset when the caller didn't specify one, so the compiler
-    // resolves the field's declared metric per kind. Defaulting to "cosine"
-    // here would mis-rank l2/inner_product fields and bypass their ANN index.
-    ...options?.metric !== void 0 && { metric: options.metric },
-    limit,
-    ...options?.minScore !== void 0 && { minScore: options.minScore },
-    ...options?.approximate !== void 0 && {
-      approximate: options.approximate
-    }
-  };
-  return predicate(expr);
-}
-function embeddingField(field) {
-  return {
-    ...baseFieldBuilder(field),
-    similarTo: (queryEmbedding, k, options) => vectorSimilarity(field, queryEmbedding, k, options)
-  };
-}
-function buildFieldBuilderForTypeInfo(field, typeInfo) {
-  if (!typeInfo) {
-    return baseField(field);
-  }
-  switch (typeInfo.valueType) {
-    case "string": {
-      return stringField(field);
-    }
-    case "number": {
-      return numberField(field);
-    }
-    case "boolean": {
-      return baseField(field);
-    }
-    case "date": {
-      return dateField(field);
-    }
-    case "array": {
-      return arrayField(field);
-    }
-    case "object": {
-      return objectField(field, { typeInfo });
-    }
-    case "embedding": {
-      return embeddingField(field);
-    }
-    case "unknown": {
-      return baseField(field);
-    }
-  }
-}
-function resolvePointerTypeInfo(typeInfo, pointer) {
-  return resolveFieldTypeInfoAtJsonPointer(typeInfo, pointer);
-}
-function objectOp(op, field, pointer, value, options) {
-  const expr = {
-    __type: "object_op",
-    op,
-    field,
-    pointer,
-    ...value !== void 0 && {
-      value: literal(coerceLiteralValue(value))
-    },
-    ...options?.valueType !== void 0 && { valueType: options.valueType },
-    ...options?.elementType !== void 0 && {
-      elementType: options.elementType
-    }
-  };
-  return predicate(expr);
-}
-function objectField(field, options) {
-  const basePointer = field.jsonPointer;
-  return {
-    ...baseFieldBuilder(field),
-    get: (key) => {
-      const pointer = jsonPointer([key]);
-      const nestedPointer = joinJsonPointers(basePointer, pointer);
-      const resolved = resolvePointerTypeInfo(options?.typeInfo, pointer);
-      const nestedRef = fieldRef(field.alias, field.path, {
-        jsonPointer: nestedPointer,
-        ...resolved?.valueType !== void 0 && {
-          valueType: resolved.valueType
-        },
-        ...resolved?.elementType !== void 0 && {
-          elementType: resolved.elementType
-        }
-      });
-      return buildFieldBuilderForTypeInfo(nestedRef, resolved);
-    },
-    hasKey: (key) => {
-      const pointer = jsonPointer([key]);
-      resolvePointerTypeInfo(options?.typeInfo, pointer);
-      return objectOp("hasKey", field, pointer);
-    },
-    hasPath: (pointer) => {
-      const normalized = normalizeJsonPointer(pointer);
-      resolvePointerTypeInfo(options?.typeInfo, normalized);
-      return objectOp("hasPath", field, normalized);
-    },
-    pathEquals: (pointer, value) => {
-      const normalized = normalizeJsonPointer(pointer);
-      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
-      if (resolved && (resolved.valueType === "array" || resolved.valueType === "object")) {
-        throw new Error("pathEquals is only supported for scalar JSON values");
-      }
-      const predicateOptions = resolved?.valueType === void 0 ? void 0 : { valueType: resolved.valueType };
-      return objectOp("pathEquals", field, normalized, value, predicateOptions);
-    },
-    pathContains: (pointer, value) => {
-      const normalized = normalizeJsonPointer(pointer);
-      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
-      if (resolved && resolved.valueType !== "array") {
-        throw new Error("pathContains is only supported for JSON array values");
-      }
-      const predicateOptions = resolved?.elementType === void 0 ? void 0 : { elementType: resolved.elementType };
-      return objectOp(
-        "pathContains",
-        field,
-        normalized,
-        value,
-        predicateOptions
-      );
-    },
-    pathIsNull: (pointer) => {
-      const normalized = normalizeJsonPointer(pointer);
-      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
-      const predicateOptions = resolved?.valueType === void 0 ? void 0 : { valueType: resolved.valueType };
-      return objectOp(
-        "pathIsNull",
-        field,
-        normalized,
-        void 0,
-        predicateOptions
-      );
-    },
-    pathIsNotNull: (pointer) => {
-      const normalized = normalizeJsonPointer(pointer);
-      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
-      const predicateOptions = resolved?.valueType === void 0 ? void 0 : { valueType: resolved.valueType };
-      return objectOp(
-        "pathIsNotNull",
-        field,
-        normalized,
-        void 0,
-        predicateOptions
-      );
-    },
-    field: (pointer) => {
-      const normalized = normalizeJsonPointer(pointer);
-      const nestedPointer = joinJsonPointers(basePointer, normalized);
-      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
-      const nestedRef = fieldRef(field.alias, field.path, {
-        jsonPointer: nestedPointer,
-        ...resolved?.valueType !== void 0 && {
-          valueType: resolved.valueType
-        },
-        ...resolved?.elementType !== void 0 && {
-          elementType: resolved.elementType
-        }
-      });
-      return buildFieldBuilderForTypeInfo(nestedRef, resolved);
-    }
-  };
-}
-function exists(subquery) {
-  const expr = {
-    __type: "exists",
-    subquery,
-    negated: false
-  };
-  return predicate(expr);
-}
-function notExists(subquery) {
-  const expr = {
-    __type: "exists",
-    subquery,
-    negated: true
-  };
-  return predicate(expr);
-}
-function inSubquery(field, subquery) {
-  assertSingleColumnSubquery(subquery);
-  assertCompatibleSubqueryValueTypes(field, subquery);
-  const expr = {
-    __type: "in_subquery",
-    field,
-    subquery,
-    negated: false
-  };
-  return predicate(expr);
-}
-function notInSubquery(field, subquery) {
-  assertSingleColumnSubquery(subquery);
-  assertCompatibleSubqueryValueTypes(field, subquery);
-  const expr = {
-    __type: "in_subquery",
-    field,
-    subquery,
-    negated: true
-  };
-  return predicate(expr);
-}
-function assertSingleColumnSubquery(subquery) {
-  const columnCount = getSubqueryColumnCount(subquery);
-  if (columnCount === 1) return;
-  throw new UnsupportedPredicateError(
-    `IN/NOT IN subquery must project exactly 1 column, but got ${columnCount}`,
-    { subqueryColumnCount: columnCount },
-    {
-      suggestion: "Use aggregate() with exactly one projected field for scalar IN/NOT IN subqueries."
-    }
-  );
-}
-function assertCompatibleSubqueryValueTypes(field, subquery) {
-  const fieldValueType = field.valueType;
-  const subqueryValueType = getSingleSubqueryColumnValueType(subquery);
-  const resolvedValueType = fieldValueType ?? subqueryValueType;
-  if (isUnsupportedInSubqueryValueType(resolvedValueType)) {
-    throw new UnsupportedPredicateError(
-      `IN/NOT IN subquery does not support ${String(resolvedValueType)} values`,
-      { valueType: resolvedValueType },
-      {
-        suggestion: "Use scalar fields (string/number/boolean/date) in IN/NOT IN predicates."
-      }
-    );
-  }
-  if (isInSubqueryTypeCompatible(fieldValueType, subqueryValueType)) {
-    return;
-  }
-  throw new UnsupportedPredicateError(
-    `IN/NOT IN type mismatch: field type "${String(fieldValueType)}" does not match subquery column type "${String(subqueryValueType)}"`,
-    {
-      fieldValueType,
-      subqueryValueType
-    }
-  );
-}
-var COMPARISON_OP_SQL = {
-  eq: "=",
-  neq: "!=",
-  gt: ">",
-  gte: ">=",
-  lt: "<",
-  lte: "<="
-};
-function compileFieldColumn(field, cteAlias, cteColumnPrefix) {
-  if (cteColumnPrefix !== void 0) {
-    const qualifier2 = cteColumnPrefix === "" ? "" : `${cteColumnPrefix}.`;
-    if (field.path.length === 1 && field.path[0] === "id") {
-      return sql.raw(`${qualifier2}id`);
-    }
-    if (field.path.length === 1 && field.path[0] === "kind") {
-      return sql.raw(`${qualifier2}kind`);
-    }
-    if (field.path.length > 0 && field.path[0] === "props") {
-      return sql.raw(`${qualifier2}props`);
-    }
-    return sql.raw(`${qualifier2}${field.path.join("_")}`);
-  }
-  const prefix = field.alias;
-  const qualifier = cteAlias ? `${cteAlias}.` : "";
-  if (field.path.length === 1 && field.path[0] === "id") {
-    return sql.raw(`${qualifier}${prefix}_id`);
-  }
-  if (field.path.length === 1 && field.path[0] === "kind") {
-    return sql.raw(`${qualifier}${prefix}_kind`);
-  }
-  if (field.path.length > 0 && field.path[0] === "props") {
-    return sql.raw(`${qualifier}${prefix}_props`);
-  }
-  return sql.raw(`${qualifier}${prefix}_${field.path.join("_")}`);
-}
-function getFieldPointer(field) {
-  if (field.jsonPointer !== void 0) {
-    return field.jsonPointer;
-  }
-  if (field.path.length > 1 && field.path[0] === "props") {
-    return jsonPointer(field.path.slice(1));
-  }
-  return void 0;
-}
-function isJsonField(field) {
-  return field.path.length > 0 && field.path[0] === "props";
-}
-function normalizeValueType2(valueType) {
-  if (!valueType || valueType === "unknown") {
-    return void 0;
-  }
-  return valueType;
-}
-function compileFieldValue(field, dialect, valueType, cteAlias, pointerOverride, cteColumnPrefix) {
-  const resolved = normalizeValueType2(valueType);
-  const column = compileFieldColumn(field, cteAlias, cteColumnPrefix);
-  if (!isJsonField(field)) {
-    return column;
-  }
-  const pointer = pointerOverride ?? getFieldPointer(field);
-  if (!pointer || pointer === "") {
-    return column;
-  }
-  switch (resolved) {
-    case "number": {
-      return dialect.jsonExtractNumber(column, pointer);
-    }
-    case "boolean": {
-      return dialect.jsonExtractBoolean(column, pointer);
-    }
-    case "date": {
-      return dialect.jsonExtractDate(column, pointer);
-    }
-    case "array":
-    case "object":
-    case "embedding": {
-      return dialect.jsonExtract(column, pointer);
-    }
-    case "string":
-    case "unknown":
-    case void 0: {
-      return dialect.jsonExtractText(column, pointer);
-    }
-  }
-}
-function compileFieldTextValue(field, dialect, cteAlias, pointerOverride, cteColumnPrefix) {
-  const column = compileFieldColumn(field, cteAlias, cteColumnPrefix);
-  if (!isJsonField(field)) {
-    return column;
-  }
-  const pointer = getFieldPointer(field);
-  if (!pointer || pointer === "") {
-    return column;
-  }
-  return dialect.jsonExtractText(column, pointer);
-}
-function compileFieldJsonValue(field, dialect, cteAlias, pointerOverride, cteColumnPrefix) {
-  const column = compileFieldColumn(field, cteAlias, cteColumnPrefix);
-  if (!isJsonField(field)) {
-    return column;
-  }
-  const pointer = pointerOverride ?? getFieldPointer(field);
-  if (!pointer || pointer === "") {
-    return column;
-  }
-  return dialect.jsonExtract(column, pointer);
-}
-function resolveLiteralValueTypes(literals) {
-  const resolved = /* @__PURE__ */ new Set();
-  for (const literal2 of literals) {
-    const valueType = normalizeValueType2(literal2.valueType);
-    if (valueType) {
-      resolved.add(valueType);
-    }
-  }
-  if (resolved.size > 1) {
-    throw new UnsupportedPredicateError(
-      "Mixed literal value types are not supported in predicates",
-      { valueTypes: [...resolved] }
-    );
-  }
-  return resolved.values().next().value;
-}
-function resolveComparisonValueType(field, right) {
-  if (isParameterRef(right)) {
-    return normalizeValueType2(right.valueType) ?? normalizeValueType2(field.valueType);
-  }
-  const literals = Array.isArray(right) ? right : [right];
-  const literalType = resolveLiteralValueTypes(literals);
-  const fieldType = normalizeValueType2(field.valueType);
-  if (fieldType === "date" && literalType === "string") {
-    return fieldType;
-  }
-  if (literalType) {
-    return literalType;
-  }
-  return fieldType;
-}
-function resolvePredicateValueType(preferred, literal2) {
-  const normalizedPreferred = normalizeValueType2(preferred);
-  if (normalizedPreferred) {
-    return normalizedPreferred;
-  }
-  return literal2 ? normalizeValueType2(literal2.valueType) : void 0;
-}
-function convertValueForSql(value, dialect) {
-  return dialect.bindValue(value);
-}
-function compileStringPattern(op, pattern) {
-  const escaped = pattern.replaceAll(
-    LIKE_ESCAPE_CHARACTER,
-    `${LIKE_ESCAPE_CHARACTER}${LIKE_ESCAPE_CHARACTER}`
-  ).replaceAll("%", `${LIKE_ESCAPE_CHARACTER}%`).replaceAll("_", `${LIKE_ESCAPE_CHARACTER}_`);
-  switch (op) {
-    case "contains": {
-      return `%${escaped}%`;
-    }
-    case "startsWith": {
-      return `${escaped}%`;
-    }
-    case "endsWith": {
-      return `%${escaped}`;
-    }
-    case "like":
-    case "ilike": {
-      return pattern;
-    }
-    default: {
-      return escaped;
-    }
-  }
-}
-function escapeLikePatternParameter(parameter) {
-  const doubledEscape = `${LIKE_ESCAPE_CHARACTER}${LIKE_ESCAPE_CHARACTER}`;
-  return sql`REPLACE(REPLACE(REPLACE(${parameter}, ${LIKE_ESCAPE_CHARACTER}, ${doubledEscape}), '%', ${`${LIKE_ESCAPE_CHARACTER}%`}), '_', ${`${LIKE_ESCAPE_CHARACTER}_`})`;
-}
-function compileParameterizedStringPattern(op, parameter) {
-  switch (op) {
-    case "contains": {
-      const escaped = escapeLikePatternParameter(parameter);
-      return sql`'%' || ${escaped} || '%'`;
-    }
-    case "startsWith": {
-      const escaped = escapeLikePatternParameter(parameter);
-      return sql`${escaped} || '%'`;
-    }
-    case "endsWith": {
-      const escaped = escapeLikePatternParameter(parameter);
-      return sql`'%' || ${escaped}`;
-    }
-    case "like":
-    case "ilike": {
-      return parameter;
-    }
-    default: {
-      return escapeLikePatternParameter(parameter);
-    }
-  }
-}
-function compilePredicateExpression(expr, ctx) {
-  const { dialect } = ctx;
-  const cteColumnPrefix = ctx.cteColumnPrefix;
-  switch (expr.__type) {
-    case "comparison": {
-      return compileComparisonPredicate(expr, dialect, cteColumnPrefix);
-    }
-    case "string_op": {
-      const field = compileFieldTextValue(
-        expr.field,
-        dialect,
-        void 0,
-        void 0,
-        cteColumnPrefix
-      );
-      if (isParameterRef(expr.pattern)) {
-        const placeholder = sql`${sql.placeholder(expr.pattern.name)}`;
-        const pattern2 = compileParameterizedStringPattern(expr.op, placeholder);
-        if (expr.op === "ilike" || expr.op === "contains" || expr.op === "startsWith" || expr.op === "endsWith") {
-          return dialect.ilike(field, pattern2);
-        }
-        return sql`${field} LIKE ${pattern2} ${likeEscapeClause}`;
-      }
-      const pattern = compileStringPattern(expr.op, expr.pattern);
-      if (expr.op === "ilike" || expr.op === "contains" || expr.op === "startsWith" || expr.op === "endsWith") {
-        return dialect.ilike(field, pattern);
-      }
-      return sql`${field} LIKE ${pattern} ${likeEscapeClause}`;
-    }
-    case "null_check": {
-      const field = compileFieldTextValue(
-        expr.field,
-        dialect,
-        void 0,
-        void 0,
-        cteColumnPrefix
-      );
-      return expr.op === "isNull" ? sql`${field} IS NULL` : sql`${field} IS NOT NULL`;
-    }
-    case "between": {
-      const lowerIsParam = isParameterRef(expr.lower);
-      const upperIsParam = isParameterRef(expr.upper);
-      const boundsForType = [];
-      if (!lowerIsParam) boundsForType.push(expr.lower);
-      if (!upperIsParam) boundsForType.push(expr.upper);
-      const valueType = boundsForType.length > 0 ? resolveComparisonValueType(expr.field, boundsForType) : normalizeValueType2(expr.field.valueType);
-      if (valueType === "array" || valueType === "object") {
-        throw new UnsupportedPredicateError(
-          "Between comparisons are not supported for JSON arrays or objects"
-        );
-      }
-      const field = compileFieldValue(
-        expr.field,
-        dialect,
-        valueType,
-        void 0,
-        void 0,
-        cteColumnPrefix
-      );
-      const lower = lowerIsParam ? sql.placeholder(expr.lower.name) : convertValueForSql(expr.lower.value, dialect);
-      const upper = upperIsParam ? sql.placeholder(expr.upper.name) : convertValueForSql(expr.upper.value, dialect);
-      return sql`${field} BETWEEN ${lower} AND ${upper}`;
-    }
-    case "and": {
-      const parts = expr.predicates.map(
-        (p) => compilePredicateExpression(p, ctx)
-      );
-      return sql`(${sql.join(parts, sql` AND `)})`;
-    }
-    case "or": {
-      const parts = expr.predicates.map(
-        (p) => compilePredicateExpression(p, ctx)
-      );
-      return sql`(${sql.join(parts, sql` OR `)})`;
-    }
-    case "not": {
-      const inner = compilePredicateExpression(expr.predicate, ctx);
-      return sql`NOT (${inner})`;
-    }
-    case "array_op": {
-      return compileArrayPredicate(expr, dialect, cteColumnPrefix);
-    }
-    case "object_op": {
-      return compileObjectPredicate(expr, dialect, cteColumnPrefix);
-    }
-    case "aggregate_comparison": {
-      return compileAggregatePredicate(expr, dialect);
-    }
-    case "exists": {
-      return compileExistsSubquery(expr, ctx);
-    }
-    case "in_subquery": {
-      return compileInSubquery(expr, ctx);
-    }
-    case "vector_similarity":
-    case "fulltext_match": {
-      return STRUCTURAL_PREDICATE_NOOP;
-    }
-  }
-}
-var STRUCTURAL_PREDICATE_NOOP = sql.raw("1=1");
-function compileComparisonPredicate(expr, dialect, cteColumnPrefix) {
-  if (isParameterRef(expr.right)) {
-    const parameterValueType = normalizeValueType2(expr.right.valueType) ?? normalizeValueType2(expr.left.valueType);
-    const left2 = compileFieldValue(
-      expr.left,
-      dialect,
-      parameterValueType,
-      void 0,
-      void 0,
-      cteColumnPrefix
-    );
-    const opSql2 = COMPARISON_OP_SQL[expr.op];
-    if (!opSql2) {
-      throw new UnsupportedPredicateError(
-        `Comparison operation "${expr.op}" is not supported for parameterized predicates`
-      );
-    }
-    return sql`${left2} ${sql.raw(opSql2)} ${sql.placeholder(expr.right.name)}`;
-  }
-  const valueType = resolveComparisonValueType(expr.left, expr.right);
-  if (valueType === "array" || valueType === "object") {
-    throw new UnsupportedPredicateError(
-      `Comparison operation "${expr.op}" is not supported for ${valueType} values`
-    );
-  }
-  const left = compileFieldValue(
-    expr.left,
-    dialect,
-    valueType,
-    void 0,
-    void 0,
-    cteColumnPrefix
-  );
-  if (expr.op === "in" || expr.op === "notIn") {
-    const values = Array.isArray(expr.right) ? expr.right : [expr.right];
-    if (values.length === 0) {
-      return expr.op === "in" ? sql.raw("1=0") : sql.raw("1=1");
-    }
-    const convertedValues = values.map(
-      (value) => convertValueForSql(value.value, dialect)
-    );
-    return dialect.inList(left, convertedValues, expr.op === "notIn");
-  }
-  const right = expr.right;
-  const rightValue = Array.isArray(right) ? right[0] : right;
-  const convertedRight = convertValueForSql(rightValue.value, dialect);
-  const opSql = COMPARISON_OP_SQL[expr.op];
-  if (!opSql) {
-    throw new UnsupportedPredicateError(
-      `Comparison operation "${expr.op}" is not supported`
-    );
-  }
-  return sql`${left} ${sql.raw(opSql)} ${convertedRight}`;
-}
-function compileArrayPredicate(expr, dialect, cteColumnPrefix) {
-  const field = compileFieldJsonValue(
-    expr.field,
-    dialect,
-    void 0,
-    void 0,
-    cteColumnPrefix
-  );
-  const values = expr.values?.map((v) => convertValueForSql(v.value, dialect)) ?? [];
-  switch (expr.op) {
-    case "isEmpty": {
-      return sql`(${field} IS NULL OR ${dialect.jsonArrayLength(field)} = 0)`;
-    }
-    case "isNotEmpty": {
-      return sql`(${field} IS NOT NULL AND ${dialect.jsonArrayLength(field)} > 0)`;
-    }
-    case "lengthEq": {
-      return sql`${dialect.jsonArrayLength(field)} = ${expr.length}`;
-    }
-    case "lengthGt": {
-      return sql`${dialect.jsonArrayLength(field)} > ${expr.length}`;
-    }
-    case "lengthGte": {
-      return sql`${dialect.jsonArrayLength(field)} >= ${expr.length}`;
-    }
-    case "lengthLt": {
-      return sql`${dialect.jsonArrayLength(field)} < ${expr.length}`;
-    }
-    case "lengthLte": {
-      return sql`${dialect.jsonArrayLength(field)} <= ${expr.length}`;
-    }
-    case "contains": {
-      const value = values[0];
-      if (value === void 0) {
-        return sql.raw("1=0");
-      }
-      return dialect.jsonArrayContains(field, value);
-    }
-    case "containsAll": {
-      return dialect.jsonArrayContainsAll(field, values);
-    }
-    case "containsAny": {
-      return dialect.jsonArrayContainsAny(field, values);
-    }
-  }
-}
-function compileObjectPredicate(expr, dialect, cteColumnPrefix) {
-  const basePointer = getFieldPointer(expr.field);
-  const pointer = joinJsonPointers(basePointer, expr.pointer);
-  const column = compileFieldColumn(expr.field, void 0, cteColumnPrefix);
-  switch (expr.op) {
-    case "hasKey":
-    case "hasPath": {
-      return dialect.jsonHasPath(column, pointer);
-    }
-    case "pathEquals": {
-      if (!expr.value) {
-        throw new UnsupportedPredicateError(
-          "pathEquals requires a comparison value"
-        );
-      }
-      const valueType = resolvePredicateValueType(expr.valueType, expr.value);
-      if (valueType === "array" || valueType === "object") {
-        throw new UnsupportedPredicateError(
-          "pathEquals is not supported for JSON arrays or objects"
-        );
-      }
-      const left = compileFieldValue(
-        expr.field,
-        dialect,
-        valueType,
-        void 0,
-        pointer,
-        cteColumnPrefix
-      );
-      return sql`${left} = ${convertValueForSql(expr.value.value, dialect)}`;
-    }
-    case "pathContains": {
-      if (!expr.value) {
-        throw new UnsupportedPredicateError(
-          "pathContains requires a comparison value"
-        );
-      }
-      const arrayField2 = compileFieldJsonValue(
-        expr.field,
-        dialect,
-        void 0,
-        pointer,
-        cteColumnPrefix
-      );
-      return dialect.jsonArrayContains(
-        arrayField2,
-        convertValueForSql(expr.value.value, dialect)
-      );
-    }
-    case "pathIsNull": {
-      return dialect.jsonPathIsNull(column, pointer);
-    }
-    case "pathIsNotNull": {
-      return dialect.jsonPathIsNotNull(column, pointer);
-    }
-  }
-}
-function compileAggregatePredicate(expr, dialect) {
-  const aggregate = compileAggregateExpr(expr.aggregate, dialect);
-  const op = COMPARISON_OP_SQL[expr.op];
-  if (!op) {
-    throw new UnsupportedPredicateError(
-      `Comparison operation "${expr.op}" is not supported for aggregate predicates`
-    );
-  }
-  const convertedValue = convertValueForSql(expr.value.value, dialect);
-  return sql`${aggregate} ${sql.raw(op)} ${convertedValue}`;
-}
-function compileAggregateExpr(expr, dialect) {
-  const cteAlias = `cte_${expr.field.alias}`;
-  const field = compileFieldValue(
-    expr.field,
-    dialect,
-    expr.field.valueType,
-    cteAlias
-  );
-  switch (expr.function) {
-    case "count": {
-      return sql`COUNT(${field})`;
-    }
-    case "countDistinct": {
-      return sql`COUNT(DISTINCT ${field})`;
-    }
-    case "sum": {
-      return sql`SUM(${field})`;
-    }
-    case "avg": {
-      return sql`AVG(${field})`;
-    }
-    case "min": {
-      return sql`MIN(${field})`;
-    }
-    case "max": {
-      return sql`MAX(${field})`;
-    }
-    default: {
-      throw new UnsupportedPredicateError(
-        `Unknown aggregate function: ${expr.function}`
-      );
-    }
-  }
-}
-function compileExistsSubquery(expr, ctx) {
-  if (expr.subquery.graphId === void 0) {
-    throw new UnsupportedPredicateError("EXISTS subquery must have a graphId");
-  }
-  const subSql = ctx.compileQuery(expr.subquery, expr.subquery.graphId);
-  return expr.negated ? sql`NOT EXISTS (${subSql})` : sql`EXISTS (${subSql})`;
-}
-function compileInSubquery(expr, ctx) {
-  const subqueryColumnCount = getSubqueryColumnCount(expr.subquery);
-  if (subqueryColumnCount !== 1) {
-    throw new UnsupportedPredicateError(
-      `IN/NOT IN subquery must project exactly 1 column, but got ${subqueryColumnCount}`,
-      { subqueryColumnCount }
-    );
-  }
-  const fieldValueType = normalizeValueType2(expr.field.valueType);
-  const subqueryValueType = getSingleSubqueryColumnValueType(expr.subquery);
-  const resolvedValueType = fieldValueType ?? subqueryValueType;
-  if (isUnsupportedInSubqueryValueType(resolvedValueType)) {
-    throw new UnsupportedPredicateError(
-      `IN/NOT IN subquery does not support ${String(resolvedValueType)} values`,
-      { valueType: resolvedValueType }
-    );
-  }
-  if (!isInSubqueryTypeCompatible(fieldValueType, subqueryValueType)) {
-    throw new UnsupportedPredicateError(
-      `IN/NOT IN type mismatch: field type "${String(fieldValueType)}" does not match subquery column type "${String(subqueryValueType)}"`,
-      {
-        fieldValueType,
-        subqueryValueType
-      }
-    );
-  }
-  const valueType = fieldValueType ?? subqueryValueType;
-  if (expr.subquery.graphId === void 0) {
-    throw new UnsupportedPredicateError(
-      "IN/NOT IN subquery must have a graphId"
-    );
-  }
-  const fieldSql = compileFieldValue(
-    expr.field,
-    ctx.dialect,
-    valueType,
-    void 0,
-    void 0,
-    ctx.cteColumnPrefix
-  );
-  const subSql = ctx.compileQuery(expr.subquery, expr.subquery.graphId);
-  return expr.negated ? sql`${fieldSql} NOT IN (${subSql})` : sql`${fieldSql} IN (${subSql})`;
-}
-function extractStructuralPredicates(predicates, isMatch, rejectionMessage) {
-  const results = [];
-  function visit(expr, inDisallowedBranch) {
-    if (isMatch(expr)) {
-      if (inDisallowedBranch) {
-        throw new UnsupportedPredicateError(rejectionMessage);
-      }
-      results.push(expr);
-      return;
-    }
-    switch (expr.__type) {
-      case "and": {
-        for (const child of expr.predicates) visit(child, inDisallowedBranch);
-        return;
-      }
-      case "or": {
-        for (const child of expr.predicates) visit(child, true);
-        return;
-      }
-      case "not": {
-        visit(expr.predicate, true);
-        return;
-      }
-      case "comparison":
-      case "string_op":
-      case "null_check":
-      case "between":
-      case "array_op":
-      case "object_op":
-      case "aggregate_comparison":
-      case "exists":
-      case "in_subquery":
-      case "vector_similarity":
-      case "fulltext_match": {
-        return;
-      }
-    }
-  }
-  for (const pred of predicates) visit(pred.expression, false);
-  return results;
-}
-function extractVectorSimilarityPredicates(predicates) {
-  return extractStructuralPredicates(
-    predicates,
-    (expr) => expr.__type === "vector_similarity",
-    "Vector similarity predicates cannot be nested under OR or NOT. Use top-level AND combinations instead."
-  );
-}
-function extractFulltextMatchPredicates(predicates) {
-  return extractStructuralPredicates(
-    predicates,
-    (expr) => expr.__type === "fulltext_match",
-    "Fulltext match predicates cannot be nested under OR or NOT. Use top-level AND combinations instead."
-  );
-}
-var EMPTY_PREDICATES = [];
-function sqlValueList(values) {
-  return sql.join(
-    values.map((value) => sql`${value}`),
-    sql`, `
-  );
-}
-function buildPredicateIndexKey(alias, targetType) {
-  return `${alias}\0${targetType}`;
-}
-function resolvePredicateTargetType(predicate2) {
-  return predicate2.targetType === "edge" ? "edge" : "node";
-}
-function buildPredicateIndex(ast) {
-  const byAliasAndType = /* @__PURE__ */ new Map();
-  for (const predicate2 of ast.predicates) {
-    const key = buildPredicateIndexKey(
-      predicate2.targetAlias,
-      resolvePredicateTargetType(predicate2)
-    );
-    const existing = byAliasAndType.get(key);
-    if (existing === void 0) {
-      byAliasAndType.set(key, [predicate2]);
-    } else {
-      existing.push(predicate2);
-    }
-  }
-  return { byAliasAndType };
-}
-function getPredicatesForAlias(predicateIndex, alias, targetType) {
-  return predicateIndex.byAliasAndType.get(
-    buildPredicateIndexKey(alias, targetType)
-  ) ?? EMPTY_PREDICATES;
-}
-function compilePredicateClauses(predicates, predicateContext) {
-  return predicates.map(
-    (predicate2) => compilePredicateExpression(predicate2.expression, predicateContext)
-  );
-}
-function compileKindFilter(column, kinds) {
-  if (kinds.length === 0) {
-    return sql`1 = 0`;
-  }
-  if (kinds.length === 1) {
-    return sql`${column} = ${kinds[0]}`;
-  }
-  return sql`${column} IN (${sqlValueList(kinds)})`;
-}
-function getNodeKindsForAlias(ast, alias) {
-  if (alias === ast.start.alias) {
-    return ast.start.kinds;
-  }
-  for (const traversal of ast.traversals) {
-    if (traversal.nodeAlias === alias) {
-      return traversal.nodeKinds;
-    }
-  }
-  throw new CompilerInvariantError(`Unknown traversal source alias: ${alias}`);
-}
-function getHybridTargetAlias(vectorPredicate, fulltextPredicate) {
-  if (!vectorPredicate || !fulltextPredicate) return void 0;
-  return vectorPredicate.field.alias === fulltextPredicate.field.alias ? vectorPredicate.field.alias : void 0;
-}
-
-// src/utils/array.ts
-function chunk(items, size) {
-  if (!Number.isSafeInteger(size) || size < 1) {
-    throw new RangeError(`chunk size must be a positive integer, got: ${size}`);
-  }
-  if (items.length === 0) return [];
-  if (items.length <= size) return [items];
-  const chunks = [];
-  for (let start = 0; start < items.length; start += size) {
-    chunks.push(items.slice(start, start + size));
-  }
-  return chunks;
-}
-function groupBy(items, keyFor) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const key = keyFor(item);
-    const group = groups.get(key) ?? [];
-    group.push(item);
-    groups.set(key, group);
-  }
-  return groups;
-}
-
-// src/utils/presence.ts
-function isPresent(value) {
-  return value !== null && value !== void 0;
-}
-
-export { CURRENT_READ_INSTANT_PLACEHOLDER, D1_MAX_BIND_PARAMETERS, DURABLE_OBJECT_MAX_BIND_PARAMETERS, INTERNAL_TEMPORARY_WRITES, MODERN_SQLITE_MAX_BIND_PARAMETERS, POSTGRES_CAPABILITIES, POSTGRES_MAX_BIND_PARAMETERS, SQLITE_CAPABILITIES, SQLITE_MAX_BIND_PARAMETERS, annIndexScanTypes, arrayField, asCompiledRowsSql, asCompiledSelectSql, asCompiledStatementSql, asCompiledTemporaryStatementSql, baseField, buildFieldBuilderForTypeInfo, buildPredicateIndex, chunk, compileFieldValue, compileKindFilter, compilePredicateClauses, compilePredicateExpression, compileTemporalFilter, createBackendOverlay, createFulltextAccessor, currentReadInstant, currentReadInstantFor, dateField, exists, extractFulltextMatchPredicates, extractTemporalOptions, extractVectorSimilarityPredicates, fieldRef, getFieldPointer, getHybridTargetAlias, getNodeKindsForAlias, getPredicatesForAlias, groupBy, inSubquery, isLiveNodeRow, isParameterRef, isPresent, isRawExecutable, isTombstonedNodeRow, markAnnIndexScan, markForceCustomPlan, normalizeGraphAnalyticsCapabilities, notExists, notInSubquery, numberField, objectField, param, rowPropsToJsonText, rowPropsToObject, runOptionallyInTransaction, shouldForceCustomPlan, sqlValueList, stringField, withPinnedReadInstant, wrapWithManagedClose };
-//# sourceMappingURL=chunk-44TA22QT.js.map
-//# sourceMappingURL=chunk-44TA22QT.js.map