{"version":3,"sources":["../src/query/compiler/temporal.ts","../src/query/subquery-utils.ts","../src/query/predicates.ts","../src/backend/drizzle/postgres-fence-sql.ts","../src/query/compiler/aggregate-validation.ts","../src/query/compiler/expression-inspection.ts","../src/query/compiler/predicates.ts","../src/query/compiler/database-expressions.ts","../src/query/compiler/predicate-utils.ts","../src/utils/delay.ts","../src/backend/async-context.ts","../src/backend/capabilities/retried-unit.ts","../src/schema/canonical.ts","../src/utils/array.ts","../src/backend/advisory-lock-namespaces.ts","../src/backend/capabilities/batch-write-verdict.ts","../src/backend/sqlite-writer-slot.ts"],"names":["nowIso","sql","optionalRecordedInstantParts","requireRecordedReadBinding","ConfigurationError","UnsupportedPredicateError","expr","resolveFieldTypeInfoAtJsonPointer","jsonPointer","joinJsonPointers","normalizeJsonPointer","assertPortableCountDistinctValueType","collectOperandExpressions","qualifier","normalizeValueType","literal","fieldType","LIKE_ESCAPE_CHARACTER","CompilerInvariantError","assertRecursiveTraversal","pattern","likeEscapeClause","left","opSql","rightValue","requireDefined","comparison","arrayField","expression","arrayExpressionElementType","assertPortableArrayMembershipElementType","isCollectScalarOperand","isCollectRecordOperand","resolveCollectOrder","compileOrderTerm","resolveCollectFilter","resolveCollectRecordFields","assertPortableScalarValueType","predicate","TransactionConflictError","isSerializationFailure","createDataKeyedBag","asCompiledStatementSql"],"mappings":"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","file":"chunk-5JOCIMQ3.cjs","sourcesContent":["/**\n * Temporal Filter Compilation\n *\n * Generates SQL clauses for temporal filtering based on valid_from/valid_to\n * and deleted_at timestamps. Consolidates the previously duplicated temporal\n * filter functions into a single, parameterized implementation.\n */\nimport { optionalRecordedInstantParts } from \"../../core/temporal\";\nimport { type TemporalMode } from \"../../core/types\";\nimport { nowIso } from \"../../utils/date\";\nimport { sql, type SqlFragment } from \"../sql-fragment\";\nimport { type RecordedReadBinding, requireRecordedReadBinding } from \"./schema\";\n\n/**\n * The instant every `currentReadInstant()` inside {@link withPinnedReadInstant}\n * returns. Compilation is synchronous and single-threaded, so this dynamic\n * scope needs no async-context machinery: nothing can interleave between the\n * assignment and the `finally` that clears it.\n */\nlet pinnedReadInstant: string | undefined;\n\n/**\n * Compiles `emit` with one shared \"current\" instant.\n *\n * A set operation is a single statement whose operands are compiled\n * independently, so each operand would otherwise sample its own `nowIso()`.\n * Two instants microseconds apart mean the two halves of an `INTERSECT` or\n * `EXCEPT` disagree about whether a row created between them is current — the\n * one thing a compound SELECT, evaluated against one snapshot, must never do.\n *\n * Re-entrant: a nested set operation keeps the outer pin rather than resampling.\n */\nexport function withPinnedReadInstant<T>(emit: () => T): T {\n  if (pinnedReadInstant !== undefined) return emit();\n  pinnedReadInstant = nowIso();\n  try {\n    return emit();\n  } finally {\n    pinnedReadInstant = undefined;\n  }\n}\n\n/**\n * The \"current\" valid-time read instant, bound as a parameter — the\n * APPLICATION clock (`nowIso()`), NOT the database clock (`NOW()`).\n *\n * `valid_from` is stamped from the application clock on write, so a \"current\"\n * read must compare against the same clock. Comparing `valid_from` (app clock)\n * against the database `NOW()` would hide a freshly-created row from an\n * immediately-following current read whenever the app server's clock runs\n * ahead of the database server's clock — a read-after-write consistency\n * violation on Postgres (issue #242; SQLite is single-process so it was never\n * exposed). This binds the same clock the facade search-currency filter\n * (`liveNodeIdsSubquery`) and the recorded/logical clock already use, and the\n * same form the `asOf` predicate uses (a bound ISO instant), so it needs no\n * dialect-specific expression.\n *\n * Samples the clock per call unless a {@link withPinnedReadInstant} scope is\n * open, in which case every call in that scope binds the same instant.\n */\nexport function currentReadInstant(): SqlFragment {\n  return sql`${pinnedReadInstant ?? nowIso()}`;\n}\n\n/**\n * How a \"current\" valid-time read instant is emitted into compiled SQL:\n *\n * - `\"literal\"` — bound as a concrete value at compile time\n *   ({@link currentReadInstant}). The instant is frozen into the compiled\n *   statement, so the statement must be recompiled to observe a newer \"now\".\n * - `\"placeholder\"` — bound as a reserved execution-time placeholder\n *   ({@link currentReadInstantPlaceholder}). The statement can be compiled\n *   once and reused across executions, filling a fresh instant each call.\n *\n * Defaults to `\"literal\"` everywhere except the query builder's compiled\n * template cache, which opts into `\"placeholder\"` so a reused/prepared query\n * never freezes \"now\" the way a cached literal would (the #246 regression).\n */\nexport type ReadInstantMode = \"literal\" | \"placeholder\";\n\n/**\n * Reserved Drizzle placeholder name for the \"current\" valid-time read instant.\n * The query builder's template cache fills it with a fresh application-clock\n * value on every execution. The `__typegraph_` prefix keeps it disjoint from\n * every user `param()` name.\n */\nexport const CURRENT_READ_INSTANT_PLACEHOLDER =\n  \"__typegraph_current_read_instant__\";\n\n/**\n * The \"current\" read instant as a reserved execution-time placeholder rather\n * than a frozen value. Compiles to the same SQL text as\n * {@link currentReadInstant} (a bound parameter), but leaves the value unbound\n * so one compiled statement can be reused across executions with a fresh\n * instant filled in per call. See {@link CURRENT_READ_INSTANT_PLACEHOLDER}.\n */\nfunction currentReadInstantPlaceholder(): SqlFragment {\n  return sql`${sql.placeholder(CURRENT_READ_INSTANT_PLACEHOLDER)}`;\n}\n\n/** Emits the \"current\" read instant for the requested {@link ReadInstantMode}. */\nexport function currentReadInstantFor(mode: ReadInstantMode): SqlFragment {\n  return mode === \"placeholder\" ?\n      currentReadInstantPlaceholder()\n    : currentReadInstant();\n}\n\n/**\n * Temporal filter options.\n */\nexport type TemporalFilterOptions = Readonly<{\n  /** The temporal mode to apply */\n  mode: TemporalMode;\n  /** Timestamp for asOf queries (required when mode is \"asOf\") */\n  asOf?: string | undefined;\n  /** Optional table alias prefix for column references */\n  tableAlias?: string | undefined;\n  /** Optional execution-time current timestamp SQL expression */\n  currentTimestamp?: SqlFragment | undefined;\n  /** Recorded/system-time timestamp for recorded-pinned reads. */\n  recordedAsOf?: string | undefined;\n  /**\n   * The recorded read binding whose `predicate` narrows the recorded rows\n   * `recordedAsOf` pins to. Required whenever `recordedAsOf` is set —\n   * refused otherwise, the same way every other recorded read refuses a\n   * missing binding.\n   */\n  recordedReadBinding?: RecordedReadBinding | undefined;\n}>;\n\n/**\n * Compiles a temporal filter to SQL.\n *\n * This is the unified temporal filter function that handles all temporal modes\n * and optional table alias prefixes. It replaces the previous three separate\n * functions (compileTemporalFilter, compileEdgeTemporalFilter, compileNodeTemporalFilter).\n *\n * @param options - Temporal filter configuration\n * @returns `SqlFragment` for the temporal filter\n *\n * @example\n * ```typescript\n * // Without table alias (for CTEs)\n * compileTemporalFilter({ mode: \"current\" })\n * // → deleted_at IS NULL AND (valid_from IS NULL OR ...) AND ...\n *\n * // With table alias (for JOINs)\n * compileTemporalFilter({ mode: \"current\", tableAlias: \"e\" })\n * // → e.deleted_at IS NULL AND (e.valid_from IS NULL OR ...) AND ...\n *\n * // AsOf mode\n * compileTemporalFilter({ mode: \"asOf\", asOf: \"2024-01-01T00:00:00.000Z\" })\n * // → deleted_at IS NULL AND (valid_from IS NULL OR valid_from <= '2024-01-01...') AND ...\n * ```\n */\nexport function compileTemporalFilter(\n  options: TemporalFilterOptions,\n): SqlFragment {\n  const {\n    mode,\n    asOf,\n    tableAlias,\n    currentTimestamp,\n    recordedAsOf,\n    recordedReadBinding,\n  } = options;\n  const recorded = optionalRecordedInstantParts(recordedAsOf, \"recordedAsOf\");\n\n  // Build column references with optional prefix\n  const prefix = tableAlias ? sql.raw(`${tableAlias}.`) : sql.raw(\"\");\n  const deletedAt = sql`${prefix}deleted_at`;\n  const validFrom = sql`${prefix}valid_from`;\n  const validTo = sql`${prefix}valid_to`;\n\n  const validFilter = (() => {\n    switch (mode) {\n      case \"current\": {\n        // When pinned to a recorded instant, \"current\" valid-time means\n        // valid-current *as of that recorded instant* — not the wall clock at\n        // read time. Pinning here collapses\n        // view({mode:'current'}).asOfRecorded(rt) to the diagonal\n        // store.asOfRecorded(rt) and stops silently dropping rows that were\n        // valid-current when recorded but ended before the read.\n        const now =\n          recorded === undefined ?\n            (currentTimestamp ?? currentReadInstant())\n          : sql`${recorded.recordedAt}`;\n        return sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${now}) AND (${validTo} IS NULL OR ${validTo} > ${now})`;\n      }\n\n      case \"asOf\": {\n        if (asOf === undefined) {\n          throw new Error(\n            `asOf timestamp is required for temporal mode \"asOf\"`,\n          );\n        }\n        const timestamp = asOf;\n        return sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${timestamp}) AND (${validTo} IS NULL OR ${validTo} > ${timestamp})`;\n      }\n\n      case \"includeEnded\": {\n        // Include records that have ended but not been deleted\n        return sql`${deletedAt} IS NULL`;\n      }\n\n      case \"includeTombstones\": {\n        // Include everything, no filter\n        return sql.raw(\"1=1\");\n      }\n    }\n  })();\n\n  if (recorded === undefined) return validFilter;\n\n  const binding = requireRecordedReadBinding(\n    recordedReadBinding,\n    \"recorded-temporal-filter\",\n  );\n  const recordedPredicate = binding.predicate(prefix, recorded);\n  if (recordedPredicate === undefined) return validFilter;\n  return sql`(${validFilter}) AND ${recordedPredicate}`;\n}\n\n/**\n * Extracts temporal options from a query AST.\n *\n * @param ast - Query AST with temporalMode\n * @param tableAlias - Optional table alias for column references\n * @returns TemporalFilterOptions for use with compileTemporalFilter\n */\nexport function extractTemporalOptions(\n  ast: {\n    temporalMode: { mode: TemporalMode; asOf?: string };\n    recordedAsOf?: string;\n  },\n  tableAlias?: string,\n): TemporalFilterOptions {\n  return {\n    mode: ast.temporalMode.mode,\n    asOf: ast.temporalMode.asOf,\n    recordedAsOf: ast.recordedAsOf,\n    tableAlias,\n  };\n}\n","/**\n * Shared utilities for subquery projection shape and type handling.\n */\nimport { type AggregateExpr, type QueryAst, type ValueType } from \"./ast\";\n\n/**\n * Normalizes a value type by treating \"unknown\" as undefined.\n */\nfunction normalizeValueType(valueType?: ValueType): ValueType | undefined {\n  if (valueType === undefined || valueType === \"unknown\") {\n    return undefined;\n  }\n  return valueType;\n}\n\n/**\n * Returns true when the type cannot be compared with IN/NOT IN.\n */\nexport function isUnsupportedInSubqueryValueType(\n  valueType?: ValueType,\n): boolean {\n  const normalized = normalizeValueType(valueType);\n  return (\n    normalized === \"array\" ||\n    normalized === \"object\" ||\n    normalized === \"embedding\"\n  );\n}\n\n/**\n * Returns true when two value types are compatible for IN/NOT IN.\n *\n * Unknown types are treated as compatible (deferred to runtime) to preserve\n * flexibility for untyped fields.\n */\nexport function isInSubqueryTypeCompatible(\n  left?: ValueType,\n  right?: ValueType,\n): boolean {\n  const normalizedLeft = normalizeValueType(left);\n  const normalizedRight = normalizeValueType(right);\n\n  if (normalizedLeft === undefined || normalizedRight === undefined) {\n    return true;\n  }\n\n  return normalizedLeft === normalizedRight;\n}\n\n/**\n * Resolves the value type produced by an aggregate projection.\n */\nfunction getAggregateValueType(\n  aggregate: AggregateExpr,\n): ValueType | undefined {\n  switch (aggregate.function) {\n    case \"count\":\n    case \"countDistinct\":\n    case \"sum\":\n    case \"avg\": {\n      return \"number\";\n    }\n    case \"min\":\n    case \"max\": {\n      return normalizeValueType(aggregate.field.valueType);\n    }\n  }\n}\n\n/**\n * Returns effective projected column value types for a subquery.\n *\n * If selective fields are present, they represent the effective projection.\n * Otherwise, falls back to the explicit projection fields.\n */\nfunction getProjectedValueTypes(\n  subquery: QueryAst,\n): readonly (ValueType | undefined)[] {\n  if (subquery.selectiveFields && subquery.selectiveFields.length > 0) {\n    return subquery.selectiveFields.map((field) =>\n      normalizeValueType(field.valueType),\n    );\n  }\n\n  return subquery.projection.fields.map((field) => {\n    if (field.source.__type === \"aggregate\") {\n      return getAggregateValueType(field.source);\n    }\n    return normalizeValueType(field.source.valueType);\n  });\n}\n\n/**\n * Returns the effective number of columns projected by a subquery.\n */\nexport function getSubqueryColumnCount(subquery: QueryAst): number {\n  return getProjectedValueTypes(subquery).length;\n}\n\n/**\n * Returns the value type when a subquery projects exactly one column.\n */\nexport function getSingleSubqueryColumnValueType(\n  subquery: QueryAst,\n): ValueType | undefined {\n  const valueTypes = getProjectedValueTypes(subquery);\n  if (valueTypes.length !== 1) {\n    return undefined;\n  }\n  return valueTypes[0];\n}\n","/**\n * Predicate builders for TypeGraph queries.\n *\n * Provides a fluent API for building type-safe predicates.\n */\nimport { type FulltextQueryMode } from \"../backend/types\";\nimport { type NullCheckOp } from \"../core/types\";\nimport { ConfigurationError, UnsupportedPredicateError } from \"../errors\";\nimport {\n  type ArrayOp,\n  type ArrayPredicate,\n  type BetweenPredicate,\n  type ComparisonOp,\n  type ComparisonPredicate,\n  type ExistsSubquery,\n  type FieldRef,\n  type FulltextMatchPredicate,\n  type InSubquery,\n  type LiteralValue,\n  type NullPredicate,\n  type ObjectOp,\n  type ObjectPredicate,\n  type ParameterRef,\n  type PredicateExpression,\n  type QueryAst,\n  type StringOp,\n  type StringPredicate,\n  type ValueType,\n  type VectorMetricType,\n  type VectorSimilarityPredicate,\n} from \"./ast\";\nimport { CURRENT_READ_INSTANT_PLACEHOLDER } from \"./compiler/temporal\";\nimport { resolveFieldTypeInfoAtJsonPointer } from \"./field-type-info\";\nimport {\n  joinJsonPointers,\n  type JsonPointer,\n  jsonPointer,\n  type JsonPointerInput,\n  type JsonPointerSegment,\n  normalizeJsonPointer,\n  type ResolveJsonPointer,\n  type ResolveJsonPointerSegments,\n} from \"./json-pointer\";\nimport { type FieldTypeInfo } from \"./schema-introspector\";\nimport {\n  getSingleSubqueryColumnValueType,\n  getSubqueryColumnCount,\n  isInSubqueryTypeCompatible,\n  isUnsupportedInSubqueryValueType,\n} from \"./subquery-utils\";\n\n// ============================================================\n// Predicate Builder\n// ============================================================\n\n/**\n * A chainable predicate that can be combined with AND/OR.\n */\nexport type Predicate = Readonly<{\n  __expr: PredicateExpression;\n  and: (other: Predicate) => Predicate;\n  or: (other: Predicate) => Predicate;\n  not: () => Predicate;\n}>;\n\n/**\n * Creates a predicate wrapper with chainable methods.\n */\nfunction predicate(expr: PredicateExpression): Predicate {\n  return {\n    __expr: expr,\n    and: (other: Predicate): Predicate =>\n      predicate({\n        __type: \"and\",\n        predicates: [expr, other.__expr],\n      }),\n    or: (other: Predicate): Predicate =>\n      predicate({\n        __type: \"or\",\n        predicates: [expr, other.__expr],\n      }),\n    not: (): Predicate =>\n      predicate({\n        __type: \"not\",\n        predicate: expr,\n      }),\n  };\n}\n\n// ============================================================\n// Parameter References\n// ============================================================\n\n/**\n * Creates a named parameter reference for prepared queries.\n *\n * Use with `query.prepare()` to create reusable parameterized queries.\n * Supported in scalar comparison positions (eq, neq, gt, etc.), string\n * operations, between bounds, and as the WHOLE list of `in()`/`notIn()` —\n * `field.in(param(\"ids\"))` bound to an array at execute time. A `param()`\n * among the individual elements of a literal list is rejected.\n *\n * @example\n * ```typescript\n * const prepared = store.query()\n *   .from(\"Person\", \"p\")\n *   .whereNode(\"p\", (p) => p.name.eq(param(\"name\")))\n *   .select((ctx) => ctx.p)\n *   .prepare();\n *\n * const results = await prepared.execute({ name: \"Alice\" });\n * ```\n *\n * @example List-valued parameter — one compiled statement, any list length.\n * ```typescript\n * const byIds = store.query()\n *   .from(\"Person\", \"p\")\n *   .whereNode(\"p\", (p) => p.id.in(param(\"ids\")))\n *   .select((ctx) => ctx.p)\n *   .prepare();\n *\n * await byIds.execute({ ids: [\"a\", \"b\"] });\n * await byIds.execute({ ids: [\"c\"] });\n * ```\n */\n// eslint-disable-next-line unicorn/name-replacements -- concise public API\nexport function param(name: string): ParameterRef {\n  // The compiled template fills this reserved placeholder with the current read\n  // instant, so a user param of the same name would be silently overwritten by\n  // the wall clock (see fillTemplateParams). Reject it up front.\n  if (name === CURRENT_READ_INSTANT_PLACEHOLDER) {\n    throw new ConfigurationError(\n      `Parameter name \"${name}\" is reserved for internal use`,\n      { parameterName: name },\n    );\n  }\n  return { __type: \"parameter\", name };\n}\n\n/**\n * Type guard for ParameterRef values.\n */\nexport function isParameterRef(value: unknown): value is ParameterRef {\n  if (typeof value !== \"object\" || value === null) return false;\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- runtime guard for untyped input\n  return (value as ParameterRef).__type === \"parameter\";\n}\n\n// ============================================================\n// Field Builder\n// ============================================================\n\n/**\n * A typed field builder for creating predicates.\n */\ntype FieldBuilder<T> =\n  [T] extends [string] ? StringFieldBuilder<T>\n  : [T] extends [number] ? NumberFieldBuilder<T>\n  : [T] extends [boolean] ? BooleanFieldBuilder<T>\n  : [T] extends [Date] ? DateFieldBuilder<T>\n  : [T] extends [readonly (infer U)[]] ? ArrayFieldBuilder<U>\n  : [T] extends [Record<string, unknown>] ? ObjectFieldBuilder<T>\n  : BaseFieldBuilder<T>;\n\ntype EqualityOperand<T> = T | FieldRef<T> | ParameterRef;\ntype MembershipOperand<T> = readonly T[] | ParameterRef;\n\ntype NullFieldBuilder = Readonly<{\n  isNull: () => Predicate;\n  isNotNull: () => Predicate;\n}>;\n\n/**\n * Base field operations available on all types.\n */\ntype BaseFieldBuilder<T = unknown> = Readonly<{\n  eq: (value: EqualityOperand<T>) => Predicate;\n  neq: (value: EqualityOperand<T>) => Predicate;\n  isNull: () => Predicate;\n  isNotNull: () => Predicate;\n  in: (values: MembershipOperand<T>) => Predicate;\n  notIn: (values: MembershipOperand<T>) => Predicate;\n}>;\n\n/**\n * Options for the `$fulltext.matches()` predicate.\n *\n * Note the term glossary used throughout TypeGraph search:\n * - **`k`** (the positional argument on `.matches(query, k)`) is the\n *   per-predicate top-k cap applied inside the fulltext CTE.\n * - **`limit`** (on store-level `search.fulltext` / `search.hybrid` and\n *   on the query builder) is the final result count returned to the\n *   caller after any fusion.\n */\ntype MatchesOptions = Readonly<{\n  /**\n   * Parse mode for the query string. Default: \"websearch\".\n   *\n   * - \"websearch\": Google-style syntax (quoted phrases, `-excluded`, `OR`).\n   *   Postgres: `websearch_to_tsquery`. SQLite: translated to FTS5 MATCH.\n   * - \"phrase\": treats the whole query as a phrase.\n   * - \"plain\": splits on whitespace and ANDs terms.\n   * - \"raw\": dialect-native syntax passed through unchanged.\n   */\n  mode?: FulltextQueryMode;\n  /**\n   * Language override for query parsing. Default: the kind's declared\n   * language when every kind in the alias shares one (a plan-time\n   * constant, so PostgreSQL can serve the match from the GIN index);\n   * mixed-language subclass aliases fall back to the per-row language\n   * column.\n   */\n  language?: string;\n  /** Minimum relevance score to include. */\n  minScore?: number;\n}>;\n\n/**\n * String-specific field operations.\n *\n * Fulltext match is exposed on `n.$fulltext.matches(...)` at the node\n * level (gated by `searchable()` declarations in the schema), not on\n * individual string fields.\n */\ntype StringFieldBuilder<T extends string = string> = BaseFieldBuilder<T> &\n  Readonly<{\n    gt: (value: string | ParameterRef) => Predicate;\n    gte: (value: string | ParameterRef) => Predicate;\n    lt: (value: string | ParameterRef) => Predicate;\n    lte: (value: string | ParameterRef) => Predicate;\n    contains: (pattern: string | ParameterRef) => Predicate;\n    startsWith: (pattern: string | ParameterRef) => Predicate;\n    endsWith: (pattern: string | ParameterRef) => Predicate;\n    like: (pattern: string | ParameterRef) => Predicate;\n    ilike: (pattern: string | ParameterRef) => Predicate;\n  }>;\n\n/**\n * Number-specific field operations.\n */\ntype NumberFieldBuilder<T extends number = number> = BaseFieldBuilder<T> &\n  Readonly<{\n    gt: (value: number | ParameterRef) => Predicate;\n    gte: (value: number | ParameterRef) => Predicate;\n    lt: (value: number | ParameterRef) => Predicate;\n    lte: (value: number | ParameterRef) => Predicate;\n    between: (\n      lower: number | ParameterRef,\n      upper: number | ParameterRef,\n    ) => Predicate;\n  }>;\n\n/**\n * Boolean-specific field operations.\n */\ntype BooleanFieldBuilder<T extends boolean = boolean> = BaseFieldBuilder<T>;\n\n/**\n * Date-specific field operations.\n */\ntype DateFieldBuilder<T extends Date = Date> = BaseFieldBuilder<T> &\n  Readonly<{\n    gt: (value: Date | string | ParameterRef) => Predicate;\n    gte: (value: Date | string | ParameterRef) => Predicate;\n    lt: (value: Date | string | ParameterRef) => Predicate;\n    lte: (value: Date | string | ParameterRef) => Predicate;\n    between: (\n      lower: Date | string | ParameterRef,\n      upper: Date | string | ParameterRef,\n    ) => Predicate;\n  }>;\n\ntype ScalarValue = string | number | boolean | Date;\n\ntype ArrayPredicateOps<T> =\n  [T] extends [ScalarValue] ?\n    Readonly<{\n      /** Check if array contains a specific value */\n      contains: (value: T) => Predicate;\n      /** Check if array contains all specified values */\n      containsAll: (values: readonly T[]) => Predicate;\n      /** Check if array contains any of the specified values (overlaps) */\n      containsAny: (values: readonly T[]) => Predicate;\n    }>\n  : Readonly<Record<string, never>>;\n\n/**\n * Array-specific field operations.\n */\ntype ArrayFieldBuilder<T = unknown> = NullFieldBuilder &\n  Readonly<{\n    /** Check if array is empty */\n    isEmpty: () => Predicate;\n    /** Check if array is not empty */\n    isNotEmpty: () => Predicate;\n    /** Check if array length equals a value */\n    lengthEq: (length: number) => Predicate;\n    /** Check if array length is greater than a value */\n    lengthGt: (length: number) => Predicate;\n    /** Check if array length is greater than or equal to a value */\n    lengthGte: (length: number) => Predicate;\n    /** Check if array length is less than a value */\n    lengthLt: (length: number) => Predicate;\n    /** Check if array length is less than or equal to a value */\n    lengthLte: (length: number) => Predicate;\n  }> &\n  ArrayPredicateOps<T>;\n\n/**\n * Object/JSON-specific field operations.\n */\ntype ResolvedPointerInput<T, Pointer> =\n  Pointer extends string ? ResolveJsonPointer<T, Pointer>\n  : Pointer extends readonly JsonPointerSegment[] ?\n    ResolveJsonPointerSegments<T, Pointer>\n  : unknown;\n\n/**\n * Resolves the type of a nested key access on an object type.\n * Returns ObjectFieldBuilder for nested objects, FieldBuilder for scalars.\n */\ntype NestedFieldBuilder<T, K extends keyof T> =\n  NonNullable<T[K]> extends Record<string, unknown> ?\n    ObjectFieldBuilder<NonNullable<T[K]>>\n  : FieldBuilder<T[K]>;\n\ntype ObjectFieldBuilder<\n  T extends Record<string, unknown> = Record<string, unknown>,\n> = NullFieldBuilder &\n  Readonly<{\n    /** Access a nested field by key for fluent chaining */\n    get: <K extends keyof T & string>(key: K) => NestedFieldBuilder<T, K>;\n    /** Check if object has a specific key at root level */\n    hasKey: (key: string) => Predicate;\n    /** Check if object has a nested path (JSON Pointer) */\n    hasPath: <P extends JsonPointerInput<T>>(pointer: P) => Predicate;\n    /** Check if value at path equals a value */\n    pathEquals: <P extends JsonPointerInput<T>>(\n      pointer: P,\n      value: string | number | boolean | Date,\n    ) => Predicate;\n    /** Check if value at path (array) contains a value */\n    pathContains: <P extends JsonPointerInput<T>>(\n      pointer: P,\n      value: string | number | boolean | Date,\n    ) => Predicate;\n    /** Check if value at path is null */\n    pathIsNull: <P extends JsonPointerInput<T>>(pointer: P) => Predicate;\n    /** Check if value at path is not null */\n    pathIsNotNull: <P extends JsonPointerInput<T>>(pointer: P) => Predicate;\n    /** Access a nested field to get a typed field builder */\n    field: <P extends JsonPointerInput<T>>(\n      pointer: P,\n    ) => FieldBuilder<ResolvedPointerInput<T, P>>;\n  }>;\n\n/**\n * Options for the similarTo method.\n */\nexport type SimilarToOptions = Readonly<{\n  /** Similarity metric to use. Default: \"cosine\" */\n  metric?: VectorMetricType;\n  /**\n   * Minimum similarity score to include results.\n   * For cosine: 0-1 where 1 is identical.\n   * For L2: maximum distance to include.\n   * For inner_product: minimum inner product value.\n   */\n  minScore?: number;\n  /**\n   * Opt into approximate retrieval: each declaring kind's candidates come\n   * from the engine's native ANN structure (pgvector HNSW/IVFFlat scans,\n   * vec0 `MATCH … k=`, libSQL `vector_top_k`) instead of an exact\n   * distance scan. This is a SEMANTIC change — results are subject to the\n   * index's recall, and predicates composed alongside constrain the ANN\n   * candidate set (exact on pgvector/vec0; bounded by over-fetch on\n   * libSQL). Default: exact.\n   *\n   * Two states cannot serve it, and they are handled differently on purpose:\n   *\n   * - **A slot declared `indexType: \"none\"`** has no ANN structure, so the\n   *   opt-in compiles to the exact scan and results are unchanged. A\n   *   DECLARED degradation: the query is still exactly what was asked for,\n   *   only faster or slower.\n   * - **A `metric` override that differs from the field's declared metric**\n   *   is REFUSED with a `ConfigurationError` naming both metrics. An ANN\n   *   structure retrieves only under the metric it was built for, so the two\n   *   options state something that cannot both hold — and serving the exact\n   *   scan instead would silently drop one of them. Omit `metric` (or pass\n   *   the declared one) to keep approximate retrieval, or drop `approximate`\n   *   to scan exactly under the overriding metric.\n   */\n  approximate?: boolean;\n}>;\n\n/**\n * Embedding-specific field operations for vector similarity search.\n */\ntype EmbeddingFieldBuilder = NullFieldBuilder &\n  Readonly<{\n    /**\n     * Find nodes with similar embeddings.\n     * Returns results ordered by similarity (most similar first).\n     *\n     * @param queryEmbedding - The embedding vector to compare against\n     * @param k - Maximum number of results to return (top-k)\n     * @param options - Optional configuration (metric, minScore)\n     *\n     * @example\n     * ```typescript\n     * store.query()\n     *   .from(\"Document\", \"d\")\n     *   .whereNode(\"d\", (d) =>\n     *     d.embedding.similarTo(queryVector, 10, { metric: \"cosine\" })\n     *   )\n     *   .select((ctx) => ({ doc: ctx.d }))\n     *   .execute()\n     * ```\n     */\n    similarTo: (\n      queryEmbedding: readonly number[],\n      k: number,\n      options?: SimilarToOptions,\n    ) => Predicate;\n  }>;\n\n// ============================================================\n// Field Builder Factory\n// ============================================================\n\n/**\n * Creates a field reference.\n */\ntype FieldRefOptions = Readonly<{\n  jsonPointer?: JsonPointer | undefined;\n  valueType?: ValueType | undefined;\n  elementType?: ValueType | undefined;\n  nullable?: boolean | undefined;\n}>;\n\nexport function fieldRef<Value = unknown>(\n  alias: string,\n  path: readonly string[],\n  options?: FieldRefOptions,\n): FieldRef<Value> {\n  return {\n    __type: \"field_ref\",\n    alias,\n    path,\n    ...(options?.jsonPointer !== undefined && {\n      jsonPointer: options.jsonPointer,\n    }),\n    ...(options?.valueType !== undefined && { valueType: options.valueType }),\n    ...(options?.elementType !== undefined && {\n      elementType: options.elementType,\n    }),\n    ...(options?.nullable !== undefined && { nullable: options.nullable }),\n  };\n}\n\nfunction isFieldRef(value: unknown): value is FieldRef {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    (value as Readonly<{ __type?: unknown }>).__type === \"field_ref\"\n  );\n}\n\nfunction assertCompatibleFieldReferences(\n  left: FieldRef,\n  right: FieldRef,\n): void {\n  const leftType = left.valueType;\n  const rightType = right.valueType;\n  if (\n    leftType !== undefined &&\n    leftType !== \"unknown\" &&\n    rightType !== undefined &&\n    rightType !== \"unknown\" &&\n    leftType !== rightType\n  ) {\n    throw new UnsupportedPredicateError(\n      `Cannot compare ${leftType} field \"${left.alias}.${left.path.join(\".\")}\" with ${rightType} field \"${right.alias}.${right.path.join(\".\")}\".`,\n      { leftType, rightType },\n    );\n  }\n}\n\nfunction assertLiteralMatchesField(\n  field: FieldRef,\n  value: unknown,\n  allowDateString = false,\n): void {\n  const valueType = field.valueType;\n  if (valueType === undefined || valueType === \"unknown\") return;\n\n  const matches =\n    (valueType === \"string\" && typeof value === \"string\") ||\n    (valueType === \"number\" && typeof value === \"number\") ||\n    (valueType === \"boolean\" && typeof value === \"boolean\") ||\n    (valueType === \"date\" &&\n      (value instanceof Date ||\n        (allowDateString && typeof value === \"string\")));\n  if (matches) return;\n\n  throw new UnsupportedPredicateError(\n    `Expected a ${valueType} literal for field \"${field.alias}.${field.path.join(\".\")}\", got ${value instanceof Date ? \"date\" : typeof value}.`,\n    { expectedValueType: valueType, receivedValueType: typeof value },\n  );\n}\n\nfunction assertComparisonSupported(field: FieldRef): void {\n  const valueType = field.valueType;\n  if (\n    valueType === \"array\" ||\n    valueType === \"object\" ||\n    valueType === \"embedding\"\n  ) {\n    throw new UnsupportedPredicateError(\n      `Comparison predicates are not supported for ${valueType} field \"${field.alias}.${field.path.join(\".\")}\".`,\n      { valueType },\n    );\n  }\n}\n\nfunction coerceLiteralValue(value: unknown): string | number | boolean | Date {\n  if (value instanceof Date) {\n    return value;\n  }\n  if (\n    typeof value === \"string\" ||\n    typeof value === \"number\" ||\n    typeof value === \"boolean\"\n  ) {\n    return value;\n  }\n  throw new Error(`Unsupported literal value type: ${typeof value}`);\n}\n\nfunction inferLiteralValueType(value: string | number | boolean): ValueType {\n  if (typeof value === \"string\") {\n    return \"string\";\n  }\n  if (typeof value === \"number\") {\n    return \"number\";\n  }\n  return \"boolean\";\n}\n\n/**\n * Creates a literal value.\n */\nfunction literal(value: string | number | boolean | Date): LiteralValue {\n  if (value instanceof Date) {\n    return { __type: \"literal\", value: value.toISOString(), valueType: \"date\" };\n  }\n  const valueType = inferLiteralValueType(value);\n  return {\n    __type: \"literal\",\n    value,\n    valueType,\n  };\n}\n\n/**\n * Creates a comparison predicate.\n */\nfunction comparison(\n  op: ComparisonOp,\n  field: FieldRef,\n  value: unknown,\n): Predicate {\n  assertComparisonSupported(field);\n  if (isParameterRef(value)) {\n    const expr: ComparisonPredicate = {\n      __type: \"comparison\",\n      op,\n      left: field,\n      right: value,\n    };\n    return predicate(expr);\n  }\n  if (isFieldRef(value)) {\n    assertCompatibleFieldReferences(field, value);\n    return predicate({\n      __type: \"comparison\",\n      op,\n      left: field,\n      right: value,\n    } satisfies ComparisonPredicate);\n  }\n  assertLiteralMatchesField(field, value, op !== \"eq\" && op !== \"neq\");\n  const coercedValue = coerceLiteralValue(value);\n  const expr: ComparisonPredicate = {\n    __type: \"comparison\",\n    op,\n    left: field,\n    right: literal(coercedValue),\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates an IN comparison predicate.\n *\n * The whole list may be a single `param()` — bound at\n * `.prepare().execute({ ids: [...] })` and compiled to one placeholder, so\n * varying list lengths reuse one cached statement. A `param()` sitting among\n * literal *elements* has no such representation (a placeholder cannot be one\n * item of a list the compiler already inlined), so it is rejected rather than\n * silently bound as a literal.\n */\nfunction inComparison(\n  op: \"in\" | \"notIn\",\n  field: FieldRef,\n  values: readonly unknown[] | ParameterRef,\n): Predicate {\n  assertComparisonSupported(field);\n  if (isParameterRef(values)) {\n    return predicate({\n      __type: \"comparison\",\n      op,\n      left: field,\n      right: values,\n    } satisfies ComparisonPredicate);\n  }\n  const literals = values.map((value) => {\n    if (isParameterRef(value)) {\n      throw new UnsupportedPredicateError(\n        `param(\"${value.name}\") is not supported as an element of the ${op}() list`,\n        { parameterName: value.name },\n        {\n          suggestion: `Bind the whole list instead: .${op}(param(\"${value.name}\")) and execute({ ${value.name}: [...] }).`,\n        },\n      );\n    }\n    assertLiteralMatchesField(field, value);\n    return literal(coerceLiteralValue(value));\n  });\n  const expr: ComparisonPredicate = {\n    __type: \"comparison\",\n    op,\n    left: field,\n    right: literals,\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates a string operation predicate.\n */\nfunction stringOp(\n  op: StringOp,\n  field: FieldRef,\n  pattern: string | ParameterRef,\n): Predicate {\n  if (isParameterRef(pattern)) {\n    const expr: StringPredicate = {\n      __type: \"string_op\",\n      op,\n      field,\n      pattern,\n    };\n    return predicate(expr);\n  }\n  const expr: StringPredicate = {\n    __type: \"string_op\",\n    op,\n    field,\n    pattern,\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates a null check predicate.\n */\nfunction nullCheck(op: NullCheckOp, field: FieldRef): Predicate {\n  const expr: NullPredicate = {\n    __type: \"null_check\",\n    op,\n    field,\n  };\n  return predicate(expr);\n}\n\nfunction nullFieldBuilder(field: FieldRef): NullFieldBuilder {\n  return {\n    isNull: () => nullCheck(\"isNull\", field),\n    isNotNull: () => nullCheck(\"isNotNull\", field),\n  };\n}\n\n/**\n * Creates a between predicate.\n */\nfunction between(\n  field: FieldRef,\n  lower: string | number | boolean | Date | ParameterRef,\n  upper: string | number | boolean | Date | ParameterRef,\n): Predicate {\n  const expr: BetweenPredicate = {\n    __type: \"between\",\n    field,\n    lower: isParameterRef(lower) ? lower : literal(lower),\n    upper: isParameterRef(upper) ? upper : literal(upper),\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates a base field builder with common operations.\n */\nfunction baseFieldBuilder<T = unknown>(field: FieldRef): BaseFieldBuilder<T> {\n  return {\n    eq: (value) => comparison(\"eq\", field, value),\n    neq: (value) => comparison(\"neq\", field, value),\n    isNull: () => nullCheck(\"isNull\", field),\n    isNotNull: () => nullCheck(\"isNotNull\", field),\n    in: (values) => inComparison(\"in\", field, values),\n    notIn: (values) => inComparison(\"notIn\", field, values),\n  };\n}\n\nfunction unsupportedComparisonFieldBuilder(field: FieldRef): BaseFieldBuilder {\n  return {\n    eq: (value) => comparison(\"eq\", field, value),\n    neq: (value) => comparison(\"neq\", field, value),\n    in: (values) => inComparison(\"in\", field, values),\n    notIn: (values) => inComparison(\"notIn\", field, values),\n    ...nullFieldBuilder(field),\n  };\n}\n\n/**\n * Creates a string field builder.\n *\n * Fulltext match is not a string-field operation — use\n * `n.$fulltext.matches(...)` at the node level. `searchable()`\n * declarations determine which node kinds expose `$fulltext`.\n */\nexport function stringField(field: FieldRef): StringFieldBuilder {\n  return {\n    ...baseFieldBuilder(field),\n    gt: (value) => comparison(\"gt\", field, value),\n    gte: (value) => comparison(\"gte\", field, value),\n    lt: (value) => comparison(\"lt\", field, value),\n    lte: (value) => comparison(\"lte\", field, value),\n    contains: (pattern) => stringOp(\"contains\", field, pattern),\n    startsWith: (pattern) => stringOp(\"startsWith\", field, pattern),\n    endsWith: (pattern) => stringOp(\"endsWith\", field, pattern),\n    like: (pattern) => stringOp(\"like\", field, pattern),\n    ilike: (pattern) => stringOp(\"ilike\", field, pattern),\n  };\n}\n\n/**\n * Default top-k for `$fulltext.matches()` when the caller does not pass\n * one. Large enough to leave headroom for downstream `.and()` filters,\n * small enough to keep latency reasonable on any dialect.\n */\nconst DEFAULT_FULLTEXT_MATCH_K = 50;\n\n/**\n * Node-level fulltext accessor. Always present on the `NodeAccessor`\n * type — a runtime check throws a clear error if the node kind has no\n * `searchable()` fields. `k` is the top-k cap applied inside the\n * fulltext CTE; defaults to `DEFAULT_FULLTEXT_MATCH_K`. Use a larger\n * value when feeding the result into RRF (`.fuseWith()` /\n * `store.search.hybrid()`).\n */\nexport type FulltextAccessor = Readonly<{\n  matches: (query: string, k?: number, options?: MatchesOptions) => Predicate;\n}>;\n\n/**\n * Creates a node-level fulltext accessor. The runtime check throws for\n * aliases whose node kind has no `searchable()` content, catching the\n * case where the field tag was dropped (e.g. by a schema refactor)\n * after the query was written.\n */\nexport function createFulltextAccessor(\n  alias: string,\n  hasSearchableField: () => boolean,\n): FulltextAccessor {\n  return {\n    matches: (query, k, options) => {\n      if (!hasSearchableField()) {\n        throw new UnsupportedPredicateError(\n          `Cannot call .$fulltext.matches() on alias \"${alias}\" — its ` +\n            `node kind has no fields declared with searchable(). Add at ` +\n            `least one: \\`title: searchable({ language: \"english\" })\\`.`,\n        );\n      }\n      return fulltextMatch(\n        fieldRef(alias, [\"$fulltext\"]),\n        query,\n        k ?? DEFAULT_FULLTEXT_MATCH_K,\n        options,\n      );\n    },\n  };\n}\n\n/**\n * Creates a fulltext match predicate.\n */\nfunction fulltextMatch(\n  field: FieldRef,\n  query: string,\n  limit: number,\n  options?: MatchesOptions,\n): Predicate {\n  if (!Number.isFinite(limit) || limit <= 0) {\n    throw new UnsupportedPredicateError(\n      `matches() limit must be a positive finite number, got ${String(limit)}`,\n    );\n  }\n  const expr: FulltextMatchPredicate = {\n    __type: \"fulltext_match\",\n    field,\n    query,\n    mode: options?.mode ?? \"websearch\",\n    limit,\n    ...(options?.language === undefined ? {} : { language: options.language }),\n    ...(options?.minScore === undefined ? {} : { minScore: options.minScore }),\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates a number field builder.\n */\nexport function numberField(field: FieldRef): NumberFieldBuilder {\n  return {\n    ...baseFieldBuilder(field),\n    gt: (value) => comparison(\"gt\", field, value),\n    gte: (value) => comparison(\"gte\", field, value),\n    lt: (value) => comparison(\"lt\", field, value),\n    lte: (value) => comparison(\"lte\", field, value),\n    between: (lower, upper) => between(field, lower, upper),\n  };\n}\n\n/**\n * Creates a date field builder.\n */\nexport function dateField(field: FieldRef): DateFieldBuilder {\n  return {\n    ...baseFieldBuilder(field),\n    gt: (value) => comparison(\"gt\", field, value),\n    gte: (value) => comparison(\"gte\", field, value),\n    lt: (value) => comparison(\"lt\", field, value),\n    lte: (value) => comparison(\"lte\", field, value),\n    between: (lower, upper) => between(field, lower, upper),\n  };\n}\n\n/**\n * Creates a base field builder (for booleans, enums, and unknown types).\n * Only provides the fundamental operations: eq, neq, isNull, isNotNull, in, notIn.\n */\nexport function baseField<T = unknown>(\n  field: FieldRef<T>,\n): BaseFieldBuilder<T> {\n  return baseFieldBuilder(field);\n}\n\n/**\n * Creates an array operation predicate.\n */\nfunction arrayOp(\n  op: ArrayOp,\n  field: FieldRef,\n  values?: readonly unknown[],\n  length?: number,\n): Predicate {\n  const expr: ArrayPredicate = {\n    __type: \"array_op\",\n    op,\n    field,\n    ...(values !== undefined && {\n      values: values.map((value) => literal(coerceLiteralValue(value))),\n    }),\n    ...(length !== undefined && { length }),\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates an array field builder.\n */\nexport function arrayField<T = unknown>(field: FieldRef): ArrayFieldBuilder<T> {\n  // The type assertion is needed because ArrayFieldBuilder conditionally includes\n  // contains/containsAll/containsAny based on whether T extends ScalarValue.\n  // At runtime we always provide them - they just won't type-check if T isn't scalar.\n  return {\n    ...nullFieldBuilder(field),\n    contains: (value: T) => arrayOp(\"contains\", field, [value]),\n    containsAll: (values: readonly T[]) =>\n      arrayOp(\"containsAll\", field, values),\n    containsAny: (values: readonly T[]) =>\n      arrayOp(\"containsAny\", field, values),\n    isEmpty: () => arrayOp(\"isEmpty\", field),\n    isNotEmpty: () => arrayOp(\"isNotEmpty\", field),\n    lengthEq: (length: number) => arrayOp(\"lengthEq\", field, undefined, length),\n    lengthGt: (length: number) => arrayOp(\"lengthGt\", field, undefined, length),\n    lengthGte: (length: number) =>\n      arrayOp(\"lengthGte\", field, undefined, length),\n    lengthLt: (length: number) => arrayOp(\"lengthLt\", field, undefined, length),\n    lengthLte: (length: number) =>\n      arrayOp(\"lengthLte\", field, undefined, length),\n  } as unknown as ArrayFieldBuilder<T>;\n}\n\n/**\n * Creates a vector similarity predicate.\n */\nfunction vectorSimilarity(\n  field: FieldRef,\n  queryEmbedding: readonly number[],\n  limit: number,\n  options?: SimilarToOptions,\n): Predicate {\n  const expr: VectorSimilarityPredicate = {\n    __type: \"vector_similarity\",\n    field,\n    queryEmbedding,\n    // Leave metric unset when the caller didn't specify one, so the compiler\n    // resolves the field's declared metric per kind. Defaulting to \"cosine\"\n    // here would mis-rank l2/inner_product fields and bypass their ANN index.\n    ...(options?.metric !== undefined && { metric: options.metric }),\n    limit,\n    ...(options?.minScore !== undefined && { minScore: options.minScore }),\n    ...(options?.approximate !== undefined && {\n      approximate: options.approximate,\n    }),\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates an embedding field builder for vector similarity search.\n */\nexport function embeddingField(field: FieldRef): EmbeddingFieldBuilder {\n  return {\n    ...nullFieldBuilder(field),\n    similarTo: (queryEmbedding, k, options) =>\n      vectorSimilarity(field, queryEmbedding, k, options),\n  };\n}\n\nexport function buildFieldBuilderForTypeInfo(\n  field: FieldRef,\n  typeInfo: FieldTypeInfo | undefined,\n): BaseFieldBuilder {\n  if (!typeInfo) {\n    return baseField(field);\n  }\n\n  switch (typeInfo.valueType) {\n    case \"string\": {\n      return stringField(field) as unknown as BaseFieldBuilder;\n    }\n    case \"number\": {\n      return numberField(field) as unknown as BaseFieldBuilder;\n    }\n    case \"boolean\": {\n      return baseField(field);\n    }\n    case \"date\": {\n      return dateField(field) as unknown as BaseFieldBuilder;\n    }\n    case \"array\": {\n      return {\n        ...arrayField(field),\n        ...unsupportedComparisonFieldBuilder(field),\n      };\n    }\n    case \"object\": {\n      return {\n        ...objectField(field, { typeInfo }),\n        ...unsupportedComparisonFieldBuilder(field),\n      };\n    }\n    case \"embedding\": {\n      return {\n        ...embeddingField(field),\n        ...unsupportedComparisonFieldBuilder(field),\n      };\n    }\n    case \"unknown\": {\n      return baseField(field);\n    }\n  }\n}\n\nfunction resolvePointerTypeInfo(\n  typeInfo: FieldTypeInfo | undefined,\n  pointer: JsonPointer,\n): FieldTypeInfo | undefined {\n  return resolveFieldTypeInfoAtJsonPointer(typeInfo, pointer);\n}\n\n/**\n * Creates an object operation predicate.\n */\ntype ObjectPredicateOptions = Readonly<{\n  valueType?: ValueType;\n  elementType?: ValueType;\n}>;\n\nfunction objectOp(\n  op: ObjectOp,\n  field: FieldRef,\n  pointer: JsonPointer,\n  value?: unknown,\n  options?: ObjectPredicateOptions,\n): Predicate {\n  const expr: ObjectPredicate = {\n    __type: \"object_op\",\n    op,\n    field,\n    pointer,\n    ...(value !== undefined && {\n      value: literal(coerceLiteralValue(value)),\n    }),\n    ...(options?.valueType !== undefined && { valueType: options.valueType }),\n    ...(options?.elementType !== undefined && {\n      elementType: options.elementType,\n    }),\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates an object/JSON field builder.\n */\ntype ObjectFieldOptions = Readonly<{\n  typeInfo?: FieldTypeInfo;\n}>;\n\nexport function objectField<\n  T extends Record<string, unknown> = Record<string, unknown>,\n>(field: FieldRef, options?: ObjectFieldOptions): ObjectFieldBuilder<T> {\n  const basePointer = field.jsonPointer;\n\n  return {\n    ...nullFieldBuilder(field),\n    get: <K extends keyof T & string>(key: K) => {\n      const pointer = jsonPointer([key]);\n      const nestedPointer = joinJsonPointers(basePointer, pointer);\n      const resolved = resolvePointerTypeInfo(options?.typeInfo, pointer);\n      const nestedRef = fieldRef(field.alias, field.path, {\n        jsonPointer: nestedPointer,\n        ...(resolved?.valueType !== undefined && {\n          valueType: resolved.valueType,\n        }),\n        ...(resolved?.elementType !== undefined && {\n          elementType: resolved.elementType,\n        }),\n      });\n      return buildFieldBuilderForTypeInfo(nestedRef, resolved) as ReturnType<\n        ObjectFieldBuilder<T>[\"get\"]\n      >;\n    },\n    hasKey: (key) => {\n      const pointer = jsonPointer([key]);\n      resolvePointerTypeInfo(options?.typeInfo, pointer);\n      return objectOp(\"hasKey\", field, pointer);\n    },\n    hasPath: <P extends JsonPointerInput<T>>(pointer: P) => {\n      const normalized = normalizeJsonPointer(pointer as JsonPointerInput<T>);\n      resolvePointerTypeInfo(options?.typeInfo, normalized);\n      return objectOp(\"hasPath\", field, normalized);\n    },\n    pathEquals: <P extends JsonPointerInput<T>>(\n      pointer: P,\n      value: string | number | boolean | Date,\n    ) => {\n      const normalized = normalizeJsonPointer(pointer as JsonPointerInput<T>);\n      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);\n      if (\n        resolved &&\n        (resolved.valueType === \"array\" || resolved.valueType === \"object\")\n      ) {\n        throw new Error(\"pathEquals is only supported for scalar JSON values\");\n      }\n      const predicateOptions: ObjectPredicateOptions | undefined =\n        resolved?.valueType === undefined ?\n          undefined\n        : { valueType: resolved.valueType };\n      return objectOp(\"pathEquals\", field, normalized, value, predicateOptions);\n    },\n    pathContains: <P extends JsonPointerInput<T>>(\n      pointer: P,\n      value: string | number | boolean | Date,\n    ) => {\n      const normalized = normalizeJsonPointer(pointer as JsonPointerInput<T>);\n      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);\n      if (resolved && resolved.valueType !== \"array\") {\n        throw new Error(\"pathContains is only supported for JSON array values\");\n      }\n      const predicateOptions: ObjectPredicateOptions | undefined =\n        resolved?.elementType === undefined ?\n          undefined\n        : { elementType: resolved.elementType };\n      return objectOp(\n        \"pathContains\",\n        field,\n        normalized,\n        value,\n        predicateOptions,\n      );\n    },\n    pathIsNull: <P extends JsonPointerInput<T>>(pointer: P) => {\n      const normalized = normalizeJsonPointer(pointer as JsonPointerInput<T>);\n      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);\n      const predicateOptions: ObjectPredicateOptions | undefined =\n        resolved?.valueType === undefined ?\n          undefined\n        : { valueType: resolved.valueType };\n      return objectOp(\n        \"pathIsNull\",\n        field,\n        normalized,\n        undefined,\n        predicateOptions,\n      );\n    },\n    pathIsNotNull: <P extends JsonPointerInput<T>>(pointer: P) => {\n      const normalized = normalizeJsonPointer(pointer as JsonPointerInput<T>);\n      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);\n      const predicateOptions: ObjectPredicateOptions | undefined =\n        resolved?.valueType === undefined ?\n          undefined\n        : { valueType: resolved.valueType };\n      return objectOp(\n        \"pathIsNotNull\",\n        field,\n        normalized,\n        undefined,\n        predicateOptions,\n      );\n    },\n    field: <P extends JsonPointerInput<T>>(pointer: P) => {\n      const normalized = normalizeJsonPointer(pointer as JsonPointerInput<T>);\n      const nestedPointer = joinJsonPointers(basePointer, normalized);\n      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);\n      const nestedRef = fieldRef(field.alias, field.path, {\n        jsonPointer: nestedPointer,\n        ...(resolved?.valueType !== undefined && {\n          valueType: resolved.valueType,\n        }),\n        ...(resolved?.elementType !== undefined && {\n          elementType: resolved.elementType,\n        }),\n      });\n      return buildFieldBuilderForTypeInfo(nestedRef, resolved) as FieldBuilder<\n        ResolvedPointerInput<T, P>\n      >;\n    },\n  };\n}\n\n// ============================================================\n// Subquery Predicates\n// ============================================================\n\n/**\n * Creates an EXISTS subquery predicate.\n * Returns true if the subquery returns at least one row.\n *\n * @param subquery - The subquery AST to check for existence\n *\n * @example\n * ```typescript\n * // Find persons who have at least one order\n * query\n *   .from(\"Person\", \"p\")\n *   .whereNode(\"p\", () =>\n *     exists(\n *       query.from(\"Order\", \"o\")\n *         .whereNode(\"o\", (o) => o.customerId.eq(field(\"p.id\")))\n *         .select((ctx) => ({ id: ctx.o.id }))\n *         .toAst()\n *     )\n *   )\n * ```\n */\nexport function exists(subquery: QueryAst): Predicate {\n  const expr: ExistsSubquery = {\n    __type: \"exists\",\n    subquery,\n    negated: false,\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates a NOT EXISTS subquery predicate.\n * Returns true if the subquery returns no rows.\n *\n * @param subquery - The subquery AST to check for non-existence\n */\nexport function notExists(subquery: QueryAst): Predicate {\n  const expr: ExistsSubquery = {\n    __type: \"exists\",\n    subquery,\n    negated: true,\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates an IN subquery predicate.\n * Returns true if the field value is in the subquery results.\n *\n * @param field - The field to check\n * @param subquery - The subquery AST that returns a single column\n *\n * @example\n * ```typescript\n * // Find persons whose ID is in the VIP list\n * query\n *   .from(\"Person\", \"p\")\n *   .where(() =>\n *     inSubquery(\n *       fieldRef(\"p\", [\"id\"]),\n *       query.from(\"VIPMember\", \"v\")\n *         .aggregate({\n *           id: fieldRef(\"v\", [\"props\", \"personId\"], { valueType: \"string\" }),\n *         })\n *         .toAst()\n *     )\n *   )\n * ```\n */\nexport function inSubquery(field: FieldRef, subquery: QueryAst): Predicate {\n  assertSingleColumnSubquery(subquery);\n  assertCompatibleSubqueryValueTypes(field, subquery);\n  const expr: InSubquery = {\n    __type: \"in_subquery\",\n    field,\n    subquery,\n    negated: false,\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates a NOT IN subquery predicate.\n * Returns true if the field value is not in the subquery results.\n *\n * @param field - The field to check\n * @param subquery - The subquery AST that returns a single column\n */\nexport function notInSubquery(field: FieldRef, subquery: QueryAst): Predicate {\n  assertSingleColumnSubquery(subquery);\n  assertCompatibleSubqueryValueTypes(field, subquery);\n  const expr: InSubquery = {\n    __type: \"in_subquery\",\n    field,\n    subquery,\n    negated: true,\n  };\n  return predicate(expr);\n}\n\n/**\n * Ensures IN/NOT IN subqueries project exactly one column.\n */\nfunction assertSingleColumnSubquery(subquery: QueryAst): void {\n  const columnCount = getSubqueryColumnCount(subquery);\n  if (columnCount === 1) return;\n\n  throw new UnsupportedPredicateError(\n    `IN/NOT IN subquery must project exactly 1 column, but got ${columnCount}`,\n    { subqueryColumnCount: columnCount },\n    {\n      suggestion:\n        \"Use aggregate() with exactly one projected field for scalar IN/NOT IN subqueries.\",\n    },\n  );\n}\n\n/**\n * Ensures IN/NOT IN subquery and field value types are compatible when known.\n */\nfunction assertCompatibleSubqueryValueTypes(\n  field: FieldRef,\n  subquery: QueryAst,\n): void {\n  const fieldValueType = field.valueType;\n  const subqueryValueType = getSingleSubqueryColumnValueType(subquery);\n  const resolvedValueType = fieldValueType ?? subqueryValueType;\n\n  if (isUnsupportedInSubqueryValueType(resolvedValueType)) {\n    throw new UnsupportedPredicateError(\n      `IN/NOT IN subquery does not support ${String(resolvedValueType)} values`,\n      { valueType: resolvedValueType },\n      {\n        suggestion:\n          \"Use scalar fields (string/number/boolean/date) in IN/NOT IN predicates.\",\n      },\n    );\n  }\n\n  if (isInSubqueryTypeCompatible(fieldValueType, subqueryValueType)) {\n    return;\n  }\n\n  throw new UnsupportedPredicateError(\n    `IN/NOT IN type mismatch: field type \"${String(fieldValueType)}\" does not match subquery column type \"${String(subqueryValueType)}\"`,\n    {\n      fieldValueType,\n      subqueryValueType,\n    },\n  );\n}\n","/**\n * The bundled PostgreSQL lock-statement spelling every write-fence lock site\n * consumes through its resolved plan (`fence.sql.*`) instead of spelling\n * `pg_advisory_xact_lock`, `hashtext(`, `LOCK TABLE`, or\n * `current_setting('transaction_isolation')` itself. The lock-fence inventory\n * test ratchets those tokens out of the lock-site files, including trusted\n * import's table lock and the PostgreSQL profile's extension-DDL lock, both\n * of which now resolve the same plan every other lock site does and consume\n * `fence.sql.lockTables(...)` / `fence.sql.acquireKeyed(...)` instead of\n * spelling `LOCK TABLE` / `pg_advisory_xact_lock` themselves — this module is\n * the only one left spelling any of these four tokens.\n *\n * Built from `SqlFragment` (`../../query/sql-fragment`), not `drizzle-orm`,\n * so this module stays outside the Drizzle zone and is safe to import from\n * portable code that only ever needs PostgreSQL's own SQL shape directly\n * (a raw-connection test fixture, or a session-fact read gated purely on\n * `dialect === \"postgres\"` rather than on a resolved lock plan).\n *\n * `postgresFenceSql` supplies only the two composable expressions and\n * `lockTables` — `FenceSql`'s complete member set. The standalone-statement\n * forms every ordinary lock site actually calls (`acquireKeyed`,\n * `acquireKeyedWithIsolation`, `isolationFact`) are never spelled here: THE\n * one owner of \"wrap this expression in a standalone `SELECT`\" is\n * `resolveWriteFencePlan`'s `resolveFenceStatements`\n * (`../capabilities/write-fence.ts`), which derives them from this module's\n * two expressions for every resolved `lock` or `row` plan, bundled or\n * custom alike.\n * `./postgres-schema-write-fence.ts` needs `drizzle-orm` to reach the schema\n * table, so it cannot live in this module (which imports none); it instead\n * takes the resolved fence target's own `advisoryLockExpression` /\n * `isolationFactExpression` members as a parameter and calls them directly,\n * converting each to Drizzle's own `SQL` at the embedding boundary — so a\n * derived profile's own `FenceSql` backs that fused statement exactly as it\n * backs every other lock site, never the bundled spelling unconditionally.\n *\n * `advisoryLockSingleExpression` is exported bare, unlike the module's other\n * two expressions: it spells the ONE-argument `pg_advisory_xact_lock(bigint)`\n * form, which occupies a lock space distinct from every namespaced\n * two-argument lock this module builds and is not a `FenceSql` member — under\n * the schema-commit fence's `\"lock\"` plan arm (`postgres.ts`), it and the\n * graph-template instantiation statement's advisory-lock variant\n * (`graph-template-sql.ts`) both import it directly and take it on\n * `hashtext(graphId)`, so they mutually exclude — calling back into this one\n * function is what keeps that guarantee from drifting into two independently\n * spelled lock calls. Under the fence's `\"row\"` plan arm, neither side takes\n * this lock: both instead take the same portable fence row.\n */\nimport { sql, type SqlFragment } from \"../../query/sql-fragment\";\nimport { type FenceSql } from \"../capabilities/write-fence\";\n\nconst LOCK_TABLE_MODE_CLAUSE = {\n  share: \"SHARE MODE\",\n  \"share-row-exclusive\": \"SHARE ROW EXCLUSIVE MODE\",\n  \"access-exclusive\": \"ACCESS EXCLUSIVE MODE\",\n} as const satisfies Record<\n  \"share\" | \"share-row-exclusive\" | \"access-exclusive\",\n  string\n>;\n\n/**\n * `hashtext($key)` for a string key, or the bare integer literal for the\n * constant `0` the database-scoped DDL locks use — PostgreSQL's two-argument\n * `pg_advisory_xact_lock(int4, int4)` overload takes that second argument as\n * a plain integer, never as a hash of one. Rendered inline rather than bound:\n * every numeric key in this codebase is a hardcoded constant at its call\n * site, never a runtime value, so inlining it is safe and matches the\n * statement text this module's callers rendered before they resolved their\n * spelling through here.\n */\nfunction advisoryLockKeyExpression(key: string | number): SqlFragment {\n  return typeof key === \"number\" ? sql.raw(String(key)) : sql`hashtext(${key})`;\n}\n\n/**\n * The bare `pg_advisory_xact_lock(...)` call, with no `SELECT` around it —\n * reachable from outside this module only as `postgresFenceSql`'s\n * `advisoryLockExpression` MEMBER: `postgres-schema-write-fence.ts` composes\n * it off the resolved `FenceSql` it is building a statement for, and\n * `resolveWriteFencePlan`'s `resolveFenceStatements` wraps it in the\n * standalone-statement form (`advisoryLock`) every other lock site consumes\n * — never off this bare function by direct import, so a derived profile's\n * own `FenceSql` backs both forms exactly as the bundled spelling does.\n */\nfunction advisoryLockExpression(\n  namespace: string,\n  key: string | number,\n): SqlFragment {\n  return sql`pg_advisory_xact_lock(hashtext(${namespace}), ${advisoryLockKeyExpression(key)})`;\n}\n\n/**\n * The bare ONE-argument `pg_advisory_xact_lock(hashtext($key))` call —\n * never route a namespaced lock through this instead of\n * {@link advisoryLockExpression}. PostgreSQL stores the one- and\n * two-argument forms with different `locktag` field4 values, so a bigint\n * key taken here can never collide with any (int4, int4) key the\n * two-argument form produces, however the hashes land. Exported bare, like\n * {@link advisoryLockExpression}, so a caller that must keep this lock\n * co-atomic with a surrounding statement (a data-modifying CTE, for one)\n * can embed it directly instead of wrapping it in a standalone `SELECT`.\n */\nexport function advisoryLockSingleExpression(key: string): SqlFragment {\n  return sql`pg_advisory_xact_lock(hashtext(${key}))`;\n}\n\nfunction lockTables(\n  tables: readonly string[],\n  mode: \"share\" | \"share-row-exclusive\" | \"access-exclusive\",\n): SqlFragment {\n  return sql`LOCK TABLE ${sql.join(\n    tables.map((table) => sql.identifier(table)),\n    sql`, `,\n  )} IN ${sql.raw(LOCK_TABLE_MODE_CLAUSE[mode])}`;\n}\n\n/**\n * The bare `current_setting('transaction_isolation')` read, with no\n * `SELECT`/alias around it — reachable from outside this module only as\n * `postgresFenceSql`'s `isolationFactExpression` member, for the same\n * reason as {@link advisoryLockExpression}.\n */\nfunction isolationFactExpression(): SqlFragment {\n  return sql`current_setting('transaction_isolation')`;\n}\n\n/** The bundled PostgreSQL backend's {@link FenceSql} declaration. */\nexport const postgresFenceSql: FenceSql = {\n  lockTables,\n  advisoryLockExpression,\n  isolationFactExpression,\n};\n","import { UnsupportedPredicateError } from \"../../errors\";\nimport { assertPortableCountDistinctValueType } from \"../aggregate-value-types\";\nimport { type AggregateExpr, type ValueType } from \"../ast\";\n\nconst MIN_MAX_VALUE_TYPES = new Set<ValueType>([\"date\", \"number\", \"string\"]);\n\n/** Validates the portable scalar contract of an aggregate operand. */\nexport function validateAggregateOperand(\n  expression: AggregateExpr,\n  resolvedValueType: ValueType | undefined = expression.field.valueType,\n): void {\n  if (resolvedValueType === undefined || resolvedValueType === \"unknown\")\n    return;\n\n  if (expression.function === \"countDistinct\") {\n    assertPortableCountDistinctValueType(resolvedValueType);\n  }\n\n  if (\n    (expression.function === \"sum\" || expression.function === \"avg\") &&\n    resolvedValueType !== \"number\"\n  ) {\n    throw new UnsupportedPredicateError(\n      `${expression.function.toUpperCase()} requires a numeric field; ` +\n        `received ${resolvedValueType} for alias \"${expression.field.alias}\".`,\n    );\n  }\n\n  if (\n    (expression.function === \"min\" || expression.function === \"max\") &&\n    !MIN_MAX_VALUE_TYPES.has(resolvedValueType)\n  ) {\n    throw new UnsupportedPredicateError(\n      `${expression.function.toUpperCase()} supports string, number, and date fields; ` +\n        `received ${resolvedValueType} for alias \"${expression.field.alias}\".`,\n    );\n  }\n}\n","import {\n  collectOperandExpressions,\n  type DatabaseExpression,\n} from \"../expressions\";\n\nexport function isAggregateExpression(expression: DatabaseExpression): boolean {\n  return (\n    expression.node.kind === \"aggregate\" || expression.node.kind === \"collect\"\n  );\n}\n\nexport function expressionContainsAggregate(\n  expression: DatabaseExpression,\n): boolean {\n  if (isAggregateExpression(expression)) return true;\n  let found = false;\n  visitExpressionChildren(expression, (operand) => {\n    if (expressionContainsAggregate(operand)) found = true;\n  });\n  return found;\n}\n\nexport function visitExpressionChildren(\n  expression: DatabaseExpression,\n  visit: (operand: DatabaseExpression) => void,\n): void {\n  const node = expression.node;\n  switch (node.kind) {\n    case \"arithmetic\":\n    case \"comparison\": {\n      visit(node.left);\n      visit(node.right);\n      return;\n    }\n    case \"array_contains\": {\n      visit(node.array);\n      visit(node.element);\n      return;\n    }\n    case \"boolean\":\n    case \"coalesce\": {\n      for (const operand of node.operands) visit(operand);\n      return;\n    }\n    case \"not\":\n    case \"null_check\":\n    case \"numeric_conversion\": {\n      visit(node.operand);\n      return;\n    }\n    case \"aggregate\": {\n      if (node.operand !== undefined) visit(node.operand);\n      return;\n    }\n    case \"collect\": {\n      for (const operand of collectOperandExpressions(node.operand))\n        visit(operand);\n      for (const order of node.orderBy) visit(order.expression);\n      if (node.filter !== undefined) visit(node.filter);\n      return;\n    }\n    case \"conditional\": {\n      visit(node.condition);\n      visit(node.then);\n      visit(node.otherwise);\n      return;\n    }\n    case \"outer_reference\": {\n      visit(node.expression);\n      return;\n    }\n    case \"exists_subquery\":\n    case \"scalar_subquery\":\n    case \"field\":\n    case \"literal\":\n    case \"parameter\": {\n      return;\n    }\n  }\n}\n","/**\n * Predicate Expression Compilation\n *\n * Compiles predicate AST nodes to SQL using dialect adapters.\n * Handles comparisons, string operations, null checks, array/object predicates,\n * and subqueries.\n */\nimport {\n  assertRecursiveTraversal,\n  type RecursiveTraversalVerdict,\n} from \"../../backend/capabilities/recursive-traversal\";\nimport {\n  CompilerInvariantError,\n  UnsupportedPredicateError,\n} from \"../../errors\";\nimport { requireDefined } from \"../../utils/presence\";\nimport {\n  type AggregateExpr,\n  type ArrayPredicate,\n  type ExistsSubquery,\n  type FieldRef,\n  type FulltextMatchPredicate,\n  type InSubquery,\n  type LiteralValue,\n  type ObjectPredicate,\n  type ParameterRef,\n  type PredicateExpression,\n  type QueryAst,\n  type ValueType,\n  type VectorSimilarityPredicate,\n} from \"../ast\";\nimport {\n  LIKE_ESCAPE_CHARACTER,\n  likeEscapeClause,\n} from \"../dialect/like-escape\";\nimport { type DialectAdapter } from \"../dialect/types\";\nimport { type VectorStrategy } from \"../dialect/vector-strategy\";\nimport type { DatabaseExpression } from \"../expressions\";\nimport {\n  joinJsonPointers,\n  type JsonPointer,\n  jsonPointer,\n} from \"../json-pointer\";\nimport { isParameterRef } from \"../predicates\";\nimport { sql, type SqlFragment } from \"../sql-fragment\";\nimport {\n  getSingleSubqueryColumnValueType,\n  getSubqueryColumnCount,\n  isInSubqueryTypeCompatible,\n  isUnsupportedInSubqueryValueType,\n} from \"../subquery-utils\";\nimport { validateAggregateOperand } from \"./aggregate-validation\";\nimport {\n  compileDatabaseExpression,\n  compileLegacyAggregateExpression,\n  type DatabaseExpressionCompilerContext,\n} from \"./database-expressions\";\nimport {\n  type RecordedReadBinding,\n  type SqlSchema,\n  type VectorSlotMap,\n} from \"./schema\";\nimport { type ReadInstantMode } from \"./temporal\";\n\nconst COMPARISON_OP_SQL: Record<string, string> = {\n  eq: \"=\",\n  neq: \"!=\",\n  gt: \">\",\n  gte: \">=\",\n  lt: \"<\",\n  lte: \"<=\",\n};\n\n// ============================================================\n// Field Reference Compilation\n// ============================================================\n\n/**\n * Compiles a field reference to a base column name.\n *\n * @param field - The field reference to compile\n * @param cteAlias - Optional CTE alias for main query context (e.g., \"cte_p\")\n * @param cteColumnPrefix - Optional prefix for CTE WHERE context:\n *   - undefined: Use aliased column names (e.g., \"p_props\")\n *   - \"\": Use raw column names (e.g., \"props\") for start CTE\n *   - \"n\": Use table-qualified names (e.g., \"n.props\") for traversal CTE\n */\nexport function compileFieldColumn(\n  field: FieldRef,\n  cteAlias?: string,\n  cteColumnPrefix?: string,\n): SqlFragment {\n  // When cteColumnPrefix is defined (including empty string), use raw column names\n  // This is for CTE WHERE clauses which operate on raw table columns\n  if (cteColumnPrefix !== undefined) {\n    const qualifier = cteColumnPrefix === \"\" ? \"\" : `${cteColumnPrefix}.`;\n\n    if (field.path.length === 1 && field.path[0] === \"id\") {\n      return sql.raw(`${qualifier}id`);\n    }\n    if (field.path.length === 1 && field.path[0] === \"kind\") {\n      return sql.raw(`${qualifier}kind`);\n    }\n    if (field.path.length > 0 && field.path[0] === \"props\") {\n      return sql.raw(`${qualifier}props`);\n    }\n\n    return sql.raw(`${qualifier}${field.path.join(\"_\")}`);\n  }\n\n  // Default behavior: use aliased column names (e.g., \"p_props\")\n  const prefix = field.alias;\n  const qualifier = cteAlias ? `${cteAlias}.` : \"\";\n\n  if (field.path.length === 1 && field.path[0] === \"id\") {\n    return sql.raw(`${qualifier}${prefix}_id`);\n  }\n  if (field.path.length === 1 && field.path[0] === \"kind\") {\n    return sql.raw(`${qualifier}${prefix}_kind`);\n  }\n  if (field.path.length > 0 && field.path[0] === \"props\") {\n    return sql.raw(`${qualifier}${prefix}_props`);\n  }\n\n  return sql.raw(`${qualifier}${prefix}_${field.path.join(\"_\")}`);\n}\n\n/**\n * Gets the JSON pointer for a field reference.\n */\nexport function getFieldPointer(field: FieldRef): JsonPointer | undefined {\n  if (field.jsonPointer !== undefined) {\n    return field.jsonPointer;\n  }\n\n  if (field.path.length > 1 && field.path[0] === \"props\") {\n    return jsonPointer(field.path.slice(1));\n  }\n\n  return undefined;\n}\n\n/**\n * Checks if a field reference points to a JSON props column.\n */\nfunction isJsonField(field: FieldRef): boolean {\n  return field.path.length > 0 && field.path[0] === \"props\";\n}\n\n/**\n * Normalizes a value type, treating \"unknown\" as undefined.\n */\nfunction normalizeValueType(\n  valueType: ValueType | undefined,\n): ValueType | undefined {\n  if (!valueType || valueType === \"unknown\") {\n    return undefined;\n  }\n  return valueType;\n}\n\n/**\n * The value type a `param()` in a comparison binds as: the parameter's own\n * declared type when it has one, else the field's.\n *\n * Shared so the two things that must agree about it cannot drift — the\n * compiler picks the `jsonExtract*` variant (and, for a list parameter, the\n * matching element cast) from this, and `PreparedQuery` validates the caller's\n * bindings against the same answer.\n */\nexport function resolveParameterValueType(\n  left: FieldRef,\n  right: ParameterRef,\n): ValueType | undefined {\n  return (\n    normalizeValueType(right.valueType) ?? normalizeValueType(left.valueType)\n  );\n}\n\n/**\n * Compiles a field reference to SQL with appropriate type extraction.\n */\nexport function compileFieldValue(\n  field: FieldRef,\n  dialect: DialectAdapter,\n  valueType?: ValueType,\n  cteAlias?: string,\n  pointerOverride?: JsonPointer,\n  cteColumnPrefix?: string,\n): SqlFragment {\n  const column = compileFieldColumn(field, cteAlias, cteColumnPrefix);\n  return compileFieldValueFromColumn(\n    field,\n    dialect,\n    valueType,\n    column,\n    pointerOverride,\n  );\n}\n\n/** Applies a field's JSON/value decoding to an already-resolved column token. */\nexport function compileFieldValueFromColumn(\n  field: FieldRef,\n  dialect: DialectAdapter,\n  valueType: ValueType | undefined,\n  column: SqlFragment,\n  pointerOverride?: JsonPointer,\n): SqlFragment {\n  const resolved = normalizeValueType(valueType);\n\n  if (!isJsonField(field)) {\n    return column;\n  }\n\n  const pointer = pointerOverride ?? getFieldPointer(field);\n  if (!pointer || pointer === \"\") {\n    return column;\n  }\n\n  switch (resolved) {\n    case \"number\": {\n      return dialect.jsonExtractNumber(column, pointer);\n    }\n    case \"boolean\": {\n      return dialect.jsonExtractBoolean(column, pointer);\n    }\n    case \"date\": {\n      return dialect.jsonExtractDate(column, pointer);\n    }\n    case \"array\":\n    case \"object\":\n    case \"embedding\": {\n      // Embeddings are stored in a separate table, but if we need to\n      // extract from JSON, treat like a regular JSON value\n      return dialect.jsonExtract(column, pointer);\n    }\n    case \"string\":\n    case \"unknown\":\n    case undefined: {\n      return dialect.jsonExtractText(column, pointer);\n    }\n  }\n}\n\n/**\n * Compiles a field reference for text comparison.\n */\nfunction compileFieldTextValue(\n  field: FieldRef,\n  dialect: DialectAdapter,\n  cteAlias?: string,\n  pointerOverride?: JsonPointer,\n  cteColumnPrefix?: string,\n): SqlFragment {\n  const column = compileFieldColumn(field, cteAlias, cteColumnPrefix);\n  if (!isJsonField(field)) {\n    return column;\n  }\n\n  const pointer = pointerOverride ?? getFieldPointer(field);\n  if (!pointer || pointer === \"\") {\n    return column;\n  }\n\n  return dialect.jsonExtractText(column, pointer);\n}\n\n/**\n * Compiles a field reference for JSON value extraction.\n */\nfunction compileFieldJsonValue(\n  field: FieldRef,\n  dialect: DialectAdapter,\n  cteAlias?: string,\n  pointerOverride?: JsonPointer,\n  cteColumnPrefix?: string,\n): SqlFragment {\n  const column = compileFieldColumn(field, cteAlias, cteColumnPrefix);\n  if (!isJsonField(field)) {\n    return column;\n  }\n\n  const pointer = pointerOverride ?? getFieldPointer(field);\n  if (!pointer || pointer === \"\") {\n    return column;\n  }\n\n  return dialect.jsonExtract(column, pointer);\n}\n\n// ============================================================\n// Value Type Resolution\n// ============================================================\n\n/**\n * Resolves literal value types from an array of literals.\n */\nfunction resolveLiteralValueTypes(\n  literals: readonly LiteralValue[],\n): ValueType | undefined {\n  const resolved = new Set<ValueType>();\n\n  for (const literal of literals) {\n    const valueType = normalizeValueType(literal.valueType);\n    if (valueType) {\n      resolved.add(valueType);\n    }\n  }\n\n  if (resolved.size > 1) {\n    throw new UnsupportedPredicateError(\n      \"Mixed literal value types are not supported in predicates\",\n      { valueTypes: [...resolved] },\n    );\n  }\n\n  return resolved.values().next().value;\n}\n\n/**\n * Resolves the value type for a comparison predicate.\n */\nfunction resolveComparisonValueType(\n  field: FieldRef,\n  right: FieldRef | LiteralValue | readonly LiteralValue[] | ParameterRef,\n): ValueType | undefined {\n  if (isParameterRef(right)) {\n    return (\n      normalizeValueType(right.valueType) ?? normalizeValueType(field.valueType)\n    );\n  }\n  if (isFieldReference(right)) {\n    const fieldType = normalizeValueType(field.valueType);\n    const rightType = normalizeValueType(right.valueType);\n    if (fieldType && rightType && fieldType !== rightType) {\n      throw new UnsupportedPredicateError(\n        `Cannot compare ${fieldType} and ${rightType} fields`,\n        { leftValueType: fieldType, rightValueType: rightType },\n      );\n    }\n    return fieldType ?? rightType;\n  }\n  const literals = Array.isArray(right) ? right : [right];\n  const literalType = resolveLiteralValueTypes(literals);\n  const fieldType = normalizeValueType(field.valueType);\n\n  // Date fields compared with string literals should use date type\n  if (fieldType === \"date\" && literalType === \"string\") {\n    return fieldType;\n  }\n\n  if (literalType) {\n    return literalType;\n  }\n\n  return fieldType;\n}\n\nfunction isFieldReference(value: unknown): value is FieldRef {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    (value as Readonly<{ __type?: unknown }>).__type === \"field_ref\"\n  );\n}\n\n/**\n * Resolves value type with preference for explicit type.\n */\nfunction resolvePredicateValueType(\n  preferred: ValueType | undefined,\n  literal: LiteralValue | undefined,\n): ValueType | undefined {\n  const normalizedPreferred = normalizeValueType(preferred);\n  if (normalizedPreferred) {\n    return normalizedPreferred;\n  }\n\n  return literal ? normalizeValueType(literal.valueType) : undefined;\n}\n\n// ============================================================\n// Value Conversion\n// ============================================================\n\n/**\n * Converts a literal value for SQL binding.\n * Delegates to dialect adapter for proper type conversion (e.g., boolean → 0/1 for SQLite).\n */\nfunction convertValueForSql(value: unknown, dialect: DialectAdapter): unknown {\n  return dialect.bindValue(value);\n}\n\n// ============================================================\n// String Pattern Compilation\n// ============================================================\n\n/**\n * Compiles a string pattern for LIKE operations.\n */\nfunction compileStringPattern(op: string, pattern: string): string {\n  // Escape the escape character first so the wildcards we prefix below aren't\n  // double-escaped, then neutralize the LIKE wildcards. Mirrors\n  // escapeLikePatternParameter for the parameterized path. The emitted\n  // LIKE/ILIKE declares this same character as its ESCAPE (see likeEscapeClause).\n  const escaped = pattern\n    .replaceAll(\n      LIKE_ESCAPE_CHARACTER,\n      `${LIKE_ESCAPE_CHARACTER}${LIKE_ESCAPE_CHARACTER}`,\n    )\n    .replaceAll(\"%\", `${LIKE_ESCAPE_CHARACTER}%`)\n    .replaceAll(\"_\", `${LIKE_ESCAPE_CHARACTER}_`);\n\n  switch (op) {\n    case \"contains\": {\n      return `%${escaped}%`;\n    }\n    case \"startsWith\": {\n      return `${escaped}%`;\n    }\n    case \"endsWith\": {\n      return `%${escaped}`;\n    }\n    case \"like\":\n    case \"ilike\": {\n      return pattern;\n    }\n    default: {\n      return escaped;\n    }\n  }\n}\n\n/**\n * Escapes wildcard characters in a SQL pattern parameter. Mirrors\n * `compileStringPattern`'s escaping for the literal-pattern path, both driven\n * by the same {@link LIKE_ESCAPE_CHARACTER} so they can't drift apart.\n */\nfunction escapeLikePatternParameter(parameter: SqlFragment): SqlFragment {\n  const doubledEscape = `${LIKE_ESCAPE_CHARACTER}${LIKE_ESCAPE_CHARACTER}`;\n  return sql`REPLACE(REPLACE(REPLACE(${parameter}, ${LIKE_ESCAPE_CHARACTER}, ${doubledEscape}), '%', ${`${LIKE_ESCAPE_CHARACTER}%`}), '_', ${`${LIKE_ESCAPE_CHARACTER}_`})`;\n}\n\n/**\n * Builds a SQL pattern expression for parameterized string operations.\n */\nfunction compileParameterizedStringPattern(\n  op: string,\n  parameter: SqlFragment,\n): SqlFragment {\n  switch (op) {\n    case \"contains\": {\n      const escaped = escapeLikePatternParameter(parameter);\n      return sql`'%' || ${escaped} || '%'`;\n    }\n    case \"startsWith\": {\n      const escaped = escapeLikePatternParameter(parameter);\n      return sql`${escaped} || '%'`;\n    }\n    case \"endsWith\": {\n      const escaped = escapeLikePatternParameter(parameter);\n      return sql`'%' || ${escaped}`;\n    }\n    case \"like\":\n    case \"ilike\": {\n      return parameter;\n    }\n    default: {\n      return escapeLikePatternParameter(parameter);\n    }\n  }\n}\n\n// ============================================================\n// Predicate Compilation\n// ============================================================\n\n/**\n * Compiler context passed to recursive compilation functions.\n *\n * When compiling predicates inside CTE WHERE clauses, `cteColumnPrefix` specifies\n * how to reference columns:\n * - undefined: Use aliased column names (e.g., \"p_props\") - for main query context\n * - \"\": Use raw column names (e.g., \"props\") - for start CTE WHERE clause\n * - \"n\": Use table-qualified names (e.g., \"n.props\") - for traversal CTE WHERE clause\n */\nexport type PredicateCompilerContext = Readonly<{\n  dialect: DialectAdapter;\n  schema: SqlSchema;\n  compileQuery: (ast: QueryAst, graphId: string) => SqlFragment;\n  compileExpressionSubquery?: (ast: QueryAst) => SqlFragment;\n  compileExpressionOuterReference?: (\n    expression: DatabaseExpression,\n    outerScopeIdentity: symbol,\n  ) => SqlFragment;\n  cteColumnPrefix?: string;\n  /**\n   * Active vector strategy for `field.similarTo(...)` compilation. When\n   * present, the embeddings CTE scans the strategy's per-`(kind, field)`\n   * tables and uses its `distanceExpression`; absent on backends without\n   * vector support (the vector pass rejects the predicate before the CTE\n   * builder runs).\n   */\n  vectorStrategy?: VectorStrategy;\n  /**\n   * Whether the active backend supports SQL window functions such as\n   * `ROW_NUMBER()`.\n   */\n  windowFunctions: boolean;\n  orderedAggregates?: boolean;\n  /**\n   * Declared embedding slots `(kind, fieldPath) -> {dimensions, metric,\n   * indexType}`. The embeddings CTE consults it to know which kinds in\n   * an alias actually declare the field — only those get a per-field\n   * table scan in the UNION ALL.\n   */\n  vectorSlots?: VectorSlotMap;\n  /** Per-kind declared fulltext language for constant-tsquery parsing. */\n  fulltextLanguages?: ReadonlyMap<string, string>;\n  /**\n   * Mutable collector: the emitter records each ANN slot index type it\n   * compiles an engine-form branch for, and the compiler entry brands\n   * the finished statement with them (see markAnnIndexScan).\n   */\n  annIndexTypes?: Set<string>;\n  /**\n   * How the temporal pass emits the \"current\" read instant. Threaded from\n   * {@link CompileQueryOptions.readInstant} so the standard and recursive\n   * pipelines can compile a reusable placeholder statement for the query\n   * builder's template cache. Absent means `\"literal\"`.\n   */\n  readInstant?: ReadInstantMode;\n  /**\n   * Recorded read binding whose `source`/`predicate` seam the temporal\n   * filter pass consults when the query carries a recorded pin. Threaded\n   * from `CompileQueryOptions.recordedReadBinding`.\n   */\n  recordedReadBinding?: RecordedReadBinding;\n  /** Equal-id behavior for historical identity traversal reconstruction. */\n  identitySameIdAcrossKinds?: \"fold\" | \"ignore\";\n  compileFieldExpression?: DatabaseExpressionCompilerContext[\"compileFieldExpression\"];\n  /**\n   * Whether the active backend can compute a bounded transitive closure in\n   * one round trip. Optional per Contract E: a required member here would\n   * churn every predicate-context literal across the compiler's tests for\n   * no added protection, since the only site that reads it today\n   * (`compileVariableLengthQuery`) already asserts its presence.\n   */\n  recursiveTraversal?: RecursiveTraversalVerdict;\n  databaseExpressionAggregates?: boolean;\n  /** Resolves completed-match fields to the CTE carrying their columns. */\n  resolveFieldCteAlias?: (field: FieldRef) => string | undefined;\n  /** Final recursive CTE qualifier used by completed-result expressions. */\n  recursiveResultAlias?: string;\n}>;\n\n/**\n * Returns the compiler context's {@link RecursiveTraversalVerdict}, or\n * refuses because the plumbing was bypassed: every path that reaches this\n * function threads the verdict through `CompileQueryOptions` /\n * `propagateOptions`, so a missing verdict means a caller skipped that\n * threading, which is a compiler invariant violation, not a capability\n * refusal.\n *\n * @throws {CompilerInvariantError} when `ctx.recursiveTraversal` is undefined.\n */\nexport function requireRecursiveTraversalVerdict(\n  ctx: PredicateCompilerContext,\n  operation: string,\n): RecursiveTraversalVerdict {\n  const verdict = ctx.recursiveTraversal;\n  if (verdict === undefined) {\n    throw new CompilerInvariantError(\n      \"recursive traversal verdict missing from compiler context\",\n      { operation },\n    );\n  }\n  return verdict;\n}\n\n/**\n * Refuses a variable-length traversal when the compiler context carries no\n * {@link RecursiveTraversalVerdict}, or when the verdict says the backend\n * cannot recurse.\n *\n * A missing verdict is never silently treated as supported: every path that\n * reaches this function threads the verdict through `CompileQueryOptions` /\n * `propagateOptions`, so its absence means a caller bypassed that plumbing,\n * which is a compiler invariant violation, not a capability refusal.\n *\n * @throws {CompilerInvariantError} when `ctx.recursiveTraversal` is undefined.\n * @throws {ConfigurationError} when the verdict declares no support.\n */\nexport function assertRecursiveTraversalSupported(\n  ctx: PredicateCompilerContext,\n  operation: string,\n): void {\n  assertRecursiveTraversal(\n    requireRecursiveTraversalVerdict(ctx, operation),\n    operation,\n  );\n}\n\n/**\n * Compiles a predicate expression to SQL.\n */\nexport function compilePredicateExpression(\n  expr: PredicateExpression,\n  ctx: PredicateCompilerContext,\n): SqlFragment {\n  const { dialect } = ctx;\n\n  const cteColumnPrefix = ctx.cteColumnPrefix;\n\n  switch (expr.__type) {\n    case \"comparison\": {\n      return compileComparisonPredicate(expr, dialect, cteColumnPrefix);\n    }\n\n    case \"tuple_comparison\": {\n      return compileTupleComparisonPredicate(expr, dialect, cteColumnPrefix);\n    }\n\n    case \"string_op\": {\n      const field = compileFieldTextValue(\n        expr.field,\n        dialect,\n        undefined,\n        undefined,\n        cteColumnPrefix,\n      );\n\n      if (isParameterRef(expr.pattern)) {\n        const placeholder = sql`${sql.placeholder(expr.pattern.name)}`;\n        const pattern = compileParameterizedStringPattern(expr.op, placeholder);\n        if (\n          expr.op === \"ilike\" ||\n          expr.op === \"contains\" ||\n          expr.op === \"startsWith\" ||\n          expr.op === \"endsWith\"\n        ) {\n          return dialect.ilike(field, pattern);\n        }\n        return sql`${field} LIKE ${pattern} ${likeEscapeClause}`;\n      }\n\n      const pattern = compileStringPattern(expr.op, expr.pattern);\n      // Use case-insensitive matching for contains, startsWith, endsWith, and ilike\n      // This ensures consistent behavior across PostgreSQL (case-sensitive LIKE)\n      // and SQLite (case-insensitive LIKE for ASCII)\n      if (\n        expr.op === \"ilike\" ||\n        expr.op === \"contains\" ||\n        expr.op === \"startsWith\" ||\n        expr.op === \"endsWith\"\n      ) {\n        return dialect.ilike(field, pattern);\n      }\n      // Use case-sensitive LIKE only for explicit 'like' operator. The ESCAPE\n      // clause must match the parameterized path (above) and dialect.ilike so a\n      // raw '\\%' / '\\_' in a user pattern is a literal on SQLite too, not just\n      // on Postgres (whose default LIKE escape is already backslash).\n      return sql`${field} LIKE ${pattern} ${likeEscapeClause}`;\n    }\n\n    case \"null_check\": {\n      const field = compileFieldTextValue(\n        expr.field,\n        dialect,\n        undefined,\n        undefined,\n        cteColumnPrefix,\n      );\n      return expr.op === \"isNull\" ?\n          sql`${field} IS NULL`\n        : sql`${field} IS NOT NULL`;\n    }\n\n    case \"between\": {\n      const lowerIsParam = isParameterRef(expr.lower);\n      const upperIsParam = isParameterRef(expr.upper);\n\n      // Resolve value type from non-param bounds\n      const boundsForType: LiteralValue[] = [];\n      if (!lowerIsParam) boundsForType.push(expr.lower);\n      if (!upperIsParam) boundsForType.push(expr.upper);\n\n      const valueType =\n        boundsForType.length > 0 ?\n          resolveComparisonValueType(expr.field, boundsForType)\n        : normalizeValueType(expr.field.valueType);\n\n      if (valueType === \"array\" || valueType === \"object\") {\n        throw new UnsupportedPredicateError(\n          \"Between comparisons are not supported for JSON arrays or objects\",\n        );\n      }\n      const field = compileFieldValue(\n        expr.field,\n        dialect,\n        valueType,\n        undefined,\n        undefined,\n        cteColumnPrefix,\n      );\n      const lower =\n        lowerIsParam ?\n          sql.placeholder(expr.lower.name)\n        : convertValueForSql(expr.lower.value, dialect);\n      const upper =\n        upperIsParam ?\n          sql.placeholder(expr.upper.name)\n        : convertValueForSql(expr.upper.value, dialect);\n      return sql`${field} BETWEEN ${lower} AND ${upper}`;\n    }\n\n    case \"and\": {\n      const parts = expr.predicates.map((p) =>\n        compilePredicateExpression(p, ctx),\n      );\n      return sql`(${sql.join(parts, sql` AND `)})`;\n    }\n\n    case \"or\": {\n      const parts = expr.predicates.map((p) =>\n        compilePredicateExpression(p, ctx),\n      );\n      return sql`(${sql.join(parts, sql` OR `)})`;\n    }\n\n    case \"not\": {\n      const inner = compilePredicateExpression(expr.predicate, ctx);\n      return sql`NOT (${inner})`;\n    }\n\n    case \"database_expression_predicate\": {\n      return compileDatabaseExpression(expr.expression, {\n        allowAggregates: ctx.databaseExpressionAggregates ?? false,\n        aggregateClause: \"predicate\",\n        ...(ctx.cteColumnPrefix === undefined ?\n          {}\n        : { cteColumnPrefix: ctx.cteColumnPrefix }),\n        dialect,\n        ...(ctx.compileExpressionSubquery === undefined ?\n          {}\n        : { compileSubquery: ctx.compileExpressionSubquery }),\n        ...(ctx.compileExpressionOuterReference === undefined ?\n          {}\n        : { compileOuterReference: ctx.compileExpressionOuterReference }),\n        ...(ctx.compileFieldExpression === undefined ?\n          {}\n        : { compileFieldExpression: ctx.compileFieldExpression }),\n        resolveFieldCteAlias(field) {\n          if (ctx.resolveFieldCteAlias !== undefined)\n            return ctx.resolveFieldCteAlias(field);\n          return ctx.cteColumnPrefix === undefined ?\n              `cte_${field.alias}`\n            : undefined;\n        },\n      });\n    }\n\n    case \"array_op\": {\n      return compileArrayPredicate(expr, dialect, cteColumnPrefix);\n    }\n\n    case \"object_op\": {\n      return compileObjectPredicate(expr, dialect, cteColumnPrefix);\n    }\n\n    case \"aggregate_comparison\": {\n      return compileAggregatePredicate(expr, dialect);\n    }\n\n    case \"exists\": {\n      return compileExistsSubquery(expr, ctx);\n    }\n\n    case \"in_subquery\": {\n      return compileInSubquery(expr, ctx);\n    }\n\n    case \"vector_similarity\":\n    case \"fulltext_match\": {\n      // Structural predicates — handled by the main compiler via JOINs,\n      // ORDER BY, and LIMIT. Compile to 1=1 so they compose safely with\n      // surrounding AND branches.\n      return STRUCTURAL_PREDICATE_NOOP;\n    }\n  }\n}\n\nconst STRUCTURAL_PREDICATE_NOOP = sql.raw(\"1=1\");\n\n/**\n * Compiles a comparison predicate.\n */\nfunction compileComparisonPredicate(\n  expr: {\n    __type: \"comparison\";\n    op: string;\n    left: FieldRef;\n    right: FieldRef | LiteralValue | readonly LiteralValue[] | ParameterRef;\n  },\n  dialect: DialectAdapter,\n  cteColumnPrefix?: string,\n): SqlFragment {\n  // Handle ParameterRef on the right side\n  if (isParameterRef(expr.right)) {\n    const parameterValueType = resolveParameterValueType(expr.left, expr.right);\n    const left = compileFieldValue(\n      expr.left,\n      dialect,\n      parameterValueType,\n      undefined,\n      undefined,\n      cteColumnPrefix,\n    );\n    if (expr.op === \"in\" || expr.op === \"notIn\") {\n      return compileListParameterPredicate(\n        left,\n        expr.right.name,\n        parameterValueType,\n        expr.op === \"notIn\",\n        dialect,\n      );\n    }\n    const opSql = COMPARISON_OP_SQL[expr.op];\n    if (!opSql) {\n      throw new UnsupportedPredicateError(\n        `Comparison operation \"${expr.op}\" is not supported for parameterized predicates`,\n      );\n    }\n    return sql`${left} ${sql.raw(opSql)} ${sql.placeholder(expr.right.name)}`;\n  }\n\n  const valueType = resolveComparisonValueType(expr.left, expr.right);\n\n  if (valueType === \"array\" || valueType === \"object\") {\n    throw new UnsupportedPredicateError(\n      `Comparison operation \"${expr.op}\" is not supported for ${valueType} values`,\n    );\n  }\n\n  const left = compileFieldValue(\n    expr.left,\n    dialect,\n    valueType,\n    undefined,\n    undefined,\n    cteColumnPrefix,\n  );\n\n  if (expr.op === \"in\" || expr.op === \"notIn\") {\n    if (isFieldReference(expr.right)) {\n      throw new UnsupportedPredicateError(\n        `${expr.op}() does not support a field-reference operand`,\n      );\n    }\n    const values: readonly LiteralValue[] =\n      Array.isArray(expr.right) ? expr.right : [expr.right as LiteralValue];\n    if (values.length === 0) {\n      return expr.op === \"in\" ? sql.raw(\"1=0\") : sql.raw(\"1=1\");\n    }\n    const convertedValues = values.map((value) =>\n      convertValueForSql(value.value, dialect),\n    );\n    return dialect.inList(left, convertedValues, expr.op === \"notIn\");\n  }\n\n  // For single-value comparisons, extract the literal value\n  const right = expr.right;\n  if (isFieldReference(right)) {\n    const rightValue = compileFieldValue(\n      right,\n      dialect,\n      valueType,\n      undefined,\n      undefined,\n      cteColumnPrefix,\n    );\n    const opSql = COMPARISON_OP_SQL[expr.op];\n    if (!opSql) {\n      throw new UnsupportedPredicateError(\n        `Comparison operation \"${expr.op}\" is not supported`,\n      );\n    }\n    return sql`${left} ${sql.raw(opSql)} ${rightValue}`;\n  }\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- Type narrowing with Array.isArray\n  const rightValue: LiteralValue =\n    Array.isArray(right) ? requireDefined(right[0]) : right;\n\n  const convertedRight = convertValueForSql(rightValue.value, dialect);\n  const opSql = COMPARISON_OP_SQL[expr.op];\n  if (!opSql) {\n    throw new UnsupportedPredicateError(\n      `Comparison operation \"${expr.op}\" is not supported`,\n    );\n  }\n  return sql`${left} ${sql.raw(opSql)} ${convertedRight}`;\n}\n\nfunction compileTupleComparisonPredicate(\n  expr: Extract<PredicateExpression, { __type: \"tuple_comparison\" }>,\n  dialect: DialectAdapter,\n  cteColumnPrefix?: string,\n): SqlFragment {\n  if (expr.fields.length !== expr.values.length)\n    throw new UnsupportedPredicateError(\n      \"Tuple comparisons require equally sized field and value tuples\",\n    );\n  const fields = expr.fields.map((field, index) =>\n    compileFieldValue(\n      field,\n      dialect,\n      resolveComparisonValueType(field, requireDefined(expr.values[index])),\n      undefined,\n      undefined,\n      cteColumnPrefix,\n    ),\n  );\n  const values = expr.values.map(\n    (value) => sql`${convertValueForSql(value.value, dialect)}`,\n  );\n  if (dialect.rowValueComparison === undefined)\n    return compileTupleComparisonFallback(expr.op, fields, values);\n  return dialect.rowValueComparison(\n    expr.op === \"gt\" ? \">\" : \"<\",\n    fields,\n    values,\n  );\n}\n\n/** Preserves lexicographic cursor semantics for adapters without row values. */\nfunction compileTupleComparisonFallback(\n  operator: \"gt\" | \"lt\",\n  fields: readonly SqlFragment[],\n  values: readonly SqlFragment[],\n): SqlFragment {\n  const comparison = sql.raw(operator === \"gt\" ? \">\" : \"<\");\n  const terms = fields.map((field, index) => {\n    const prefix = fields\n      .slice(0, index)\n      .map(\n        (prefixField, prefixIndex) =>\n          sql`${prefixField} = ${requireDefined(values[prefixIndex])}`,\n      );\n    const currentValue = requireDefined(values[index]);\n    const current = sql`${field} ${comparison} ${currentValue}`;\n    return prefix.length === 0 ?\n        current\n      : sql`(${sql.join([...prefix, current], sql` AND `)})`;\n  });\n  return sql`(${sql.join(terms, sql` OR `)})`;\n}\n\n/**\n * Compiles `field.in(param(\"ids\"))` / `field.notIn(param(\"ids\"))`.\n *\n * The whole list rides on ONE placeholder — the dialect unpacks it — so the\n * emitted SQL text is independent of how many elements the caller eventually\n * binds. That is what lets a prepared query compile once and serve every\n * arity from the same cached template, including the empty list (which yields\n * an empty relation, hence `IN` false / `NOT IN` true, matching the literal\n * form's short circuit).\n */\nfunction compileListParameterPredicate(\n  left: SqlFragment,\n  parameterName: string,\n  elementType: ValueType | undefined,\n  negated: boolean,\n  dialect: DialectAdapter,\n): SqlFragment {\n  if (\n    elementType === \"array\" ||\n    elementType === \"object\" ||\n    elementType === \"embedding\"\n  ) {\n    throw new UnsupportedPredicateError(\n      `IN/NOT IN is not supported for ${elementType} values`,\n      { valueType: elementType },\n      {\n        suggestion:\n          \"Use scalar fields (string/number/boolean/date) in IN/NOT IN predicates.\",\n      },\n    );\n  }\n  return dialect.inListParameter(left, sql.placeholder(parameterName), {\n    negated,\n    elementType,\n  });\n}\n\n/**\n * Compiles an array predicate.\n */\nfunction compileArrayPredicate(\n  expr: ArrayPredicate,\n  dialect: DialectAdapter,\n  cteColumnPrefix?: string,\n): SqlFragment {\n  const field = compileFieldJsonValue(\n    expr.field,\n    dialect,\n    undefined,\n    undefined,\n    cteColumnPrefix,\n  );\n  const values =\n    expr.values?.map((v) => convertValueForSql(v.value, dialect)) ?? [];\n\n  switch (expr.op) {\n    case \"isEmpty\": {\n      return sql`(${field} IS NULL OR ${dialect.jsonArrayLength(field)} = 0)`;\n    }\n    case \"isNotEmpty\": {\n      return sql`(${field} IS NOT NULL AND ${dialect.jsonArrayLength(field)} > 0)`;\n    }\n    case \"lengthEq\": {\n      return sql`${dialect.jsonArrayLength(field)} = ${expr.length}`;\n    }\n    case \"lengthGt\": {\n      return sql`${dialect.jsonArrayLength(field)} > ${expr.length}`;\n    }\n    case \"lengthGte\": {\n      return sql`${dialect.jsonArrayLength(field)} >= ${expr.length}`;\n    }\n    case \"lengthLt\": {\n      return sql`${dialect.jsonArrayLength(field)} < ${expr.length}`;\n    }\n    case \"lengthLte\": {\n      return sql`${dialect.jsonArrayLength(field)} <= ${expr.length}`;\n    }\n    case \"contains\": {\n      const value = values[0];\n      if (value === undefined) {\n        return sql.raw(\"1=0\");\n      }\n      return dialect.jsonArrayContains(field, value);\n    }\n    case \"containsAll\": {\n      return dialect.jsonArrayContainsAll(field, values);\n    }\n    case \"containsAny\": {\n      return dialect.jsonArrayContainsAny(field, values);\n    }\n  }\n}\n\n/**\n * Compiles an object/JSON predicate.\n */\nfunction compileObjectPredicate(\n  expr: ObjectPredicate,\n  dialect: DialectAdapter,\n  cteColumnPrefix?: string,\n): SqlFragment {\n  const basePointer = getFieldPointer(expr.field);\n  const pointer = joinJsonPointers(basePointer, expr.pointer);\n  const column = compileFieldColumn(expr.field, undefined, cteColumnPrefix);\n\n  switch (expr.op) {\n    case \"hasKey\":\n    case \"hasPath\": {\n      return dialect.jsonHasPath(column, pointer);\n    }\n\n    case \"pathEquals\": {\n      if (!expr.value) {\n        throw new UnsupportedPredicateError(\n          \"pathEquals requires a comparison value\",\n        );\n      }\n      const valueType = resolvePredicateValueType(expr.valueType, expr.value);\n      if (valueType === \"array\" || valueType === \"object\") {\n        throw new UnsupportedPredicateError(\n          \"pathEquals is not supported for JSON arrays or objects\",\n        );\n      }\n      const left = compileFieldValue(\n        expr.field,\n        dialect,\n        valueType,\n        undefined,\n        pointer,\n        cteColumnPrefix,\n      );\n      return sql`${left} = ${convertValueForSql(expr.value.value, dialect)}`;\n    }\n\n    case \"pathContains\": {\n      if (!expr.value) {\n        throw new UnsupportedPredicateError(\n          \"pathContains requires a comparison value\",\n        );\n      }\n      const arrayField = compileFieldJsonValue(\n        expr.field,\n        dialect,\n        undefined,\n        pointer,\n        cteColumnPrefix,\n      );\n      return dialect.jsonArrayContains(\n        arrayField,\n        convertValueForSql(expr.value.value, dialect),\n      );\n    }\n\n    case \"pathIsNull\": {\n      return dialect.jsonPathIsNull(column, pointer);\n    }\n\n    case \"pathIsNotNull\": {\n      return dialect.jsonPathIsNotNull(column, pointer);\n    }\n  }\n}\n\n/**\n * AggregateExpr structure from AST.\n */\ntype AggregateExprInput = Readonly<{\n  __type: \"aggregate\";\n  function: AggregateExpr[\"function\"];\n  field: FieldRef;\n}>;\n\n/**\n * Compiles an aggregate comparison predicate.\n */\nfunction compileAggregatePredicate(\n  expr: {\n    __type: \"aggregate_comparison\";\n    op: string;\n    aggregate: AggregateExprInput;\n    value: LiteralValue;\n  },\n  dialect: DialectAdapter,\n): SqlFragment {\n  const aggregate = compileAggregateExpr(expr.aggregate, dialect);\n\n  const op = COMPARISON_OP_SQL[expr.op];\n  if (!op) {\n    throw new UnsupportedPredicateError(\n      `Comparison operation \"${expr.op}\" is not supported for aggregate predicates`,\n    );\n  }\n\n  const convertedValue = convertValueForSql(expr.value.value, dialect);\n  return sql`${aggregate} ${sql.raw(op)} ${convertedValue}`;\n}\n\n/**\n * Compiles an aggregate expression.\n */\nfunction compileAggregateExpr(\n  expr: AggregateExprInput,\n  dialect: DialectAdapter,\n): SqlFragment {\n  validateAggregateOperand(expr);\n  return compileLegacyAggregateExpression(expr, {\n    dialect,\n    resolveFieldCteAlias() {\n      return `cte_${expr.field.alias}`;\n    },\n  });\n}\n\n/**\n * Compiles an EXISTS subquery predicate.\n */\nfunction compileExistsSubquery(\n  expr: ExistsSubquery,\n  ctx: PredicateCompilerContext,\n): SqlFragment {\n  if (expr.subquery.graphId === undefined) {\n    throw new UnsupportedPredicateError(\"EXISTS subquery must have a graphId\");\n  }\n  const subSql = ctx.compileQuery(expr.subquery, expr.subquery.graphId);\n  return expr.negated ? sql`NOT EXISTS (${subSql})` : sql`EXISTS (${subSql})`;\n}\n\n/**\n * Compiles an IN subquery predicate.\n */\nfunction compileInSubquery(\n  expr: InSubquery,\n  ctx: PredicateCompilerContext,\n): SqlFragment {\n  const subqueryColumnCount = getSubqueryColumnCount(expr.subquery);\n  if (subqueryColumnCount !== 1) {\n    throw new UnsupportedPredicateError(\n      `IN/NOT IN subquery must project exactly 1 column, but got ${subqueryColumnCount}`,\n      { subqueryColumnCount },\n    );\n  }\n\n  const fieldValueType = normalizeValueType(expr.field.valueType);\n  const subqueryValueType = getSingleSubqueryColumnValueType(expr.subquery);\n  const resolvedValueType = fieldValueType ?? subqueryValueType;\n\n  if (isUnsupportedInSubqueryValueType(resolvedValueType)) {\n    throw new UnsupportedPredicateError(\n      `IN/NOT IN subquery does not support ${String(resolvedValueType)} values`,\n      { valueType: resolvedValueType },\n    );\n  }\n\n  if (!isInSubqueryTypeCompatible(fieldValueType, subqueryValueType)) {\n    throw new UnsupportedPredicateError(\n      `IN/NOT IN type mismatch: field type \"${String(fieldValueType)}\" does not match subquery column type \"${String(subqueryValueType)}\"`,\n      {\n        fieldValueType,\n        subqueryValueType,\n      },\n    );\n  }\n\n  const valueType = fieldValueType ?? subqueryValueType;\n  if (expr.subquery.graphId === undefined) {\n    throw new UnsupportedPredicateError(\n      \"IN/NOT IN subquery must have a graphId\",\n    );\n  }\n  const fieldSql = compileFieldValue(\n    expr.field,\n    ctx.dialect,\n    valueType,\n    undefined,\n    undefined,\n    ctx.cteColumnPrefix,\n  );\n  const subSql = ctx.compileQuery(expr.subquery, expr.subquery.graphId);\n  return expr.negated ?\n      sql`${fieldSql} NOT IN (${subSql})`\n    : sql`${fieldSql} IN (${subSql})`;\n}\n\n/**\n * Compiles a vector similarity predicate.\n *\n * Vector similarity predicates require special handling at the query compilation\n * level to handle:\n * - JOIN to embeddings table\n * - ORDER BY distance ASC\n * - LIMIT k\n *\n * This function handles the minScore filter if present. The main query compiler\n * must detect vector_similarity predicates and set up the appropriate JOINs\n * and ordering.\n */\n\n// ============================================================\n// Structural Predicate Extraction\n// ============================================================\n\n/**\n * Extracts all instances of a \"structural\" predicate (one that rewrites\n * the query into JOIN + ORDER BY + LIMIT, rather than acting as a\n * boolean WHERE clause). Both `vector_similarity` and `fulltext_match`\n * have the same placement rules: top-level or under AND only — nesting\n * under OR/NOT is rejected because the rewrite is incompatible with\n * disjunction and negation.\n */\nfunction extractStructuralPredicates<T extends PredicateExpression>(\n  predicates: readonly { expression: PredicateExpression }[],\n  isMatch: (expr: PredicateExpression) => expr is T,\n  rejectionMessage: string,\n): T[] {\n  const results: T[] = [];\n\n  function visit(expr: PredicateExpression, inDisallowedBranch: boolean): void {\n    if (isMatch(expr)) {\n      if (inDisallowedBranch) {\n        throw new UnsupportedPredicateError(rejectionMessage);\n      }\n      results.push(expr);\n      return;\n    }\n    switch (expr.__type) {\n      case \"and\": {\n        for (const child of expr.predicates) visit(child, inDisallowedBranch);\n        return;\n      }\n      case \"or\": {\n        for (const child of expr.predicates) visit(child, true);\n        return;\n      }\n      case \"not\": {\n        visit(expr.predicate, true);\n        return;\n      }\n      case \"comparison\":\n      case \"tuple_comparison\":\n      case \"string_op\":\n      case \"null_check\":\n      case \"between\":\n      case \"array_op\":\n      case \"object_op\":\n      case \"aggregate_comparison\":\n      case \"exists\":\n      case \"in_subquery\":\n      case \"vector_similarity\":\n      case \"fulltext_match\": {\n        return;\n      }\n      case \"database_expression_predicate\": {\n        return;\n      }\n    }\n  }\n\n  for (const pred of predicates) visit(pred.expression, false);\n  return results;\n}\n\nexport function extractVectorSimilarityPredicates(\n  predicates: readonly { expression: PredicateExpression }[],\n): VectorSimilarityPredicate[] {\n  return extractStructuralPredicates(\n    predicates,\n    (expr): expr is VectorSimilarityPredicate =>\n      expr.__type === \"vector_similarity\",\n    \"Vector similarity predicates cannot be nested under OR or NOT. \" +\n      \"Use top-level AND combinations instead.\",\n  );\n}\n\nexport function extractFulltextMatchPredicates(\n  predicates: readonly { expression: PredicateExpression }[],\n): FulltextMatchPredicate[] {\n  return extractStructuralPredicates(\n    predicates,\n    (expr): expr is FulltextMatchPredicate => expr.__type === \"fulltext_match\",\n    \"Fulltext match predicates cannot be nested under OR or NOT. \" +\n      \"Use top-level AND combinations instead.\",\n  );\n}\n\n// ============================================================\n// Exports for aggregate compilation\n// ============================================================\n\nexport { compileAggregateExpr };\n","import { ConfigurationError, UnsupportedPredicateError } from \"../../errors\";\nimport {\n  assertPortableCountDistinctValueType,\n  assertPortableScalarValueType,\n} from \"../aggregate-value-types\";\nimport { type AggregateExpr, type FieldRef, type QueryAst } from \"../ast\";\nimport { type DialectAdapter } from \"../dialect/types\";\nimport {\n  type AggregateOperator,\n  arrayExpressionElementType,\n  assertPortableArrayMembershipElementType,\n  type DatabaseExpression,\n  type DatabaseExpressionNode,\n  type DatabaseLiteral,\n  isCollectRecordOperand,\n  isCollectScalarOperand,\n  resolveCollectFilter,\n  resolveCollectOrder,\n  resolveCollectRecordFields,\n} from \"../expressions\";\nimport { compileOrderTerm } from \"../order\";\nimport { sql, type SqlFragment } from \"../sql-fragment\";\nimport { isAggregateExpression } from \"./expression-inspection\";\nimport { compileFieldValue } from \"./predicates\";\n\nexport type DatabaseExpressionCompilerContext = Readonly<{\n  dialect: DialectAdapter;\n  cteColumnPrefix?: string;\n  allowAggregates?: boolean;\n  aggregateClause?: string;\n  orderedAggregates?: boolean;\n  /** Resolves fields for non-graph sources such as derived relation outputs. */\n  compileFieldExpression?: (\n    field: FieldRef,\n    expression: DatabaseExpression,\n  ) => SqlFragment | undefined;\n  resolveFieldCteAlias?: (field: FieldRef) => string | undefined;\n  compileSubquery?: (\n    subquery: QueryAst,\n    kind: \"exists\" | \"scalar\",\n  ) => SqlFragment;\n  compileOuterReference?: (\n    expression: DatabaseExpression,\n    outerScopeIdentity: symbol,\n  ) => SqlFragment;\n}>;\n\nfunction compileLiteral(\n  value: DatabaseLiteral,\n  dialect: DialectAdapter,\n): SqlFragment {\n  if (value === undefined) return sql.raw(\"NULL\");\n  if (value instanceof Date) return sql`${value.toISOString()}`;\n  if (typeof value === \"object\") return sql`${JSON.stringify(value)}`;\n  if (typeof value === \"boolean\") return dialect.booleanLiteral(value);\n  if (typeof value === \"number\") {\n    if (!Number.isFinite(value)) {\n      throw new UnsupportedPredicateError(\n        \"Database expression numeric literals must be finite\",\n      );\n    }\n    return sql.raw(String(value));\n  }\n  return sql`${value}`;\n}\n\nfunction comparisonOperator(\n  operator: \"eq\" | \"gt\" | \"gte\" | \"lt\" | \"lte\" | \"neq\",\n): SqlFragment {\n  switch (operator) {\n    case \"eq\": {\n      return sql.raw(\"=\");\n    }\n    case \"neq\": {\n      return sql.raw(\"<>\");\n    }\n    case \"gt\": {\n      return sql.raw(\">\");\n    }\n    case \"gte\": {\n      return sql.raw(\">=\");\n    }\n    case \"lt\": {\n      return sql.raw(\"<\");\n    }\n    case \"lte\": {\n      return sql.raw(\"<=\");\n    }\n  }\n}\n\nfunction aggregateFunction(operator: AggregateOperator): SqlFragment {\n  switch (operator) {\n    case \"avg\": {\n      return sql.raw(\"AVG\");\n    }\n    case \"count\": {\n      return sql.raw(\"COUNT\");\n    }\n    case \"max\": {\n      return sql.raw(\"MAX\");\n    }\n    case \"min\": {\n      return sql.raw(\"MIN\");\n    }\n    case \"sum\": {\n      return sql.raw(\"SUM\");\n    }\n    case \"countDistinct\": {\n      throw new UnsupportedPredicateError(\n        \"COUNT DISTINCT must be compiled through its operand-aware path\",\n      );\n    }\n    default: {\n      throw new UnsupportedPredicateError(\n        `Unknown aggregate function: ${String(operator)}`,\n      );\n    }\n  }\n}\n\nfunction compileNode(\n  expression: DatabaseExpression,\n  context: DatabaseExpressionCompilerContext,\n  aggregateDepth: number,\n): SqlFragment {\n  const node: DatabaseExpressionNode = expression.node;\n  function compile(expression: DatabaseExpression): SqlFragment {\n    return compileNode(expression, context, aggregateDepth);\n  }\n\n  if (isAggregateExpression(expression)) {\n    if (context.allowAggregates === false) {\n      throw new UnsupportedPredicateError(\n        `Aggregate expressions are not allowed in ${context.aggregateClause ?? \"this query\"} clauses`,\n      );\n    }\n    if (aggregateDepth > 0) {\n      throw new UnsupportedPredicateError(\n        \"Nested aggregate expressions are not supported\",\n      );\n    }\n  }\n  switch (node.kind) {\n    case \"field\": {\n      const resolved = context.compileFieldExpression?.(node.field, expression);\n      if (resolved !== undefined) return resolved;\n      return compileFieldValue(\n        node.field,\n        context.dialect,\n        expression.valueType,\n        context.resolveFieldCteAlias?.(node.field),\n        undefined,\n        context.cteColumnPrefix,\n      );\n    }\n    case \"literal\": {\n      return compileLiteral(node.value, context.dialect);\n    }\n    case \"parameter\": {\n      return sql.placeholder(node.name);\n    }\n    case \"arithmetic\": {\n      const left = compile(node.left);\n      const right = compile(node.right);\n      switch (node.operator) {\n        case \"add\": {\n          return sql`(${left} + ${right})`;\n        }\n        case \"subtract\": {\n          return sql`(${left} - ${right})`;\n        }\n        case \"multiply\": {\n          return sql`(${left} * ${right})`;\n        }\n        case \"divide\": {\n          return sql`(1.0 * ${left} / NULLIF(${right}, 0))`;\n        }\n      }\n      throw new UnsupportedPredicateError(\n        \"Unknown database arithmetic operator\",\n      );\n    }\n    case \"comparison\": {\n      return sql`(${compile(node.left)} ${comparisonOperator(node.operator)} ${compile(node.right)})`;\n    }\n    case \"array_contains\": {\n      const elementType = arrayExpressionElementType(node.array);\n      if (elementType === undefined)\n        throw new UnsupportedPredicateError(\n          \"Array membership requires a known element type\",\n        );\n      assertPortableArrayMembershipElementType(elementType);\n      if (context.dialect.jsonArrayContainsExpression === undefined) {\n        throw new ConfigurationError(\n          \"The active dialect adapter does not support the jsonArrayContainsExpression capability.\",\n          { capability: \"jsonArrayContainsExpression\" },\n        );\n      }\n      return context.dialect.jsonArrayContainsExpression(\n        compile(node.array),\n        compile(node.element),\n        elementType,\n      );\n    }\n    case \"boolean\": {\n      const separator = node.operator === \"and\" ? sql` AND ` : sql` OR `;\n      return sql`(${sql.join(\n        node.operands.map((operand) => compile(operand)),\n        separator,\n      )})`;\n    }\n    case \"not\": {\n      return sql`NOT (${compile(node.operand)})`;\n    }\n    case \"null_check\": {\n      const operator =\n        node.operator === \"isNull\" ?\n          sql.raw(\"IS NULL\")\n        : sql.raw(\"IS NOT NULL\");\n      return sql`(${compile(node.operand)} ${operator})`;\n    }\n    case \"collect\": {\n      if (context.orderedAggregates !== true)\n        throw new ConfigurationError(\n          \"COLLECT requires ordered aggregate support from the active backend profile.\",\n          { capability: \"orderedAggregates\", orderedAggregates: false },\n        );\n      const operand = node.operand;\n      if (!isCollectScalarOperand(operand) && !isCollectRecordOperand(operand))\n        throw new UnsupportedPredicateError(\"Unknown COLLECT operand kind\");\n      const ordering = resolveCollectOrder(node.orderBy).map((order) => {\n        const { direction, nulls } = order;\n        return compileOrderTerm(\n          compileNode(order.expression, context, aggregateDepth + 1),\n          direction,\n          nulls,\n        );\n      });\n      const filter = resolveCollectFilter(node.filter);\n      const compiledFilter =\n        filter === undefined ? undefined : (\n          compileNode(filter, context, aggregateDepth + 1)\n        );\n      if (isCollectRecordOperand(operand)) {\n        return context.dialect.orderedRecordJsonArray({\n          fields: resolveCollectRecordFields(operand.fields).map(\n            ({ name, expression: value }) => {\n              return {\n                name,\n                value: compileNode(value, context, aggregateDepth + 1),\n                valueType: value.valueType,\n              };\n            },\n          ),\n          filter: compiledFilter,\n          orderBy: ordering,\n        });\n      }\n      assertPortableScalarValueType(operand.valueType, \"COLLECT\");\n      return context.dialect.orderedScalarJsonArray({\n        filter: compiledFilter,\n        orderBy: ordering,\n        value: compileNode(operand, context, aggregateDepth + 1),\n        valueType: operand.valueType,\n      });\n    }\n    case \"aggregate\": {\n      const operand =\n        node.operand === undefined ?\n          sql.raw(\"*\")\n        : compileNode(node.operand, context, aggregateDepth + 1);\n      if (node.operator === \"countDistinct\") {\n        if (node.operand === undefined) {\n          throw new UnsupportedPredicateError(\n            \"COUNT DISTINCT requires an operand\",\n          );\n        }\n        assertPortableCountDistinctValueType(node.operand.valueType);\n        return sql`COUNT(DISTINCT ${operand})`;\n      }\n      return sql`${aggregateFunction(node.operator)}(${operand})`;\n    }\n    case \"coalesce\": {\n      return sql`COALESCE(${sql.join(\n        node.operands.map((operand) => compile(operand)),\n        sql`, `,\n      )})`;\n    }\n    case \"conditional\": {\n      return sql`CASE WHEN ${compile(node.condition)} THEN ${compile(node.then)} ELSE ${compile(node.otherwise)} END`;\n    }\n    case \"numeric_conversion\": {\n      if (node.operand.valueType === \"number\") return compile(node.operand);\n      return context.dialect.safeNumericConversion(compile(node.operand));\n    }\n    case \"outer_reference\": {\n      if (context.compileOuterReference === undefined) {\n        throw new UnsupportedPredicateError(\n          \"Outer references are not available in this expression compiler scope\",\n        );\n      }\n      return context.compileOuterReference(\n        node.expression,\n        node.outerScopeIdentity,\n      );\n    }\n    case \"exists_subquery\": {\n      if (context.compileSubquery === undefined) {\n        throw new UnsupportedPredicateError(\n          \"Expression subqueries are not available in this compiler scope\",\n        );\n      }\n      return sql`EXISTS (${context.compileSubquery(node.subquery, \"exists\")})`;\n    }\n    case \"scalar_subquery\": {\n      if (context.compileSubquery === undefined) {\n        throw new UnsupportedPredicateError(\n          \"Expression subqueries are not available in this compiler scope\",\n        );\n      }\n      return sql`(${context.compileSubquery(node.subquery, \"scalar\")})`;\n    }\n  }\n\n  throw new UnsupportedPredicateError(\"Unknown database expression node\");\n}\n\n/** Compiles a portable typed expression into the current query's SQL scope. */\nexport function compileDatabaseExpression(\n  expression: DatabaseExpression,\n  context: DatabaseExpressionCompilerContext,\n): SqlFragment {\n  return compileNode(expression, context, 0);\n}\n\n/** Routes the legacy aggregate AST through the shared expression emitter. */\nexport function compileLegacyAggregateExpression(\n  aggregate: AggregateExpr,\n  context: DatabaseExpressionCompilerContext,\n): SqlFragment {\n  const scopeIdentity = Symbol(\"legacy aggregate expression\");\n  const operand: DatabaseExpression = {\n    __type: \"database_expression\",\n    node: { field: aggregate.field, kind: \"field\" },\n    nullable: true,\n    scopeIdentity,\n    valueType: aggregate.field.valueType ?? \"unknown\",\n  };\n  return compileDatabaseExpression(\n    {\n      __type: \"database_expression\",\n      node: {\n        kind: \"aggregate\",\n        operand,\n        operator: aggregate.function,\n      },\n      nullable:\n        aggregate.function !== \"count\" &&\n        aggregate.function !== \"countDistinct\",\n      scopeIdentity,\n      valueType:\n        aggregate.function === \"min\" || aggregate.function === \"max\" ?\n          operand.valueType\n        : \"number\",\n    },\n    context,\n  );\n}\n","import type { KindEntity } from \"../../core/types\";\nimport { CompilerInvariantError } from \"../../errors\";\nimport {\n  type FulltextMatchPredicate,\n  type NodePredicate,\n  type QueryAst,\n  type VectorSimilarityPredicate,\n} from \"../ast\";\nimport { sql, type SqlFragment } from \"../sql-fragment\";\nimport {\n  compilePredicateExpression,\n  type PredicateCompilerContext,\n} from \"./predicates\";\n\nconst EMPTY_PREDICATES: readonly NodePredicate[] = [];\n\n/**\n * Builds a comma-separated bound-parameter list for an `IN (...)` clause. Each\n * value is parameterized, never interpolated.\n */\nexport function sqlValueList(values: readonly string[]): SqlFragment {\n  return sql.join(\n    values.map((value) => sql`${value}`),\n    sql`, `,\n  );\n}\n\nexport type PredicateIndex = Readonly<{\n  byAliasAndType: ReadonlyMap<string, readonly NodePredicate[]>;\n}>;\n\nfunction buildPredicateIndexKey(alias: string, targetType: KindEntity): string {\n  return `${alias}\\u0000${targetType}`;\n}\n\nfunction resolvePredicateTargetType(predicate: NodePredicate): KindEntity {\n  return predicate.targetType === \"edge\" ? \"edge\" : \"node\";\n}\n\nexport function buildPredicateIndex(ast: QueryAst): PredicateIndex {\n  const byAliasAndType = new Map<string, NodePredicate[]>();\n  for (const predicate of ast.predicates) {\n    const key = buildPredicateIndexKey(\n      predicate.targetAlias,\n      resolvePredicateTargetType(predicate),\n    );\n    const existing = byAliasAndType.get(key);\n    if (existing === undefined) {\n      byAliasAndType.set(key, [predicate]);\n    } else {\n      existing.push(predicate);\n    }\n  }\n  return { byAliasAndType };\n}\n\nexport function getPredicatesForAlias(\n  predicateIndex: PredicateIndex,\n  alias: string,\n  targetType: KindEntity,\n): readonly NodePredicate[] {\n  return (\n    predicateIndex.byAliasAndType.get(\n      buildPredicateIndexKey(alias, targetType),\n    ) ?? EMPTY_PREDICATES\n  );\n}\n\nexport function compilePredicateClauses(\n  predicates: readonly NodePredicate[],\n  predicateContext: PredicateCompilerContext,\n): SqlFragment[] {\n  return predicates.map((predicate) =>\n    compilePredicateExpression(predicate.expression, predicateContext),\n  );\n}\n\nexport function compileKindFilter(\n  column: SqlFragment,\n  kinds: readonly string[],\n): SqlFragment {\n  if (kinds.length === 0) {\n    return sql`1 = 0`;\n  }\n  if (kinds.length === 1) {\n    return sql`${column} = ${kinds[0]}`;\n  }\n  return sql`${column} IN (${sqlValueList(kinds)})`;\n}\n\nexport function getNodeKindsForAlias(\n  ast: QueryAst,\n  alias: string,\n): readonly string[] {\n  if (alias === ast.start.alias) {\n    return ast.start.kinds;\n  }\n\n  for (const traversal of ast.traversals) {\n    if (traversal.nodeAlias === alias) {\n      return traversal.nodeKinds;\n    }\n  }\n\n  throw new CompilerInvariantError(`Unknown traversal source alias: ${alias}`);\n}\n\n/**\n * Returns the shared alias when a hybrid (vector + fulltext) query has\n * both predicates targeting the same alias — that's the case where the\n * emitter can fuse ranks via `HYBRID_CANDIDATES_CTE_ALIAS` / RRF.\n * Returns `undefined` when either predicate is missing or the two\n * predicates target different aliases.\n */\nexport function getHybridTargetAlias(\n  vectorPredicate: VectorSimilarityPredicate | undefined,\n  fulltextPredicate: FulltextMatchPredicate | undefined,\n): string | undefined {\n  if (!vectorPredicate || !fulltextPredicate) return undefined;\n  return vectorPredicate.field.alias === fulltextPredicate.field.alias ?\n      vectorPredicate.field.alias\n    : undefined;\n}\n","/**\n * Resolves after `milliseconds`. Zero or negative resolves immediately,\n * without scheduling a timer.\n */\nexport function delay(milliseconds: number): Promise<void> {\n  if (milliseconds <= 0) return Promise.resolve();\n  return new Promise((resolve) => setTimeout(resolve, milliseconds));\n}\n","/**\n * Lazy, optional loader for `node:async_hooks`' `AsyncLocalStorage`, shared by\n * every module that needs to detect something through JavaScript's async call\n * graph rather than through an explicit parameter: `serialized-execution-\n * queue.ts` (a submission made from inside a task this same queue is already\n * running) and `capabilities/retried-unit.ts` (a retried unit started while\n * already inside another one). Each caller builds its OWN loader instance —\n * {@link createAsyncContextLoader} is a factory, not a singleton — so the two\n * concerns never share a context object and one module's marker can never be\n * mistaken for the other's.\n *\n * AsyncLocalStorage is available on Node and on Cloudflare Workers with the\n * `nodejs_als` compatibility flag. A caller whose {@link AsyncContextLoader.current}\n * reads `undefined` — the constructor import failed, or the load has not\n * settled yet — must degrade exactly as it did before this loader existed;\n * this module makes no promise about what that degradation looks like, only\n * about loading the constructor once and reporting whether it succeeded.\n */\nexport type AsyncContextStore<T> = Readonly<{\n  getStore: () => T | undefined;\n  run: <R>(store: T, callback: () => R) => R;\n}>;\n\nexport type AsyncContextLoader<T> = Readonly<{\n  /**\n   * Resolves once loading has settled — successfully or not; the loader\n   * never rejects. A caller awaits this before its first read of\n   * {@link current} so \"the dynamic import has not resolved yet\" is, at\n   * worst, one microtask of latency rather than a silent detection gap.\n   */\n  ready: () => Promise<void>;\n  /** The loaded context, or `undefined` when unavailable or not yet loaded. */\n  current: () => AsyncContextStore<T> | undefined;\n  /**\n   * @internal Test seam: replaces the loader's context and readiness state\n   * with a caller-controlled value, so a test can simulate a runtime with no\n   * AsyncLocalStorage (`context: undefined`) or a cold start where the load\n   * has not resolved yet (a `readyDelayMs` the test's own assertions run\n   * within) deterministically, instead of racing the real dynamic\n   * `import(\"node:async_hooks\")`. Not reachable from published entrypoints.\n   */\n  setForTesting: (\n    context: AsyncContextStore<T> | undefined,\n    readyDelayMs?: number,\n  ) => void;\n  /** @internal Restores the real loader after a test uses {@link setForTesting}. */\n  restoreForTesting: () => void;\n}>;\n\nexport function createAsyncContextLoader<T>(): AsyncContextLoader<T> {\n  let context: AsyncContextStore<T> | undefined;\n\n  async function load(): Promise<void> {\n    try {\n      const asyncHooks = await import(\"node:async_hooks\");\n      context = new asyncHooks.AsyncLocalStorage<T>();\n    } catch {\n      // AsyncLocalStorage unavailable on this runtime: the caller degrades\n      // per its own documented fallback.\n    }\n  }\n\n  let readyPromise: Promise<void> = load();\n\n  return {\n    ready: () => readyPromise,\n    current: () => context,\n    setForTesting(newContext, readyDelayMs = 0) {\n      context = undefined;\n      readyPromise = new Promise((resolve) => {\n        setTimeout(() => {\n          context = newContext;\n          resolve();\n        }, readyDelayMs);\n      });\n    },\n    restoreForTesting() {\n      context = undefined;\n      readyPromise = load();\n    },\n  };\n}\n","/**\n * The retry owner for a unit of work run under the `\"optimistic-retry\"`\n * tier: a `row`-mechanism write fence with `conflict: \"commit-time\"` lets\n * two acquirers of one fence row both proceed, so the loser's COMMIT fails\n * and correctness comes from replaying the WHOLE unit from the top, never\n * from waiting.\n *\n * Lives under `backend/capabilities` — below the store, not inside it — so\n * a backend factory (`backend/drizzle/postgres.ts`,\n * `backend/drizzle/sqlite.ts`, `backend/drizzle/engine/create-sql-backend.ts`)\n * can wrap its own `db.transaction(...)` calls in {@link runRetriedUnit}\n * without importing upward into `store/`. `store/operations/write-transaction.ts`\n * imports these same exports for its store-owned units, so this stays the\n * ONE retry owner in the codebase: no caller — store or backend — runs a\n * second, parallel retry loop.\n */\nimport { ConfigurationError, TransactionConflictError } from \"../../errors\";\nimport { delay } from \"../../utils/delay\";\nimport { isSerializationFailure } from \"../../utils/sql-errors\";\nimport {\n  type AsyncContextStore,\n  createAsyncContextLoader,\n} from \"../async-context\";\nimport { type BackendCapabilities } from \"../types\";\n\n/**\n * Whether `backend`'s declared tier requires every unit of work it opens to\n * run as a retried unit: `capabilities.execution.unitOfWork` reads\n * `\"optimistic-retry\"` — a `row`-mechanism write fence with `conflict:\n * \"commit-time\"` (`src/backend/capabilities/write-fence.ts`), where two\n * acquirers of one fence row both proceed and the loser's COMMIT fails, so\n * correctness comes from replaying the whole unit from the top, never from\n * waiting.\n *\n * Takes just the `capabilities` a caller has in hand rather than a full\n * `GraphBackend | TransactionBackend`, so a caller holding only a\n * capabilities-bearing fence target (`WriteFenceTarget`, for one) reads the\n * SAME decision instead of re-spelling the `unitOfWork` comparison itself.\n */\nexport function isOptimisticRetryTier(\n  backend: Readonly<{ capabilities: BackendCapabilities }>,\n): boolean {\n  return backend.capabilities.execution.unitOfWork === \"optimistic-retry\";\n}\n\n/**\n * The retry budget for every unit of work the `\"optimistic-retry\"` tier\n * routes through {@link runRetriedUnit}: `write-executor.ts`'s three plan\n * runners, `runIdentityMutation`, `rebuildIdentityClosureWithSchemaFence`,\n * `rebuildContribution`, and the index-materialization claim/record calls\n * (all store-owned, routed through `store/operations/write-transaction.ts`),\n * plus the two backend-owned units that acquire a fence row directly —\n * PostgreSQL's graph-template row-mechanism instantiation branch and\n * `runSchemaWriteTransaction` (`src/backend/drizzle/postgres.ts`). One\n * owner, the same role graph-merge's own `MERGE_COMMIT_ATTEMPTS`\n * (`src/graph-merge/merge.ts`) plays for its three commit sites — kept\n * separate because those units route through this module's helpers, never\n * graph-merge's.\n */\nexport const OPTIMISTIC_RETRY_ATTEMPTS = 3;\n\n/**\n * Milliseconds the backoff schedule starts from once it begins growing (from\n * the third attempt on; see {@link retryBackoffDelayMs}). The only backoff\n * for transaction-conflict replay.\n */\nconst RETRY_BACKOFF_BASE_MS = 5;\n\n/** Backoff never waits longer than this, no matter how many attempts failed. */\nconst RETRY_BACKOFF_CAP_MS = 50;\n\n/**\n * Jitter applied symmetrically around the capped exponential delay, as a\n * fraction of it (0.5 means the delay actually used is anywhere from half to\n * one and a half times the capped value).\n */\nconst RETRY_BACKOFF_JITTER_RATIO = 0.5;\n\n/**\n * Delay, in milliseconds, before running `attemptNumber` after the previous\n * attempt failed with a retryable conflict. Attempt 2 (run immediately after\n * attempt 1 fails) waits zero: a single lost race deserves an immediate\n * re-open, not a pause. From attempt 3 on, the delay grows exponentially from\n * {@link RETRY_BACKOFF_BASE_MS}, capped at {@link RETRY_BACKOFF_CAP_MS} and\n * jittered by {@link RETRY_BACKOFF_JITTER_RATIO} so that several transactions\n * retrying the same conflict do not all wake up and collide again together.\n */\nfunction retryBackoffDelayMs(attemptNumber: number): number {\n  if (attemptNumber <= 2) return 0;\n  const exponential = RETRY_BACKOFF_BASE_MS * 2 ** (attemptNumber - 2);\n  const capped = Math.min(RETRY_BACKOFF_CAP_MS, exponential);\n  const jitterMultiplier =\n    1 + (Math.random() * 2 - 1) * RETRY_BACKOFF_JITTER_RATIO;\n  return capped * jitterMultiplier;\n}\n\n/**\n * How {@link runRetriedUnit} disposes of a failure one attempt raised:\n * whether it will re-run the unit, and — when it will not — the exact value\n * it raises to its own caller. `reported` is `undefined` while `retry` is\n * `true`; it is meaningless there and never read.\n */\ntype RetriedUnitFailureDisposition = Readonly<\n  { retry: true; reported?: undefined } | { retry: false; reported: unknown }\n>;\n\n/**\n * An attempt that itself runs a nested unit of work through this same owner —\n * graph-merge's commit sites call `target.transaction(...)`, which is\n * `store.transaction()` run with no `retry` option, i.e. a single-attempt\n * (`attempts: 1`) `runRetriedUnit` call of its own — reports a\n * {@link TransactionConflictError} as its failure, not the driver error\n * underneath, whenever that inner call is NOT recognized as nested. Detection\n * requires a working async-context loader (see `runRetriedUnit`'s own doc);\n * on a runtime where it is unavailable, the inner call cannot tell it is\n * nested, runs its own top-level loop, and — with a budget of exactly one\n * attempt — mints the wrapper on that attempt's first failure, since it has\n * no second attempt to retry into. This is the one remaining shape the\n * degraded (undetected) path still has to handle: `runRetriedUnit` refuses\n * outright, before ever reaching this code, when the target itself is on the\n * `\"optimistic-retry\"` tier and detection is unavailable — but a merge\n * target on the plain `\"interactive\"` tier carries no such refusal, so its\n * commit sites can still reach an undetected nested single-attempt call.\n * Classifying the wrapper as-is would still work ({@link isSerializationFailure}\n * walks into its `cause`), but the exhaustion `TransactionConflictError` this\n * loop mints would then wrap the INNER `TransactionConflictError` instead of\n * the driver error it wraps in turn, chaining two conflict errors where the\n * replay contract promises one. Unwrapping first makes the classification,\n * and the eventual `cause`, the same regardless of whether an attempt calls\n * the driver directly, through a nested unit detection caught (which never\n * wraps in the first place), or through one it did not.\n */\nfunction unwrapNestedConflict(error: unknown): unknown {\n  return error instanceof TransactionConflictError ? error.cause : error;\n}\n\n/**\n * Marks \"the current async execution is already inside a `runRetriedUnit`\n * attempt\" so a `runRetriedUnit` call reached from further down the same\n * call graph — synchronously or through any number of intervening `await`s —\n * can tell it is NESTED rather than a second, independent owner. A loader\n * fully separate from {@link file://../serialized-execution-queue.ts}'s own\n * (a different concern, tracking reentrant queue submissions): the two never\n * share a context object, so one can never be mistaken for the other.\n */\nconst nestedRetriedUnitContext = createAsyncContextLoader<true>();\n\n/**\n * @internal Test seam for `tests/transaction-retry.test.ts`: see\n * {@link createAsyncContextLoader}'s own `setForTesting` doc — the same\n * seam shape `tests/caller-serialized-queue.test.ts` uses for the queue's\n * loader, applied to this module's own nesting-detection instance. Not\n * reachable from published entrypoints.\n */\nexport function __setRetriedUnitAsyncContextForTesting(\n  context: AsyncContextStore<true> | undefined,\n  readyDelayMs = 0,\n): void {\n  nestedRetriedUnitContext.setForTesting(context, readyDelayMs);\n}\n\n/** @internal Restores the real loader after a test uses the seam above. */\nexport function __restoreRetriedUnitAsyncContextForTesting(): void {\n  nestedRetriedUnitContext.restoreForTesting();\n}\n\n/**\n * The one classification a retryable failure gets, called both by the retry\n * loop itself and by {@link RetriedUnitFrame} so an attempt can learn — from\n * the very same decision, not a re-spelled copy of it — how its own failure\n * will be disposed of before the loop ever sees it.\n *\n * `options.target` — the backend or transaction object this unit is writing\n * through, when the caller has one to name — is passed to\n * {@link isSerializationFailure} so a profile-declared classifier\n * (`SqlExecutionAdapter.serializationFailure`) is consulted before the\n * SQLSTATE/message rules, for an engine whose commit-conflict shape is not\n * PostgreSQL's own.\n *\n * A failure {@link isSerializationFailure} does not recognize — after\n * {@link unwrapNestedConflict} — is never retried and is reported as the\n * ORIGINAL `error`, unchanged. A recognized failure retries while attempts\n * remain; once they don't, it is reported as the {@link TransactionConflictError}\n * the loop raises for it, whose `cause` is always the unwrapped failure, so\n * exhaustion is ever only one conflict error deep.\n */\nfunction classifyRetriedUnitFailure(\n  error: unknown,\n  attemptNumber: number,\n  options: RetriedUnitOptions,\n): RetriedUnitFailureDisposition {\n  const unwrapped = unwrapNestedConflict(error);\n  if (!isSerializationFailure(unwrapped, options.target)) {\n    return { retry: false, reported: error };\n  }\n  if (attemptNumber < options.attempts) return { retry: true };\n  return {\n    retry: false,\n    reported: new TransactionConflictError(\n      { operation: options.operation, attempts: options.attempts },\n      { cause: unwrapped },\n    ),\n  };\n}\n\n/**\n * Wraps {@link classifyRetriedUnitFailure} in a one-slot memo keyed by\n * reference identity, so every call this attempt makes with the SAME error\n * object — from `frame.willRetry`/`frame.reportedFailure` inside the\n * attempt's own `catch`, and from the loop's `catch` once that same error\n * propagates out of it — resolves to the exact same disposition. That is\n * what lets an attempt report a value (to a hook, say) that is REFERENCE-\n * EQUAL to what `runRetriedUnit` goes on to raise, without minting the\n * `TransactionConflictError` twice: the attempt always rethrows the raw\n * error unchanged (never the disposition), so the loop's own classification\n * of it is the cache hit, not a second mint.\n */\nfunction createMemoizedFailureClassifier(\n  attemptNumber: number,\n  options: RetriedUnitOptions,\n): (error: unknown) => RetriedUnitFailureDisposition {\n  let cache:\n    | Readonly<{ error: unknown; disposition: RetriedUnitFailureDisposition }>\n    | undefined;\n  return (error) => {\n    if (cache !== undefined && Object.is(cache.error, error)) {\n      return cache.disposition;\n    }\n    const disposition = classifyRetriedUnitFailure(\n      error,\n      attemptNumber,\n      options,\n    );\n    cache = { error, disposition };\n    return disposition;\n  };\n}\n\n/**\n * What {@link runRetriedUnit} needs beyond the `attempt` factory: the\n * operation name and attempt budget every existing caller already supplies,\n * plus an optional `target` — the backend or transaction object the unit\n * writes through — so {@link isSerializationFailure} can consult a\n * profile-declared classifier registered for that exact object. Absent\n * `target`, classification falls back to the SQLSTATE/message rules, exactly\n * as before this field existed.\n */\nexport type RetriedUnitOptions = Readonly<{\n  operation: string;\n  attempts: number;\n  target?: object;\n}>;\n\n/**\n * Whether `target` — {@link RetriedUnitOptions.target}, declared as a bare\n * `object` so this module never needs to import the full `GraphBackend` /\n * `TransactionBackend` / fence-target union just to carry it — resolves to\n * the `\"optimistic-retry\"` tier. Delegates the actual comparison to\n * {@link isOptimisticRetryTier} (the one place that decision is made) once\n * the `\"capabilities\" in target` check has narrowed `target` to the shape\n * that predicate requires; a `target` with no `capabilities` member at all\n * (or none supplied) is never on the tier.\n */\nfunction targetIsOptimisticRetryTier(target: object | undefined): boolean {\n  return (\n    target !== undefined &&\n    \"capabilities\" in target &&\n    isOptimisticRetryTier(\n      target as Readonly<{ capabilities: BackendCapabilities }>,\n    )\n  );\n}\n\n/**\n * THE refusal `runRetriedUnit` throws when `options.target` is on the\n * `\"optimistic-retry\"` tier and the async-context loader it needs to detect\n * nesting is unavailable. See the \"Fail closed when nesting cannot be\n * detected\" section of `runRetriedUnit`'s own doc for why this tier alone\n * cannot degrade to independent per-call retry loops the way every other\n * tier safely can.\n */\nfunction optimisticRetryRequiresAsyncContext(\n  operation: string,\n): ConfigurationError {\n  return new ConfigurationError(\n    `runRetriedUnit(${JSON.stringify(operation)}): this unit's target is on the \"optimistic-retry\" tier, which requires AsyncLocalStorage ` +\n      \"(node:async_hooks) to detect a unit of work nested inside another one, \" +\n      \"but it is unavailable on this runtime. Running without that detection \" +\n      \"would let an inner unit's independent retry commit against reads an \" +\n      \"outer attempt took before it ever conflicted, so this unit is refused \" +\n      \"rather than run without it.\",\n    { code: \"OPTIMISTIC_RETRY_REQUIRES_ASYNC_CONTEXT\", operation },\n    {\n      suggestion:\n        \"Run on a runtime that provides node:async_hooks' AsyncLocalStorage \" +\n        \"(Node.js, or Cloudflare Workers with the nodejs_als compatibility \" +\n        'flag), or avoid an \"optimistic-retry\" write-fence declaration ' +\n        '(writeFence: { mechanism: \"row\", conflict: \"commit-time\" }) on ' +\n        \"this runtime. Interactive backends are unaffected.\",\n    },\n  );\n}\n\n/**\n * The per-attempt handle {@link runRetriedUnit} passes to its `attempt`\n * factory.\n */\ntype RetriedUnitFrame = Readonly<{\n  /** 1-based number of this attempt. */\n  attempt: number;\n  /**\n   * Whether `runRetriedUnit` will re-run the unit if this attempt fails with\n   * `error`. An attempt-scoped effect that must not survive a retry (a\n   * buffered hook, say) reads this to decide whether to discard itself\n   * instead of reporting.\n   */\n  willRetry: (error: unknown) => boolean;\n  /**\n   * The exact value `runRetriedUnit` raises to its caller when it does not\n   * retry `error` — the driver error itself when `error` was never\n   * retryable, or the {@link TransactionConflictError} the loop mints on\n   * exhaustion. An attempt that reports its own failure to something other\n   * than its return value (a hook, a log) uses this so that value always\n   * matches what the eventual caller sees, never a second, independently\n   * chosen error.\n   */\n  reportedFailure: (error: unknown) => unknown;\n}>;\n\n/**\n * One attempt of a unit of work run by {@link runRetriedUnit}: given a fresh\n * `frame`, performs the work and resolves with its result, or throws/rejects\n * to signal that the attempt did not commit.\n */\nexport type RetriedUnitAttempt<T> = (frame: RetriedUnitFrame) => Promise<T>;\n\n/**\n * Runs `attempt` up to `options.attempts` times, re-running it from the top\n * whenever it fails with a transaction conflict\n * ({@link isSerializationFailure}), and raising a\n * {@link TransactionConflictError} — carrying `options.operation`,\n * `options.attempts`, and the last failure as `cause` — if every attempt is\n * exhausted. A failure `isSerializationFailure` does not recognize propagates\n * unchanged on the attempt that raised it; it is never retried.\n *\n * This is the one retry owner in the codebase: every unit of work that may\n * be replayed on a transaction conflict — store-owned or backend-owned —\n * runs through this function, never a second, parallel retry loop.\n *\n * When `attempt` itself fails with a `TransactionConflictError` — the shape a\n * nested single-attempt unit reports (e.g. graph-merge's commit sites call\n * `target.transaction(...)`, which is `store.transaction()` run with no\n * `retry` option) — this loop classifies, and on exhaustion wraps, that\n * error's OWN `cause` rather than the wrapper itself\n * ({@link unwrapNestedConflict}). Exhaustion is therefore always exactly one\n * `TransactionConflictError` deep, whose `cause` is the underlying driver\n * error, never a chain of two conflict errors.\n *\n * `options.attempts` must be a positive integer — the budget for a unit that\n * has not tried even once is a configuration mistake, not a valid zero-retry\n * request, so it is refused with {@link ConfigurationError} before `attempt`\n * is ever called. `options.target`, when supplied, is threaded to\n * {@link isSerializationFailure} so a profile-declared classifier is\n * consulted for that exact backend/transaction object — see\n * {@link RetriedUnitOptions}.\n *\n * ## Nesting is structural, not declared\n *\n * A `runRetriedUnit` call reached from inside another one's `attempt` — a\n * decision-driving read followed by a call into a SEPARATE function that\n * itself opens its own `runRetriedUnit` around a fenced transaction, e.g.\n * `rebuildContribution`'s pre-reads followed by `runSchemaWriteTransaction`\n * — is detected through async context, the same mechanism\n * `serialized-execution-queue.ts` uses to detect a reentrant submission,\n * rather than through any parameter the nested call passes. When detected,\n * the nested call runs `attempt` exactly ONCE, with a `frame` whose `attempt`\n * is always `1` and whose `willRetry` always returns `false`, and lets\n * whatever `attempt` throws propagate completely unchanged — no\n * classification, no `TransactionConflictError` minted here. The reasoning:\n * the reads that decided what the nested unit would do were taken by the\n * OUTER attempt, before it ever called in; replaying only the nested part on\n * its own budget would re-run stale decisions against a database a\n * concurrent committer may have already changed, while multiplying the\n * total attempts made (an outer budget of 3 wrapping an inner budget of 3\n * could attempt the same conflict up to 9 times through two owners). Letting\n * the nested failure propagate untouched hands it to the outermost owner,\n * which replays the WHOLE unit — reads included — from the top, so the total\n * number of attempts made for one logical unit of work is always exactly the\n * outermost owner's own budget, never a multiple of nested budgets.\n *\n * Detection requires the async-context loader to have finished loading, so\n * `runRetriedUnit` awaits its readiness before ever looking at it (mirroring\n * the queue's own `await` before its first reentrancy check) — at worst one\n * microtask of latency before the very first attempt of this process runs.\n *\n * ## Fail closed when nesting cannot be detected\n *\n * If the runtime has no `node:async_hooks` `AsyncLocalStorage` at all,\n * nesting can never be detected. Independent nested retries are only ever\n * unsafe on the `\"optimistic-retry\"` tier: it is the one tier where a\n * backend-owned transaction enrolls itself as a nested unit underneath a\n * store-owned attempt that already took decision-driving reads (exactly\n * `rebuildContribution`'s pre-reads followed by `runSchemaWriteTransaction`,\n * above) — an inner unit that conflicts and then independently succeeds on\n * its own retry would commit against reads the outer attempt never refreshed,\n * and nothing about that inner success signals the outer attempt to redo\n * them. So when `options.target` resolves to the `\"optimistic-retry\"` tier\n * ({@link isOptimisticRetryTier}) and the async-context loader is\n * unavailable, `runRetriedUnit` refuses with {@link ConfigurationError} code\n * `OPTIMISTIC_RETRY_REQUIRES_ASYNC_CONTEXT` BEFORE `attempt` is ever called —\n * naming `node:async_hooks`' `AsyncLocalStorage`, or an equivalent async-\n * context primitive the host runtime provides, as what is missing.\n *\n * Under every other tier no nested owner of this kind exists — a backend\n * whose transactions do not self-enroll has nothing to detect — so this\n * function behaves exactly as it always has: one full, independent retry\n * loop per call, needing no async-context support at all. An interactive\n * backend keeps working unmodified on a runtime with no `AsyncLocalStorage`.\n * {@link unwrapNestedConflict} is what keeps THAT degraded case (a nested\n * single-attempt unit — e.g. graph-merge's `target.transaction(...)` commit\n * sites — going undetected on such a backend) correctly classified when its\n * mint reaches an outer owner unpeeled.\n *\n * ## The replay contract\n *\n * `attempt` receives a fresh `frame` on every call and MUST satisfy:\n *\n * - **Await all of its work** before resolving or rejecting. A retried\n *   attempt that left a fire-and-forget side effect in flight from a\n *   previous, failed attempt could observe — or duplicate — work the caller\n *   never sees fail.\n * - **Use only the supplied `frame`, and values created fresh inside this\n *   call.** A failed attempt's transaction rolled back, so anything it left\n *   behind in memory (a counter, a buffer, an id set) is state no committed\n *   database agrees with; reading it on the next attempt would let a rolled\n *   back attempt leak into a committed one.\n * - **Perform no effect external to its own transaction.** The whole attempt\n *   re-runs on retry, so anything it does outside that transaction (a network\n *   call, a write to a different store) runs again too.\n * - **Tolerate being run up to `attempts` times.** The caller is supplying a\n *   callback willing to be invoked that many times, not exactly once.\n */\nexport async function runRetriedUnit<T>(\n  options: RetriedUnitOptions,\n  attempt: RetriedUnitAttempt<T>,\n): Promise<T> {\n  if (!Number.isInteger(options.attempts) || options.attempts < 1) {\n    throw new ConfigurationError(\n      `runRetriedUnit(${JSON.stringify(options.operation)}): options.attempts must be a positive integer, got ${options.attempts}.`,\n      { operation: options.operation, attempts: options.attempts },\n    );\n  }\n  // Awaited before the context is ever read, so a nested call reached a\n  // microtask after this process's very first `runRetriedUnit` call still\n  // observes the loader's FINAL value rather than a still-loading\n  // `undefined` — see the \"Nesting is structural\" doc section above.\n  await nestedRetriedUnitContext.ready();\n  const context = nestedRetriedUnitContext.current();\n  // Fail closed rather than degrade: only the \"optimistic-retry\" tier has a\n  // nested owner whose independent retry can commit against stale reads (see\n  // the doc section above), so an unavailable loader is refused for it here,\n  // before `attempt` ever runs, instead of falling through to the\n  // undetected-nesting loop below.\n  if (context === undefined && targetIsOptimisticRetryTier(options.target)) {\n    throw optimisticRetryRequiresAsyncContext(options.operation);\n  }\n  // Runs `body` marked as \"inside a retried unit\" for the duration of the\n  // call, so any `runRetriedUnit` reached from further down `body`'s own\n  // call graph — nested or sibling to this one — sees the marker. A no-op\n  // wrapper when the context is unavailable: nesting simply cannot be\n  // detected then, on this call or any further down.\n  const runMarked = <R>(body: () => Promise<R>): Promise<R> =>\n    context === undefined ? body() : context.run(true, body);\n\n  if (context?.getStore() === true) {\n    // Nested: this call's OWN budget is never spent. One call, one frame\n    // pinned to attempt 1, no retry — the failure is the outermost owner's\n    // to classify, retry, or mint on exhaustion.\n    const nestedFrame: RetriedUnitFrame = {\n      attempt: 1,\n      willRetry: () => false,\n      reportedFailure: (error) => error,\n    };\n    return runMarked(() => attempt(nestedFrame));\n  }\n\n  for (let attemptNumber = 1; ; attemptNumber += 1) {\n    await delay(retryBackoffDelayMs(attemptNumber));\n    const classify = createMemoizedFailureClassifier(attemptNumber, options);\n    const frame: RetriedUnitFrame = {\n      attempt: attemptNumber,\n      willRetry: (error) => classify(error).retry,\n      reportedFailure: (error) => {\n        const disposition = classify(error);\n        return disposition.retry ? error : disposition.reported;\n      },\n    };\n    try {\n      return await runMarked(() => attempt(frame));\n    } catch (error) {\n      const disposition = classify(error);\n      if (disposition.retry) continue;\n      throw disposition.reported;\n    }\n  }\n}\n","/**\n * Canonical-form helpers for deterministic schema serialization.\n *\n * Used by both content-hashing (`computeSchemaHash`) and structural diffing\n * (`computeSchemaDiff`) to ensure that semantically-equivalent objects with\n * differently-ordered keys produce identical canonical strings.\n */\n\nimport { createDataKeyedBag } from \"../utils/object\";\n\n/**\n * `JSON.stringify` replacer that sorts object keys recursively.\n *\n * Apply via `JSON.stringify(value, sortedReplacer)` to obtain output in\n * which sibling keys at every depth appear in lexicographic order.\n *\n * Arrays are passed through unchanged — array order is semantically\n * meaningful and must not be normalized.\n *\n * The re-keyed object is null-prototype ({@link createDataKeyedBag}): every key\n * here is DATA — a kind name, a property name, a JSON-Schema keyword — and\n * `sorted[\"__proto__\"] = value` on a `{}` literal reaches the prototype setter\n * instead of creating an entry. The key would then be missing from the\n * canonical string, so a schema declaring such a property would hash and\n * compare equal to one that does not: `computeSchemaHash` would report\n * \"unchanged\" and `computeSchemaDiff` would find no change to migrate. Output\n * is byte-identical for every value without such a key, so no existing\n * schema's hash moves.\n */\nexport function sortedReplacer(_key: string, value: unknown): unknown {\n  if (value !== null && typeof value === \"object\" && !Array.isArray(value)) {\n    const sorted = createDataKeyedBag<unknown>();\n    for (const key of Object.keys(value).toSorted()) {\n      sorted[key] = (value as Record<string, unknown>)[key];\n    }\n    return sorted;\n  }\n  return value;\n}\n\n/**\n * Compare two values for canonical-form equality.\n *\n * Returns `true` when both values produce identical JSON under `sortedReplacer`\n * — i.e., they have the same JSON structure regardless of object key order.\n * Used by diff machinery to detect semantic changes in JSON-shaped fields.\n *\n * Note: callers must handle `undefined` themselves — `JSON.stringify(undefined)`\n * returns `undefined`, so two `undefined` inputs would compare equal here, which\n * may or may not be the desired semantics depending on context.\n */\nexport function canonicalEqual(a: unknown, b: unknown): boolean {\n  return (\n    JSON.stringify(a, sortedReplacer) === JSON.stringify(b, sortedReplacer)\n  );\n}\n","/**\n * Splits `items` into consecutive chunks of at most `size` elements.\n *\n * An empty input yields no chunks (`[]`), and an input that already fits in a\n * single chunk is returned without copying. Callers rely on the empty-input\n * behavior to skip work entirely rather than issue a statement with an empty\n * `IN ()` list.\n */\nexport function chunk<T>(\n  items: readonly T[],\n  size: number,\n): readonly (readonly T[])[] {\n  // A non-positive, non-finite, or fractional size would make the slice loop\n  // fail to advance correctly; fail loud rather than spin or emit empty chunks.\n  // All current callers derive size from a positive integer bind-parameter\n  // budget, so this only guards against a future regression.\n  if (!Number.isSafeInteger(size) || size < 1) {\n    throw new RangeError(`chunk size must be a positive integer, got: ${size}`);\n  }\n  if (items.length === 0) return [];\n  if (items.length <= size) return [items];\n  const chunks: T[][] = [];\n  for (let start = 0; start < items.length; start += size) {\n    chunks.push(items.slice(start, start + size));\n  }\n  return chunks;\n}\n\n/**\n * Groups items by a caller-supplied key while preserving input order within\n * each group.\n */\nexport function groupBy<T, K>(\n  items: Iterable<T>,\n  keyFor: (item: T) => K,\n): Map<K, T[]> {\n  const groups = new Map<K, T[]>();\n  for (const item of items) {\n    const key = keyFor(item);\n    const group = groups.get(key) ?? [];\n    group.push(item);\n    groups.set(key, group);\n  }\n  return groups;\n}\n","/**\n * The canonical graph-write lock namespace shared by backend SQL fusion and\n * recorded-capture's portable lock statement.\n *\n * This namespace occupies one fixed position in the global lock order. A\n * second spelling would create a disjoint exclusion set, not an optimization.\n */\nexport const RECORDED_GRAPH_WRITE_ADVISORY_LOCK_NAMESPACE =\n  \"typegraph:recorded-graph-write\";\n","/**\n * The one classification of a schema-managed write's fitness for a\n * `\"batch\"` engine (Cloudflare D1's `batch()`, Neon HTTP's\n * `transaction(queries)`) — a backend whose `capabilities.execution.unitOfWork`\n * is `\"batch\"` fixes every statement before the first one runs and commits\n * them together with no interactive session in between.\n *\n * A leaf module so both halves of the write path can reach it without a\n * cycle: `store/operations/write-transaction.ts` re-exports it beside\n * `constraintFenceRefusal`, and `store/recorded-capture/guards.ts` (which\n * `write-transaction.ts` itself imports through the `recorded-capture`\n * barrel) imports it directly instead of reaching back through that barrel.\n */\nimport { type BackendCapabilities } from \"../types\";\n\n/**\n * What a schema-managed write needs that a closed batch program cannot\n * supply. Each reason names the one thing, of the five kinds this module's\n * callers already refuse, that requires a session instead.\n */\nexport type BatchWriteRefusalReason =\n  | \"interactive-callback\"\n  | \"constraint-needs-probe\"\n  | \"identity\"\n  | \"history\"\n  | \"schema-commit\";\n\n/**\n * Either an atomic program or a fused statement carries the write\n * (`program`), or it needs something a closed batch cannot supply, named by\n * `reason` with the `explanation` every enforcing gate embeds.\n */\nexport type BatchWriteVerdict =\n  | Readonly<{ kind: \"program\" }>\n  | Readonly<{\n      kind: \"refused\";\n      code: \"BATCH_WRITE_UNSUPPORTED\";\n      reason: BatchWriteRefusalReason;\n      explanation: string;\n    }>;\n\n/**\n * The one canonical explanation per {@link BatchWriteRefusalReason}, so the\n * enforcing gates (the constrained-write probe, `store.transaction`,\n * Operational Identity, recorded-time capture, and a schema commit) describe\n * the same limitation in the same words instead of independently-worded\n * sentences.\n */\nconst BATCH_WRITE_REFUSAL_EXPLANATIONS: Readonly<\n  Record<BatchWriteRefusalReason, string>\n> = {\n  \"interactive-callback\":\n    \"hold an interactive callback transaction open across several round trips\",\n  \"constraint-needs-probe\":\n    \"read a value it wrote earlier in the same write before deciding what to write next\",\n  identity:\n    \"read and write Operational Identity's closure across several round trips inside one held transaction\",\n  history:\n    \"hold the per-graph write lock and clock open across a whole write cascade\",\n  \"schema-commit\":\n    \"hold one transaction across its compare-and-swap read and its activating write\",\n};\n\n/**\n * Classifies a schema-managed write's fitness for the backend's declared\n * `unitOfWork`, for a caller that has ALREADY decided — from its own\n * existing predicate (identity enabled, history enabled, a probe-needing\n * constraint, an interactive `store.transaction` call, a schema commit) —\n * that `write.needs` names what this write requires. This function does\n * not re-derive that classification; it only decides whether the backend's\n * declared tier is the reason the need goes unmet, so that a backend which\n * is non-transactional AND has no atomic batch either — a custom\n * `GraphBackend` with neither primitive — keeps its own plain wording\n * (`kind: \"program\"` here, meaning \"not a batch-tier limitation\") instead\n * of being misdescribed as a batch-engine limitation it does not have.\n *\n * `needs` is required: a caller with no proven need has nothing to classify\n * and must not call this function at all, rather than pass an absent value\n * through it and silently receive the same \"not a batch limitation\" answer.\n */\nexport function resolveBatchWriteVerdict(\n  backend: Readonly<{ capabilities: Pick<BackendCapabilities, \"execution\"> }>,\n  write: Readonly<{ needs: BatchWriteRefusalReason }>,\n): BatchWriteVerdict {\n  if (backend.capabilities.execution.unitOfWork !== \"batch\") {\n    return { kind: \"program\" };\n  }\n  return {\n    kind: \"refused\",\n    code: \"BATCH_WRITE_UNSUPPORTED\",\n    reason: write.needs,\n    explanation: BATCH_WRITE_REFUSAL_EXPLANATIONS[write.needs],\n  };\n}\n\n/**\n * The one composed sentence fragment every enforcing gate appends to its own\n * base message — empty when `verdict.kind` is `\"program\"`, so a gate can\n * always write `baseSentence + batchRefusalSuffix(verdict)` with no\n * conditional of its own.\n */\nexport function batchRefusalSuffix(verdict: BatchWriteVerdict): string {\n  return verdict.kind === \"refused\" ?\n      ` Specifically, this needs to ${verdict.explanation}, which a closed batch program cannot do.`\n    : \"\";\n}\n\n/**\n * The one `details` fragment every enforcing gate spreads into its error's\n * `details` object, nested under `batchRefusal` so it never collides with a\n * gate's own `code` (`SCHEMA_WRITE_FENCE_UNSUPPORTED`,\n * `CONSTRAINT_WRITE_FENCE_UNSUPPORTED`, `IDENTITY_REQUIRES_ATOMIC_BACKEND`,\n * …) — empty when `verdict.kind` is `\"program\"`.\n */\nexport function batchRefusalDetails(\n  verdict: BatchWriteVerdict,\n): Readonly<Record<string, unknown>> {\n  return verdict.kind === \"refused\" ?\n      { batchRefusal: { code: verdict.code, reason: verdict.reason } }\n    : {};\n}\n","/** The shared no-op statement that acquires SQLite's transaction writer slot. */\nimport { sql, type SqlFragment } from \"../query/sql-fragment\";\nimport {\n  asCompiledStatementSql,\n  type CompiledStatementSql,\n} from \"../query/sql-intent\";\n\n/** No graph row changes; its UPDATE still reserves the connection's slot. */\nexport function engineSerializedWriterSlotStatement(\n  nodesTable: SqlFragment,\n): CompiledStatementSql {\n  return asCompiledStatementSql(\n    sql`UPDATE ${nodesTable} SET graph_id = graph_id WHERE 0`,\n  );\n}\n"]}