mnemocyte 0.2.0 → 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 retries, operation timeouts, and caller `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({
@@ -149,11 +152,11 @@ Inside this repository, the equivalent development shortcut is:
 pnpm migration:render -- --dimensions 768 --out migrations/0000_initial.768.sql
 ```
 
-The Postgres backend supports one embedding dimension per installation. On the
-first 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"`.
+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.
@@ -191,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
@@ -213,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
@@ -252,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
@@ -324,15 +361,21 @@ 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:
 
-- `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
 
@@ -340,6 +383,9 @@ 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
@@ -347,34 +393,99 @@ Current behavior:
 
 Known limitations before v1:
 
-- The two current backends share behavior by convention rather than through a
-  formal `MemoryStore` adapter boundary.
-- Configured provider timeouts fail the Mnemocyte operation with `"TIMEOUT"`;
-  actively aborting the underlying provider request on timeout remains a
-  pre-v1 hardening follow-up.
+- 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:
 
-- Extract a `MemoryStore` boundary so storage adapters own persistence while
-  shared core code owns validation, embedding, scoring, observability,
-  resilience, and context building.
+- 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-DXEGcc47.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-DXEGcc47.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,8 +15,9 @@ 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, 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
@@ -76,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":";;;;;AA+BA;;;;;;;;AAAyE;;;;ACnBzE;;;;AAA8B;AA6B9B;;;;;;iBDVgB,eAAA,CAAgB,MAAA,EAAQ,eAAA,GAAkB,eAAe;;;;;;AAAzE;;;;;;;;AAAyE;KCnB7D,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"}