@kisev/memomatic 1.0.0-dev.70.g8d00098df14b → 1.0.0-dev.71.gee4e37a5bb61

package/dist/ingest.js

@@ -1,107 +1,8 @@
 import { homedir } from "node:os";
 import { isAbsolute, join } from "node:path";
-import { DatabaseSync } from "node:sqlite";
 export function opencodeDatabasePath() {
-    const base = process.env.XDG_DATA_HOME
-        ? process.env.XDG_DATA_HOME
-        : join(homedir(), ".local", "share");
+    const base = process.env.XDG_DATA_HOME ?? join(homedir(), ".local/share");
     if (!isAbsolute(base))
         throw new Error("XDG_DATA_HOME must be an absolute path");
     return join(base, "opencode", "opencode.db");
 }
-function readMessages(db, sessionId) {
-    const hasParts = db
-        .prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'part'")
-        .get();
-    const rows = db
-        .prepare(`SELECT ${hasParts ? "id, " : ""}data FROM message WHERE session_id = ? ORDER BY time_created ASC;`)
-        .all(sessionId);
-    if (!hasParts)
-        return rows;
-    const parts = db.prepare("SELECT data FROM part WHERE message_id = ? ORDER BY time_created ASC, id ASC");
-    return rows.map((row) => {
-        try {
-            const message = JSON.parse(row.data);
-            message.parts = parts.all(row.id).flatMap((part) => {
-                try {
-                    return [JSON.parse(part.data)];
-                }
-                catch {
-                    return [];
-                }
-            });
-            return { data: JSON.stringify(message) };
-        }
-        catch {
-            return row;
-        }
-    });
-}
-export function loadRecentSessions(databaseFile, afterTimeCreated, options = {
-    maxSessions: 20,
-    maxCharsPerSession: 24_000,
-}) {
-    let db;
-    try {
-        db = new DatabaseSync(databaseFile, { readOnly: true });
-    }
-    catch {
-        return [];
-    }
-    try {
-        const before = options.before ?? Number.MAX_SAFE_INTEGER;
-        const sessions = db
-            .prepare(`SELECT id, title, directory, time_created FROM session
-        WHERE time_created > ? AND time_created < ? ORDER BY time_created ASC LIMIT ?;`)
-            .all(afterTimeCreated, before, options.maxSessions);
-        const result = [];
-        for (const session of sessions) {
-            const messages = [];
-            let budget = options.maxCharsPerSession;
-            let internal = false;
-            const rows = readMessages(db, session.id);
-            for (const row of rows) {
-                if (budget <= 0)
-                    break;
-                let parsed;
-                try {
-                    parsed = JSON.parse(row.data);
-                }
-                catch {
-                    continue;
-                }
-                const texts = [];
-                for (const part of parsed.parts ?? []) {
-                    const value = part;
-                    if (value.type === "text" && typeof value.text === "string")
-                        texts.push(value.text);
-                }
-                const text = texts.join("\n").trim();
-                if (!text)
-                    continue;
-                if (text.includes("[memomatic-internal]"))
-                    internal = true;
-                if (budget - text.length < 0) {
-                    messages.push({ role: parsed.role ?? "unknown", text: text.slice(0, budget) });
-                    budget = 0;
-                    break;
-                }
-                budget -= text.length;
-                messages.push({ role: parsed.role ?? "unknown", text });
-            }
-            if (internal || !messages.length)
-                continue;
-            result.push({
-                id: session.id,
-                title: session.title,
-                directory: session.directory,
-                timeCreated: session.time_created,
-                messages,
-            });
-        }
-        return result;
-    }
-    finally {
-        db.close();
-    }
-}

package/dist/ingestion.d.ts

@@ -0,0 +1,30 @@
+import type { MemoryStore } from "./store.js";
+export type Fragment = {
+    id: string;
+    sessionId: string;
+    messageIds: string[];
+    title: string;
+    directory: string;
+    text: string;
+    context: string;
+    checkpointKeys: string[];
+    seal?: [string, string];
+};
+export type IngestionPlan = {
+    fragments: Fragment[];
+    sessions: number;
+    messages: number;
+    cached: number;
+    skipped: number;
+    characters: number;
+    watermark: number;
+    cachedSessions: number;
+    unscannedSessions: number;
+    seals: Array<[string, string]>;
+};
+export declare function planIngestion(file: string, store: MemoryStore, options: {
+    before: number;
+    maxChars: number;
+    maxSessions?: number;
+    contextChars?: number;
+}): IngestionPlan;

