@nxgt/ai-memory 0.0.0-stage → 0.1.0

package/dist/mongo.js

@@ -0,0 +1,271 @@
+import {
+  MemoryError2,
+  assertOwner,
+  notFound,
+  messageSchema2,
+  pageLimit,
+  assertUuidCursor
+} from "./chunks/index-vj24rcgc.js";
+
+// src/mongo-fields.ts
+var threadFields = {
+  id: "_id",
+  ownerId: "ownerId",
+  title: "title",
+  meta: "meta",
+  messageCount: "messageCount",
+  summary: "summary",
+  createdAt: "createdAt",
+  updatedAt: "updatedAt",
+  expiresAt: "expiresAt"
+};
+var messageFields = {
+  id: "_id",
+  threadId: "threadId",
+  ownerId: "ownerId",
+  seq: "seq",
+  message: "message",
+  createdAt: "createdAt",
+  actions: "actions",
+  expiresAt: "expiresAt"
+};
+var threadIndexes = [
+  { key: { ownerId: 1, _id: -1 } }
+];
+var messageIndexes = [
+  { key: { ownerId: 1, threadId: 1, seq: 1 }, unique: true },
+  { key: { ownerId: 1, "actions.id": 1 } }
+];
+var expiresAtIndex = {
+  key: { expiresAt: 1 },
+  expireAfterSeconds: 0
+};
+// src/mongo-actions.ts
+import {
+  toProposedAction
+} from "@nxgt/ai-core";
+
+// src/mongo-ctx.ts
+async function ownThread(c, id, ownerId) {
+  assertOwner(ownerId);
+  return c.threads.findOne({ _id: id, ownerId });
+}
+
+// src/mongo-map.ts
+function toThread(doc) {
+  const { _id, expiresAt: _expiresAt, ...rest } = doc;
+  return { id: _id, ...rest };
+}
+function toStoredMessage(doc) {
+  return {
+    id: doc["_id"],
+    threadId: doc["threadId"],
+    seq: doc["seq"],
+    message: doc["message"],
+    createdAt: doc["createdAt"]
+  };
+}
+function pickAction(doc, actionId) {
+  const list = doc?.["actions"] ?? [];
+  return list.find((a) => a.id === actionId);
+}
+
+// src/mongo-actions.ts
+async function newActions(c, ownerId, list) {
+  const seen = new Set;
+  const result = [];
+  for (const message of list) {
+    const fresh = [];
+    for (const part of message.parts) {
+      if (part.type !== "proposed-action" || seen.has(part.id))
+        continue;
+      seen.add(part.id);
+      const known = await c.messages.findOne({
+        ownerId,
+        "actions.id": part.id
+      });
+      if (!known)
+        fresh.push(toProposedAction(part));
+    }
+    result.push(fresh);
+  }
+  return result;
+}
+async function findAction(c, actionId, ownerId) {
+  assertOwner(ownerId);
+  const doc = await c.messages.findOne({ ownerId, "actions.id": actionId });
+  return pickAction(doc, actionId);
+}
+async function updateAction(c, actionId, ownerId, patch) {
+  assertOwner(ownerId);
+  const doc = await c.messages.findOneAndUpdate({ ownerId, actions: { $elemMatch: { id: actionId, status: "pending" } } }, {
+    $set: {
+      "actions.$.status": patch.status,
+      ...patch.result === undefined ? {} : { "actions.$.result": patch.result }
+    }
+  }, { returnDocument: "after" });
+  return pickAction(doc, actionId);
+}
+
+// src/mongo-messages.ts
+async function append(c, threadId, ownerId, list) {
+  assertOwner(ownerId);
+  const parsed = list.map((m) => messageSchema2.parse(m));
+  const at = c.now();
+  const before = await c.threads.findOneAndUpdate({ _id: threadId, ownerId }, {
+    $inc: { messageCount: parsed.length },
+    $set: { updatedAt: at, ...c.expiry(at) }
+  }, { returnDocument: "before" });
+  if (!before)
+    throw notFound(threadId);
+  const first = before["messageCount"] + 1;
+  const actions = await newActions(c, ownerId, parsed);
+  const docs = parsed.map((message, i) => ({
+    _id: Bun.randomUUIDv7(),
+    threadId,
+    ownerId,
+    seq: first + i,
+    message,
+    createdAt: at,
+    ...(actions[i]?.length ?? 0) > 0 ? { actions: actions[i] } : {},
+    ...c.expiry(at)
+  }));
+  if (docs.length > 0) {
+    await c.messages.insertMany(docs);
+    if (!await ownThread(c, threadId, ownerId)) {
+      await c.messages.deleteMany({ threadId, ownerId });
+      throw notFound(threadId);
+    }
+  }
+  await slide(c, threadId, ownerId, at);
+  return docs.map(toStoredMessage);
+}
+async function slide(c, threadId, ownerId, at) {
+  const expiry = c.expiry(at);
+  if (Object.keys(expiry).length === 0)
+    return;
+  await c.messages.updateMany({ threadId, ownerId }, { $set: expiry });
+}
+async function load(c, threadId, ownerId, opts) {
+  const doc = await ownThread(c, threadId, ownerId);
+  if (!doc)
+    return;
+  const thread = toThread(doc);
+  let after = 0;
+  if (opts.sinceSummary && thread.summary) {
+    const through = await c.messages.findOne({
+      _id: thread.summary.throughMessageId,
+      threadId,
+      ownerId
+    });
+    after = through?.["seq"] ?? 0;
+  }
+  const docs = await c.messages.find({ threadId, ownerId, seq: { $gt: after } }).sort({ seq: 1 }).toArray();
+  return {
+    thread,
+    ...thread.summary ? { summary: thread.summary } : {},
+    messages: docs.map(toStoredMessage)
+  };
+}
+async function setSummary(c, threadId, ownerId, input) {
+  if (!await ownThread(c, threadId, ownerId))
+    throw notFound(threadId);
+  const through = await c.messages.findOne({
+    _id: input.throughMessageId,
+    threadId,
+    ownerId
+  });
+  if (!through) {
+    throw new MemoryError2("MESSAGE_NOT_FOUND", `Message "${input.throughMessageId}" is not in thread "${threadId}".`);
+  }
+  const at = c.now();
+  const summary = {
+    text: input.text,
+    throughMessageId: input.throughMessageId,
+    tokens: input.tokens,
+    createdAt: at
+  };
+  const done = await c.threads.updateOne({ _id: threadId, ownerId }, { $set: { summary, updatedAt: at, ...c.expiry(at) } });
+  if (done.matchedCount === 0)
+    throw notFound(threadId);
+  await slide(c, threadId, ownerId, at);
+  return summary;
+}
+
+// src/mongo-threads.ts
+async function createThread(c, input) {
+  assertOwner(input.ownerId);
+  const at = c.now();
+  const doc = {
+    _id: Bun.randomUUIDv7(),
+    ownerId: input.ownerId,
+    ...input.title === undefined ? {} : { title: input.title },
+    ...input.meta === undefined ? {} : { meta: input.meta },
+    messageCount: 0,
+    createdAt: at,
+    updatedAt: at,
+    ...c.expiry(at)
+  };
+  await c.threads.insertOne(doc);
+  return toThread(doc);
+}
+async function getThread(c, id, ownerId) {
+  const doc = await ownThread(c, id, ownerId);
+  return doc ? toThread(doc) : undefined;
+}
+async function listThreads(c, ownerId, page) {
+  assertOwner(ownerId);
+  const limit = pageLimit(page);
+  assertUuidCursor(page.cursor);
+  const docs = await c.threads.find({
+    ownerId,
+    ...page.cursor === undefined ? {} : { _id: { $lt: page.cursor } }
+  }).sort({ _id: -1 }).limit(limit + 1).toArray();
+  const items = docs.slice(0, limit);
+  const last = items[items.length - 1];
+  return {
+    items: items.map(toThread),
+    ...docs.length > limit && last ? { nextCursor: last["_id"] } : {}
+  };
+}
+async function deleteThread(c, id, ownerId) {
+  if (!await ownThread(c, id, ownerId))
+    return false;
+  await c.messages.deleteMany({ threadId: id, ownerId });
+  await c.threads.deleteOne({ _id: id, ownerId });
+  await c.messages.deleteMany({ threadId: id, ownerId });
+  return true;
+}
+
+// src/mongo-store.ts
+function mongoMemory(options) {
+  const ttl = options.expireAfterSeconds;
+  const c = {
+    threads: options.threads,
+    messages: options.messages,
+    now: options.now ?? Date.now,
+    expiry: (at) => ttl === undefined ? {} : { expiresAt: new Date(at + ttl * 1000) }
+  };
+  return {
+    createThread: (input) => createThread(c, input),
+    getThread: (id, ownerId) => getThread(c, id, ownerId),
+    listThreads: (ownerId, page = {}) => listThreads(c, ownerId, page),
+    append: (id, ownerId, list) => append(c, id, ownerId, list),
+    load: (id, ownerId, opts) => load(c, id, ownerId, opts),
+    setSummary: (id, ownerId, input) => setSummary(c, id, ownerId, input),
+    findAction: (id, ownerId) => findAction(c, id, ownerId),
+    updateAction: (id, ownerId, patch) => updateAction(c, id, ownerId, patch),
+    deleteThread: (id, ownerId) => deleteThread(c, id, ownerId)
+  };
+}
+export {
+  expiresAtIndex,
+  messageFields,
+  messageIndexes,
+  mongoMemory,
+  threadFields,
+  threadIndexes
+};
+
+//# debugId=96A98DAE51319F1364756E2164756E21
+//# sourceMappingURL=mongo.js.map

