@nicia-ai/typegraph 0.39.0 → 0.40.0

package/dist/chunk-HAQVISUF.cjs

@@ -0,0 +1,1098 @@
+'use strict';
+
+var chunkYX3H63VV_cjs = require('./chunk-YX3H63VV.cjs');
+var chunk764JHTLT_cjs = require('./chunk-764JHTLT.cjs');
+var chunkTDXIBCGY_cjs = require('./chunk-TDXIBCGY.cjs');
+
+// src/backend/table-contribution.ts
+var FULLTEXT_CONTRIBUTION_NAME = "fulltext";
+var BASE_CONTRIBUTION_OWNER = "base";
+
+// src/query/dialect/fulltext-strategy.ts
+var ALL_FULLTEXT_MODES = [
+  "websearch",
+  "phrase",
+  "plain",
+  "raw"
+];
+function buildFulltextCapabilities(strategy) {
+  return {
+    supported: true,
+    languages: strategy.languages,
+    phraseQueries: strategy.supportedModes.includes("phrase"),
+    prefixQueries: strategy.supportsPrefix,
+    highlighting: strategy.supportsSnippets
+  };
+}
+function quoteIdentifier(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+function tsvectorColumn(tableName) {
+  return chunkYX3H63VV_cjs.sql`${chunkYX3H63VV_cjs.sql.identifier(tableName)}."tsv"`;
+}
+function dedupeFulltextBatchRows(rows) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const row of rows) seen.set(row.nodeId, row);
+  return [...seen.values()];
+}
+function buildPkScopedDelete(tableName, params) {
+  const table = chunkYX3H63VV_cjs.sql.identifier(tableName);
+  return chunkYX3H63VV_cjs.sql`
+    DELETE FROM ${table}
+    WHERE "graph_id" = ${params.graphId}
+      AND "node_kind" = ${params.nodeKind}
+      AND "node_id" = ${params.nodeId}
+  `;
+}
+function buildPkScopedBatchDelete(tableName, params) {
+  if (params.nodeIds.length === 0) return void 0;
+  const unique = [...new Set(params.nodeIds)];
+  const table = chunkYX3H63VV_cjs.sql.identifier(tableName);
+  return chunkYX3H63VV_cjs.sql`
+    DELETE FROM ${table}
+    WHERE "graph_id" = ${params.graphId}
+      AND "node_kind" = ${params.nodeKind}
+      AND "node_id" IN (${chunkYX3H63VV_cjs.sql.join(
+    unique.map((id) => chunkYX3H63VV_cjs.sql`${id}`),
+    chunkYX3H63VV_cjs.sql`, `
+  )})
+  `;
+}
+function postgresTsquery(mode, query, language) {
+  const langExpr = language === void 0 ? chunkYX3H63VV_cjs.sql`"language"` : chunkYX3H63VV_cjs.sql`${language}::regconfig`;
+  switch (mode) {
+    case "websearch": {
+      return chunkYX3H63VV_cjs.sql`websearch_to_tsquery(${langExpr}, ${query})`;
+    }
+    case "phrase": {
+      return chunkYX3H63VV_cjs.sql`phraseto_tsquery(${langExpr}, ${query})`;
+    }
+    case "plain": {
+      return chunkYX3H63VV_cjs.sql`plainto_tsquery(${langExpr}, ${query})`;
+    }
+    case "raw": {
+      return chunkYX3H63VV_cjs.sql`to_tsquery(${langExpr}, ${query})`;
+    }
+    default: {
+      const _exhaustive = mode;
+      throw new Error(`Unsupported fulltext mode: ${String(_exhaustive)}`);
+    }
+  }
+}
+var tsvectorStrategy = {
+  name: "tsvector",
+  supportedModes: ALL_FULLTEXT_MODES,
+  supportsSnippets: true,
+  // `raw` mode exposes `foo:*` prefix-match syntax to callers.
+  supportsPrefix: true,
+  supportsLanguageOverride: true,
+  // Canonical Postgres stemmers; every stock install ships these plus a
+  // few others. Runtime `to_tsvector` accepts any installed regconfig
+  // name — this list is advisory for capability discovery.
+  languages: [
+    "simple",
+    "english",
+    "french",
+    "german",
+    "italian",
+    "portuguese",
+    "russian",
+    "spanish",
+    "swedish"
+  ],
+  matchCondition(tableName, query, mode, language) {
+    const q = postgresTsquery(mode, query, language);
+    return chunkYX3H63VV_cjs.sql`${tsvectorColumn(tableName)} @@ ${q}`;
+  },
+  rankExpression(tableName, query, mode, language) {
+    const q = postgresTsquery(mode, query, language);
+    return chunkYX3H63VV_cjs.sql`ts_rank_cd(${tsvectorColumn(tableName)}, ${q})`;
+  },
+  snippetExpression(_tableName, query, mode, language) {
+    const langExpr = language === void 0 ? chunkYX3H63VV_cjs.sql`"language"` : chunkYX3H63VV_cjs.sql`${language}::regconfig`;
+    const q = postgresTsquery(mode, query, language);
+    return chunkYX3H63VV_cjs.sql`ts_headline(${langExpr}, "content", ${q}, 'StartSel=<mark>,StopSel=</mark>,MaxFragments=1,MinWords=5,MaxWords=30,ShortWord=3')`;
+  },
+  ownedTables(primaryTableName) {
+    const name = quoteIdentifier(primaryTableName);
+    const gin = quoteIdentifier(`${primaryTableName}_tsv_idx`);
+    const kind = quoteIdentifier(`${primaryTableName}_kind_idx`);
+    const createDdl = [
+      `CREATE TABLE IF NOT EXISTS ${name} (
+  "graph_id" TEXT NOT NULL,
+  "node_kind" TEXT NOT NULL,
+  "node_id" TEXT NOT NULL,
+  "content" TEXT NOT NULL,
+  "language" regconfig NOT NULL,
+  "tsv" tsvector NOT NULL
+    GENERATED ALWAYS AS (to_tsvector("language", "content")) STORED,
+  "updated_at" TIMESTAMPTZ NOT NULL,
+  PRIMARY KEY ("graph_id", "node_kind", "node_id")
+);`,
+      `CREATE INDEX IF NOT EXISTS ${gin} ON ${name} USING GIN ("tsv");`,
+      `CREATE INDEX IF NOT EXISTS ${kind} ON ${name} ("graph_id", "node_kind");`
+    ];
+    return [
+      {
+        logicalName: FULLTEXT_CONTRIBUTION_NAME,
+        owner: "tsvector",
+        tableName: primaryTableName,
+        createDdl,
+        runtimeEnsure: true
+      }
+    ];
+  },
+  buildUpsert(tableName, params, timestamp) {
+    const table = chunkYX3H63VV_cjs.sql.identifier(tableName);
+    return [
+      chunkYX3H63VV_cjs.sql`
+        INSERT INTO ${table} ("graph_id", "node_kind", "node_id", "content", "language", "updated_at")
+        VALUES (
+          ${params.graphId}, ${params.nodeKind}, ${params.nodeId},
+          ${params.content}, ${params.language}::regconfig,
+          ${timestamp}
+        )
+        ON CONFLICT ("graph_id", "node_kind", "node_id")
+        DO UPDATE SET
+          "content" = EXCLUDED."content",
+          "language" = EXCLUDED."language",
+          "updated_at" = EXCLUDED."updated_at"
+      `
+    ];
+  },
+  buildBatchUpsert(tableName, params, timestamp) {
+    const rows = dedupeFulltextBatchRows(params.rows);
+    if (rows.length === 0) return [];
+    const table = chunkYX3H63VV_cjs.sql.identifier(tableName);
+    const valueTuples = rows.map(
+      (row) => chunkYX3H63VV_cjs.sql`
+        (
+              ${params.graphId}, ${params.nodeKind}, ${row.nodeId},
+              ${row.content}, ${row.language}::regconfig,
+              ${timestamp}
+            )
+      `
+    );
+    return [
+      chunkYX3H63VV_cjs.sql`
+        INSERT INTO ${table} ("graph_id", "node_kind", "node_id", "content", "language", "updated_at")
+        VALUES ${chunkYX3H63VV_cjs.sql.join(valueTuples, chunkYX3H63VV_cjs.sql`, `)}
+        ON CONFLICT ("graph_id", "node_kind", "node_id")
+        DO UPDATE SET
+          "content" = EXCLUDED."content",
+          "language" = EXCLUDED."language",
+          "updated_at" = EXCLUDED."updated_at"
+      `
+    ];
+  },
+  buildDelete(tableName, params) {
+    return [buildPkScopedDelete(tableName, params)];
+  },
+  buildBatchDelete(tableName, params) {
+    const stmt = buildPkScopedBatchDelete(tableName, params);
+    return stmt === void 0 ? [] : [stmt];
+  }
+};
+function translateToFts5Query(query, mode) {
+  switch (mode) {
+    case "phrase": {
+      return `"${query.replaceAll('"', '""')}"`;
+    }
+    case "plain": {
+      return query.trim().split(/\s+/u).filter((token) => token.length > 0).map((token) => `"${token.replaceAll('"', '""')}"`).join(" ");
+    }
+    case "websearch": {
+      return translateWebsearchToFts5(query);
+    }
+    case "raw": {
+      return query;
+    }
+    default: {
+      const _exhaustive = mode;
+      throw new Error(`Unsupported fulltext mode: ${String(_exhaustive)}`);
+    }
+  }
+}
+function translateWebsearchToFts5(query) {
+  const tokens = [];
+  let index = 0;
+  function skipWhitespace() {
+    while (index < query.length && /\s/u.test(query[index] ?? "")) {
+      index += 1;
+    }
+  }
+  function readPhrase() {
+    index += 1;
+    let content = "";
+    while (index < query.length && query[index] !== '"') {
+      content += query[index] ?? "";
+      index += 1;
+    }
+    if (query[index] === '"') index += 1;
+    return `"${content.replaceAll('"', '""')}"`;
+  }
+  function readBareTerm() {
+    let term = "";
+    while (index < query.length && !/\s/u.test(query[index] ?? "")) {
+      term += query[index] ?? "";
+      index += 1;
+    }
+    return term;
+  }
+  while (index < query.length) {
+    skipWhitespace();
+    if (index >= query.length) break;
+    const ch = query[index];
+    if (ch === '"') {
+      tokens.push(readPhrase());
+      continue;
+    }
+    if (ch === "-") {
+      index += 1;
+      const term = query[index] === '"' ? readPhrase() : `"${readBareTerm().replaceAll('"', '""')}"`;
+      tokens.push(`NOT ${term}`);
+      continue;
+    }
+    if (ch === "+") {
+      index += 1;
+      continue;
+    }
+    const bare = readBareTerm();
+    if (bare.length === 0) continue;
+    if (bare.toUpperCase() === "OR") {
+      tokens.push("OR");
+      continue;
+    }
+    tokens.push(`"${bare.replaceAll('"', '""')}"`);
+  }
+  if (tokens.length > 0 && tokens[0]?.startsWith("NOT ")) {
+    tokens.shift();
+  }
+  return tokens.join(" ");
+}
+var fts5Strategy = {
+  name: "fts5",
+  supportedModes: ALL_FULLTEXT_MODES,
+  supportsSnippets: true,
+  // FTS5 supports `foo*` prefix matching natively.
+  supportsPrefix: true,
+  // FTS5 tokenizer is fixed at table-create time; per-row / per-query
+  // language metadata is stored but not consulted.
+  supportsLanguageOverride: false,
+  // The built-in tokenizer is `porter unicode61 remove_diacritics 2`; the
+  // `language` field on searchable() is recorded for future use but not
+  // applied at query time.
+  languages: ["porter", "unicode61", "trigram"],
+  matchCondition(tableName, query, mode, _language) {
+    const matchExpression = translateToFts5Query(query, mode);
+    return chunkYX3H63VV_cjs.sql`${chunkYX3H63VV_cjs.sql.identifier(tableName)} MATCH ${matchExpression}`;
+  },
+  rankExpression(tableName, _query, _mode, _language) {
+    return chunkYX3H63VV_cjs.sql`-bm25(${chunkYX3H63VV_cjs.sql.identifier(tableName)})`;
+  },
+  snippetExpression(tableName, _query, _mode, _language) {
+    return chunkYX3H63VV_cjs.sql`snippet(${chunkYX3H63VV_cjs.sql.identifier(tableName)}, -1, '<mark>', '</mark>', '…', 20)`;
+  },
+  ownedTables(primaryTableName) {
+    const name = quoteIdentifier(primaryTableName);
+    return [
+      {
+        logicalName: FULLTEXT_CONTRIBUTION_NAME,
+        owner: "fts5",
+        tableName: primaryTableName,
+        createDdl: [
+          `CREATE VIRTUAL TABLE IF NOT EXISTS ${name} USING fts5(
+  graph_id UNINDEXED,
+  node_kind UNINDEXED,
+  node_id UNINDEXED,
+  language UNINDEXED,
+  updated_at UNINDEXED,
+  content,
+  tokenize='porter unicode61 remove_diacritics 2'
+);`
+        ],
+        runtimeEnsure: true
+      }
+    ];
+  },
+  buildUpsert(tableName, params, timestamp) {
+    const table = chunkYX3H63VV_cjs.sql.identifier(tableName);
+    return [
+      chunkYX3H63VV_cjs.sql`
+        DELETE FROM ${table}
+        WHERE "graph_id" = ${params.graphId}
+          AND "node_kind" = ${params.nodeKind}
+          AND "node_id" = ${params.nodeId}
+      `,
+      chunkYX3H63VV_cjs.sql`
+        INSERT INTO ${table} (graph_id, node_kind, node_id, content, language, updated_at)
+        VALUES (${params.graphId}, ${params.nodeKind}, ${params.nodeId}, ${params.content}, ${params.language}, ${timestamp})
+      `
+    ];
+  },
+  buildBatchUpsert(tableName, params, timestamp) {
+    const rows = dedupeFulltextBatchRows(params.rows);
+    if (rows.length === 0) return [];
+    const table = chunkYX3H63VV_cjs.sql.identifier(tableName);
+    const nodeIds = rows.map((row) => row.nodeId);
+    const deleteStmt = chunkYX3H63VV_cjs.sql`
+      DELETE FROM ${table}
+      WHERE "graph_id" = ${params.graphId}
+        AND "node_kind" = ${params.nodeKind}
+        AND "node_id" IN (${chunkYX3H63VV_cjs.sql.join(
+      nodeIds.map((id) => chunkYX3H63VV_cjs.sql`${id}`),
+      chunkYX3H63VV_cjs.sql`, `
+    )})
+    `;
+    const valueTuples = rows.map(
+      (row) => chunkYX3H63VV_cjs.sql`
+        (
+              ${params.graphId}, ${params.nodeKind}, ${row.nodeId},
+              ${row.content}, ${row.language}, ${timestamp}
+            )
+      `
+    );
+    const insertStmt = chunkYX3H63VV_cjs.sql`
+      INSERT INTO ${table} (graph_id, node_kind, node_id, content, language, updated_at)
+      VALUES ${chunkYX3H63VV_cjs.sql.join(valueTuples, chunkYX3H63VV_cjs.sql`, `)}
+    `;
+    return [deleteStmt, insertStmt];
+  },
+  buildDelete(tableName, params) {
+    return [buildPkScopedDelete(tableName, params)];
+  },
+  buildBatchDelete(tableName, params) {
+    const stmt = buildPkScopedBatchDelete(tableName, params);
+    return stmt === void 0 ? [] : [stmt];
+  }
+};
+
+// src/query/dialect/vector-strategy.ts
+var VECTOR_CONTRIBUTION_PREFIX = "vector";
+function buildVectorCapabilities(strategy) {
+  return strategy.capabilities;
+}
+function vectorScoreExpression(distanceExpression, metric) {
+  switch (metric) {
+    case "cosine": {
+      return chunkYX3H63VV_cjs.sql`(1 - (${distanceExpression}))`;
+    }
+    case "l2":
+    case "inner_product": {
+      return distanceExpression;
+    }
+    default: {
+      const _exhaustive = metric;
+      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);
+    }
+  }
+}
+function vectorMinScoreCondition(distanceExpression, metric, minScore) {
+  assertVectorMinScore(minScore, metric);
+  switch (metric) {
+    case "cosine": {
+      return chunkYX3H63VV_cjs.sql`${distanceExpression} <= ${1 - minScore}`;
+    }
+    case "l2": {
+      return chunkYX3H63VV_cjs.sql`${distanceExpression} <= ${minScore}`;
+    }
+    case "inner_product": {
+      return chunkYX3H63VV_cjs.sql`${distanceExpression} <= ${-minScore}`;
+    }
+    default: {
+      const _exhaustive = metric;
+      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);
+    }
+  }
+}
+function assertFiniteEmbedding(embedding, name) {
+  for (const [index, value] of embedding.entries()) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      throw new TypeError(
+        `${name}[${index}] must be a finite number, got: ${value}`
+      );
+    }
+  }
+}
+function assertVectorSearchLimit(limit) {
+  if (!Number.isInteger(limit) || limit <= 0) {
+    throw new RangeError(
+      `vectorSearch limit must be a positive integer, got: ${limit}`
+    );
+  }
+}
+function assertVectorMinScore(minScore, metric, label = "minScore") {
+  if (!Number.isFinite(minScore)) {
+    throw new RangeError(`${label} must be a finite number, got: ${minScore}`);
+  }
+  if (metric === "cosine" && Math.abs(minScore) > 1) {
+    throw new RangeError(
+      `${label} for the cosine metric must be between -1 and 1, got: ${minScore}`
+    );
+  }
+}
+var MAX_VECTOR_IDENTIFIER_LENGTH = 63;
+function sanitizeIdentifierPart(value) {
+  return value.toLowerCase().replaceAll(/[^a-z0-9_]/g, "_");
+}
+function shortHash(input) {
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let index = 0; index < input.length; index++) {
+    const ch = chunk764JHTLT_cjs.requireDefined(input.codePointAt(index));
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  const hi = (h2 >>> 0).toString(16).padStart(8, "0");
+  const lo = (h1 >>> 0).toString(16).padStart(8, "0");
+  return `${hi}${lo}`.slice(0, 8);
+}
+function vectorPhysicalName(prefix, graphId, nodeKind, fieldPath) {
+  const readable = `${prefix}_${sanitizeIdentifierPart(graphId)}_${sanitizeIdentifierPart(nodeKind)}_${sanitizeIdentifierPart(fieldPath)}`;
+  const hash = shortHash(JSON.stringify([graphId, nodeKind, fieldPath]));
+  const full = `${readable}_${hash}`;
+  if (full.length <= MAX_VECTOR_IDENTIFIER_LENGTH) return full;
+  return `${readable.slice(0, MAX_VECTOR_IDENTIFIER_LENGTH - 1 - hash.length)}_${hash}`;
+}
+function quoteIdentifier2(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+
+// src/query/dialect/postgres.ts
+function toPostgresPath(pointer) {
+  if (!pointer || pointer === "" || pointer === "/") {
+    return chunkYX3H63VV_cjs.sql.raw("ARRAY[]::text[]");
+  }
+  const segments = chunkTDXIBCGY_cjs.parseJsonPointer(pointer);
+  if (segments.length === 0) {
+    return chunkYX3H63VV_cjs.sql.raw("ARRAY[]::text[]");
+  }
+  const escapedSegments = segments.map((segment) => chunkYX3H63VV_cjs.inlineSqlStringLiteral(segment, "postgres")).join(", ");
+  return chunkYX3H63VV_cjs.sql.raw(`ARRAY[${escapedSegments}]`);
+}
+var postgresDialect = {
+  name: "postgres",
+  capabilities: {
+    standardQueryStrategy: "cte_project",
+    recursiveQueryStrategy: "recursive_cte",
+    materializeIntermediateTraversalCtes: false,
+    emitNotMaterializedHint: true,
+    forceRecursiveWorktableOuterJoinOrder: false,
+    vectorPredicateStrategy: "native",
+    vectorMetrics: ["cosine", "l2", "inner_product"],
+    supportsFulltext: true
+  },
+  binaryText(expression) {
+    return chunkYX3H63VV_cjs.sql`${expression} COLLATE "C"`;
+  },
+  analyzeTemporaryTable(table) {
+    return chunkYX3H63VV_cjs.sql`ANALYZE ${table}`;
+  },
+  setTransactionWorkingMemory(workingMemory) {
+    return chunkYX3H63VV_cjs.sql`SELECT set_config('work_mem', ${workingMemory}, true)`;
+  },
+  // ============================================================
+  // JSON Path Operations
+  // ============================================================
+  compilePath(pointer) {
+    return toPostgresPath(pointer);
+  },
+  jsonExtract(column, pointer) {
+    const path = toPostgresPath(pointer);
+    return chunkYX3H63VV_cjs.sql`${column} #> ${path}`;
+  },
+  jsonExtractText(column, pointer) {
+    const path = toPostgresPath(pointer);
+    return chunkYX3H63VV_cjs.sql`${column} #>> ${path}`;
+  },
+  jsonExtractNumber(column, pointer) {
+    const path = toPostgresPath(pointer);
+    return chunkYX3H63VV_cjs.sql`(${column} #>> ${path})::numeric`;
+  },
+  jsonExtractDouble(column, pointer) {
+    const path = toPostgresPath(pointer);
+    return chunkYX3H63VV_cjs.sql`(${column} #>> ${path})::double precision`;
+  },
+  jsonExtractBoolean(column, pointer) {
+    const path = toPostgresPath(pointer);
+    return chunkYX3H63VV_cjs.sql`(${column} #>> ${path})::boolean`;
+  },
+  jsonExtractDate(column, pointer) {
+    const path = toPostgresPath(pointer);
+    return chunkYX3H63VV_cjs.sql`(${column} #>> ${path})::timestamptz`;
+  },
+  // ============================================================
+  // JSON Array Operations
+  // ============================================================
+  jsonArrayLength(column) {
+    return chunkYX3H63VV_cjs.sql`jsonb_array_length(${column})`;
+  },
+  jsonArrayContains(column, value) {
+    const jsonValue = JSON.stringify([value]);
+    return chunkYX3H63VV_cjs.sql`${column} @> ${jsonValue}::jsonb`;
+  },
+  jsonArrayContainsAll(column, values) {
+    if (values.length === 0) {
+      return chunkYX3H63VV_cjs.sql.raw("1=1");
+    }
+    const jsonValue = JSON.stringify(values);
+    return chunkYX3H63VV_cjs.sql`${column} @> ${jsonValue}::jsonb`;
+  },
+  jsonArrayContainsAny(column, values) {
+    if (values.length === 0) {
+      return chunkYX3H63VV_cjs.sql.raw("1=0");
+    }
+    const conditions = values.map((value) => {
+      const jsonValue = JSON.stringify([value]);
+      return chunkYX3H63VV_cjs.sql`${column} @> ${jsonValue}::jsonb`;
+    });
+    return chunkYX3H63VV_cjs.sql`(${chunkYX3H63VV_cjs.sql.join(conditions, chunkYX3H63VV_cjs.sql` OR `)})`;
+  },
+  // ============================================================
+  // JSON Object Operations
+  // ============================================================
+  jsonHasPath(column, pointer) {
+    const path = toPostgresPath(pointer);
+    return chunkYX3H63VV_cjs.sql`${column} #> ${path} IS NOT NULL`;
+  },
+  jsonPathIsNull(column, pointer) {
+    const path = toPostgresPath(pointer);
+    return chunkYX3H63VV_cjs.sql`COALESCE(jsonb_typeof(${column} #> ${path}) = 'null', TRUE)`;
+  },
+  jsonPathIsNumber(column, pointer) {
+    const path = toPostgresPath(pointer);
+    return chunkYX3H63VV_cjs.sql`COALESCE(jsonb_typeof(${column} #> ${path}) = 'number', FALSE)`;
+  },
+  jsonPathIsNotNull(column, pointer) {
+    const path = toPostgresPath(pointer);
+    return chunkYX3H63VV_cjs.sql`COALESCE(jsonb_typeof(${column} #> ${path}) <> 'null', FALSE)`;
+  },
+  // ============================================================
+  // Comparison Operations
+  // ============================================================
+  nullSafeEquals(left, right) {
+    return chunkYX3H63VV_cjs.sql`${left} IS NOT DISTINCT FROM ${right}`;
+  },
+  inList(left, values, negated) {
+    const operator = negated ? chunkYX3H63VV_cjs.sql.raw("NOT IN") : chunkYX3H63VV_cjs.sql.raw("IN");
+    const placeholders = values.map((value) => chunkYX3H63VV_cjs.sql`${value}`);
+    return chunkYX3H63VV_cjs.sql`${left} ${operator} (${chunkYX3H63VV_cjs.sql.join(placeholders, chunkYX3H63VV_cjs.sql`, `)})`;
+  },
+  // ============================================================
+  // String Operations
+  // ============================================================
+  ilike(column, pattern) {
+    return chunkYX3H63VV_cjs.sql`${column} ILIKE ${pattern} ${chunkYX3H63VV_cjs.likeEscapeClause}`;
+  },
+  // ============================================================
+  // Set Operations
+  // ============================================================
+  wrapSetOperationOperand(inner) {
+    return chunkYX3H63VV_cjs.sql`(${inner})`;
+  },
+  // ============================================================
+  // Recursive CTE Path Operations
+  // ============================================================
+  initializePath(nodeId) {
+    return chunkYX3H63VV_cjs.sql`ARRAY[${nodeId}]`;
+  },
+  extendPath(currentPath, nodeId) {
+    return chunkYX3H63VV_cjs.sql`${currentPath} || ${nodeId}`;
+  },
+  cycleCheck(nodeId, path) {
+    return chunkYX3H63VV_cjs.sql`${nodeId} != ALL(${path})`;
+  },
+  // ============================================================
+  // Value Binding & Literals
+  // ============================================================
+  bindValue(value) {
+    return chunkYX3H63VV_cjs.getSqlDialectProfile("postgres").bindValue(value);
+  },
+  booleanLiteral(value) {
+    return chunkYX3H63VV_cjs.sql.raw(
+      chunkYX3H63VV_cjs.getSqlDialectProfile("postgres").booleanLiteralString(value)
+    );
+  },
+  booleanLiteralString(value) {
+    return chunkYX3H63VV_cjs.getSqlDialectProfile("postgres").booleanLiteralString(value);
+  },
+  quoteIdentifier(name) {
+    return `"${name.replaceAll('"', '""')}"`;
+  },
+  // ============================================================
+  // Vector Operations
+  // ============================================================
+  // Compile-time gate for `field.similarTo(...)`; the active
+  // `VectorStrategy` (pgvector) owns the distance SQL.
+  supportsVectors: true,
+  // ============================================================
+  // Fulltext Operations
+  // ============================================================
+  fulltext: tsvectorStrategy
+};
+
+// src/query/dialect/sqlite.ts
+function escapeSqliteLiteral(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function toSqlitePath(pointer) {
+  if (!pointer || pointer === "" || pointer === "/") {
+    return "$";
+  }
+  const segments = chunkTDXIBCGY_cjs.parseJsonPointer(pointer);
+  const parts = ["$"];
+  for (const segment of segments) {
+    if (isArrayIndex(segment)) {
+      parts.push(`[${segment}]`);
+    } else {
+      parts.push(`.${JSON.stringify(segment)}`);
+    }
+  }
+  return parts.join("");
+}
+function isArrayIndex(segment) {
+  return /^\d+$/.test(segment);
+}
+var sqliteDialect = {
+  name: "sqlite",
+  capabilities: {
+    standardQueryStrategy: "cte_project",
+    recursiveQueryStrategy: "recursive_cte",
+    materializeIntermediateTraversalCtes: true,
+    emitNotMaterializedHint: false,
+    forceRecursiveWorktableOuterJoinOrder: true,
+    vectorPredicateStrategy: "native",
+    vectorMetrics: ["cosine", "l2"],
+    supportsFulltext: true
+  },
+  binaryText(expression) {
+    return expression;
+  },
+  analyzeTemporaryTable() {
+    return;
+  },
+  setTransactionWorkingMemory() {
+    return;
+  },
+  // ============================================================
+  // JSON Path Operations
+  // ============================================================
+  compilePath(pointer) {
+    return chunkYX3H63VV_cjs.sql.raw(escapeSqliteLiteral(toSqlitePath(pointer)));
+  },
+  jsonExtract(column, pointer) {
+    const path = toSqlitePath(pointer);
+    return chunkYX3H63VV_cjs.sql`json_extract(${column}, ${chunkYX3H63VV_cjs.sql.raw(escapeSqliteLiteral(path))})`;
+  },
+  jsonExtractText(column, pointer) {
+    const path = toSqlitePath(pointer);
+    return chunkYX3H63VV_cjs.sql`json_extract(${column}, ${chunkYX3H63VV_cjs.sql.raw(escapeSqliteLiteral(path))})`;
+  },
+  jsonExtractNumber(column, pointer) {
+    const path = toSqlitePath(pointer);
+    return chunkYX3H63VV_cjs.sql`json_extract(${column}, ${chunkYX3H63VV_cjs.sql.raw(escapeSqliteLiteral(path))})`;
+  },
+  jsonExtractDouble(column, pointer) {
+    const path = toSqlitePath(pointer);
+    return chunkYX3H63VV_cjs.sql`json_extract(${column}, ${chunkYX3H63VV_cjs.sql.raw(escapeSqliteLiteral(path))})`;
+  },
+  jsonExtractBoolean(column, pointer) {
+    const path = toSqlitePath(pointer);
+    return chunkYX3H63VV_cjs.sql`json_extract(${column}, ${chunkYX3H63VV_cjs.sql.raw(escapeSqliteLiteral(path))})`;
+  },
+  jsonExtractDate(column, pointer) {
+    const path = toSqlitePath(pointer);
+    return chunkYX3H63VV_cjs.sql`json_extract(${column}, ${chunkYX3H63VV_cjs.sql.raw(escapeSqliteLiteral(path))})`;
+  },
+  // ============================================================
+  // JSON Array Operations
+  // ============================================================
+  jsonArrayLength(column) {
+    return chunkYX3H63VV_cjs.sql`json_array_length(${column})`;
+  },
+  jsonArrayContains(column, value) {
+    return chunkYX3H63VV_cjs.sql`EXISTS (SELECT 1 FROM json_each(${column}) WHERE json_each.value = ${value})`;
+  },
+  jsonArrayContainsAll(column, values) {
+    if (values.length === 0) {
+      return chunkYX3H63VV_cjs.sql.raw("1=1");
+    }
+    const packedValues = JSON.stringify(values);
+    return chunkYX3H63VV_cjs.sql`
+      NOT EXISTS (
+            SELECT 1 FROM json_each(${packedValues}) AS tg_required
+            WHERE NOT EXISTS (
+              SELECT 1 FROM json_each(${column}) AS tg_actual
+              WHERE tg_actual.value = tg_required.value
+            )
+          )
+    `;
+  },
+  jsonArrayContainsAny(column, values) {
+    if (values.length === 0) {
+      return chunkYX3H63VV_cjs.sql.raw("1=0");
+    }
+    const packedValues = JSON.stringify(values);
+    return chunkYX3H63VV_cjs.sql`
+      EXISTS (
+            SELECT 1
+            FROM json_each(${column}) AS tg_actual
+            JOIN json_each(${packedValues}) AS tg_wanted
+              ON tg_actual.value = tg_wanted.value
+          )
+    `;
+  },
+  // ============================================================
+  // JSON Object Operations
+  // ============================================================
+  jsonHasPath(column, pointer) {
+    const path = toSqlitePath(pointer);
+    return chunkYX3H63VV_cjs.sql`json_type(${column}, ${chunkYX3H63VV_cjs.sql.raw(escapeSqliteLiteral(path))}) IS NOT NULL`;
+  },
+  jsonPathIsNull(column, pointer) {
+    const path = toSqlitePath(pointer);
+    const pathSql = chunkYX3H63VV_cjs.sql.raw(escapeSqliteLiteral(path));
+    return chunkYX3H63VV_cjs.sql`COALESCE(json_type(${column}, ${pathSql}) = 'null', 1)`;
+  },
+  jsonPathIsNumber(column, pointer) {
+    const path = toSqlitePath(pointer);
+    const pathSql = chunkYX3H63VV_cjs.sql.raw(escapeSqliteLiteral(path));
+    return chunkYX3H63VV_cjs.sql`COALESCE(json_type(${column}, ${pathSql}) IN ('integer', 'real'), 0)`;
+  },
+  jsonPathIsNotNull(column, pointer) {
+    const path = toSqlitePath(pointer);
+    const pathSql = chunkYX3H63VV_cjs.sql.raw(escapeSqliteLiteral(path));
+    return chunkYX3H63VV_cjs.sql`COALESCE(json_type(${column}, ${pathSql}) <> 'null', 0)`;
+  },
+  // ============================================================
+  // Comparison Operations
+  // ============================================================
+  nullSafeEquals(left, right) {
+    return chunkYX3H63VV_cjs.sql`${left} IS ${right}`;
+  },
+  inList(left, values, negated) {
+    const operator = negated ? chunkYX3H63VV_cjs.sql.raw("NOT IN") : chunkYX3H63VV_cjs.sql.raw("IN");
+    const packedValues = JSON.stringify(values);
+    return chunkYX3H63VV_cjs.sql`${left} ${operator} (SELECT value FROM json_each(${packedValues}))`;
+  },
+  // ============================================================
+  // String Operations
+  // ============================================================
+  ilike(column, pattern) {
+    return chunkYX3H63VV_cjs.sql`LOWER(${column}) LIKE LOWER(${pattern}) ${chunkYX3H63VV_cjs.likeEscapeClause}`;
+  },
+  // ============================================================
+  // Set Operations
+  // ============================================================
+  wrapSetOperationOperand(inner) {
+    return chunkYX3H63VV_cjs.sql`SELECT * FROM (${inner})`;
+  },
+  // ============================================================
+  // Recursive CTE Path Operations
+  // ============================================================
+  initializePath(nodeId) {
+    return chunkYX3H63VV_cjs.sql`'|' || ${nodeId} || '|'`;
+  },
+  extendPath(currentPath, nodeId) {
+    return chunkYX3H63VV_cjs.sql`${currentPath} || ${nodeId} || '|'`;
+  },
+  cycleCheck(nodeId, path) {
+    return chunkYX3H63VV_cjs.sql`INSTR(${path}, '|' || ${nodeId} || '|') = 0`;
+  },
+  // ============================================================
+  // Value Binding & Literals
+  // ============================================================
+  bindValue(value) {
+    return chunkYX3H63VV_cjs.getSqlDialectProfile("sqlite").bindValue(value);
+  },
+  booleanLiteral(value) {
+    return chunkYX3H63VV_cjs.sql.raw(chunkYX3H63VV_cjs.getSqlDialectProfile("sqlite").booleanLiteralString(value));
+  },
+  booleanLiteralString(value) {
+    return chunkYX3H63VV_cjs.getSqlDialectProfile("sqlite").booleanLiteralString(value);
+  },
+  quoteIdentifier(name) {
+    return `"${name.replaceAll('"', '""')}"`;
+  },
+  // ============================================================
+  // Vector Operations
+  // ============================================================
+  // Compile-time gate for `field.similarTo(...)`; the active
+  // `VectorStrategy` (sqlite-vec / libSQL-native) owns the distance SQL.
+  supportsVectors: true,
+  // ============================================================
+  // Fulltext Operations
+  // ============================================================
+  fulltext: fts5Strategy
+};
+
+// src/query/dialect/index.ts
+var DIALECT_ADAPTERS = {
+  sqlite: sqliteDialect,
+  postgres: postgresDialect
+};
+function getDialect(dialect) {
+  return DIALECT_ADAPTERS[dialect];
+}
+
+// src/indexes/compiler.ts
+function compileNodeIndexKeys(index, dialect, propsColumn, systemColumn) {
+  const adapter = getDialect(dialect);
+  const keys = [];
+  const systemColumns = [
+    ...getNodeScopeColumns(index.scope),
+    ...index.keySystemColumns ?? []
+  ];
+  for (const column of systemColumns) {
+    keys.push(systemColumn(column));
+  }
+  const allPointers = [...index.fields, ...index.coveringFields];
+  const allValueTypes = [
+    ...index.fieldValueTypes,
+    ...index.coveringFieldValueTypes
+  ];
+  for (const [pointerIndex, pointer] of allPointers.entries()) {
+    const valueType = allValueTypes[pointerIndex];
+    const extracted = compileIndexKeyValue(
+      adapter,
+      propsColumn,
+      pointer,
+      valueType
+    );
+    keys.push(chunkYX3H63VV_cjs.sql`(${extracted})`);
+  }
+  return { keys };
+}
+function compileEdgeIndexKeys(index, dialect, propsColumn, systemColumn) {
+  const adapter = getDialect(dialect);
+  const keys = [];
+  for (const column of getEdgeScopeColumns(index.scope, index.direction)) {
+    keys.push(systemColumn(column));
+  }
+  const allPointers = [...index.fields, ...index.coveringFields];
+  const allValueTypes = [
+    ...index.fieldValueTypes,
+    ...index.coveringFieldValueTypes
+  ];
+  for (const [pointerIndex, pointer] of allPointers.entries()) {
+    const valueType = allValueTypes[pointerIndex];
+    const extracted = compileIndexKeyValue(
+      adapter,
+      propsColumn,
+      pointer,
+      valueType
+    );
+    keys.push(chunkYX3H63VV_cjs.sql`(${extracted})`);
+  }
+  return { keys };
+}
+function compileNodeIndexFieldKeys(index, ctx) {
+  const adapter = getDialect(ctx.dialect);
+  const keys = [];
+  for (const [position, pointer] of index.fields.entries()) {
+    const extracted = compileIndexKeyValue(
+      adapter,
+      ctx.propsColumn,
+      pointer,
+      index.fieldValueTypes[position]
+    );
+    keys.push(chunkYX3H63VV_cjs.sql`(${extracted})`);
+  }
+  return keys;
+}
+function compileIndexKeyValue(dialect, propsColumn, pointer, valueType) {
+  switch (valueType) {
+    case "number": {
+      return dialect.jsonExtractNumber(propsColumn, pointer);
+    }
+    case "boolean": {
+      return dialect.jsonExtractBoolean(propsColumn, pointer);
+    }
+    case "date": {
+      return dialect.jsonExtractDate(propsColumn, pointer);
+    }
+    case "string":
+    case "unknown":
+    case void 0: {
+      return dialect.jsonExtractText(propsColumn, pointer);
+    }
+    case "array":
+    case "object":
+    case "embedding": {
+      return dialect.jsonExtract(propsColumn, pointer);
+    }
+  }
+}
+function getNodeScopeColumns(scope) {
+  switch (scope) {
+    case "graphAndKind": {
+      return ["graph_id", "kind"];
+    }
+    case "graph": {
+      return ["graph_id"];
+    }
+    case "none": {
+      return [];
+    }
+  }
+}
+function getEdgeScopeColumns(scope, direction) {
+  const base = scope === "graphAndKind" ? ["graph_id", "kind"] : scope === "graph" ? ["graph_id"] : [];
+  if (direction === "out") {
+    return [...base, "from_id"];
+  }
+  if (direction === "in") {
+    return [...base, "to_id"];
+  }
+  return [...base];
+}
+function isIndexWhereLiteralList(value) {
+  return Array.isArray(value);
+}
+function compileIndexWhere(ctx, expression) {
+  switch (expression.__type) {
+    case "index_where_and": {
+      return chunkYX3H63VV_cjs.sql`(${chunkYX3H63VV_cjs.sql.join(
+        expression.predicates.map((p) => compileIndexWhere(ctx, p)),
+        chunkYX3H63VV_cjs.sql` AND `
+      )})`;
+    }
+    case "index_where_or": {
+      return chunkYX3H63VV_cjs.sql`(${chunkYX3H63VV_cjs.sql.join(
+        expression.predicates.map((p) => compileIndexWhere(ctx, p)),
+        chunkYX3H63VV_cjs.sql` OR `
+      )})`;
+    }
+    case "index_where_not": {
+      return chunkYX3H63VV_cjs.sql`(NOT ${compileIndexWhere(ctx, expression.predicate)})`;
+    }
+    case "index_where_null_check": {
+      const operand = compileIndexWhereOperand(ctx, expression.operand);
+      return expression.op === "isNull" ? chunkYX3H63VV_cjs.sql`${operand} IS NULL` : chunkYX3H63VV_cjs.sql`${operand} IS NOT NULL`;
+    }
+    case "index_where_comparison": {
+      const left = compileIndexWhereOperand(ctx, expression.left);
+      const right = expression.right;
+      if (isIndexWhereLiteralList(right)) {
+        if (expression.op !== "in" && expression.op !== "notIn") {
+          throw new Error(
+            `Operator "${expression.op}" does not support list comparison in index WHERE clause`
+          );
+        }
+        const values = right.map(
+          (literal) => compileIndexWhereLiteral(ctx.dialect, literal)
+        );
+        const operator = expression.op === "in" ? chunkYX3H63VV_cjs.sql`IN` : chunkYX3H63VV_cjs.sql`NOT IN`;
+        return chunkYX3H63VV_cjs.sql`${left} ${operator} (${chunkYX3H63VV_cjs.sql.join(values, chunkYX3H63VV_cjs.sql`, `)})`;
+      }
+      if (expression.op === "in" || expression.op === "notIn") {
+        throw new Error(
+          `Operator "${expression.op}" requires a list of values in index WHERE clause`
+        );
+      }
+      const rightLiteral = compileIndexWhereLiteral(ctx.dialect, right);
+      const opSql = compileComparisonOperator(expression.op);
+      return chunkYX3H63VV_cjs.sql`${left} ${opSql} ${rightLiteral}`;
+    }
+  }
+}
+function compileIndexWhereOperand(ctx, operand) {
+  if (operand.__type === "index_operand_system") {
+    return ctx.systemColumn(operand.column);
+  }
+  const adapter = getDialect(ctx.dialect);
+  const pointer = chunkTDXIBCGY_cjs.jsonPointer([operand.field]);
+  switch (operand.valueType) {
+    case "number": {
+      return adapter.jsonExtractNumber(ctx.propsColumn, pointer);
+    }
+    case "boolean": {
+      return adapter.jsonExtractBoolean(ctx.propsColumn, pointer);
+    }
+    case "date": {
+      return adapter.jsonExtractDate(ctx.propsColumn, pointer);
+    }
+    case "array":
+    case "object":
+    case "embedding": {
+      return adapter.jsonExtract(ctx.propsColumn, pointer);
+    }
+    case "string":
+    case "unknown":
+    case void 0: {
+      return adapter.jsonExtractText(ctx.propsColumn, pointer);
+    }
+  }
+}
+function compileIndexWhereLiteral(dialect, literal) {
+  switch (literal.valueType) {
+    case "string":
+    case "date": {
+      return chunkYX3H63VV_cjs.sql.raw(escapeStringLiteral(literal.value.toString()));
+    }
+    case "number": {
+      return chunkYX3H63VV_cjs.sql.raw(literal.value.toString());
+    }
+    case "boolean": {
+      return getDialect(dialect).booleanLiteral(literal.value);
+    }
+    case "array":
+    case "object":
+    case "embedding":
+    case "unknown": {
+      return chunkYX3H63VV_cjs.sql.raw(escapeStringLiteral(literal.value.toString()));
+    }
+  }
+}
+function compileComparisonOperator(op) {
+  switch (op) {
+    case "eq": {
+      return chunkYX3H63VV_cjs.sql`=`;
+    }
+    case "neq": {
+      return chunkYX3H63VV_cjs.sql`<>`;
+    }
+    case "gt": {
+      return chunkYX3H63VV_cjs.sql`>`;
+    }
+    case "gte": {
+      return chunkYX3H63VV_cjs.sql`>=`;
+    }
+    case "lt": {
+      return chunkYX3H63VV_cjs.sql`<`;
+    }
+    case "lte": {
+      return chunkYX3H63VV_cjs.sql`<=`;
+    }
+  }
+}
+function escapeStringLiteral(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+
+exports.ALL_FULLTEXT_MODES = ALL_FULLTEXT_MODES;
+exports.BASE_CONTRIBUTION_OWNER = BASE_CONTRIBUTION_OWNER;
+exports.FULLTEXT_CONTRIBUTION_NAME = FULLTEXT_CONTRIBUTION_NAME;
+exports.VECTOR_CONTRIBUTION_PREFIX = VECTOR_CONTRIBUTION_PREFIX;
+exports.assertFiniteEmbedding = assertFiniteEmbedding;
+exports.assertVectorMinScore = assertVectorMinScore;
+exports.assertVectorSearchLimit = assertVectorSearchLimit;
+exports.buildFulltextCapabilities = buildFulltextCapabilities;
+exports.buildVectorCapabilities = buildVectorCapabilities;
+exports.compileEdgeIndexKeys = compileEdgeIndexKeys;
+exports.compileIndexWhere = compileIndexWhere;
+exports.compileNodeIndexFieldKeys = compileNodeIndexFieldKeys;
+exports.compileNodeIndexKeys = compileNodeIndexKeys;
+exports.fts5Strategy = fts5Strategy;
+exports.getDialect = getDialect;
+exports.getNodeScopeColumns = getNodeScopeColumns;
+exports.quoteIdentifier = quoteIdentifier2;
+exports.shortHash = shortHash;
+exports.tsvectorStrategy = tsvectorStrategy;
+exports.vectorMinScoreCondition = vectorMinScoreCondition;
+exports.vectorPhysicalName = vectorPhysicalName;
+exports.vectorScoreExpression = vectorScoreExpression;
+//# sourceMappingURL=chunk-HAQVISUF.cjs.map
+//# sourceMappingURL=chunk-HAQVISUF.cjs.map