package/dist/ingestion.js

@@ -0,0 +1,209 @@
+import { createHash } from "node:crypto";
+import { DatabaseSync } from "node:sqlite";
+const digest = (text) => createHash("sha256").update(text).digest("hex");
+export function planIngestion(file, store, options) {
+    if (!Number.isSafeInteger(options.maxChars) ||
+        options.maxChars < 2 ||
+        !Number.isFinite(options.before))
+        throw new Error("invalid ingestion limits");
+    const result = {
+        fragments: [],
+        sessions: 0,
+        messages: 0,
+        cached: 0,
+        skipped: 0,
+        characters: 0,
+        watermark: 0,
+        cachedSessions: 0,
+        unscannedSessions: 0,
+        seals: [],
+    };
+    const db = new DatabaseSync(file, { readOnly: true });
+    try {
+        db.exec("BEGIN");
+        const hasParts = Boolean(db.prepare("SELECT 1 FROM sqlite_master WHERE name='part' AND type='table'").get());
+        const hasUpdated = db
+            .prepare("PRAGMA table_info(session)")
+            .all()
+            .some((row) => row.name === "time_updated");
+        const fastRevision = hasParts &&
+            hasUpdated &&
+            ["message", "part"].every((table) => db
+                .prepare(`PRAGMA table_info(${table})`)
+                .all()
+                .some((row) => row.name === "time_updated"));
+        const partHasSession = hasParts &&
+            db
+                .prepare("PRAGMA table_info(part)")
+                .all()
+                .some((row) => row.name === "session_id");
+        const sessions = db
+            .prepare(`SELECT id,title,directory,time_created,${hasUpdated ? "time_updated" : "time_created"} AS revision FROM session WHERE ${hasUpdated ? "time_updated" : "time_created"} < ? ORDER BY time_created,id`)
+            .all(options.before);
+        for (const [position, session] of sessions.entries()) {
+            if (session.title.startsWith("[memomatic-internal]")) {
+                result.skipped++;
+                continue;
+            }
+            const sealKey = `ingest-session-v2:${digest(session.id)}`;
+            let seal;
+            if (fastRevision) {
+                const messages = db
+                    .prepare("SELECT COUNT(*) AS count,MAX(time_updated) AS updated FROM message WHERE session_id=?")
+                    .get(session.id);
+                const parts = db
+                    .prepare(`SELECT COUNT(*) AS count,MAX(time_updated) AS updated FROM part WHERE ${partHasSession ? "session_id=?" : "message_id IN (SELECT id FROM message WHERE session_id=?)"}`)
+                    .get(session.id);
+                if (Math.max(Number(messages.updated), Number(parts.updated)) >= options.before) {
+                    result.skipped++;
+                    continue;
+                }
+                const revision = digest(JSON.stringify([session.revision, session.title, session.directory, messages, parts]));
+                if (store.getMeta(sealKey) === revision) {
+                    result.cachedSessions++;
+                    continue;
+                }
+                seal = [sealKey, revision];
+            }
+            const rows = hasParts
+                ? db
+                    .prepare(`SELECT m.id,m.data AS message,p.data AS part FROM message m JOIN part p ON p.message_id=m.id
+                WHERE ${partHasSession ? "p" : "m"}.session_id=?
+                AND CASE WHEN json_valid(p.data) THEN json_extract(p.data,'$.type') END='text'
+                AND CASE WHEN json_valid(m.data) THEN json_extract(m.data,'$.role') END IN ('user','assistant')
+                ORDER BY m.time_created,m.id,p.time_created,p.id`)
+                    .all(session.id)
+                : db
+                    .prepare("SELECT rowid AS id,data FROM message WHERE session_id=? ORDER BY time_created,rowid")
+                    .all(session.id).flatMap((row) => {
+                    try {
+                        const message = JSON.parse(row.data);
+                        return (message.parts ?? []).map((part) => ({
+                            id: String(row.id),
+                            message: row.data,
+                            part: JSON.stringify(part),
+                        }));
+                    }
+                    catch {
+                        return [];
+                    }
+                });
+            const messages = new Map();
+            for (const row of rows) {
+                try {
+                    const message = JSON.parse(row.message);
+                    const part = JSON.parse(row.part);
+                    if (!["user", "assistant"].includes(message.role) ||
+                        part.type !== "text" ||
+                        typeof part.text !== "string")
+                        continue;
+                    const item = messages.get(row.id) ?? {
+                        role: message.role,
+                        texts: [],
+                    };
+                    item.texts.push(part.text);
+                    messages.set(row.id, item);
+                }
+                catch {
+                    result.skipped++;
+                }
+            }
+            const firstUser = [...messages.values()].find((message) => message.role === "user");
+            if (firstUser?.texts.join("\n").trimStart().startsWith("[memomatic-internal]")) {
+                result.skipped++;
+                continue;
+            }
+            let batch = [];
+            let ids = [];
+            let keys = [];
+            let context = "";
+            let previous = "";
+            let length = 0;
+            let changed = false;
+            const flush = () => {
+                if (!batch.length)
+                    return;
+                result.fragments.push({
+                    id: digest(keys.join("\n")),
+                    sessionId: session.id,
+                    messageIds: ids,
+                    title: session.title,
+                    directory: session.directory,
+                    text: batch.join("\n\n"),
+                    context,
+                    checkpointKeys: keys,
+                });
+                batch = [];
+                ids = [];
+                keys = [];
+                length = 0;
+            };
+            let lastMessage = "";
+            for (const [id, message] of messages) {
+                const body = message.texts.join("\n").trim();
+                if (!body) {
+                    result.skipped++;
+                    continue;
+                }
+                result.messages++;
+                const full = `${message.role}: ${body}`;
+                // Only adjacent exact duplicate messages with the same role are redundant.
+                if (full === lastMessage) {
+                    result.skipped++;
+                    continue;
+                }
+                lastMessage = full;
+                for (let offset = 0; offset < body.length;) {
+                    const start = offset;
+                    let end = Math.min(body.length, offset + options.maxChars);
+                    if (end < body.length &&
+                        /[\uD800-\uDBFF]/.test(body[end - 1]) &&
+                        /[\uDC00-\uDFFF]/.test(body[end]))
+                        end--;
+                    const text = `${message.role}: ${body.slice(start, end)}`;
+                    offset = end;
+                    const preceding = Array.from(previous)
+                        .slice(-(options.contextChars ?? 2000))
+                        .join("");
+                    const key = `ingest-v2:${digest(`${session.id}\n${id}\n${start}\n${preceding}\n${text}`)}`;
+                    if (store.getMeta(key)) {
+                        result.cached++;
+                        previous = text;
+                        continue;
+                    }
+                    if (batch.length && length + text.length > options.maxChars)
+                        flush();
+                    if (!batch.length)
+                        context = preceding;
+                    batch.push(text);
+                    ids.push(id);
+                    keys.push(key);
+                    length += text.length;
+                    result.characters += text.length;
+                    changed = true;
+                    previous = text;
+                }
+            }
+            flush();
+            if (seal) {
+                if (changed)
+                    result.fragments.at(-1).seal = seal;
+                else
+                    result.seals.push(seal);
+            }
+            if (changed) {
+                result.sessions++;
+                result.watermark = Math.max(result.watermark, session.time_created);
+            }
+            if (options.maxSessions && result.sessions >= options.maxSessions) {
+                result.unscannedSessions = sessions.length - position - 1;
+                break;
+            }
+        }
+        db.exec("COMMIT");
+        return result;
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/operations.d.ts

@@ -0,0 +1,7 @@
+import type { Observe } from "./generated/cli.js";
+export type OperationOptions = {
+    signal?: AbortSignal;
+    observe?: Observe;
+    force?: boolean;
+};
+export declare function check(options: OperationOptions): void;

package/dist/operations.js

@@ -0,0 +1,3 @@
+export function check(options) {
+    options.signal?.throwIfAborted();
+}

package/dist/paths.js

@@ -25,7 +25,12 @@ async function assertDirectory(path) {
     }
 }
 export function memomaticPaths() {
-    const stateRoot = join(safeXdg("XDG_STATE_HOME", ".local/state"), "memomatic");
+    const configured = process.env.MEMOMATIC_HOME;
+    if (configured && (!isAbsolute(configured) || configured.split(sep).includes("..")))
+        throw new Error("MEMOMATIC_HOME must be an absolute safe path");
+    const stateRoot = configured
+        ? resolve(configured)
+        : join(safeXdg("XDG_STATE_HOME", ".local/state"), "memomatic");
     const configRoot = join(safeXdg("XDG_CONFIG_HOME", ".config"), "memomatic");
     return {
         stateRoot,
@@ -34,7 +39,7 @@ export function memomaticPaths() {
         userFile: join(stateRoot, "USER.md"),
         dreamsFile: join(stateRoot, "DREAMS.md"),
         rulesFile: join(configRoot, "MEMORY_RULES.md"),
-        settingsFile: join(configRoot, "settings.json"),
+        settingsFile: process.env.MEMOMATIC_CONFIG ?? join(configRoot, "settings.json"),
         dailyDir: join(stateRoot, "memory"),
         archiveDir: join(stateRoot, "archive"),
         historyDir: join(stateRoot, "history"),

package/dist/search.d.ts

@@ -1,6 +1,7 @@
 import { type IndexedEntry, MemoryStore } from "./store.js";
 import type { MemomaticPaths } from "./paths.js";
 import type { MemomaticSettings } from "./settings.js";
+import { type OperationOptions } from "./operations.js";
 export type SearchHit = {
     entry: IndexedEntry;
     score: number;
@@ -17,7 +18,7 @@ export type SearchHit = {
     };
 };
 export declare function corpusFiles(paths: MemomaticPaths): Promise<string[]>;
-export declare function reindex(paths: MemomaticPaths, settings: MemomaticSettings, store: MemoryStore): Promise<number>;
+export declare function reindex(paths: MemomaticPaths, settings: MemomaticSettings, store: MemoryStore, options?: OperationOptions): Promise<number>;
 export type SearchOptions = {
     includeArchived?: boolean;
     markSurfaced?: boolean;

package/dist/search.js

@@ -4,6 +4,7 @@ import { cosineSimilarity, stableIdFor } from "./store.js";
 import { entryKind, parseCorpusEntries } from "./corpus.js";
 import { entryImportance, entryObservedAt } from "./entries.js";
 import { embedTexts, embeddingFingerprint } from "./settings.js";
+import { check } from "./operations.js";
 export async function corpusFiles(paths) {
     const files = [];
     for (const name of ["MEMORY.md", "USER.md"]) {
@@ -17,7 +18,9 @@ export async function corpusFiles(paths) {
     }
     return files;
 }
-export async function reindex(paths, settings, store) {
+export async function reindex(paths, settings, store, options = {}) {
+    check(options);
+    options.observe?.({ phase: "index.scan", message: "Reading memory files" });
     const entries = [];
     const indexedIds = new Set();
     for (const file of await corpusFiles(paths)) {
@@ -47,8 +50,55 @@ export async function reindex(paths, settings, store) {
             });
         }
     }
-    const vectors = await embedTexts(settings, entries.map((entry) => entry.text));
+    const prior = new Map(store.allEntries().map((entry) => [entry.stableId, entry.text]));
+    const cache = new Map(store.vectors().map((row) => [row.stableId, row.data]));
+    const compatible = !options.force && store.getMeta("embeddingFingerprint") === embeddingFingerprint(settings);
+    const vectors = settings.embedding ? [] : null;
+    const missing = entries
+        .map((entry, index) => ({ entry, index }))
+        .filter(({ entry, index }) => {
+        const cached = compatible && prior.get(entry.stableId) === entry.text
+            ? cache.get(entry.stableId)
+            : undefined;
+        if (cached && vectors) {
+            vectors[index] = cached;
+            return false;
+        }
+        return Boolean(vectors);
+    });
+    options.observe?.({
+        phase: "index.embeddings",
+        message: "Embedding changed entries",
+        total: missing.length,
+        completed: 0,
+        cached: entries.length - missing.length,
+    });
+    for (let start = 0; start < missing.length; start += 32) {
+        check(options);
+        const batch = missing.slice(start, start + 32);
+        const computed = await embedTexts(settings, batch.map((item) => item.entry.text), "document", options.signal);
+        if (vectors && computed)
+            batch.forEach((item, index) => {
+                vectors[item.index] = computed[index];
+            });
+        options.observe?.({
+            phase: "index.embeddings",
+            message: "Embedding batch complete",
+            total: missing.length,
+            completed: Math.min(start + 32, missing.length),
+        });
+    }
+    check(options);
+    if (vectors?.length && vectors.some((vector) => vector.length !== vectors[0].length))
+        throw new Error("embedding dimensions changed; run memomatic index --force");
     store.replaceIndex(entries, vectors, embeddingFingerprint(settings));
+    options.observe?.({
+        phase: "index.done",
+        message: "Index committed",
+        entries: entries.length,
+        embedded: missing.length,
+        cached: entries.length - missing.length,
+    });
     return entries.length;
 }
 function recencyMultiplier(entry, halfLifeDays, now = Date.now()) {

package/dist/service.d.ts

@@ -1,6 +1,7 @@
 import { type MemoryRules } from "./rules.js";
 import { type MemomaticPaths } from "./paths.js";
 import { type MemomaticSettings } from "./settings.js";
+import { type OperationOptions } from "./operations.js";
 import { type SearchHit, type SearchOptions } from "./search.js";
 import { MemoryStore } from "./store.js";
 export type WriteRequest = {
@@ -22,6 +23,7 @@ export type MemomaticContext = {
 };
 export declare function openMemomatic(options?: {
     readOnly?: boolean;
+    configure?: (settings: MemomaticSettings) => MemomaticSettings;
 }): Promise<MemomaticContext>;
 export declare function writeEntry(context: MemomaticContext, request: WriteRequest): Promise<string>;
 export declare function searchMemory(context: MemomaticContext, query: string, options?: SearchOptions): Promise<SearchHit[]>;
@@ -57,5 +59,5 @@ export declare function forgetEntry(context: MemomaticContext, target: {
     file: string;
     line: number;
 }): Promise<string>;
-export declare function archiveOldEpisodic(context: MemomaticContext): Promise<string[]>;
-export declare function rebuildIndex(context: MemomaticContext): Promise<number>;
+export declare function archiveOldEpisodic(context: MemomaticContext, options?: OperationOptions): Promise<string[]>;
+export declare function rebuildIndex(context: MemomaticContext, options?: OperationOptions): Promise<number>;

package/dist/service.js

@@ -7,6 +7,7 @@ import { dropToInbox, withRunLock } from "./inbox.js";
 import { isForbidden, loadRules } from "./rules.js";
 import { memomaticPaths } from "./paths.js";
 import { loadSettings } from "./settings.js";
+import { check } from "./operations.js";
 import { reindex, search } from "./search.js";
 import { MemoryStore } from "./store.js";
 import { visibilityForSource } from "./visibility.js";
@@ -20,11 +21,12 @@ async function memoryPath(context, file) {
 }
 export async function openMemomatic(options = {}) {
     const paths = memomaticPaths();
-    const [settings, rules, store] = await Promise.all([
-        loadSettings(paths.settingsFile),
-        loadRules(paths.rulesFile),
-        options.readOnly ? MemoryStore.preview(paths.indexFile) : MemoryStore.open(paths.indexFile),
-    ]);
+    const loaded = await loadSettings(paths.settingsFile);
+    const settings = options.configure ? options.configure(loaded) : loaded;
+    const rules = await loadRules(paths.rulesFile);
+    const store = options.readOnly
+        ? await MemoryStore.preview(paths.indexFile)
+        : await MemoryStore.open(paths.indexFile);
     return { paths, settings, rules, store };
 }
 export async function writeEntry(context, request) {
@@ -100,7 +102,7 @@ export async function forgetEntry(context, target) {
         return file;
     });
 }
-export async function archiveOldEpisodic(context) {
+export async function archiveOldEpisodic(context, options = {}) {
     const archived = [];
     if (!context.rules.autoClean)
         return archived;
@@ -111,6 +113,7 @@ export async function archiveOldEpisodic(context) {
         .filter((entry) => entry.kind === "episodic")
         .map((entry) => entry.file));
     for (const file of files) {
+        check(options);
         await memoryPath(context, file);
         const content = await readTextIfExists(file);
         if (content === undefined)
@@ -141,6 +144,6 @@ export async function archiveOldEpisodic(context) {
     }
     return archived;
 }
-export async function rebuildIndex(context) {
-    return withRunLock(context.paths, () => reindex(context.paths, context.settings, context.store));
+export async function rebuildIndex(context, options = {}) {
+    return withRunLock(context.paths, () => reindex(context.paths, context.settings, context.store, options));
 }

package/dist/settings.d.ts

@@ -13,6 +13,13 @@ export type MemomaticSettings = {
         maxCandidates: number;
         memoryBudgetLines: number;
         maxPriorEntryLoss: number;
+        timeoutMs: number;
+        maxDurationMs: number;
+        maxSessions: number;
+        maxChars: number;
+        retries: number;
+        idleMs: number;
+        opencodeUrl: string | null;
     };
     search: {
         maxResults: number;
@@ -28,7 +35,7 @@ export type MemomaticSettings = {
 export declare const defaultSettings: () => MemomaticSettings;
 export declare function normalizeSettings(raw: unknown): MemomaticSettings;
 export declare function loadSettings(settingsFile: string): Promise<MemomaticSettings>;
-export declare function embedTexts(settings: MemomaticSettings, texts: string[], purpose?: "document" | "query"): Promise<Float32Array[] | null>;
+export declare function embedTexts(settings: MemomaticSettings, texts: string[], purpose?: "document" | "query", signal?: AbortSignal): Promise<Float32Array[] | null>;
 export declare const MEMORY_QUERY_INSTRUCTION = "Given a search query, retrieve relevant personal memory entries that answer the query.";
 export declare function embeddingQuery(settings: MemomaticSettings, query: string): string;
 export declare function embeddingFingerprint(settings: MemomaticSettings): string;

package/dist/settings.js

@@ -11,6 +11,13 @@ export const defaultSettings = () => ({
         maxCandidates: 12,
         memoryBudgetLines: 80,
         maxPriorEntryLoss: 0.25,
+        timeoutMs: 180000,
+        maxDurationMs: 0,
+        maxSessions: 0,
+        maxChars: 24000,
+        retries: 1,
+        idleMs: 600000,
+        opencodeUrl: null,
     },
     search: { maxResults: 6, minScore: 0.35, minSemanticScore: 0.45, halfLifeDays: 30 },
     archive: { enabled: false, days: 60 },
@@ -30,6 +37,25 @@ export function normalizeSettings(raw) {
     const source = (raw ?? {});
     const embedding = source.embedding;
     const search = mergeSection(defaults.search, source.search);
+    const dream = mergeSection(defaults.dream, source.dream);
+    for (const key of [
+        "timeoutMs",
+        "maxDurationMs",
+        "maxSessions",
+        "maxChars",
+        "retries",
+        "idleMs",
+    ])
+        if (!Number.isSafeInteger(dream[key]) || dream[key] < 0)
+            throw new Error(`invalid dream.${key}`);
+    if (dream.timeoutMs < 1 || dream.maxChars < 256 || dream.maxChars > 200000 || dream.retries > 5)
+        throw new Error("invalid Dream request limits");
+    if (dream.model !== null && (typeof dream.model !== "string" || !/^[^/]+\/.+/.test(dream.model)))
+        throw new Error("model must use provider/model format");
+    if (dream.variant !== null && typeof dream.variant !== "string")
+        throw new Error("dream.variant must be a string or null");
+    if (dream.opencodeUrl !== null && typeof dream.opencodeUrl !== "string")
+        throw new Error("dream.opencodeUrl must be a string or null");
     if (!Number.isInteger(search.maxResults) ||
         search.maxResults < 1 ||
         search.maxResults > 200 ||
@@ -47,7 +73,7 @@ export function normalizeSettings(raw) {
                     : {}),
             }
             : null,
-        dream: mergeSection(defaults.dream, source.dream),
+        dream,
         search,
         archive: mergeSection(defaults.archive, source.archive),
     };
@@ -62,7 +88,7 @@ export async function loadSettings(settingsFile) {
         throw error;
     }
 }
-export async function embedTexts(settings, texts, purpose = "document") {
+export async function embedTexts(settings, texts, purpose = "document", signal) {
     if (!settings.embedding || !texts.length)
         return null;
     const response = await fetch(settings.embedding.url, {
@@ -72,7 +98,9 @@ export async function embedTexts(settings, texts, purpose = "document") {
         }),
         headers: { "content-type": "application/json" },
         method: "POST",
-        signal: AbortSignal.timeout(30_000),
+        signal: signal
+            ? AbortSignal.any([signal, AbortSignal.timeout(30_000)])
+            : AbortSignal.timeout(30_000),
     });
     if (!response.ok)
         throw new Error(`embedding request failed: ${response.status} ${await response.text()}`);

package/dist/store.js

@@ -71,6 +71,8 @@ export class MemoryStore {
                         .run(...Object.values(row));
                 }
             }
+            if (copy.fts)
+                copy.db.exec("INSERT INTO entries_fts(stable_id,text) SELECT stable_id,text FROM entries");
             return copy;
         }
         catch (error) {