okengine 0.3.5 → 0.4.3

package/src/drivers/libsql.ts

@@ -0,0 +1,179 @@
+/**
+ * `libsql` driver — binds `@libsql/client` (optional peer, dynamic import).
+ *
+ * Protocol-named: libSQL speaks the sqlite wire dialect plus native ANN
+ * vectors (`F32_BLOB` + `libsql_vector_idx` + `vector_top_k`). Classic libSQL
+ * only — never the Turso Rust rewrite (`@tursodatabase/database`).
+ *
+ * Serves both the `sql` facet (same `?` placeholder convention as `sqlite`)
+ * and the `index` facet (native ANN, no JS-side distance math).
+ *
+ * Latency note: local file / `:memory:` opens are in-process like sqlite.
+ */
+
+import { customType, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import type {
+  IndexHit,
+  IndexOpenOptions,
+  SqlConnectOptions,
+  SqlConnection,
+  SqlDriver,
+  SqlRow,
+  VectorIndexDriver,
+  VectorIndexStore,
+} from "./types.ts";
+
+/** `@libsql/client` is an optional peer — loaded only when this driver runs. */
+type LibsqlModule = typeof import("@libsql/client");
+
+async function loadLibsql(): Promise<LibsqlModule> {
+  try {
+    return await import("@libsql/client");
+  } catch {
+    throw new Error(
+      "libsql driver: install optional peer `@libsql/client` (bun add @libsql/client)",
+    );
+  }
+}
+
+/** Bare file paths become `file:` URLs; `:memory:` / scheme URLs pass through. */
+function normalizeLibsqlUrl(url: string): string {
+  if (url === ":memory:" || url.includes("://") || url.startsWith("file:")) return url;
+  return `file:${url}`;
+}
+
+/**
+ * Open a libSQL connection implementing {@link SqlConnection}.
+ *
+ * @param options - URL (`:memory:` / `file:…` / `libsql://…`) / role
+ */
+export async function connectLibsql(options: SqlConnectOptions = {}): Promise<SqlConnection> {
+  const role = options.role ?? "primary";
+  const { createClient } = await loadLibsql();
+  const client = createClient({ url: normalizeLibsqlUrl(options.url ?? ":memory:") });
+  return {
+    driverId: "libsql",
+    role,
+    async query(sql, params = []) {
+      const rs = await client.execute({ sql, args: params as never });
+      return rs.rows as unknown as SqlRow[];
+    },
+    async exec(sql, params = []) {
+      const rs = await client.execute({ sql, args: params as never });
+      return { changes: rs.rowsAffected };
+    },
+    async close() {
+      client.close();
+    },
+  };
+}
+
+/** Protocol-named libsql sql driver. */
+export const libsqlDriver: SqlDriver = {
+  id: "libsql",
+  facet: "sql",
+  connect: connectLibsql,
+};
+
+/** libSQL native vector column: `F32_BLOB(dims)` (float32, validated by the engine). */
+const f32Blob = customType<{
+  data: readonly number[];
+  driverData: string;
+  config: { dimensions: number };
+}>({
+  dataType(config) {
+    return `F32_BLOB(${config?.dimensions ?? 0})`;
+  },
+  toDriver(value) {
+    return JSON.stringify(value);
+  },
+});
+
+/**
+ * Open a libSQL-backed index with native ANN.
+ *
+ * DDL: `F32_BLOB(dims)` column + `libsql_vector_idx` ANN index (validated
+ * against `@libsql/client@0.17`). Queries run `vector_top_k` joined back to
+ * the base table — approximate nearest neighbours, never a full scan. Score
+ * is cosine similarity (`1 - vector_distance_cos`), matching the memory
+ * driver's higher-is-better convention.
+ *
+ * @param options - Name / dims / shared SQL connection
+ */
+export async function openLibsqlIndex(options: IndexOpenOptions): Promise<VectorIndexStore> {
+  const ownsSql = !options.sql;
+  const sql = options.sql ?? (await connectLibsql({ url: options.url }));
+  if (sql.driverId !== "libsql") {
+    if (ownsSql) await sql.close();
+    throw new Error(
+      `libsql index: needs a libsql SQL connection, got "${sql.driverId}" — ` +
+        `set store.sql to "libsql" so the index shares its connection`,
+    );
+  }
+
+  const tableName = `oke_idx_${options.name.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+  const indexName = `${tableName}_vec`;
+  const table = sqliteTable(tableName, {
+    id: text("id").primaryKey(),
+    embedding: f32Blob("embedding", { dimensions: options.dims }).notNull(),
+    meta: text("meta"),
+  });
+
+  await sql.exec(
+    `CREATE TABLE IF NOT EXISTS "${tableName}" (id TEXT PRIMARY KEY, embedding ${table.embedding.getSQLType()} NOT NULL, meta TEXT)`,
+  );
+  // ANN index — fails loud on engines without vector support (never falls back).
+  await sql.exec(
+    `CREATE INDEX IF NOT EXISTS "${indexName}" ON "${tableName}" (libsql_vector_idx(embedding))`,
+  );
+
+  return {
+    driverId: "libsql",
+    async upsert(id, vector, meta) {
+      if (vector.length !== options.dims) {
+        throw new Error(`vector dims ${vector.length} !== index dims ${options.dims}`);
+      }
+      await sql.exec(
+        `INSERT INTO "${tableName}" (id, embedding, meta) VALUES (?, vector32(?), ?) ` +
+          `ON CONFLICT (id) DO UPDATE SET embedding = excluded.embedding, meta = excluded.meta`,
+        [id, JSON.stringify(vector), meta ? JSON.stringify(meta) : null],
+      );
+    },
+    async search(vector, topK = 10): Promise<IndexHit[]> {
+      const k = Math.max(1, Math.floor(topK));
+      const rows = await sql.query(
+        `SELECT t.id AS id, t.meta AS meta, ` +
+          `vector_distance_cos(t.embedding, vector32(?)) AS distance ` +
+          `FROM vector_top_k('${indexName}', vector32(?), ${k}) AS i ` +
+          `JOIN "${tableName}" AS t ON t.rowid = i.id ` +
+          `ORDER BY distance ASC`,
+        [JSON.stringify(vector), JSON.stringify(vector)],
+      );
+      return rows.map((row) => {
+        const metaRaw = row.meta;
+        return {
+          id: String(row.id),
+          score: 1 - Number(row.distance),
+          meta:
+            typeof metaRaw === "string"
+              ? (JSON.parse(metaRaw) as Record<string, unknown>)
+              : undefined,
+        };
+      });
+    },
+    async delete(id) {
+      const result = await sql.exec(`DELETE FROM "${tableName}" WHERE id = ?`, [id]);
+      return result.changes > 0;
+    },
+    async close() {
+      if (ownsSql) await sql.close();
+    },
+  };
+}
+
+/** Protocol-named libsql index driver. */
+export const libsqlIndexDriver: VectorIndexDriver = {
+  id: "libsql",
+  facet: "index",
+  open: openLibsqlIndex,
+};

package/src/drivers/meilisearch.integration.test.ts

@@ -0,0 +1,77 @@
+/**
+ * Live Meilisearch round-trip — Arabic + typo tolerance.
+ *
+ * The only acceptable evidence that Meilisearch actually handles Arabic (not
+ * just "supported" in marketing copy) is a real round-trip against a live
+ * server: index Arabic content, then search it — with and without the
+ * definite article (ال), with diacritics stripped, and with a Latin typo that
+ * typo-tolerance must forgive.
+ *
+ * Gated on a live server: set `OKE_TEST_MEILI_URL` (and optionally
+ * `OKE_TEST_MEILI_KEY`). Without it the whole suite skips, so unit runs never
+ * depend on Docker or a spawned binary.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { openMeilisearchIndex, type MeilisearchIndexOptions } from "./meilisearch.ts";
+
+const URL = process.env.OKE_TEST_MEILI_URL;
+const KEY = process.env.OKE_TEST_MEILI_KEY;
+if (!URL) {
+  console.log("skip: live meilisearch e2e (OKE_TEST_MEILI_URL not set)");
+}
+const live = URL ? test : test.skip;
+
+const opened: Array<{ close(): Promise<void> }> = [];
+afterEach(async () => {
+  while (opened.length > 0) {
+    await opened.pop()?.close();
+  }
+});
+
+async function liveIndex(name: string): ReturnType<typeof openMeilisearchIndex> {
+  const opts: MeilisearchIndexOptions = { name, dims: 0, url: URL, apiKey: KEY };
+  const index = await openMeilisearchIndex(opts);
+  opened.push(index);
+  return index;
+}
+
+describe("meilisearch live — arabic + typo tolerance", () => {
+  live("indexes and searches Arabic content (round-trip)", async () => {
+    const index = await liveIndex(`ar-${crypto.randomUUID().slice(0, 8)}`);
+    await index.upsert("d1", { title: "كتاب عن محركات البحث" });
+    await index.upsert("d2", { title: "مقال عن قواعد البيانات" });
+
+    const found = await index.search("البحث", { topK: 5 });
+    expect(found.hits.length).toBeGreaterThan(0);
+    expect(found.hits[0]?.id).toBe("d1");
+  });
+
+  live("matches a query without the definite article ال", async () => {
+    const index = await liveIndex(`ar-${crypto.randomUUID().slice(0, 8)}`);
+    await index.upsert("d1", { title: "الكتاب" });
+    // Charabia segments/normalises ال, so the bare stem should still match.
+    const found = await index.search("كتاب", { topK: 5 });
+    expect(found.hits.map((h) => h.id)).toContain("d1");
+  });
+
+  live("typo tolerance forgives a latin misspelling", async () => {
+    const index = await liveIndex(`en-${crypto.randomUUID().slice(0, 8)}`);
+    await index.upsert("d1", { title: "search engine" });
+    // One-transposition typo ("serach") must still hit the document.
+    const found = await index.search("serach", { topK: 5 });
+    expect(found.hits.map((h) => h.id)).toContain("d1");
+  });
+
+  live("filter + facets aggregate real results", async () => {
+    const index = await liveIndex(`fac-${crypto.randomUUID().slice(0, 8)}`);
+    await index.upsert("d1", { title: "red apple", color: "red" });
+    await index.upsert("d2", { title: "green apple", color: "green" });
+    const found = await index.search("apple", {
+      topK: 5,
+      filter: "color = red",
+      facets: ["color"],
+    });
+    expect(found.hits.map((h) => h.id)).toEqual(["d1"]);
+  });
+});

package/src/drivers/meilisearch.test.ts

@@ -0,0 +1,181 @@
+/**
+ * `meilisearch` index driver — task-waited writes, relevance search mapping,
+ * and fail-loud semantics against an injected fetch (never a live server).
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+  MeilisearchUnavailableError,
+  meilisearchDriver,
+  openMeilisearchIndex,
+} from "./meilisearch.ts";
+
+/** A scripted Meilisearch over the wire — in-memory task + document store. */
+export function createMeilisearchFakeFetch(opts?: {
+  readonly failHealth?: boolean;
+  readonly failTask?: boolean;
+}): typeof fetch {
+  const documents = new Map<string, Record<string, unknown>>();
+  const taskResults = new Map<number, { fail: boolean }>();
+  let taskSeq = 0;
+
+  const json = (body: unknown, status = 200): Response =>
+    new Response(JSON.stringify(body), {
+      status,
+      headers: { "content-type": "application/json" },
+    });
+
+  const task = (type: string, fail: boolean): object => {
+    taskSeq += 1;
+    taskResults.set(taskSeq, { fail });
+    return { taskUid: taskSeq, indexUid: "kb", status: "enqueued", type };
+  };
+
+  return (async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const method = init?.method ?? "GET";
+
+    if (url.endsWith("/health")) {
+      if (opts?.failHealth) return json({ message: "down" }, 503);
+      return json({ status: "available" });
+    }
+
+    if (url.endsWith("/indexes") && method === "POST") {
+      return json(task("indexCreation", false), 202);
+    }
+
+    if (url.includes("/tasks/")) {
+      const taskUid = Number(url.split("/tasks/")[1]);
+      const fail = taskResults.get(taskUid)?.fail ?? false;
+      return json({
+        taskUid,
+        status: fail ? "failed" : "succeeded",
+        error: fail ? { message: "boom" } : null,
+      });
+    }
+
+    if (url.includes("/documents/") && method === "DELETE") {
+      const id = decodeURIComponent(url.split("/documents/")[1] ?? "");
+      if (!documents.delete(id)) return json({ message: "not found" }, 404);
+      return json(task("documentDeletion", opts?.failTask ?? false), 202);
+    }
+
+    if (url.endsWith("/documents") && method === "POST") {
+      const docs = JSON.parse(String(init?.body ?? "[]")) as Record<string, unknown>[];
+      if (!(opts?.failTask ?? false)) {
+        for (const doc of docs) documents.set(String(doc.id), doc);
+      }
+      return json(task("documentAdditionOrUpdate", opts?.failTask ?? false), 202);
+    }
+
+    if (url.endsWith("/search") && method === "POST") {
+      const {
+        q,
+        limit = 10,
+        facets,
+      } = JSON.parse(String(init?.body ?? "{}")) as {
+        q?: string;
+        limit?: number;
+        facets?: string[];
+      };
+      const query = (q ?? "").toLowerCase();
+      const hits = [...documents.values()]
+        .filter((doc) => query === "" || JSON.stringify(doc).toLowerCase().includes(query))
+        .slice(0, limit)
+        .map((doc) => ({ ...doc, _rankingScore: 0.95 }));
+      const facetDistribution: Record<string, Record<string, number>> = {};
+      for (const facet of facets ?? []) {
+        facetDistribution[facet] = { tagged: documents.size };
+      }
+      return json({
+        hits,
+        ...(facets && facets.length > 0 ? { facetDistribution } : {}),
+        estimatedTotalHits: hits.length,
+      });
+    }
+
+    return json({ message: `no route for ${method} ${url}` }, 404);
+  }) as typeof fetch;
+}
+
+describe("meilisearch driver", () => {
+  test("upsert → search maps _rankingScore into relevance score", async () => {
+    const index = await openMeilisearchIndex({
+      name: "kb",
+      dims: 0,
+      url: "http://127.0.0.1:7700",
+      apiKey: "master-key",
+      fetch: createMeilisearchFakeFetch(),
+    });
+    await index.upsert("d1", { title: "hello world", tag: "a" });
+    await index.upsert("d2", { title: "goodbye world", tag: "b" });
+
+    const found = await index.search("hello", { topK: 1 });
+    expect(found.hits).toHaveLength(1);
+    expect(found.hits[0]?.id).toBe("d1");
+    expect(found.hits[0]?.score).toBeGreaterThan(0);
+    expect(found.hits[0]?.meta).toMatchObject({ title: "hello world", tag: "a" });
+    await index.close();
+  });
+
+  test("facets return a facetDistribution", async () => {
+    const index = await openMeilisearchIndex({
+      name: "kb",
+      dims: 0,
+      url: "http://127.0.0.1:7700",
+      fetch: createMeilisearchFakeFetch(),
+    });
+    await index.upsert("d1", { title: "x", tag: "a" });
+    const found = await index.search("x", { facets: ["tag"] });
+    expect(found.facetDistribution).toEqual({ tag: { tagged: 1 } });
+    await index.close();
+  });
+
+  test("delete removes the document; missing id is false", async () => {
+    const index = await openMeilisearchIndex({
+      name: "kb",
+      dims: 0,
+      url: "http://127.0.0.1:7700",
+      fetch: createMeilisearchFakeFetch(),
+    });
+    await index.upsert("d1", { title: "x" });
+    expect(await index.delete("d1")).toBe(true);
+    expect(await index.delete("d1")).toBe(false);
+    await index.close();
+  });
+
+  test("missing URL fails loud (no memory fallback)", async () => {
+    await expect(openMeilisearchIndex({ name: "kb", dims: 0 })).rejects.toBeInstanceOf(
+      MeilisearchUnavailableError,
+    );
+  });
+
+  test("unhealthy server fails loud at open", async () => {
+    await expect(
+      openMeilisearchIndex({
+        name: "kb",
+        dims: 0,
+        url: "http://127.0.0.1:7700",
+        fetch: createMeilisearchFakeFetch({ failHealth: true }),
+      }),
+    ).rejects.toBeInstanceOf(MeilisearchUnavailableError);
+  });
+
+  test("a failed indexing task surfaces as a loud error, not a silent write", async () => {
+    const index = await openMeilisearchIndex({
+      name: "kb",
+      dims: 0,
+      url: "http://127.0.0.1:7700",
+      fetch: createMeilisearchFakeFetch({ failTask: true }),
+    });
+    await expect(index.upsert("d1", { title: "x" })).rejects.toBeInstanceOf(
+      MeilisearchUnavailableError,
+    );
+    await index.close();
+  });
+
+  test("driver id + facet", () => {
+    expect(meilisearchDriver.id).toBe("meilisearch");
+    expect(meilisearchDriver.facet).toBe("index");
+  });
+});

package/src/drivers/meilisearch.ts

@@ -0,0 +1,208 @@
+/**
+ * `meilisearch` index driver — full-text search over the Meilisearch HTTP API.
+ *
+ * Product-as-protocol id (same pattern as `openbao` / `pgvector`); the image
+ * pin lives in `images["store.index"]` (e.g. `getmeili/meilisearch`). This is
+ * a genuinely different capability from the vector ANN drivers — typo-tolerant
+ * / faceted full-text relevance, not cosine similarity.
+ *
+ * Fail-loud: a configured Meilisearch that is unreachable, unhealthy, or
+ * rejects a call throws {@link MeilisearchUnavailableError} — never silently
+ * falls back to memory. Writes wait for their task to succeed (Meilisearch is
+ * asynchronous), so an `upsert`/`delete` only resolves once the server has
+ * actually indexed it.
+ */
+
+import type {
+  IndexHit,
+  IndexOpenOptions,
+  TextIndexDriver,
+  TextIndexSearchOptions,
+  TextIndexSearchResult,
+  TextIndexStore,
+} from "./types.ts";
+
+/** Error thrown when the remote Meilisearch is unreachable / unhealthy / errors. */
+export class MeilisearchUnavailableError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "MeilisearchUnavailableError";
+  }
+}
+
+/** Minimal response shape of a Meilisearch summarized / finished task. */
+interface MeiliTask {
+  readonly taskUid: number;
+  readonly status: "enqueued" | "processing" | "succeeded" | "failed" | "canceled";
+  readonly error?: { readonly message?: string } | null;
+}
+
+/** Search response hit shape we consume. */
+interface MeiliSearchResponse {
+  readonly hits?: ReadonlyArray<Record<string, unknown> & { readonly _rankingScore?: number }>;
+  readonly facetDistribution?: Record<string, Record<string, number>>;
+}
+
+/** Options for opening a Meilisearch-backed text index. */
+export interface MeilisearchIndexOptions extends IndexOpenOptions {
+  /** Max ms to wait for an indexing task to finish (default 5000). */
+  readonly taskTimeoutMs?: number;
+}
+
+/**
+ * Open a full-text index.
+ *
+ * Ensures the index exists, health-checks the server, and returns a handle
+ * whose writes are confirmed (task-waited) and whose search maps
+ * `_rankingScore` into `IndexHit.score` as relevance.
+ *
+ * @param options - name / url / apiKey / injected fetch
+ */
+export async function openMeilisearchIndex(
+  options: MeilisearchIndexOptions,
+): Promise<TextIndexStore> {
+  const url = options.url?.replace(/\/$/, "");
+  if (!url) {
+    throw new MeilisearchUnavailableError(
+      "meilisearch index: needs an HTTP URL (OKE_STORE_INDEX_URL) — no silent memory fallback",
+    );
+  }
+  const apiKey = options.apiKey;
+  const fetchFn = options.fetch ?? globalThis.fetch;
+  const taskTimeoutMs = options.taskTimeoutMs ?? 5_000;
+  const uid = encodeURIComponent(options.name);
+
+  const headers: Record<string, string> = { "content-type": "application/json" };
+  if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+
+  async function request(path: string, init?: RequestInit): Promise<Response> {
+    let res: Response;
+    try {
+      res = await fetchFn(`${url}${path}`, {
+        ...init,
+        headers: { ...headers, ...(init?.headers ?? {}) },
+      });
+    } catch (err) {
+      throw new MeilisearchUnavailableError(
+        `meilisearch index: unreachable at ${url} — ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+    return res;
+  }
+
+  async function requestOk(path: string, init?: RequestInit): Promise<Response> {
+    const res = await request(path, init);
+    if (!res.ok) {
+      const detail = await res.text().catch(() => "");
+      throw new MeilisearchUnavailableError(
+        `meilisearch index: ${init?.method ?? "GET"} ${path} failed (${res.status})${detail ? ` — ${detail.slice(0, 200)}` : ""}`,
+      );
+    }
+    return res;
+  }
+
+  async function enqueue(path: string, init: RequestInit): Promise<MeiliTask> {
+    const res = await requestOk(path, init);
+    return (await res.json()) as MeiliTask;
+  }
+
+  async function waitForTask(taskUid: number): Promise<void> {
+    const deadline = Date.now() + taskTimeoutMs;
+    // Poll the task until it leaves the queue; treat a failed/canceled task as
+    // a loud error rather than an optimistic write.
+    for (;;) {
+      const res = await requestOk(`/tasks/${taskUid}`);
+      const task = (await res.json()) as MeiliTask;
+      if (task.status === "succeeded") return;
+      if (task.status === "failed" || task.status === "canceled") {
+        throw new MeilisearchUnavailableError(
+          `meilisearch index: task ${taskUid} ${task.status}${task.error?.message ? ` — ${task.error.message}` : ""}`,
+        );
+      }
+      if (Date.now() > deadline) {
+        throw new MeilisearchUnavailableError(
+          `meilisearch index: task ${taskUid} did not finish within ${taskTimeoutMs}ms`,
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+  }
+
+  // Fail loud up front: server must be healthy and the index must exist
+  // (created if absent) before we hand back a usable handle.
+  await requestOk("/health");
+  const created = await enqueue("/indexes", {
+    method: "POST",
+    body: JSON.stringify({ uid: options.name, primaryKey: "id" }),
+  });
+  await waitForTask(created.taskUid);
+
+  const scoreOf = (hit: { readonly _rankingScore?: unknown }): number =>
+    typeof hit._rankingScore === "number" ? hit._rankingScore : 0;
+
+  return {
+    driverId: "meilisearch",
+    async upsert(id, document) {
+      const body = [{ ...document, id }];
+      const task = await enqueue(`/indexes/${uid}/documents`, {
+        method: "POST",
+        body: JSON.stringify(body),
+      });
+      await waitForTask(task.taskUid);
+    },
+    async search(q, opts?: TextIndexSearchOptions): Promise<TextIndexSearchResult> {
+      const payload: Record<string, unknown> = {
+        q,
+        limit: opts?.topK ?? 10,
+        showRankingScore: true,
+      };
+      if (opts?.filter !== undefined) payload.filter = opts.filter;
+      if (opts?.facets !== undefined) payload.facets = opts.facets;
+      const res = await requestOk(`/indexes/${uid}/search`, {
+        method: "POST",
+        body: JSON.stringify(payload),
+      });
+      const body = (await res.json()) as MeiliSearchResponse;
+      const hits: IndexHit[] = (body.hits ?? []).map((hit) => {
+        const { _rankingScore, ...rest } = hit;
+        void _rankingScore;
+        const meta = Object.fromEntries(Object.entries(rest).filter(([key]) => key !== "id"));
+        return {
+          id: String(rest.id ?? ""),
+          score: scoreOf(hit),
+          ...(Object.keys(meta).length > 0 ? { meta } : {}),
+        };
+      });
+      return {
+        hits,
+        ...(body.facetDistribution !== undefined
+          ? { facetDistribution: body.facetDistribution }
+          : {}),
+      };
+    },
+    async delete(id) {
+      const res = await request(`/indexes/${uid}/documents/${encodeURIComponent(id)}`, {
+        method: "DELETE",
+      });
+      if (res.status === 404) return false;
+      if (!res.ok) {
+        throw new MeilisearchUnavailableError(
+          `meilisearch index: delete ${id} failed (${res.status})`,
+        );
+      }
+      const task = (await res.json()) as MeiliTask;
+      await waitForTask(task.taskUid);
+      return true;
+    },
+    async close() {
+      // Stateless HTTP client — nothing to release.
+    },
+  };
+}
+
+/** Protocol-named Meilisearch driver. */
+export const meilisearchDriver: TextIndexDriver = {
+  id: "meilisearch",
+  facet: "index",
+  open: openMeilisearchIndex,
+};

package/src/drivers/memory.ts

@@ -7,10 +7,10 @@ import type {
   FilesBucket,
   FilesDriver,
   FilesOpenOptions,
-  IndexDriver,
   IndexHit,
   IndexOpenOptions,
-  IndexStore,
+  VectorIndexDriver,
+  VectorIndexStore,
   KvDriver,
   KvNamespace,
   KvOpenOptions,
@@ -638,10 +638,10 @@ function cosine(a: readonly number[], b: readonly number[]): number {
 }
 
 /** Memory index driver. */
-export const memoryIndexDriver: IndexDriver = {
+export const memoryIndexDriver: VectorIndexDriver = {
   id: "memory",
   facet: "index",
-  async open(options: IndexOpenOptions): Promise<IndexStore> {
+  async open(options: IndexOpenOptions): Promise<VectorIndexStore> {
     const docs = new Map<string, { vector: number[]; meta?: Record<string, unknown> }>();
     return {
       driverId: "memory",