meminbox 0.0.0-stage → 0.2.1

package/.env.example

@@ -0,0 +1,19 @@
+# --- Supabase (your own project; use a DEDICATED project for memory) ---
+# Project Settings > API
+SUPABASE_URL=https://your-project.supabase.co
+# Server-side only. Never expose this to browsers or commit it.
+# The MCP server / CLI run on your machine, so the service role key stays local.
+SUPABASE_SERVICE_ROLE_KEY=
+
+# --- Embeddings (optional) ---
+# Without this, search falls back to full-text only and everything still works.
+# Model changes require a full reindex: embeddings are a derived index, not the source of truth.
+OPENAI_API_KEY=
+EMBEDDING_MODEL=text-embedding-3-small
+EMBEDDING_DIMS=1536
+
+# --- Defaults ---
+# Project slug used when a write does not name one.
+MEMORY_DEFAULT_PROJECT=default
+# Actor name recorded in provenance / audit log for this process (e.g. claude-code, codex, cursor).
+MEMORY_ACTOR=cli

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 daaquan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,163 @@
-# Temporary Holding Version
+# meminbox
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**Every agent writes to the inbox. Only reviewed memory becomes shared truth.**
+
+Shared memory for AI agents, stored in **your own Supabase project**.
+
+One memory that Claude Code, Codex, Cursor and any other MCP client read and
+write through the same interface — instead of every agent keeping its own
+private notes that die with its session.
+
+## Design (the parts that matter)
+
+This project borrows Cerefox's philosophy and uses extraction (the mem0
+idea) as a component — in that order, on purpose:
+
+1. **Documents are the source of truth.**
+   Memory is human-readable Markdown in a Postgres table (`documents`).
+   You can read it, edit it, export it with `pg_dump`, and leave with it.
+   No proprietary payload, no lock-in.
+2. **Vectors are a derived index, never the truth.**
+   `document_chunks` + pgvector exist only to make search better. Drop them
+   and run `meminbox reindex` and they come back. Changing the embedding
+   model is a reindex, not a migration.
+3. **Agent writes land in an inbox first.**
+   Shared memory amplifies errors: one agent's wrong note becomes every
+   agent's fact. So writes default to `status = 'inbox'` and only become
+   trusted memory on `promote`. Every document carries **provenance**
+   (which agent, which session, what source) and every action is in
+   `audit_log`.
+4. **Extraction is a replaceable component, not the foundation.**
+   `src/extract.ts` turns raw transcripts into inbox candidates. It is a
+   small interface — swap in mem0, a local model, anything — because
+   extracted facts are inputs to review, not the store itself.
+5. **Keyword search is a first-class mode.**
+   At personal scale (hundreds–thousands of documents), full-text +
+   substring search carries most of the weight. Embeddings are optional:
+   no `OPENAI_API_KEY`, no vector search, everything else still works.
+
+## Architecture
+
+```
+ Claude Code ─┐
+ Codex ───────┤  MCP (stdio)        ┌──────────────────────────────┐
+ Cursor ──────┼───────────────────► │ meminbox MCP server      │
+ Muse (files)┤  CLI / import        │  search · write · extract    │
+ Human ───────┘  CLI + Supabase UI  └──────────────┬───────────────┘
+                                                   │ service role (local only)
+                                        ┌──────────▼───────────────┐
+                                        │ Your Supabase project    │
+                                        │  documents  (truth)      │
+                                        │  document_chunks (index) │
+                                        │  audit_log               │
+                                        └──────────────────────────┘
+```
+
+## Setup
+
+### 1. Create a Supabase project
+
+Use a **dedicated** project for memory (don't mix it into an app's project).
+Free tier is enough. You'll need:
+
+- the project URL and **service role** key (Project Settings → API)
+- optionally, the Postgres **connection string** (Project Settings →
+  Database) — if you provide it, `init` applies the schema for you;
+  it is used once and never saved
+
+### 2. Install
+
+```bash
+npm install -g meminbox
+# from source instead: npm install -g github:daaquan/meminbox
+```
+
+### 3. Initialise
+
+```bash
+meminbox init
+```
+
+This prompts for your Supabase credentials, applies the schema when a
+connection string is provided (otherwise it tells you which SQL file to
+paste into the Supabase SQL Editor), saves your configuration to
+`~/.meminbox/.env` (mode `0600`), and smoke-tests the connection.
+
+Non-interactive form:
+
+```bash
+meminbox init --yes \
+  --url https://your-project.supabase.co \
+  --service-key <service-role-key> \
+  --database-url <postgres-connection-string>
+```
+
+### 4. Connect your agents
+
+```bash
+meminbox configure-agent --tool claude-code   # or: codex | cursor | claude-desktop
+```
+
+This writes the MCP server entry into the client's own config file
+(backing up the previous one to `<file>.bak`). The entry contains **no
+secrets** — the server reads `~/.meminbox/.env` itself. Each client gets
+its own `MEMORY_ACTOR`, so provenance shows which agent wrote what.
+Use `--print` to preview the entry without writing anything.
+Restart the client afterwards.
+
+### 5. First memory
+
+```bash
+meminbox add --title "How we deploy" --text "Staging first, then prod. See runbook." --active
+meminbox search "deploy"
+```
+
+### Development (from a clone)
+
+```bash
+npm install        # then: npm run build to refresh dist/ (dist/ is committed
+                   # so git-based installs work without building)
+npm test
+npm run cli -- list
+```
+
+## MCP tools
+
+| Tool | What it does |
+|---|---|
+| `memory_search` | Hybrid search over **active** memory (`includeInbox` to also search the inbox) |
+| `memory_read` | Read a document in full |
+| `memory_write` | Write a document — **inbox by default** |
+| `memory_extract` | Extract durable candidates from raw text into the inbox |
+| `memory_promote` | Promote inbox → active, or archive |
+| `memory_list` | List documents by status |
+| `memory_projects` | List projects (namespaces) |
+
+## Security notes (read before connecting anything)
+
+- Access is **service-role from your own machines only**. The service
+  role key bypasses RLS; treat it like a root password. `meminbox init`
+  keeps it in exactly one place — `~/.meminbox/.env`, mode `0600` — and
+  agent client configs never contain it. Never put it in a
+  browser, a hosted endpoint, or a repo.
+- RLS is enabled with no public policies on purpose. A future remote MCP
+  endpoint must add per-agent tokens and explicit policies first.
+- Anything an agent can read, a prompt injection in its input can try to
+  exfiltrate. The inbox/promote gate limits *writes*; reads of active memory
+  are trusted-agent-only by design.
+
+## Known limitations / roadmap
+
+- Search RPCs don't filter by project yet (single-project use is the v0
+  assumption); project filtering is the next migration.
+- `embedBatch` is sequential; reindex of large libraries will want batching.
+- No web UI yet: the human window is the CLI + Supabase Table Editor.
+  A small read/review UI for the inbox is the natural next step.
+- No remote (HTTP) MCP transport yet — stdio only, one process per client,
+  all sharing the same database.
+- Muse's own file-based memory does not plug into this directly; bridging
+  it means an import/export sync, which is intentionally not faked here.
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/agents.js