package/dist/mongo.js.map

@@ -0,0 +1,16 @@
+{
+  "version": 3,
+  "sources": ["../src/mongo-fields.ts", "../src/mongo-actions.ts", "../src/mongo-ctx.ts", "../src/mongo-map.ts", "../src/mongo-messages.ts", "../src/mongo-threads.ts", "../src/mongo-store.ts"],
+  "sourcesContent": [
+    "/**\n * The fields the store writes on a thread document. `_id` is the thread id.\n * `expiresAt` is a `Date`, set only with `expireAfterSeconds`.\n */\nexport const threadFields = {\n\tid: '_id',\n\townerId: 'ownerId',\n\ttitle: 'title',\n\tmeta: 'meta',\n\tmessageCount: 'messageCount',\n\tsummary: 'summary',\n\tcreatedAt: 'createdAt',\n\tupdatedAt: 'updatedAt',\n\texpiresAt: 'expiresAt',\n} as const;\n\n/**\n * The fields the store writes on a message document. `_id` is the message id;\n * `actions` holds the state of the proposed actions the message carries.\n */\nexport const messageFields = {\n\tid: '_id',\n\tthreadId: 'threadId',\n\townerId: 'ownerId',\n\tseq: 'seq',\n\tmessage: 'message',\n\tcreatedAt: 'createdAt',\n\tactions: 'actions',\n\texpiresAt: 'expiresAt',\n} as const;\n\nexport interface MongoIndex {\n\tkey: Record<string, 1 | -1>;\n\tunique?: boolean;\n\texpireAfterSeconds?: number;\n}\n\n/** Indexes to create on the threads collection (`createIndex(key, options)`). */\nexport const threadIndexes: readonly MongoIndex[] = [\n\t{ key: { ownerId: 1, _id: -1 } },\n];\n\n/** Indexes to create on the messages collection. */\nexport const messageIndexes: readonly MongoIndex[] = [\n\t{ key: { ownerId: 1, threadId: 1, seq: 1 }, unique: true },\n\t{ key: { ownerId: 1, 'actions.id': 1 } },\n];\n\n/** The TTL index, on both collections, when `expireAfterSeconds` is set. */\nexport const expiresAtIndex: MongoIndex = {\n\tkey: { expiresAt: 1 },\n\texpireAfterSeconds: 0,\n};\n",
+    "import {\n\ttype Message,\n\ttype ProposedAction,\n\ttoProposedAction,\n} from '@nxgt/ai-core';\nimport { assertOwner, type Ctx } from './mongo-ctx';\nimport { pickAction } from './mongo-map';\nimport type { ActionPatch } from './types';\n\n/** Per message, the actions it proposes that this owner has not recorded yet. */\nexport async function newActions(\n\tc: Ctx,\n\townerId: string,\n\tlist: readonly Message[],\n): Promise<ProposedAction[][]> {\n\tconst seen = new Set<string>();\n\tconst result: ProposedAction[][] = [];\n\tfor (const message of list) {\n\t\tconst fresh: ProposedAction[] = [];\n\t\tfor (const part of message.parts) {\n\t\t\tif (part.type !== 'proposed-action' || seen.has(part.id)) continue;\n\t\t\tseen.add(part.id);\n\t\t\tconst known = await c.messages.findOne({\n\t\t\t\townerId,\n\t\t\t\t'actions.id': part.id,\n\t\t\t});\n\t\t\tif (!known) fresh.push(toProposedAction(part));\n\t\t}\n\t\tresult.push(fresh);\n\t}\n\treturn result;\n}\n\nexport async function findAction(c: Ctx, actionId: string, ownerId: string) {\n\tassertOwner(ownerId);\n\tconst doc = await c.messages.findOne({ ownerId, 'actions.id': actionId });\n\treturn pickAction(doc, actionId);\n}\n\nexport async function updateAction(\n\tc: Ctx,\n\tactionId: string,\n\townerId: string,\n\tpatch: ActionPatch,\n) {\n\tassertOwner(ownerId);\n\t// One atomic write: it matches only while the action is still pending.\n\tconst doc = await c.messages.findOneAndUpdate(\n\t\t{ ownerId, actions: { $elemMatch: { id: actionId, status: 'pending' } } },\n\t\t{\n\t\t\t$set: {\n\t\t\t\t'actions.$.status': patch.status,\n\t\t\t\t...(patch.result === undefined\n\t\t\t\t\t? {}\n\t\t\t\t\t: { 'actions.$.result': patch.result }),\n\t\t\t},\n\t\t},\n\t\t{ returnDocument: 'after' },\n\t);\n\treturn pickAction(doc, actionId);\n}\n",
+    "import { assertOwner } from './guards';\nimport type { MongoCollection, MongoDoc } from './mongo-collection';\n\n/** What the functions of the sibling files share. */\nexport interface Ctx {\n\tthreads: MongoCollection;\n\tmessages: MongoCollection;\n\tnow: () => number;\n\t/** `{ expiresAt }` for a write at `at`, or nothing without a TTL. */\n\texpiry: (at: number) => MongoDoc;\n}\n\nexport { assertOwner, notFound } from './guards';\n\nexport async function ownThread(c: Ctx, id: string, ownerId: string) {\n\tassertOwner(ownerId);\n\treturn c.threads.findOne({ _id: id, ownerId });\n}\n",
+    "import type { ProposedAction } from '@nxgt/ai-core';\nimport type { MongoDoc } from './mongo-collection';\nimport type { StoredMessage, Thread } from './types';\n\n/** A thread document as the application reads it: no storage-only field. */\nexport function toThread(doc: MongoDoc): Thread {\n\tconst { _id, expiresAt: _expiresAt, ...rest } = doc;\n\treturn { id: _id, ...rest } as Thread;\n}\n\nexport function toStoredMessage(doc: MongoDoc): StoredMessage {\n\treturn {\n\t\tid: doc['_id'],\n\t\tthreadId: doc['threadId'],\n\t\tseq: doc['seq'],\n\t\tmessage: doc['message'],\n\t\tcreatedAt: doc['createdAt'],\n\t} as StoredMessage;\n}\n\nexport function pickAction(\n\tdoc: MongoDoc | null,\n\tactionId: string,\n): ProposedAction | undefined {\n\tconst list = (doc?.['actions'] ?? []) as ProposedAction[];\n\treturn list.find((a) => a.id === actionId);\n}\n",
+    "import type { Message } from '@nxgt/ai-core';\nimport { MemoryError } from './errors';\nimport { newActions } from './mongo-actions';\nimport type { MongoDoc } from './mongo-collection';\nimport { assertOwner, type Ctx, notFound, ownThread } from './mongo-ctx';\nimport { toStoredMessage, toThread } from './mongo-map';\nimport { messageSchema } from './schemas';\nimport type {\n\tLoadedThread,\n\tLoadOptions,\n\tStoredMessage,\n\tSummaryInput,\n\tThreadSummary,\n} from './types';\n\nexport async function append(\n\tc: Ctx,\n\tthreadId: string,\n\townerId: string,\n\tlist: readonly Message[],\n): Promise<StoredMessage[]> {\n\tassertOwner(ownerId);\n\t// Parsing strips unknown keys; schemas.types.spec.ts guards the cast.\n\tconst parsed = list.map((m) => messageSchema.parse(m) as Message);\n\tconst at = c.now();\n\t// The $inc reserves the seq range, so concurrent appends never share one.\n\tconst before = await c.threads.findOneAndUpdate(\n\t\t{ _id: threadId, ownerId },\n\t\t{\n\t\t\t$inc: { messageCount: parsed.length },\n\t\t\t$set: { updatedAt: at, ...c.expiry(at) },\n\t\t},\n\t\t{ returnDocument: 'before' },\n\t);\n\tif (!before) throw notFound(threadId);\n\tconst first = (before['messageCount'] as number) + 1;\n\tconst actions = await newActions(c, ownerId, parsed);\n\tconst docs = parsed.map(\n\t\t(message, i): MongoDoc => ({\n\t\t\t_id: Bun.randomUUIDv7(),\n\t\t\tthreadId,\n\t\t\townerId,\n\t\t\tseq: first + i,\n\t\t\tmessage,\n\t\t\tcreatedAt: at,\n\t\t\t...((actions[i]?.length ?? 0) > 0 ? { actions: actions[i] } : {}),\n\t\t\t...c.expiry(at),\n\t\t}),\n\t);\n\tif (docs.length > 0) {\n\t\tawait c.messages.insertMany(docs);\n\t\t// A delete that ran meanwhile cannot see this batch: drop it.\n\t\tif (!(await ownThread(c, threadId, ownerId))) {\n\t\t\tawait c.messages.deleteMany({ threadId, ownerId });\n\t\t\tthrow notFound(threadId);\n\t\t}\n\t}\n\tawait slide(c, threadId, ownerId, at);\n\treturn docs.map(toStoredMessage);\n}\n\n/**\n * A thread expires as one unit: every write moves all its messages to the\n * thread's `expiresAt`, so the oldest never expire first.\n */\nasync function slide(c: Ctx, threadId: string, ownerId: string, at: number) {\n\tconst expiry = c.expiry(at);\n\tif (Object.keys(expiry).length === 0) return;\n\tawait c.messages.updateMany({ threadId, ownerId }, { $set: expiry });\n}\n\nexport async function load(\n\tc: Ctx,\n\tthreadId: string,\n\townerId: string,\n\topts: LoadOptions,\n): Promise<LoadedThread | undefined> {\n\tconst doc = await ownThread(c, threadId, ownerId);\n\tif (!doc) return undefined;\n\tconst thread = toThread(doc);\n\tlet after = 0;\n\tif (opts.sinceSummary && thread.summary) {\n\t\tconst through = await c.messages.findOne({\n\t\t\t_id: thread.summary.throughMessageId,\n\t\t\tthreadId,\n\t\t\townerId,\n\t\t});\n\t\tafter = (through?.['seq'] as number | undefined) ?? 0;\n\t}\n\tconst docs = await c.messages\n\t\t.find({ threadId, ownerId, seq: { $gt: after } })\n\t\t.sort({ seq: 1 })\n\t\t.toArray();\n\treturn {\n\t\tthread,\n\t\t...(thread.summary ? { summary: thread.summary } : {}),\n\t\tmessages: docs.map(toStoredMessage),\n\t};\n}\n\nexport async function setSummary(\n\tc: Ctx,\n\tthreadId: string,\n\townerId: string,\n\tinput: SummaryInput,\n): Promise<ThreadSummary> {\n\tif (!(await ownThread(c, threadId, ownerId))) throw notFound(threadId);\n\tconst through = await c.messages.findOne({\n\t\t_id: input.throughMessageId,\n\t\tthreadId,\n\t\townerId,\n\t});\n\tif (!through) {\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 = c.now();\n\tconst summary: ThreadSummary = {\n\t\ttext: input.text,\n\t\tthroughMessageId: input.throughMessageId,\n\t\ttokens: input.tokens,\n\t\tcreatedAt: at,\n\t};\n\tconst done = await c.threads.updateOne(\n\t\t{ _id: threadId, ownerId },\n\t\t{ $set: { summary, updatedAt: at, ...c.expiry(at) } },\n\t);\n\tif (done.matchedCount === 0) throw notFound(threadId);\n\tawait slide(c, threadId, ownerId, at);\n\treturn summary;\n}\n",
+    "import type { MongoDoc } from './mongo-collection';\nimport { assertOwner, type Ctx, ownThread } from './mongo-ctx';\nimport { toThread } from './mongo-map';\nimport { assertUuidCursor, pageLimit } from './paging';\nimport type { CreateThreadInput, Page, Thread, ThreadPage } from './types';\n\nexport async function createThread(\n\tc: Ctx,\n\tinput: CreateThreadInput,\n): Promise<Thread> {\n\tassertOwner(input.ownerId);\n\tconst at = c.now();\n\tconst doc: MongoDoc = {\n\t\t_id: Bun.randomUUIDv7(),\n\t\townerId: input.ownerId,\n\t\t...(input.title === undefined ? {} : { title: input.title }),\n\t\t...(input.meta === undefined ? {} : { meta: input.meta }),\n\t\tmessageCount: 0,\n\t\tcreatedAt: at,\n\t\tupdatedAt: at,\n\t\t...c.expiry(at),\n\t};\n\tawait c.threads.insertOne(doc);\n\treturn toThread(doc);\n}\n\nexport async function getThread(c: Ctx, id: string, ownerId: string) {\n\tconst doc = await ownThread(c, id, ownerId);\n\treturn doc ? toThread(doc) : undefined;\n}\n\nexport async function listThreads(\n\tc: Ctx,\n\townerId: string,\n\tpage: Page,\n): Promise<ThreadPage> {\n\tassertOwner(ownerId);\n\tconst limit = pageLimit(page);\n\tassertUuidCursor(page.cursor);\n\tconst docs = await c.threads\n\t\t.find({\n\t\t\townerId,\n\t\t\t...(page.cursor === undefined ? {} : { _id: { $lt: page.cursor } }),\n\t\t})\n\t\t.sort({ _id: -1 })\n\t\t.limit(limit + 1)\n\t\t.toArray();\n\tconst items = docs.slice(0, limit);\n\tconst last = items[items.length - 1];\n\treturn {\n\t\titems: items.map(toThread),\n\t\t...(docs.length > limit && last\n\t\t\t? { nextCursor: last['_id'] as string }\n\t\t\t: {}),\n\t};\n}\n\n/**\n * Messages, the thread, then the messages again. A crash in between leaves an\n * empty thread that a retry removes. An `append` racing the delete either\n * inserts before the last sweep (removed here) or checks the thread after its\n * insert and removes its own batch.\n */\nexport async function deleteThread(c: Ctx, id: string, ownerId: string) {\n\tif (!(await ownThread(c, id, ownerId))) return false;\n\tawait c.messages.deleteMany({ threadId: id, ownerId });\n\tawait c.threads.deleteOne({ _id: id, ownerId });\n\tawait c.messages.deleteMany({ threadId: id, ownerId });\n\treturn true;\n}\n",
+    "import * as actions from './mongo-actions';\nimport type { MongoCollection } from './mongo-collection';\nimport type { Ctx } from './mongo-ctx';\nimport * as messages from './mongo-messages';\nimport * as threads from './mongo-threads';\nimport type { MemoryStore } from './types';\n\nexport interface MongoMemoryOptions {\n\tthreads: MongoCollection;\n\tmessages: MongoCollection;\n\t/**\n\t * Documents expire this long after their last write (a thread) or their\n\t * insert (a message); needs `expiresAtIndex` on both collections.\n\t */\n\texpireAfterSeconds?: number;\n\t/** The clock, in epoch ms; default `Date.now`. */\n\tnow?: () => number;\n}\n\n/** A store over two MongoDB collections; see the guide for indexes and TTL. */\nexport function mongoMemory(options: MongoMemoryOptions): MemoryStore {\n\tconst ttl = options.expireAfterSeconds;\n\tconst c: Ctx = {\n\t\tthreads: options.threads,\n\t\tmessages: options.messages,\n\t\tnow: options.now ?? Date.now,\n\t\texpiry: (at) =>\n\t\t\tttl === undefined ? {} : { expiresAt: new Date(at + ttl * 1000) },\n\t};\n\treturn {\n\t\tcreateThread: (input) => threads.createThread(c, input),\n\t\tgetThread: (id, ownerId) => threads.getThread(c, id, ownerId),\n\t\tlistThreads: (ownerId, page = {}) => threads.listThreads(c, ownerId, page),\n\t\tappend: (id, ownerId, list) => messages.append(c, id, ownerId, list),\n\t\tload: (id, ownerId, opts) => messages.load(c, id, ownerId, opts),\n\t\tsetSummary: (id, ownerId, input) =>\n\t\t\tmessages.setSummary(c, id, ownerId, input),\n\t\tfindAction: (id, ownerId) => actions.findAction(c, id, ownerId),\n\t\tupdateAction: (id, ownerId, patch) =>\n\t\t\tactions.updateAction(c, id, ownerId, patch),\n\t\tdeleteThread: (id, ownerId) => threads.deleteThread(c, id, ownerId),\n\t};\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "96A98DAE51319F1364756E2164756E21",
+  "names": []
+}

package/dist/paging.d.ts

@@ -0,0 +1,8 @@
+import { MemoryError } from './errors.js';
+import type { Page } from './types.js';
+/** The page size, clamped to 1..100 and 20 by default. */
+export declare const pageLimit: (page: Page) => number;
+export declare const invalidCursor: (cursor: string) => MemoryError;
+/** For the stores whose cursor is a thread id: throws on any other string. */
+export declare function assertUuidCursor(cursor: string | undefined): void;
+//# sourceMappingURL=paging.d.ts.map

package/dist/paging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paging.d.ts","sourceRoot":"","sources":["../src/paging.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAOpC,0DAA0D;AAC1D,eAAO,MAAM,SAAS,GAAI,MAAM,IAAI,KAAG,MACuB,CAAC;AAE/D,eAAO,MAAM,aAAa,GAAI,QAAQ,MAAM,KAAG,WAI7C,CAAC;AAEH,8EAA8E;AAC9E,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAEjE"}

package/dist/pairs.d.ts

@@ -0,0 +1,14 @@
+import type { StoredMessage } from './types.js';
+/**
+ * The first index a fold may keep from: `from`, moved back until no kept tool
+ * result answers a tool call that the fold would swallow. A call is always
+ * before its result, so this is the only way to split a pair.
+ */
+export declare function safeCut(messages: readonly StoredMessage[], from: number): number;
+/**
+ * `safeCut`, then moved back until the kept messages start on a user turn,
+ * which providers require of a conversation. When no user turn lies before the
+ * cut, the pair-safe cut stands and the kept messages start on another role.
+ */
+export declare function userCut(messages: readonly StoredMessage[], from: number): number;
+//# sourceMappingURL=pairs.d.ts.map

package/dist/pairs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pairs.d.ts","sourceRoot":"","sources":["../src/pairs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,EAAE,IAAI,EAAE,MAAM,UAIvE;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,EAAE,IAAI,EAAE,MAAM,UAUvE"}

package/dist/redis-actions.d.ts

@@ -0,0 +1,8 @@
+import { type Message, type ProposedAction } from '@nxgt/ai-core';
+import { type Ctx } from './redis-ctx.js';
+import type { ActionPatch } from './types.js';
+/** Per message, the actions it proposes, once each within the batch. */
+export declare function proposedIn(list: readonly Message[]): ProposedAction[][];
+export declare function findAction(c: Ctx, actionId: string, ownerId: string): Promise<ProposedAction | undefined>;
+export declare function updateAction(c: Ctx, actionId: string, ownerId: string, patch: ActionPatch): Promise<ProposedAction | undefined>;
+//# sourceMappingURL=redis-actions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"redis-actions.d.ts","sourceRoot":"","sources":["../src/redis-actions.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,OAAO,EACZ,KAAK,cAAc,EAEnB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAe,KAAK,GAAG,EAAiB,MAAM,aAAa,CAAC;AAGnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,wEAAwE;AACxE,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,cAAc,EAAE,EAAE,CAWvE;AAED,wBAAsB,UAAU,CAC/B,CAAC,EAAE,GAAG,EACN,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACb,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC,CAgBrC;AAED,wBAAsB,YAAY,CACjC,CAAC,EAAE,GAAG,EACN,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,WAAW,uCAmBlB"}

package/dist/redis-ctx.d.ts

@@ -0,0 +1,37 @@
+import { assertOwner, notFound } from './guards.js';
+export { assertOwner, notFound };
+/**
+ * The one method the store calls: `RedisClient.send` of Bun, the client that
+ * `connectRedis` and `openRedis` of `@nxgt/redis` hand out.
+ */
+export interface RedisCommands {
+    send(command: string, args: string[]): Promise<unknown>;
+}
+/** What the functions of the sibling files share. */
+export interface Ctx {
+    redis: RedisCommands;
+    prefix: string;
+    now: () => number;
+    /** The expiry as an epoch ms for a write at `at`, or `'0'` without a TTL. */
+    expireAt: (at: number) => string;
+}
+/** The keys of one thread and of one owner. */
+export declare const keys: {
+    thread: (c: Ctx, id: string) => string;
+    messages: (c: Ctx, id: string) => string;
+    ids: (c: Ctx, id: string) => string;
+    actionIndex: (c: Ctx, id: string) => string;
+    owner: (c: Ctx, ownerId: string) => string;
+    /**
+     * The prefix of an owner's action keys; the action id follows it. The
+     * owner's length comes first, so `a:b` + `c` never meets `a` + `b:c`.
+     */
+    actionPrefix: (c: Ctx, ownerId: string) => string;
+};
+/** Runs a Lua script atomically. */
+export declare function evalLua(c: Ctx, script: string, scriptKeys: readonly string[], args: readonly string[]): Promise<unknown>;
+/** The thread's fields as a Redis hash holds them, or `undefined` when absent. */
+export declare function readThreadHash(c: Ctx, id: string): Promise<Record<string, string> | undefined>;
+/** The owner's thread hash, or `undefined` when absent or another owner's. */
+export declare function ownThread(c: Ctx, id: string, ownerId: string): Promise<Record<string, string> | undefined>;
+//# sourceMappingURL=redis-ctx.d.ts.map

package/dist/redis-ctx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-ctx.d.ts","sourceRoot":"","sources":["../src/redis-ctx.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEjD,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC;AAEjC;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC7B,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACxD;AAED,qDAAqD;AACrD,MAAM,WAAW,GAAG;IACnB,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,6EAA6E;IAC7E,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;CACjC;AAED,+CAA+C;AAC/C,eAAO,MAAM,IAAI;gBACJ,GAAG,MAAM,MAAM;kBACb,GAAG,MAAM,MAAM;aACpB,GAAG,MAAM,MAAM;qBACP,GAAG,MAAM,MAAM;eACrB,GAAG,WAAW,MAAM;IAC/B;;;OAGG;sBACe,GAAG,WAAW,MAAM;CAEtC,CAAC;AAEF,oCAAoC;AACpC,wBAAgB,OAAO,CACtB,CAAC,EAAE,GAAG,EACN,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,IAAI,EAAE,SAAS,MAAM,EAAE,GACrB,OAAO,CAAC,OAAO,CAAC,CAOlB;AAED,kFAAkF;AAClF,wBAAsB,cAAc,CACnC,CAAC,EAAE,GAAG,EACN,EAAE,EAAE,MAAM,GACR,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC,CAc7C;AAED,8EAA8E;AAC9E,wBAAsB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,+CAIlE"}

package/dist/redis-map.d.ts

@@ -0,0 +1,13 @@
+import type { Message, ProposedAction } from '@nxgt/ai-core';
+import type { StoredMessage, Thread } from './types.js';
+/** A thread hash as the application reads it. */
+export declare function toThread(id: string, hash: Record<string, string>): Thread;
+/** What a sorted-set member holds; the seq is its position, not stored. */
+export interface MessageMember {
+    id: string;
+    message: Message;
+    createdAt: number;
+}
+export declare function toStoredMessage(threadId: string, seq: number, member: MessageMember): StoredMessage;
+export declare function parseAction(raw: unknown): ProposedAction | undefined;
+//# sourceMappingURL=redis-map.d.ts.map

package/dist/redis-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-map.d.ts","sourceRoot":"","sources":["../src/redis-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,EAAiB,MAAM,SAAS,CAAC;AAEpE,iDAAiD;AACjD,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAazE;AAED,2EAA2E;AAC3E,MAAM,WAAW,aAAa;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,eAAe,CAC9B,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,aAAa,GACnB,aAAa,CAQf;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,cAAc,GAAG,SAAS,CAIpE"}

package/dist/redis-messages.d.ts

@@ -0,0 +1,7 @@
+import type { Message } from '@nxgt/ai-core';
+import { type Ctx } from './redis-ctx.js';
+import type { LoadedThread, LoadOptions, StoredMessage, SummaryInput, ThreadSummary } from './types.js';
+export declare function append(c: Ctx, threadId: string, ownerId: string, list: readonly Message[]): Promise<StoredMessage[]>;
+export declare function load(c: Ctx, threadId: string, ownerId: string, opts: LoadOptions): Promise<LoadedThread | undefined>;
+export declare function setSummary(c: Ctx, threadId: string, ownerId: string, input: SummaryInput): Promise<ThreadSummary>;
+//# sourceMappingURL=redis-messages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"redis-messages.d.ts","sourceRoot":"","sources":["../src/redis-messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAG7C,OAAO,EAEN,KAAK,GAAG,EAKR,MAAM,aAAa,CAAC;AAIrB,OAAO,KAAK,EACX,YAAY,EACZ,WAAW,EACX,aAAa,EACb,YAAY,EACZ,aAAa,EACb,MAAM,SAAS,CAAC;AAUjB,wBAAsB,MAAM,CAC3B,CAAC,EAAE,GAAG,EACN,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,OAAO,EAAE,GACtB,OAAO,CAAC,aAAa,EAAE,CAAC,CAiC1B;AAED,wBAAsB,IAAI,CACzB,CAAC,EAAE,GAAG,EACN,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,WAAW,GACf,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CA6BnC;AAED,wBAAsB,UAAU,CAC/B,CAAC,EAAE,GAAG,EACN,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,YAAY,GACjB,OAAO,CAAC,aAAa,CAAC,CA2BxB"}

package/dist/redis-scripts.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The Lua scripts of the store. A script runs as one command, so each
+ * read-then-write below is atomic: no other client sees it half done.
+ *
+ * `ARGV` values that are an expiry hold an epoch ms, or `'0'` for no TTL.
+ */
+/**
+ * KEYS: thread hash, owner index. ARGV: id, ownerId, at, expireAt, then
+ * field/value pairs (`title`, `meta`). Writes the thread and indexes it.
+ */
+export declare const CREATE_THREAD = "\nlocal function slide(key, at)\n\tif at ~= '0' then redis.call('PEXPIREAT', key, at) end\nend\nlocal function slideThread(keys, at)\n\tfor j = 1, 4 do slide(keys[j], at) end\n\tfor _, key in ipairs(redis.call('SMEMBERS', keys[4])) do slide(key, at) end\nend\n\nlocal fields = {'ownerId', ARGV[2], 'messageCount', '0', 'createdAt', ARGV[3], 'updatedAt', ARGV[3]}\nfor i = 5, #ARGV do fields[#fields + 1] = ARGV[i] end\nredis.call('HSET', KEYS[1], unpack(fields))\nredis.call('ZADD', KEYS[2], 0, ARGV[1])\nslide(KEYS[1], ARGV[4])\nreturn 1\n";
+/**
+ * KEYS: thread hash, messages sorted set, id index, action index. ARGV:
+ * ownerId, updatedAt, expireAt, action key prefix, thread id, count, then per message
+ * its id, its JSON, its action count and per action its id and its body.
+ * Returns the first seq of the range it reserved, or nil when the thread is
+ * absent or another owner's. The seq range, the messages and the actions are
+ * written in the same step, so a reader never sees a gap.
+ */
+export declare const APPEND = "\nlocal function slide(key, at)\n\tif at ~= '0' then redis.call('PEXPIREAT', key, at) end\nend\nlocal function slideThread(keys, at)\n\tfor j = 1, 4 do slide(keys[j], at) end\n\tfor _, key in ipairs(redis.call('SMEMBERS', keys[4])) do slide(key, at) end\nend\n\nif redis.call('HGET', KEYS[1], 'ownerId') ~= ARGV[1] then return false end\nlocal n = tonumber(ARGV[6])\nlocal first = redis.call('HINCRBY', KEYS[1], 'messageCount', n) - n + 1\nredis.call('HSET', KEYS[1], 'updatedAt', ARGV[2])\nlocal i = 7\nfor k = 0, n - 1 do\n\tlocal id, json, count = ARGV[i], ARGV[i + 1], tonumber(ARGV[i + 2])\n\ti = i + 3\n\tredis.call('ZADD', KEYS[2], first + k, json)\n\tredis.call('HSET', KEYS[3], id, first + k)\n\tfor _ = 1, count do\n\t\tlocal key = ARGV[4] .. ARGV[i]\n\t\tif redis.call('HSETNX', key, 'status', 'pending') == 1 then\n\t\t\tredis.call('HSET', key, 'body', ARGV[i + 1], 'thread', ARGV[5])\n\t\t\tredis.call('SADD', KEYS[4], key)\n\t\tend\n\t\ti = i + 2\n\tend\nend\nslideThread(KEYS, ARGV[3])\nreturn first\n";
+/**
+ * KEYS: thread hash, messages, id index, action index. ARGV: ownerId,
+ * summary JSON, updatedAt, expireAt. Returns 1, or nil when the thread is
+ * absent or another owner's.
+ */
+export declare const SET_SUMMARY = "\nlocal function slide(key, at)\n\tif at ~= '0' then redis.call('PEXPIREAT', key, at) end\nend\nlocal function slideThread(keys, at)\n\tfor j = 1, 4 do slide(keys[j], at) end\n\tfor _, key in ipairs(redis.call('SMEMBERS', keys[4])) do slide(key, at) end\nend\n\nif redis.call('HGET', KEYS[1], 'ownerId') ~= ARGV[1] then return false end\nredis.call('HSET', KEYS[1], 'summary', ARGV[2], 'updatedAt', ARGV[3])\nslideThread(KEYS, ARGV[4])\nreturn 1\n";
+/**
+ * KEYS: action hash. ARGV: status, '1' when a result follows, the result
+ * JSON, expireAt, key prefix. Moves a pending action on and slides the
+ * thread's keys and actions with it; returns 1, or nil when it is absent or
+ * no longer pending.
+ */
+export declare const UPDATE_ACTION = "\nlocal function slide(key, at)\n\tif at ~= '0' then redis.call('PEXPIREAT', key, at) end\nend\nlocal function slideThread(keys, at)\n\tfor j = 1, 4 do slide(keys[j], at) end\n\tfor _, key in ipairs(redis.call('SMEMBERS', keys[4])) do slide(key, at) end\nend\n\nif redis.call('HGET', KEYS[1], 'status') ~= 'pending' then return false end\nredis.call('HSET', KEYS[1], 'status', ARGV[1])\nif ARGV[2] == '1' then redis.call('HSET', KEYS[1], 'result', ARGV[3]) end\nif ARGV[4] ~= '0' then\n\tlocal id = redis.call('HGET', KEYS[1], 'thread')\n\tlocal base = ARGV[5] .. ':'\n\tslideThread({base .. 'thread:' .. id, base .. 'messages:' .. id, base .. 'ids:' .. id, base .. 'actions:' .. id}, ARGV[4])\nend\nreturn 1\n";
+/**
+ * KEYS: thread hash, messages, id index, action index, owner index. ARGV:
+ * ownerId, thread id. Removes the thread, its messages and its actions in
+ * one step; returns 1, or nil when the thread is absent or another owner's.
+ */
+export declare const DELETE_THREAD = "\nif redis.call('HGET', KEYS[1], 'ownerId') ~= ARGV[1] then return false end\nfor _, key in ipairs(redis.call('SMEMBERS', KEYS[4])) do redis.call('DEL', key) end\nredis.call('DEL', KEYS[2], KEYS[3], KEYS[4], KEYS[1])\nredis.call('ZREM', KEYS[5], ARGV[2])\nreturn 1\n";
+//# sourceMappingURL=redis-scripts.d.ts.map

package/dist/redis-scripts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-scripts.d.ts","sourceRoot":"","sources":["../src/redis-scripts.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAYH;;;GAGG;AACH,eAAO,MAAM,aAAa,iiBAOzB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,6/BAsBlB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW,ocAKvB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,2sBAUzB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,aAAa,+QAMzB,CAAC"}

package/dist/redis-store.d.ts

@@ -0,0 +1,21 @@
+import type { RedisCommands } from './redis-ctx.js';
+import type { MemoryStore } from './types.js';
+export interface RedisMemoryOptions {
+    /**
+     * The client: `connection.client` of `connectRedis`, or the `client` of an
+     * instance of `openRedis`, both from `@nxgt/redis`.
+     */
+    client: RedisCommands;
+    /** What every key starts with; default `ai-memory`. */
+    prefix?: string;
+    /**
+     * Keys expire this long after the thread's last write, so the whole thread
+     * goes together.
+     */
+    expireAfterSeconds?: number;
+    /** The clock, in epoch ms; default `Date.now`. */
+    now?: () => number;
+}
+/** A store over Redis keys; see the guide for the layout, expiry and limits. */
+export declare function redisMemory(options: RedisMemoryOptions): MemoryStore;
+//# sourceMappingURL=redis-store.d.ts.map

package/dist/redis-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-store.d.ts","sourceRoot":"","sources":["../src/redis-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAO,aAAa,EAAE,MAAM,aAAa,CAAC;AAGtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,MAAM,WAAW,kBAAkB;IAClC;;;OAGG;IACH,MAAM,EAAE,aAAa,CAAC;IACtB,uDAAuD;IACvD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,kDAAkD;IAClD,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACnB;AAED,gFAAgF;AAChF,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,WAAW,CAqBpE"}

package/dist/redis-threads.d.ts

@@ -0,0 +1,16 @@
+import { type Ctx } from './redis-ctx.js';
+import type { CreateThreadInput, Page, Thread, ThreadPage } from './types.js';
+export declare function createThread(c: Ctx, input: CreateThreadInput): Promise<Thread>;
+export declare function getThread(c: Ctx, id: string, ownerId: string): Promise<Thread | undefined>;
+/**
+ * Newest first, by id. The owner index can name a thread that has expired:
+ * it is skipped and removed, and the page is filled from the ones after it.
+ */
+export declare function listThreads(c: Ctx, ownerId: string, page: Page): Promise<ThreadPage>;
+/**
+ * One script removes the messages, the actions, the thread and its owner
+ * index entry, so a crash or a racing `append` never leaves keys nobody can
+ * reach: the append finds the thread gone.
+ */
+export declare function deleteThread(c: Ctx, id: string, ownerId: string): Promise<boolean>;
+//# sourceMappingURL=redis-threads.d.ts.map

package/dist/redis-threads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-threads.d.ts","sourceRoot":"","sources":["../src/redis-threads.ts"],"names":[],"mappings":"AACA,OAAO,EAEN,KAAK,GAAG,EAKR,MAAM,aAAa,CAAC;AAGrB,OAAO,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE3E,wBAAsB,YAAY,CACjC,CAAC,EAAE,GAAG,EACN,KAAK,EAAE,iBAAiB,GACtB,OAAO,CAAC,MAAM,CAAC,CAmBjB;AAED,wBAAsB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,+BAGlE;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAChC,CAAC,EAAE,GAAG,EACN,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,IAAI,GACR,OAAO,CAAC,UAAU,CAAC,CA+BrB;AAED;;;;GAIG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,oBAerE"}

package/dist/redis.d.ts

@@ -0,0 +1,3 @@
+export type { RedisCommands } from './redis-ctx.js';
+export { type RedisMemoryOptions, redisMemory } from './redis-store.js';
+//# sourceMappingURL=redis.d.ts.map

package/dist/redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../src/redis.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,KAAK,kBAAkB,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}