@nicia-ai/typegraph 0.37.1 → 0.38.0

package/dist/chunk-XGU7DZDA.cjs

@@ -1,1095 +0,0 @@
-'use strict';
-
-var chunk7YSP4V4R_cjs = require('./chunk-7YSP4V4R.cjs');
-var chunkTDXIBCGY_cjs = require('./chunk-TDXIBCGY.cjs');
-var drizzleOrm = require('drizzle-orm');
-
-// 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 drizzleOrm.sql`${chunk7YSP4V4R_cjs.quotedTableName(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 = chunk7YSP4V4R_cjs.quotedTableName(tableName);
-  return drizzleOrm.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 = chunk7YSP4V4R_cjs.quotedTableName(tableName);
-  return drizzleOrm.sql`
-    DELETE FROM ${table}
-    WHERE "graph_id" = ${params.graphId}
-      AND "node_kind" = ${params.nodeKind}
-      AND "node_id" IN (${drizzleOrm.sql.join(
-    unique.map((id) => drizzleOrm.sql`${id}`),
-    drizzleOrm.sql`, `
-  )})
-  `;
-}
-function postgresTsquery(mode, query, language) {
-  const langExpr = language === void 0 ? drizzleOrm.sql`"language"` : drizzleOrm.sql`${language}::regconfig`;
-  switch (mode) {
-    case "websearch": {
-      return drizzleOrm.sql`websearch_to_tsquery(${langExpr}, ${query})`;
-    }
-    case "phrase": {
-      return drizzleOrm.sql`phraseto_tsquery(${langExpr}, ${query})`;
-    }
-    case "plain": {
-      return drizzleOrm.sql`plainto_tsquery(${langExpr}, ${query})`;
-    }
-    case "raw": {
-      return drizzleOrm.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 drizzleOrm.sql`${tsvectorColumn(tableName)} @@ ${q}`;
-  },
-  rankExpression(tableName, query, mode, language) {
-    const q = postgresTsquery(mode, query, language);
-    return drizzleOrm.sql`ts_rank_cd(${tsvectorColumn(tableName)}, ${q})`;
-  },
-  snippetExpression(_tableName, query, mode, language) {
-    const langExpr = language === void 0 ? drizzleOrm.sql`"language"` : drizzleOrm.sql`${language}::regconfig`;
-    const q = postgresTsquery(mode, query, language);
-    return drizzleOrm.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 = chunk7YSP4V4R_cjs.quotedTableName(tableName);
-    return [
-      drizzleOrm.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 = chunk7YSP4V4R_cjs.quotedTableName(tableName);
-    const valueTuples = rows.map(
-      (row) => drizzleOrm.sql`
-        (
-              ${params.graphId}, ${params.nodeKind}, ${row.nodeId},
-              ${row.content}, ${row.language}::regconfig,
-              ${timestamp}
-            )
-      `
-    );
-    return [
-      drizzleOrm.sql`
-        INSERT INTO ${table} ("graph_id", "node_kind", "node_id", "content", "language", "updated_at")
-        VALUES ${drizzleOrm.sql.join(valueTuples, drizzleOrm.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 drizzleOrm.sql`${chunk7YSP4V4R_cjs.quotedTableName(tableName)} MATCH ${matchExpression}`;
-  },
-  rankExpression(tableName, _query, _mode, _language) {
-    return drizzleOrm.sql`-bm25(${chunk7YSP4V4R_cjs.quotedTableName(tableName)})`;
-  },
-  snippetExpression(tableName, _query, _mode, _language) {
-    return drizzleOrm.sql`snippet(${chunk7YSP4V4R_cjs.quotedTableName(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 = chunk7YSP4V4R_cjs.quotedTableName(tableName);
-    return [
-      drizzleOrm.sql`
-        DELETE FROM ${table}
-        WHERE "graph_id" = ${params.graphId}
-          AND "node_kind" = ${params.nodeKind}
-          AND "node_id" = ${params.nodeId}
-      `,
-      drizzleOrm.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 = chunk7YSP4V4R_cjs.quotedTableName(tableName);
-    const nodeIds = rows.map((row) => row.nodeId);
-    const deleteStmt = drizzleOrm.sql`
-      DELETE FROM ${table}
-      WHERE "graph_id" = ${params.graphId}
-        AND "node_kind" = ${params.nodeKind}
-        AND "node_id" IN (${drizzleOrm.sql.join(
-      nodeIds.map((id) => drizzleOrm.sql`${id}`),
-      drizzleOrm.sql`, `
-    )})
-    `;
-    const valueTuples = rows.map(
-      (row) => drizzleOrm.sql`
-        (
-              ${params.graphId}, ${params.nodeKind}, ${row.nodeId},
-              ${row.content}, ${row.language}, ${timestamp}
-            )
-      `
-    );
-    const insertStmt = drizzleOrm.sql`
-      INSERT INTO ${table} (graph_id, node_kind, node_id, content, language, updated_at)
-      VALUES ${drizzleOrm.sql.join(valueTuples, drizzleOrm.sql`, `)}
-    `;
-    return [deleteStmt, insertStmt];
-  },
-  buildDelete(tableName, params) {
-    return [buildPkScopedDelete(tableName, params)];
-  },
-  buildBatchDelete(tableName, params) {
-    const stmt = buildPkScopedBatchDelete(tableName, params);
-    return stmt === void 0 ? [] : [stmt];
-  }
-};
-var VECTOR_CONTRIBUTION_PREFIX = "vector";
-function buildVectorCapabilities(strategy) {
-  return strategy.capabilities;
-}
-function vectorScoreExpression(distanceExpression, metric) {
-  switch (metric) {
-    case "cosine": {
-      return drizzleOrm.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 drizzleOrm.sql`${distanceExpression} <= ${1 - minScore}`;
-    }
-    case "l2": {
-      return drizzleOrm.sql`${distanceExpression} <= ${minScore}`;
-    }
-    case "inner_product": {
-      return drizzleOrm.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 = 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('"', '""')}"`;
-}
-function escapePostgresLiteral(value) {
-  if (value.includes("\\")) {
-    return `E'${value.replaceAll("\\", "\\\\").replaceAll("'", "''")}'`;
-  }
-  return `'${value.replaceAll("'", "''")}'`;
-}
-function toPostgresPath(pointer) {
-  if (!pointer || pointer === "" || pointer === "/") {
-    return drizzleOrm.sql.raw("ARRAY[]::text[]");
-  }
-  const segments = chunkTDXIBCGY_cjs.parseJsonPointer(pointer);
-  if (segments.length === 0) {
-    return drizzleOrm.sql.raw("ARRAY[]::text[]");
-  }
-  const escapedSegments = segments.map((segment) => escapePostgresLiteral(segment)).join(", ");
-  return drizzleOrm.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 drizzleOrm.sql`${expression} COLLATE "C"`;
-  },
-  analyzeTemporaryTable(table) {
-    return drizzleOrm.sql`ANALYZE ${table}`;
-  },
-  setTransactionWorkingMemory(workingMemory) {
-    return drizzleOrm.sql`SELECT set_config('work_mem', ${workingMemory}, true)`;
-  },
-  // ============================================================
-  // JSON Path Operations
-  // ============================================================
-  compilePath(pointer) {
-    return toPostgresPath(pointer);
-  },
-  jsonExtract(column, pointer) {
-    const path = toPostgresPath(pointer);
-    return drizzleOrm.sql`${column} #> ${path}`;
-  },
-  jsonExtractText(column, pointer) {
-    const path = toPostgresPath(pointer);
-    return drizzleOrm.sql`${column} #>> ${path}`;
-  },
-  jsonExtractNumber(column, pointer) {
-    const path = toPostgresPath(pointer);
-    return drizzleOrm.sql`(${column} #>> ${path})::numeric`;
-  },
-  jsonExtractDouble(column, pointer) {
-    const path = toPostgresPath(pointer);
-    return drizzleOrm.sql`(${column} #>> ${path})::double precision`;
-  },
-  jsonExtractBoolean(column, pointer) {
-    const path = toPostgresPath(pointer);
-    return drizzleOrm.sql`(${column} #>> ${path})::boolean`;
-  },
-  jsonExtractDate(column, pointer) {
-    const path = toPostgresPath(pointer);
-    return drizzleOrm.sql`(${column} #>> ${path})::timestamptz`;
-  },
-  // ============================================================
-  // JSON Array Operations
-  // ============================================================
-  jsonArrayLength(column) {
-    return drizzleOrm.sql`jsonb_array_length(${column})`;
-  },
-  jsonArrayContains(column, value) {
-    const jsonValue = JSON.stringify([value]);
-    return drizzleOrm.sql`${column} @> ${jsonValue}::jsonb`;
-  },
-  jsonArrayContainsAll(column, values) {
-    if (values.length === 0) {
-      return drizzleOrm.sql.raw("1=1");
-    }
-    const jsonValue = JSON.stringify(values);
-    return drizzleOrm.sql`${column} @> ${jsonValue}::jsonb`;
-  },
-  jsonArrayContainsAny(column, values) {
-    if (values.length === 0) {
-      return drizzleOrm.sql.raw("1=0");
-    }
-    const conditions = values.map((value) => {
-      const jsonValue = JSON.stringify([value]);
-      return drizzleOrm.sql`${column} @> ${jsonValue}::jsonb`;
-    });
-    return drizzleOrm.sql`(${drizzleOrm.sql.join(conditions, drizzleOrm.sql` OR `)})`;
-  },
-  // ============================================================
-  // JSON Object Operations
-  // ============================================================
-  jsonHasPath(column, pointer) {
-    const path = toPostgresPath(pointer);
-    return drizzleOrm.sql`${column} #> ${path} IS NOT NULL`;
-  },
-  jsonPathIsNull(column, pointer) {
-    const path = toPostgresPath(pointer);
-    return drizzleOrm.sql`COALESCE(jsonb_typeof(${column} #> ${path}) = 'null', TRUE)`;
-  },
-  jsonPathIsNumber(column, pointer) {
-    const path = toPostgresPath(pointer);
-    return drizzleOrm.sql`COALESCE(jsonb_typeof(${column} #> ${path}) = 'number', FALSE)`;
-  },
-  jsonPathIsNotNull(column, pointer) {
-    const path = toPostgresPath(pointer);
-    return drizzleOrm.sql`COALESCE(jsonb_typeof(${column} #> ${path}) <> 'null', FALSE)`;
-  },
-  // ============================================================
-  // Comparison Operations
-  // ============================================================
-  nullSafeEquals(left, right) {
-    return drizzleOrm.sql`${left} IS NOT DISTINCT FROM ${right}`;
-  },
-  inList(left, values, negated) {
-    const operator = negated ? drizzleOrm.sql.raw("NOT IN") : drizzleOrm.sql.raw("IN");
-    const placeholders = values.map((value) => drizzleOrm.sql`${value}`);
-    return drizzleOrm.sql`${left} ${operator} (${drizzleOrm.sql.join(placeholders, drizzleOrm.sql`, `)})`;
-  },
-  // ============================================================
-  // String Operations
-  // ============================================================
-  ilike(column, pattern) {
-    return drizzleOrm.sql`${column} ILIKE ${pattern} ${chunk7YSP4V4R_cjs.likeEscapeClause}`;
-  },
-  // ============================================================
-  // Set Operations
-  // ============================================================
-  wrapSetOperationOperand(inner) {
-    return drizzleOrm.sql`(${inner})`;
-  },
-  // ============================================================
-  // Recursive CTE Path Operations
-  // ============================================================
-  initializePath(nodeId) {
-    return drizzleOrm.sql`ARRAY[${nodeId}]`;
-  },
-  extendPath(currentPath, nodeId) {
-    return drizzleOrm.sql`${currentPath} || ${nodeId}`;
-  },
-  cycleCheck(nodeId, path) {
-    return drizzleOrm.sql`${nodeId} != ALL(${path})`;
-  },
-  // ============================================================
-  // Value Binding & Literals
-  // ============================================================
-  bindValue(value) {
-    return value;
-  },
-  booleanLiteral(value) {
-    return drizzleOrm.sql.raw(this.booleanLiteralString(value));
-  },
-  booleanLiteralString(value) {
-    return value ? "TRUE" : "FALSE";
-  },
-  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
-};
-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 drizzleOrm.sql.raw(escapeSqliteLiteral(toSqlitePath(pointer)));
-  },
-  jsonExtract(column, pointer) {
-    const path = toSqlitePath(pointer);
-    return drizzleOrm.sql`json_extract(${column}, ${drizzleOrm.sql.raw(escapeSqliteLiteral(path))})`;
-  },
-  jsonExtractText(column, pointer) {
-    const path = toSqlitePath(pointer);
-    return drizzleOrm.sql`json_extract(${column}, ${drizzleOrm.sql.raw(escapeSqliteLiteral(path))})`;
-  },
-  jsonExtractNumber(column, pointer) {
-    const path = toSqlitePath(pointer);
-    return drizzleOrm.sql`json_extract(${column}, ${drizzleOrm.sql.raw(escapeSqliteLiteral(path))})`;
-  },
-  jsonExtractDouble(column, pointer) {
-    const path = toSqlitePath(pointer);
-    return drizzleOrm.sql`json_extract(${column}, ${drizzleOrm.sql.raw(escapeSqliteLiteral(path))})`;
-  },
-  jsonExtractBoolean(column, pointer) {
-    const path = toSqlitePath(pointer);
-    return drizzleOrm.sql`json_extract(${column}, ${drizzleOrm.sql.raw(escapeSqliteLiteral(path))})`;
-  },
-  jsonExtractDate(column, pointer) {
-    const path = toSqlitePath(pointer);
-    return drizzleOrm.sql`json_extract(${column}, ${drizzleOrm.sql.raw(escapeSqliteLiteral(path))})`;
-  },
-  // ============================================================
-  // JSON Array Operations
-  // ============================================================
-  jsonArrayLength(column) {
-    return drizzleOrm.sql`json_array_length(${column})`;
-  },
-  jsonArrayContains(column, value) {
-    return drizzleOrm.sql`EXISTS (SELECT 1 FROM json_each(${column}) WHERE json_each.value = ${value})`;
-  },
-  jsonArrayContainsAll(column, values) {
-    if (values.length === 0) {
-      return drizzleOrm.sql.raw("1=1");
-    }
-    const packedValues = JSON.stringify(values);
-    return drizzleOrm.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 drizzleOrm.sql.raw("1=0");
-    }
-    const packedValues = JSON.stringify(values);
-    return drizzleOrm.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 drizzleOrm.sql`json_type(${column}, ${drizzleOrm.sql.raw(escapeSqliteLiteral(path))}) IS NOT NULL`;
-  },
-  jsonPathIsNull(column, pointer) {
-    const path = toSqlitePath(pointer);
-    const pathSql = drizzleOrm.sql.raw(escapeSqliteLiteral(path));
-    return drizzleOrm.sql`COALESCE(json_type(${column}, ${pathSql}) = 'null', 1)`;
-  },
-  jsonPathIsNumber(column, pointer) {
-    const path = toSqlitePath(pointer);
-    const pathSql = drizzleOrm.sql.raw(escapeSqliteLiteral(path));
-    return drizzleOrm.sql`COALESCE(json_type(${column}, ${pathSql}) IN ('integer', 'real'), 0)`;
-  },
-  jsonPathIsNotNull(column, pointer) {
-    const path = toSqlitePath(pointer);
-    const pathSql = drizzleOrm.sql.raw(escapeSqliteLiteral(path));
-    return drizzleOrm.sql`COALESCE(json_type(${column}, ${pathSql}) <> 'null', 0)`;
-  },
-  // ============================================================
-  // Comparison Operations
-  // ============================================================
-  nullSafeEquals(left, right) {
-    return drizzleOrm.sql`${left} IS ${right}`;
-  },
-  inList(left, values, negated) {
-    const operator = negated ? drizzleOrm.sql.raw("NOT IN") : drizzleOrm.sql.raw("IN");
-    const packedValues = JSON.stringify(values);
-    return drizzleOrm.sql`${left} ${operator} (SELECT value FROM json_each(${packedValues}))`;
-  },
-  // ============================================================
-  // String Operations
-  // ============================================================
-  ilike(column, pattern) {
-    return drizzleOrm.sql`LOWER(${column}) LIKE LOWER(${pattern}) ${chunk7YSP4V4R_cjs.likeEscapeClause}`;
-  },
-  // ============================================================
-  // Set Operations
-  // ============================================================
-  wrapSetOperationOperand(inner) {
-    return drizzleOrm.sql`SELECT * FROM (${inner})`;
-  },
-  // ============================================================
-  // Recursive CTE Path Operations
-  // ============================================================
-  initializePath(nodeId) {
-    return drizzleOrm.sql`'|' || ${nodeId} || '|'`;
-  },
-  extendPath(currentPath, nodeId) {
-    return drizzleOrm.sql`${currentPath} || ${nodeId} || '|'`;
-  },
-  cycleCheck(nodeId, path) {
-    return drizzleOrm.sql`INSTR(${path}, '|' || ${nodeId} || '|') = 0`;
-  },
-  // ============================================================
-  // Value Binding & Literals
-  // ============================================================
-  bindValue(value) {
-    if (typeof value === "boolean") {
-      return value ? 1 : 0;
-    }
-    return value;
-  },
-  booleanLiteral(value) {
-    return drizzleOrm.sql.raw(this.booleanLiteralString(value));
-  },
-  booleanLiteralString(value) {
-    return value ? "1" : "0";
-  },
-  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];
-}
-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(drizzleOrm.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(drizzleOrm.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(drizzleOrm.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 drizzleOrm.sql`(${drizzleOrm.sql.join(
-        expression.predicates.map((p) => compileIndexWhere(ctx, p)),
-        drizzleOrm.sql` AND `
-      )})`;
-    }
-    case "index_where_or": {
-      return drizzleOrm.sql`(${drizzleOrm.sql.join(
-        expression.predicates.map((p) => compileIndexWhere(ctx, p)),
-        drizzleOrm.sql` OR `
-      )})`;
-    }
-    case "index_where_not": {
-      return drizzleOrm.sql`(NOT ${compileIndexWhere(ctx, expression.predicate)})`;
-    }
-    case "index_where_null_check": {
-      const operand = compileIndexWhereOperand(ctx, expression.operand);
-      return expression.op === "isNull" ? drizzleOrm.sql`${operand} IS NULL` : drizzleOrm.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" ? drizzleOrm.sql`IN` : drizzleOrm.sql`NOT IN`;
-        return drizzleOrm.sql`${left} ${operator} (${drizzleOrm.sql.join(values, drizzleOrm.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 drizzleOrm.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 drizzleOrm.sql.raw(escapeStringLiteral(literal.value.toString()));
-    }
-    case "number": {
-      return drizzleOrm.sql.raw(literal.value.toString());
-    }
-    case "boolean": {
-      return getDialect(dialect).booleanLiteral(literal.value);
-    }
-    case "array":
-    case "object":
-    case "embedding":
-    case "unknown": {
-      return drizzleOrm.sql.raw(escapeStringLiteral(literal.value.toString()));
-    }
-  }
-}
-function compileComparisonOperator(op) {
-  switch (op) {
-    case "eq": {
-      return drizzleOrm.sql`=`;
-    }
-    case "neq": {
-      return drizzleOrm.sql`<>`;
-    }
-    case "gt": {
-      return drizzleOrm.sql`>`;
-    }
-    case "gte": {
-      return drizzleOrm.sql`>=`;
-    }
-    case "lt": {
-      return drizzleOrm.sql`<`;
-    }
-    case "lte": {
-      return drizzleOrm.sql`<=`;
-    }
-  }
-}
-function escapeStringLiteral(value) {
-  return `'${value.replaceAll("'", "''")}'`;
-}
-
-exports.BASE_CONTRIBUTION_OWNER = BASE_CONTRIBUTION_OWNER;
-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-XGU7DZDA.cjs.map
-//# sourceMappingURL=chunk-XGU7DZDA.cjs.map