pi-vault-mind 0.7.1 → 0.7.3

package/dist/src/sync.js

@@ -0,0 +1,211 @@
+/**
+ * Modal vector sync engine.
+ *
+ * Drains `ModalEmbeddingClient.exportAll(collection, …)` into the local
+ * LanceDB via the precomputed-vector insert path (`upsertPrecomputed`), and
+ * persists a per-(collection, model, dim) `seq` watermark (ADR-4) so
+ * incremental syncs resume from where the last one left off.
+ *
+ * Idempotent: rows are keyed by `id` and applied with merge-insert, so
+ * re-fetching a boundary row is a no-op and re-running a sync with no new rows
+ * changes nothing but the (unchanged) watermark.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { upsertPrecomputed } from "./lance.js";
+import { createModalClient, resolveDim, resolveModel } from "./modal-config.js";
+const stateKey = (collection, model, dim) => `${collection}__${model}__${dim}`;
+const resolveWatermarkFile = (cfg) => {
+    const wiki = cfg.wiki;
+    const rel = wiki.embedding.modal?.sync?.watermarkPath || "_sync_state.json";
+    const dataDir = wiki.dataDir;
+    const absDir = path.isAbsolute(dataDir) ? dataDir : path.resolve(dataDir);
+    return path.isAbsolute(rel) ? rel : path.join(absDir, rel);
+};
+export const loadSyncState = (cfg) => {
+    const p = resolveWatermarkFile(cfg);
+    try {
+        if (fs.existsSync(p)) {
+            const raw = JSON.parse(fs.readFileSync(p, "utf-8"));
+            return { watermarks: raw?.watermarks ?? {} };
+        }
+    }
+    catch (err) {
+        console.warn(`[pi-vault-mind] Failed to read sync state at ${p}: ${err.message}`);
+    }
+    return { watermarks: {} };
+};
+export const saveSyncState = (cfg, state) => {
+    const p = resolveWatermarkFile(cfg);
+    const dir = path.dirname(p);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(p, `${JSON.stringify(state, null, 2)}\n`, "utf-8");
+};
+/** Current watermark for a (collection, model, dim), default 0. */
+export const getWatermark = (cfg, collection, model, dim) => loadSyncState(cfg).watermarks[stateKey(collection, model, dim)] ?? 0;
+// ── Collection discovery ────────────────────────────────────────────────────
+/** List the collections/tables held in the server-side vector store. */
+export const listRemoteCollections = async (cfg) => {
+    const client = createModalClient(cfg.wiki);
+    if (!client)
+        throw new Error("Modal not configured (missing baseUrl or token).");
+    return client.syncCollections();
+};
+/**
+ * Resolve the dim to sync for a collection+model. Config dim wins; otherwise the
+ * server's table dim is discovered via `/sync/collections`. Returns null when
+ * the server has no table for that collection+model (nothing to sync).
+ */
+const resolveSyncDim = async (cfg, collection, model) => {
+    const configured = resolveDim(cfg.wiki, collection);
+    if (configured != null)
+        return configured;
+    const remote = await listRemoteCollections(cfg);
+    const match = remote.find((c) => c.collection === collection && c.model === model);
+    return match?.dim ?? null;
+};
+/**
+ * Sync a single collection from the server into the local LanceDB. Incremental
+ * by default (from the persisted watermark); `full` re-pulls from seq 0. Rows
+ * are merge-inserted by `id` (idempotent). Returns the row count + new
+ * watermark. A re-run with no new rows is a no-op (rows: 0, watermark unchanged).
+ */
+export const syncCollection = async (cfg, collection, opts = {}) => {
+    const wiki = cfg.wiki;
+    const client = createModalClient(wiki);
+    if (!client)
+        throw new Error("Modal not configured (missing baseUrl or token).");
+    const model = resolveModel(wiki, collection);
+    const dim = await resolveSyncDim(cfg, collection, model);
+    if (dim == null) {
+        return {
+            collection,
+            model,
+            dim: resolveDim(wiki, collection) ?? 0,
+            rows: 0,
+            watermark: 0,
+            full: !!opts.full,
+        };
+    }
+    const state = loadSyncState(cfg);
+    const key = stateKey(collection, model, dim);
+    const since = opts.full ? 0 : (state.watermarks[key] ?? 0);
+    const pageSize = wiki.embedding.modal?.sync?.pageSize ?? 500;
+    let rows = 0;
+    const watermark = await client.exportAll(collection, async (page) => {
+        const withVectors = page.filter((r) => Array.isArray(r.vector) && r.vector.length > 0);
+        if (withVectors.length < page.length) {
+            console.warn(`[pi-vault-mind] sync: skipped ${page.length - withVectors.length} vector-less row(s) for "${collection}"`);
+        }
+        if (withVectors.length === 0)
+            return;
+        await upsertPrecomputed(wiki.dataDir, collection, model, dim, withVectors, wiki);
+        rows += withVectors.length;
+        opts.onProgress?.(rows);
+    }, { model, dim, since, limit: pageSize });
+    state.watermarks[key] = watermark;
+    saveSyncState(cfg, state);
+    return { collection, model, dim, rows, watermark, full: !!opts.full };
+};
+/**
+ * Sync every configured collection (or a caller-supplied list). Collections
+ * with no server-side table report `rows: 0` and are skipped harmlessly.
+ */
+export const syncAll = async (cfg, collections, opts = {}) => {
+    const syncCfg = cfg.wiki.embedding.modal?.sync;
+    const names = collections ?? syncCfg?.collections ?? Object.keys(cfg.collections);
+    const results = [];
+    for (const name of names) {
+        if (!cfg.collections[name])
+            continue;
+        try {
+            results.push(await syncCollection(cfg, name, opts));
+        }
+        catch (err) {
+            console.warn(`[pi-vault-mind] sync "${name}" failed: ${err.message}`);
+            results.push({
+                collection: name,
+                model: resolveModel(cfg.wiki, name),
+                dim: resolveDim(cfg.wiki, name) ?? 0,
+                rows: 0,
+                watermark: 0,
+                full: !!opts.full,
+            });
+        }
+    }
+    return results;
+};
+/**
+ * Read a collection's JSONL (the source of truth), submit a Modal bulk embedding
+ * job, poll it to completion, then sync the freshly-embedded vectors down into
+ * the local LanceDB. Used by `/wiki reindex --all --reembed --remote`. Local
+ * re-embed remains the default; this offloads bulk embedding to cloud GPUs.
+ *
+ * Records map the JSONL entry's embeddable field (`fact`) to `text` and the
+ * remaining fields to `metadata`, so sync-down can reconstruct the local row.
+ */
+export const reindexRemote = async (cfg, collections, opts = {}) => {
+    const wiki = cfg.wiki;
+    const client = createModalClient(wiki);
+    if (!client)
+        throw new Error("Modal not configured (missing baseUrl or token).");
+    const model = resolveModel(wiki);
+    const dim = resolveDim(wiki);
+    const out = [];
+    for (const collection of collections) {
+        const def = cfg.collections[collection];
+        if (!def) {
+            out.push({ collection, error: "unknown collection" });
+            continue;
+        }
+        try {
+            const lines = fs.existsSync(def.path)
+                ? fs.readFileSync(def.path, "utf-8").split("\n").filter(Boolean)
+                : [];
+            const records = [];
+            for (const line of lines) {
+                try {
+                    const entry = JSON.parse(line);
+                    const text = String(entry.fact ?? entry.content ?? "");
+                    if (!text)
+                        continue;
+                    const { id, fact, content, ...rest } = entry;
+                    records.push({
+                        id: String(id ?? crypto.randomUUID()),
+                        text,
+                        metadata: rest,
+                    });
+                }
+                catch {
+                    /* skip malformed */
+                }
+            }
+            if (records.length === 0) {
+                out.push({ collection, error: "no records to embed" });
+                continue;
+            }
+            const submitted = await client.submitJob(collection, records, { model, dim });
+            let status;
+            try {
+                status = await client.waitForJob(submitted.job_id, opts.pollMs ?? 2000);
+                opts.onStatus?.(status);
+            }
+            catch (err) {
+                out.push({ collection, error: `job poll failed: ${err.message}` });
+                continue;
+            }
+            if (status?.status !== "done") {
+                out.push({ collection, job: status, error: status?.error || `job ${status?.status}` });
+                continue;
+            }
+            // Pull the freshly-embedded vectors down (full, from seq 0).
+            const sync = await syncCollection(cfg, collection, { full: true });
+            out.push({ collection, job: status, sync });
+        }
+        catch (err) {
+            out.push({ collection, error: err.message });
+        }
+    }
+    return out;
+};

