{"version":3,"sources":["../src/indexes/types.ts","../src/query/dialect/aggregate-filter.ts","../src/query/dialect/numeric-conversion.ts","../src/query/dialect/postgres.ts","../src/query/dialect/sqlite.ts","../src/query/dialect/index.ts","../src/indexes/node-key-contract.ts"],"names":["sql","parseJsonPointer","inlineSqlStringLiteral","assertPortableScalarValueType","packSqlListValue","likeEscapeClause","getSqlDialectProfile","tsvectorStrategy","fts5Strategy"],"mappings":"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","file":"chunk-DOADEZA6.cjs","sourcesContent":["import { type z } from \"zod\";\n\nimport {\n  type AnyEdgeType,\n  type NodeType,\n  type NullCheckOp,\n} from \"../core/types\";\nimport { type ValueType } from \"../query/ast\";\nimport {\n  type JsonPointer,\n  type JsonPointerFor,\n  type JsonPointerSegmentsFor,\n} from \"../query/json-pointer\";\n\n// ============================================================\n// Scoping\n// ============================================================\n\nexport type IndexScope =\n  /**\n   * Prefix index keys with `(graph_id, kind)` (nodes) or `(graph_id, kind)` (edges).\n   *\n   * This matches TypeGraph queries which always filter on `graph_id` and `kind`\n   * (often as `IN (...)` due to ontology expansion).\n   */\n  | \"graphAndKind\"\n  /**\n   * Prefix index keys with `graph_id` only.\n   */\n  | \"graph\"\n  /**\n   * Do not prefix index keys with TypeGraph system columns.\n   */\n  | \"none\";\n\n// ============================================================\n// Index Access Method\n// ============================================================\n\n/**\n * Index access method for relational (node/edge) index declarations.\n *\n * - `\"btree\"` — the default ordered index over the compiled extraction\n *   expressions; serves equality/range predicates and `orderBy`.\n * - `\"gin\"` — a PostgreSQL expression GIN over the field's jsonb value\n *   (`jsonb_path_ops`); serves the array containment predicates\n *   (`contains` / `containsAll` / `containsAny` on array fields), which a\n *   btree can never serve. Skipped on SQLite.\n * - `\"trigram\"` — a PostgreSQL expression GIN over the field's text value\n *   (`gin_trgm_ops`, requires the `pg_trgm` extension); serves substring\n *   and case-insensitive matches (`contains` / `startsWith` / `endsWith` /\n *   `like` / `ilike` on string fields). Skipped on SQLite, whose substring\n *   search story is FTS5 fulltext.\n *\n * `\"gin\"` and `\"trigram\"` take exactly one field and reject `unique`,\n * `coveringFields`, and `where`; `scope` (and edge `direction`) prefix\n * columns do not apply — the query's `graph_id` / `kind` equality filters\n * are applied as residual conditions over the index's candidate rows.\n */\nexport type RelationalIndexMethod = \"btree\" | \"gin\" | \"trigram\";\n\n// ============================================================\n// Partial Index WHERE DSL (portable AST)\n// ============================================================\n\nexport type IndexWhereOp =\n  \"eq\" | \"neq\" | \"gt\" | \"gte\" | \"lt\" | \"lte\" | \"in\" | \"notIn\";\n\nexport type IndexWhereExpression =\n  | Readonly<{\n      __type: \"index_where_and\";\n      predicates: readonly IndexWhereExpression[];\n    }>\n  | Readonly<{\n      __type: \"index_where_or\";\n      predicates: readonly IndexWhereExpression[];\n    }>\n  | Readonly<{\n      __type: \"index_where_not\";\n      predicate: IndexWhereExpression;\n    }>\n  | Readonly<{\n      __type: \"index_where_comparison\";\n      left: IndexWhereOperand;\n      op: IndexWhereOp;\n      right: IndexWhereLiteral | readonly IndexWhereLiteral[];\n    }>\n  | Readonly<{\n      __type: \"index_where_null_check\";\n      operand: IndexWhereOperand;\n      op: NullCheckOp;\n    }>;\n\nexport type IndexWhereOperand =\n  | Readonly<{\n      __type: \"index_operand_system\";\n      column: SystemColumnName;\n      valueType: ValueType | undefined;\n    }>\n  | Readonly<{\n      __type: \"index_operand_prop\";\n      field: string;\n      valueType: ValueType | undefined;\n    }>;\n\nexport type IndexWhereLiteral = Readonly<{\n  __type: \"index_where_literal\";\n  value: string | number | boolean;\n  valueType: ValueType;\n}>;\n\ntype IndexWhereComparableValue<T> =\n  NonNullable<T> extends string ? string\n  : NonNullable<T> extends number ? number\n  : NonNullable<T> extends boolean ? boolean\n  : NonNullable<T> extends Date ? Date | string\n  : never;\n\nexport type IndexWhereFieldBuilder<T> = Readonly<{\n  eq: (value: IndexWhereComparableValue<T>) => IndexWhereExpression;\n  neq: (value: IndexWhereComparableValue<T>) => IndexWhereExpression;\n  gt: (value: IndexWhereComparableValue<T>) => IndexWhereExpression;\n  gte: (value: IndexWhereComparableValue<T>) => IndexWhereExpression;\n  lt: (value: IndexWhereComparableValue<T>) => IndexWhereExpression;\n  lte: (value: IndexWhereComparableValue<T>) => IndexWhereExpression;\n  in: (values: readonly IndexWhereComparableValue<T>[]) => IndexWhereExpression;\n  notIn: (\n    values: readonly IndexWhereComparableValue<T>[],\n  ) => IndexWhereExpression;\n  isNull: () => IndexWhereExpression;\n  isNotNull: () => IndexWhereExpression;\n}>;\n\nexport type NodeIndexWhereBuilder<N extends NodeType> = Readonly<\n  {\n    graphId: IndexWhereFieldBuilder<string>;\n    kind: IndexWhereFieldBuilder<string>;\n    id: IndexWhereFieldBuilder<string>;\n    deletedAt: IndexWhereFieldBuilder<string | undefined>;\n    validFrom: IndexWhereFieldBuilder<string | undefined>;\n    validTo: IndexWhereFieldBuilder<string | undefined>;\n    createdAt: IndexWhereFieldBuilder<string>;\n    updatedAt: IndexWhereFieldBuilder<string>;\n    version: IndexWhereFieldBuilder<number>;\n  } & {\n    [K in keyof z.infer<N[\"schema\"]>]-?: IndexWhereFieldBuilder<\n      z.infer<N[\"schema\"]>[K]\n    >;\n  }\n>;\n\nexport type EdgeIndexWhereBuilder<E extends AnyEdgeType> = Readonly<\n  {\n    graphId: IndexWhereFieldBuilder<string>;\n    kind: IndexWhereFieldBuilder<string>;\n    id: IndexWhereFieldBuilder<string>;\n    fromKind: IndexWhereFieldBuilder<string>;\n    fromId: IndexWhereFieldBuilder<string>;\n    toKind: IndexWhereFieldBuilder<string>;\n    toId: IndexWhereFieldBuilder<string>;\n    deletedAt: IndexWhereFieldBuilder<string | undefined>;\n    validFrom: IndexWhereFieldBuilder<string | undefined>;\n    validTo: IndexWhereFieldBuilder<string | undefined>;\n    createdAt: IndexWhereFieldBuilder<string>;\n    updatedAt: IndexWhereFieldBuilder<string>;\n  } & {\n    [K in keyof z.infer<E[\"schema\"]>]-?: IndexWhereFieldBuilder<\n      z.infer<E[\"schema\"]>[K]\n    >;\n  }\n>;\n\nexport type IndexWhereInput<Builder> =\n  IndexWhereExpression | ((where: Builder) => IndexWhereExpression);\n\n// ============================================================\n// Index Definitions\n// ============================================================\n\ntype NonEmptyJsonPointerFor<T> = Exclude<JsonPointerFor<T>, \"\">;\n\ntype NonEmptyJsonPointerSegmentsFor<T> = Exclude<\n  JsonPointerSegmentsFor<T>,\n  readonly []\n>;\n\nexport type IndexFieldInput<T> =\n  | (keyof T & string)\n  | NonEmptyJsonPointerFor<T>\n  | NonEmptyJsonPointerSegmentsFor<T>\n  | JsonPointer;\n\n/** Node system columns accepted by {@link NodeIndexKeyInput}. */\nexport const NODE_SYSTEM_COLUMN_NAMES = [\n  \"graph_id\",\n  \"kind\",\n  \"id\",\n  \"deleted_at\",\n  \"valid_from\",\n  \"valid_to\",\n  \"created_at\",\n  \"updated_at\",\n  \"version\",\n] as const;\n\nexport const NODE_INDEX_KEY_DIRECTIONS = [\"asc\", \"desc\"] as const;\n\nexport type NodeSystemColumnName = (typeof NODE_SYSTEM_COLUMN_NAMES)[number];\n\nexport type NodeIndexKeyInput<T> =\n  | Readonly<{\n      field: IndexFieldInput<T>;\n      system?: never;\n      direction: \"asc\" | \"desc\";\n    }>\n  | Readonly<{\n      field?: never;\n      system: NodeSystemColumnName;\n      direction: \"asc\" | \"desc\";\n    }>;\n\nexport type NodeIndexConfig<N extends NodeType> = Readonly<{\n  coveringFields?: readonly IndexFieldInput<z.infer<N[\"schema\"]>>[] | undefined;\n  name?: string | undefined;\n  scope?: IndexScope | undefined;\n  where?: IndexWhereInput<NodeIndexWhereBuilder<N>> | undefined;\n}> &\n  (\n    | Readonly<{\n        /** Ordered B-tree keys. */\n        keys: readonly [\n          NodeIndexKeyInput<z.infer<N[\"schema\"]>>,\n          ...NodeIndexKeyInput<z.infer<N[\"schema\"]>>[],\n        ];\n        fields?: never;\n        keySystemColumns?: never;\n        unique?: false | undefined;\n        method?: \"btree\" | undefined;\n      }>\n    | Readonly<{\n        keys?: never;\n        /**\n         * Prop-based key fields. May be empty (or omitted) only if\n         * `coveringFields` or `keySystemColumns` supplies at least one key\n         * column instead.\n         */\n        fields?: readonly IndexFieldInput<z.infer<N[\"schema\"]>>[] | undefined;\n        /**\n         * System columns to include after the scope prefix and before\n         * `fields`/`coveringFields`. Node indexes reject edge-only endpoint\n         * columns and columns already implied by `scope`.\n         */\n        keySystemColumns?: readonly SystemColumnName[] | undefined;\n        unique?: boolean | undefined;\n        /** Index access method. Default: `\"btree\"`. */\n        method?: RelationalIndexMethod | undefined;\n      }>\n  );\n\nexport type EdgeIndexDirection = \"out\" | \"in\" | \"none\";\n\nexport type EdgeIndexConfig<E extends AnyEdgeType> = Readonly<{\n  fields: readonly [\n    IndexFieldInput<z.infer<E[\"schema\"]>>,\n    ...IndexFieldInput<z.infer<E[\"schema\"]>>[],\n  ];\n  coveringFields?: readonly IndexFieldInput<z.infer<E[\"schema\"]>>[] | undefined;\n  unique?: boolean | undefined;\n  name?: string | undefined;\n  scope?: IndexScope | undefined;\n  /**\n   * Optional direction hint to prefix edge indexes with the join key that\n   * TypeGraph traversal queries use (`from_id` for out, `to_id` for in).\n   */\n  direction?: EdgeIndexDirection | undefined;\n  where?: IndexWhereInput<EdgeIndexWhereBuilder<E>> | undefined;\n  /** Index access method. Default: `\"btree\"`. See {@link RelationalIndexMethod}. */\n  method?: RelationalIndexMethod | undefined;\n}>;\n\n// ============================================================\n// Index Origin\n// ============================================================\n\n/**\n * Where an index declaration originated.\n *\n * - `compile-time`: declared via `defineNodeIndex` / `defineEdgeIndex` and\n *   threaded through `defineGraph({ indexes })`. This is the default and is\n *   omitted from the canonical schema document so legacy graphs hash\n *   byte-identically.\n * - `runtime`: produced by a graph extension. Always emitted explicitly\n *   so the loader can re-route the declaration through the extension\n *   compiler on restart.\n */\nexport type IndexOrigin = \"compile-time\" | \"runtime\";\n\n// ============================================================\n// Serializable Index Declaration\n// ============================================================\n\n/**\n * Common shape shared by node and edge index declarations.\n *\n * `IndexDeclaration` is the canonical, JSON-serializable representation of\n * an index that flows through `GraphDef.indexes` and\n * `SerializedSchema.indexes`. It carries everything the DDL compiler and\n * the Drizzle schema factories need to generate index SQL — the same\n * value can come from a typed builder (`defineNodeIndex` /\n * `defineEdgeIndex`) or be reconstructed from a graph extension on\n * restart.\n */\nexport type IndexDeclarationBase = Readonly<{\n  /** Unique index name (used in DDL and as the diffing identity key). */\n  name: string;\n  /**\n   * Where this declaration originated.\n   *\n   * `undefined` is the canonical representation of `\"compile-time\"` —\n   * the default origin is omitted from the serialized form so legacy\n   * graphs (no `indexes` slice) hash byte-identically with new graphs\n   * that declare only compile-time indexes.\n   */\n  origin?: IndexOrigin;\n  fields: readonly JsonPointer[];\n  fieldValueTypes: readonly (ValueType | undefined)[];\n  coveringFields: readonly JsonPointer[];\n  coveringFieldValueTypes: readonly (ValueType | undefined)[];\n  unique: boolean;\n  scope: IndexScope;\n  where: IndexWhereExpression | undefined;\n  /**\n   * Index access method. Absent means `\"btree\"` — canonicalized by\n   * absence (like `origin`) so serialized declarations and\n   * materialization signatures from before this field existed stay\n   * byte-identical.\n   */\n  method?: Exclude<RelationalIndexMethod, \"btree\">;\n}>;\n\nexport type NodeIndexDeclaration = IndexDeclarationBase &\n  Readonly<{\n    entity: \"node\";\n    kind: string;\n    /**\n     * System columns included in the index key (see\n     * {@link NodeIndexConfig.keySystemColumns}). Absent means none —\n     * canonicalized by absence like `origin`/`method` so declarations\n     * that don't use this stay byte-identical to before it existed.\n     */\n    keySystemColumns?: readonly SystemColumnName[];\n    /** Ordered B-tree keys; absent for legacy field-key declarations. */\n    keys?: readonly (\n      | Readonly<{\n          type: \"field\";\n          pointer: JsonPointer;\n          valueType: ValueType | undefined;\n          direction: \"asc\" | \"desc\";\n        }>\n      | Readonly<{\n          type: \"system\";\n          column:\n            | \"graph_id\"\n            | \"kind\"\n            | \"id\"\n            | \"deleted_at\"\n            | \"valid_from\"\n            | \"valid_to\"\n            | \"created_at\"\n            | \"updated_at\"\n            | \"version\";\n          direction: \"asc\" | \"desc\";\n        }>\n    )[];\n  }>;\n\nexport type NodeIndexKey = NonNullable<NodeIndexDeclaration[\"keys\"]>[number];\n\nexport type EdgeIndexDeclaration = IndexDeclarationBase &\n  Readonly<{\n    entity: \"edge\";\n    kind: string;\n    direction: EdgeIndexDirection;\n  }>;\n\n/**\n * Distance metric for vector similarity. Mirrors `EmbeddingMetric` from\n * `core/embedding.ts` (re-exported here as part of the index surface).\n */\nexport type VectorIndexMetric = \"cosine\" | \"l2\" | \"inner_product\";\n\n/**\n * Vector index implementation. `none` is a declarative opt-out: the\n * declaration carries shape metadata for tooling but `materializeIndexes`\n * skips the DDL.\n */\nexport type VectorIndexImplementation = \"hnsw\" | \"ivfflat\" | \"none\";\n\n/**\n * Vector-index parameters. Concrete defaults are applied at the\n * `embedding(...)` brand boundary; this carries them onto the\n * declaration so the materializer / signature / drift detection have\n * everything they need without re-resolving from the brand.\n */\nexport type VectorIndexParams = Readonly<{\n  /** HNSW: max connections per layer. */\n  m: number;\n  /** HNSW: build-time search depth. */\n  efConstruction: number;\n  /** IVFFlat: number of inverted lists. `undefined` when not IVFFlat. */\n  lists: number | undefined;\n}>;\n\n/**\n * Vector index declaration. Auto-derived from `embedding()` brands at\n * `defineGraph()` time and explicitly buildable via `defineVectorIndex`.\n *\n * Identity key is `(kind, fieldPath)` — v1 allows at most one vector\n * index per (kind, field) pair. The `name` field is generated\n * deterministically from this tuple plus the metric so consumers don't\n * accidentally collide vector index names with relational indexes.\n *\n * `unique` / `scope` / `where` from the relational base are NOT\n * supported on vector — pgvector / sqlite-vec don't implement them.\n */\nexport type VectorIndexDeclaration = Readonly<{\n  entity: \"vector\";\n  /** Index name (also the physical identity key in the materialization status table). */\n  name: string;\n  origin?: IndexOrigin;\n  /** Node kind the embedding lives on. */\n  kind: string;\n  /** JSON-pointer-style field path for the embedding inside the node's props. */\n  fieldPath: string;\n  /** Embedding dimensionality. */\n  dimensions: number;\n  /** Distance metric. */\n  metric: VectorIndexMetric;\n  /** Index implementation. */\n  indexType: VectorIndexImplementation;\n  /** Concrete index parameters. */\n  indexParams: VectorIndexParams;\n}>;\n\n/**\n * Relational subset of `IndexDeclaration` — the variants that emit\n * `CREATE INDEX` DDL via `generateIndexDDL`. Used to narrow input\n * types in the relational DDL / serializer / migration code paths\n * that don't apply to vector indexes (which use a different\n * materialization primitive on the backend).\n */\nexport type RelationalIndexDeclaration =\n  NodeIndexDeclaration | EdgeIndexDeclaration;\n\n/**\n * A serializable index declaration that flows through `GraphDef.indexes`\n * and `SerializedSchema.indexes`.\n *\n * Discriminated by `entity`. Everything is JSON round-trippable so a\n * declaration produced by `defineNodeIndex` and a declaration\n * reconstructed from a stored schema document compile to byte-identical\n * SQL.\n */\nexport type IndexDeclaration =\n  RelationalIndexDeclaration | VectorIndexDeclaration;\n\n// ============================================================\n// System Columns\n// ============================================================\n\nexport type SystemColumnName =\n  | \"graph_id\"\n  | \"kind\"\n  | \"id\"\n  | \"from_kind\"\n  | \"from_id\"\n  | \"to_kind\"\n  | \"to_id\"\n  | \"deleted_at\"\n  | \"valid_from\"\n  | \"valid_to\"\n  | \"created_at\"\n  | \"updated_at\"\n  | \"version\";\n","import { sql, type SqlFragment } from \"../sql-fragment\";\n\n/** Applies the portable SQL aggregate filter contract when a filter is present. */\nexport function applyAggregateFilter(\n  aggregate: SqlFragment,\n  filter: SqlFragment | undefined,\n): SqlFragment {\n  return filter === undefined ? aggregate : (\n      sql`${aggregate} FILTER (WHERE ${filter})`\n    );\n}\n","/** Exact round-to-nearest overflow boundary for IEEE-754 binary64. */\nexport const DOUBLE_OVERFLOW_BOUNDARY = String(2n ** 1024n - 2n ** 970n);\n\n/** Exact integer value of the largest finite IEEE-754 binary64. */\nexport const MAXIMUM_FINITE_DOUBLE_INTEGER = String(2n ** 1024n - 2n ** 971n);\n\n/** Shortest decimal text that round-trips to the largest finite binary64. */\nexport const MAXIMUM_FINITE_DOUBLE_TEXT = \"1.7976931348623157e308\";\n","/**\n * PostgreSQL Dialect Adapter\n *\n * Implements dialect-specific SQL generation for PostgreSQL databases.\n * Uses PostgreSQL's native JSONB operators for JSON operations.\n */\nimport {\n  assertPortableScalarValueType,\n  type PortableCountDistinctValueType,\n} from \"../aggregate-value-types\";\nimport { type ValueType } from \"../ast\";\nimport { type JsonPointer, parseJsonPointer } from \"../json-pointer\";\nimport { sql, type SqlFragment } from \"../sql-fragment\";\nimport { applyAggregateFilter } from \"./aggregate-filter\";\nimport { tsvectorStrategy } from \"./fulltext-strategy\";\nimport { likeEscapeClause } from \"./like-escape\";\nimport { DOUBLE_OVERFLOW_BOUNDARY } from \"./numeric-conversion\";\nimport {\n  getSqlDialectProfile,\n  inlineSqlStringLiteral,\n  packSqlListValue,\n} from \"./profile\";\nimport { type DialectAdapter } from \"./types\";\n\nconst SCALAR_SQL_TYPES: Readonly<\n  Record<PortableCountDistinctValueType, string>\n> = {\n  boolean: \"boolean\",\n  date: \"timestamptz\",\n  number: \"numeric\",\n  string: \"text\",\n};\n\n/** Gives expression membership a concrete PostgreSQL JSON scalar type. */\nfunction postgresJsonScalar(\n  value: SqlFragment,\n  valueType: ValueType,\n): SqlFragment {\n  switch (valueType) {\n    case \"boolean\": {\n      return sql`CAST(${value} AS boolean)`;\n    }\n    case \"date\": {\n      // Date arrays are serialized with Date#toJSON(), whose UTC millisecond\n      // form differs from PostgreSQL's ordinary timestamptz text rendering.\n      return sql`to_char(CAST(${value} AS timestamptz) AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.MS\"Z\"')`;\n    }\n    case \"number\": {\n      return sql`CAST(${value} AS numeric)`;\n    }\n    case \"string\": {\n      return sql`CAST(${value} AS text)`;\n    }\n    case \"array\":\n    case \"embedding\":\n    case \"object\":\n    case \"unknown\": {\n      throw new Error(\n        `JSON array expression membership requires a scalar element type, got ${valueType}`,\n      );\n    }\n  }\n}\n\nfunction buildTextJsonArray(values: readonly SqlFragment[]): SqlFragment {\n  return sql`jsonb_build_array(${sql.join(\n    values.map((value) => sql`CAST(${value} AS text)`),\n    sql`, `,\n  )})`;\n}\n\n// Exact round-to-nearest boundaries for IEEE-754 binary64. Keeping these as\n// decimal NUMERIC literals lets PostgreSQL decide whether a text value can be\n// converted before a DOUBLE PRECISION cast has a chance to throw.\nconst DOUBLE_ZERO_ROUNDING_BOUNDARY = `${5n ** 1075n}e-1075`;\n\n/**\n * Escapes a string for use in a PostgreSQL string literal, independent of\n * server configuration.\n *\n * A plain `'…'` literal is only safe when the value contains no backslash:\n * under the legacy `standard_conforming_strings = off` setting, backslashes\n * act as escape characters inside regular literals, so a value ending in\n * `\\` could swallow the closing quote and change how the statement parses.\n * Values containing a backslash therefore use the `E'…'` form — where\n * backslash is an escape character under BOTH settings — with backslashes\n * and quotes doubled. Backslash-free values keep the plain form so the\n * emitted SQL text (which callers rely on being identical across clauses)\n * is unchanged for the common case.\n */\n/**\n * Converts a JSON pointer to PostgreSQL's text array path.\n *\n * Uses raw SQL (non-parameterized) to ensure the same expression text\n * is generated when the same field is used in multiple clauses (SELECT, GROUP BY).\n * Pointers usually come from schema definitions, but some (e.g. a weighted\n * traversal's `weightProperty`) are runtime strings — safe either way\n * because the shared PostgreSQL literal renderer escapes independently of server\n * configuration.\n *\n * @example\n * \"/name\" → ARRAY['name']\n * \"/items/0\" → ARRAY['items', '0']\n * \"/a/b/c\" → ARRAY['a', 'b', 'c']\n */\nfunction toPostgresPath(pointer: JsonPointer): SqlFragment {\n  if (!pointer || pointer === \"\" || pointer === \"/\") {\n    return sql.raw(\"ARRAY[]::text[]\");\n  }\n\n  const segments = parseJsonPointer(pointer);\n  if (segments.length === 0) {\n    return sql.raw(\"ARRAY[]::text[]\");\n  }\n\n  // Use raw SQL for path segments to ensure identical SQL text\n  // when the same field is used in multiple clauses (e.g., SELECT and GROUP BY)\n  const escapedSegments = segments\n    .map((segment) => inlineSqlStringLiteral(segment, \"postgres\"))\n    .join(\", \");\n  return sql.raw(`ARRAY[${escapedSegments}]`);\n}\n\n/**\n * The cast that turns a text element of a list-valued `IN` parameter into the\n * type its left operand was extracted as. Mirrors the `jsonExtract*` casts:\n * `jsonExtractNumber` yields numeric, `jsonExtractBoolean` boolean,\n * `jsonExtractDate` timestamptz, and everything else stays text.\n */\nfunction postgresElementCast(elementType: ValueType | undefined): SqlFragment {\n  switch (elementType) {\n    case \"number\": {\n      return sql.raw(\"::numeric\");\n    }\n    case \"boolean\": {\n      return sql.raw(\"::boolean\");\n    }\n    case \"date\": {\n      return sql.raw(\"::timestamptz\");\n    }\n    // `jsonExtractText` leaves these as text, so the elements must stay text\n    // too. The compiler rejects array/object/embedding before reaching here.\n    case \"string\":\n    case \"array\":\n    case \"object\":\n    case \"embedding\":\n    case \"unknown\":\n    case undefined: {\n      return sql.empty();\n    }\n  }\n}\n\n/**\n * PostgreSQL dialect adapter implementation.\n */\nexport const postgresDialect: DialectAdapter = {\n  safeNumericConversion(expression) {\n    const trimmed = sql`btrim(${expression}, ${\" \\t\\r\\n\"})`;\n    const exact = sql`CAST(${trimmed} AS NUMERIC)`;\n    const converted = sql`CAST(${trimmed} AS DOUBLE PRECISION)`;\n    const signedZero = sql`CASE WHEN left(${trimmed}, 1) = '-' THEN CAST('-0' AS DOUBLE PRECISION) ELSE CAST('0' AS DOUBLE PRECISION) END`;\n    return sql`CASE WHEN length(${trimmed}) <= 400 AND ${trimmed} ~ '^-?(?:0|[1-9][0-9]*)(?:\\\\.[0-9]+)?(?:[eE][+-]?[0-9]{1,3})?$' THEN CASE WHEN abs(${exact}) >= ${sql.raw(DOUBLE_OVERFLOW_BOUNDARY)}::numeric THEN NULL WHEN abs(${exact}) <= ${sql.raw(DOUBLE_ZERO_ROUNDING_BOUNDARY)}::numeric THEN ${signedZero} ELSE ${converted} END ELSE NULL END`;\n  },\n  name: \"postgres\",\n  capabilities: {\n    standardQueryStrategy: \"cte_project\",\n    recursiveQueryStrategy: \"recursive_cte\",\n    materializeIntermediateTraversalCtes: false,\n    emitNotMaterializedHint: true,\n    forceRecursiveWorktableOuterJoinOrder: false,\n    vectorPredicateStrategy: \"native\",\n    vectorMetrics: [\"cosine\", \"l2\", \"inner_product\"] as const,\n    supportsFulltext: true,\n    subgraphMembershipStrategy: \"materialized-ids\",\n  },\n\n  binaryText(expression) {\n    return sql`${expression} COLLATE \"C\"`;\n  },\n\n  analyzeTemporaryTable(table) {\n    return sql`ANALYZE ${table}`;\n  },\n\n  setTransactionWorkingMemory(workingMemory) {\n    // The parameterizable form of `SET LOCAL work_mem`: is_local => true\n    // scopes the override to the current transaction, matching the pgvector\n    // iterative-scan GUC handling elsewhere in the backend.\n    return sql`SELECT set_config('work_mem', ${workingMemory}, true)`;\n  },\n\n  orderedRowsJsonArray(rowAlias, _columns, orderColumn) {\n    const row = sql.identifier(rowAlias);\n    const order = sql`${row}.${sql.identifier(orderColumn)}`;\n    return sql`(SELECT COALESCE(jsonb_agg(to_jsonb(${row}) - ${orderColumn} ORDER BY ${order}), '[]'::jsonb) FROM ${row})`;\n  },\n\n  orderedScalarJsonArray({ filter, orderBy, value, valueType }) {\n    assertPortableScalarValueType(valueType, \"COLLECT\");\n    // Bind-only operands have no SQL context from which PostgreSQL can infer a type.\n    const typedValue = sql`CAST(${value} AS ${sql.raw(SCALAR_SQL_TYPES[valueType])})`;\n    const aggregate = sql`jsonb_agg(to_jsonb(${typedValue}) ORDER BY ${sql.join(orderBy, sql`, `)})`;\n    const filteredAggregate = applyAggregateFilter(aggregate, filter);\n    return sql`COALESCE(${filteredAggregate}, '[]'::jsonb)`;\n  },\n\n  orderedRecordJsonArray({ fields, filter, orderBy }) {\n    const parts = Array.from(\n      { length: Math.ceil(fields.length / 40) },\n      (_, index) => {\n        const chunk = fields.slice(index * 40, (index + 1) * 40);\n        const pairs = chunk.flatMap((field) => {\n          assertPortableScalarValueType(\n            field.valueType,\n            \"COLLECT record field\",\n          );\n          return [\n            sql`CAST(${field.name} AS text)`,\n            sql`CAST(${field.value} AS ${sql.raw(SCALAR_SQL_TYPES[field.valueType])})`,\n          ];\n        });\n        return sql`jsonb_build_object(${sql.join(pairs, sql`, `)})`;\n      },\n    );\n    const record = sql.join(parts, sql` || `);\n    const aggregate = sql`jsonb_agg(${record} ORDER BY ${sql.join(orderBy, sql`, `)})`;\n    return sql`COALESCE(${applyAggregateFilter(aggregate, filter)}, '[]'::jsonb)`;\n  },\n\n  // ============================================================\n  // JSON Path Operations\n  // ============================================================\n\n  compilePath(pointer) {\n    return toPostgresPath(pointer);\n  },\n\n  jsonExtract(column, pointer) {\n    // #> returns JSONB value at path\n    const path = toPostgresPath(pointer);\n    return sql`${column} #> ${path}`;\n  },\n\n  jsonExtractText(column, pointer) {\n    // #>> returns text value at path\n    const path = toPostgresPath(pointer);\n    return sql`${column} #>> ${path}`;\n  },\n\n  jsonExtractNumber(column, pointer) {\n    // Extract as text then cast to numeric\n    const path = toPostgresPath(pointer);\n    return sql`(${column} #>> ${path})::numeric`;\n  },\n\n  jsonExtractDouble(column, pointer) {\n    // float8, not ::numeric — decimal arithmetic would diverge from\n    // SQLite's binary doubles when values accumulate.\n    const path = toPostgresPath(pointer);\n    return sql`(${column} #>> ${path})::double precision`;\n  },\n\n  jsonExtractBoolean(column, pointer) {\n    // Extract as text then cast to boolean\n    const path = toPostgresPath(pointer);\n    return sql`(${column} #>> ${path})::boolean`;\n  },\n\n  jsonExtractDate(column, pointer) {\n    // Extract as text then cast to timestamptz\n    const path = toPostgresPath(pointer);\n    return sql`(${column} #>> ${path})::timestamptz`;\n  },\n\n  // ============================================================\n  // JSON Array Operations\n  // ============================================================\n\n  jsonArrayLength(column) {\n    return sql`jsonb_array_length(${column})`;\n  },\n\n  jsonArrayContains(column, value) {\n    // @> checks if left contains right\n    const jsonValue = JSON.stringify([value]);\n    return sql`${column} @> ${jsonValue}::jsonb`;\n  },\n\n  jsonArrayContainsExpression(column, value, valueType) {\n    const scalar = postgresJsonScalar(value, valueType);\n    return sql`CASE WHEN jsonb_typeof(${column}) = 'array' THEN EXISTS (SELECT 1 FROM jsonb_array_elements(${column}) AS tg_element(value) WHERE tg_element.value = to_jsonb(${scalar})) ELSE FALSE END`;\n  },\n\n  rowValueComparison(operator, left, right) {\n    return sql`(${sql.join(left, sql`, `)}) ${sql.raw(operator)} (${sql.join(right, sql`, `)})`;\n  },\n\n  jsonArrayContainsAll(column, values) {\n    if (values.length === 0) {\n      return sql.raw(\"1=1\");\n    }\n\n    // @> with full array checks all values\n    const jsonValue = JSON.stringify(values);\n    return sql`${column} @> ${jsonValue}::jsonb`;\n  },\n\n  jsonArrayContainsAny(column, values) {\n    if (values.length === 0) {\n      return sql.raw(\"1=0\");\n    }\n\n    // Check each value with @> and OR them together\n    // PostgreSQL doesn't have a native \"overlaps\" for jsonb arrays\n    const conditions = values.map((value) => {\n      const jsonValue = JSON.stringify([value]);\n      return sql`${column} @> ${jsonValue}::jsonb`;\n    });\n    return sql`(${sql.join(conditions, sql` OR `)})`;\n  },\n\n  // ============================================================\n  // JSON Object Operations\n  // ============================================================\n\n  jsonHasPath(column, pointer) {\n    const path = toPostgresPath(pointer);\n    return sql`${column} #> ${path} IS NOT NULL`;\n  },\n\n  jsonPathIsNull(column, pointer) {\n    const path = toPostgresPath(pointer);\n    // Type-based, not the `#>> path = 'null'` text comparison this used to\n    // be: `#>>` renders a JSON null as SQL NULL (making the old form\n    // three-valued, so `.pathIsNull()` silently missed stored JSON nulls) and\n    // renders the JSON *string* \"null\" as the same text 'null' (falsely\n    // matching it). jsonb_typeof distinguishes both, and COALESCE maps a\n    // missing path to TRUE, keeping the predicate two-valued.\n    return sql`COALESCE(jsonb_typeof(${column} #> ${path}) = 'null', TRUE)`;\n  },\n\n  jsonPathIsNumber(column, pointer) {\n    const path = toPostgresPath(pointer);\n    // jsonb_typeof returns NULL for a missing path; COALESCE keeps the\n    // predicate two-valued so negations don't silently drop rows.\n    return sql`COALESCE(jsonb_typeof(${column} #> ${path}) = 'number', FALSE)`;\n  },\n\n  jsonPathIsNotNull(column, pointer) {\n    const path = toPostgresPath(pointer);\n    // Mirror image of jsonPathIsNull; COALESCE maps a missing path to FALSE.\n    return sql`COALESCE(jsonb_typeof(${column} #> ${path}) <> 'null', FALSE)`;\n  },\n\n  jsonScalarPathEquals(column, pointer, value) {\n    const path = toPostgresPath(pointer);\n    return sql`${column} #> ${path} = CAST(${JSON.stringify(value)} AS jsonb)`;\n  },\n\n  jsonSetProperties(column, patch, unsetProperties = []) {\n    const withReplacements =\n      Object.keys(patch).length === 0 ?\n        column\n      : sql`${column} || ${JSON.stringify(patch)}::jsonb`;\n    if (unsetProperties.length === 0) return withReplacements;\n    const properties = unsetProperties.map((property) => sql`${property}`);\n    return sql`(${withReplacements}) - ARRAY[${sql.join(properties, sql`, `)}]::text[]`;\n  },\n\n  // ============================================================\n  // Comparison Operations\n  // ============================================================\n\n  nullSafeEquals(left, right) {\n    return sql`${left} IS NOT DISTINCT FROM ${right}`;\n  },\n\n  inList(left, values, negated) {\n    const operator = negated ? sql.raw(\"NOT IN\") : sql.raw(\"IN\");\n    const placeholders = values.map((value) => sql`${value}`);\n    return sql`${left} ${operator} (${sql.join(placeholders, sql`, `)})`;\n  },\n\n  inListParameter(left, packedValues, { negated, elementType }) {\n    const operator = negated ? sql.raw(\"NOT IN\") : sql.raw(\"IN\");\n    // One placeholder for the whole list: the binding is JSON text, cast to\n    // jsonb and expanded into a one-column relation, so arity never reaches\n    // the SQL text. Elements arrive as text (`jsonb_array_elements_text`) and\n    // are cast to whatever type the left operand was extracted as, mirroring\n    // the jsonExtract* casts above.\n    const element = sql`in_list_element.value${postgresElementCast(elementType)}`;\n    return sql`${left} ${operator} (SELECT ${element} FROM jsonb_array_elements_text(${packedValues}::jsonb) AS in_list_element(value))`;\n  },\n\n  packListValue(values) {\n    return packSqlListValue(values, \"postgres\");\n  },\n\n  // ============================================================\n  // String Operations\n  // ============================================================\n\n  ilike(column, pattern) {\n    // PostgreSQL has native ILIKE operator. Declaring backslash as the escape\n    // character is a no-op (it is the LIKE default) but keeps the emitted SQL\n    // identical in intent to SQLite, which has no default escape character.\n    return sql`${column} ILIKE ${pattern} ${likeEscapeClause}`;\n  },\n\n  // ============================================================\n  // Set Operations\n  // ============================================================\n\n  wrapSetOperationOperand(inner) {\n    // PostgreSQL allows a complete SELECT (incl. its own WITH) as a\n    // parenthesized compound operand.\n    return sql`(${inner})`;\n  },\n\n  // ============================================================\n  // Recursive CTE Path Operations\n  // ============================================================\n\n  textJsonArray: buildTextJsonArray,\n\n  appendTextJsonArray(array, values) {\n    return sql`(${array} || ${buildTextJsonArray(values)})`;\n  },\n\n  initializePath(nodeId) {\n    // PostgreSQL uses text arrays: ARRAY[id]\n    return sql`ARRAY[${nodeId}]`;\n  },\n\n  extendPath(currentPath, nodeId) {\n    // Array concatenation: path || id\n    return sql`${currentPath} || ${nodeId}`;\n  },\n\n  cycleCheck(nodeId, path) {\n    // Check that id is NOT in array path\n    // Returns TRUE if no cycle (id not in array)\n    return sql`${nodeId} != ALL(${path})`;\n  },\n\n  // ============================================================\n  // Value Binding & Literals\n  // ============================================================\n\n  bindValue(value) {\n    return getSqlDialectProfile(\"postgres\").bindValue(value);\n  },\n\n  unboundedLimit() {\n    return sql.raw(\"ALL\");\n  },\n\n  booleanLiteral(value) {\n    return sql.raw(\n      getSqlDialectProfile(\"postgres\").booleanLiteralString(value),\n    );\n  },\n\n  booleanLiteralString(value) {\n    return getSqlDialectProfile(\"postgres\").booleanLiteralString(value);\n  },\n\n  quoteIdentifier(name) {\n    // PostgreSQL uses double quotes, escape embedded quotes by doubling\n    return `\"${name.replaceAll('\"', '\"\"')}\"`;\n  },\n\n  // ============================================================\n  // Vector Operations\n  // ============================================================\n\n  // Compile-time gate for `field.similarTo(...)`; the active\n  // `VectorStrategy` (pgvector) owns the distance SQL.\n  supportsVectors: true,\n\n  // ============================================================\n  // Fulltext Operations\n  // ============================================================\n\n  fulltext: tsvectorStrategy,\n};\n","/**\n * SQLite Dialect Adapter\n *\n * Implements dialect-specific SQL generation for SQLite databases.\n * Uses SQLite's JSON1 extension for JSON operations.\n */\nimport { type JsonPointer, parseJsonPointer } from \"../json-pointer\";\nimport { sql, type SqlFragment } from \"../sql-fragment\";\nimport { applyAggregateFilter } from \"./aggregate-filter\";\nimport { fts5Strategy } from \"./fulltext-strategy\";\nimport { likeEscapeClause } from \"./like-escape\";\nimport {\n  DOUBLE_OVERFLOW_BOUNDARY,\n  MAXIMUM_FINITE_DOUBLE_INTEGER,\n  MAXIMUM_FINITE_DOUBLE_TEXT,\n} from \"./numeric-conversion\";\nimport { getSqlDialectProfile, packSqlListValue } from \"./profile\";\nimport { type DialectAdapter } from \"./types\";\n\n/**\n * Escapes a string for use in a SQLite string literal.\n * SQLite uses single quotes and escapes embedded single quotes by doubling them.\n */\nfunction escapeSqliteLiteral(value: string): string {\n  return `'${value.replaceAll(\"'\", \"''\")}'`;\n}\n\n/**\n * Converts a JSON pointer to SQLite's JSON path syntax.\n *\n * @example\n * \"/name\" → \"$.\\\"name\\\"\"\n * \"/items/0\" → \"$.\\\"items\\\"[0]\"\n * \"/a/b/c\" → \"$.\\\"a\\\".\\\"b\\\".\\\"c\\\"\"\n */\nfunction toSqlitePath(pointer: JsonPointer): string {\n  if (!pointer || pointer === \"\" || pointer === \"/\") {\n    return \"$\";\n  }\n\n  const segments = parseJsonPointer(pointer);\n  const parts: string[] = [\"$\"];\n\n  for (const segment of segments) {\n    if (isArrayIndex(segment)) {\n      parts.push(`[${segment}]`);\n    } else {\n      // Quote the key to handle special characters\n      parts.push(`.${JSON.stringify(segment)}`);\n    }\n  }\n\n  return parts.join(\"\");\n}\n\n/**\n * Returns a JSON path for an object property, even when the property name is a\n * numeric string. `toSqlitePath()` interprets numeric pointer segments as\n * array indexes, which is correct for query pointers but not for the\n * top-level object keys accepted by set-based patches.\n */\nfunction toSqliteObjectPropertyPath(property: string): string {\n  return `$.${JSON.stringify(property)}`;\n}\n\n// SQLite builds before 3.48 default to 127 function arguments. Each json_set\n// replacement consumes a path/value pair in addition to the input document, so\n// compose bounded calls instead of making schema breadth an engine-version\n// dependency.\nconst JSON_SET_REPLACEMENTS_PER_CALL = 50;\nconst JSON_OBJECT_PAIRS_PER_CALL = 40;\n\nfunction mergeJsonObjects(parts: readonly SqlFragment[]): SqlFragment {\n  const [first, ...rest] = parts;\n  if (first === undefined) return sql`json('{}')`;\n  if (rest.length === 0) return first;\n  return sql`json_patch(${first}, ${mergeJsonObjects(rest)})`;\n}\n\n/**\n * Checks if a JSON pointer segment is an array index.\n */\nfunction isArrayIndex(segment: string): boolean {\n  return /^\\d+$/.test(segment);\n}\n\n/**\n * SQLite dialect adapter implementation.\n */\nexport const sqliteDialect: DialectAdapter = {\n  safeNumericConversion(expression) {\n    const trimmed = sql`trim(${expression})`;\n    const wrapped = sql`'[' || ${trimmed} || ']'`;\n    const exponentPosition = sql`instr(lower(${trimmed}), 'e')`;\n    const exponent = sql`substr(${trimmed}, ${exponentPosition} + 1)`;\n    const exponentDigits = sql`CASE WHEN substr(${exponent}, 1, 1) IN ('+', '-') THEN substr(${exponent}, 2) ELSE ${exponent} END`;\n    const converted = sql`CAST(${trimmed} AS REAL)`;\n    // Linux libSQL can parse decimal text between the exact maximum and the\n    // binary64 overflow boundary as Infinity even though round-to-nearest must\n    // produce Number.MAX_VALUE. Classify that narrow interval from the decimal\n    // text so the fallback does not depend on another floating-point parse.\n    const unsigned = sql`CASE WHEN substr(${trimmed}, 1, 1) = '-' THEN substr(${trimmed}, 2) ELSE ${trimmed} END`;\n    const unsignedExponentPosition = sql`instr(lower(${unsigned}), 'e')`;\n    const mantissa = sql`CASE WHEN ${unsignedExponentPosition} = 0 THEN ${unsigned} ELSE substr(${unsigned}, 1, ${unsignedExponentPosition} - 1) END`;\n    const explicitExponent = sql`CASE WHEN ${unsignedExponentPosition} = 0 THEN 0 ELSE CAST(substr(${unsigned}, ${unsignedExponentPosition} + 1) AS INTEGER) END`;\n    const decimalPosition = sql`instr(${mantissa}, '.')`;\n    const integerDigits = sql`CASE WHEN ${decimalPosition} = 0 THEN length(${mantissa}) ELSE ${decimalPosition} - 1 END`;\n    const digits = sql`replace(${mantissa}, '.', '')`;\n    const significantDigits = sql`ltrim(${digits}, '0')`;\n    const magnitudeExponent = sql`${explicitExponent} + ${integerDigits} - 1 - (length(${digits}) - length(${significantDigits}))`;\n    const boundaryDigits = sql`substr(${significantDigits} || printf('%0309d', 0), 1, 309)`;\n    const belowOverflowBoundary = sql`${significantDigits} = '' OR ${magnitudeExponent} < 308 OR (${magnitudeExponent} = 308 AND ${boundaryDigits} < ${DOUBLE_OVERFLOW_BOUNDARY})`;\n    const roundsToMaximum = sql`${magnitudeExponent} = 308 AND ${boundaryDigits} >= ${MAXIMUM_FINITE_DOUBLE_INTEGER} AND ${boundaryDigits} < ${DOUBLE_OVERFLOW_BOUNDARY}`;\n    const maximumFinite = sql`CAST(${MAXIMUM_FINITE_DOUBLE_TEXT} AS REAL)`;\n    const signedMaximum = sql`CASE WHEN substr(${trimmed}, 1, 1) = '-' THEN -${maximumFinite} ELSE ${maximumFinite} END`;\n    const finiteConversion = sql`CASE WHEN NOT (${belowOverflowBoundary}) THEN NULL WHEN abs(${converted}) <= ${maximumFinite} THEN ${converted} WHEN ${roundsToMaximum} THEN ${signedMaximum} ELSE NULL END`;\n    return sql`CASE WHEN length(${trimmed}) <= 400 AND json_valid(${wrapped}) THEN CASE WHEN json_array_length(${wrapped}) = 1 AND json_type(${wrapped}, '$[0]') IN ('integer', 'real') AND (${exponentPosition} = 0 OR length(${exponentDigits}) BETWEEN 1 AND 3) THEN ${finiteConversion} ELSE NULL END ELSE NULL END`;\n  },\n  name: \"sqlite\",\n  capabilities: {\n    standardQueryStrategy: \"cte_project\",\n    recursiveQueryStrategy: \"recursive_cte\",\n    materializeIntermediateTraversalCtes: true,\n    emitNotMaterializedHint: false,\n    forceRecursiveWorktableOuterJoinOrder: true,\n    vectorPredicateStrategy: \"native\",\n    vectorMetrics: [\"cosine\", \"l2\"] as const,\n    supportsFulltext: true,\n    subgraphMembershipStrategy: \"inline-cte\",\n  },\n\n  binaryText(expression) {\n    return expression;\n  },\n\n  analyzeTemporaryTable(): undefined {\n    return;\n  },\n\n  setTransactionWorkingMemory(): undefined {\n    // SQLite has no per-transaction working-memory budget to raise.\n    return;\n  },\n\n  orderedRowsJsonArray(rowAlias, columns, orderColumn) {\n    const row = sql.identifier(rowAlias);\n    const objectParts = Array.from(\n      { length: Math.ceil(columns.length / JSON_OBJECT_PAIRS_PER_CALL) },\n      (_, index) => {\n        const slice = columns.slice(\n          index * JSON_OBJECT_PAIRS_PER_CALL,\n          (index + 1) * JSON_OBJECT_PAIRS_PER_CALL,\n        );\n        const pairs = slice.flatMap((column) => [\n          sql`${column}`,\n          sql`${row}.${sql.identifier(column)}`,\n        ]);\n        return sql`json_object(${sql.join(pairs, sql`, `)})`;\n      },\n    );\n    const object = mergeJsonObjects(objectParts);\n    return sql`COALESCE((SELECT json_group_array(json(batch_json)) FROM (SELECT ${object} AS batch_json FROM ${row} ORDER BY ${row}.${sql.identifier(orderColumn)})), json('[]'))`;\n  },\n\n  orderedScalarJsonArray({ filter, orderBy, value, valueType }) {\n    void valueType;\n    const aggregate = sql`json_group_array(${value} ORDER BY ${sql.join(orderBy, sql`, `)})`;\n    const filteredAggregate = applyAggregateFilter(aggregate, filter);\n    return sql`COALESCE(${filteredAggregate}, json('[]'))`;\n  },\n\n  orderedRecordJsonArray({ fields, filter, orderBy }) {\n    // json_patch treats null fields as deletion. Splice bounded JSON objects\n    // by removing only their outer braces; bound names remain JSON-escaped.\n    const chunks: SqlFragment[] = [];\n    for (\n      let index = 0;\n      index < fields.length;\n      index += JSON_OBJECT_PAIRS_PER_CALL\n    ) {\n      const chunk = fields.slice(index, index + JSON_OBJECT_PAIRS_PER_CALL);\n      const pairs = chunk.flatMap((field) => [sql`${field.name}`, field.value]);\n      const object = sql`json_object(${sql.join(pairs, sql`, `)})`;\n      chunks.push(sql`substr(${object}, 2, length(${object}) - 2)`);\n    }\n    const record = sql`json('{' || ${sql.join(chunks, sql` || ',' || `)} || '}')`;\n    // SQLite versions before 3.45 lose the JSON subtype through aggregate\n    // ORDER BY, so json_group_array would quote each record as a string.\n    const aggregate = sql`group_concat(${record} ORDER BY ${sql.join(orderBy, sql`, `)})`;\n    return sql`json('[' || COALESCE(${applyAggregateFilter(aggregate, filter)}, '') || ']')`;\n  },\n\n  // ============================================================\n  // JSON Path Operations\n  // ============================================================\n\n  compilePath(pointer) {\n    // Use raw SQL to ensure the path is a literal, which allows expression\n    // indexes on json_extract(...) to be used by the query planner.\n    return sql.raw(escapeSqliteLiteral(toSqlitePath(pointer)));\n  },\n\n  jsonExtract(column, pointer) {\n    const path = toSqlitePath(pointer);\n    return sql`json_extract(${column}, ${sql.raw(escapeSqliteLiteral(path))})`;\n  },\n\n  jsonExtractText(column, pointer) {\n    // SQLite's json_extract returns the native JSON type, which works\n    // for text comparisons. For explicit text, we use the same function.\n    const path = toSqlitePath(pointer);\n    return sql`json_extract(${column}, ${sql.raw(escapeSqliteLiteral(path))})`;\n  },\n\n  jsonExtractNumber(column, pointer) {\n    // SQLite json_extract returns numbers natively when the value is numeric\n    const path = toSqlitePath(pointer);\n    return sql`json_extract(${column}, ${sql.raw(escapeSqliteLiteral(path))})`;\n  },\n\n  jsonExtractDouble(column, pointer) {\n    // json_extract already yields INTEGER/REAL affinity for JSON numbers,\n    // and SQLite arithmetic on those values is IEEE 754 double.\n    const path = toSqlitePath(pointer);\n    return sql`json_extract(${column}, ${sql.raw(escapeSqliteLiteral(path))})`;\n  },\n\n  jsonExtractBoolean(column, pointer) {\n    // SQLite json_extract returns 0/1 for boolean values\n    const path = toSqlitePath(pointer);\n    return sql`json_extract(${column}, ${sql.raw(escapeSqliteLiteral(path))})`;\n  },\n\n  jsonExtractDate(column, pointer) {\n    // SQLite stores dates as ISO strings, json_extract returns them as text\n    const path = toSqlitePath(pointer);\n    return sql`json_extract(${column}, ${sql.raw(escapeSqliteLiteral(path))})`;\n  },\n\n  // ============================================================\n  // JSON Array Operations\n  // ============================================================\n\n  jsonArrayLength(column) {\n    return sql`json_array_length(${column})`;\n  },\n\n  jsonArrayContains(column, value) {\n    return sql`EXISTS (SELECT 1 FROM json_each(${column}) WHERE json_each.value = ${value})`;\n  },\n\n  jsonArrayContainsExpression(column, value) {\n    return sql`CASE WHEN json_valid(${column}) THEN CASE WHEN json_type(${column}) = 'array' THEN EXISTS (SELECT 1 FROM json_each(${column}) WHERE json_each.value = ${value}) ELSE FALSE END ELSE FALSE END`;\n  },\n\n  rowValueComparison(operator, left, right) {\n    return sql`(${sql.join(left, sql`, `)}) ${sql.raw(operator)} (${sql.join(right, sql`, `)})`;\n  },\n\n  jsonArrayContainsAll(column, values) {\n    if (values.length === 0) {\n      return sql.raw(\"1=1\");\n    }\n    const packedValues = JSON.stringify(values);\n    return sql`\n      NOT EXISTS (\n            SELECT 1 FROM json_each(${packedValues}) AS tg_required\n            WHERE NOT EXISTS (\n              SELECT 1 FROM json_each(${column}) AS tg_actual\n              WHERE tg_actual.value = tg_required.value\n            )\n          )\n    `;\n  },\n\n  jsonArrayContainsAny(column, values) {\n    if (values.length === 0) {\n      return sql.raw(\"1=0\");\n    }\n    const packedValues = JSON.stringify(values);\n    return sql`\n      EXISTS (\n            SELECT 1\n            FROM json_each(${column}) AS tg_actual\n            JOIN json_each(${packedValues}) AS tg_wanted\n              ON tg_actual.value = tg_wanted.value\n          )\n    `;\n  },\n\n  // ============================================================\n  // JSON Object Operations\n  // ============================================================\n\n  jsonHasPath(column, pointer) {\n    const path = toSqlitePath(pointer);\n    return sql`json_type(${column}, ${sql.raw(escapeSqliteLiteral(path))}) IS NOT NULL`;\n  },\n\n  jsonPathIsNull(column, pointer) {\n    const path = toSqlitePath(pointer);\n    const pathSql = sql.raw(escapeSqliteLiteral(path));\n    return sql`COALESCE(json_type(${column}, ${pathSql}) = 'null', 1)`;\n  },\n\n  jsonPathIsNumber(column, pointer) {\n    const path = toSqlitePath(pointer);\n    const pathSql = sql.raw(escapeSqliteLiteral(path));\n    // json_type returns NULL for a missing path; COALESCE keeps the\n    // predicate two-valued so negations don't silently drop rows.\n    return sql`COALESCE(json_type(${column}, ${pathSql}) IN ('integer', 'real'), 0)`;\n  },\n\n  jsonPathIsNotNull(column, pointer) {\n    const path = toSqlitePath(pointer);\n    const pathSql = sql.raw(escapeSqliteLiteral(path));\n    return sql`COALESCE(json_type(${column}, ${pathSql}) <> 'null', 0)`;\n  },\n\n  jsonScalarPathEquals(column, pointer, value) {\n    const path = toSqlitePath(pointer);\n    const pathSql = sql.raw(escapeSqliteLiteral(path));\n    if (value === null) {\n      return sql`json_type(${column}, ${pathSql}) = 'null'`;\n    }\n    if (typeof value === \"boolean\") {\n      return sql`json_type(${column}, ${pathSql}) IN ('true', 'false') AND json_extract(${column}, ${pathSql}) = ${value ? 1 : 0}`;\n    }\n    if (typeof value === \"number\") {\n      return sql`json_type(${column}, ${pathSql}) IN ('integer', 'real') AND json_extract(${column}, ${pathSql}) = ${value}`;\n    }\n    return sql`json_type(${column}, ${pathSql}) = 'text' AND json_extract(${column}, ${pathSql}) = ${value}`;\n  },\n\n  jsonSetProperties(column, patch, unsetProperties = []) {\n    const entries = Object.entries(patch);\n    let patchedColumn = column;\n    for (\n      let offset = 0;\n      offset < entries.length;\n      offset += JSON_SET_REPLACEMENTS_PER_CALL\n    ) {\n      const replacements = entries\n        .slice(offset, offset + JSON_SET_REPLACEMENTS_PER_CALL)\n        .flatMap(([property, value]) => [\n          sql.raw(escapeSqliteLiteral(toSqliteObjectPropertyPath(property))),\n          sql`json(${JSON.stringify(value)})`,\n        ]);\n      patchedColumn = sql`json_set(${patchedColumn}, ${sql.join(replacements, sql`, `)})`;\n    }\n    if (unsetProperties.length === 0) return patchedColumn;\n    const removalPaths = unsetProperties.map((property) =>\n      sql.raw(escapeSqliteLiteral(toSqliteObjectPropertyPath(property))),\n    );\n    return sql`json_remove(${patchedColumn}, ${sql.join(removalPaths, sql`, `)})`;\n  },\n\n  // ============================================================\n  // Comparison Operations\n  // ============================================================\n\n  nullSafeEquals(left, right) {\n    // SQLite's IS operator is null-safe equality (equivalent to = for\n    // non-null operands, TRUE when both sides are NULL).\n    return sql`${left} IS ${right}`;\n  },\n\n  inList(left, values, negated) {\n    const operator = negated ? sql.raw(\"NOT IN\") : sql.raw(\"IN\");\n    const packedValues = JSON.stringify(values);\n    return sql`${left} ${operator} (SELECT value FROM json_each(${packedValues}))`;\n  },\n\n  inListParameter(left, packedValues, { negated }) {\n    const operator = negated ? sql.raw(\"NOT IN\") : sql.raw(\"IN\");\n    // Same packed shape as the literal `inList` above, with the JSON text\n    // supplied by the caller's binding instead of baked in. SQLite's dynamic\n    // typing makes `json_each.value` compare correctly against every extracted\n    // column type, so the element type needs no cast here.\n    return sql`${left} ${operator} (SELECT value FROM json_each(${packedValues}))`;\n  },\n\n  packListValue(values) {\n    return packSqlListValue(values, \"sqlite\");\n  },\n\n  // ============================================================\n  // String Operations\n  // ============================================================\n\n  ilike(column, pattern) {\n    // SQLite LIKE is case-insensitive for ASCII by default, but we use\n    // LOWER() for consistency with non-ASCII characters. SQLite has no default\n    // LIKE escape character, so declare backslash explicitly to honor the\n    // escaping the compiler applies to the pattern (parity with Postgres).\n    return sql`LOWER(${column}) LIKE LOWER(${pattern}) ${likeEscapeClause}`;\n  },\n\n  // ============================================================\n  // Set Operations\n  // ============================================================\n\n  wrapSetOperationOperand(inner) {\n    // SQLite forbids parenthesized compound operands, but a FROM-subquery may\n    // carry its own WITH clause, so wrap each operand as a subquery.\n    return sql`SELECT * FROM (${inner})`;\n  },\n\n  // ============================================================\n  // Recursive CTE Path Operations\n  // ============================================================\n\n  textJsonArray(values) {\n    return sql`json_array(${sql.join(values, sql`, `)})`;\n  },\n\n  appendTextJsonArray(array, values) {\n    const arguments_ = values.flatMap((value) => [sql`'$[#]'`, value]);\n    return sql`json_insert(${array}, ${sql.join(arguments_, sql`, `)})`;\n  },\n\n  initializePath(nodeId) {\n    // SQLite uses string-based paths with delimiters: '|id|'\n    return sql`'|' || ${nodeId} || '|'`;\n  },\n\n  extendPath(currentPath, nodeId) {\n    // Append: path || id || '|'\n    return sql`${currentPath} || ${nodeId} || '|'`;\n  },\n\n  cycleCheck(nodeId, path) {\n    // Check that id is NOT in path using INSTR\n    // Returns TRUE if no cycle (id not found in path)\n    return sql`INSTR(${path}, '|' || ${nodeId} || '|') = 0`;\n  },\n\n  // ============================================================\n  // Value Binding & Literals\n  // ============================================================\n\n  bindValue(value) {\n    return getSqlDialectProfile(\"sqlite\").bindValue(value);\n  },\n\n  unboundedLimit() {\n    return sql.raw(\"-1\");\n  },\n\n  booleanLiteral(value) {\n    return sql.raw(getSqlDialectProfile(\"sqlite\").booleanLiteralString(value));\n  },\n\n  booleanLiteralString(value) {\n    return getSqlDialectProfile(\"sqlite\").booleanLiteralString(value);\n  },\n\n  quoteIdentifier(name) {\n    // SQLite uses double quotes (or backticks), escape embedded quotes by doubling\n    return `\"${name.replaceAll('\"', '\"\"')}\"`;\n  },\n\n  // ============================================================\n  // Vector Operations\n  // ============================================================\n\n  // Compile-time gate for `field.similarTo(...)`; the active\n  // `VectorStrategy` (sqlite-vec / libSQL-native) owns the distance SQL.\n  supportsVectors: true,\n\n  // ============================================================\n  // Fulltext Operations\n  // ============================================================\n\n  fulltext: fts5Strategy,\n};\n","/**\n * SQL Dialect Module\n *\n * Provides dialect adapters for different SQL databases.\n * Use `getDialect()` to get the appropriate adapter for a dialect name.\n */\n\nexport type { FulltextStrategy } from \"./fulltext-strategy\";\nexport {\n  ALL_FULLTEXT_MODES,\n  buildFulltextCapabilities,\n  fts5Strategy,\n  tsvectorStrategy,\n} from \"./fulltext-strategy\";\nexport { postgresDialect } from \"./postgres\";\nexport { sqliteDialect } from \"./sqlite\";\nexport type {\n  DialectAdapter,\n  DialectCapabilities,\n  DialectRecursiveQueryStrategy,\n  DialectStandardQueryStrategy,\n  DialectSubgraphMembershipStrategy,\n  DialectVectorPredicateStrategy,\n  InListParameterOptions,\n  SqlDialect,\n} from \"./types\";\nexport {\n  buildVectorCapabilities,\n  type VectorSlot,\n  type VectorStrategy,\n} from \"./vector-strategy\";\n\nimport { postgresDialect } from \"./postgres\";\nimport { sqliteDialect } from \"./sqlite\";\nimport { type DialectAdapter, type SqlDialect } from \"./types\";\n\n/**\n * Map of dialect names to their adapters.\n */\nconst DIALECT_ADAPTERS: Record<SqlDialect, DialectAdapter> = {\n  sqlite: sqliteDialect,\n  postgres: postgresDialect,\n};\n\n/**\n * Gets the dialect adapter for a given dialect name.\n *\n * @param dialect - The dialect name (\"sqlite\" or \"postgres\")\n * @returns The dialect adapter\n *\n * @example\n * ```typescript\n * const adapter = getDialect(\"postgres\");\n * const sql = adapter.jsonExtract(column, \"/name\");\n * ```\n */\nexport function getDialect(dialect: SqlDialect): DialectAdapter {\n  return DIALECT_ADAPTERS[dialect];\n}\n\n/**\n * Default dialect used when none is specified.\n */\nexport const DEFAULT_DIALECT: SqlDialect = \"sqlite\";\n","import { type JsonPointer } from \"../query/json-pointer\";\nimport type { NODE_INDEX_KEY_DIRECTIONS } from \"./types\";\nimport {\n  type IndexScope,\n  NODE_SYSTEM_COLUMN_NAMES,\n  type NodeIndexKey,\n  type SystemColumnName,\n} from \"./types\";\n\nexport function parseNodeIndexKeyDirection(\n  value: unknown,\n): (typeof NODE_INDEX_KEY_DIRECTIONS)[number] | undefined {\n  return value === \"asc\" || value === \"desc\" ? value : undefined;\n}\n\nexport function validateEdgeIndexKeysPresence(\n  value: object,\n): string | undefined {\n  return Object.hasOwn(value, \"keys\") ?\n      \"Edge indexes do not support keys\"\n    : undefined;\n}\n\nconst NODE_SYSTEM_COLUMNS: ReadonlySet<SystemColumnName> = new Set(\n  NODE_SYSTEM_COLUMN_NAMES,\n);\n\nexport type NodeIndexKeyContract = Readonly<{\n  keys: readonly NodeIndexKey[];\n  fields: readonly JsonPointer[];\n  coveringFields: readonly JsonPointer[];\n  keySystemColumns: readonly SystemColumnName[] | undefined;\n  unique: boolean;\n  scope: IndexScope;\n  method?: unknown;\n  fieldsDeclared?: boolean;\n}>;\n\nexport function getNodeScopeColumns(\n  scope: IndexScope,\n): readonly SystemColumnName[] {\n  switch (scope) {\n    case \"graphAndKind\": {\n      return [\"graph_id\", \"kind\"];\n    }\n    case \"graph\": {\n      return [\"graph_id\"];\n    }\n    case \"none\": {\n      return [];\n    }\n  }\n}\n\nexport function validateNodeIndexKeyContract(\n  contract: NodeIndexKeyContract,\n): readonly string[] {\n  if (contract.keys.length === 0) return [\"Node index keys must not be empty\"];\n  const errors: string[] = [];\n  if (\n    (contract.fieldsDeclared ?? contract.fields.length > 0) ||\n    contract.keySystemColumns !== undefined\n  ) {\n    errors.push(\n      \"Node index keys are mutually exclusive with fields and keySystemColumns\",\n    );\n  }\n  if (contract.unique)\n    errors.push(\"Node index keys do not support unique indexes\");\n  if (contract.method !== undefined && contract.method !== \"btree\") {\n    errors.push('Node index keys support only method: \"btree\"');\n  }\n  const scopeColumns = new Set(getNodeScopeColumns(contract.scope));\n  const seen = new Set<string>();\n  for (const key of contract.keys) {\n    const identity = key.type === \"field\" ? key.pointer : key.column;\n    const fingerprint = `${key.type}:${identity}`;\n    if (seen.has(fingerprint))\n      errors.push(`Node index keys must not repeat \"${identity}\"`);\n    seen.add(fingerprint);\n    if (key.type === \"system\") {\n      if (!NODE_SYSTEM_COLUMNS.has(key.column)) {\n        errors.push(\n          `Node index keys do not support system column \"${key.column}\"`,\n        );\n      }\n      if (scopeColumns.has(key.column)) {\n        errors.push(\n          `Node index keys must not repeat a column already implied by scope \"${contract.scope}\": \"${key.column}\"`,\n        );\n      }\n    } else if (contract.coveringFields.includes(key.pointer)) {\n      errors.push(\n        `Index keys and coveringFields must not overlap: \"${key.pointer}\"`,\n      );\n    }\n  }\n  return errors;\n}\n"]}