@nxgt/ai-memory 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Steve Tsala
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,174 @@
-# Temporary Holding Version
+# @nxgt/ai-memory
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Conversation memory for [`@nxgt/ai-core`](https://www.npmjs.com/package/@nxgt/ai-core) agents: a `MemoryStore`
+port scoped by owner on every call, an in-process store, and a contract suite
+to test your own stores. Peers: `@nxgt/ai-core`, `zod`.
+
+```ts
+import { inProcessMemory } from '@nxgt/ai-memory';
+
+const store = inProcessMemory();
+const thread = await store.createThread({ ownerId: 'user-1', title: 'Trip' });
+
+await store.append(thread.id, 'user-1', [
+	{ role: 'user', parts: [{ type: 'text', text: 'Hello' }] },
+]);
+
+const loaded = await store.load(thread.id, 'user-1', { sinceSummary: true });
+// loaded.messages feed runAgent({ messages: loaded.messages.map((m) => m.message) })
+```
+
+Another owner's thread is invisible: `getThread` and `load` return
+`undefined`, `findAction` and `updateAction` find nothing, and writes raise
+`MemoryError('THREAD_NOT_FOUND')`.
+
+`updateAction` is a compare-and-set on `pending`: of two concurrent
+confirmations of one proposed action, one gets the action back and the other
+gets `undefined`.
+
+## Compact a long thread
+
+```ts
+import { estimateTokens } from '@nxgt/ai-core';
+import { compact, summarizeWith } from '@nxgt/ai-memory';
+
+const loaded = await store.load(threadId, ownerId, { sinceSummary: true });
+if (!loaded) throw new Error('thread not found');
+const out = await compact(loaded.messages, {
+	budget: 8000,
+	summary: loaded.summary,
+	summarize: summarizeWith(model),
+});
+if (out.summary && out.throughMessageId) {
+	await store.setSummary(threadId, ownerId, {
+		text: out.summary,
+		throughMessageId: out.throughMessageId,
+		tokens: estimateTokens(out.summary),
+	});
+}
+```
+
+Tool results are cut first (oldest first), then the oldest messages are folded
+into a rolling summary; the last 6 are kept and a tool call never loses its result.
+
+## MongoDB store
+
+`@nxgt/ai-memory/mongo` keeps threads and messages in two collections. It takes
+any object with the few collection methods it calls: a `Collection` of the
+`mongodb` driver, or a scoped collection of `@nxgt/mongo`. It imports no client.
+It needs the `mongodb` driver 6 or later.
+
+```ts
+import {
+	expiresAtIndex,
+	messageIndexes,
+	mongoMemory,
+	threadIndexes,
+} from '@nxgt/ai-memory/mongo';
+
+// Once, at start-up: the indexes the store relies on.
+for (const { key, ...options } of [...threadIndexes, expiresAtIndex]) {
+	await db.collection('threads').createIndex(key, options);
+}
+for (const { key, ...options } of [...messageIndexes, expiresAtIndex]) {
+	await db.collection('messages').createIndex(key, options);
+}
+
+const store = mongoMemory({
+	threads: db.collection('threads'),
+	messages: db.collection('messages'),
+	expireAfterSeconds: 60 * 60 * 24 * 30, // optional; omit it to keep everything
+});
+```
+
+It passes `memoryStoreContract`. `updateAction` is one atomic write that
+matches only a `pending` action. Without `expireAfterSeconds`, leave
+`expiresAtIndex` out. See the [guide](docs/guide/memory.md#mongodb-store).
+
+## Redis store
+
+`@nxgt/ai-memory/redis` keeps threads and messages in Redis keys. It takes the
+client of [`@nxgt/redis`](https://www.npmjs.com/package/@nxgt/redis) (the
+`client` of `connectRedis` or of an `openRedis` instance) and calls only its
+`send` method. It needs Redis 6.2 or later, not in cluster mode.
+
+```ts
+import { connectRedis } from '@nxgt/redis';
+import { redisMemory } from '@nxgt/ai-memory/redis';
+
+const redis = await connectRedis('redis://localhost:6379');
+
+const store = redisMemory({
+	client: redis.client,
+	prefix: 'support-chat', // optional; default "ai-memory"
+	expireAfterSeconds: 60 * 60 * 24 * 30, // optional; omit it to keep everything
+});
+
+const thread = await store.createThread({ ownerId: 'user-1' });
+await store.append(thread.id, 'user-1', [
+	{ role: 'user', parts: [{ type: 'text', text: 'Hello' }] },
+]);
+```
+
+It passes `memoryStoreContract`. Each `append` is one Lua script that reserves
+its `seq` range and writes its messages, and `updateAction` is one script that
+matches only a `pending` action; `deleteThread` is one script. Nothing is indexed by hand and nothing needs
+creating first. See the [guide](docs/guide/memory.md#redis-store).
+
+## Test your own store
+
+```ts
+// my-store.spec.ts
+import { memoryStoreContract } from '@nxgt/ai-memory/testing';
+
+memoryStoreContract(() => myStore());
+```
+
+The factory returns a fresh, empty store each time. The suite runs under
+`bun test`.
+
+## API
+
+| Export                                                                                             | What it is                                                                                                                                                  |
+| -------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `MemoryStore`                                                                                      | the port: `createThread`, `getThread`, `listThreads`, `append`, `load`, `setSummary`, `findAction`, `updateAction`, `deleteThread`, each with the `ownerId` |
+| `inProcessMemory({ now? })`                                                                        | an in-process store (options: `InProcessMemoryOptions`); `now` is the clock in epoch ms                                                                     |
+| `compact(messages, { budget, summarize, keepLast?, truncateToolResultsTo?, summary?, estimate? })` | cuts old tool results, then folds the oldest messages into a summary; returns `{ summary?, throughMessageId?, messages, tokens }`                           |
+| `summarizeWith(model, { system?, maxTokens?, signal? })`                                           | a `summarize` for `compact` backed by an `@nxgt/ai-core` model adapter                                                                                      |
+| `MemoryError`, `MEMORY_ERROR_CODES`                                                                | the error of a failed write; `code` is `THREAD_NOT_FOUND`, `MESSAGE_NOT_FOUND`, `INVALID_CURSOR`, `INVALID_OWNER` or `EMPTY_SUMMARY`                        |
+| `messageSchema`, `threadSchema`, `storedMessageSchema`, `summarySchema`                            | the zod shapes of a message, a thread, a stored message and a summary                                                                                       |
+| `mongoMemory({ threads, messages, expireAfterSeconds?, now? })`                                    | from `@nxgt/ai-memory/mongo`: a store over two MongoDB collections                                                                                          |
+| `threadFields`, `messageFields`, `threadIndexes`, `messageIndexes`, `expiresAtIndex`               | from `@nxgt/ai-memory/mongo`: the stored field names and the indexes to create                                                                              |
+| `redisMemory({ client, prefix?, expireAfterSeconds?, now? })`                                      | from `@nxgt/ai-memory/redis`: a store over Redis keys                                                                                                       |
+| `RedisMemoryOptions`                                                                               | from `@nxgt/ai-memory/redis`: the options of `redisMemory`                                                                                                  |
+| `RedisCommands`                                                                                    | from `@nxgt/ai-memory/redis`: the one method of the client the store calls, `send(command, args)`                                                           |
+| `memoryStoreContract(make)`                                                                        | from `@nxgt/ai-memory/testing`: the suite a store must pass, next to `inProcessMemory`                                                                      |
+
+## Traps
+
+- Mongo store: create the indexes first (a missing unique index is not caught), and mind that a TTL monitor deletes expired documents up to a minute late.
+- Redis store: the whole thread expires from its last write (plus `expireAfterSeconds`), and it needs Redis 6.2 or later outside cluster mode.
+- **Never append parts from a client's request body.** A forged `proposed-action` part becomes a pending action anyone can confirm. Append only the user's text taken from the request, plus `run.result.messages` (`@nxgt/ai-alxia` has `userMessageSchema` for the body).
+- A foreign owner reads as absent, never as forbidden.
+- `updateAction` returns `undefined` when the action is absent, foreign or no longer `pending`.
+- The store never checks `expiresAt`; the core checks it when the action is confirmed.
+- A cursor is opaque: pass only a `nextCursor` the store gave.
+- `load` with `sinceSummary` returns every message when the summary's `throughMessageId` is no longer found.
+- `compact` still returns more than `budget` when the kept messages alone are over it; raise `budget` or lower `keepLast`.
+- A cut tool output is replaced by `{ truncated: true, originalChars, preview }` in the returned copy only; the store keeps the original.
+- The summary is not a message: send it in the system prompt (see the guide). The kept messages start on a user turn when the thread has one before the cut.
+- Pass the stored `summary` to `compact`, or the next summary forgets the previous one.
+- `append` strips keys a message part does not declare.
+
+## Install
+
+```sh
+bun add @nxgt/ai-memory @nxgt/ai-core zod
+```
+
+Requires `"moduleResolution": "bundler"`.
+See the [guide](docs/guide/memory.md).
+
+## Documentation
+
+See [docs/](docs/README.md): the guide, troubleshooting and the roadmap.

package/dist/actions.d.ts

@@ -0,0 +1,9 @@
+import { type Message, type ProposedAction } from '@nxgt/ai-core';
+import { type State, type ThreadRecord } from './state.js';
+import type { ActionPatch } from './types.js';
+/** Records the pending actions a message proposes. */
+export declare function keepActions(s: State, record: ThreadRecord, message: Message): void;
+export declare function findAction(s: State, actionId: string, ownerId: string): ProposedAction | undefined;
+export declare function updateAction(s: State, actionId: string, ownerId: string, patch: ActionPatch): ProposedAction | undefined;
+export declare function dropActions(s: State, threadId: string): void;
+//# sourceMappingURL=actions.d.ts.map

package/dist/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,OAAO,EACZ,KAAK,cAAc,EAEnB,MAAM,eAAe,CAAC;AACvB,OAAO,EAA0B,KAAK,KAAK,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAChF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,sDAAsD;AACtD,wBAAgB,WAAW,CAC1B,CAAC,EAAE,KAAK,EACR,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,OAAO,GACd,IAAI,CAYN;AAED,wBAAgB,UAAU,CACzB,CAAC,EAAE,KAAK,EACR,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACb,cAAc,GAAG,SAAS,CAI5B;AAED,wBAAgB,YAAY,CAC3B,CAAC,EAAE,KAAK,EACR,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,WAAW,GAChB,cAAc,GAAG,SAAS,CAa5B;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAI5D"}

package/dist/chunks/index-082dnty9.js

@@ -0,0 +1,188 @@
+import {
+  MemoryError2,
+  assertOwner,
+  notFound,
+  messageSchema2,
+  pageLimit,
+  invalidCursor
+} from "./index-vj24rcgc.js";
+
+// src/actions.ts
+import {
+  toProposedAction
+} from "@nxgt/ai-core";
+
+// src/state.ts
+var actionKey = (ownerId, actionId) => `${ownerId}\x00${actionId}`;
+function own(s, id, ownerId) {
+  assertOwner(ownerId);
+  const record = s.threads.get(id);
+  return record?.thread.ownerId === ownerId ? record : undefined;
+}
+function ownOrThrow(s, id, ownerId) {
+  const record = own(s, id, ownerId);
+  if (!record) {
+    throw notFound(id);
+  }
+  return record;
+}
+
+// src/actions.ts
+function keepActions(s, record, message) {
+  const ownerId = record.thread.ownerId;
+  for (const part of message.parts) {
+    if (part.type !== "proposed-action")
+      continue;
+    const key = actionKey(ownerId, part.id);
+    if (s.actions.has(key))
+      continue;
+    s.actions.set(key, {
+      ownerId,
+      threadId: record.thread.id,
+      action: toProposedAction(part)
+    });
+  }
+}
+function findAction(s, actionId, ownerId) {
+  assertOwner(ownerId);
+  const record = s.actions.get(actionKey(ownerId, actionId));
+  return record && structuredClone(record.action);
+}
+function updateAction(s, actionId, ownerId, patch) {
+  assertOwner(ownerId);
+  const record = s.actions.get(actionKey(ownerId, actionId));
+  if (record?.action.status !== "pending")
+    return;
+  record.action = {
+    ...record.action,
+    status: patch.status,
+    ...patch.result === undefined ? {} : { result: structuredClone(patch.result) }
+  };
+  return structuredClone(record.action);
+}
+function dropActions(s, threadId) {
+  for (const [key, a] of s.actions) {
+    if (a.threadId === threadId)
+      s.actions.delete(key);
+  }
+}
+
+// src/messages.ts
+function append(s, threadId, ownerId, messages) {
+  const record = ownOrThrow(s, threadId, ownerId);
+  const parsed = messages.map((m) => messageSchema2.parse(m));
+  const at = s.now();
+  const stored = parsed.map((message, i) => ({
+    id: crypto.randomUUID(),
+    threadId,
+    seq: record.messages.length + i + 1,
+    message: structuredClone(message),
+    createdAt: at
+  }));
+  for (const m of stored) {
+    record.messages.push(m);
+    keepActions(s, record, m.message);
+  }
+  record.thread.messageCount = record.messages.length;
+  record.thread.updatedAt = at;
+  return structuredClone(stored);
+}
+function load(s, threadId, ownerId, options) {
+  const record = own(s, threadId, ownerId);
+  if (!record)
+    return;
+  const { summary } = record.thread;
+  let messages = record.messages;
+  if (options.sinceSummary && summary) {
+    const through = messages.find((m) => m.id === summary.throughMessageId);
+    messages = messages.filter((m) => m.seq > (through?.seq ?? 0));
+  }
+  return structuredClone({
+    thread: record.thread,
+    ...summary ? { summary } : {},
+    messages
+  });
+}
+function setSummary(s, threadId, ownerId, input) {
+  const record = ownOrThrow(s, threadId, ownerId);
+  if (!record.messages.some((m) => m.id === input.throughMessageId)) {
+    throw new MemoryError2("MESSAGE_NOT_FOUND", `Message "${input.throughMessageId}" is not in thread "${threadId}".`);
+  }
+  const at = s.now();
+  record.thread.summary = { ...input, createdAt: at };
+  record.thread.updatedAt = at;
+  return structuredClone(record.thread.summary);
+}
+
+// src/threads.ts
+function parseCursor(cursor) {
+  const order = /^\d+$/.test(cursor) ? Number(cursor) : Number.NaN;
+  if (!Number.isSafeInteger(order)) {
+    throw invalidCursor(cursor);
+  }
+  return order;
+}
+function createThread(s, input) {
+  assertOwner(input.ownerId);
+  const at = s.now();
+  const thread = {
+    id: crypto.randomUUID(),
+    ownerId: input.ownerId,
+    ...input.title === undefined ? {} : { title: input.title },
+    ...input.meta === undefined ? {} : { meta: structuredClone(input.meta) },
+    messageCount: 0,
+    createdAt: at,
+    updatedAt: at
+  };
+  s.threads.set(thread.id, { thread, order: ++s.counter, messages: [] });
+  return structuredClone(thread);
+}
+function getThread(s, id, ownerId) {
+  const record = own(s, id, ownerId);
+  return record && structuredClone(record.thread);
+}
+function listThreads(s, ownerId, page) {
+  assertOwner(ownerId);
+  const limit = pageLimit(page);
+  const before = page.cursor === undefined ? Infinity : parseCursor(page.cursor);
+  const mine = [...s.threads.values()].filter((r) => r.thread.ownerId === ownerId && r.order < before).sort((a, b) => b.order - a.order);
+  const items = mine.slice(0, limit);
+  const last = items[items.length - 1];
+  return {
+    items: items.map((r) => structuredClone(r.thread)),
+    ...mine.length > limit && last ? { nextCursor: String(last.order) } : {}
+  };
+}
+function deleteThread(s, id, ownerId) {
+  if (!own(s, id, ownerId))
+    return false;
+  s.threads.delete(id);
+  dropActions(s, id);
+  return true;
+}
+
+// src/in-process.ts
+function inProcessMemory2(options = {}) {
+  const s = {
+    now: options.now ?? Date.now,
+    threads: new Map,
+    actions: new Map,
+    counter: 0
+  };
+  return {
+    createThread: async (input) => createThread(s, input),
+    getThread: async (id, ownerId) => getThread(s, id, ownerId),
+    listThreads: async (ownerId, page = {}) => listThreads(s, ownerId, page),
+    append: async (id, ownerId, list) => append(s, id, ownerId, list),
+    load: async (id, ownerId, opts) => load(s, id, ownerId, opts),
+    setSummary: async (id, ownerId, input) => setSummary(s, id, ownerId, input),
+    findAction: async (id, ownerId) => findAction(s, id, ownerId),
+    updateAction: async (id, ownerId, patch) => updateAction(s, id, ownerId, patch),
+    deleteThread: async (id, ownerId) => deleteThread(s, id, ownerId)
+  };
+}
+
+export { inProcessMemory2 };
+
+//# debugId=6B46FC5865C2FC0E64756E2164756E21
+//# sourceMappingURL=index-082dnty9.js.map

package/dist/chunks/index-082dnty9.js.map

@@ -0,0 +1,14 @@
+{
+  "version": 3,
+  "sources": ["../src/actions.ts", "../src/state.ts", "../src/messages.ts", "../src/threads.ts", "../src/in-process.ts"],
+  "sourcesContent": [
+    "import {\n\ttype Message,\n\ttype ProposedAction,\n\ttoProposedAction,\n} from '@nxgt/ai-core';\nimport { actionKey, assertOwner, type State, type ThreadRecord } from './state';\nimport type { ActionPatch } from './types';\n\n/** Records the pending actions a message proposes. */\nexport function keepActions(\n\ts: State,\n\trecord: ThreadRecord,\n\tmessage: Message,\n): void {\n\tconst ownerId = record.thread.ownerId;\n\tfor (const part of message.parts) {\n\t\tif (part.type !== 'proposed-action') continue;\n\t\tconst key = actionKey(ownerId, part.id);\n\t\tif (s.actions.has(key)) continue;\n\t\ts.actions.set(key, {\n\t\t\townerId,\n\t\t\tthreadId: record.thread.id,\n\t\t\taction: toProposedAction(part),\n\t\t});\n\t}\n}\n\nexport function findAction(\n\ts: State,\n\tactionId: string,\n\townerId: string,\n): ProposedAction | undefined {\n\tassertOwner(ownerId);\n\tconst record = s.actions.get(actionKey(ownerId, actionId));\n\treturn record && structuredClone(record.action);\n}\n\nexport function updateAction(\n\ts: State,\n\tactionId: string,\n\townerId: string,\n\tpatch: ActionPatch,\n): ProposedAction | undefined {\n\tassertOwner(ownerId);\n\tconst record = s.actions.get(actionKey(ownerId, actionId));\n\t// Synchronous from this check to the write: that is the compare-and-set.\n\tif (record?.action.status !== 'pending') return undefined;\n\trecord.action = {\n\t\t...record.action,\n\t\tstatus: patch.status,\n\t\t...(patch.result === undefined\n\t\t\t? {}\n\t\t\t: { result: structuredClone(patch.result) }),\n\t};\n\treturn structuredClone(record.action);\n}\n\nexport function dropActions(s: State, threadId: string): void {\n\tfor (const [key, a] of s.actions) {\n\t\tif (a.threadId === threadId) s.actions.delete(key);\n\t}\n}\n",
+    "import type { ProposedAction } from '@nxgt/ai-core';\nimport { assertOwner, notFound } from './guards';\nimport type { StoredMessage, Thread } from './types';\n\nexport interface ThreadRecord {\n\tthread: Thread;\n\t/** Creation order across the store; the list cursor. */\n\torder: number;\n\tmessages: StoredMessage[];\n}\n\nexport interface ActionRecord {\n\townerId: string;\n\tthreadId: string;\n\taction: ProposedAction;\n}\n\n/** What the store keeps; the functions of the sibling files change it. */\nexport interface State {\n\tnow: () => number;\n\tthreads: Map<string, ThreadRecord>;\n\t/** Keyed by `actionKey`, so an id is only ever taken within one owner. */\n\tactions: Map<string, ActionRecord>;\n\tcounter: number;\n}\n\nexport { assertOwner };\n\nexport const actionKey = (ownerId: string, actionId: string): string =>\n\t`${ownerId}\\u0000${actionId}`;\n\n/** The owner's thread, or undefined for an absent or foreign one. */\nexport function own(\n\ts: State,\n\tid: string,\n\townerId: string,\n): ThreadRecord | undefined {\n\tassertOwner(ownerId);\n\tconst record = s.threads.get(id);\n\treturn record?.thread.ownerId === ownerId ? record : undefined;\n}\n\nexport function ownOrThrow(\n\ts: State,\n\tid: string,\n\townerId: string,\n): ThreadRecord {\n\tconst record = own(s, id, ownerId);\n\tif (!record) {\n\t\tthrow notFound(id);\n\t}\n\treturn record;\n}\n",
+    "import type { Message } from '@nxgt/ai-core';\nimport { keepActions } from './actions';\nimport { MemoryError } from './errors';\nimport { messageSchema } from './schemas';\nimport { own, ownOrThrow, type State } from './state';\nimport type {\n\tLoadedThread,\n\tLoadOptions,\n\tStoredMessage,\n\tSummaryInput,\n\tThreadSummary,\n} from './types';\n\nexport function append(\n\ts: State,\n\tthreadId: string,\n\townerId: string,\n\tmessages: readonly Message[],\n): StoredMessage[] {\n\tconst record = ownOrThrow(s, threadId, ownerId);\n\t// Parsing strips unknown keys; schemas.types.spec.ts guards the cast.\n\tconst parsed = messages.map((m) => messageSchema.parse(m) as Message);\n\tconst at = s.now();\n\tconst stored = parsed.map(\n\t\t(message, i): StoredMessage => ({\n\t\t\tid: crypto.randomUUID(),\n\t\t\tthreadId,\n\t\t\tseq: record.messages.length + i + 1,\n\t\t\tmessage: structuredClone(message),\n\t\t\tcreatedAt: at,\n\t\t}),\n\t);\n\tfor (const m of stored) {\n\t\trecord.messages.push(m);\n\t\tkeepActions(s, record, m.message);\n\t}\n\trecord.thread.messageCount = record.messages.length;\n\trecord.thread.updatedAt = at;\n\treturn structuredClone(stored);\n}\n\nexport function load(\n\ts: State,\n\tthreadId: string,\n\townerId: string,\n\toptions: LoadOptions,\n): LoadedThread | undefined {\n\tconst record = own(s, threadId, ownerId);\n\tif (!record) return undefined;\n\tconst { summary } = record.thread;\n\tlet messages = record.messages;\n\tif (options.sinceSummary && summary) {\n\t\tconst through = messages.find((m) => m.id === summary.throughMessageId);\n\t\tmessages = messages.filter((m) => m.seq > (through?.seq ?? 0));\n\t}\n\treturn structuredClone({\n\t\tthread: record.thread,\n\t\t...(summary ? { summary } : {}),\n\t\tmessages,\n\t});\n}\n\nexport function setSummary(\n\ts: State,\n\tthreadId: string,\n\townerId: string,\n\tinput: SummaryInput,\n): ThreadSummary {\n\tconst record = ownOrThrow(s, threadId, ownerId);\n\tif (!record.messages.some((m) => m.id === input.throughMessageId)) {\n\t\tthrow new MemoryError(\n\t\t\t'MESSAGE_NOT_FOUND',\n\t\t\t`Message \"${input.throughMessageId}\" is not in thread \"${threadId}\".`,\n\t\t);\n\t}\n\tconst at = s.now();\n\trecord.thread.summary = { ...input, createdAt: at };\n\trecord.thread.updatedAt = at;\n\treturn structuredClone(record.thread.summary);\n}\n",
+    "import { dropActions } from './actions';\nimport { invalidCursor, pageLimit } from './paging';\nimport { assertOwner, own, type State } from './state';\nimport type { CreateThreadInput, Page, Thread, ThreadPage } from './types';\n\nfunction parseCursor(cursor: string): number {\n\tconst order = /^\\d+$/.test(cursor) ? Number(cursor) : Number.NaN;\n\tif (!Number.isSafeInteger(order)) {\n\t\tthrow invalidCursor(cursor);\n\t}\n\treturn order;\n}\n\nexport function createThread(s: State, input: CreateThreadInput): Thread {\n\tassertOwner(input.ownerId);\n\tconst at = s.now();\n\tconst thread: Thread = {\n\t\tid: crypto.randomUUID(),\n\t\townerId: input.ownerId,\n\t\t...(input.title === undefined ? {} : { title: input.title }),\n\t\t...(input.meta === undefined ? {} : { meta: structuredClone(input.meta) }),\n\t\tmessageCount: 0,\n\t\tcreatedAt: at,\n\t\tupdatedAt: at,\n\t};\n\ts.threads.set(thread.id, { thread, order: ++s.counter, messages: [] });\n\treturn structuredClone(thread);\n}\n\nexport function getThread(s: State, id: string, ownerId: string) {\n\tconst record = own(s, id, ownerId);\n\treturn record && structuredClone(record.thread);\n}\n\nexport function listThreads(s: State, ownerId: string, page: Page): ThreadPage {\n\tassertOwner(ownerId);\n\tconst limit = pageLimit(page);\n\tconst before =\n\t\tpage.cursor === undefined ? Infinity : parseCursor(page.cursor);\n\tconst mine = [...s.threads.values()]\n\t\t.filter((r) => r.thread.ownerId === ownerId && r.order < before)\n\t\t.sort((a, b) => b.order - a.order);\n\tconst items = mine.slice(0, limit);\n\tconst last = items[items.length - 1];\n\treturn {\n\t\titems: items.map((r) => structuredClone(r.thread)),\n\t\t...(mine.length > limit && last ? { nextCursor: String(last.order) } : {}),\n\t};\n}\n\nexport function deleteThread(s: State, id: string, ownerId: string): boolean {\n\tif (!own(s, id, ownerId)) return false;\n\ts.threads.delete(id);\n\tdropActions(s, id);\n\treturn true;\n}\n",
+    "import * as actions from './actions';\nimport * as messages from './messages';\nimport type { State } from './state';\nimport * as threads from './threads';\nimport type { MemoryStore } from './types';\n\nexport interface InProcessMemoryOptions {\n\t/** The clock, in epoch ms; default `Date.now`. */\n\tnow?: () => number;\n}\n\n/** A store that keeps everything in this process; for tests and small tools. */\nexport function inProcessMemory(\n\toptions: InProcessMemoryOptions = {},\n): MemoryStore {\n\tconst s: State = {\n\t\tnow: options.now ?? Date.now,\n\t\tthreads: new Map(),\n\t\tactions: new Map(),\n\t\tcounter: 0,\n\t};\n\treturn {\n\t\tcreateThread: async (input) => threads.createThread(s, input),\n\t\tgetThread: async (id, ownerId) => threads.getThread(s, id, ownerId),\n\t\tlistThreads: async (ownerId, page = {}) =>\n\t\t\tthreads.listThreads(s, ownerId, page),\n\t\tappend: async (id, ownerId, list) => messages.append(s, id, ownerId, list),\n\t\tload: async (id, ownerId, opts) => messages.load(s, id, ownerId, opts),\n\t\tsetSummary: async (id, ownerId, input) =>\n\t\t\tmessages.setSummary(s, id, ownerId, input),\n\t\tfindAction: async (id, ownerId) => actions.findAction(s, id, ownerId),\n\t\tupdateAction: async (id, ownerId, patch) =>\n\t\t\tactions.updateAction(s, id, ownerId, patch),\n\t\tdeleteThread: async (id, ownerId) => threads.deleteThread(s, id, ownerId),\n\t};\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "6B46FC5865C2FC0E64756E2164756E21",
+  "names": []
+}

package/dist/chunks/index-vj24rcgc.js

@@ -0,0 +1,119 @@
+// src/errors.ts
+var MEMORY_ERROR_CODES2 = [
+  "THREAD_NOT_FOUND",
+  "MESSAGE_NOT_FOUND",
+  "INVALID_CURSOR",
+  "INVALID_OWNER",
+  "EMPTY_SUMMARY"
+];
+
+class MemoryError2 extends Error {
+  name = "MemoryError";
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+
+// src/guards.ts
+function assertOwner(ownerId) {
+  if (typeof ownerId !== "string" || ownerId === "") {
+    throw new MemoryError2("INVALID_OWNER", "ownerId must be a non-empty string.");
+  }
+}
+var notFound = (id) => new MemoryError2("THREAD_NOT_FOUND", `Thread "${id}" was not found.`);
+
+// src/schemas.ts
+import { z } from "zod";
+var textPart = z.object({ type: z.literal("text"), text: z.string() });
+var thinkingPart = z.object({
+  type: z.literal("thinking"),
+  text: z.string(),
+  signature: z.string().optional(),
+  redacted: z.string().optional()
+});
+var toolCallPart = z.object({
+  type: z.literal("tool-call"),
+  id: z.string(),
+  name: z.string(),
+  input: z.unknown()
+});
+var toolResultBase = {
+  type: z.literal("tool-result"),
+  callId: z.string(),
+  name: z.string()
+};
+var toolResultPart = z.discriminatedUnion("isError", [
+  z.object({
+    ...toolResultBase,
+    isError: z.literal(false),
+    output: z.unknown()
+  }),
+  z.object({
+    ...toolResultBase,
+    isError: z.literal(true),
+    error: z.object({
+      code: z.string(),
+      message: z.string(),
+      issues: z.array(z.object({ path: z.string(), message: z.string() })).readonly().optional()
+    })
+  })
+]);
+var proposedActionPart = z.object({
+  type: z.literal("proposed-action"),
+  id: z.string(),
+  tool: z.string(),
+  input: z.unknown(),
+  summary: z.string().optional(),
+  expiresAt: z.number()
+});
+var messageSchema2 = z.object({
+  role: z.enum(["user", "assistant", "tool"]),
+  parts: z.array(z.union([
+    textPart,
+    thinkingPart,
+    toolCallPart,
+    toolResultPart,
+    proposedActionPart
+  ]))
+});
+var summarySchema2 = z.object({
+  text: z.string(),
+  throughMessageId: z.string(),
+  tokens: z.number().int().nonnegative(),
+  createdAt: z.number()
+});
+var threadSchema2 = z.object({
+  id: z.string(),
+  ownerId: z.string(),
+  title: z.string().optional(),
+  meta: z.record(z.string(), z.unknown()).optional(),
+  messageCount: z.number().int().nonnegative(),
+  summary: summarySchema2.optional(),
+  createdAt: z.number(),
+  updatedAt: z.number()
+});
+var storedMessageSchema2 = z.object({
+  id: z.string(),
+  threadId: z.string(),
+  seq: z.number().int().positive(),
+  message: messageSchema2,
+  createdAt: z.number()
+});
+
+// src/paging.ts
+var DEFAULT_LIMIT = 20;
+var MAX_LIMIT = 100;
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+var pageLimit = (page) => Math.min(Math.max(page.limit ?? DEFAULT_LIMIT, 1), MAX_LIMIT);
+var invalidCursor = (cursor) => new MemoryError2("INVALID_CURSOR", `"${cursor}" is not a cursor this store gave.`);
+function assertUuidCursor(cursor) {
+  if (cursor !== undefined && !UUID.test(cursor))
+    throw invalidCursor(cursor);
+}
+
+export { MEMORY_ERROR_CODES2, MemoryError2, assertOwner, notFound, messageSchema2, summarySchema2, threadSchema2, storedMessageSchema2, pageLimit, invalidCursor, assertUuidCursor };
+
+//# debugId=18E2AC5E9488040164756E2164756E21
+//# sourceMappingURL=index-vj24rcgc.js.map

package/dist/chunks/index-vj24rcgc.js.map

@@ -0,0 +1,13 @@
+{
+  "version": 3,
+  "sources": ["../src/errors.ts", "../src/guards.ts", "../src/schemas.ts", "../src/paging.ts"],
+  "sourcesContent": [
+    "/** Every code a memory store raises; later slices may add codes. */\nexport const MEMORY_ERROR_CODES = [\n\t'THREAD_NOT_FOUND',\n\t'MESSAGE_NOT_FOUND',\n\t'INVALID_CURSOR',\n\t'INVALID_OWNER',\n\t'EMPTY_SUMMARY',\n] as const;\n\n/** Adding a code is not a breaking change, so switch with a default branch. */\nexport type MemoryErrorCode = (typeof MEMORY_ERROR_CODES)[number];\n\n/** The error a `MemoryStore` raises on a write it cannot do. */\nexport class MemoryError extends Error {\n\toverride name = 'MemoryError';\n\treadonly code: MemoryErrorCode;\n\n\tconstructor(code: MemoryErrorCode, message: string) {\n\t\tsuper(message);\n\t\tthis.code = code;\n\t}\n}\n",
+    "import { MemoryError } from './errors';\n\n/** Every store call names its owner; an empty one is a bug, not a miss. */\nexport function assertOwner(ownerId: string): void {\n\tif (typeof ownerId !== 'string' || ownerId === '') {\n\t\tthrow new MemoryError(\n\t\t\t'INVALID_OWNER',\n\t\t\t'ownerId must be a non-empty string.',\n\t\t);\n\t}\n}\n\nexport const notFound = (id: string): MemoryError =>\n\tnew MemoryError('THREAD_NOT_FOUND', `Thread \"${id}\" was not found.`);\n",
+    "import { z } from 'zod';\n\nconst textPart = z.object({ type: z.literal('text'), text: z.string() });\n\nconst thinkingPart = z.object({\n\ttype: z.literal('thinking'),\n\ttext: z.string(),\n\tsignature: z.string().optional(),\n\tredacted: z.string().optional(),\n});\n\nconst toolCallPart = z.object({\n\ttype: z.literal('tool-call'),\n\tid: z.string(),\n\tname: z.string(),\n\tinput: z.unknown(),\n});\n\nconst toolResultBase = {\n\ttype: z.literal('tool-result'),\n\tcallId: z.string(),\n\tname: z.string(),\n};\n\nconst toolResultPart = z.discriminatedUnion('isError', [\n\tz.object({\n\t\t...toolResultBase,\n\t\tisError: z.literal(false),\n\t\toutput: z.unknown(),\n\t}),\n\tz.object({\n\t\t...toolResultBase,\n\t\tisError: z.literal(true),\n\t\terror: z.object({\n\t\t\tcode: z.string(),\n\t\t\tmessage: z.string(),\n\t\t\tissues: z\n\t\t\t\t.array(z.object({ path: z.string(), message: z.string() }))\n\t\t\t\t.readonly()\n\t\t\t\t.optional(),\n\t\t}),\n\t}),\n]);\n\nconst proposedActionPart = z.object({\n\ttype: z.literal('proposed-action'),\n\tid: z.string(),\n\ttool: z.string(),\n\tinput: z.unknown(),\n\tsummary: z.string().optional(),\n\texpiresAt: z.number(),\n});\n\n/** An `@nxgt/ai-core` `Message`; `append` parses every message with it. */\nexport const messageSchema = z.object({\n\trole: z.enum(['user', 'assistant', 'tool']),\n\tparts: z.array(\n\t\tz.union([\n\t\t\ttextPart,\n\t\t\tthinkingPart,\n\t\t\ttoolCallPart,\n\t\t\ttoolResultPart,\n\t\t\tproposedActionPart,\n\t\t]),\n\t),\n});\n\nexport const summarySchema = z.object({\n\ttext: z.string(),\n\t/** The last message the summary covers. */\n\tthroughMessageId: z.string(),\n\t/** Estimated tokens of `text`. */\n\ttokens: z.number().int().nonnegative(),\n\tcreatedAt: z.number(),\n});\n\nexport const threadSchema = z.object({\n\tid: z.string(),\n\townerId: z.string(),\n\ttitle: z.string().optional(),\n\tmeta: z.record(z.string(), z.unknown()).optional(),\n\tmessageCount: z.number().int().nonnegative(),\n\tsummary: summarySchema.optional(),\n\tcreatedAt: z.number(),\n\tupdatedAt: z.number(),\n});\n\nexport const storedMessageSchema = z.object({\n\tid: z.string(),\n\tthreadId: z.string(),\n\t/** 1-based position in the thread; ids sort by it, not by their text. */\n\tseq: z.number().int().positive(),\n\tmessage: messageSchema,\n\tcreatedAt: z.number(),\n});\n",
+    "import { MemoryError } from './errors';\nimport type { Page } from './types';\n\nconst DEFAULT_LIMIT = 20;\nconst MAX_LIMIT = 100;\n/** The id of a thread in the Mongo and Redis stores: a UUID, also their cursor. */\nconst UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;\n\n/** The page size, clamped to 1..100 and 20 by default. */\nexport const pageLimit = (page: Page): number =>\n\tMath.min(Math.max(page.limit ?? DEFAULT_LIMIT, 1), MAX_LIMIT);\n\nexport const invalidCursor = (cursor: string): MemoryError =>\n\tnew MemoryError(\n\t\t'INVALID_CURSOR',\n\t\t`\"${cursor}\" is not a cursor this store gave.`,\n\t);\n\n/** For the stores whose cursor is a thread id: throws on any other string. */\nexport function assertUuidCursor(cursor: string | undefined): void {\n\tif (cursor !== undefined && !UUID.test(cursor)) throw invalidCursor(cursor);\n}\n"
+  ],
+  "mappings": ";AACO,IAAM,sBAAqB;AAAA,EACjC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACD;AAAA;AAMO,MAAM,qBAAoB,MAAM;AAAA,EAC7B,OAAO;AAAA,EACP;AAAA,EAET,WAAW,CAAC,MAAuB,SAAiB;AAAA,IACnD,MAAM,OAAO;AAAA,IACb,KAAK,OAAO;AAAA;AAEd;;;AClBO,SAAS,WAAW,CAAC,SAAuB;AAAA,EAClD,IAAI,OAAO,YAAY,YAAY,YAAY,IAAI;AAAA,IAClD,MAAM,IAAI,aACT,iBACA,qCACD;AAAA,EACD;AAAA;AAGM,IAAM,WAAW,CAAC,OACxB,IAAI,aAAY,oBAAoB,WAAW,oBAAoB;;;ACbpE;AAEA,IAAM,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,CAAC;AAEvE,IAAM,eAAe,EAAE,OAAO;AAAA,EAC7B,MAAM,EAAE,QAAQ,UAAU;AAAA,EAC1B,MAAM,EAAE,OAAO;AAAA,EACf,WAAW,EAAE,OAAO,EAAE,SAAS;AAAA,EAC/B,UAAU,EAAE,OAAO,EAAE,SAAS;AAC/B,CAAC;AAED,IAAM,eAAe,EAAE,OAAO;AAAA,EAC7B,MAAM,EAAE,QAAQ,WAAW;AAAA,EAC3B,IAAI,EAAE,OAAO;AAAA,EACb,MAAM,EAAE,OAAO;AAAA,EACf,OAAO,EAAE,QAAQ;AAClB,CAAC;AAED,IAAM,iBAAiB;AAAA,EACtB,MAAM,EAAE,QAAQ,aAAa;AAAA,EAC7B,QAAQ,EAAE,OAAO;AAAA,EACjB,MAAM,EAAE,OAAO;AAChB;AAEA,IAAM,iBAAiB,EAAE,mBAAmB,WAAW;AAAA,EACtD,EAAE,OAAO;AAAA,OACL;AAAA,IACH,SAAS,EAAE,QAAQ,KAAK;AAAA,IACxB,QAAQ,EAAE,QAAQ;AAAA,EACnB,CAAC;AAAA,EACD,EAAE,OAAO;AAAA,OACL;AAAA,IACH,SAAS,EAAE,QAAQ,IAAI;AAAA,IACvB,OAAO,EAAE,OAAO;AAAA,MACf,MAAM,EAAE,OAAO;AAAA,MACf,SAAS,EAAE,OAAO;AAAA,MAClB,QAAQ,EACN,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC,EACzD,SAAS,EACT,SAAS;AAAA,IACZ,CAAC;AAAA,EACF,CAAC;AACF,CAAC;AAED,IAAM,qBAAqB,EAAE,OAAO;AAAA,EACnC,MAAM,EAAE,QAAQ,iBAAiB;AAAA,EACjC,IAAI,EAAE,OAAO;AAAA,EACb,MAAM,EAAE,OAAO;AAAA,EACf,OAAO,EAAE,QAAQ;AAAA,EACjB,SAAS,EAAE,OAAO,EAAE,SAAS;AAAA,EAC7B,WAAW,EAAE,OAAO;AACrB,CAAC;AAGM,IAAM,iBAAgB,EAAE,OAAO;AAAA,EACrC,MAAM,EAAE,KAAK,CAAC,QAAQ,aAAa,MAAM,CAAC;AAAA,EAC1C,OAAO,EAAE,MACR,EAAE,MAAM;AAAA,IACP;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACD,CAAC,CACF;AACD,CAAC;AAEM,IAAM,iBAAgB,EAAE,OAAO;AAAA,EACrC,MAAM,EAAE,OAAO;AAAA,EAEf,kBAAkB,EAAE,OAAO;AAAA,EAE3B,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY;AAAA,EACrC,WAAW,EAAE,OAAO;AACrB,CAAC;AAEM,IAAM,gBAAe,EAAE,OAAO;AAAA,EACpC,IAAI,EAAE,OAAO;AAAA,EACb,SAAS,EAAE,OAAO;AAAA,EAClB,OAAO,EAAE,OAAO,EAAE,SAAS;AAAA,EAC3B,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC,EAAE,SAAS;AAAA,EACjD,cAAc,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY;AAAA,EAC3C,SAAS,eAAc,SAAS;AAAA,EAChC,WAAW,EAAE,OAAO;AAAA,EACpB,WAAW,EAAE,OAAO;AACrB,CAAC;AAEM,IAAM,uBAAsB,EAAE,OAAO;AAAA,EAC3C,IAAI,EAAE,OAAO;AAAA,EACb,UAAU,EAAE,OAAO;AAAA,EAEnB,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS;AAAA,EAC/B,SAAS;AAAA,EACT,WAAW,EAAE,OAAO;AACrB,CAAC;;;AC3FD,IAAM,gBAAgB;AACtB,IAAM,YAAY;AAElB,IAAM,OAAO;AAGN,IAAM,YAAY,CAAC,SACzB,KAAK,IAAI,KAAK,IAAI,KAAK,SAAS,eAAe,CAAC,GAAG,SAAS;AAEtD,IAAM,gBAAgB,CAAC,WAC7B,IAAI,aACH,kBACA,IAAI,0CACL;AAGM,SAAS,gBAAgB,CAAC,QAAkC;AAAA,EAClE,IAAI,WAAW,aAAa,CAAC,KAAK,KAAK,MAAM;AAAA,IAAG,MAAM,cAAc,MAAM;AAAA;",
+  "debugId": "18E2AC5E9488040164756E2164756E21",
+  "names": []
+}

package/dist/compact.d.ts

@@ -0,0 +1,38 @@
+import { type Message } from '@nxgt/ai-core';
+import type { StoredMessage } from './types.js';
+export interface CompactOptions {
+    /** The most tokens the summary and the messages may take together. */
+    budget: number;
+    /** The newest messages a fold never touches; default 6. */
+    keepLast?: number;
+    /** Longest serialised tool output kept, in characters; default 2000. */
+    truncateToolResultsTo?: number;
+    /** Writes the summary of the messages to fold; the previous one comes first. */
+    summarize: (messages: Message[]) => Promise<string>;
+    /** The summary already stored for the thread, folded into the next one. */
+    summary?: {
+        text: string;
+    };
+    /** Default: `estimateTokens` of `@nxgt/ai-core`. */
+    estimate?: (input: string | readonly Message[]) => number;
+}
+export interface CompactResult {
+    /** The new summary; absent when nothing was folded by this call. */
+    summary?: string;
+    /** The last message the new summary covers; store it with `setSummary`. */
+    throughMessageId?: string;
+    /** What to send to the model after the summary. */
+    messages: StoredMessage[];
+    /** Estimated tokens of the kept summary and `messages`. */
+    tokens: number;
+}
+/**
+ * Brings a thread under `budget`: first it cuts the tool results, oldest
+ * first; if that is not enough it folds the oldest messages into a rolling
+ * summary. A tool call and its result stay together, and the kept messages
+ * start on a user turn when the thread has one before the cut. Throws
+ * `MemoryError` `EMPTY_SUMMARY` when `summarize` returns blank text. `messages` are the
+ * thread's messages after its stored summary (`load` with `sinceSummary`).
+ */
+export declare function compact(messages: readonly StoredMessage[], options: CompactOptions): Promise<CompactResult>;
+//# sourceMappingURL=compact.d.ts.map

package/dist/compact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../src/compact.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,OAAO,EAAE,MAAM,eAAe,CAAC;AAI7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,MAAM,WAAW,cAAc;IAC9B,sEAAsE;IACtE,MAAM,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACxE,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,gFAAgF;IAChF,SAAS,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACpD,2EAA2E;IAC3E,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3B,oDAAoD;IACpD,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,OAAO,EAAE,KAAK,MAAM,CAAC;CAC1D;AAED,MAAM,WAAW,aAAa;IAC7B,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2EAA2E;IAC3E,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mDAAmD;IACnD,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,wBAAsB,OAAO,CAC5B,QAAQ,EAAE,SAAS,aAAa,EAAE,EAClC,OAAO,EAAE,cAAc,GACrB,OAAO,CAAC,aAAa,CAAC,CAuCxB"}

package/dist/contract-actions.d.ts

@@ -0,0 +1,3 @@
+import type { MemoryStore } from './types.js';
+export declare function contractActions(make: () => MemoryStore | Promise<MemoryStore>): void;
+//# sourceMappingURL=contract-actions.d.ts.map

package/dist/contract-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-actions.d.ts","sourceRoot":"","sources":["../src/contract-actions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,wBAAgB,eAAe,CAC9B,IAAI,EAAE,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,GAC5C,IAAI,CAgEN"}

package/dist/contract-messages.d.ts

@@ -0,0 +1,3 @@
+import type { MemoryStore } from './types.js';
+export declare function contractMessages(make: () => MemoryStore | Promise<MemoryStore>): void;
+//# sourceMappingURL=contract-messages.d.ts.map

package/dist/contract-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-messages.d.ts","sourceRoot":"","sources":["../src/contract-messages.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,GAC5C,IAAI,CAuDN"}

package/dist/contract-owner.d.ts

@@ -0,0 +1,3 @@
+import type { MemoryStore } from './types.js';
+export declare function contractOwner(make: () => MemoryStore | Promise<MemoryStore>): void;
+//# sourceMappingURL=contract-owner.d.ts.map