@tryhamster/gerbil 1.0.0-rc.8 → 1.0.0

package/dist/memory-D1P7Tmda.mjs

@@ -0,0 +1,4 @@
+import { n as createMemory, t as Memory } from "./memory-Dj0J1v88.mjs";
+import "./vector-B0panuy6.mjs";
+
+export { Memory, createMemory };

package/dist/memory-DVN0MnIG.mjs

@@ -0,0 +1,132 @@
+import { a as deserializeRecord, i as topK, o as matchesFilter, s as serializeRecord } from "./vector-B0panuy6.mjs";
+import { dirname } from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+
+//#region src/memory/gerbil-embedder.ts
+/**
+* Build an {@link Embedder} from a Gerbil instance (or any object exposing a
+* compatible `embedBatch`). Vectors are converted to {@link Float32Array}.
+*
+* @example
+* ```ts
+* import { Gerbil } from "@tryhamster/gerbil";
+* import { createMemory, createGerbilEmbedder } from "@tryhamster/gerbil/memory";
+*
+* const g = new Gerbil();
+* await g.loadModel("embeddinggemma-300m");
+* const mem = createMemory({ embed: createGerbilEmbedder(g) });
+* ```
+*/
+function createGerbilEmbedder(engine) {
+	return async (texts) => {
+		return (await engine.embedBatch(texts)).map((result) => Float32Array.from(result.vector));
+	};
+}
+
+//#endregion
+//#region src/memory/stores/file-store.ts
+/**
+* File-backed JSON {@link MemoryStore} for simple Node persistence.
+*
+* Loads the whole corpus into memory and writes the full JSON file on every
+* mutation (debounced via an awaited write queue). This is intentionally
+* simple and aimed at small-to-medium corpora; see follow-ups for a
+* SQLite/OPFS backend at scale. Node-only — do not import in browser code.
+*/
+const DEFAULT_K = 5;
+/** JSON-on-disk vector store for Node. */
+var FileStore = class {
+	path;
+	records = /* @__PURE__ */ new Map();
+	loaded = false;
+	writeQueue = Promise.resolve();
+	constructor(path$1) {
+		this.path = path$1;
+	}
+	async ensureLoaded() {
+		if (this.loaded) return;
+		try {
+			const raw = await readFile(this.path, "utf8");
+			const parsed = JSON.parse(raw);
+			for (const record of parsed.records) {
+				const hydrated = deserializeRecord(record);
+				this.records.set(hydrated.id, hydrated);
+			}
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		this.loaded = true;
+	}
+	persist() {
+		const snapshot = {
+			version: 1,
+			records: [...this.records.values()].map(serializeRecord)
+		};
+		const payload = JSON.stringify(snapshot);
+		this.writeQueue = this.writeQueue.then(async () => {
+			await mkdir(dirname(this.path), { recursive: true });
+			await writeFile(this.path, payload, "utf8");
+		});
+		return this.writeQueue;
+	}
+	async add(record) {
+		await this.ensureLoaded();
+		this.records.set(record.id, record);
+		await this.persist();
+	}
+	async addMany(records) {
+		await this.ensureLoaded();
+		for (const record of records) this.records.set(record.id, record);
+		await this.persist();
+	}
+	async get(id) {
+		await this.ensureLoaded();
+		return this.records.get(id);
+	}
+	async search(queryVector, options = {}) {
+		await this.ensureLoaded();
+		const k = options.k ?? DEFAULT_K;
+		const candidates = [];
+		for (const record of this.records.values()) {
+			if (!record.embedding) continue;
+			if (!matchesFilter(record.metadata, options.filter)) continue;
+			candidates.push({
+				item: record,
+				vector: record.embedding
+			});
+		}
+		return topK(queryVector, candidates, k, options.minScore).map((entry) => ({
+			record: entry.item,
+			score: entry.score
+		}));
+	}
+	async delete(id) {
+		await this.ensureLoaded();
+		const existed = this.records.delete(id);
+		if (existed) await this.persist();
+		return existed;
+	}
+	async list(filter) {
+		await this.ensureLoaded();
+		const out = [];
+		for (const record of this.records.values()) if (matchesFilter(record.metadata, filter)) out.push(record);
+		return out;
+	}
+	async clear() {
+		await this.ensureLoaded();
+		this.records.clear();
+		await this.persist();
+	}
+	async size() {
+		await this.ensureLoaded();
+		return this.records.size;
+	}
+};
+/** Create a {@link FileStore} backed by `path` (JSON). */
+function createFileStore(path$1) {
+	return new FileStore(path$1);
+}
+
+//#endregion
+export { createFileStore as n, createGerbilEmbedder as r, FileStore as t };
+//# sourceMappingURL=memory-DVN0MnIG.mjs.map

package/dist/memory-DVN0MnIG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-DVN0MnIG.mjs","names":["path","snapshot: MemoryExport","candidates: { item: MemoryRecord; vector: Float32Array }[]","out: MemoryRecord[]"],"sources":["../src/memory/gerbil-embedder.ts","../src/memory/stores/file-store.ts"],"sourcesContent":["/**\n * Adapter that wires Gerbil's native embeddings into the memory module.\n *\n * The memory module only needs `(texts) => Promise<Float32Array[]>`. This\n * adapter accepts anything that exposes an `embedBatch` returning records with\n * a numeric `vector` — which covers a {@link Gerbil} instance, the one-liner\n * `embedBatch`, and the browser `useEmbedding().embedBatch`. Keeping the\n * contract structural avoids a hard dependency on the core engine types and\n * keeps the module engine-agnostic.\n */\n\nimport type { Embedder } from \"./types.js\";\n\n/** Minimal shape of a batch embedder returning `{ vector }` records. */\nexport type BatchEmbedderLike = {\n  embedBatch(texts: string[]): Promise<{ vector: number[] }[]>;\n};\n\n/**\n * Build an {@link Embedder} from a Gerbil instance (or any object exposing a\n * compatible `embedBatch`). Vectors are converted to {@link Float32Array}.\n *\n * @example\n * ```ts\n * import { Gerbil } from \"@tryhamster/gerbil\";\n * import { createMemory, createGerbilEmbedder } from \"@tryhamster/gerbil/memory\";\n *\n * const g = new Gerbil();\n * await g.loadModel(\"embeddinggemma-300m\");\n * const mem = createMemory({ embed: createGerbilEmbedder(g) });\n * ```\n */\nexport function createGerbilEmbedder(engine: BatchEmbedderLike): Embedder {\n  return async (texts: string[]) => {\n    const results = await engine.embedBatch(texts);\n    return results.map((result) => Float32Array.from(result.vector));\n  };\n}\n","/**\n * File-backed JSON {@link MemoryStore} for simple Node persistence.\n *\n * Loads the whole corpus into memory and writes the full JSON file on every\n * mutation (debounced via an awaited write queue). This is intentionally\n * simple and aimed at small-to-medium corpora; see follow-ups for a\n * SQLite/OPFS backend at scale. Node-only — do not import in browser code.\n */\n\nimport { mkdir, readFile, writeFile } from \"node:fs/promises\";\nimport { dirname } from \"node:path\";\nimport { deserializeRecord, matchesFilter, serializeRecord } from \"../serialize.js\";\nimport type {\n  MemoryExport,\n  MemoryRecord,\n  MemorySearchResult,\n  MemoryStore,\n  MetadataFilter,\n  StoreSearchOptions,\n} from \"../types.js\";\nimport { type Scored, topK } from \"../vector.js\";\n\nconst DEFAULT_K = 5;\n\n/** JSON-on-disk vector store for Node. */\nexport class FileStore implements MemoryStore {\n  private readonly path: string;\n  private records = new Map<string, MemoryRecord>();\n  private loaded = false;\n  private writeQueue: Promise<void> = Promise.resolve();\n\n  constructor(path: string) {\n    this.path = path;\n  }\n\n  private async ensureLoaded(): Promise<void> {\n    if (this.loaded) {\n      return;\n    }\n    try {\n      const raw = await readFile(this.path, \"utf8\");\n      const parsed = JSON.parse(raw) as MemoryExport;\n      for (const record of parsed.records) {\n        const hydrated = deserializeRecord(record);\n        this.records.set(hydrated.id, hydrated);\n      }\n    } catch (error) {\n      // Missing file is fine — start empty. Re-throw anything else.\n      if ((error as NodeJS.ErrnoException).code !== \"ENOENT\") {\n        throw error;\n      }\n    }\n    this.loaded = true;\n  }\n\n  private persist(): Promise<void> {\n    const snapshot: MemoryExport = {\n      version: 1,\n      records: [...this.records.values()].map(serializeRecord),\n    };\n    const payload = JSON.stringify(snapshot);\n    // Serialize writes so concurrent mutations don't interleave on disk.\n    this.writeQueue = this.writeQueue.then(async () => {\n      await mkdir(dirname(this.path), { recursive: true });\n      await writeFile(this.path, payload, \"utf8\");\n    });\n    return this.writeQueue;\n  }\n\n  async add(record: MemoryRecord): Promise<void> {\n    await this.ensureLoaded();\n    this.records.set(record.id, record);\n    await this.persist();\n  }\n\n  async addMany(records: MemoryRecord[]): Promise<void> {\n    await this.ensureLoaded();\n    for (const record of records) {\n      this.records.set(record.id, record);\n    }\n    await this.persist();\n  }\n\n  async get(id: string): Promise<MemoryRecord | undefined> {\n    await this.ensureLoaded();\n    return this.records.get(id);\n  }\n\n  async search(\n    queryVector: Float32Array,\n    options: StoreSearchOptions = {},\n  ): Promise<MemorySearchResult[]> {\n    await this.ensureLoaded();\n    const k = options.k ?? DEFAULT_K;\n    const candidates: { item: MemoryRecord; vector: Float32Array }[] = [];\n    for (const record of this.records.values()) {\n      if (!record.embedding) {\n        continue;\n      }\n      if (!matchesFilter(record.metadata, options.filter)) {\n        continue;\n      }\n      candidates.push({ item: record, vector: record.embedding });\n    }\n    const ranked: Scored<MemoryRecord>[] = topK(queryVector, candidates, k, options.minScore);\n    return ranked.map((entry) => ({ record: entry.item, score: entry.score }));\n  }\n\n  async delete(id: string): Promise<boolean> {\n    await this.ensureLoaded();\n    const existed = this.records.delete(id);\n    if (existed) {\n      await this.persist();\n    }\n    return existed;\n  }\n\n  async list(filter?: MetadataFilter): Promise<MemoryRecord[]> {\n    await this.ensureLoaded();\n    const out: MemoryRecord[] = [];\n    for (const record of this.records.values()) {\n      if (matchesFilter(record.metadata, filter)) {\n        out.push(record);\n      }\n    }\n    return out;\n  }\n\n  async clear(): Promise<void> {\n    await this.ensureLoaded();\n    this.records.clear();\n    await this.persist();\n  }\n\n  async size(): Promise<number> {\n    await this.ensureLoaded();\n    return this.records.size;\n  }\n}\n\n/** Create a {@link FileStore} backed by `path` (JSON). */\nexport function createFileStore(path: string): MemoryStore {\n  return new FileStore(path);\n}\n"],"mappings":"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"}

