@absolutejs/rag 0.0.19 → 0.0.21

package/dist/index.js

@@ -35670,2204 +35670,176 @@ var createInMemoryRAGStore = (options = {}) => {
     getStatus: () => createInMemoryStatus(dimensions)
   };
 };
-// src/adapters/queryPlanning.ts
-var planNativeCandidateSearchK = (input) => {
-  const base = Math.min(Math.max(input.topK * input.queryMultiplier, input.topK), input.candidateLimit);
-  if (input.filteredCandidateCount === undefined || !Number.isFinite(input.filteredCandidateCount)) {
-    return base;
-  }
-  const filtered = Math.max(0, Math.floor(input.filteredCandidateCount));
-  if (filtered === 0) {
-    return 0;
-  }
-  return Math.min(base, filtered);
-};
-var resolveAdaptiveNativeCandidateLimit = (input) => {
-  const clamp = (value) => Math.min(input.defaultCandidateLimit, Math.max(1, Math.floor(value)));
-  const filteredCap = typeof input.filteredCandidateCount === "number" && Number.isFinite(input.filteredCandidateCount) ? Math.max(0, Math.floor(input.filteredCandidateCount)) : undefined;
-  if (typeof input.explicitCandidateLimit === "number" && Number.isFinite(input.explicitCandidateLimit)) {
-    return filteredCap === undefined ? clamp(input.explicitCandidateLimit) : Math.min(clamp(input.explicitCandidateLimit), filteredCap);
-  }
-  const baseFloor = Math.max(input.topK, input.topK * Math.max(1, Math.floor(input.queryMultiplier)));
-  let tuned = input.plannerProfile === "latency" ? clamp(Math.max(input.topK * 2, baseFloor)) : input.plannerProfile === "recall" ? clamp(Math.max(input.topK * 12, baseFloor * 4)) : clamp(Math.max(input.topK * 6, baseFloor * 2));
-  if (filteredCap !== undefined) {
-    if (filteredCap === 0) {
-      return 0;
-    }
-    tuned = Math.min(tuned, filteredCap);
-  }
-  return tuned;
-};
-var planNativeCandidateSearchBackfillK = (input) => {
-  if (typeof input.maxBackfills === "number" && Number.isFinite(input.maxBackfills) && (input.backfillCount ?? 0) >= Math.max(0, Math.floor(input.maxBackfills))) {
-    return input.currentSearchK;
-  }
-  const cappedLimit = input.filteredCandidateCount === undefined || !Number.isFinite(input.filteredCandidateCount) ? input.candidateLimit : Math.min(input.candidateLimit, Math.max(0, Math.floor(input.filteredCandidateCount)));
-  if (input.currentSearchK >= cappedLimit) {
-    return input.currentSearchK;
-  }
-  return Math.min(cappedLimit, Math.max(input.currentSearchK + 1, input.currentSearchK * 2));
-};
-var summarizeSQLiteCandidateCoverage = (input) => {
-  const basis = typeof input.filteredCandidateCount === "number" && Number.isFinite(input.filteredCandidateCount) ? Math.max(0, Math.floor(input.filteredCandidateCount)) : typeof input.returnedCount === "number" && Number.isFinite(input.returnedCount) ? Math.max(0, Math.floor(input.returnedCount)) : 0;
-  if (basis === 0) {
-    return "empty";
-  }
-  if (basis < input.topK) {
-    return "under_target";
-  }
-  if (basis >= input.topK * 3) {
-    return "broad";
-  }
-  return "target_sized";
-};
-
-// src/adapters/postgres.ts
-var DEFAULT_DIMENSIONS = RAG_VECTOR_DIMENSIONS_DEFAULT;
-var DEFAULT_TABLE_NAME = "rag_chunks";
-var DEFAULT_SCHEMA_NAME = "public";
-var DEFAULT_QUERY_MULTIPLIER = 4;
-var MAX_QUERY_MULTIPLIER = 16;
-var DEFAULT_POSTGRES_INDEX_TYPE = "hnsw";
-var DEFAULT_POSTGRES_IVFFLAT_LISTS = 100;
-var DEFAULT_POSTGRES_HNSW_M = 16;
-var DEFAULT_POSTGRES_HNSW_EF_CONSTRUCTION = 64;
-var IDENTIFIER_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-var FILTER_PATH_SEGMENT_RE = /^[a-zA-Z0-9_]+$/;
-var isObjectFilterRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
-var isNestedFilterArray2 = (value) => Array.isArray(value) && value.every((entry) => isObjectFilterRecord(entry));
-var isOperatorFilterRecord = (value) => isObjectFilterRecord(value) && Object.keys(value).some((key) => key.startsWith("$"));
-var countFilterClauses = (filter) => {
-  if (!filter) {
-    return 0;
-  }
-  let count = 0;
-  for (const [key, value] of Object.entries(filter)) {
-    if (key === "$and" || key === "$or") {
-      if (isNestedFilterArray2(value)) {
-        count += value.reduce((total, entry) => total + countFilterClauses(entry), 0);
-      }
-      continue;
-    }
-    if (key === "$not") {
-      if (isObjectFilterRecord(value)) {
-        count += countFilterClauses(value);
-      }
-      continue;
-    }
-    count += 1;
-  }
-  return count;
-};
-var toPostgresJsonPath = (key) => {
-  const segments = key.split(".").filter(Boolean);
-  if (segments.length === 0 || !segments.every((segment) => FILTER_PATH_SEGMENT_RE.test(segment))) {
-    return null;
-  }
-  return segments;
-};
-var toPostgresFilterBinding = (value) => {
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
-    return value;
-  }
-  return;
-};
-var buildPostgresJsonbScalarEquality = (input) => {
-  const comparison = input.comparison ?? "=";
-  return comparison === "=" ? `jsonb_typeof(${input.valueSql}) = 'null'` : `coalesce(jsonb_typeof(${input.valueSql}), 'missing') <> 'null'`;
-};
-var buildPostgresMetadataScalarEquality = (input) => input.value === null ? buildPostgresJsonbScalarEquality({
-  comparison: input.comparison,
-  valueSql: input.valueSql
-}) : `${input.actualSql} ${input.comparison ?? "="} ${input.bind(String(input.value))}`;
-var buildPostgresFilterPlan = (filter, startIndex = 0) => {
-  if (!filter) {
-    return { clause: "", params: [] };
-  }
-  const params = [];
-  const bind = (value) => {
-    params.push(value);
-    return `$${params.length + startIndex}`;
-  };
-  const build = (entry) => {
-    const clauses = [];
-    for (const [key, value] of Object.entries(entry)) {
-      if (key === "$and" || key === "$or") {
-        if (!isNestedFilterArray2(value) || value.length === 0) {
-          return null;
-        }
-        const nested = value.map((item) => build(item));
-        if (nested.some((item) => item === null)) {
-          return null;
-        }
-        clauses.push(`(${nested.filter((item) => Boolean(item)).join(key === "$and" ? " AND " : " OR ")})`);
-        continue;
-      }
-      if (key === "$not") {
-        if (!isObjectFilterRecord(value)) {
-          return null;
-        }
-        const nested = build(value);
-        if (!nested) {
-          return null;
-        }
-        clauses.push(`NOT (${nested})`);
-        continue;
-      }
-      const isScalarField = key === "chunkId" || key === "source" || key === "title";
-      const jsonPath = isScalarField ? null : toPostgresJsonPath(key);
-      if (!isScalarField && !jsonPath) {
-        return null;
-      }
-      let actualSql;
-      let metadataPathSegments = [];
-      let metadataValueSql;
-      if (isScalarField) {
-        actualSql = key === "chunkId" ? "chunk_id" : key;
-      } else {
-        metadataPathSegments = jsonPath ?? [];
-        actualSql = `jsonb_extract_path_text(metadata, ${metadataPathSegments.map((segment) => `'${segment}'`).join(", ")})`;
-        metadataValueSql = `metadata #> '{${metadataPathSegments.join(",")}}'`;
-      }
-      if (!isOperatorFilterRecord(value)) {
-        const binding = toPostgresFilterBinding(value);
-        if (binding === undefined) {
-          return null;
-        }
-        clauses.push(isScalarField ? `${actualSql} = ${bind(String(binding))}` : buildPostgresMetadataScalarEquality({
-          actualSql,
-          bind,
-          value: binding,
-          valueSql: metadataValueSql
-        }));
-        continue;
-      }
-      const operatorClauses = Object.entries(value).map(([operator, expected]) => {
-        switch (operator) {
-          case "$exists":
-            return isScalarField ? expected ? `${actualSql} IS NOT NULL` : `${actualSql} IS NULL` : expected ? `${metadataValueSql} IS NOT NULL` : `${metadataValueSql} IS NULL`;
-          case "$in": {
-            if (!Array.isArray(expected) || expected.length === 0) {
-              return null;
-            }
-            const bindings = expected.map((entry2) => toPostgresFilterBinding(entry2)).filter((entry2) => entry2 !== undefined);
-            if (bindings.length !== expected.length) {
-              return null;
-            }
-            return isScalarField ? `${actualSql} IN (${bindings.map((entry2) => bind(String(entry2))).join(", ")})` : `(${bindings.map((entry2) => buildPostgresMetadataScalarEquality({
-              actualSql,
-              bind,
-              value: entry2,
-              valueSql: metadataValueSql
-            })).join(" OR ")})`;
-          }
-          case "$ne": {
-            const binding = toPostgresFilterBinding(expected);
-            return binding === undefined ? null : isScalarField ? `${actualSql} <> ${bind(String(binding))}` : buildPostgresMetadataScalarEquality({
-              actualSql,
-              bind,
-              comparison: "<>",
-              value: binding,
-              valueSql: metadataValueSql
-            });
-          }
-          case "$gt":
-          case "$gte":
-          case "$lt":
-          case "$lte": {
-            if (typeof expected !== "number" || !Number.isFinite(expected)) {
-              return null;
-            }
-            const comparison = operator === "$gt" ? ">" : operator === "$gte" ? ">=" : operator === "$lt" ? "<" : "<=";
-            return `((${actualSql}) ~ '^-?[0-9]+(\\.[0-9]+)?$' AND (${actualSql})::double precision ${comparison} ${bind(expected)})`;
-          }
-          case "$contains":
-            if (isScalarField) {
-              return null;
-            }
-            if (toPostgresFilterBinding(expected) === undefined) {
-              return null;
-            }
-            return `(${metadataValueSql} IS NOT NULL AND ${metadataValueSql} ? ${bind(String(expected))})`;
-          case "$containsAny":
-          case "$containsAll": {
-            if (isScalarField || !Array.isArray(expected)) {
-              return null;
-            }
-            const values = expected.map((entry2) => toPostgresFilterBinding(entry2)).filter((entry2) => entry2 !== undefined);
-            if (values.length === 0 || values.length !== expected.length) {
-              return null;
-            }
-            const sqlArray = `ARRAY[${values.map((value2) => bind(String(value2))).join(", ")}]::text[]`;
-            return `(${metadataValueSql} IS NOT NULL AND ${metadataValueSql} ${operator === "$containsAny" ? "?|" : "?&"} ${sqlArray})`;
-          }
-          default:
-            return null;
-        }
-      });
-      if (operatorClauses.some((clause2) => clause2 === null)) {
-        return null;
-      }
-      clauses.push(operatorClauses.filter((clause2) => Boolean(clause2)).map((clause2) => `(${clause2})`).join(" AND "));
-    }
-    return clauses.length > 0 ? clauses.map((clause2) => `(${clause2})`).join(" AND ") : "";
-  };
-  const clause = build(filter);
-  return clause === null || clause.trim().length === 0 ? null : { clause, params };
-};
-var buildPostgresPushdownFilter = (filter) => {
-  if (!filter) {
-    return;
-  }
-  const hasPushdownFilterPlan = (entry) => {
-    const plan = buildPostgresFilterPlan(entry);
-    return plan !== null && Boolean(plan.clause) && plan.clause.trim().length > 0;
-  };
-  const hasPushdownFilterPlanEntry = (entry) => {
-    if (!isObjectFilterRecord(entry)) {
-      return false;
-    }
-    return hasPushdownFilterPlan(entry);
-  };
-  const nextEntries = [];
-  for (const [key, value] of Object.entries(filter)) {
-    if (key === "$and" || key === "$or") {
-      if (!isNestedFilterArray2(value)) {
-        continue;
-      }
-      const nested = value.map((entry) => buildPostgresPushdownFilter(entry)).filter((entry) => hasPushdownFilterPlanEntry(entry));
-      if (nested.length > 0) {
-        nextEntries.push([key, nested]);
-      }
-      continue;
-    }
-    if (key === "$not") {
-      if (!isObjectFilterRecord(value)) {
-        continue;
-      }
-      const nested = buildPostgresPushdownFilter(value);
-      if (hasPushdownFilterPlanEntry(nested)) {
-        nextEntries.push([key, nested]);
-      }
-      continue;
-    }
-    if (Array.isArray(value) || isOperatorFilterRecord(value) && Object.keys(value).some((operator) => !(operator === "$exists" || operator === "$in" || operator === "$contains" || operator === "$containsAny" || operator === "$containsAll" || operator === "$ne" || operator === "$gt" || operator === "$gte" || operator === "$lt" || operator === "$lte"))) {
-      continue;
-    }
-    const isScalarColumnKey = ["chunkId", "source", "title"].includes(key);
-    const jsonPath = isScalarColumnKey ? null : toPostgresJsonPath(key);
-    if (!isScalarColumnKey && !jsonPath) {
-      continue;
-    }
-    if (!hasPushdownFilterPlan({ [key]: value })) {
-      continue;
-    }
-    nextEntries.push([key, value]);
-  }
-  return nextEntries.length > 0 ? Object.fromEntries(nextEntries) : undefined;
-};
-var resolvePostgresPushdownMode = (input) => {
-  const totalFilterClauseCount = countFilterClauses(input.filter);
-  const pushdownClauseCount = countFilterClauses(input.pushdownFilter);
-  const jsRemainderClauseCount = Math.max(0, totalFilterClauseCount - pushdownClauseCount);
-  const pushdownMode = pushdownClauseCount === 0 ? "none" : pushdownClauseCount >= totalFilterClauseCount ? "full" : "partial";
-  return {
-    jsRemainderClauseCount,
-    jsRemainderRatio: totalFilterClauseCount > 0 ? jsRemainderClauseCount / totalFilterClauseCount : undefined,
-    pushdownClauseCount,
-    pushdownCoverageRatio: totalFilterClauseCount > 0 ? pushdownClauseCount / totalFilterClauseCount : undefined,
-    pushdownMode,
-    totalFilterClauseCount
-  };
-};
-var assertSupportedIdentifier2 = (name) => {
-  if (!IDENTIFIER_RE.test(name)) {
-    throw new Error(`Invalid identifier "${name}". Only alphanumeric and underscore names are allowed.`);
-  }
-};
-var normalizePostgresIndexType = (value) => {
-  if (value === undefined) {
-    return DEFAULT_POSTGRES_INDEX_TYPE;
-  }
-  if (value === "none" || value === "hnsw" || value === "ivfflat") {
-    return value;
-  }
-  throw new Error(`Invalid postgres index type "${String(value)}". Expected "none", "hnsw", or "ivfflat".`);
-};
-var normalizePositiveInteger = (value, fallback) => {
-  if (value === undefined || !Number.isFinite(value)) {
-    return fallback;
-  }
-  return Math.max(1, Math.floor(value));
-};
-var getPostgresIndexOperatorClass = (metric) => metric === "cosine" ? "vector_cosine_ops" : metric === "inner_product" ? "vector_ip_ops" : "vector_l2_ops";
-var getPostgresIndexName = (qualifiedTableName, indexType) => indexType === "none" ? undefined : `${qualifiedTableName.replace(".", "_")}_embedding_${indexType}_idx`;
-var buildPostgresIndexSql = (input) => {
-  if (input.indexType === "none") {
-    return;
-  }
-  const opclass = getPostgresIndexOperatorClass(input.distanceMetric);
-  const indexName = getPostgresIndexName(input.qualifiedTableName, input.indexType);
-  const optionsSql = input.indexType === "hnsw" ? ` with (m = ${input.hnswM}, ef_construction = ${input.hnswEfConstruction})` : ` with (lists = ${input.indexLists})`;
-  const createPrefix = input.ifNotExists === false ? "create index" : "create index if not exists";
-  return `${createPrefix} ${indexName} on ${input.qualifiedTableName} using ${input.indexType} (embedding ${opclass})${optionsSql}`;
-};
-var normalizeQueryMultiplier = (value) => {
-  if (value === undefined || !Number.isFinite(value)) {
-    return DEFAULT_QUERY_MULTIPLIER;
-  }
-  return Math.min(MAX_QUERY_MULTIPLIER, Math.max(1, Math.floor(value)));
-};
-var normalizeMaxBackfills = (value) => {
-  if (value === undefined || !Number.isFinite(value)) {
-    return;
-  }
-  return Math.max(0, Math.floor(value));
-};
-var normalizeMinResults = (value, topK) => {
-  if (value === undefined || !Number.isFinite(value)) {
-    return topK;
-  }
-  return Math.min(topK, Math.max(1, Math.floor(value)));
-};
-var resolveFillTarget = (input) => {
-  const fillPolicy = input.fillPolicy ?? "satisfy_min_results";
-  return {
-    fillPolicy,
-    targetResults: fillPolicy === "strict_topk" ? input.topK : input.minResults
-  };
-};
-var toQualifiedTableName = (schemaName, tableName) => `${schemaName}.${tableName}`;
-var toVectorLiteral = (vector) => `[${vector.join(",")}]`;
-var parseMetadata = (value) => {
-  if (typeof value === "string") {
-    try {
-      const parsed = JSON.parse(value);
-      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-        return parsed;
-      }
-    } catch {
-      return;
-    }
-  }
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return;
-  }
-  return value;
-};
-var parseVectorText = (value) => {
-  if (!value) {
-    return [];
-  }
-  const normalized = value.trim();
-  const wrapped = normalized.startsWith("[") ? normalized : `[${normalized.replace(/[()]/g, "")}]`;
-  try {
-    const parsed = JSON.parse(wrapped);
-    return Array.isArray(parsed) ? parsed.filter((entry) => typeof entry === "number" && Number.isFinite(entry)) : [];
-  } catch {
-    return [];
-  }
-};
-var parseCountValue = (value) => {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value === "bigint") {
-    return Number(value);
-  }
-  if (typeof value === "string") {
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? parsed : 0;
-  }
-  return 0;
-};
-var parseBooleanValue = (value) => {
-  if (typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value === "number") {
-    return value !== 0;
-  }
-  if (typeof value === "bigint") {
-    return value !== 0n;
-  }
-  if (typeof value === "string") {
-    const normalized = value.trim().toLowerCase();
-    return normalized === "true" || normalized === "t" || normalized === "1";
-  }
-  return false;
-};
-var refreshPostgresRuntimeDiagnostics = async (db, nativeDiagnostics, input) => {
-  try {
-    const rows = await db.unsafe(`select
-				c.reltuples::bigint as estimated_row_count,
-				pg_relation_size($1::regclass) as table_bytes,
-				pg_indexes_size($1::regclass) as index_bytes,
-				pg_total_relation_size($1::regclass) as total_bytes,
-				exists(
-					select 1
-					from pg_indexes
-					where schemaname = $2
-					  and tablename = $3
-					  and indexname = $4
-				) as index_present
-			from pg_class c
-			join pg_namespace n on n.oid = c.relnamespace
-			where n.nspname = $2
-			  and c.relname = $3
-			limit 1`, [
-      input.qualifiedTableName,
-      input.schemaName,
-      input.tableName,
-      input.indexName ?? ""
-    ]);
-    const row = rows[0];
-    nativeDiagnostics.indexName = input.indexName;
-    nativeDiagnostics.indexPresent = input.indexName ? parseBooleanValue(row?.index_present) : undefined;
-    nativeDiagnostics.estimatedRowCount = parseCountValue(row?.estimated_row_count);
-    nativeDiagnostics.tableBytes = parseCountValue(row?.table_bytes);
-    nativeDiagnostics.indexBytes = parseCountValue(row?.index_bytes);
-    nativeDiagnostics.totalBytes = parseCountValue(row?.total_bytes);
-    nativeDiagnostics.lastHealthCheckAt = Date.now();
-    nativeDiagnostics.lastHealthError = undefined;
-  } catch (error) {
-    nativeDiagnostics.lastHealthCheckAt = Date.now();
-    nativeDiagnostics.lastHealthError = error instanceof Error ? error.message : String(error);
-  }
-};
-var analyzePostgresTable = async (db, nativeDiagnostics, input) => {
-  try {
-    await db.unsafe(`analyze ${input.qualifiedTableName}`);
-    nativeDiagnostics.lastAnalyzeAt = Date.now();
-    nativeDiagnostics.lastAnalyzeError = undefined;
-    await refreshPostgresRuntimeDiagnostics(db, nativeDiagnostics, input);
-  } catch (error) {
-    nativeDiagnostics.lastAnalyzeAt = Date.now();
-    nativeDiagnostics.lastAnalyzeError = error instanceof Error ? error.message : String(error);
-    throw error;
-  }
-};
-var rebuildPostgresNativeIndex = async (db, nativeDiagnostics, input) => {
-  if (!input.indexName || input.indexType === "none") {
-    throw new Error("Postgres native index rebuild is not configured");
-  }
-  try {
-    await db.unsafe(`drop index if exists ${input.indexName}`);
-    await db.unsafe(buildPostgresIndexSql({
-      distanceMetric: input.distanceMetric,
-      hnswEfConstruction: input.hnswEfConstruction,
-      hnswM: input.hnswM,
-      ifNotExists: false,
-      indexLists: input.indexLists,
-      indexType: input.indexType,
-      qualifiedTableName: input.qualifiedTableName
-    }));
-    nativeDiagnostics.lastReindexAt = Date.now();
-    nativeDiagnostics.lastReindexError = undefined;
-    await analyzePostgresTable(db, nativeDiagnostics, input);
-  } catch (error) {
-    nativeDiagnostics.lastReindexAt = Date.now();
-    nativeDiagnostics.lastReindexError = error instanceof Error ? error.message : String(error);
-    throw error;
-  }
-};
-var getPostgresChunkIdsByChunkIds = async (db, qualifiedTableName, chunkIds) => {
-  const normalized = [...new Set(chunkIds)].filter((chunkId) => chunkId.length > 0);
-  if (normalized.length === 0) {
-    return [];
-  }
-  const placeholders = normalized.map((_, index) => `$${index + 1}`).join(", ");
-  const rows = await db.unsafe(`select chunk_id from ${qualifiedTableName} where chunk_id in (${placeholders})`, normalized);
-  return rows.map((row) => row.chunk_id).filter((chunkId) => typeof chunkId === "string");
-};
-var getPostgresCandidateChunkIdsByFilter = async (db, qualifiedTableName, filter) => {
-  if (!filter || Object.keys(filter).length === 0) {
-    return [];
-  }
-  const pushdownFilter = buildPostgresPushdownFilter(filter);
-  const filterPlan = buildPostgresFilterPlan(pushdownFilter);
-  const rowsSql = filterPlan?.clause ? `select chunk_id, text, title, source, metadata from ${qualifiedTableName} where ${filterPlan.clause}` : `select chunk_id, text, title, source, metadata from ${qualifiedTableName}`;
-  const rows = await db.unsafe(rowsSql, filterPlan?.clause ? filterPlan.params ?? [] : []);
-  const chunks = rows.map((row) => mapRowToChunk(row)).filter((chunk) => matchesFilter(chunk, filter));
-  return chunks.map((chunk) => chunk.chunkId);
-};
-var getPostgresCandidateChunkIds = async (db, qualifiedTableName, input) => {
-  const chunkIdSet = new Set;
-  if (input.filter && Object.keys(input.filter).length > 0) {
-    for (const chunkId of await getPostgresCandidateChunkIdsByFilter(db, qualifiedTableName, input.filter)) {
-      chunkIdSet.add(chunkId);
-    }
-  }
-  if (input.chunkIds && input.chunkIds.length > 0) {
-    for (const chunkId of await getPostgresChunkIdsByChunkIds(db, qualifiedTableName, input.chunkIds)) {
-      chunkIdSet.add(chunkId);
-    }
-  }
-  return [...chunkIdSet];
-};
-var normalizeDistance = (distance, metric) => {
-  if (!Number.isFinite(distance)) {
-    return 0;
-  }
-  if (metric === "cosine") {
-    return Math.min(1, Math.max(0, 1 - distance));
-  }
-  if (metric === "inner_product") {
-    return Math.max(0, -distance);
-  }
-  return Math.max(0, 1 / (1 + Math.abs(distance)));
-};
-var getDistanceOperator = (metric) => metric === "cosine" ? "<=>" : metric === "inner_product" ? "<#>" : "<->";
-var createPostgresStatus = (dimensions, nativeDiagnostics) => ({
-  backend: "postgres",
-  dimensions,
-  native: nativeDiagnostics,
-  vectorMode: "native_pgvector"
-});
-var createPostgresCapabilities = () => ({
-  backend: "postgres",
-  nativeVectorSearch: true,
-  persistence: "external",
-  serverSideFiltering: true,
-  streamingIngestStatus: false
-});
-var updatePostgresLastQueryPlan = (input) => {
-  const pushdown = resolvePostgresPushdownMode({
-    filter: input.filter,
-    pushdownFilter: input.pushdownFilter
-  });
-  input.nativeDiagnostics.lastQueryPlan = {
-    backfillCount: input.backfillCount,
-    candidateBudgetExhausted: input.candidateBudgetExhausted,
-    candidateCoverage: summarizeSQLiteCandidateCoverage({
-      filteredCandidateCount: input.filteredCandidateCount,
-      returnedCount: input.returnedCount,
-      topK: input.topK
-    }),
-    filteredCandidateCount: input.filteredCandidateCount,
-    finalSearchK: input.finalSearchK,
-    initialSearchK: input.initialSearchK,
-    searchExpansionRatio: typeof input.initialSearchK === "number" && typeof input.finalSearchK === "number" && input.initialSearchK > 0 ? input.finalSearchK / input.initialSearchK : undefined,
-    candidateLimitUsed: input.candidateLimitUsed,
-    maxBackfillsUsed: input.maxBackfillsUsed,
-    minResultsUsed: input.minResultsUsed,
-    fillPolicyUsed: input.fillPolicyUsed,
-    plannerProfileUsed: input.plannerProfileUsed,
-    jsRemainderClauseCount: pushdown.jsRemainderClauseCount,
-    queryMultiplierUsed: input.queryMultiplierUsed,
-    jsRemainderRatio: pushdown.jsRemainderRatio,
-    pushdownApplied: pushdown.pushdownClauseCount > 0,
-    pushdownClauseCount: pushdown.pushdownClauseCount,
-    pushdownCoverageRatio: pushdown.pushdownCoverageRatio,
-    pushdownMode: pushdown.pushdownMode,
-    queryMode: "native_pgvector",
-    candidateYieldRatio: typeof input.returnedCount === "number" && typeof input.finalSearchK === "number" && input.finalSearchK > 0 ? input.returnedCount / input.finalSearchK : undefined,
-    returnedCount: input.returnedCount,
-    backfillLimitReached: input.backfillLimitReached,
-    minResultsSatisfied: input.minResultsSatisfied,
-    topKFillRatio: typeof input.returnedCount === "number" && input.topK > 0 ? input.returnedCount / input.topK : undefined,
-    totalFilterClauseCount: pushdown.totalFilterClauseCount,
-    underfilledTopK: input.underfilledTopK
-  };
-};
-var matchesFilter = (record, filter) => matchesMetadataFilterRecord({
-  chunkId: record.chunkId,
-  metadata: record.metadata,
-  source: record.source,
-  title: record.title,
-  ...record.metadata ?? {}
-}, filter);
-var mapRowToChunk = (row) => ({
-  chunkId: row.chunk_id,
-  metadata: parseMetadata(row.metadata),
-  source: row.source ?? undefined,
-  text: row.text,
-  title: row.title ?? undefined,
-  vector: parseVectorText(row.embedding)
-});
-var ensurePostgresSchema = async (db, input) => {
-  await db.unsafe("create extension if not exists vector");
-  const [schemaName] = input.qualifiedTableName.split(".");
-  if (schemaName) {
-    await db.unsafe(`create schema if not exists ${schemaName}`);
-  }
-  await db.unsafe(`
-		create table if not exists ${input.qualifiedTableName} (
-			chunk_id text primary key,
-			text text not null,
-			title text,
-			source text,
-			metadata jsonb,
-			embedding vector(${input.dimensions}) not null
-		)
-	`);
-  const indexSql = buildPostgresIndexSql(input);
-  if (indexSql) {
-    await db.unsafe(indexSql);
-  }
-};
-var createPostgresRAGStore = (options = {}) => {
-  const dimensions = options.dimensions ?? DEFAULT_DIMENSIONS;
-  const distanceMetric = options.distanceMetric ?? "cosine";
-  const queryMultiplier = normalizeQueryMultiplier(options.queryMultiplier);
-  const indexType = normalizePostgresIndexType(options.indexType);
-  const indexLists = normalizePositiveInteger(options.indexLists, DEFAULT_POSTGRES_IVFFLAT_LISTS);
-  const hnswM = normalizePositiveInteger(options.hnswM, DEFAULT_POSTGRES_HNSW_M);
-  const hnswEfConstruction = normalizePositiveInteger(options.hnswEfConstruction, DEFAULT_POSTGRES_HNSW_EF_CONSTRUCTION);
-  const tableName = options.tableName ?? DEFAULT_TABLE_NAME;
-  const schemaName = options.schemaName ?? DEFAULT_SCHEMA_NAME;
-  assertSupportedIdentifier2(tableName);
-  assertSupportedIdentifier2(schemaName);
-  const qualifiedTableName = toQualifiedTableName(schemaName, tableName);
-  const indexName = getPostgresIndexName(qualifiedTableName, indexType);
-  const db = options.sql ?? new Bun.SQL(options.connectionString ?? process.env.RAG_POSTGRES_URL ?? process.env.DATABASE_URL ?? "postgres://postgres:postgres@localhost:55433/absolute_rag_demo");
-  const nativeDiagnostics = {
-    active: true,
-    available: true,
-    distanceMetric,
-    extensionName: "vector",
-    indexName,
-    indexType,
-    mode: "pgvector",
-    requested: true,
-    schemaName,
-    tableName
-  };
-  const capabilities = createPostgresCapabilities();
-  const distanceOperator = getDistanceOperator(distanceMetric);
-  let initialized;
-  const init = () => {
-    initialized ??= ensurePostgresSchema(db, {
-      dimensions,
-      distanceMetric,
-      hnswEfConstruction,
-      hnswM,
-      indexLists,
-      indexType,
-      qualifiedTableName
-    }).then(() => refreshPostgresRuntimeDiagnostics(db, nativeDiagnostics, {
-      indexName,
-      qualifiedTableName,
-      schemaName,
-      tableName
-    })).catch((error) => {
-      nativeDiagnostics.active = false;
-      nativeDiagnostics.available = false;
-      nativeDiagnostics.lastInitError = error instanceof Error ? error.message : String(error);
-      nativeDiagnostics.lastMigrationError = error instanceof Error ? error.message : String(error);
-      nativeDiagnostics.fallbackReason = nativeDiagnostics.lastInitError;
-      throw error;
-    });
-    return initialized;
-  };
-  const embed = async (input) => {
-    input.model;
-    input.signal;
-    if (options.mockEmbedding) {
-      return options.mockEmbedding(input.text);
-    }
-    return normalizeVector(createRAGVector(input.text, dimensions));
-  };
-  const query = async (input) => {
-    await init();
-    const queryVector = normalizeVector(input.queryVector);
-    const queryMultiplier2 = normalizeQueryMultiplier(input.queryMultiplier ?? options.queryMultiplier);
-    const maxBackfills = normalizeMaxBackfills(input.maxBackfills);
-    const minResults = normalizeMinResults(input.minResults, input.topK);
-    const fillTarget = resolveFillTarget({
-      fillPolicy: input.fillPolicy,
-      minResults,
-      topK: input.topK
-    });
-    const queryVectorLiteral = toVectorLiteral(queryVector);
-    const pushdownFilter = buildPostgresPushdownFilter(input.filter);
-    const queryFilterPlan = buildPostgresFilterPlan(pushdownFilter);
-    const effectivePushdownFilter = queryFilterPlan ? pushdownFilter : undefined;
-    const countFilterPlan = queryFilterPlan;
-    const countSql = countFilterPlan?.clause ? `select count(*)::int as count from ${qualifiedTableName} where ${countFilterPlan.clause}` : `select count(*)::int as count from ${qualifiedTableName}`;
-    const totalRowsResult = await db.unsafe(countSql, countFilterPlan?.params ?? []);
-    nativeDiagnostics.lastFilterDebug = {
-      countParams: countFilterPlan?.params ?? [],
-      countResultRaw: totalRowsResult?.[0],
-      countSql,
-      filter: input.filter,
-      pushdownFilter: effectivePushdownFilter
-    };
-    const totalRows = parseCountValue(totalRowsResult?.[0]?.count);
-    const candidateLimit = resolveAdaptiveNativeCandidateLimit({
-      defaultCandidateLimit: RAG_NATIVE_QUERY_CANDIDATE_LIMIT,
-      explicitCandidateLimit: input.candidateLimit,
-      filteredCandidateCount: totalRows,
-      plannerProfile: input.plannerProfile,
-      queryMultiplier: queryMultiplier2,
-      topK: input.topK
-    });
-    const hasPushdownFilter = Boolean(effectivePushdownFilter);
-    const plannedFilteredCandidateCount = hasPushdownFilter && totalRows === 0 ? undefined : totalRows;
-    const initialSearchK = planNativeCandidateSearchK({
-      candidateLimit,
-      filteredCandidateCount: plannedFilteredCandidateCount,
-      queryMultiplier: queryMultiplier2,
-      topK: input.topK
-    });
-    if (initialSearchK === 0) {
-      return [];
-    }
-    let currentSearchK = initialSearchK;
-    let backfillCount = 0;
-    let candidateBudgetExhausted = false;
-    let backfillLimitReached = false;
-    let effectiveFilteredCandidateCount = plannedFilteredCandidateCount;
-    let mapped = [];
-    for (;; ) {
-      const rowsSql = queryFilterPlan?.clause ? `select chunk_id, text, title, source, metadata, embedding::text as embedding, embedding ${distanceOperator} '${queryVectorLiteral}'::vector as distance from ${qualifiedTableName} where ${queryFilterPlan.clause} order by embedding ${distanceOperator} '${queryVectorLiteral}'::vector limit $${queryFilterPlan.params.length + 1}` : `select chunk_id, text, title, source, metadata, embedding::text as embedding, embedding ${distanceOperator} '${queryVectorLiteral}'::vector as distance from ${qualifiedTableName} order by embedding ${distanceOperator} '${queryVectorLiteral}'::vector limit $1`;
-      const rows = await db.unsafe(rowsSql, queryFilterPlan?.clause ? [...queryFilterPlan.params ?? [], currentSearchK] : [currentSearchK]);
-      nativeDiagnostics.lastFilterDebug = {
-        ...nativeDiagnostics.lastFilterDebug,
-        queryParams: queryFilterPlan?.clause ? [...queryFilterPlan.params ?? [], currentSearchK] : [currentSearchK],
-        queryRowCount: rows.length,
-        querySql: rowsSql
-      };
-      if (hasPushdownFilter && effectiveFilteredCandidateCount === undefined && rows.length <= currentSearchK) {
-        effectiveFilteredCandidateCount = rows.length;
-      }
-      mapped = rows.map((row) => {
-        const chunk = mapRowToChunk(row);
-        return {
-          chunk,
-          score: normalizeDistance(Number(row.distance ?? 0), distanceMetric)
-        };
-      }).filter(({ chunk }) => matchesFilter(chunk, input.filter)).map((entry) => ({
-        chunkId: entry.chunk.chunkId,
-        chunkText: entry.chunk.text,
-        embedding: entry.chunk.vector,
-        metadata: entry.chunk.metadata,
-        score: entry.score,
-        source: entry.chunk.source,
-        title: entry.chunk.title
-      })).sort((left, right) => right.score - left.score);
-      if (mapped.length >= fillTarget.targetResults) {
-        break;
-      }
-      const nextSearchK = planNativeCandidateSearchBackfillK({
-        backfillCount,
-        candidateLimit,
-        currentSearchK,
-        filteredCandidateCount: effectiveFilteredCandidateCount,
-        maxBackfills
-      });
-      if (nextSearchK <= currentSearchK) {
-        backfillLimitReached = typeof maxBackfills === "number" && backfillCount >= maxBackfills && mapped.length < fillTarget.targetResults;
-        candidateBudgetExhausted = mapped.length < fillTarget.targetResults;
-        break;
-      }
-      currentSearchK = nextSearchK;
-      backfillCount += 1;
-    }
-    nativeDiagnostics.lastQueryError = undefined;
-    const returned = mapped.slice(0, input.topK);
-    updatePostgresLastQueryPlan({
-      backfillCount,
-      backfillLimitReached,
-      candidateBudgetExhausted,
-      candidateLimitUsed: candidateLimit,
-      maxBackfillsUsed: maxBackfills,
-      minResultsUsed: minResults,
-      fillPolicyUsed: fillTarget.fillPolicy,
-      plannerProfileUsed: input.plannerProfile,
-      filter: input.filter,
-      pushdownFilter: effectivePushdownFilter,
-      queryMultiplierUsed: queryMultiplier2,
-      filteredCandidateCount: effectiveFilteredCandidateCount,
-      finalSearchK: currentSearchK,
-      initialSearchK,
-      nativeDiagnostics,
-      minResultsSatisfied: returned.length >= minResults,
-      returnedCount: returned.length,
-      topK: input.topK,
-      underfilledTopK: returned.length < input.topK
-    });
-    return returned;
-  };
-  const queryLexical = async (input) => {
-    await init();
-    const pushdownFilter = buildPostgresPushdownFilter(input.filter);
-    const lexicalFilterPlan = buildPostgresFilterPlan(pushdownFilter);
-    const rowsSql = lexicalFilterPlan?.clause ? `select chunk_id, text, title, source, metadata from ${qualifiedTableName} where ${lexicalFilterPlan.clause}` : `select chunk_id, text, title, source, metadata from ${qualifiedTableName}`;
-    const rows = await db.unsafe(rowsSql, lexicalFilterPlan?.params ?? []);
-    const chunks = rows.map((row) => mapRowToChunk(row)).filter((chunk) => matchesFilter(chunk, input.filter));
-    const ranked = rankRAGLexicalMatches(input.query, chunks);
-    return ranked.slice(0, input.topK).map(({ result, score }) => ({
-      chunkId: result.chunkId,
-      chunkText: result.text,
-      metadata: result.metadata,
-      score,
-      source: result.source,
-      title: result.title
-    }));
-  };
-  const upsert = async (input) => {
-    await init();
-    const chunks = input.chunks.length > 0 ? await Promise.all(input.chunks.map(async (chunk) => ({
-      chunkId: chunk.chunkId,
-      metadata: chunk.metadata,
-      source: chunk.source,
-      text: chunk.text,
-      title: chunk.title,
-      vector: chunk.embedding ? normalizeVector(chunk.embedding) : normalizeVector(await embed({ text: chunk.text }))
-    }))) : [];
-    for (const chunk of chunks) {
-      await db.unsafe(`insert into ${qualifiedTableName} (chunk_id, text, title, source, metadata, embedding)
-				 values ($1, $2, $3, $4, $5::jsonb, $6::vector)
-				 on conflict (chunk_id) do update set
-				   text = excluded.text,
-				   title = excluded.title,
-				   source = excluded.source,
-				   metadata = excluded.metadata,
-				   embedding = excluded.embedding`, [
-        chunk.chunkId,
-        chunk.text,
-        chunk.title ?? null,
-        chunk.source ?? null,
-        chunk.metadata ?? null,
-        toVectorLiteral(chunk.vector)
-      ]);
-    }
-    await refreshPostgresRuntimeDiagnostics(db, nativeDiagnostics, {
-      indexName,
-      qualifiedTableName,
-      schemaName,
-      tableName
-    });
-  };
-  const count = async (input = {}) => {
-    await init();
-    const filter = input.filter;
-    const chunkIds = input.chunkIds;
-    const hasFilter = Boolean(filter && Object.keys(filter).length > 0);
-    const hasChunkIds = Boolean(chunkIds && chunkIds.length > 0);
-    if (!hasFilter && !hasChunkIds) {
-      const countResult = await db.unsafe(`select count(*)::int as count from ${qualifiedTableName}`);
-      return parseCountValue(countResult[0]?.count);
-    }
-    return (await getPostgresCandidateChunkIds(db, qualifiedTableName, {
-      filter,
-      chunkIds
-    })).length;
-  };
-  const remove = async (input = {}) => {
-    await init();
-    const filter = input.filter;
-    const chunkIds = input.chunkIds;
-    const hasFilter = Boolean(filter && Object.keys(filter).length > 0);
-    const hasChunkIds = Boolean(chunkIds && chunkIds.length > 0);
-    if (!hasFilter && !hasChunkIds) {
-      return 0;
-    }
-    const ids = await getPostgresCandidateChunkIds(db, qualifiedTableName, {
-      filter,
-      chunkIds
-    });
-    if (ids.length === 0) {
-      return 0;
-    }
-    const placeholders = ids.map((_, index) => `$${index + 1}`).join(", ");
-    await db.unsafe(`delete from ${qualifiedTableName} where chunk_id in (${placeholders})`, ids);
-    await refreshPostgresRuntimeDiagnostics(db, nativeDiagnostics, {
-      indexName,
-      qualifiedTableName,
-      schemaName,
-      tableName
-    });
-    return ids.length;
-  };
-  const clear = async () => {
-    await init();
-    await db.unsafe(`truncate table ${qualifiedTableName}`);
-    await refreshPostgresRuntimeDiagnostics(db, nativeDiagnostics, {
-      indexName,
-      qualifiedTableName,
-      schemaName,
-      tableName
-    });
-  };
-  const analyze = async () => {
-    await init();
-    await analyzePostgresTable(db, nativeDiagnostics, {
-      indexName,
-      qualifiedTableName,
-      schemaName,
-      tableName
-    });
-  };
-  const rebuildNativeIndex = async () => {
-    await init();
-    await rebuildPostgresNativeIndex(db, nativeDiagnostics, {
-      distanceMetric,
-      hnswEfConstruction,
-      hnswM,
-      indexLists,
-      indexName,
-      indexType,
-      qualifiedTableName,
-      schemaName,
-      tableName
-    });
-  };
-  const close = async () => {
-    await db.close?.();
-  };
-  return {
-    analyze,
-    clear,
-    close,
-    embed,
-    getCapabilities: () => capabilities,
-    getStatus: () => createPostgresStatus(dimensions, nativeDiagnostics),
-    query,
-    queryLexical,
-    rebuildNativeIndex: indexName ? rebuildNativeIndex : undefined,
-    count,
-    delete: remove,
-    upsert
-  };
-};
-// src/adapters/sqlite.ts
-import { Database } from "bun:sqlite";
-import { existsSync as existsSync2 } from "fs";
-
-// src/internal/resolveAbsoluteSQLiteVec.ts
-import { existsSync, readFileSync } from "fs";
-import { arch, platform } from "os";
-import { dirname as dirname5, join as join3 } from "path";
-var PLATFORM_PACKAGE_MAP = {
-  "darwin-arm64": {
-    libraryFile: "vec0.dylib",
-    packageName: "@absolutejs/absolute-rag-sqlite-darwin-arm64"
-  },
-  "darwin-x64": {
-    libraryFile: "vec0.dylib",
-    packageName: "@absolutejs/absolute-rag-sqlite-darwin-x64"
-  },
-  "linux-arm64": {
-    libraryFile: "vec0.so",
-    packageName: "@absolutejs/absolute-rag-sqlite-linux-arm64"
-  },
-  "linux-x64": {
-    libraryFile: "vec0.so",
-    packageName: "@absolutejs/absolute-rag-sqlite-linux-x64"
-  },
-  "win32-x64": {
-    libraryFile: "vec0.dll",
-    packageName: "@absolutejs/absolute-rag-sqlite-windows-x64"
-  }
-};
-var currentPlatformKey = () => `${platform()}-${arch()}`;
-var getErrorMessage = (error) => error instanceof Error ? error.message : String(error);
-var isPackageJsonShape = (value) => Boolean(value) && typeof value === "object";
-var readPackageVersion = (packageJsonPath) => {
-  try {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-    if (!isPackageJsonShape(packageJson)) {
-      return;
-    }
-    return typeof packageJson.version === "string" ? packageJson.version : undefined;
-  } catch {
-    return;
-  }
-};
-var resolveAbsoluteSQLiteVec = () => {
-  const platformKey = currentPlatformKey();
-  const packageInfo = PLATFORM_PACKAGE_MAP[platformKey];
-  if (!packageInfo) {
-    return {
-      platformKey,
-      reason: `No AbsoluteJS sqlite-vec package is defined for ${platformKey}.`,
-      source: "absolute-package",
-      status: "unsupported_platform"
-    };
-  }
-  try {
-    const resolve4 = import.meta.resolve;
-    if (typeof resolve4 !== "function") {
-      throw new Error("AbsoluteJS sqlite-vec package resolution requires import.meta.resolve support.");
-    }
-    const packageJsonPath = new URL(resolve4(`${packageInfo.packageName}/package.json`)).pathname;
-    const packageRoot = dirname5(packageJsonPath);
-    const libraryPath = join3(packageRoot, packageInfo.libraryFile);
-    const packageVersion = readPackageVersion(packageJsonPath);
-    if (!existsSync(libraryPath)) {
-      return {
-        libraryFile: packageInfo.libraryFile,
-        libraryPath,
-        packageName: packageInfo.packageName,
-        packageRoot,
-        packageVersion,
-        platformKey,
-        reason: `Resolved ${packageInfo.packageName} but ${packageInfo.libraryFile} was not found.`,
-        source: "absolute-package",
-        status: "binary_missing"
-      };
-    }
-    return {
-      libraryFile: packageInfo.libraryFile,
-      libraryPath,
-      packageName: packageInfo.packageName,
-      packageRoot,
-      packageVersion,
-      platformKey,
-      source: "absolute-package",
-      status: "resolved"
-    };
-  } catch (error) {
-    return {
-      libraryFile: packageInfo.libraryFile,
-      packageName: packageInfo.packageName,
-      platformKey,
-      reason: getErrorMessage(error),
-      source: "absolute-package",
-      status: "package_not_installed"
-    };
-  }
-};
-var resolveAbsoluteSQLiteVecExtensionPath = () => {
-  const resolution = resolveAbsoluteSQLiteVec();
-  return resolution.status === "resolved" ? resolution.libraryPath ?? null : null;
-};
-
-// src/adapters/sqlite.ts
-var DEFAULT_DIMENSIONS2 = RAG_VECTOR_DIMENSIONS_DEFAULT;
-var DEFAULT_TABLE_NAME2 = "rag_chunks";
-var DEFAULT_NATIVE_TABLE_SUFFIX = "_vec0";
-var DEFAULT_QUERY_MULTIPLIER2 = 4;
-var MAX_QUERY_MULTIPLIER2 = 16;
-var IDENTIFIER_RE2 = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-var isParsedMetadata = (value) => Boolean(value) && typeof value === "object";
-var isObjectRecord5 = (value) => Boolean(value) && typeof value === "object";
-var isStoredRow = (value) => isObjectRecord5(value) && typeof value.chunk_id === "string" && typeof value.text === "string" && (typeof value.title === "string" || value.title === null) && (typeof value.source === "string" || value.source === null) && (typeof value.metadata === "string" || value.metadata === null) && typeof value.embedding === "string";
-var isNativeStoredRow = (value) => isObjectRecord5(value) && typeof value.chunk_id === "string" && typeof value.chunk_text === "string" && (typeof value.title === "string" || value.title === null) && (typeof value.source === "string" || value.source === null) && (typeof value.metadata === "string" || value.metadata === null) && typeof value.embedding === "string" && typeof value.distance === "number";
-var toStoredRows = (value) => Array.isArray(value) ? value.filter((row) => isStoredRow(row)) : [];
-var toNativeStoredRows = (value) => Array.isArray(value) ? value.filter((row) => isNativeStoredRow(row)) : [];
-var createSQLiteStatus = (dimensions, nativeDiagnostics, useNative) => ({
-  backend: "sqlite",
-  dimensions,
-  native: nativeDiagnostics,
-  vectorMode: useNative ? "native_vec0" : "json_fallback"
-});
-var createSQLiteCapabilities = (useNative) => ({
-  backend: "sqlite",
-  nativeVectorSearch: useNative,
-  persistence: "embedded",
-  serverSideFiltering: useNative,
-  streamingIngestStatus: false
-});
-var assertSupportedIdentifier3 = (name) => {
-  if (!IDENTIFIER_RE2.test(name)) {
-    throw new Error(`Invalid table name "${name}". Only alphanumeric and underscore names are allowed.`);
-  }
-};
-var normalizeQueryMultiplier2 = (value) => {
-  if (value === undefined || !Number.isFinite(value)) {
-    return DEFAULT_QUERY_MULTIPLIER2;
-  }
-  const minMultiplier = Math.max(1, Math.floor(value));
-  return Math.min(minMultiplier, MAX_QUERY_MULTIPLIER2);
-};
-var normalizeMaxBackfills2 = (value) => {
-  if (value === undefined || !Number.isFinite(value)) {
-    return;
-  }
-  return Math.max(0, Math.floor(value));
-};
-var normalizeMinResults2 = (value, topK) => {
-  if (value === undefined || !Number.isFinite(value)) {
-    return topK;
-  }
-  return Math.min(topK, Math.max(1, Math.floor(value)));
-};
-var resolveFillTarget2 = (input) => {
-  const fillPolicy = input.fillPolicy ?? "satisfy_min_results";
-  return {
-    fillPolicy,
-    targetResults: fillPolicy === "strict_topk" ? input.topK : input.minResults
-  };
-};
-var toJSONString = (metadata) => metadata === undefined ? null : JSON.stringify(metadata);
-var parseMetadata2 = (value) => {
-  if (value === null) {
-    return;
-  }
-  try {
-    const parsed = JSON.parse(value);
-    if (isParsedMetadata(parsed)) {
-      return parsed;
-    }
-  } catch {}
-  return;
-};
-var parseVector = (value) => {
-  try {
-    const parsed = JSON.parse(value);
-    if (Array.isArray(parsed)) {
-      return parsed.filter((element) => typeof element === "number" && Number.isFinite(element));
-    }
-  } catch {}
-  return [];
-};
-var toSQLiteFilterBinding = (value) => value === null || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean" ? value : undefined;
-var FILTER_PATH_SEGMENT_RE2 = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-var isObjectFilterRecord2 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
-var isOperatorFilterRecord2 = (value) => isObjectFilterRecord2(value) && Object.keys(value).some((key) => key.startsWith("$"));
-var isNestedFilterArray3 = (value) => Array.isArray(value) && value.every((entry) => isObjectFilterRecord2(entry));
-var toSQLiteJsonPath = (key) => {
-  const segments = key.split(".").filter(Boolean);
-  if (segments.length === 0 || !segments.every((segment) => FILTER_PATH_SEGMENT_RE2.test(segment))) {
-    return null;
-  }
-  return `$.${segments.join(".")}`;
-};
-var resolveSQLiteFilterColumn = (key, aliases) => {
-  if (key === "chunkId")
-    return { actualSql: aliases.chunkId, kind: "scalar" };
-  if (key === "source")
-    return { actualSql: aliases.source, kind: "scalar" };
-  if (key === "title")
-    return { actualSql: aliases.title, kind: "scalar" };
-  const path = toSQLiteJsonPath(key);
-  if (!path) {
-    return null;
-  }
-  return {
-    actualSql: `json_extract(${aliases.metadata}, ?)`,
-    kind: "metadata",
-    path
-  };
-};
-var buildSQLiteScalarClause = (actualSql, expected, params) => {
-  if (!isOperatorFilterRecord2(expected)) {
-    const binding = toSQLiteFilterBinding(expected);
-    if (binding === undefined) {
-      return null;
-    }
-    params.push(binding);
-    return `${actualSql} = ?`;
-  }
-  const clauses = [];
-  for (const [operator, value] of Object.entries(expected)) {
-    switch (operator) {
-      case "$exists":
-        clauses.push(Boolean(value) ? `${actualSql} IS NOT NULL` : `${actualSql} IS NULL`);
-        break;
-      case "$ne":
-        const neBinding = toSQLiteFilterBinding(value);
-        if (neBinding === undefined) {
-          return null;
-        }
-        params.push(neBinding);
-        clauses.push(`(${actualSql} IS NULL OR ${actualSql} != ?)`);
-        break;
-      case "$in":
-        if (!Array.isArray(value) || value.length === 0 || value.some((entry) => toSQLiteFilterBinding(entry) === undefined)) {
-          return null;
-        }
-        params.push(...value);
-        clauses.push(`${actualSql} IN (${value.map(() => "?").join(", ")})`);
-        break;
-      case "$gt":
-      case "$gte":
-      case "$lt":
-      case "$lte": {
-        if (typeof value !== "number" || !Number.isFinite(value)) {
-          return null;
-        }
-        params.push(value);
-        const comparison = operator === "$gt" ? ">" : operator === "$gte" ? ">=" : operator === "$lt" ? "<" : "<=";
-        clauses.push(`${actualSql} ${comparison} ?`);
-        break;
-      }
-      default:
-        return null;
-    }
-  }
-  return clauses.length > 0 ? clauses.map((clause) => `(${clause})`).join(" AND ") : null;
-};
-var buildSQLiteArrayClause = (metadataSql, path, expected, params) => {
-  if (!isOperatorFilterRecord2(expected)) {
-    return null;
-  }
-  const arrayTypeClause = `json_type(${metadataSql}, ?) = 'array'`;
-  const clauses = [];
-  for (const [operator, value] of Object.entries(expected)) {
-    switch (operator) {
-      case "$contains":
-        const containsBinding = toSQLiteFilterBinding(value);
-        if (containsBinding === undefined) {
-          return null;
-        }
-        params.push(path, path, containsBinding);
-        clauses.push(`(${arrayTypeClause} AND EXISTS (SELECT 1 FROM json_each(json_extract(${metadataSql}, ?)) WHERE json_each.value = ?))`);
-        break;
-      case "$containsAny":
-        if (!Array.isArray(value) || value.length === 0 || value.some((entry) => toSQLiteFilterBinding(entry) === undefined)) {
-          return null;
-        }
-        params.push(path, path, ...value);
-        clauses.push(`(${arrayTypeClause} AND EXISTS (SELECT 1 FROM json_each(json_extract(${metadataSql}, ?)) WHERE json_each.value IN (${value.map(() => "?").join(", ")})))`);
-        break;
-      case "$containsAll":
-        if (!Array.isArray(value) || value.length === 0 || value.some((entry) => toSQLiteFilterBinding(entry) === undefined)) {
-          return null;
-        }
-        clauses.push(...value.map((entry) => {
-          params.push(path, path, entry);
-          return `(${arrayTypeClause} AND EXISTS (SELECT 1 FROM json_each(json_extract(${metadataSql}, ?)) WHERE json_each.value = ?))`;
-        }));
-        break;
-      default:
-        return null;
-    }
-  }
-  return clauses.length > 0 ? clauses.map((clause) => `(${clause})`).join(" AND ") : null;
-};
-var buildSQLiteMetadataScalarMatchClause = (metadataSql, actualSql, path, expected, params) => {
-  const binding = toSQLiteFilterBinding(expected);
-  if (binding === undefined) {
-    return null;
-  }
-  params.push(path, binding, path, path, binding);
-  return `(${actualSql} = ? OR (json_type(${metadataSql}, ?) = 'array' AND EXISTS (SELECT 1 FROM json_each(json_extract(${metadataSql}, ?)) WHERE json_each.value = ?)))`;
-};
-var buildSQLiteFilterPlan = (filter, aliases) => {
-  if (!filter) {
-    return { clause: "", params: [] };
-  }
-  const params = [];
-  const build = (entry) => {
-    const clauses = [];
-    for (const [key, value] of Object.entries(entry)) {
-      if (key === "$and" || key === "$or") {
-        if (!isNestedFilterArray3(value) || value.length === 0) {
-          return null;
-        }
-        const nested = value.map((item) => build(item));
-        if (nested.some((item) => item === null)) {
-          return null;
-        }
-        clauses.push(`(${nested.filter((item) => Boolean(item)).join(key === "$and" ? " AND " : " OR ")})`);
-        continue;
-      }
-      if (key === "$not") {
-        if (!isObjectFilterRecord2(value)) {
-          return null;
-        }
-        const nested = build(value);
-        if (!nested) {
-          return null;
-        }
-        clauses.push(`NOT (${nested})`);
-        continue;
-      }
-      const resolved = resolveSQLiteFilterColumn(key, aliases);
-      if (!resolved) {
-        return null;
-      }
-      if (resolved.kind === "metadata") {
-        const metadataScalarClause = buildSQLiteMetadataScalarMatchClause(aliases.metadata, resolved.actualSql, resolved.path, value, params);
-        if (metadataScalarClause) {
-          clauses.push(metadataScalarClause);
-          continue;
-        }
-        const arrayClause = buildSQLiteArrayClause(aliases.metadata, resolved.path, value, params);
-        if (arrayClause) {
-          clauses.push(arrayClause);
-          continue;
-        }
-        params.push(resolved.path);
-      }
-      const scalarClause = buildSQLiteScalarClause(resolved.actualSql, value, params);
-      if (!scalarClause) {
-        return null;
-      }
-      clauses.push(scalarClause);
-    }
-    return clauses.length > 0 ? clauses.map((clause2) => `(${clause2})`).join(" AND ") : "";
-  };
-  const clause = build(filter);
-  return clause === null ? null : { clause, params };
-};
-var buildSQLitePushdownFilter = (filter) => {
-  if (!filter) {
-    return;
-  }
-  const nextEntries = [];
-  for (const [key, value] of Object.entries(filter)) {
-    if (key === "$and" || key === "$or") {
-      if (!isNestedFilterArray3(value)) {
-        continue;
-      }
-      const nested = value.map((entry) => buildSQLitePushdownFilter(entry)).filter((entry) => Boolean(entry));
-      if (nested.length > 0) {
-        nextEntries.push([key, nested]);
-      }
-      continue;
-    }
-    if (key === "$not") {
-      if (!isObjectFilterRecord2(value)) {
-        continue;
-      }
-      const nested = buildSQLitePushdownFilter(value);
-      if (nested) {
-        nextEntries.push([key, nested]);
-      }
-      continue;
-    }
-    if (Array.isArray(value) || isOperatorFilterRecord2(value) && Object.keys(value).some((operator) => operator === "$contains" || operator === "$containsAny" || operator === "$containsAll")) {
-      continue;
-    }
-    nextEntries.push([key, value]);
-  }
-  return nextEntries.length > 0 ? Object.fromEntries(nextEntries) : undefined;
-};
-var normalizeDistance2 = (distance, metric) => {
-  if (!Number.isFinite(distance)) {
-    return 0;
-  }
-  if (metric === "cosine") {
-    return Math.min(1, Math.max(0, 1 - distance));
-  }
-  return Math.max(0, 1 / (1 + Math.abs(distance)));
-};
-var matchesFilter2 = (record, filter) => matchesMetadataFilterRecord({
-  chunkId: record.chunkId,
-  metadata: record.metadata,
-  source: record.source,
-  title: record.title,
-  ...record.metadata ?? {}
-}, filter);
-var mapFilterToRows = (rows) => rows.map((row) => ({
-  chunkId: row.chunk_id,
-  metadata: parseMetadata2(row.metadata),
-  source: row.source ?? undefined,
-  text: row.text,
-  title: row.title ?? undefined,
-  vector: parseVector(row.embedding)
-}));
-var buildJsonQuerySql = (tableName, whereClause) => `
-	SELECT chunk_id, text, title, source, metadata, embedding FROM ${tableName}
-	${whereClause ? `WHERE ${whereClause}` : ""}
-`;
-var buildJsonCountSql = (tableName, whereClause) => `
-	SELECT COUNT(*) AS count FROM ${tableName}
-	${whereClause ? `WHERE ${whereClause}` : ""}
-`;
-var getChunkCountFromSql = (db, sql, params = []) => {
-  const result = db.prepare(sql).get(...params);
-  const count = result?.count;
-  return typeof count === "number" && Number.isFinite(count) ? count : 0;
-};
-var getPragmaNumericValue = (db, pragma) => {
-  const row = db.prepare(`PRAGMA ${pragma}`).get();
-  const value = row ? row[Object.keys(row)[0] ?? ""] : undefined;
-  return typeof value === "number" && Number.isFinite(value) ? value : 0;
-};
-var refreshSQLiteRuntimeDiagnostics = (db, nativeDiagnostics, diagnosticTableName) => {
-  if (!nativeDiagnostics) {
-    return;
-  }
-  try {
-    const rowCount = getChunkCountFromSql(db, buildJsonCountSql(diagnosticTableName));
-    const pageCount = getPragmaNumericValue(db, "page_count");
-    const pageSize = getPragmaNumericValue(db, "page_size");
-    const freelistCount = getPragmaNumericValue(db, "freelist_count");
-    nativeDiagnostics.rowCount = rowCount;
-    nativeDiagnostics.pageCount = pageCount;
-    nativeDiagnostics.freelistCount = freelistCount;
-    nativeDiagnostics.databaseBytes = pageCount > 0 && pageSize > 0 ? pageCount * pageSize : 0;
-    nativeDiagnostics.lastHealthCheckAt = Date.now();
-    nativeDiagnostics.lastHealthError = undefined;
-  } catch (error) {
-    nativeDiagnostics.lastHealthCheckAt = Date.now();
-    nativeDiagnostics.lastHealthError = getErrorMessage2(error);
-  }
-};
-var buildNativeQuerySql = (tableName, whereClause) => `
-	SELECT
-		chunk_id,
-		embedding,
-		chunk_text,
-		title,
-		source,
-		metadata,
-		distance
-	FROM ${tableName}
-	WHERE embedding MATCH vec_f32(?)
-		AND k = ?
-		${whereClause ? `AND (${whereClause})` : ""}
-	ORDER BY distance
-`;
-var getFilteredSQLiteCandidateCount = (db, tableName, filterPlan) => {
-  if (!filterPlan) {
-    return;
-  }
-  const result = db.prepare(buildJsonCountSql(tableName, filterPlan.clause)).get(...filterPlan.params);
-  const count = result?.count;
-  return typeof count === "number" && Number.isFinite(count) ? count : undefined;
-};
-var createJsonStatements = (db, tableName) => {
-  const insertSql = `
-		INSERT INTO ${tableName} (
-			chunk_id,
-			text,
-			title,
-			source,
-			metadata,
-			embedding
-		) VALUES (?, ?, ?, ?, ?, ?)
-		ON CONFLICT(chunk_id) DO UPDATE SET
-			text = excluded.text,
-			title = excluded.title,
-			source = excluded.source,
-			metadata = excluded.metadata,
-			embedding = excluded.embedding
-	`;
-  const querySql = `
-		SELECT chunk_id, text, title, source, metadata, embedding FROM ${tableName}
-	`;
-  const clearSql = `DELETE FROM ${tableName}`;
-  const deleteSql = `DELETE FROM ${tableName} WHERE chunk_id = ?`;
-  const init = () => db.exec(`
-			CREATE TABLE IF NOT EXISTS ${tableName} (
-				chunk_id TEXT PRIMARY KEY,
-				text TEXT NOT NULL,
-				title TEXT,
-				source TEXT,
-				metadata TEXT,
-				embedding TEXT NOT NULL
-			)
-		`);
-  init();
-  return {
-    clear: db.prepare(clearSql),
-    delete: db.prepare(deleteSql),
-    init,
-    insert: db.prepare(insertSql),
-    query: db.prepare(querySql)
-  };
-};
-var getSQLiteChunkIdsByChunkIds = (db, tableName, chunkIds) => {
-  const uniqueChunkIds = [...new Set(chunkIds)];
-  if (uniqueChunkIds.length === 0) {
-    return [];
-  }
-  const whereClause = uniqueChunkIds.map(() => "?").join(", ");
-  const rows = db.prepare(`SELECT chunk_id FROM ${tableName} WHERE chunk_id IN (${whereClause})`).all(...uniqueChunkIds);
-  return rows.map((row) => row.chunk_id).filter((chunkId) => typeof chunkId === "string");
-};
-var getSQLiteCandidateChunkIdsByFilter = (db, tableName, filter, jsonStatements) => {
-  if (!filter || Object.keys(filter).length === 0) {
-    return [];
-  }
-  const pushdownFilter = buildSQLitePushdownFilter(filter);
-  const filterPlan = buildSQLiteFilterPlan(pushdownFilter, {
-    chunkId: "chunk_id",
-    metadata: "metadata",
-    source: "source",
-    title: "title"
+// src/adapters/sync.ts
+import {
+  createSyncEngine,
+  createTextIndex,
+  createVectorIndex,
+  defineSearchCollection
+} from "@absolutejs/sync/engine";
+var createSyncRAGStore = (options = {}) => {
+  const dimensions = options.dimensions ?? RAG_VECTOR_DIMENSIONS_DEFAULT;
+  const engine = options.engine ?? createSyncEngine();
+  const retrievalCollection = options.collection ?? "ragRetrieval";
+  const table = options.table ?? "ragChunks";
+  const records = new Map;
+  const toLight = (record) => ({
+    chunkId: record.chunkId,
+    chunkText: record.text,
+    source: record.source,
+    title: record.title
   });
-  const rawRows = toStoredRows(filterPlan ? db.prepare(buildJsonQuerySql(tableName, filterPlan.clause)).all(...filterPlan.params) : jsonStatements.query.all());
-  const chunks = mapFilterToRows(rawRows);
-  return chunks.filter((chunk) => matchesFilter2(chunk, filter)).map((chunk) => chunk.chunkId);
-};
-var getSQLiteCandidateChunkIds = (db, tableName, jsonStatements, input) => {
-  const chunkIdSet = new Set;
-  if (input.filter && Object.keys(input.filter).length > 0) {
-    for (const chunkId of getSQLiteCandidateChunkIdsByFilter(db, tableName, input.filter, jsonStatements)) {
-      chunkIdSet.add(chunkId);
-    }
-  }
-  if (input.chunkIds && input.chunkIds.length > 0) {
-    for (const chunkId of getSQLiteChunkIdsByChunkIds(db, tableName, input.chunkIds)) {
-      chunkIdSet.add(chunkId);
-    }
-  }
-  return [...chunkIdSet];
-};
-var toVectorText = (vector) => JSON.stringify(vector);
-var createNativeVec0Table = (db, tableName, dimensions, metric) => {
-  const metricSuffix = metric === "cosine" ? " distance_metric=cosine" : "";
-  db.exec(`
-		CREATE VIRTUAL TABLE IF NOT EXISTS ${tableName} USING vec0(
-			chunk_id TEXT,
-			embedding float[${dimensions}]${metricSuffix},
-			+chunk_text TEXT,
-			title TEXT,
-			source TEXT,
-			metadata TEXT
-		)
-	`);
-};
-var createNativeVec0Statements = (db, tableName) => {
-  const upsertSql = `
-		INSERT INTO ${tableName} (
-			chunk_id,
-			embedding,
-			chunk_text,
-			title,
-			source,
-			metadata
-		) VALUES (?, vec_f32(?), ?, ?, ?, ?)
-	`;
-  const deleteSql = `DELETE FROM ${tableName} WHERE chunk_id = ?`;
-  const querySql = `
-		SELECT
-			chunk_id,
-			embedding,
-			chunk_text,
-			title,
-			source,
-			metadata,
-			distance
-		FROM ${tableName}
-		WHERE embedding MATCH vec_f32(?)
-			AND k = ?
-		ORDER BY distance
-	`;
-  return {
-    clear: db.prepare(`DELETE FROM ${tableName}`),
-    delete: db.prepare(deleteSql),
-    insert: db.prepare(upsertSql),
-    query: db.prepare(querySql)
-  };
-};
-var mapToRows = (vector, chunks, filter) => chunks.map((chunk) => ({
-  chunk,
-  score: querySimilarity(vector, normalizeVector(chunk.vector))
-})).filter(({ chunk }) => matchesFilter2(chunk, filter)).sort((left, right) => right.score - left.score);
-var executeNativeInitSql = (db, initSql) => {
-  if (!initSql) {
-    return;
-  }
-  if (typeof initSql === "string") {
-    db.exec(initSql);
-    return;
-  }
-  for (const command of initSql) {
-    db.exec(command);
-  }
-};
-var getErrorMessage2 = (error) => error instanceof Error ? error.message : String(error);
-var resolveConfiguredNativeExtension = (nativeConfig) => {
-  const platformKey = `${process.platform}-${process.arch}`;
-  if (nativeConfig?.extensionPath) {
-    return existsSync2(nativeConfig.extensionPath) ? {
-      libraryPath: nativeConfig.extensionPath,
-      platformKey,
-      source: "explicit",
-      status: "resolved"
-    } : {
-      libraryPath: nativeConfig.extensionPath,
-      platformKey,
-      reason: `Configured native.extensionPath was not found: ${nativeConfig.extensionPath}`,
-      source: "explicit",
-      status: "binary_missing"
-    };
-  }
-  if (nativeConfig?.resolveFromAbsolutePackages !== false) {
-    return resolveAbsolutePackageNativeExtension(platformKey);
-  }
-  const envResolution = resolveNativeExtensionFromEnv(platformKey);
-  if (envResolution)
-    return envResolution;
-  return {
-    platformKey,
-    reason: "No native sqlite-vec path was configured. AbsoluteJS will still attempt vec0 initialization in case the extension is already registered on the Database connection.",
-    source: "database",
-    status: "not_configured"
-  };
-};
-var describeNativeFallbackReason = (resolution) => {
-  if (!resolution) {
-    return "Native sqlite vec0 was not configured.";
-  }
-  switch (resolution.status) {
-    case "resolved":
-      return;
-    case "package_not_installed":
-      return `Install ${resolution.packageName ?? "@absolutejs/absolute-rag-sqlite"} for ${resolution.platformKey}, or provide native.extensionPath.`;
-    case "binary_missing":
-      return resolution.reason ?? "Resolved sqlite-vec binary was missing.";
-    case "unsupported_platform":
-      return resolution.reason ?? "This platform is not yet supported by AbsoluteJS sqlite-vec packages.";
-    case "not_configured":
-      return resolution.reason ?? "No sqlite-vec binary path was configured.";
-    case "package_invalid":
-      return resolution.reason ?? "The sqlite-vec package manifest was invalid.";
-    default:
-      return "Native sqlite vec0 could not be initialized.";
-  }
-};
-var resolveNativeExtensionFromEnv = (platformKey) => {
-  const envPath = process.env.SQLITE_VEC_EXTENSION_PATH;
-  if (!envPath) {
-    return null;
-  }
-  if (existsSync2(envPath)) {
-    return {
-      libraryPath: envPath,
-      platformKey,
-      source: "env",
-      status: "resolved"
-    };
-  }
-  return {
-    libraryPath: envPath,
-    platformKey,
-    reason: `SQLITE_VEC_EXTENSION_PATH was set but not found: ${envPath}`,
-    source: "env",
-    status: "binary_missing"
-  };
-};
-var shouldResolveNativeFromEnv = (resolution) => resolution.status === "binary_missing" || resolution.status === "package_not_installed" || resolution.status === "unsupported_platform";
-var resolveAbsolutePackageNativeExtension = (platformKey) => {
-  const packageResolution = resolveAbsoluteSQLiteVec();
-  if (!shouldResolveNativeFromEnv(packageResolution)) {
-    return packageResolution;
-  }
-  const envResolution = resolveNativeExtensionFromEnv(platformKey);
-  if (envResolution) {
-    return envResolution;
-  }
-  return packageResolution;
-};
-var activateNativeDiagnostics = (nativeDiagnostics) => {
-  if (!nativeDiagnostics) {
-    return;
-  }
-  nativeDiagnostics.available = true;
-  nativeDiagnostics.active = true;
-  nativeDiagnostics.fallbackReason = undefined;
-  if (nativeDiagnostics.resolution && nativeDiagnostics.resolution.status === "resolved") {
-    return;
-  }
-  nativeDiagnostics.resolution = {
-    platformKey: `${process.platform}-${process.arch}`,
-    reason: "sqlite-vec was already available on the Database connection or loaded by native.extensionInitSql.",
-    source: "database",
-    status: "resolved"
-  };
-};
-var loadNativeExtension = (db, nativeResolution) => {
-  if (nativeResolution?.status !== "resolved") {
-    return;
-  }
-  if (!nativeResolution.libraryPath) {
-    return;
-  }
-  db.loadExtension(nativeResolution.libraryPath);
-};
-var markNativeLoadFailure = (nativeDiagnostics, error, nativeResolution) => {
-  if (!nativeDiagnostics) {
-    return;
-  }
-  nativeDiagnostics.available = false;
-  nativeDiagnostics.active = false;
-  nativeDiagnostics.lastLoadError = getErrorMessage2(error);
-  nativeDiagnostics.fallbackReason = describeNativeFallbackReason(nativeResolution) ?? nativeDiagnostics.lastLoadError;
-};
-var markNativeQueryFailure = (nativeDiagnostics, error) => {
-  if (!nativeDiagnostics) {
-    return;
-  }
-  nativeDiagnostics.lastQueryError = getErrorMessage2(error);
-  nativeDiagnostics.active = false;
-  nativeDiagnostics.fallbackReason = nativeDiagnostics.lastQueryError;
-};
-var countFilterClauses2 = (filter) => {
-  if (!filter) {
-    return 0;
-  }
-  let count = 0;
-  for (const [key, value] of Object.entries(filter)) {
-    if (key === "$and" || key === "$or") {
-      if (isNestedFilterArray3(value)) {
-        count += value.reduce((total, entry) => total + countFilterClauses2(entry), 0);
-      }
-      continue;
-    }
-    if (key === "$not") {
-      if (isObjectFilterRecord2(value)) {
-        count += countFilterClauses2(value);
-      }
-      continue;
-    }
-    count += 1;
-  }
-  return count;
-};
-var resolveSQLitePushdownMode = (input) => {
-  const totalFilterClauseCount = countFilterClauses2(input.filter);
-  const pushdownClauseCount = countFilterClauses2(input.pushdownFilter);
-  const jsRemainderClauseCount = Math.max(0, totalFilterClauseCount - pushdownClauseCount);
-  const pushdownMode = pushdownClauseCount === 0 ? "none" : pushdownClauseCount >= totalFilterClauseCount ? "full" : "partial";
-  return {
-    jsRemainderClauseCount,
-    jsRemainderRatio: totalFilterClauseCount > 0 ? jsRemainderClauseCount / totalFilterClauseCount : undefined,
-    pushdownClauseCount,
-    pushdownCoverageRatio: totalFilterClauseCount > 0 ? pushdownClauseCount / totalFilterClauseCount : undefined,
-    pushdownMode,
-    totalFilterClauseCount
-  };
-};
-var updateSQLiteLastQueryPlan = (input) => {
-  if (!input.nativeDiagnostics) {
-    return;
-  }
-  const pushdown = resolveSQLitePushdownMode({
-    filter: input.filter,
-    pushdownFilter: input.pushdownFilter
+  const textIndex = createTextIndex({
+    fields: ["chunkText"],
+    key: (chunk) => chunk.chunkId
   });
-  input.nativeDiagnostics.lastQueryPlan = {
-    backfillCount: input.backfillCount,
-    candidateBudgetExhausted: input.candidateBudgetExhausted,
-    candidateCoverage: summarizeSQLiteCandidateCoverage({
-      filteredCandidateCount: input.filteredCandidateCount,
-      returnedCount: input.returnedCount,
-      topK: input.topK
-    }),
-    filteredCandidateCount: input.filteredCandidateCount,
-    finalSearchK: input.finalSearchK,
-    initialSearchK: input.initialSearchK,
-    searchExpansionRatio: typeof input.initialSearchK === "number" && typeof input.finalSearchK === "number" && input.initialSearchK > 0 ? input.finalSearchK / input.initialSearchK : undefined,
-    jsRemainderClauseCount: pushdown.jsRemainderClauseCount,
-    plannerProfileUsed: input.plannerProfileUsed,
-    candidateLimitUsed: input.candidateLimitUsed,
-    maxBackfillsUsed: input.maxBackfillsUsed,
-    minResultsUsed: input.minResultsUsed,
-    fillPolicyUsed: input.fillPolicyUsed,
-    queryMultiplierUsed: input.queryMultiplierUsed,
-    jsRemainderRatio: pushdown.jsRemainderRatio,
-    pushdownApplied: pushdown.pushdownClauseCount > 0,
-    pushdownClauseCount: pushdown.pushdownClauseCount,
-    pushdownCoverageRatio: pushdown.pushdownCoverageRatio,
-    pushdownMode: pushdown.pushdownMode,
-    queryMode: input.queryMode,
-    candidateYieldRatio: typeof input.returnedCount === "number" && typeof input.finalSearchK === "number" && input.finalSearchK > 0 ? input.returnedCount / input.finalSearchK : undefined,
-    returnedCount: input.returnedCount,
-    backfillLimitReached: input.backfillLimitReached,
-    minResultsSatisfied: input.minResultsSatisfied,
-    topKFillRatio: typeof input.returnedCount === "number" && input.topK > 0 ? input.returnedCount / input.topK : undefined,
-    totalFilterClauseCount: pushdown.totalFilterClauseCount,
-    underfilledTopK: input.underfilledTopK
-  };
-};
-var markNativeUpsertFailure = (nativeDiagnostics, error) => {
-  if (!nativeDiagnostics) {
-    return;
-  }
-  nativeDiagnostics.lastUpsertError = getErrorMessage2(error);
-  nativeDiagnostics.active = false;
-  nativeDiagnostics.fallbackReason = nativeDiagnostics.lastUpsertError;
-};
-var analyzeSQLiteBackend = (input) => {
-  try {
-    input.db.exec("PRAGMA optimize");
-    input.db.exec(`ANALYZE ${input.tableName}`);
-    input.nativeDiagnostics && (input.nativeDiagnostics.lastAnalyzeAt = Date.now());
-    if (input.nativeDiagnostics) {
-      input.nativeDiagnostics.lastAnalyzeError = undefined;
-    }
-    refreshSQLiteRuntimeDiagnostics(input.db, input.nativeDiagnostics, input.diagnosticTableName);
-  } catch (error) {
-    if (input.nativeDiagnostics) {
-      input.nativeDiagnostics.lastAnalyzeAt = Date.now();
-      input.nativeDiagnostics.lastAnalyzeError = getErrorMessage2(error);
-    }
-    throw error;
-  }
-};
-var initializeNativeBackend = (input) => {
-  const {
-    db,
-    dimensions,
-    nativeConfig,
-    nativeDiagnostics,
-    nativeDistanceMetric,
-    nativeResolution,
-    nativeTableName
-  } = input;
-  loadNativeExtension(db, nativeResolution);
-  executeNativeInitSql(db, nativeConfig.extensionInitSql);
-  createNativeVec0Table(db, nativeTableName, dimensions, nativeDistanceMetric);
-  const nativeStatements = createNativeVec0Statements(db, nativeTableName);
-  activateNativeDiagnostics(nativeDiagnostics);
-  return nativeStatements;
-};
-var createNativeInitializationError = (error, nativeTableName) => new Error(`Failed to initialize sqlite vec0 backend for table "${nativeTableName}". ` + `Install @absolutejs/absolute-rag-sqlite for your platform, set native.extensionPath, or pre-register the sqlite-vec extension in the Database connection. ` + `Details: ${getErrorMessage2(error)}`);
-var initializeNativeBackendSafely = (input) => {
-  const { nativeConfig, nativeDiagnostics, nativeResolution, nativeTableName } = input;
-  try {
-    return initializeNativeBackend(input);
-  } catch (error) {
-    markNativeLoadFailure(nativeDiagnostics, error, nativeResolution);
-    if (nativeConfig.requireAvailable) {
-      throw createNativeInitializationError(error, nativeTableName);
-    }
-    return;
-  }
-};
-var fallbackToJsonUpsert = (chunks, jsonStatements) => {
-  for (const chunk of chunks) {
-    jsonStatements.insert.run(chunk.chunkId, chunk.text, chunk.title ?? null, chunk.source ?? null, toJSONString(chunk.metadata), toVectorText(chunk.vector));
-  }
-};
-var upsertNativeChunks = (chunks, nativeStatements) => {
-  if (!nativeStatements) {
-    throw new Error("Native vector statements unavailable");
-  }
-  for (const chunk of chunks) {
-    nativeStatements.delete.run(chunk.chunkId);
-    nativeStatements.insert.run(chunk.chunkId, toVectorText(chunk.vector), chunk.text, chunk.title ?? null, chunk.source ?? null, toJSONString(chunk.metadata));
-  }
-};
-var createSQLiteRAGStore = (options = {}) => {
-  const dimensions = options.dimensions ?? DEFAULT_DIMENSIONS2;
-  const tableName = options.tableName ?? DEFAULT_TABLE_NAME2;
-  assertSupportedIdentifier3(tableName);
-  const nativeConfig = options.native;
-  const nativeTableName = nativeConfig?.tableName ?? `${tableName}${DEFAULT_NATIVE_TABLE_SUFFIX}`;
-  if (nativeConfig?.mode === "vec0" && nativeConfig.tableName) {
-    assertSupportedIdentifier3(nativeConfig.tableName);
-  }
-  if (!Number.isInteger(dimensions) || dimensions <= 0) {
-    throw new Error(`Invalid dimension "${dimensions}". dimensions must be a positive integer.`);
-  }
-  const db = options.db ?? new Database(options.path ?? ":memory:");
-  const nativeDistanceMetric = nativeConfig?.distanceMetric === "l2" ? "l2" : "cosine";
-  const nativeQueryMultiplier = normalizeQueryMultiplier2(nativeConfig?.queryMultiplier);
-  const nativeResolution = nativeConfig?.mode === "vec0" ? resolveConfiguredNativeExtension(nativeConfig) : undefined;
-  const nativeDiagnostics = nativeConfig?.mode === "vec0" ? {
-    active: false,
-    available: false,
-    distanceMetric: nativeDistanceMetric,
-    fallbackReason: describeNativeFallbackReason(nativeResolution),
-    mode: nativeConfig.mode,
-    requested: true,
-    resolution: nativeResolution,
-    tableName: nativeTableName
-  } : undefined;
-  const jsonStatements = createJsonStatements(db, tableName);
-  jsonStatements.init();
-  let useNative = false;
-  let nativeStatements;
-  if (nativeConfig?.mode === "vec0") {
-    nativeStatements = initializeNativeBackendSafely({
-      db,
-      dimensions,
-      nativeConfig,
-      nativeDiagnostics,
-      nativeDistanceMetric,
-      nativeResolution,
-      nativeTableName
-    });
-    useNative = nativeStatements !== undefined;
-  }
-  refreshSQLiteRuntimeDiagnostics(db, nativeDiagnostics, useNative ? nativeTableName : tableName);
+  const vectorIndex = createVectorIndex({
+    embedding: (chunk) => records.get(chunk.chunkId)?.vector ?? [],
+    key: (chunk) => chunk.chunkId
+  });
+  engine.registerSearch(defineSearchCollection({
+    index: () => textIndex,
+    key: (chunk) => chunk.chunkId,
+    name: retrievalCollection,
+    source: () => [...records.values()].map(toLight),
+    table
+  }));
   const embed = async (input) => {
-    input.model;
-    if (input.signal?.aborted) {
-      throw new DOMException("Aborted", "AbortError");
+    if (options.embedding) {
+      return options.embedding(input);
     }
     if (options.mockEmbedding) {
-      return options.mockEmbedding(input.text).then(normalizeVector);
+      return options.mockEmbedding(input.text);
     }
-    return normalizeVector([...createRAGVector(input.text, dimensions)]);
-  };
-  const queryFallback = async (input) => {
-    const queryVector = normalizeVector(input.queryVector);
-    const pushdownFilter = buildSQLitePushdownFilter(input.filter);
-    const filterPlan = buildSQLiteFilterPlan(pushdownFilter, {
-      chunkId: "chunk_id",
-      metadata: "metadata",
-      source: "source",
-      title: "title"
-    });
-    const rawRows = toStoredRows(filterPlan ? db.prepare(buildJsonQuerySql(tableName, filterPlan.clause)).all(...filterPlan.params) : jsonStatements.query.all());
-    const chunks = mapFilterToRows(rawRows);
-    const filtered = mapToRows(queryVector, chunks, input.filter);
-    const limited = filtered.slice(0, input.topK);
-    updateSQLiteLastQueryPlan({
-      backfillCount: 0,
-      candidateBudgetExhausted: false,
-      filter: input.filter,
-      filteredCandidateCount: rawRows.length,
-      finalSearchK: rawRows.length,
-      initialSearchK: rawRows.length,
-      nativeDiagnostics,
-      pushdownFilter,
-      plannerProfileUsed: input.plannerProfile,
-      queryMultiplierUsed: input.queryMultiplier,
-      queryMode: "json_fallback",
-      returnedCount: limited.length,
-      topK: input.topK,
-      underfilledTopK: limited.length < input.topK
-    });
-    return limited.map(({ chunk, score }) => ({
-      chunkId: chunk.chunkId,
-      chunkText: chunk.text,
-      embedding: chunk.vector,
-      metadata: chunk.metadata,
-      score,
-      source: chunk.source,
-      title: chunk.title
-    }));
+    return normalizeVector(createRAGVector(input.text, dimensions));
   };
-  const queryNative = async (input) => {
-    if (!nativeStatements) {
-      throw new Error("Native vector backend is not available");
-    }
-    const queryMultiplier = normalizeQueryMultiplier2(input.queryMultiplier ?? nativeConfig?.queryMultiplier);
-    const maxBackfills = normalizeMaxBackfills2(input.maxBackfills);
-    const minResults = normalizeMinResults2(input.minResults, input.topK);
-    const fillTarget = resolveFillTarget2({
-      fillPolicy: input.fillPolicy,
-      minResults,
-      topK: input.topK
-    });
-    const queryVector = normalizeVector(input.queryVector);
-    const queryVectorText = toVectorText(queryVector);
-    const pushdownFilter = buildSQLitePushdownFilter(input.filter);
-    const filterPlan = buildSQLiteFilterPlan(pushdownFilter, {
-      chunkId: "chunk_id",
-      metadata: "metadata",
-      source: "source",
-      title: "title"
-    });
-    const filteredCandidateCount = getFilteredSQLiteCandidateCount(db, tableName, filterPlan);
-    const candidateLimit = resolveAdaptiveNativeCandidateLimit({
-      defaultCandidateLimit: RAG_NATIVE_QUERY_CANDIDATE_LIMIT,
-      explicitCandidateLimit: input.candidateLimit,
-      filteredCandidateCount,
-      plannerProfile: input.plannerProfile,
-      queryMultiplier,
-      topK: input.topK
-    });
-    const searchK = planNativeCandidateSearchK({
-      candidateLimit,
-      filteredCandidateCount,
-      queryMultiplier,
-      topK: input.topK
-    });
-    if (searchK === 0) {
-      return [];
-    }
-    const runNativeQuery = (candidateK) => toNativeStoredRows(filterPlan ? db.prepare(buildNativeQuerySql(nativeTableName, filterPlan.clause)).all(queryVectorText, candidateK, ...filterPlan.params) : nativeStatements.query.all(queryVectorText, candidateK));
-    let currentSearchK = searchK;
-    let backfillCount = 0;
-    let candidateBudgetExhausted = false;
-    let backfillLimitReached = false;
-    let mapped = [];
-    for (;; ) {
-      const rawRows = runNativeQuery(currentSearchK);
-      mapped = rawRows.map((row) => {
-        const chunk = {
-          chunkId: row.chunk_id,
-          metadata: parseMetadata2(row.metadata),
-          source: row.source ?? undefined,
-          text: row.chunk_text,
-          title: row.title ?? undefined,
-          vector: parseVector(row.embedding)
-        };
-        return {
-          chunk,
-          score: normalizeDistance2(row.distance, nativeDistanceMetric)
-        };
-      }).filter(({ chunk }) => matchesFilter2(chunk, input.filter)).map((entry) => ({
-        chunkId: entry.chunk.chunkId,
-        chunkText: entry.chunk.text,
-        embedding: entry.chunk.vector,
-        metadata: entry.chunk.metadata,
-        score: entry.score,
-        source: entry.chunk.source,
-        title: entry.chunk.title
-      })).sort((left, right) => right.score - left.score);
-      if (mapped.length >= fillTarget.targetResults) {
-        break;
-      }
-      const nextSearchK = planNativeCandidateSearchBackfillK({
-        backfillCount,
-        candidateLimit,
-        currentSearchK,
-        filteredCandidateCount,
-        maxBackfills
-      });
-      if (nextSearchK <= currentSearchK) {
-        backfillLimitReached = typeof maxBackfills === "number" && backfillCount >= maxBackfills && mapped.length < fillTarget.targetResults;
-        candidateBudgetExhausted = mapped.length < fillTarget.targetResults;
-        break;
-      }
-      currentSearchK = nextSearchK;
-      backfillCount += 1;
+  const matchesFilter = (record, filter) => matchesMetadataFilterRecord({
+    chunkId: record.chunkId,
+    metadata: record.metadata,
+    source: record.source,
+    title: record.title,
+    ...record.metadata ?? {}
+  }, filter);
+  const toResult = (record, score) => ({
+    chunkId: record.chunkId,
+    chunkText: record.text,
+    embedding: record.vector,
+    metadata: record.metadata,
+    score,
+    source: record.source,
+    title: record.title
+  });
+  const upsert = async (input) => {
+    for (const chunk of input.chunks) {
+      const vector = chunk.embedding ? normalizeVector(chunk.embedding) : normalizeVector(await embed({ text: chunk.text }));
+      const record = {
+        chunkId: chunk.chunkId,
+        metadata: chunk.metadata,
+        source: chunk.source,
+        text: chunk.text,
+        title: chunk.title,
+        vector
+      };
+      records.set(record.chunkId, record);
+      const light = toLight(record);
+      vectorIndex.add(light);
+      textIndex.add(light);
+      await engine.applyChange(table, { op: "insert", row: light });
     }
-    updateSQLiteLastQueryPlan({
-      backfillCount,
-      backfillLimitReached,
-      candidateBudgetExhausted,
-      filter: input.filter,
-      filteredCandidateCount,
-      finalSearchK: currentSearchK,
-      initialSearchK: searchK,
-      nativeDiagnostics,
-      pushdownFilter,
-      plannerProfileUsed: input.plannerProfile,
-      candidateLimitUsed: candidateLimit,
-      maxBackfillsUsed: maxBackfills,
-      minResultsUsed: minResults,
-      fillPolicyUsed: fillTarget.fillPolicy,
-      queryMultiplierUsed: queryMultiplier,
-      queryMode: "native_vec0",
-      returnedCount: Math.min(mapped.length, input.topK),
-      minResultsSatisfied: mapped.length >= minResults,
-      topK: input.topK,
-      underfilledTopK: mapped.length < input.topK
-    });
-    return mapped.slice(0, input.topK);
   };
   const query = async (input) => {
-    if (!useNative) {
-      return queryFallback(input);
-    }
-    try {
-      return await queryNative(input);
-    } catch (error) {
-      markNativeQueryFailure(nativeDiagnostics, error);
-      if (nativeConfig?.requireAvailable) {
-        throw new Error(`Native vector query failed for table "${nativeTableName}". ${getErrorMessage2(error)}`, { cause: error });
+    const queryVector = normalizeVector(input.queryVector);
+    const results = [];
+    for (const record of records.values()) {
+      if (!matchesFilter(record, input.filter)) {
+        continue;
+      }
+      const score = querySimilarity(queryVector, normalizeVector(record.vector));
+      if (Number.isFinite(score)) {
+        results.push(toResult(record, score));
       }
-      return queryFallback(input);
     }
+    results.sort((first, second) => second.score - first.score);
+    return results.slice(0, input.topK);
   };
   const queryLexical = async (input) => {
-    const pushdownFilter = buildSQLitePushdownFilter(input.filter);
-    const filterPlan = buildSQLiteFilterPlan(pushdownFilter, {
-      chunkId: "chunk_id",
-      metadata: "metadata",
-      source: "source",
-      title: "title"
-    });
-    const rawRows = toStoredRows(filterPlan ? db.prepare(buildJsonQuerySql(tableName, filterPlan.clause)).all(...filterPlan.params) : jsonStatements.query.all());
-    const chunks = mapFilterToRows(rawRows).filter((chunk) => matchesFilter2(chunk, input.filter));
-    const ranked = rankRAGLexicalMatches(input.query, chunks);
-    return ranked.slice(0, input.topK).map(({ result, score }) => ({
-      chunkId: result.chunkId,
-      chunkText: result.text,
-      metadata: result.metadata,
-      score,
-      source: result.source,
-      title: result.title
-    }));
-  };
-  const upsert = async (input) => {
-    const chunks = input.chunks.length > 0 ? await Promise.all(input.chunks.map(async (chunk) => ({
-      chunkId: chunk.chunkId,
-      metadata: chunk.metadata,
-      source: chunk.source,
-      text: chunk.text,
-      title: chunk.title,
-      vector: chunk.embedding ? normalizeVector(chunk.embedding) : normalizeVector(await embed({ text: chunk.text }))
-    }))) : [];
-    if (!useNative) {
-      fallbackToJsonUpsert(chunks, jsonStatements);
-      refreshSQLiteRuntimeDiagnostics(db, nativeDiagnostics, tableName);
-      return;
-    }
-    try {
-      upsertNativeChunks(chunks, nativeStatements);
-    } catch (error) {
-      markNativeUpsertFailure(nativeDiagnostics, error);
-      if (nativeConfig?.requireAvailable) {
-        throw new Error(`Native vector upsert failed for table "${nativeTableName}". ${getErrorMessage2(error)}`, { cause: error });
+    const hits = textIndex.search(input.query, input.topK * 5);
+    const results = [];
+    for (const hit of hits) {
+      const record = records.get(hit.row.chunkId);
+      if (record && matchesFilter(record, input.filter)) {
+        results.push(toResult(record, hit.score));
       }
-      useNative = false;
-      fallbackToJsonUpsert(chunks, jsonStatements);
     }
-    refreshSQLiteRuntimeDiagnostics(db, nativeDiagnostics, useNative ? nativeTableName : tableName);
+    return results.slice(0, input.topK);
   };
+  const hasFilters = (chunkIds, filter) => ({
+    filtered: Boolean(filter && Object.keys(filter).length > 0),
+    ided: chunkIds.size > 0
+  });
   const count = async (input = {}) => {
-    const filter = input.filter;
-    const chunkIds = input.chunkIds;
-    const hasFilter = Boolean(filter && Object.keys(filter).length > 0);
-    const hasChunkIds = Boolean(chunkIds && chunkIds.length > 0);
-    if (!hasFilter && !hasChunkIds) {
-      return getChunkCountFromSql(db, buildJsonCountSql(tableName), []);
+    const chunkIds = new Set(input.chunkIds ?? []);
+    const { filtered, ided } = hasFilters(chunkIds, input.filter);
+    if (!filtered && !ided) {
+      return records.size;
     }
-    if (hasFilter && !hasChunkIds) {
-      return getSQLiteCandidateChunkIdsByFilter(db, tableName, filter, jsonStatements).length;
-    }
-    return getSQLiteCandidateChunkIds(db, tableName, jsonStatements, {
-      chunkIds,
-      filter
-    }).length;
+    return [...records.values()].filter((record) => ided && chunkIds.has(record.chunkId) || filtered && matchesFilter(record, input.filter)).length;
   };
   const remove = async (input = {}) => {
-    const filter = input.filter;
-    const chunkIds = input.chunkIds;
-    const hasFilter = Boolean(filter && Object.keys(filter).length > 0);
-    const hasChunkIds = Boolean(chunkIds && chunkIds.length > 0);
-    if (!hasFilter && !hasChunkIds) {
-      return 0;
-    }
-    const toDelete = getSQLiteCandidateChunkIds(db, tableName, jsonStatements, {
-      chunkIds,
-      filter
-    });
-    if (toDelete.length === 0) {
+    const chunkIds = new Set(input.chunkIds ?? []);
+    const { filtered, ided } = hasFilters(chunkIds, input.filter);
+    if (!filtered && !ided) {
       return 0;
     }
-    for (const chunkId of toDelete) {
-      jsonStatements.delete.run(chunkId);
-    }
-    if (!useNative || !nativeStatements) {
-      refreshSQLiteRuntimeDiagnostics(db, nativeDiagnostics, tableName);
-      return toDelete.length;
-    }
-    for (const chunkId of toDelete) {
-      nativeStatements.delete.run(chunkId);
+    let removed = 0;
+    for (const record of [...records.values()]) {
+      const matches = ided && chunkIds.has(record.chunkId) || filtered && matchesFilter(record, input.filter);
+      if (!matches) {
+        continue;
+      }
+      records.delete(record.chunkId);
+      vectorIndex.remove(record.chunkId);
+      textIndex.remove(record.chunkId);
+      await engine.applyChange(table, {
+        op: "delete",
+        row: toLight(record)
+      });
+      removed += 1;
     }
-    refreshSQLiteRuntimeDiagnostics(db, nativeDiagnostics, useNative ? nativeTableName : tableName);
-    return toDelete.length;
+    return removed;
   };
-  const clear = () => {
-    jsonStatements.clear.run();
-    if (!useNative || !nativeStatements) {
-      refreshSQLiteRuntimeDiagnostics(db, nativeDiagnostics, tableName);
-      return;
-    }
-    try {
-      nativeStatements.clear.run();
-    } catch {
-      jsonStatements.clear.run();
+  const clear = async () => {
+    for (const record of [...records.values()]) {
+      records.delete(record.chunkId);
+      vectorIndex.remove(record.chunkId);
+      textIndex.remove(record.chunkId);
+      await engine.applyChange(table, { op: "delete", row: toLight(record) });
     }
-    refreshSQLiteRuntimeDiagnostics(db, nativeDiagnostics, useNative ? nativeTableName : tableName);
   };
-  const analyze = () => {
-    analyzeSQLiteBackend({
-      db,
-      diagnosticTableName: useNative ? nativeTableName : tableName,
-      nativeDiagnostics,
-      tableName
-    });
+  const status = {
+    backend: "in_memory",
+    dimensions,
+    vectorMode: "in_memory"
+  };
+  const capabilities = {
+    backend: "in_memory",
+    nativeVectorSearch: false,
+    persistence: "memory_only",
+    serverSideFiltering: false,
+    streamingIngestStatus: false
   };
   return {
-    analyze,
     clear,
+    count,
+    delete: remove,
     embed,
+    engine,
+    getCapabilities: () => capabilities,
+    getStatus: () => status,
     query,
     queryLexical,
-    count,
-    delete: remove,
-    upsert,
-    getCapabilities: () => createSQLiteCapabilities(useNative),
-    getStatus: () => createSQLiteStatus(dimensions, nativeDiagnostics, useNative)
+    retrievalCollection,
+    upsert
   };
 };
 export {
@@ -37889,8 +35861,6 @@ export {
   resolveRAGQueryTransform,
   resolveRAGHybridSearchOptions,
   resolveRAGEmbeddingProvider,
-  resolveAbsoluteSQLiteVecExtensionPath,
-  resolveAbsoluteSQLiteVec,
   reorderRAGEvaluationSuiteCases,
   removeRAGEvaluationSuiteCaseHardNegative,
   removeRAGEvaluationSuiteCase,
@@ -37977,7 +35947,7 @@ export {
   deepseekEmbeddings,
   createVoyageRAGReranker,
   createTextFileExtractor,
-  createSQLiteRAGStore,
+  createSyncRAGStore,
   createRAGVector,
   createRAGUrlSyncSource,
   createRAGSyncScheduler,
@@ -38069,7 +36039,6 @@ export {
   createRAGAdaptiveNativePlannerBenchmarkSuite,
   createRAGAdaptiveNativePlannerBenchmarkSnapshot,
   createRAGAccessControl,
-  createPostgresRAGStore,
   createPDFFileExtractor,
   createOfficeDocumentExtractor,
   createLegacyDocumentExtractor,
@@ -38164,5 +36133,5 @@ export {
   addRAGEvaluationSuiteCase
 };
 
-//# debugId=BD3325EB562F864664756E2164756E21
+//# debugId=7661BF2D41E88F6A64756E2164756E21
 //# sourceMappingURL=index.js.map