package/dist/src/types.d.ts

@@ -12,10 +12,116 @@ export interface InjectorDef {
     artifactPath?: string;
     template?: string;
 }
+/**
+ * Configuration for the Modal embedding service (see `src/modal-client.ts`
+ * and `docs/MODAL_EMBEDDING.md`). Optional — only needed when
+ * `provider: "modal"` is selected.
+ *
+ * The canonical model owns the vector space (see the shared strategy: one
+ * model, no cross-model alignment adapters). A single query never mixes
+ * `model__dim` spaces; changing the canonical model is a re-embed migration,
+ * not a translation.
+ */
+export interface ModalEmbeddingConfig {
+    /** Base URL of the deployed Modal ASGI app (no trailing slash needed). */
+    baseUrl?: string;
+    /**
+     * Modal workspace slug. When set, the extension derives `baseUrl` from the
+     * canonical app name if `baseUrl` itself is not set.
+     */
+    workspace?: string;
+    /**
+     * Bearer token matching the `pi-vault-mind-auth` Modal secret. Prefer
+     * setting via the `PVM_API_TOKEN` env var over committing it to config;
+     * the env var always wins and is preferred when both are set.
+     */
+    apiToken?: string;
+    /** Canonical embedder key, e.g. "embeddinggemma". Default "embeddinggemma". */
+    model?: string;
+    /** Matryoshka output dimension (omit to resolve the model's native dim). */
+    dim?: number;
+    /**
+     * Offline fallback policy. When Modal is unreachable the search path
+     * falls back to a configured local provider *only if* it produces vectors
+     * in the same `model__dim` space (so the same table can be queried);
+     * otherwise it degrades to FTS/keyword search — it never crashes a search.
+     */
+    fallback?: ModalFallbackConfig;
+    /** Sync-down options (pulling server-side vectors into the local LanceDB). */
+    sync?: ModalSyncConfig;
+}
+/**
+ * Offline fallback policy for the Modal provider.
+ */
+export interface ModalFallbackConfig {
+    /** Whether to fall back at all when Modal is offline. Default true. */
+    enabled?: boolean;
+    /**
+     * Local provider to use when Modal is unreachable ("ollama" |
+     * "transformers"). Must serve the same canonical `model__dim` to query the
+     * same namespaced table; if the space differs, search degrades to FTS.
+     */
+    provider?: "ollama" | "transformers";
+}
+/**
+ * Sync-down options. The local side pulls server-side vectors (already
+ * embedded) into its own LanceDB and keeps working offline.
+ */
+export interface ModalSyncConfig {
+    /** Collections to sync. Defaults to all configured collections. */
+    collections?: string[];
+    /** Page size for incremental export pulls. Default 500. */
+    pageSize?: number;
+    /** Auto-sync enabled (off by default). */
+    autoSync?: boolean;
+    /** Auto-sync interval in ms. Default 300000 (5 minutes). */
+    autoSyncIntervalMs?: number;
+    /**
+     * Watermark store location, relative to `wiki.dataDir` or absolute.
+     * Default `_sync_state.json`.
+     */
+    watermarkPath?: string;
+}
+/**
+ * Coalescer knobs (see `src/embed-queue.ts`). Applies to any provider routed
+ * through the coalescer (modal + local providers that opt in). Sensible
+ * defaults match the watcher's feel (≈1000ms debounce).
+ */
+export interface CoalesceConfig {
+    /** Debounce window in ms before flushing a batch. Default 1000. */
+    debounceMs?: number;
+    /** Flush early once a task buffer reaches this size. Default 64. */
+    maxBatchSize?: number;
+    /** Max batched embed calls in flight at once. Default 2. */
+    maxConcurrentFlushes?: number;
+    /** Coalesce identical texts within a batch to a single embed. Default true. */
+    dedupe?: boolean;
+    /** Whether latency-sensitive search queries bypass batching. Default true. */
+    searchBypass?: boolean;
+}
+/**
+ * Per-collection canonical model override. A collection may pin a different
+ * canonical `model__dim` than the global default, but a single query never
+ * mixes spaces — each query targets exactly one `model__dim` table.
+ */
+export interface CollectionModelOverride {
+    /** Canonical embedder key for this collection. */
+    model: string;
+    /** Output dimension for this collection. */
+    dim: number;
+}
 export interface EmbeddingConfig {
-    provider: "ollama" | "transformers";
+    provider: "ollama" | "transformers" | "modal";
     ollamaModel?: string;
     ollamaHost?: string;
+    modal?: ModalEmbeddingConfig;
+    /**
+     * Per-collection canonical `model__dim` override (optional). Keys are
+     * collection names; a query targets exactly one space.
+     */
+    collectionModels?: Record<string, CollectionModelOverride>;
+    /** Coalescer knobs (debounce + batch append/ingest embedding). */
+    coalesce?: CoalesceConfig;
 }
 export interface GraphConfig {
     enabled?: boolean;

package/dist/src/utils.d.ts

@@ -4,6 +4,10 @@ export declare const CONFIG_FILES: string[];
 export declare const GLOBAL_CONFIG_DIR: string;
 export declare const GLOBAL_CONFIG_PATH: string;
 export declare const EXT_ROOT: string;
+/** Expand a leading `~` to the user's home directory. */
+export declare const expandHome: (p: string) => string;
+/** Store a path as `~/...` when it lives under the user's home directory. */
+export declare const shrinkHome: (p: string) => string;
 export declare const resolvePath: (cwd: string, p: string) => string;
 export declare const ensureDir: (filePath: string) => void;
 export declare const findConfig: (cwd: string) => {

package/dist/src/utils.js

@@ -6,6 +6,22 @@ export const CONFIG_FILES = ["pi-vault-mind.config.json", ".pi/vault-mind.config
 export const GLOBAL_CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE || "", ".pi", "agent");
 export const GLOBAL_CONFIG_PATH = path.join(GLOBAL_CONFIG_DIR, "vault-mind.config.json");
 export const EXT_ROOT = path.join(import.meta.dirname, "..");
+/** Expand a leading `~` to the user's home directory. */
+export const expandHome = (p) => {
+    if (p.startsWith("~/") || p === "~") {
+        const home = process.env.HOME || process.env.USERPROFILE || "";
+        return home ? path.join(home, p.slice(1)) : p;
+    }
+    return p;
+};
+/** Store a path as `~/...` when it lives under the user's home directory. */
+export const shrinkHome = (p) => {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    if (home && p.startsWith(home)) {
+        return `~${p.slice(home.length)}`;
+    }
+    return p;
+};
 export const resolvePath = (cwd, p) => path.isAbsolute(p) ? p : path.join(cwd, p);
 export const ensureDir = (filePath) => {
     const dir = path.dirname(filePath);
@@ -38,6 +54,15 @@ const readConfigFile = (p) => {
         return {};
     }
 };
+/** Expand `~` in all vault paths after loading a config layer. */
+const expandVaultPaths = (layer) => {
+    if (!layer.wiki?.vaults)
+        return;
+    for (const vault of Object.values(layer.wiki.vaults)) {
+        if (vault.path)
+            vault.path = expandHome(vault.path);
+    }
+};
 const mergeConfigLayer = (base, layer, cwd) => {
     const rawLayer = layer;
     const merged = {
@@ -80,6 +105,8 @@ export const loadConfig = (cwd) => {
     const paths = findConfig(cwd);
     const globalCfg = readConfigFile(paths.global);
     const projectCfg = readConfigFile(paths.project);
+    expandVaultPaths(globalCfg);
+    expandVaultPaths(projectCfg);
     let merged = mergeConfigLayer(DEFAULT_CONFIG, globalCfg, cwd);
     merged = mergeConfigLayer(merged, projectCfg, cwd);
     return merged;

package/dist/src/watcher.js

@@ -16,6 +16,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { expandHome } from "./utils.js";
 // ── Constants ────────────────────────────────────────────────────────────────────
 const MARKER_REGEX = /@agent-(\w+)(?::(\S+))?\s*(.*)/;
 const WRITEBACK_MARKER_REGEX = /<!--\s*pi-dispatch:(\S+)\s*-->/;
@@ -231,7 +232,7 @@ export function startWatcher(pi, vaults, state) {
         return;
     }
     for (const [name, vault] of vaultEntries) {
-        const vaultPath = vault.path;
+        const vaultPath = expandHome(vault.path);
         if (!fs.existsSync(vaultPath)) {
             console.warn(`[pi-vault-mind] Vault "${name}" path does not exist: ${vaultPath}`);
             continue;

package/dist/test/embed-queue.test.js

@@ -0,0 +1,105 @@
+import { strict as assert } from "node:assert";
+import { afterEach, beforeEach, describe, it, mock } from "node:test";
+import { EmbeddingCoalescer } from "../src/embed-queue.js";
+/**
+ * Unit tests for the embedding coalescer (src/embed-queue.ts).
+ * Pure logic, no external deps — uses node:test mock timers for the debounce.
+ */
+describe("EmbeddingCoalescer", () => {
+    beforeEach(() => {
+        mock.timers.enable({ apis: ["setTimeout"] });
+    });
+    afterEach(() => {
+        mock.timers.reset();
+    });
+    // A fake backend that records each batched call and returns a deterministic
+    // vector per text (length 2: [seq, textLength]).
+    function fakeBackend() {
+        const calls = [];
+        const embedFn = async (texts, task) => {
+            calls.push({ texts, task });
+            return texts.map((t, i) => [i, t.length]);
+        };
+        return { calls, embedFn };
+    }
+    it("coalesces requests in the debounce window into one batched call", async () => {
+        const { calls, embedFn } = fakeBackend();
+        const c = new EmbeddingCoalescer({ embedFn, debounceMs: 1000 });
+        const p1 = c.embed("alpha");
+        const p2 = c.embed("beta");
+        const p3 = c.embed("gamma");
+        assert.equal(c.size(), 3, "all three buffered before flush");
+        assert.equal(calls.length, 0, "nothing sent before the window elapses");
+        mock.timers.tick(1000);
+        const [v1, v2, v3] = await Promise.all([p1, p2, p3]);
+        assert.equal(calls.length, 1, "one batched call");
+        assert.deepEqual(calls[0].texts, ["alpha", "beta", "gamma"]);
+        assert.deepEqual(calls[0].task, "document");
+        assert.deepEqual(v1, [0, 5]);
+        assert.deepEqual(v2, [1, 4]);
+        assert.deepEqual(v3, [2, 5]);
+    });
+    it("dedupes identical texts within a batch", async () => {
+        const { calls, embedFn } = fakeBackend();
+        const c = new EmbeddingCoalescer({ embedFn, debounceMs: 1000 });
+        const a1 = c.embed("dup");
+        const a2 = c.embed("dup");
+        const b = c.embed("unique");
+        mock.timers.tick(1000);
+        const [r1, r2, rb] = await Promise.all([a1, a2, b]);
+        assert.equal(calls.length, 1);
+        assert.deepEqual(calls[0].texts, ["dup", "unique"], "only unique texts embedded");
+        assert.deepEqual(r1, r2, "both duplicate waiters get the same vector");
+        assert.deepEqual(rb, [1, 6]);
+    });
+    it("flushes early when maxBatchSize is reached (no timer needed)", async () => {
+        const { calls, embedFn } = fakeBackend();
+        const c = new EmbeddingCoalescer({ embedFn, debounceMs: 99999, maxBatchSize: 2 });
+        const p1 = c.embed("one");
+        const p2 = c.embed("two"); // reaching size 2 triggers an immediate flush
+        await Promise.all([p1, p2]);
+        assert.equal(calls.length, 1, "flushed without waiting for the debounce");
+        assert.deepEqual(calls[0].texts, ["one", "two"]);
+        assert.equal(c.size(), 0);
+    });
+    it("keeps query and document batches separate, each with the right task", async () => {
+        const { calls, embedFn } = fakeBackend();
+        const c = new EmbeddingCoalescer({ embedFn, debounceMs: 1000 });
+        const q = c.embed("a question", "query");
+        const d = c.embed("a document", "document");
+        mock.timers.tick(1000);
+        await Promise.all([q, d]);
+        assert.equal(calls.length, 2, "one batch per task");
+        const tasks = calls.map((c) => c.task).sort();
+        assert.deepEqual(tasks, ["document", "query"]);
+    });
+    it("rejects every waiter in a batch when the backend throws", async () => {
+        const embedFn = async () => {
+            throw new Error("backend down");
+        };
+        const c = new EmbeddingCoalescer({ embedFn, debounceMs: 1000 });
+        const p1 = c.embed("x");
+        const p2 = c.embed("y");
+        mock.timers.tick(1000);
+        await assert.rejects(p1, /backend down/);
+        await assert.rejects(p2, /backend down/);
+    });
+    it("embedImmediate bypasses batching", async () => {
+        const { calls, embedFn } = fakeBackend();
+        const c = new EmbeddingCoalescer({ embedFn, debounceMs: 1000 });
+        const v = await c.embedImmediate("now", "query");
+        assert.equal(calls.length, 1, "sent immediately, no tick required");
+        assert.deepEqual(calls[0].texts, ["now"]);
+        assert.deepEqual(calls[0].task, "query");
+        assert.deepEqual(v, [0, 3]);
+    });
+    it("drain() flushes buffered work and awaits it", async () => {
+        const { calls, embedFn } = fakeBackend();
+        const c = new EmbeddingCoalescer({ embedFn, debounceMs: 1000 });
+        c.embed("p");
+        c.embed("q");
+        await c.drain();
+        assert.equal(calls.length, 1, "drain forced the flush without a timer tick");
+        assert.equal(c.size(), 0);
+    });
+});

package/dist/test/index.test.js

@@ -365,4 +365,39 @@ describe("pi-vault-mind", () => {
             process.chdir(cwd);
         }
     });
+    it("planGitignore creates a vault .gitignore when none exists", async () => {
+        const { planGitignore } = await import("../src/commands.js");
+        const plan = planGitignore(null);
+        assert.equal(plan.action, "create");
+        assert.ok(plan.content.includes(".lancedb/"), "must ignore the binary index");
+        assert.ok(plan.content.includes(".obsidian/workspace*.json"), "must ignore churny workspace state");
+    });
+    it("planGitignore appends only missing entries, tolerating slash-format differences", async () => {
+        const { planGitignore } = await import("../src/commands.js");
+        // obsidian-git already ignores the index, but in a different slash format
+        // (leading slash, no trailing slash) and without the workspace-state rule.
+        const plan = planGitignore("node_modules/\n/.lancedb\n");
+        assert.equal(plan.action, "append");
+        assert.ok(plan.content.includes(".obsidian/workspace*.json"), "should add the missing entry");
+        assert.ok(!plan.content.includes(".lancedb"), "should not duplicate an entry already present under a different slash format");
+    });
+    it("planGitignore skips when all entries are already present", async () => {
+        const { planGitignore } = await import("../src/commands.js");
+        const plan = planGitignore(".lancedb/\n.obsidian/workspace*.json\n");
+        assert.equal(plan.action, "skip");
+        assert.equal(plan.content, "");
+    });
+    it("planGitignore avoids gluing a new entry onto an unterminated last line", async () => {
+        const { planGitignore } = await import("../src/commands.js");
+        const plan = planGitignore("node_modules/"); // no trailing newline
+        assert.equal(plan.action, "append");
+        assert.ok(plan.content.startsWith("\n"), "should insert a separating newline first");
+    });
+    it("planGitignore appends to an empty file without a leading blank line", async () => {
+        const { planGitignore } = await import("../src/commands.js");
+        const plan = planGitignore("");
+        assert.equal(plan.action, "append");
+        assert.ok(!plan.content.startsWith("\n"), "empty file needs no leading blank line");
+        assert.ok(plan.content.includes(".lancedb/"), "should still add the index rule");
+    });
 });

package/dist/test/lance-modal.test.js

@@ -0,0 +1,95 @@
+import { strict as assert } from "node:assert";
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { connect, resetConnection, searchFts, searchHybrid, upsertPrecomputed, } from "../src/lance.js";
+import { MODAL_TOKEN_ENV } from "../src/modal-config.js";
+const MODEL = "testmodel";
+const DIM = 3;
+const wiki = (dataDir) => ({
+    dataDir,
+    embedding: {
+        provider: "modal",
+        modal: { baseUrl: "https://pvm.modal.run", model: MODEL },
+        coalesce: { debounceMs: 5, maxBatchSize: 1, maxConcurrentFlushes: 1 },
+    },
+    ftsEnabled: true,
+});
+const syncRow = (id, vector, fact = `fact ${id}`) => ({
+    id,
+    text: fact,
+    vector,
+    metadata: { domain: "d", tag: "t" },
+    model: MODEL,
+    dim: DIM,
+    seq: 1,
+    created_at: "",
+});
+describe("Modal lance path (precomputed + search + fallback)", () => {
+    let dir;
+    let origToken;
+    let origFetch;
+    beforeEach(() => {
+        dir = path.join(tmpdir(), `pvm-lance-${randomUUID()}`);
+        fs.mkdirSync(dir, { recursive: true });
+        origToken = process.env[MODAL_TOKEN_ENV];
+        process.env[MODAL_TOKEN_ENV] = "tok";
+        origFetch = globalThis.fetch;
+        resetConnection();
+    });
+    afterEach(() => {
+        if (origToken === undefined)
+            delete process.env[MODAL_TOKEN_ENV];
+        else
+            process.env[MODAL_TOKEN_ENV] = origToken;
+        globalThis.fetch = origFetch;
+        resetConnection();
+    });
+    it("upsertPrecomputed imports rows into the namespaced table", async () => {
+        const cfg = wiki(dir);
+        await upsertPrecomputed(dir, "main", MODEL, DIM, [syncRow("1", [1, 0, 0]), syncRow("2", [0, 1, 0])], cfg);
+        const conn = await connect(dir);
+        const table = await conn.openTable(`col_main__${MODEL}__${DIM}`);
+        assert.equal(await table.countRows(), 2);
+    });
+    it("upsertPrecomputed is idempotent (merge-insert by id)", async () => {
+        const cfg = wiki(dir);
+        await upsertPrecomputed(dir, "main", MODEL, DIM, [syncRow("1", [1, 0, 0])], cfg);
+        await upsertPrecomputed(dir, "main", MODEL, DIM, [syncRow("1", [1, 0, 0])], cfg);
+        const conn = await connect(dir);
+        const table = await conn.openTable(`col_main__${MODEL}__${DIM}`);
+        assert.equal(await table.countRows(), 1);
+    });
+    it("searchHybrid (modal) returns nearest results via the /embed query path", async () => {
+        const cfg = wiki(dir);
+        await upsertPrecomputed(dir, "main", MODEL, DIM, [syncRow("1", [1, 0, 0]), syncRow("2", [0, 1, 0]), syncRow("3", [0, 0, 1])], cfg);
+        // Mock /embed to return a query vector matching row "1".
+        globalThis.fetch = (async () => ({
+            ok: true,
+            status: 200,
+            json: async () => ({ model: MODEL, dim: DIM, vectors: [[1, 0, 0]] }),
+            text: async () => "",
+        }));
+        const results = (await searchHybrid(dir, "main", "anything", 2, cfg));
+        assert.ok(results.length > 0, "search returned results");
+        assert.equal(results[0].id, "1", "nearest neighbor is row 1");
+    });
+    it("searchHybrid degrades gracefully (no crash) when Modal is offline", async () => {
+        const cfg = wiki(dir);
+        await upsertPrecomputed(dir, "main", MODEL, DIM, [syncRow("1", [1, 0, 0], "authentication tokens")], cfg);
+        // Offline: every fetch rejects.
+        globalThis.fetch = (async () => {
+            throw new Error("network unreachable");
+        });
+        const results = await searchHybrid(dir, "main", "authentication", 5, cfg);
+        assert.ok(Array.isArray(results), "offline search returns an array, never throws");
+    });
+    it("searchFts (modal) targets the namespaced table without throwing", async () => {
+        const cfg = wiki(dir);
+        await upsertPrecomputed(dir, "main", MODEL, DIM, [syncRow("1", [1, 0, 0], "rare keyword match here")], cfg);
+        const results = await searchFts(dir, "main", "rare", 5, cfg);
+        assert.ok(Array.isArray(results));
+    });
+});