package/dist/memory-Dj0J1v88.mjs

@@ -0,0 +1,294 @@
+import { a as deserializeRecord, i as topK, o as matchesFilter, r as normalize, s as serializeRecord } from "./vector-B0panuy6.mjs";
+
+//#region src/memory/chunking.ts
+const DEFAULT_CHUNK_SIZE = 1e3;
+const DEFAULT_OVERLAP = 200;
+/**
+* Split `text` into overlapping character windows.
+*
+* Chunks are `chunkSize` characters with `overlap` characters shared between
+* consecutive chunks, which preserves context across boundaries. Whitespace
+* is trimmed and empty chunks are dropped. Short text returns a single chunk.
+*
+* @throws if `overlap` is not less than `chunkSize` (would loop forever).
+*/
+function chunkText(text, options = {}) {
+	const chunkSize = options.chunkSize ?? DEFAULT_CHUNK_SIZE;
+	const overlap = options.overlap ?? DEFAULT_OVERLAP;
+	if (chunkSize <= 0) throw new Error("chunkSize must be greater than 0");
+	if (overlap < 0 || overlap >= chunkSize) throw new Error("overlap must be >= 0 and < chunkSize");
+	const trimmed = text.trim();
+	if (trimmed.length <= chunkSize) return trimmed.length > 0 ? [trimmed] : [];
+	const stride = chunkSize - overlap;
+	const chunks = [];
+	for (let start = 0; start < trimmed.length; start += stride) {
+		const chunk = trimmed.slice(start, start + chunkSize).trim();
+		if (chunk.length > 0) chunks.push(chunk);
+		if (start + chunkSize >= trimmed.length) break;
+	}
+	return chunks;
+}
+
+//#endregion
+//#region src/memory/redaction.ts
+const REDACTION_PLACEHOLDER = "[REDACTED]";
+/**
+* Apply a {@link Redactor} to `text`.
+*
+* - A {@link RegExp} replaces all matches with `[REDACTED]` (the `g` flag is
+*   forced so replacement is global regardless of the supplied flags).
+* - A function is invoked and its return value used.
+* - `undefined` returns the text unchanged.
+*/
+function applyRedaction(text, redact) {
+	if (!redact) return text;
+	if (typeof redact === "function") return redact(text);
+	const global = redact.global ? redact : new RegExp(redact.source, `${redact.flags}g`);
+	return text.replace(global, REDACTION_PLACEHOLDER);
+}
+
+//#endregion
+//#region src/memory/stores/memory-store.ts
+/**
+* In-memory {@link MemoryStore} — the default backend.
+*
+* Works in both Node and the browser. Holds records in a `Map` and performs
+* a brute-force cosine top-k scan on search. Records are expected to carry
+* pre-normalized embeddings (the {@link Memory} facade normalizes on insert).
+*/
+const DEFAULT_K = 5;
+/** Brute-force, embedding-agnostic in-memory vector store. */
+var InMemoryStore = class {
+	records = /* @__PURE__ */ new Map();
+	add(record) {
+		this.records.set(record.id, record);
+		return Promise.resolve();
+	}
+	addMany(records) {
+		for (const record of records) this.records.set(record.id, record);
+		return Promise.resolve();
+	}
+	get(id) {
+		return Promise.resolve(this.records.get(id));
+	}
+	search(queryVector, options = {}) {
+		const k = options.k ?? DEFAULT_K;
+		const candidates = [];
+		for (const record of this.records.values()) {
+			if (!record.embedding) continue;
+			if (!matchesFilter(record.metadata, options.filter)) continue;
+			candidates.push({
+				item: record,
+				vector: record.embedding
+			});
+		}
+		const ranked = topK(queryVector, candidates, k, options.minScore);
+		return Promise.resolve(ranked.map((entry) => ({
+			record: entry.item,
+			score: entry.score
+		})));
+	}
+	delete(id) {
+		return Promise.resolve(this.records.delete(id));
+	}
+	list(filter) {
+		const out = [];
+		for (const record of this.records.values()) if (matchesFilter(record.metadata, filter)) out.push(record);
+		return Promise.resolve(out);
+	}
+	clear() {
+		this.records.clear();
+		return Promise.resolve();
+	}
+	size() {
+		return Promise.resolve(this.records.size);
+	}
+};
+/** Create an {@link InMemoryStore}. */
+function createInMemoryStore() {
+	return new InMemoryStore();
+}
+
+//#endregion
+//#region src/memory/tokens.ts
+/**
+* Approximate token counting for context packing.
+*
+* We deliberately avoid a real tokenizer dependency here. The heuristic is
+* the widely used "~4 characters per token" rule for English-ish text, with
+* a small floor so very short strings still cost at least one token. This is
+* an estimate used only for budgeting — slightly conservative is fine, since
+* the goal is to stay under a model's context window, not to be exact.
+*/
+const CHARS_PER_TOKEN = 4;
+/**
+* Estimate the number of tokens in `text`.
+*
+* Uses the ~4-chars-per-token heuristic. Returns 0 for empty strings.
+*/
+function estimateTokens(text) {
+	if (text.length === 0) return 0;
+	return Math.max(1, Math.ceil(text.length / CHARS_PER_TOKEN));
+}
+
+//#endregion
+//#region src/memory/memory.ts
+/**
+* The {@link Memory} facade: the small, obvious public API over a pluggable
+* {@link MemoryStore} and an injected {@link Embedder}.
+*
+* Lifecycle of a write: redact -> (optional) chunk -> embed -> normalize ->
+* store. Reads embed the query once and delegate cosine top-k to the store.
+* {@link Memory.recall} adds token-budgeted context packing on top of search.
+*/
+const DEFAULT_RECALL_K = 20;
+const DEFAULT_TOKEN_BUDGET = 1024;
+const DEFAULT_SEPARATOR = "\n\n";
+function generateId() {
+	const cryptoObj = globalThis.crypto;
+	if (cryptoObj?.randomUUID) return cryptoObj.randomUUID();
+	return `mem-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+/**
+* On-device persistent memory with semantic recall.
+*
+* Construct via {@link createMemory}. Engine-agnostic: bring any
+* {@link Embedder} (Gerbil's native embeddings by default) and any
+* {@link MemoryStore} backend.
+*/
+var Memory = class {
+	embedder;
+	store;
+	redact;
+	defaultChunk;
+	constructor(options) {
+		if (typeof options.embed !== "function") throw new Error("createMemory requires an `embed` function");
+		this.embedder = options.embed;
+		this.store = options.store ?? createInMemoryStore();
+		this.redact = options.redact;
+		this.defaultChunk = options.chunk;
+	}
+	/** The underlying store, for advanced use (custom queries, swapping). */
+	get backend() {
+		return this.store;
+	}
+	/**
+	* Add text to memory. Long text can be split into overlapping chunks
+	* (one record per chunk). Returns the ids of the created record(s).
+	*/
+	async add(text, options = {}) {
+		const redacted = applyRedaction(text, this.redact);
+		const chunkConfig = this.resolveChunking(options.chunk);
+		const nonEmpty = (chunkConfig ? chunkText(redacted, chunkConfig) : [redacted]).filter((piece) => piece.length > 0);
+		if (nonEmpty.length === 0) return [];
+		if (options.id && nonEmpty.length > 1) throw new Error("Cannot use an explicit `id` when text is split into multiple chunks");
+		const vectors = await this.embedder(nonEmpty);
+		const createdAt = Date.now();
+		const metadata = options.metadata ?? {};
+		const records = nonEmpty.map((piece, index) => ({
+			id: index === 0 && options.id ? options.id : generateId(),
+			text: piece,
+			embedding: normalize(vectors[index]),
+			metadata,
+			createdAt
+		}));
+		await this.store.addMany(records);
+		return records.map((record) => record.id);
+	}
+	resolveChunking(chunk) {
+		if (chunk === true) return this.defaultChunk ?? {};
+		if (chunk && typeof chunk === "object") return chunk;
+	}
+	/** Fetch a record by id. */
+	get(id) {
+		return this.store.get(id);
+	}
+	/** Semantic search: returns the top-k records by cosine similarity. */
+	async search(query, options = {}) {
+		const [vector] = await this.embedder([query]);
+		return this.store.search(normalize(vector), {
+			k: options.k,
+			filter: options.filter,
+			minScore: options.minScore
+		});
+	}
+	/**
+	* Retrieve relevant memories and greedily pack them into a token-budgeted
+	* context block, highest-scoring first, stopping before the budget is
+	* exceeded. This is the per-turn context-rebuild step that turns the store
+	* into agent memory. Token counts are approximate (see {@link estimateTokens}).
+	*/
+	async recall(query, options = {}) {
+		const budget = options.tokenBudget ?? DEFAULT_TOKEN_BUDGET;
+		const separator = options.separator ?? DEFAULT_SEPARATOR;
+		const candidates = await this.search(query, {
+			k: options.k ?? DEFAULT_RECALL_K,
+			filter: options.filter,
+			minScore: options.minScore
+		});
+		const separatorTokens = estimateTokens(separator);
+		const packed = [];
+		let tokensUsed = 0;
+		for (const { record } of candidates) {
+			const recordTokens = estimateTokens(record.text);
+			const withSeparator = packed.length === 0 ? recordTokens : recordTokens + separatorTokens;
+			if (tokensUsed + withSeparator > budget) continue;
+			packed.push(record);
+			tokensUsed += withSeparator;
+		}
+		return {
+			context: packed.map((record) => record.text).join(separator),
+			records: packed,
+			tokensUsed
+		};
+	}
+	/** Delete a record by id. Returns `true` if it existed. */
+	delete(id) {
+		return this.store.delete(id);
+	}
+	/** List all records, optionally filtered by metadata. */
+	list(filter) {
+		return this.store.list(filter);
+	}
+	/** Remove all records. */
+	clear() {
+		return this.store.clear();
+	}
+	/** Total number of stored records. */
+	size() {
+		return this.store.size();
+	}
+	/** Export the full corpus as a JSON-serializable snapshot. */
+	async export() {
+		return {
+			version: 1,
+			records: (await this.store.list()).map(serializeRecord)
+		};
+	}
+	/**
+	* Import records from a snapshot produced by {@link Memory.export}.
+	* Existing records with the same id are overwritten.
+	*/
+	async import(snapshot) {
+		const records = snapshot.records.map(deserializeRecord);
+		await this.store.addMany(records);
+	}
+};
+/**
+* Create a {@link Memory} instance.
+*
+* @example
+* ```ts
+* const mem = createMemory({ embed, store });
+* await mem.add("Paris is the capital of France", { metadata: { topic: "geo" } });
+* const hits = await mem.search("French capital", { k: 3 });
+* const { context } = await mem.recall("French capital", { tokenBudget: 512 });
+* ```
+*/
+function createMemory(options) {
+	return new Memory(options);
+}
+
+//#endregion
+export { createInMemoryStore as a, InMemoryStore as i, createMemory as n, applyRedaction as o, estimateTokens as r, chunkText as s, Memory as t };
+//# sourceMappingURL=memory-Dj0J1v88.mjs.map

package/dist/memory-Dj0J1v88.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-Dj0J1v88.mjs","names":["chunks: string[]","candidates: { item: MemoryRecord; vector: Float32Array }[]","ranked: Scored<MemoryRecord>[]","out: MemoryRecord[]","records: MemoryRecord[]","packed: MemoryRecord[]"],"sources":["../src/memory/chunking.ts","../src/memory/redaction.ts","../src/memory/stores/memory-store.ts","../src/memory/tokens.ts","../src/memory/memory.ts"],"sourcesContent":["/**\n * Document chunking: split long text into overlapping windows before\n * embedding so retrieval can target relevant passages.\n */\n\nimport type { ChunkOptions } from \"./types.js\";\n\nconst DEFAULT_CHUNK_SIZE = 1000;\nconst DEFAULT_OVERLAP = 200;\n\n/**\n * Split `text` into overlapping character windows.\n *\n * Chunks are `chunkSize` characters with `overlap` characters shared between\n * consecutive chunks, which preserves context across boundaries. Whitespace\n * is trimmed and empty chunks are dropped. Short text returns a single chunk.\n *\n * @throws if `overlap` is not less than `chunkSize` (would loop forever).\n */\nexport function chunkText(text: string, options: ChunkOptions = {}): string[] {\n  const chunkSize = options.chunkSize ?? DEFAULT_CHUNK_SIZE;\n  const overlap = options.overlap ?? DEFAULT_OVERLAP;\n\n  if (chunkSize <= 0) {\n    throw new Error(\"chunkSize must be greater than 0\");\n  }\n  if (overlap < 0 || overlap >= chunkSize) {\n    throw new Error(\"overlap must be >= 0 and < chunkSize\");\n  }\n\n  const trimmed = text.trim();\n  if (trimmed.length <= chunkSize) {\n    return trimmed.length > 0 ? [trimmed] : [];\n  }\n\n  const stride = chunkSize - overlap;\n  const chunks: string[] = [];\n  for (let start = 0; start < trimmed.length; start += stride) {\n    const chunk = trimmed.slice(start, start + chunkSize).trim();\n    if (chunk.length > 0) {\n      chunks.push(chunk);\n    }\n    if (start + chunkSize >= trimmed.length) {\n      break;\n    }\n  }\n  return chunks;\n}\n","/**\n * Privacy redaction applied to memory text on write.\n */\n\nimport type { Redactor } from \"./types.js\";\n\nconst REDACTION_PLACEHOLDER = \"[REDACTED]\";\n\n/**\n * Apply a {@link Redactor} to `text`.\n *\n * - A {@link RegExp} replaces all matches with `[REDACTED]` (the `g` flag is\n *   forced so replacement is global regardless of the supplied flags).\n * - A function is invoked and its return value used.\n * - `undefined` returns the text unchanged.\n */\nexport function applyRedaction(text: string, redact?: Redactor): string {\n  if (!redact) {\n    return text;\n  }\n  if (typeof redact === \"function\") {\n    return redact(text);\n  }\n  const global = redact.global ? redact : new RegExp(redact.source, `${redact.flags}g`);\n  return text.replace(global, REDACTION_PLACEHOLDER);\n}\n","/**\n * In-memory {@link MemoryStore} — the default backend.\n *\n * Works in both Node and the browser. Holds records in a `Map` and performs\n * a brute-force cosine top-k scan on search. Records are expected to carry\n * pre-normalized embeddings (the {@link Memory} facade normalizes on insert).\n */\n\nimport { matchesFilter } from \"../serialize.js\";\nimport type {\n  MemoryRecord,\n  MemorySearchResult,\n  MemoryStore,\n  MetadataFilter,\n  StoreSearchOptions,\n} from \"../types.js\";\nimport { type Scored, topK } from \"../vector.js\";\n\nconst DEFAULT_K = 5;\n\n/** Brute-force, embedding-agnostic in-memory vector store. */\nexport class InMemoryStore implements MemoryStore {\n  private readonly records = new Map<string, MemoryRecord>();\n\n  add(record: MemoryRecord): Promise<void> {\n    this.records.set(record.id, record);\n    return Promise.resolve();\n  }\n\n  addMany(records: MemoryRecord[]): Promise<void> {\n    for (const record of records) {\n      this.records.set(record.id, record);\n    }\n    return Promise.resolve();\n  }\n\n  get(id: string): Promise<MemoryRecord | undefined> {\n    return Promise.resolve(this.records.get(id));\n  }\n\n  search(\n    queryVector: Float32Array,\n    options: StoreSearchOptions = {},\n  ): Promise<MemorySearchResult[]> {\n    const k = options.k ?? DEFAULT_K;\n    const candidates: { item: MemoryRecord; vector: Float32Array }[] = [];\n    for (const record of this.records.values()) {\n      if (!record.embedding) {\n        continue;\n      }\n      if (!matchesFilter(record.metadata, options.filter)) {\n        continue;\n      }\n      candidates.push({ item: record, vector: record.embedding });\n    }\n    const ranked: Scored<MemoryRecord>[] = topK(queryVector, candidates, k, options.minScore);\n    return Promise.resolve(ranked.map((entry) => ({ record: entry.item, score: entry.score })));\n  }\n\n  delete(id: string): Promise<boolean> {\n    return Promise.resolve(this.records.delete(id));\n  }\n\n  list(filter?: MetadataFilter): Promise<MemoryRecord[]> {\n    const out: MemoryRecord[] = [];\n    for (const record of this.records.values()) {\n      if (matchesFilter(record.metadata, filter)) {\n        out.push(record);\n      }\n    }\n    return Promise.resolve(out);\n  }\n\n  clear(): Promise<void> {\n    this.records.clear();\n    return Promise.resolve();\n  }\n\n  size(): Promise<number> {\n    return Promise.resolve(this.records.size);\n  }\n}\n\n/** Create an {@link InMemoryStore}. */\nexport function createInMemoryStore(): MemoryStore {\n  return new InMemoryStore();\n}\n","/**\n * Approximate token counting for context packing.\n *\n * We deliberately avoid a real tokenizer dependency here. The heuristic is\n * the widely used \"~4 characters per token\" rule for English-ish text, with\n * a small floor so very short strings still cost at least one token. This is\n * an estimate used only for budgeting — slightly conservative is fine, since\n * the goal is to stay under a model's context window, not to be exact.\n */\n\nconst CHARS_PER_TOKEN = 4;\n\n/**\n * Estimate the number of tokens in `text`.\n *\n * Uses the ~4-chars-per-token heuristic. Returns 0 for empty strings.\n */\nexport function estimateTokens(text: string): number {\n  if (text.length === 0) {\n    return 0;\n  }\n  return Math.max(1, Math.ceil(text.length / CHARS_PER_TOKEN));\n}\n","/**\n * The {@link Memory} facade: the small, obvious public API over a pluggable\n * {@link MemoryStore} and an injected {@link Embedder}.\n *\n * Lifecycle of a write: redact -> (optional) chunk -> embed -> normalize ->\n * store. Reads embed the query once and delegate cosine top-k to the store.\n * {@link Memory.recall} adds token-budgeted context packing on top of search.\n */\n\nimport { chunkText } from \"./chunking.js\";\nimport { applyRedaction } from \"./redaction.js\";\nimport { deserializeRecord, serializeRecord } from \"./serialize.js\";\nimport { createInMemoryStore } from \"./stores/memory-store.js\";\nimport { estimateTokens } from \"./tokens.js\";\nimport type {\n  AddOptions,\n  ChunkOptions,\n  Embedder,\n  MemoryExport,\n  MemoryOptions,\n  MemoryRecord,\n  MemorySearchResult,\n  MemoryStore,\n  MetadataFilter,\n  RecallOptions,\n  RecallResult,\n  Redactor,\n  SearchOptions,\n} from \"./types.js\";\nimport { normalize } from \"./vector.js\";\n\nconst DEFAULT_RECALL_K = 20;\nconst DEFAULT_TOKEN_BUDGET = 1024;\nconst DEFAULT_SEPARATOR = \"\\n\\n\";\n\nfunction generateId(): string {\n  // crypto.randomUUID exists in modern Node (>=16) and browsers.\n  const cryptoObj = globalThis.crypto;\n  if (cryptoObj?.randomUUID) {\n    return cryptoObj.randomUUID();\n  }\n  return `mem-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;\n}\n\n/**\n * On-device persistent memory with semantic recall.\n *\n * Construct via {@link createMemory}. Engine-agnostic: bring any\n * {@link Embedder} (Gerbil's native embeddings by default) and any\n * {@link MemoryStore} backend.\n */\nexport class Memory {\n  private readonly embedder: Embedder;\n  private readonly store: MemoryStore;\n  private readonly redact?: Redactor;\n  private readonly defaultChunk?: ChunkOptions;\n\n  constructor(options: MemoryOptions) {\n    if (typeof options.embed !== \"function\") {\n      throw new Error(\"createMemory requires an `embed` function\");\n    }\n    this.embedder = options.embed;\n    this.store = options.store ?? createInMemoryStore();\n    this.redact = options.redact;\n    this.defaultChunk = options.chunk;\n  }\n\n  /** The underlying store, for advanced use (custom queries, swapping). */\n  get backend(): MemoryStore {\n    return this.store;\n  }\n\n  /**\n   * Add text to memory. Long text can be split into overlapping chunks\n   * (one record per chunk). Returns the ids of the created record(s).\n   */\n  async add(text: string, options: AddOptions = {}): Promise<string[]> {\n    const redacted = applyRedaction(text, this.redact);\n\n    const chunkConfig = this.resolveChunking(options.chunk);\n    const pieces = chunkConfig ? chunkText(redacted, chunkConfig) : [redacted];\n    const nonEmpty = pieces.filter((piece) => piece.length > 0);\n    if (nonEmpty.length === 0) {\n      return [];\n    }\n\n    if (options.id && nonEmpty.length > 1) {\n      throw new Error(\"Cannot use an explicit `id` when text is split into multiple chunks\");\n    }\n\n    const vectors = await this.embedder(nonEmpty);\n    const createdAt = Date.now();\n    const metadata = options.metadata ?? {};\n    const records: MemoryRecord[] = nonEmpty.map((piece, index) => ({\n      id: index === 0 && options.id ? options.id : generateId(),\n      text: piece,\n      embedding: normalize(vectors[index]),\n      metadata,\n      createdAt,\n    }));\n\n    await this.store.addMany(records);\n    return records.map((record) => record.id);\n  }\n\n  private resolveChunking(chunk: AddOptions[\"chunk\"]): ChunkOptions | undefined {\n    if (chunk === true) {\n      return this.defaultChunk ?? {};\n    }\n    if (chunk && typeof chunk === \"object\") {\n      return chunk;\n    }\n    return;\n  }\n\n  /** Fetch a record by id. */\n  get(id: string): Promise<MemoryRecord | undefined> {\n    return this.store.get(id);\n  }\n\n  /** Semantic search: returns the top-k records by cosine similarity. */\n  async search(query: string, options: SearchOptions = {}): Promise<MemorySearchResult[]> {\n    const [vector] = await this.embedder([query]);\n    return this.store.search(normalize(vector), {\n      k: options.k,\n      filter: options.filter,\n      minScore: options.minScore,\n    });\n  }\n\n  /**\n   * Retrieve relevant memories and greedily pack them into a token-budgeted\n   * context block, highest-scoring first, stopping before the budget is\n   * exceeded. This is the per-turn context-rebuild step that turns the store\n   * into agent memory. Token counts are approximate (see {@link estimateTokens}).\n   */\n  async recall(query: string, options: RecallOptions = {}): Promise<RecallResult> {\n    const budget = options.tokenBudget ?? DEFAULT_TOKEN_BUDGET;\n    const separator = options.separator ?? DEFAULT_SEPARATOR;\n    const candidates = await this.search(query, {\n      k: options.k ?? DEFAULT_RECALL_K,\n      filter: options.filter,\n      minScore: options.minScore,\n    });\n\n    const separatorTokens = estimateTokens(separator);\n    const packed: MemoryRecord[] = [];\n    let tokensUsed = 0;\n    for (const { record } of candidates) {\n      const recordTokens = estimateTokens(record.text);\n      const withSeparator = packed.length === 0 ? recordTokens : recordTokens + separatorTokens;\n      if (tokensUsed + withSeparator > budget) {\n        continue; // Try smaller later candidates rather than stop outright.\n      }\n      packed.push(record);\n      tokensUsed += withSeparator;\n    }\n\n    return {\n      context: packed.map((record) => record.text).join(separator),\n      records: packed,\n      tokensUsed,\n    };\n  }\n\n  /** Delete a record by id. Returns `true` if it existed. */\n  delete(id: string): Promise<boolean> {\n    return this.store.delete(id);\n  }\n\n  /** List all records, optionally filtered by metadata. */\n  list(filter?: MetadataFilter): Promise<MemoryRecord[]> {\n    return this.store.list(filter);\n  }\n\n  /** Remove all records. */\n  clear(): Promise<void> {\n    return this.store.clear();\n  }\n\n  /** Total number of stored records. */\n  size(): Promise<number> {\n    return this.store.size();\n  }\n\n  /** Export the full corpus as a JSON-serializable snapshot. */\n  async export(): Promise<MemoryExport> {\n    const records = await this.store.list();\n    return {\n      version: 1,\n      records: records.map(serializeRecord),\n    };\n  }\n\n  /**\n   * Import records from a snapshot produced by {@link Memory.export}.\n   * Existing records with the same id are overwritten.\n   */\n  async import(snapshot: MemoryExport): Promise<void> {\n    const records = snapshot.records.map(deserializeRecord);\n    await this.store.addMany(records);\n  }\n}\n\n/**\n * Create a {@link Memory} instance.\n *\n * @example\n * ```ts\n * const mem = createMemory({ embed, store });\n * await mem.add(\"Paris is the capital of France\", { metadata: { topic: \"geo\" } });\n * const hits = await mem.search(\"French capital\", { k: 3 });\n * const { context } = await mem.recall(\"French capital\", { tokenBudget: 512 });\n * ```\n */\nexport function createMemory(options: MemoryOptions): Memory {\n  return new Memory(options);\n}\n"],"mappings":"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"}

package/dist/moonshine-stt-BLyVoRpB.mjs

@@ -0,0 +1,4 @@
+import "./architectures-C1I5V3Dt.mjs";
+import { t as MoonshineSTT } from "./moonshine-stt-v_P_Ci_m.mjs";
+
+export { MoonshineSTT };