mnemocyte 0.1.5 → 0.3.0

package/README.md

@@ -16,7 +16,7 @@ logs, and duplicate-consolidation tools on top of your existing infrastructure.
 - Hybrid recall with vector similarity, lexical matching, recency, confidence,
   access count, and importance.
 - Prompt-ready context output in Markdown, plain text, or XML.
-- Provider timeouts, retries, and `AbortSignal` cancellation.
+- Provider retries, per-attempt timeouts, and caller `AbortSignal` cancellation.
 - Pruning, duplicate detection, audit logs, and experimental consolidation.
 
 Mnemocyte is ESM-only. Use `import`, not CommonJS `require`.
@@ -70,6 +70,9 @@ When `databaseUrl` is omitted, Mnemocyte uses the in-memory backend.
 ## Embedder
 
 Mnemocyte accepts any embedder that returns one vector per input text.
+Each vector must match `embedder.dimensions` and contain only finite numbers;
+invalid provider output fails with `MnemocyteError` code `"EMBEDDING"` before
+anything is stored.
 
 ```ts
 const client = createMnemocyte({
@@ -103,8 +106,8 @@ supported for consumers that prefer provider-specific imports.
 
 ## Postgres
 
-For persistent storage, apply the bundled migration to a Postgres database with
-pgvector enabled, then pass `databaseUrl`.
+For persistent storage, enable pgvector in your Postgres database, apply the
+bundled migrations, then pass `databaseUrl`.
 
 ```ts
 const client = createMnemocyte({
@@ -117,13 +120,46 @@ The package includes:
 
 ```txt
 migrations/0000_initial.sql
+migrations/0001_add_mnemocyte_meta.sql
+migrations/0000_initial.sql.template
+migrations/render-initial.mjs
 ```
 
-The current Postgres schema uses `embedding vector(1536)`, so the Postgres
-backend currently requires a 1536-dimensional embedder.
+For the default 1536-dimensional schema on a fresh install, apply these in
+order:
 
-If dimensions do not match, `createMnemocyte` throws a `MnemocyteError` with
-code `"CONFIG"` before opening the connection pool.
+```txt
+migrations/0000_initial.sql
+migrations/0001_add_mnemocyte_meta.sql
+```
+
+For an existing 0.1.x Postgres install, apply
+`migrations/0001_add_mnemocyte_meta.sql` to record the current 1536-dimensional
+installation metadata.
+
+For a different embedding dimension on a fresh installation, render an explicit
+initial migration from the template and apply that rendered file instead of the
+default `0000_initial.sql`. The rendered initial migration includes the
+matching `mnemocyte_meta` row.
+
+```bash
+node node_modules/mnemocyte/migrations/render-initial.mjs --dimensions 768 --out migrations/0000_initial.768.sql
+```
+
+Inside this repository, the equivalent development shortcut is:
+
+```bash
+pnpm migration:render -- --dimensions 768 --out migrations/0000_initial.768.sql
+```
+
+The Postgres backend supports one embedding dimension per installation. Before
+the first embedding-dependent Postgres operation, Mnemocyte reads
+`mnemocyte_meta` and validates it against `embedder.dimensions` before calling
+the embedder. A mismatch throws a `MnemocyteError` with code `"CONFIG"`; missing
+v0.2.0 metadata throws code `"MIGRATION"`.
+
+Use the embedding dimension documented for your chosen model, render or apply a
+matching schema, and keep one dimension per Mnemocyte installation.
 
 The migration creates the bundled HNSW pgvector index
 `mnemocyte_memories_embedding_hnsw_idx` for cosine search. HNSW is approximate:
@@ -141,7 +177,8 @@ add full-text or tag-specific GIN indexes yet; add and benchmark expression
 indexes such as `to_tsvector('english', content)` or tag-oriented indexes only
 when your workload needs them.
 
-Configurable embedding dimensions are planned for `0.2.0`.
+Existing 0.1.x deployments remain on 1536 unless you plan and run your own
+Postgres migration to a different pgvector dimension.
 
 ## API
 
@@ -157,6 +194,31 @@ await client.remember({
 });
 ```
 
+Memory metadata is persisted JSON value data. Use the exported `JsonObject`
+and `JsonValue` types; unsupported values such as `undefined`, functions,
+bigints, non-finite numbers, class instances, or cyclic objects are rejected
+with `MnemocyteError` code `"VALIDATION"`. Mnemocyte deep-clones metadata when
+writing and reading, so later mutations do not change stored state.
+
+For batches, cancellation belongs to the whole operation:
+
+```ts
+const abortController = new AbortController();
+
+const memories = await client.rememberMany({
+  inputs: [
+    { entityId: "user_123", content: "Likes concise answers." },
+    { entityId: "user_123", content: "Uses TypeScript." },
+  ],
+  signal: abortController.signal,
+});
+```
+
+The positional `rememberMany(inputs)` form remains as a deprecated pre-v1
+compatibility overload and treats its first item's signal as the batch signal.
+New code should use `{ inputs, signal }`; individual items in the object form do
+not have cancellation signals.
+
 ### `recall`
 
 ```ts
@@ -179,6 +241,9 @@ const context = await client.buildContext({
 });
 ```
 
+When supplied, `maxTokens` must be a positive integer or `buildContext` rejects
+with `"VALIDATION"`. Omitting it keeps the default token-budget path.
+
 ### `prune`
 
 ```ts
@@ -218,6 +283,12 @@ const events = await client.listAuditLog({
 });
 ```
 
+Ordinary audit writes are best-effort: an audit storage failure does not fail
+the primary client operation, so `listAuditLog` returns only events that were
+successfully persisted. Postgres consolidation is the exception; its
+`"memory.superseded"` events share the consolidation transaction and commit or
+roll back with it.
+
 ### `experimental.consolidate`
 
 ```ts
@@ -266,6 +337,7 @@ VALIDATION
 CONFIG
 DB
 NOT_FOUND
+MIGRATION
 ```
 
 ## Retrieval Tuning
@@ -289,29 +361,131 @@ const client = createMnemocyte({
 });
 ```
 
+Retrieval weights must be finite and non-negative, with a non-zero effective
+total after defaults are applied. `recencyHalfLifeDays` and `accessSaturation`
+must be positive finite numbers, and `candidateMultiplier` must be an integer
+of at least 1. Invalid tuning is rejected at client construction with
+`MnemocyteError` code `"CONFIG"`.
+
 ## Roadmap
 
 Planned larger milestones:
 
-- configurable embedding dimensions with `mnemocyte_meta`
-- `MemoryStore` abstraction
+- public `MemoryStore` adapter surface
 - `drizzleStore(db)` for caller-owned Drizzle clients
 - `@mnemocyte/mcp`
 
-See [ROADMAP.md](./ROADMAP.md).
+See [ROADMAP.md](./docs/ROADMAP.md).
+
+## Pre-v1 Notes
+
+Current behavior:
+
+- `createMnemocyte()` selects either the in-memory backend or the
+  Postgres/pgvector backend.
+- Both backends run through an internal `MemoryStore` boundary and shared
+  client orchestration; `MemoryStore` is not exported as a public adapter API
+  yet.
+- Postgres schema setup is explicit; the client does not create tables or
+  indexes for you.
+- `findDuplicates`, audit-log workflows, and `experimental.consolidate` are
+  available before v1 but still subject to API refinement.
+
+Known limitations before v1:
+
+- The internal `MemoryStore` boundary is not a public adapter API yet.
+  `drizzleStore(db)` is the planned first public store adapter.
+- Configured provider timeouts abort the per-attempt `AbortSignal`; the
+  underlying provider request only stops promptly when the embedder honors that
+  signal.
+- Postgres dimension metadata is installation-wide. Mixed embedding dimensions
+  in one database are intentionally out of scope for now.
+
+Planned v1 direction:
+
+- Keep storage adapters behind `MemoryStore` while shared core code owns
+  validation, embedding, scoring, observability, resilience, and context
+  building.
+- Keep root `mnemocyte` imports provider-SDK-free.
+- Keep migrations, dimensions, and production index choices explicit.
 
 ## Development
 
+### Prerequisites
+
+- Node.js 22.18 or newer. CI tests the minimum 22.18 release and Node 24.
+- pnpm 11.1.1, matching the `packageManager` field in `package.json`.
+- Postgres with pgvector only when you want to run the integration suite.
+
+Clone the repository and install its locked dependencies:
+
+```bash
+git clone https://github.com/Meenic/mnemocyte.git
+cd mnemocyte
+pnpm install --frozen-lockfile
+```
+
+Mnemocyte is a library, not a standalone server. Use the quick-start example
+from a consuming TypeScript project, or run the repository build in watch mode
+while developing:
+
+```bash
+pnpm dev
+```
+
+Create the publishable ESM artifacts in `dist/` with:
+
+```bash
+pnpm build
+```
+
+### Validation
+
+Run the same main gates used by CI before committing:
+
 ```bash
 pnpm checktypes
 pnpm lint
 pnpm test
-pnpm run test:integration
 pnpm run pack:check
 ```
 
-`test:integration` skips when `DATABASE_URL` is not set.
+`pnpm test` builds the package, runs unit behavior, verifies package exports,
+and type-checks the public declarations. `pnpm lint` is a read-only formatting,
+lint, and import-order check; use `pnpm lint:fix` to apply its safe fixes. The
+Postgres suite is separate:
+
+```bash
+DATABASE_URL=postgres://... pnpm run test:integration
+```
+
+On PowerShell, set the environment variable for the current process first:
+
+```powershell
+$env:DATABASE_URL = "postgres://..."
+pnpm run test:integration
+```
+
+`test:integration` skips when `DATABASE_URL` is not set. The database must have
+pgvector available; the test applies the bundled migrations.
+
+### Where changes belong
+
+- Public exports and types: `src/index.ts`, `src/types.ts`, and `src/errors.ts`.
+- Shared client behavior: `src/memory/client-core.ts`; backend mechanics stay
+  in `src/memory/in-memory.ts` or `src/memory/postgres.ts`.
+- Postgres schema and SQL: `src/db/schema.ts` and `src/db/queries/`. Schema
+  changes require an explicit file under `migrations/`.
+- Provider helpers: `src/embedders/`; keep the root package provider-SDK-free.
+- Retrieval and context rendering: `src/retrieval/` and `src/context/`.
+- Tests: mirror the affected responsibility under `test/`; package boundary
+  checks live under `test/package/`, and real Postgres coverage under
+  `test/integration/`.
+
+See [AGENTS.md](./AGENTS.md) for repository rules and the validation/release
+policy. Read [ARCHITECTURE.md](./docs/ARCHITECTURE.md) before changing module
+boundaries or the public surface.
 
 ## Architecture
 
-See [ARCHITECTURE.md](./ARCHITECTURE.md).
+See [ARCHITECTURE.md](./docs/ARCHITECTURE.md).

package/dist/embedders/openai.d.mts

@@ -1,4 +1,4 @@
-import { c as Embedder } from "../types-QK_43oKJ.mjs";
+import { c as Embedder } from "../types-gOPLre4V.mjs";
 
 //#region src/embedders/openai.d.ts
 interface OpenAIEmbedderOptions {

package/dist/embedders/openai.mjs

@@ -1,4 +1,4 @@
-import { t as MnemocyteError } from "../errors-BG3-mNur.mjs";
+import { t as MnemocyteError } from "../errors-B_7ZdjEO.mjs";
 //#region src/embedders/openai.ts
 const KNOWN_MODEL_DIMENSIONS = {
 	"text-embedding-3-small": 1536,

package/dist/{errors-BG3-mNur.mjs → errors-B_7ZdjEO.mjs}

@@ -38,8 +38,9 @@ var MnemocyteError = class extends Error {
 /**
 * Type guard for {@link MnemocyteError}.
 *
-* Prefer this over `instanceof` when working across module boundaries or
-* bundlers where multiple copies of the class may exist.
+* This guard uses `instanceof` and recognizes errors created by the same loaded
+* Mnemocyte class. It does not recognize structurally similar errors or errors
+* created by another installed copy of the package.
 *
 * @param error - Value to test (typically a caught `unknown`).
 * @returns `true` if `error` is a {@link MnemocyteError}.
@@ -50,4 +51,4 @@ function isMnemocyteError(error) {
 //#endregion
 export { isMnemocyteError as n, MnemocyteError as t };
 
-//# sourceMappingURL=errors-BG3-mNur.mjs.map
+//# sourceMappingURL=errors-B_7ZdjEO.mjs.map

package/dist/{errors-BG3-mNur.mjs.map → errors-B_7ZdjEO.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"errors-BG3-mNur.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\n * Stable, machine-readable error code attached to every {@link MnemocyteError}.\n *\n * - `\"CONFIG\"` — invalid client configuration (e.g. missing or malformed embedder).\n * - `\"VALIDATION\"` — invalid argument passed to a client method.\n * - `\"DB\"` — Postgres or driver-level failure.\n * - `\"EMBEDDING\"` — embedder threw or returned an invalid vector.\n * - `\"NOT_FOUND\"` — referenced memory or entity does not exist.\n * - `\"MIGRATION\"` — schema/migration check failed against the target database.\n * - `\"TIMEOUT\"` — a provider call exceeded its configured timeout.\n * - `\"ABORTED\"` — the operation was cancelled via an `AbortSignal`.\n */\nexport type MnemocyteErrorCode =\n\t| \"CONFIG\"\n\t| \"VALIDATION\"\n\t| \"DB\"\n\t| \"EMBEDDING\"\n\t| \"NOT_FOUND\"\n\t| \"MIGRATION\"\n\t| \"TIMEOUT\"\n\t| \"ABORTED\";\n\n/**\n * Error type thrown by every public Mnemocyte API.\n *\n * Use the {@link MnemocyteError.code} property — not the message — to branch\n * on failure modes, or call {@link isMnemocyteError} as a type guard when\n * working with `unknown` errors.\n *\n * @example\n * ```ts\n * try {\n *   await client.recall({ entityId: \"u1\", query: \"hi\" });\n * } catch (err) {\n *   if (isMnemocyteError(err) && err.code === \"DB\") {\n *     // handle database failure\n *   }\n *   throw err;\n * }\n * ```\n */\nexport class MnemocyteError extends Error {\n\t/** Stable, machine-readable failure code. See {@link MnemocyteErrorCode}. */\n\treadonly code: MnemocyteErrorCode;\n\t/** Underlying cause, if any (e.g. an original driver or embedder error). */\n\toverride readonly cause?: unknown;\n\n\t/**\n\t * @param message - Human-readable error message.\n\t * @param code - Stable failure code; see {@link MnemocyteErrorCode}.\n\t * @param cause - Optional underlying cause (driver error, network error, etc.).\n\t */\n\tconstructor(message: string, code: MnemocyteErrorCode, cause?: unknown) {\n\t\tsuper(message);\n\t\tthis.name = \"MnemocyteError\";\n\t\tthis.code = code;\n\t\tthis.cause = cause;\n\t}\n}\n\n/**\n * Type guard for {@link MnemocyteError}.\n *\n * Prefer this over `instanceof` when working across module boundaries or\n * bundlers where multiple copies of the class may exist.\n *\n * @param error - Value to test (typically a caught `unknown`).\n * @returns `true` if `error` is a {@link MnemocyteError}.\n */\nexport function isMnemocyteError(error: unknown): error is MnemocyteError {\n\treturn error instanceof MnemocyteError;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAyCA,IAAa,iBAAb,cAAoC,MAAM;;CAEzC;;CAEA;;;;;;CAOA,YAAY,SAAiB,MAA0B,OAAiB;EACvE,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,OAAO;EACZ,KAAK,QAAQ;CACd;AACD;;;;;;;;;;AAWA,SAAgB,iBAAiB,OAAyC;CACzE,OAAO,iBAAiB;AACzB"}
+{"version":3,"file":"errors-B_7ZdjEO.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\n * Stable, machine-readable error code attached to every {@link MnemocyteError}.\n *\n * - `\"CONFIG\"` — invalid client configuration (e.g. missing or malformed embedder).\n * - `\"VALIDATION\"` — invalid argument passed to a client method.\n * - `\"DB\"` — Postgres or driver-level failure.\n * - `\"EMBEDDING\"` — embedder threw or returned an invalid vector.\n * - `\"NOT_FOUND\"` — referenced memory or entity does not exist.\n * - `\"MIGRATION\"` — schema/migration check failed against the target database.\n * - `\"TIMEOUT\"` — a provider call exceeded its configured timeout.\n * - `\"ABORTED\"` — the operation was cancelled via an `AbortSignal`.\n */\nexport type MnemocyteErrorCode =\n\t| \"CONFIG\"\n\t| \"VALIDATION\"\n\t| \"DB\"\n\t| \"EMBEDDING\"\n\t| \"NOT_FOUND\"\n\t| \"MIGRATION\"\n\t| \"TIMEOUT\"\n\t| \"ABORTED\";\n\n/**\n * Error type thrown by every public Mnemocyte API.\n *\n * Use the {@link MnemocyteError.code} property — not the message — to branch\n * on failure modes, or call {@link isMnemocyteError} as a type guard when\n * working with `unknown` errors.\n *\n * @example\n * ```ts\n * try {\n *   await client.recall({ entityId: \"u1\", query: \"hi\" });\n * } catch (err) {\n *   if (isMnemocyteError(err) && err.code === \"DB\") {\n *     // handle database failure\n *   }\n *   throw err;\n * }\n * ```\n */\nexport class MnemocyteError extends Error {\n\t/** Stable, machine-readable failure code. See {@link MnemocyteErrorCode}. */\n\treadonly code: MnemocyteErrorCode;\n\t/** Underlying cause, if any (e.g. an original driver or embedder error). */\n\toverride readonly cause?: unknown;\n\n\t/**\n\t * @param message - Human-readable error message.\n\t * @param code - Stable failure code; see {@link MnemocyteErrorCode}.\n\t * @param cause - Optional underlying cause (driver error, network error, etc.).\n\t */\n\tconstructor(message: string, code: MnemocyteErrorCode, cause?: unknown) {\n\t\tsuper(message);\n\t\tthis.name = \"MnemocyteError\";\n\t\tthis.code = code;\n\t\tthis.cause = cause;\n\t}\n}\n\n/**\n * Type guard for {@link MnemocyteError}.\n *\n * This guard uses `instanceof` and recognizes errors created by the same loaded\n * Mnemocyte class. It does not recognize structurally similar errors or errors\n * created by another installed copy of the package.\n *\n * @param error - Value to test (typically a caught `unknown`).\n * @returns `true` if `error` is a {@link MnemocyteError}.\n */\nexport function isMnemocyteError(error: unknown): error is MnemocyteError {\n\treturn error instanceof MnemocyteError;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAyCA,IAAa,iBAAb,cAAoC,MAAM;;CAEzC;;CAEA;;;;;;CAOA,YAAY,SAAiB,MAA0B,OAAiB;EACvE,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,OAAO;EACZ,KAAK,QAAQ;CACd;AACD;;;;;;;;;;;AAYA,SAAgB,iBAAiB,OAAyC;CACzE,OAAO,iBAAiB;AACzB"}

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { A as RetrievalConfig, C as MnemocyteOperation, D as PruneResult, E as PruneInput, M as RetrievalScoreWeights, N as RetrievalScores, O as RecallInput, P as TokenCounter, S as MnemocyteObservationPhase, T as ProviderResilienceConfig, _ as MemoryWithScore, a as ConsolidateResult, b as MnemocyteConfig, c as Embedder, d as FindDuplicatesInput, f as GlobalStats, g as MemoryType, h as Memory, i as ConsolidateInput, j as RetrievalExplanation, k as RememberInput, l as EntityStats, m as ListAuditLogInput, n as AuditEvent, o as ContextFormat, p as ImportanceLevel, r as BuildContextInput, s as DuplicatePair, t as AuditConfig, u as ExperimentalMnemocyteClient, v as MnemocyteBackend, w as ObservabilityConfig, x as MnemocyteObservation, y as MnemocyteClient } from "./types-QK_43oKJ.mjs";
+import { A as RecallInput, C as MnemocyteObservation, D as ProviderResilienceConfig, E as ObservabilityConfig, F as RetrievalScoreWeights, I as RetrievalScores, L as TokenCounter, M as RememberManyInput, N as RetrievalConfig, O as PruneInput, P as RetrievalExplanation, S as MnemocyteConfig, T as MnemocyteOperation, _ as Memory, a as ConsolidateResult, b as MnemocyteBackend, c as Embedder, d as FindDuplicatesInput, f as GlobalStats, g as ListAuditLogInput, h as JsonValue, i as ConsolidateInput, j as RememberInput, k as PruneResult, l as EntityStats, m as JsonObject, n as AuditEvent, o as ContextFormat, p as ImportanceLevel, r as BuildContextInput, s as DuplicatePair, t as AuditConfig, u as ExperimentalMnemocyteClient, v as MemoryType, w as MnemocyteObservationPhase, x as MnemocyteClient, y as MemoryWithScore } from "./types-gOPLre4V.mjs";
 
 //#region src/client.d.ts
 /**
@@ -15,16 +15,15 @@ import { A as RetrievalConfig, C as MnemocyteOperation, D as PruneResult, E as P
  *
  * @param config - Client configuration. {@link MnemocyteConfig.embedder} is required.
  * @returns A {@link MnemocyteClient} instance.
- * @throws {MnemocyteError} With code `"CONFIG"` if `embedder` is missing or
- * invalid (including when `databaseUrl` is set and `embedder.dimensions`
- * is not 1536 — the dimensionality pinned by the bundled migration), or
- * `"VALIDATION"` if `databaseUrl` is provided but empty.
+ * @throws {MnemocyteError} With code `"CONFIG"` if `embedder`, retrieval
+ * tuning, or the database URL is malformed, or `"VALIDATION"` if
+ * `databaseUrl` is explicitly empty.
  *
  * @example Postgres-backed client
  * ```ts
  * const client = createMnemocyte({
  *   databaseUrl: process.env.DATABASE_URL,
- *   embedder, // embedder.dimensions MUST be 1536 for the Postgres backend
+ *   embedder, // embedder.dimensions must match mnemocyte_meta
  * });
  * ```
  */
@@ -78,13 +77,14 @@ declare class MnemocyteError extends Error {
 /**
  * Type guard for {@link MnemocyteError}.
  *
- * Prefer this over `instanceof` when working across module boundaries or
- * bundlers where multiple copies of the class may exist.
+ * This guard uses `instanceof` and recognizes errors created by the same loaded
+ * Mnemocyte class. It does not recognize structurally similar errors or errors
+ * created by another installed copy of the package.
  *
  * @param error - Value to test (typically a caught `unknown`).
  * @returns `true` if `error` is a {@link MnemocyteError}.
  */
 declare function isMnemocyteError(error: unknown): error is MnemocyteError;
 //#endregion
-export { type AuditConfig, type AuditEvent, type BuildContextInput, type ConsolidateInput, type ConsolidateResult, type ContextFormat, type DuplicatePair, type Embedder, type EntityStats, type ExperimentalMnemocyteClient, type FindDuplicatesInput, type GlobalStats, type ImportanceLevel, type ListAuditLogInput, type Memory, type MemoryType, type MemoryWithScore, type MnemocyteBackend, type MnemocyteClient, type MnemocyteConfig, MnemocyteError, type MnemocyteErrorCode, type MnemocyteObservation, type MnemocyteObservationPhase, type MnemocyteOperation, type ObservabilityConfig, type ProviderResilienceConfig, type PruneInput, type PruneResult, type RecallInput, type RememberInput, type RetrievalConfig, type RetrievalExplanation, type RetrievalScoreWeights, type RetrievalScores, type TokenCounter, createMnemocyte, isMnemocyteError };
+export { type AuditConfig, type AuditEvent, type BuildContextInput, type ConsolidateInput, type ConsolidateResult, type ContextFormat, type DuplicatePair, type Embedder, type EntityStats, type ExperimentalMnemocyteClient, type FindDuplicatesInput, type GlobalStats, type ImportanceLevel, type JsonObject, type JsonValue, type ListAuditLogInput, type Memory, type MemoryType, type MemoryWithScore, type MnemocyteBackend, type MnemocyteClient, type MnemocyteConfig, MnemocyteError, type MnemocyteErrorCode, type MnemocyteObservation, type MnemocyteObservationPhase, type MnemocyteOperation, type ObservabilityConfig, type ProviderResilienceConfig, type PruneInput, type PruneResult, type RecallInput, type RememberInput, type RememberManyInput, type RetrievalConfig, type RetrievalExplanation, type RetrievalScoreWeights, type RetrievalScores, type TokenCounter, createMnemocyte, isMnemocyteError };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/client.ts","../src/errors.ts"],"mappings":";;;;;AAqCA;;;;;;;;AAAyE;;;;ACzBzE;;;;AAA8B;AA6B9B;;;;;;;;iBDJgB,eAAA,CAAgB,MAAA,EAAQ,eAAA,GAAkB,eAAe;;;;;;AAAzE;;;;;;;;AAAyE;KCzB7D,kBAAA;;;AAAZ;;;;AAA8B;AA6B9B;;;;;;;;;;;;cAAa,cAAA,SAAuB,KAAA;EAWvB;EAAA,SATH,IAAA,EAAM,kBAAA;EASc;EAAA,SAPX,KAAA;EAOoD;AAAA;AAiBvE;;;cAjBa,OAAA,UAAiB,IAAA,EAAM,kBAAA,EAAoB,KAAA;AAAA;;;;AAiBiB;;;;;;iBAAzD,gBAAA,CAAiB,KAAA,YAAiB,KAAA,IAAS,cAAc"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/client.ts","../src/errors.ts"],"mappings":";;;;;AAoCA;;;;;;;;AAAyE;;;;ACxBzE;;;;AAA8B;AA6B9B;;;;;;;iBDLgB,eAAA,CAAgB,MAAA,EAAQ,eAAA,GAAkB,eAAe;;;;;;AAAzE;;;;;;;;AAAyE;KCxB7D,kBAAA;;;AAAZ;;;;AAA8B;AA6B9B;;;;;;;;;;;;cAAa,cAAA,SAAuB,KAAA;EAWvB;EAAA,SATH,IAAA,EAAM,kBAAA;EASc;EAAA,SAPX,KAAA;EAOoD;AAAA;AAkBvE;;;cAlBa,OAAA,UAAiB,IAAA,EAAM,kBAAA,EAAoB,KAAA;AAAA;;;;AAkBiB;;;;;;;iBAAzD,gBAAA,CAAiB,KAAA,YAAiB,KAAA,IAAS,cAAc"}