libsql-search 0.7.1 → 0.9.0

package/README.md

@@ -74,11 +74,33 @@ console.log(results.map((result) => ({
 
 Important behavior:
 
-- Call `createTable()` before indexing or searching.
+- Call `createTable()` before indexing or searching. It creates the `<tableName>_embedding_idx` vector index that `search()` needs.
 - Keep table width, provider, and dimensions aligned across create/index/query.
-- `indexContent()` clears existing rows before rebuilding and is not transactional.
+- `indexContent()` embeds every document before it touches the database, then replaces the table in one transaction, so a failed rebuild leaves the previous index intact.
+- `indexContent()` throws `IndexingError` when a file fails; pass `failurePolicy: "skip"` to rebuild from the remaining files.
+- `indexContent()` throws `IndexingError` when no source files are found; pass `allowEmptyIndex: true` to intentionally empty the index.
 - Hosted providers send indexed and queried text to external services and may incur provider charges.
 
+## Search Accuracy And Performance
+
+`search()` queries the `<tableName>_embedding_idx` vector index through libSQL's `vector_top_k()`. It does not score every row, so query cost no longer grows linearly with the size of the index.
+
+That index is an approximate-nearest-neighbor structure, so **the default search path is approximate and can miss a true nearest neighbor.** To limit the loss, `search()` over-fetches candidates from the index, recomputes the true cosine distance for each, and orders exactly by `(distance, id)` before trimming to `limit`. Distances on returned rows are always exact, and result ordering is fully deterministic — including when two rows tie — even though the index's own candidate order is not.
+
+Two options control the trade-off:
+
+```ts
+// Widen the index probe to raise recall (default: max(limit * 4, 32))
+await search({ client, query, limit: 10, candidates: 200 });
+
+// Bypass the index entirely: exact, but linear in table size
+await search({ client, query, exact: true });
+```
+
+`exact: true` is the only way to guarantee exactness. Use it for small corpora, for correctness checks against the index path, and for tables that have no vector index.
+
+Requirements: `vector_top_k()` and `libsql_vector_idx()` need a libSQL build with native vector support. The peer dependency is `@libsql/client ^0.15.0`, verified against `0.15.15`; remote Turso/libSQL servers must support vector indexes as well. See the [API reference](./docs/API.md#searchoptions) for full semantics, and [Indexing and operations](./docs/INDEXING.md) for tables created before the index existed.
+
 ## Providers
 
 Built-in providers:

package/dist/index.cjs

@@ -788,6 +788,9 @@ function prepareTextForEmbedding(fields) {
 const SQL_IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const DEFAULT_SEARCH_LIMIT = 10;
 const MAX_SEARCH_LIMIT = 100;
+const DEFAULT_SEARCH_CANDIDATE_MULTIPLIER = 4;
+const MIN_SEARCH_CANDIDATES = 32;
+const MAX_SEARCH_CANDIDATES = MAX_SEARCH_LIMIT * 10;
 function validateSqlIdentifier(identifier, name = "identifier") {
   if (typeof identifier !== "string" || !SQL_IDENTIFIER_PATTERN.test(identifier)) {
     throw new Error(
@@ -806,6 +809,23 @@ function normalizeSearchLimit(limit = DEFAULT_SEARCH_LIMIT) {
   }
   return limit;
 }
+function defaultSearchCandidates(limit) {
+  return Math.min(
+    Math.max(limit * DEFAULT_SEARCH_CANDIDATE_MULTIPLIER, MIN_SEARCH_CANDIDATES),
+    MAX_SEARCH_CANDIDATES
+  );
+}
+function normalizeSearchCandidates(candidates, limit) {
+  if (candidates === void 0) {
+    return defaultSearchCandidates(limit);
+  }
+  if (typeof candidates !== "number" || !Number.isFinite(candidates) || !Number.isInteger(candidates) || candidates < limit || candidates > MAX_SEARCH_CANDIDATES) {
+    throw new Error(
+      `Invalid search candidates: expected an integer from the search limit (${limit}) to ${MAX_SEARCH_CANDIDATES}`
+    );
+  }
+  return candidates;
+}
 function normalizeVectorDimensions(dimensions) {
   if (typeof dimensions !== "number" || !Number.isFinite(dimensions) || !Number.isInteger(dimensions) || dimensions < 1) {
     throw new Error("Invalid vector dimensions: expected a positive integer");
@@ -813,6 +833,16 @@ function normalizeVectorDimensions(dimensions) {
   return dimensions;
 }
 
+class IndexingError extends Error {
+  phase;
+  failures;
+  constructor(message, phase, failures = [], options) {
+    super(message, options);
+    this.name = "IndexingError";
+    this.phase = phase;
+    this.failures = failures;
+  }
+}
 async function indexContent(options) {
   const {
     client,
@@ -821,32 +851,92 @@ async function indexContent(options) {
     fileExtensions = [".md", ".markdown"],
     exclude = ["node_modules", ".git", "dist", "build"],
     tableName = "articles",
-    onProgress
+    onProgress,
+    failurePolicy = "abort",
+    allowEmptyIndex = false
   } = options;
   const quotedTableName = quoteSqlIdentifier(tableName, "tableName");
-  const files = await findFiles(contentPath, contentPath, fileExtensions, exclude);
-  if (files.length === 0) {
-    console.warn(`No files found in ${contentPath}`);
-    return { success: 0, failed: 0, total: 0 };
-  }
-  await client.execute(`DELETE FROM ${quotedTableName}`);
-  let success = 0;
-  let failed = 0;
+  let files;
+  try {
+    files = await findFiles(contentPath, contentPath, fileExtensions, exclude);
+  } catch (error) {
+    throw new IndexingError(
+      `Failed to scan ${contentPath} for source files. The existing index was left unchanged.`,
+      "build",
+      [],
+      { cause: toError(error) }
+    );
+  }
+  files.sort((a, b) => a.relativePath < b.relativePath ? -1 : a.relativePath > b.relativePath ? 1 : 0);
+  if (files.length === 0 && !allowEmptyIndex) {
+    throw new IndexingError(
+      `No source files found in ${contentPath}. The existing index was left unchanged. Pass allowEmptyIndex: true to intentionally empty the index.`,
+      "build"
+    );
+  }
+  const documents = [];
+  const failures = [];
+  const slugOwners = /* @__PURE__ */ new Map();
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
     if (onProgress) {
       onProgress(i + 1, files.length, file.relativePath);
     }
-    try {
-      const document = await processFile(file, embeddingOptions);
-      await insertDocument(client, document, quotedTableName);
-      success++;
-    } catch (error) {
-      console.error(`Failed to index ${file.relativePath}:`, error);
-      failed++;
+    const outcome = await buildDocument(file, embeddingOptions);
+    let failure;
+    if (outcome.ok) {
+      const owner = slugOwners.get(outcome.document.slug);
+      if (owner === void 0) {
+        slugOwners.set(outcome.document.slug, file.relativePath);
+        documents.push(outcome.document);
+      } else {
+        failure = {
+          file: file.relativePath,
+          stage: "parse",
+          error: new Error(
+            `Duplicate slug "${outcome.document.slug}": ${file.relativePath} collides with ${owner}`
+          )
+        };
+      }
+    } else {
+      failure = {
+        file: file.relativePath,
+        stage: outcome.stage,
+        error: outcome.error
+      };
+    }
+    if (failure === void 0) {
+      continue;
     }
+    if (failurePolicy === "abort") {
+      throw new IndexingError(
+        `Failed to ${failure.stage} ${file.relativePath}: ${failure.error.message}. The existing index was left unchanged. Pass failurePolicy: 'skip' to rebuild from the remaining files.`,
+        "build",
+        [failure],
+        { cause: failure.error }
+      );
+    }
+    console.error(`Skipping ${file.relativePath} (${failure.stage} failed):`, failure.error);
+    failures.push(failure);
+  }
+  if (files.length > 0 && documents.length === 0) {
+    throw new IndexingError(
+      `All ${files.length} source file(s) in ${contentPath} failed to index. The existing index was left unchanged.`,
+      "build",
+      failures,
+      { cause: failures[0].error }
+    );
   }
-  return { success, failed, total: files.length };
+  const success = documents.length;
+  await replaceIndex(client, quotedTableName, documents, failures);
+  return {
+    success,
+    failed: failures.length,
+    total: files.length,
+    replaced: true,
+    partial: failures.length > 0,
+    failures
+  };
 }
 async function findFiles(dir, baseDir, extensions, exclude) {
   const files = [];
@@ -870,34 +960,113 @@ async function findFiles(dir, baseDir, extensions, exclude) {
   }
   return files;
 }
-async function processFile(file, embeddingOptions) {
-  const content = await promises.readFile(file.fullPath, "utf-8");
-  const { data: frontMatter, content: markdown } = matter(content);
+async function buildDocument(file, embeddingOptions) {
+  let raw;
+  try {
+    raw = await promises.readFile(file.fullPath, "utf-8");
+  } catch (error) {
+    return { ok: false, stage: "read", error: toError(error) };
+  }
+  let parsed;
+  try {
+    parsed = parseFile(file, raw);
+  } catch (error) {
+    return { ok: false, stage: "parse", error: toError(error) };
+  }
+  let embedding;
+  try {
+    embedding = await generateEmbedding(parsed.embeddingText, {
+      ...embeddingOptions,
+      intent: embeddingOptions.intent ?? "document"
+    });
+  } catch (error) {
+    return { ok: false, stage: "embed", error: toError(error) };
+  }
+  return {
+    ok: true,
+    document: {
+      slug: parsed.slug,
+      title: parsed.title,
+      content: parsed.content,
+      folder: file.folder,
+      tags: parsed.tags,
+      serializedTags: parsed.serializedTags,
+      embedding,
+      metadata: parsed.metadata
+    }
+  };
+}
+function parseFile(file, raw) {
+  const { data: frontMatter, content: markdown } = matter(raw);
   const slug = file.relativePath.replace(/\.(md|markdown)$/, "").replace(/\\/g, "/");
-  const title = frontMatter.title || file.relativePath.split("/").pop()?.replace(/\.(md|markdown)$/, "").replace(/-/g, " ") || "Untitled";
+  const title = resolveTitle(file, frontMatter.title);
   const tags = Array.isArray(frontMatter.tags) ? frontMatter.tags : [];
+  const serializedTags = JSON.stringify(tags);
   const embeddingText = prepareTextForEmbedding({
     title,
     description: frontMatter.description,
     content: markdown,
     tags
   });
-  const embedding = await generateEmbedding(embeddingText, {
-    ...embeddingOptions,
-    intent: embeddingOptions.intent ?? "document"
-  });
   return {
     slug,
     title,
     content: markdown,
-    folder: file.folder,
     tags,
-    embedding,
+    serializedTags,
+    embeddingText,
     metadata: frontMatter
   };
 }
-async function insertDocument(client, document, quotedTableName) {
-  await client.execute({
+function resolveTitle(file, rawTitle) {
+  if (!rawTitle) {
+    return fallbackTitle(file);
+  }
+  if (typeof rawTitle === "string") {
+    return rawTitle;
+  }
+  if (typeof rawTitle === "number" || typeof rawTitle === "bigint" || typeof rawTitle === "boolean") {
+    return String(rawTitle);
+  }
+  if (rawTitle instanceof Date) {
+    return rawTitle.toISOString();
+  }
+  throw new Error(
+    `Unsupported frontmatter title of type ${describeType(rawTitle)}: expected a string`
+  );
+}
+function fallbackTitle(file) {
+  return file.relativePath.split("/").pop()?.replace(/\.(md|markdown)$/, "").replace(/-/g, " ") || "Untitled";
+}
+function describeType(value) {
+  return Array.isArray(value) ? "array" : typeof value;
+}
+async function replaceIndex(client, quotedTableName, documents, failures) {
+  const statements = [`DELETE FROM ${quotedTableName}`];
+  try {
+    for (let i = 0; i < documents.length; i++) {
+      const document = documents[i];
+      if (document !== void 0) {
+        statements.push(createInsertStatement(document, quotedTableName));
+        documents[i] = void 0;
+      }
+    }
+  } finally {
+    documents.length = 0;
+  }
+  try {
+    await client.batch(statements, "write");
+  } catch (error) {
+    throw new IndexingError(
+      `Failed to replace the contents of ${quotedTableName}. The transaction was rolled back and the existing index was left unchanged.`,
+      "replace",
+      failures,
+      { cause: toError(error) }
+    );
+  }
+}
+function createInsertStatement(document, quotedTableName) {
+  return {
     sql: `INSERT INTO ${quotedTableName}
           (slug, title, content, folder, tags, embedding, created_at, updated_at)
           VALUES (?, ?, ?, ?, ?, vector(?), datetime('now'), datetime('now'))`,
@@ -906,10 +1075,13 @@ async function insertDocument(client, document, quotedTableName) {
       document.title,
       document.content,
       document.folder,
-      JSON.stringify(document.tags),
+      document.serializedTags,
       JSON.stringify(document.embedding)
     ]
-  });
+  };
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
 }
 async function createTable(client, tableName = "articles", dimensions = 384) {
   const quotedTableName = quoteSqlIdentifier(tableName, "tableName");
@@ -944,39 +1116,102 @@ async function createTable(client, tableName = "articles", dimensions = 384) {
   `);
 }
 
+const RESULT_COLUMNS = "a.id, a.slug, a.title, a.content, a.folder, a.tags, a.created_at";
+const MISSING_VECTOR_INDEX_PATTERNS = [
+  /failed to parse vector index parameters/i
+];
+const NO_VECTOR_SUPPORT_PATTERNS = [
+  /no such table:\s*vector_top_k/i
+];
 async function search(options) {
   const {
     client,
     query,
     limit = 10,
     tableName = "articles",
-    embeddingOptions = {}
+    embeddingOptions = {},
+    candidates,
+    exact = false
   } = options;
   const quotedTableName = quoteSqlIdentifier(tableName, "tableName");
   const resultLimit = normalizeSearchLimit(limit);
+  const embeddingIndexName = validateSqlIdentifier(
+    `${tableName}_embedding_idx`,
+    "embedding index name"
+  );
+  const candidateCount = normalizeSearchCandidates(candidates, resultLimit);
   const queryEmbedding = await generateEmbedding(query, {
     ...embeddingOptions,
     intent: embeddingOptions.intent ?? "query"
   });
-  const results = await client.execute({
+  const queryVector = JSON.stringify(queryEmbedding);
+  const results = exact ? await executeExactSearch(client, quotedTableName, queryVector, resultLimit) : await executeIndexSearch(
+    client,
+    quotedTableName,
+    embeddingIndexName,
+    queryVector,
+    candidateCount,
+    resultLimit
+  );
+  return results.rows.map(toSearchResult);
+}
+async function executeIndexSearch(client, quotedTableName, embeddingIndexName, queryVector, candidateCount, resultLimit) {
+  try {
+    return await client.execute({
+      sql: `
+        SELECT
+          ${RESULT_COLUMNS},
+          vector_distance_cos(a.embedding, vector(:queryVector)) as distance
+        FROM vector_top_k(:indexName, vector(:queryVector), :candidates) AS v
+        JOIN ${quotedTableName} a ON a.rowid = v.id
+        ORDER BY distance, a.id
+        LIMIT :resultLimit
+      `,
+      args: {
+        queryVector,
+        indexName: embeddingIndexName,
+        candidates: candidateCount,
+        resultLimit
+      }
+    });
+  } catch (error) {
+    throw wrapIndexPathError(error, embeddingIndexName);
+  }
+}
+async function executeExactSearch(client, quotedTableName, queryVector, resultLimit) {
+  return client.execute({
     sql: `
       SELECT
-        id,
-        slug,
-        title,
-        content,
-        folder,
-        tags,
-        created_at,
-        vector_distance_cos(embedding, vector(?)) as distance
-      FROM ${quotedTableName}
-      WHERE embedding IS NOT NULL
-      ORDER BY distance
-      LIMIT ?
+        ${RESULT_COLUMNS},
+        vector_distance_cos(a.embedding, vector(:queryVector)) as distance
+      FROM ${quotedTableName} a
+      WHERE a.embedding IS NOT NULL
+      ORDER BY distance, a.id
+      LIMIT :resultLimit
     `,
-    args: [JSON.stringify(queryEmbedding), resultLimit]
+    args: { queryVector, resultLimit }
   });
-  return results.rows.map((row) => ({
+}
+function wrapIndexPathError(error, embeddingIndexName) {
+  if (!(error instanceof Error)) {
+    return error;
+  }
+  if (MISSING_VECTOR_INDEX_PATTERNS.some((pattern) => pattern.test(error.message))) {
+    return new Error(
+      `Vector index "${embeddingIndexName}" could not be used for search. createTable() creates this index; a table created before it existed, or created by hand, will not have it. Create it with CREATE INDEX IF NOT EXISTS "${embeddingIndexName}" ON <table>(libsql_vector_idx(embedding)), or pass exact: true to search without the index.`,
+      { cause: error }
+    );
+  }
+  if (NO_VECTOR_SUPPORT_PATTERNS.some((pattern) => pattern.test(error.message))) {
+    return new Error(
+      `This libSQL deployment has no vector index support: vector_top_k() is unavailable. Pass exact: true to search on the full-scan path.`,
+      { cause: error }
+    );
+  }
+  return error;
+}
+function toSearchResult(row) {
+  return {
     id: row.id,
     slug: row.slug,
     title: row.title,
@@ -985,7 +1220,7 @@ async function search(options) {
     tags: JSON.parse(row.tags || "[]"),
     distance: row.distance,
     created_at: row.created_at
-  }));
+  };
 }
 async function getAllArticles(client, tableName = "articles") {
   const quotedTableName = quoteSqlIdentifier(tableName, "tableName");
@@ -1059,6 +1294,10 @@ async function getFolders(client, tableName = "articles") {
   return results.rows.map((row) => row.folder);
 }
 
+exports.DEFAULT_SEARCH_CANDIDATE_MULTIPLIER = DEFAULT_SEARCH_CANDIDATE_MULTIPLIER;
+exports.IndexingError = IndexingError;
+exports.MAX_SEARCH_CANDIDATES = MAX_SEARCH_CANDIDATES;
+exports.MIN_SEARCH_CANDIDATES = MIN_SEARCH_CANDIDATES;
 exports.createEmbeddingProvider = createEmbeddingProvider;
 exports.createTable = createTable;
 exports.generateEmbedding = generateEmbedding;

package/dist/index.d.ts

@@ -82,6 +82,28 @@ declare function prepareTextForEmbedding(fields: {
  * Content indexer for markdown and other formats
  */
 
+/**
+ * How build-phase failures are handled.
+ *
+ * - `abort` (default) rejects the whole rebuild on the first failure
+ * - `skip` drops the failing file and rebuilds from the survivors
+ */
+type IndexFailurePolicy = 'abort' | 'skip';
+/** The step that failed while turning a file into an indexable document. */
+type IndexFailureStage = 'read' | 'parse' | 'embed';
+/**
+ * The phase an {@link IndexingError} was raised in.
+ *
+ * - `build` means no database state was touched
+ * - `replace` means the replacement transaction failed and was rolled back
+ */
+type IndexingErrorPhase = 'build' | 'replace';
+interface IndexFailure {
+    /** Path of the file relative to `contentPath`. */
+    file: string;
+    stage: IndexFailureStage;
+    error: Error;
+}
 interface IndexerOptions {
     client: Client;
     contentPath: string;
@@ -90,6 +112,23 @@ interface IndexerOptions {
     exclude?: string[];
     tableName?: string;
     onProgress?: (current: number, total: number, file: string) => void;
+    /** Defaults to `abort`. */
+    failurePolicy?: IndexFailurePolicy;
+    /** Allow an empty source directory to empty the index. Defaults to `false`. */
+    allowEmptyIndex?: boolean;
+}
+interface IndexResult {
+    /** Documents written to the table. */
+    success: number;
+    /** Files that could not be indexed. */
+    failed: number;
+    /** Files discovered on disk. */
+    total: number;
+    /** Whether table contents were replaced by this call. */
+    replaced: boolean;
+    /** Replaced, but some files were skipped. */
+    partial: boolean;
+    failures: IndexFailure[];
 }
 interface IndexedDocument {
     slug: string;
@@ -101,18 +140,48 @@ interface IndexedDocument {
     metadata?: Record<string, any>;
 }
 /**
- * Index markdown content from a directory
+ * Raised when a rebuild cannot complete. The previously indexed rows are always
+ * left exactly as they were.
  */
-declare function indexContent(options: IndexerOptions): Promise<{
-    success: number;
-    failed: number;
-    total: number;
-}>;
+declare class IndexingError extends Error {
+    readonly phase: IndexingErrorPhase;
+    readonly failures: IndexFailure[];
+    constructor(message: string, phase: IndexingErrorPhase, failures?: IndexFailure[], options?: ErrorOptions);
+}
+/**
+ * Index markdown content from a directory.
+ *
+ * Every document is read, parsed, and embedded in memory before any database
+ * state changes. The table is then replaced inside a single write transaction,
+ * so a failure at any point leaves the previous index intact.
+ */
+declare function indexContent(options: IndexerOptions): Promise<IndexResult>;
 /**
  * Create the articles table if it doesn't exist
  */
 declare function createTable(client: Client, tableName?: string, dimensions?: number): Promise<void>;
 
+/**
+ * Multiplier applied to `limit` when deriving the default candidate count.
+ *
+ * The vector index is approximate, so the default search over-fetches
+ * candidates and re-ranks them exactly. Four candidates per requested result
+ * recovers most of the recall an ANN probe loses without materially changing
+ * the cost of the join.
+ */
+declare const DEFAULT_SEARCH_CANDIDATE_MULTIPLIER = 4;
+/**
+ * Floor for the default candidate count. Small limits would otherwise probe
+ * the index too shallowly for the exact re-rank to have anything to work with.
+ */
+declare const MIN_SEARCH_CANDIDATES = 32;
+/**
+ * Ceiling for an explicit `candidates` value. Mirrors {@link MAX_SEARCH_LIMIT},
+ * scaled by an order of magnitude, so the widest legal probe still stays well
+ * short of a full table scan.
+ */
+declare const MAX_SEARCH_CANDIDATES: number;
+
 /**
  * Vector search functionality
  */
@@ -123,6 +192,22 @@ interface SearchOptions {
     limit?: number;
     tableName?: string;
     embeddingOptions?: EmbeddingOptions;
+    /**
+     * How many candidates to pull from the vector index before the exact
+     * re-rank. Must be an integer from `limit` through {@link MAX_SEARCH_CANDIDATES}.
+     *
+     * Defaults to `max(limit * 4, 32)`.
+     *
+     * Has no effect when `exact` is `true`, but is still validated: an
+     * out-of-range value throws on both paths rather than being quietly accepted
+     * on one of them.
+     */
+    candidates?: number;
+    /**
+     * Bypass the vector index and score every row instead. Exact but linear in
+     * table size. Defaults to `false`.
+     */
+    exact?: boolean;
 }
 interface SearchResult {
     id: number;
@@ -135,7 +220,17 @@ interface SearchResult {
     created_at: string;
 }
 /**
- * Perform semantic search using vector similarity
+ * Perform semantic search using vector similarity.
+ *
+ * By default this queries the `<tableName>_embedding_idx` vector index, which
+ * is an approximate-nearest-neighbor structure: the candidate set it returns is
+ * not guaranteed to contain the true nearest rows, and is not stable across
+ * runs when distances tie. To limit both effects the query over-fetches
+ * `candidates` rows, recomputes the true cosine distance for each, and orders
+ * exactly by `(distance, id)`. The returned ordering is therefore fully
+ * deterministic even though the candidate set is not.
+ *
+ * Pass `exact: true` for a guaranteed-exact full scan.
  */
 declare function search(options: SearchOptions): Promise<SearchResult[]>;
 /**
@@ -178,5 +273,5 @@ declare function getArticlesByFolder(client: Client, folder: string, tableName?:
  */
 declare function getFolders(client: Client, tableName?: string): Promise<string[]>;
 
-export { createEmbeddingProvider, createTable, generateEmbedding, generateEmbeddings, getAllArticles, getArticleBySlug, getArticlesByFolder, getEmbeddingProviderMetadata, getFolders, indexContent, padEmbedding, prepareTextForEmbedding, search, validateEmbeddingBatch };
-export type { EmbeddingBatchBehavior, EmbeddingBatchItem, EmbeddingBatchItemResult, EmbeddingBatchMode, EmbeddingBatchResult, EmbeddingIntent, EmbeddingOptions, EmbeddingProvider, EmbeddingProviderClient, EmbeddingProviderMetadata, EmbeddingRequestOptions, IndexedDocument, IndexerOptions, SearchOptions, SearchResult };
+export { DEFAULT_SEARCH_CANDIDATE_MULTIPLIER, IndexingError, MAX_SEARCH_CANDIDATES, MIN_SEARCH_CANDIDATES, createEmbeddingProvider, createTable, generateEmbedding, generateEmbeddings, getAllArticles, getArticleBySlug, getArticlesByFolder, getEmbeddingProviderMetadata, getFolders, indexContent, padEmbedding, prepareTextForEmbedding, search, validateEmbeddingBatch };
+export type { EmbeddingBatchBehavior, EmbeddingBatchItem, EmbeddingBatchItemResult, EmbeddingBatchMode, EmbeddingBatchResult, EmbeddingIntent, EmbeddingOptions, EmbeddingProvider, EmbeddingProviderClient, EmbeddingProviderMetadata, EmbeddingRequestOptions, IndexFailure, IndexFailurePolicy, IndexFailureStage, IndexResult, IndexedDocument, IndexerOptions, IndexingErrorPhase, SearchOptions, SearchResult };