@@ -0,0 +1,112 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
+import { homedir, platform } from "node:os";
+import { dirname, join } from "node:path";
+export const AGENT_TOOLS = [
+    "claude-code",
+    "codex",
+    "cursor",
+    "claude-desktop",
+];
+export function mcpServerEntry(actor) {
+    return { command: "meminbox-mcp", args: [], env: { MEMORY_ACTOR: actor } };
+}
+/** Merge the meminbox entry into an MCP JSON config (pure; unit-tested). */
+export function mergeMcpJson(existingText, entry) {
+    const root = existingText ? JSON.parse(existingText) : {};
+    const servers = (root.mcpServers ?? {});
+    servers.meminbox = entry;
+    root.mcpServers = servers;
+    return JSON.stringify(root, null, 2) + "\n";
+}
+export function codexTomlBlock(actor) {
+    return [
+        "[mcp_servers.meminbox]",
+        'command = "meminbox-mcp"',
+        "args = []",
+        "",
+        "[mcp_servers.meminbox.env]",
+        `MEMORY_ACTOR = "${actor}"`,
+        "",
+    ].join("\n");
+}
+/** Insert or replace the meminbox section in Codex's config.toml (pure). */
+export function upsertCodexToml(existingText, actor) {
+    const lines = existingText.split(/\r?\n/);
+    const kept = [];
+    let skipping = false;
+    for (const line of lines) {
+        const header = line.match(/^\s*\[([^\]]+)\]\s*$/);
+        if (header) {
+            skipping =
+                header[1] === "mcp_servers.meminbox" ||
+                    header[1] === "mcp_servers.meminbox.env";
+        }
+        if (!skipping)
+            kept.push(line);
+    }
+    const base = kept.join("\n").replace(/\n+$/, "");
+    return (base ? base + "\n\n" : "") + codexTomlBlock(actor);
+}
+export function agentConfigPath(tool) {
+    const home = homedir();
+    switch (tool) {
+        case "claude-code":
+            return join(home, ".claude.json");
+        case "cursor":
+            return join(home, ".cursor", "mcp.json");
+        case "codex":
+            return join(home, ".codex", "config.toml");
+        case "claude-desktop": {
+            if (platform() === "darwin") {
+                return join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+            }
+            if (platform() === "win32") {
+                return join(process.env.APPDATA ?? home, "Claude", "claude_desktop_config.json");
+            }
+            return join(home, ".config", "Claude", "claude_desktop_config.json");
+        }
+    }
+}
+function onPath(bin) {
+    const exts = platform() === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+    for (const dir of (process.env.PATH ?? "").split(":")) {
+        for (const ext of exts) {
+            if (dir && existsSync(join(dir, bin + ext)))
+                return true;
+        }
+    }
+    return false;
+}
+export function runConfigureAgent(argv) {
+    const toolIdx = argv.indexOf("--tool");
+    const tool = toolIdx >= 0 ? argv[toolIdx + 1] : undefined;
+    if (!tool || !AGENT_TOOLS.includes(tool)) {
+        throw new Error(`usage: meminbox configure-agent --tool <${AGENT_TOOLS.join("|")}> [--print]`);
+    }
+    const printOnly = argv.includes("--print");
+    const actorIdx = argv.indexOf("--actor");
+    const actor = actorIdx >= 0 ? argv[actorIdx + 1] : tool;
+    const path = agentConfigPath(tool);
+    const existing = existsSync(path) ? readFileSync(path, "utf8") : null;
+    const next = tool === "codex"
+        ? upsertCodexToml(existing ?? "", actor)
+        : mergeMcpJson(existing, mcpServerEntry(actor));
+    if (printOnly) {
+        console.log(`# ${path}\n`);
+        console.log(next);
+        return;
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    if (existing !== null)
+        copyFileSync(path, `${path}.bak`);
+    writeFileSync(path, next);
+    console.log(`configured ${tool}: meminbox MCP server written to ${path}`);
+    if (existing !== null)
+        console.log(`previous config backed up to ${path}.bak`);
+    if (!onPath("meminbox-mcp")) {
+        console.log("note: `meminbox-mcp` is not on your PATH yet. Install meminbox globally first:\n" +
+            "  npm install -g github:daaquan/meminbox");
+    }
+    console.log("restart the agent client to pick up the new MCP server.");
+}
+//# sourceMappingURL=agents.js.map

package/dist/chunk.js

@@ -0,0 +1,48 @@
+/**
+ * Split Markdown into chunks for the derived vector index.
+ *
+ * Rules (kept deliberately simple and deterministic):
+ * - Split on heading boundaries first, then on blank lines.
+ * - Greedily pack paragraphs up to `maxChars`.
+ * - A single oversized paragraph is hard-split with `overlap` characters
+ *   carried into the next chunk.
+ * The document itself is never modified — chunks are disposable.
+ */
+export function chunkMarkdown(markdown, opts = {}) {
+    const maxChars = opts.maxChars ?? 1200;
+    const overlap = opts.overlap ?? 120;
+    if (maxChars <= 0)
+        throw new Error("maxChars must be positive");
+    const blocks = markdown
+        .split(/\n(?=#{1,6}\s)/) // keep headings with the block that follows
+        .flatMap((section) => section.split(/\n{2,}/))
+        .map((b) => b.trim())
+        .filter((b) => b.length > 0);
+    const chunks = [];
+    let current = "";
+    const flush = () => {
+        if (current.trim().length > 0)
+            chunks.push(current.trim());
+        current = "";
+    };
+    for (const block of blocks) {
+        if (block.length > maxChars) {
+            flush();
+            let rest = block;
+            while (rest.length > maxChars) {
+                chunks.push(rest.slice(0, maxChars));
+                rest = rest.slice(maxChars - overlap);
+            }
+            if (rest.trim().length > 0)
+                current = rest;
+            continue;
+        }
+        if (current.length > 0 && current.length + block.length + 2 > maxChars) {
+            flush();
+        }
+        current = current.length > 0 ? `${current}\n\n${block}` : block;
+    }
+    flush();
+    return chunks;
+}
+//# sourceMappingURL=chunk.js.map

package/dist/cli.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { runConfigureAgent } from "./agents.js";
+import { loadConfig } from "./config.js";
+import { createDb } from "./db.js";
+import { extractCandidates } from "./extract.js";
+import { runInit } from "./init.js";
+import { MemoryService } from "./memory.js";
+/**
+ * The human's window into the same memory the agents use.
+ *
+ * Setup:
+ *   meminbox init [--url <url> --service-key <key> --database-url <url>]
+ *   meminbox configure-agent --tool <claude-code|codex|cursor|claude-desktop> [--print]
+ *
+ * Memory:
+ *   meminbox search <query>
+ *   meminbox add --title <t> [--file <path> | --text <md>] [--active]
+ *   meminbox list [--status inbox|active|archived]
+ *   meminbox promote <id> | archive <id>
+ *   meminbox extract --file <transcript>
+ *   meminbox reindex
+ *   meminbox projects
+ */
+const [cmd, ...rest] = process.argv.slice(2);
+function flag(name) {
+    const i = rest.indexOf(`--${name}`);
+    return i >= 0 ? rest[i + 1] : undefined;
+}
+function positional(i) {
+    return rest.filter((a) => !a.startsWith("--"))[i];
+}
+// Setup commands run BEFORE any config exists — they must not load it.
+if (cmd === "init") {
+    await runInit(rest);
+    process.exit(0);
+}
+if (cmd === "configure-agent") {
+    runConfigureAgent(rest);
+    process.exit(0);
+}
+let cfg;
+let memory;
+try {
+    cfg = loadConfig();
+    memory = new MemoryService(cfg, createDb(cfg));
+}
+catch (err) {
+    if (cmd === undefined) {
+        console.log("usage: meminbox <init|configure-agent|search|add|list|promote|archive|extract|reindex|projects>\n" +
+            "start with: meminbox init");
+        process.exit(0);
+    }
+    throw err;
+}
+switch (cmd) {
+    case "search": {
+        const query = rest.join(" ");
+        if (!query)
+            throw new Error("usage: meminbox search <query>");
+        const hits = await memory.search(query, { limit: 10 });
+        for (const h of hits) {
+            console.log(`\n## ${h.title}  [${h.documentId}] score=${h.score.toFixed(2)} via=${h.via.join("+")}`);
+            console.log(h.snippet.replace(/\s+/g, " ").trim());
+        }
+        if (hits.length === 0)
+            console.log("no hits");
+        break;
+    }
+    case "add": {
+        const title = flag("title");
+        if (!title)
+            throw new Error("usage: meminbox add --title <t> [--file <path> | --text <md>]");
+        const content = flag("file")
+            ? readFileSync(flag("file"), "utf8")
+            : (flag("text") ?? "");
+        if (!content)
+            throw new Error("provide --file or --text");
+        const doc = await memory.writeDocument({
+            title,
+            contentMd: content,
+            projectSlug: flag("project"),
+            status: rest.includes("--active") ? "active" : "inbox",
+            provenance: { source: "cli" },
+        });
+        console.log(`${doc.status}: ${doc.id} ${doc.title}`);
+        break;
+    }
+    case "list": {
+        const status = flag("status");
+        const docs = await memory.listDocuments({ status, limit: 50 });
+        for (const d of docs) {
+            console.log(`${d.status.padEnd(8)} ${d.id}  ${d.title}  (${d.source_agent ?? "?"}, ${d.updated_at})`);
+        }
+        break;
+    }
+    case "promote":
+    case "archive": {
+        const id = positional(0);
+        if (!id)
+            throw new Error(`usage: meminbox ${cmd} <id>`);
+        const doc = await memory.setStatus(id, cmd === "promote" ? "active" : "archived");
+        console.log(`${doc.status}: ${doc.id} ${doc.title}`);
+        break;
+    }
+    case "extract": {
+        const file = flag("file");
+        if (!file)
+            throw new Error("usage: meminbox extract --file <transcript>");
+        const candidates = await extractCandidates(cfg, readFileSync(file, "utf8"));
+        for (const c of candidates) {
+            const doc = await memory.writeDocument({
+                title: c.title,
+                contentMd: c.contentMd,
+                provenance: { source: "extraction" },
+            });
+            console.log(`inbox: ${doc.id} ${doc.title}`);
+        }
+        if (candidates.length === 0)
+            console.log("nothing durable extracted");
+        break;
+    }
+    case "reindex": {
+        const n = await memory.reindexAll();
+        console.log(`reindexed ${n} documents`);
+        break;
+    }
+    case "projects": {
+        for (const p of await memory.listProjects())
+            console.log(`${p.slug}\t${p.name}`);
+        break;
+    }
+    default:
+        console.log("usage: meminbox <init|configure-agent|search|add|list|promote|archive|extract|reindex|projects>");
+        process.exit(cmd ? 1 : 0);
+}
+//# sourceMappingURL=cli.js.map

package/dist/config.js

@@ -0,0 +1,21 @@
+import { loadEnvFiles } from "./dotenv.js";
+function required(name) {
+    const v = process.env[name];
+    if (!v) {
+        throw new Error(`Missing required env var: ${name}. Run \`meminbox init\` or see .env.example`);
+    }
+    return v;
+}
+export function loadConfig() {
+    loadEnvFiles();
+    return {
+        supabaseUrl: required("SUPABASE_URL"),
+        supabaseServiceRoleKey: required("SUPABASE_SERVICE_ROLE_KEY"),
+        openaiApiKey: process.env.OPENAI_API_KEY || null,
+        embeddingModel: process.env.EMBEDDING_MODEL || "text-embedding-3-small",
+        embeddingDims: Number(process.env.EMBEDDING_DIMS || 1536),
+        defaultProject: process.env.MEMORY_DEFAULT_PROJECT || "default",
+        actor: process.env.MEMORY_ACTOR || "cli",
+    };
+}
+//# sourceMappingURL=config.js.map

package/dist/db.js

@@ -0,0 +1,7 @@
+import { createClient } from "@supabase/supabase-js";
+export function createDb(cfg) {
+    return createClient(cfg.supabaseUrl, cfg.supabaseServiceRoleKey, {
+        auth: { persistSession: false },
+    });
+}
+//# sourceMappingURL=db.js.map

package/dist/dotenv.js

@@ -0,0 +1,64 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** Directory holding the user's meminbox configuration (~/.meminbox). */
+export function meminboxHome() {
+    return process.env.MEMINBOX_HOME || join(homedir(), ".meminbox");
+}
+export function meminboxEnvPath() {
+    return join(meminboxHome(), ".env");
+}
+/**
+ * Minimal .env parser: KEY=value lines, `#` comments, optional quotes.
+ * Deliberately tiny — the file format we write in `init` is our own.
+ */
+export function parseDotEnv(text) {
+    const out = {};
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const eq = line.indexOf("=");
+        if (eq <= 0)
+            continue;
+        const key = line.slice(0, eq).trim();
+        let value = line.slice(eq + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        out[key] = value;
+    }
+    return out;
+}
+/**
+ * Load configuration files into process.env WITHOUT overriding variables
+ * that are already set. Lookup order:
+ *   1. ~/.meminbox/.env  (written by `meminbox init` — the normal case)
+ *   2. ./.env            (project-local, for development)
+ * Real environment variables always win over both files.
+ */
+export function loadEnvFiles() {
+    for (const path of [meminboxEnvPath(), join(process.cwd(), ".env")]) {
+        if (!existsSync(path))
+            continue;
+        const parsed = parseDotEnv(readFileSync(path, "utf8"));
+        for (const [key, value] of Object.entries(parsed)) {
+            if (process.env[key] === undefined)
+                process.env[key] = value;
+        }
+    }
+}
+/** Serialise values back to .env text (used by `init`). */
+export function formatDotEnv(values) {
+    const lines = [
+        "# meminbox configuration — written by `meminbox init`.",
+        "# Contains secrets (service role key). Keep this file private (mode 0600).",
+        "",
+    ];
+    for (const [key, value] of Object.entries(values)) {
+        lines.push(`${key}=${value}`);
+    }
+    return lines.join("\n") + "\n";
+}
+//# sourceMappingURL=dotenv.js.map

package/dist/embeddings.js

@@ -0,0 +1,39 @@
+/**
+ * Embeddings are OPTIONAL and DERIVED.
+ * - No OPENAI_API_KEY -> returns null, callers fall back to keyword search.
+ * - The embedding model/dims are configuration, not truth: changing them
+ *   only means the chunk index must be rebuilt (`meminbox reindex`).
+ */
+export async function embedText(cfg, text) {
+    if (!cfg.openaiApiKey)
+        return null;
+    const res = await fetch("https://api.openai.com/v1/embeddings", {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${cfg.openaiApiKey}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ model: cfg.embeddingModel, input: text }),
+    });
+    if (!res.ok) {
+        throw new Error(`Embedding request failed: ${res.status} ${await res.text()}`);
+    }
+    const json = (await res.json());
+    const vec = json.data[0]?.embedding;
+    if (!vec)
+        throw new Error("Embedding response had no vector");
+    if (vec.length !== cfg.embeddingDims) {
+        throw new Error(`Embedding dims mismatch: model returned ${vec.length}, schema expects ${cfg.embeddingDims}. ` +
+            `Set EMBEDDING_DIMS to match the model, or keep the default model.`);
+    }
+    return vec;
+}
+export async function embedBatch(cfg, texts) {
+    // v0: sequential calls keep failure handling simple. Batching is a
+    // performance optimisation that belongs in the reindex path later.
+    const out = [];
+    for (const t of texts)
+        out.push(await embedText(cfg, t));
+    return out;
+}
+//# sourceMappingURL=embeddings.js.map