@redtuma/store-do 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,98 @@
+# @redtuma/store-do
+
+Edge-native agent memory for Redtuma, backed by a **Cloudflare Durable Object**.
+No external database: each conversation thread lives in its own strongly
+consistent, co-located DO instance that hibernates when idle and wakes on the
+next request — the natural home for agent state and human-in-the-loop workflows.
+
+It implements the standard Redtuma [`Store`](../../packages/core/src/store/index.ts)
+interface, so anything that takes a `Store` (memory, workflow snapshots) works
+unchanged.
+
+## Install
+
+```bash
+pnpm add @redtuma/store-do
+```
+
+## Define the Durable Object
+
+```ts
+// src/memory.ts
+import { RedtumaMemoryObject, type KVStorage } from '@redtuma/store-do'
+
+export class Memory extends RedtumaMemoryObject {
+  constructor(state: DurableObjectState) {
+    super(state.storage as unknown as KVStorage)
+  }
+}
+```
+
+## Use it from a Worker
+
+```ts
+// src/worker.ts
+import { Agent } from '@redtuma/core'
+import { durableObjectStoreClient } from '@redtuma/store-do'
+export { Memory } from './memory'
+
+interface Env {
+  MEMORY: DurableObjectNamespace
+  ANTHROPIC_API_KEY: string
+}
+
+export default {
+  async fetch(req: Request, env: Env): Promise<Response> {
+    const { threadId, message } = await req.json<{ threadId: string; message: string }>()
+
+    // One Durable Object per thread → strongly consistent per-conversation memory.
+    const stub = env.MEMORY.get(env.MEMORY.idFromName(threadId))
+    const store = durableObjectStoreClient(stub)
+
+    const agent = new Agent({
+      id: 'assistant',
+      instructions: 'You are helpful.',
+      model: 'anthropic/claude-opus-4-8',
+    })
+
+    // Persist this turn, then answer using prior history from the DO.
+    await store.saveThread({
+      id: threadId, resourceId: 'user', createdAt: new Date(), updatedAt: new Date(),
+    })
+    const history = await store.getMessages({ threadId, last: 20 })
+    const res = await agent.generate([
+      ...history.map((m) => ({ role: m.role, content: m.content })),
+      { role: 'user', content: message },
+    ])
+
+    await store.saveMessages([
+      { id: crypto.randomUUID(), role: 'user', content: message, createdAt: new Date(), threadId, resourceId: 'user' },
+      { id: crypto.randomUUID(), role: 'assistant', content: res.text, createdAt: new Date(), threadId, resourceId: 'user' },
+    ])
+    return Response.json({ text: res.text })
+  },
+}
+```
+
+See [`wrangler.example.toml`](./wrangler.example.toml) for the binding + migration.
+
+## Local development & testing
+
+`MemoryKVStorage` mirrors the DO storage semantics (structured-clone writes,
+lexicographic key ordering) with no Workers runtime — ideal for unit tests and
+local runs:
+
+```ts
+import { DurableObjectStore, MemoryKVStorage } from '@redtuma/store-do'
+const store = new DurableObjectStore(new MemoryKVStorage())
+```
+
+This adapter passes the shared `runStoreConformance` suite — the same contract
+the reference `InMemoryStore` satisfies.
+
+## API
+
+- `DurableObjectStore(storage: KVStorage)` — the `Store` implementation.
+- `MemoryKVStorage` — in-memory `KVStorage` for dev/test.
+- `RedtumaMemoryObject` — base Durable Object class exposing the store over JSON-RPC.
+- `durableObjectStoreClient(fetcher)` — a `Store` that forwards to a DO stub.

package/dist/durable-object.d.ts

@@ -0,0 +1,45 @@
+import { KVStorage } from "./storage.js";
+import { Store } from "@redtuma/core/store";
+
+//#region src/durable-object.d.ts
+/** Cloudflare's `DurableObjectStorage` is a structural superset of this. */
+type DurableObjectStorageLike = KVStorage;
+/**
+ * Base class for a Redtuma memory Durable Object. Each instance owns one
+ * conversation's persistent state through a {@link DurableObjectStore}, exposed
+ * over a tiny JSON-RPC `fetch` so a Worker can drive it with
+ * {@link durableObjectStoreClient}. Subclass it and forward `state.storage`:
+ *
+ * ```ts
+ * export class Memory extends RedtumaMemoryObject {
+ *   constructor(state: DurableObjectState) {
+ *     super(state.storage as unknown as KVStorage)
+ *   }
+ * }
+ * ```
+ */
+declare class RedtumaMemoryObject {
+  protected readonly memory: Store;
+  constructor(storage: KVStorage);
+  fetch(request: Request): Promise<Response>;
+}
+/** Anything that can take a `Request` and return a `Response` — e.g. a DO stub. */
+interface Fetcher {
+  fetch(request: Request): Promise<Response>;
+}
+/**
+ * A {@link Store} whose calls are forwarded to a remote {@link RedtumaMemoryObject}
+ * (or any {@link Fetcher}, such as a Durable Object stub) over JSON-RPC. This is
+ * what a Worker uses as its agent/memory storage:
+ *
+ * ```ts
+ * const id = env.MEMORY.idFromName(threadId)
+ * const store = durableObjectStoreClient(env.MEMORY.get(id))
+ * ```
+ *
+ * Note: values round-trip through JSON, so `Date` fields arrive as ISO strings.
+ */
+declare function durableObjectStoreClient(fetcher: Fetcher): Store;
+//#endregion
+export { DurableObjectStorageLike, Fetcher, RedtumaMemoryObject, durableObjectStoreClient };
+//# sourceMappingURL=durable-object.d.ts.map

package/dist/durable-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable-object.d.ts","names":[],"sources":["../src/durable-object.ts"],"sourcesContent":[],"mappings":";;;;;KAKY,wBAAA,GAA2B;AAAvC;AAoCA;;;;;;;AA+BA;;;;;AAgBA;cA/Ca,mBAAA;6BACgB;uBAEN;iBAIA,UAAU,QAAQ;;;UAwBxB,OAAA;iBACA,UAAU,QAAQ;;;;;;;;;;;;;;iBAenB,wBAAA,UAAkC,UAAU"}

package/dist/durable-object.js

@@ -0,0 +1,99 @@
+import { DurableObjectStore } from "./store.js";
+
+//#region src/durable-object.ts
+const STORE_METHODS = new Set([
+	"saveThread",
+	"getThread",
+	"getThreadsByResourceId",
+	"deleteThread",
+	"saveMessages",
+	"getMessages",
+	"getResource",
+	"saveResource",
+	"persistSnapshot",
+	"loadSnapshot"
+]);
+function json(data, status = 200) {
+	return new Response(JSON.stringify(data), {
+		status,
+		headers: { "content-type": "application/json" }
+	});
+}
+/**
+* Base class for a Redtuma memory Durable Object. Each instance owns one
+* conversation's persistent state through a {@link DurableObjectStore}, exposed
+* over a tiny JSON-RPC `fetch` so a Worker can drive it with
+* {@link durableObjectStoreClient}. Subclass it and forward `state.storage`:
+*
+* ```ts
+* export class Memory extends RedtumaMemoryObject {
+*   constructor(state: DurableObjectState) {
+*     super(state.storage as unknown as KVStorage)
+*   }
+* }
+* ```
+*/
+var RedtumaMemoryObject = class {
+	memory;
+	constructor(storage) {
+		this.memory = new DurableObjectStore(storage);
+	}
+	async fetch(request) {
+		let body;
+		try {
+			body = await request.json();
+		} catch {
+			return json({ error: "Invalid JSON body." }, 400);
+		}
+		const method = body.method;
+		if (!method || !STORE_METHODS.has(method)) return json({ error: `Unknown store method "${String(method)}".` }, 400);
+		try {
+			return json({ result: await this.memory[method].apply(this.memory, body.args ?? []) });
+		} catch (err) {
+			return json({ error: err instanceof Error ? err.message : String(err) }, 500);
+		}
+	}
+};
+/**
+* A {@link Store} whose calls are forwarded to a remote {@link RedtumaMemoryObject}
+* (or any {@link Fetcher}, such as a Durable Object stub) over JSON-RPC. This is
+* what a Worker uses as its agent/memory storage:
+*
+* ```ts
+* const id = env.MEMORY.idFromName(threadId)
+* const store = durableObjectStoreClient(env.MEMORY.get(id))
+* ```
+*
+* Note: values round-trip through JSON, so `Date` fields arrive as ISO strings.
+*/
+function durableObjectStoreClient(fetcher) {
+	const call = async (method, args) => {
+		const res = await fetcher.fetch(new Request("https://redtuma-memory/rpc", {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				method,
+				args
+			})
+		}));
+		const data = await res.json();
+		if (!res.ok || data.error) throw new Error(data.error ?? `Memory store RPC failed (HTTP ${res.status}).`);
+		return data.result;
+	};
+	return {
+		saveThread: (t) => call("saveThread", [t]),
+		getThread: (id) => call("getThread", [id]),
+		getThreadsByResourceId: (rid) => call("getThreadsByResourceId", [rid]),
+		deleteThread: (id) => call("deleteThread", [id]),
+		saveMessages: (m) => call("saveMessages", [m]),
+		getMessages: (a) => call("getMessages", [a]),
+		getResource: (id) => call("getResource", [id]),
+		saveResource: (r) => call("saveResource", [r]),
+		persistSnapshot: (k, v) => call("persistSnapshot", [k, v]),
+		loadSnapshot: (k) => call("loadSnapshot", [k])
+	};
+}
+
+//#endregion
+export { RedtumaMemoryObject, durableObjectStoreClient };
+//# sourceMappingURL=durable-object.js.map

package/dist/durable-object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable-object.js","names":["body: { method?: string; args?: unknown[] }"],"sources":["../src/durable-object.ts"],"sourcesContent":["import type { Store } from '@redtuma/core/store'\nimport { DurableObjectStore } from './store'\nimport type { KVStorage } from './storage'\n\n/** Cloudflare's `DurableObjectStorage` is a structural superset of this. */\nexport type DurableObjectStorageLike = KVStorage\n\nconst STORE_METHODS = new Set<keyof Store>([\n  'saveThread',\n  'getThread',\n  'getThreadsByResourceId',\n  'deleteThread',\n  'saveMessages',\n  'getMessages',\n  'getResource',\n  'saveResource',\n  'persistSnapshot',\n  'loadSnapshot',\n])\n\nfunction json(data: unknown, status = 200): Response {\n  return new Response(JSON.stringify(data), {\n    status,\n    headers: { 'content-type': 'application/json' },\n  })\n}\n\n/**\n * Base class for a Redtuma memory Durable Object. Each instance owns one\n * conversation's persistent state through a {@link DurableObjectStore}, exposed\n * over a tiny JSON-RPC `fetch` so a Worker can drive it with\n * {@link durableObjectStoreClient}. Subclass it and forward `state.storage`:\n *\n * ```ts\n * export class Memory extends RedtumaMemoryObject {\n *   constructor(state: DurableObjectState) {\n *     super(state.storage as unknown as KVStorage)\n *   }\n * }\n * ```\n */\nexport class RedtumaMemoryObject {\n  protected readonly memory: Store\n\n  constructor(storage: KVStorage) {\n    this.memory = new DurableObjectStore(storage)\n  }\n\n  async fetch(request: Request): Promise<Response> {\n    let body: { method?: string; args?: unknown[] }\n    try {\n      body = (await request.json()) as { method?: string; args?: unknown[] }\n    } catch {\n      return json({ error: 'Invalid JSON body.' }, 400)\n    }\n\n    const method = body.method\n    if (!method || !STORE_METHODS.has(method as keyof Store)) {\n      return json({ error: `Unknown store method \"${String(method)}\".` }, 400)\n    }\n\n    try {\n      const fn = this.memory[method as keyof Store] as (...args: unknown[]) => Promise<unknown>\n      const result = await fn.apply(this.memory, body.args ?? [])\n      return json({ result })\n    } catch (err) {\n      return json({ error: err instanceof Error ? err.message : String(err) }, 500)\n    }\n  }\n}\n\n/** Anything that can take a `Request` and return a `Response` — e.g. a DO stub. */\nexport interface Fetcher {\n  fetch(request: Request): Promise<Response>\n}\n\n/**\n * A {@link Store} whose calls are forwarded to a remote {@link RedtumaMemoryObject}\n * (or any {@link Fetcher}, such as a Durable Object stub) over JSON-RPC. This is\n * what a Worker uses as its agent/memory storage:\n *\n * ```ts\n * const id = env.MEMORY.idFromName(threadId)\n * const store = durableObjectStoreClient(env.MEMORY.get(id))\n * ```\n *\n * Note: values round-trip through JSON, so `Date` fields arrive as ISO strings.\n */\nexport function durableObjectStoreClient(fetcher: Fetcher): Store {\n  const call = async (method: keyof Store, args: unknown[]): Promise<unknown> => {\n    const res = await fetcher.fetch(\n      new Request('https://redtuma-memory/rpc', {\n        method: 'POST',\n        headers: { 'content-type': 'application/json' },\n        body: JSON.stringify({ method, args }),\n      }),\n    )\n    const data = (await res.json()) as { result?: unknown; error?: string }\n    if (!res.ok || data.error) {\n      throw new Error(data.error ?? `Memory store RPC failed (HTTP ${res.status}).`)\n    }\n    return data.result\n  }\n\n  return {\n    saveThread: (t) => call('saveThread', [t]) as Promise<never>,\n    getThread: (id) => call('getThread', [id]) as Promise<never>,\n    getThreadsByResourceId: (rid) => call('getThreadsByResourceId', [rid]) as Promise<never>,\n    deleteThread: (id) => call('deleteThread', [id]) as Promise<void>,\n    saveMessages: (m) => call('saveMessages', [m]) as Promise<never>,\n    getMessages: (a) => call('getMessages', [a]) as Promise<never>,\n    getResource: (id) => call('getResource', [id]) as Promise<never>,\n    saveResource: (r) => call('saveResource', [r]) as Promise<never>,\n    persistSnapshot: (k, v) => call('persistSnapshot', [k, v]) as Promise<void>,\n    loadSnapshot: (k) => call('loadSnapshot', [k]) as Promise<never>,\n  }\n}\n"],"mappings":";;;AAOA,MAAM,gBAAgB,IAAI,IAAiB;CACzC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;AAEF,SAAS,KAAK,MAAe,SAAS,KAAe;AACnD,QAAO,IAAI,SAAS,KAAK,UAAU,KAAK,EAAE;EACxC;EACA,SAAS,EAAE,gBAAgB,oBAAoB;EAChD,CAAC;;;;;;;;;;;;;;;;AAiBJ,IAAa,sBAAb,MAAiC;CAC/B,AAAmB;CAEnB,YAAY,SAAoB;AAC9B,OAAK,SAAS,IAAI,mBAAmB,QAAQ;;CAG/C,MAAM,MAAM,SAAqC;EAC/C,IAAIA;AACJ,MAAI;AACF,UAAQ,MAAM,QAAQ,MAAM;UACtB;AACN,UAAO,KAAK,EAAE,OAAO,sBAAsB,EAAE,IAAI;;EAGnD,MAAM,SAAS,KAAK;AACpB,MAAI,CAAC,UAAU,CAAC,cAAc,IAAI,OAAsB,CACtD,QAAO,KAAK,EAAE,OAAO,yBAAyB,OAAO,OAAO,CAAC,KAAK,EAAE,IAAI;AAG1E,MAAI;AAGF,UAAO,KAAK,EAAE,QADC,MADJ,KAAK,OAAO,QACC,MAAM,KAAK,QAAQ,KAAK,QAAQ,EAAE,CAAC,EACrC,CAAC;WAChB,KAAK;AACZ,UAAO,KAAK,EAAE,OAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EAAE,EAAE,IAAI;;;;;;;;;;;;;;;;AAsBnF,SAAgB,yBAAyB,SAAyB;CAChE,MAAM,OAAO,OAAO,QAAqB,SAAsC;EAC7E,MAAM,MAAM,MAAM,QAAQ,MACxB,IAAI,QAAQ,8BAA8B;GACxC,QAAQ;GACR,SAAS,EAAE,gBAAgB,oBAAoB;GAC/C,MAAM,KAAK,UAAU;IAAE;IAAQ;IAAM,CAAC;GACvC,CAAC,CACH;EACD,MAAM,OAAQ,MAAM,IAAI,MAAM;AAC9B,MAAI,CAAC,IAAI,MAAM,KAAK,MAClB,OAAM,IAAI,MAAM,KAAK,SAAS,iCAAiC,IAAI,OAAO,IAAI;AAEhF,SAAO,KAAK;;AAGd,QAAO;EACL,aAAa,MAAM,KAAK,cAAc,CAAC,EAAE,CAAC;EAC1C,YAAY,OAAO,KAAK,aAAa,CAAC,GAAG,CAAC;EAC1C,yBAAyB,QAAQ,KAAK,0BAA0B,CAAC,IAAI,CAAC;EACtE,eAAe,OAAO,KAAK,gBAAgB,CAAC,GAAG,CAAC;EAChD,eAAe,MAAM,KAAK,gBAAgB,CAAC,EAAE,CAAC;EAC9C,cAAc,MAAM,KAAK,eAAe,CAAC,EAAE,CAAC;EAC5C,cAAc,OAAO,KAAK,eAAe,CAAC,GAAG,CAAC;EAC9C,eAAe,MAAM,KAAK,gBAAgB,CAAC,EAAE,CAAC;EAC9C,kBAAkB,GAAG,MAAM,KAAK,mBAAmB,CAAC,GAAG,EAAE,CAAC;EAC1D,eAAe,MAAM,KAAK,gBAAgB,CAAC,EAAE,CAAC;EAC/C"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { KVStorage, MemoryKVStorage } from "./storage.js";
+import { DurableObjectStore } from "./store.js";
+import { DurableObjectStorageLike, Fetcher, RedtumaMemoryObject, durableObjectStoreClient } from "./durable-object.js";
+export { type DurableObjectStorageLike, DurableObjectStore, type Fetcher, type KVStorage, MemoryKVStorage, RedtumaMemoryObject, durableObjectStoreClient };

package/dist/index.js

@@ -0,0 +1,5 @@
+import { DurableObjectStore } from "./store.js";
+import { MemoryKVStorage } from "./storage.js";
+import { RedtumaMemoryObject, durableObjectStoreClient } from "./durable-object.js";
+
+export { DurableObjectStore, MemoryKVStorage, RedtumaMemoryObject, durableObjectStoreClient };

package/dist/storage.d.ts

@@ -0,0 +1,35 @@
+//#region src/storage.d.ts
+/**
+ * The subset of Cloudflare's `DurableObjectStorage` API that the store uses.
+ * Cloudflare's real storage is a structural superset of this, so a Durable
+ * Object's `state.storage` satisfies it directly.
+ *
+ * `list()` returns entries ordered lexicographically by key — the property the
+ * store relies on for message ordering via zero-padded sequence keys.
+ */
+interface KVStorage {
+  get<T = unknown>(key: string): Promise<T | undefined>;
+  put<T = unknown>(key: string, value: T): Promise<void>;
+  delete(key: string): Promise<boolean>;
+  list<T = unknown>(options?: {
+    prefix?: string;
+  }): Promise<Map<string, T>>;
+}
+/**
+ * In-memory {@link KVStorage} that mirrors the Durable Object storage semantics
+ * (structured-clone on write, lexicographic key ordering on `list`). Use it for
+ * local development, tests, and conformance — it behaves like the real DO store
+ * without the Workers runtime.
+ */
+declare class MemoryKVStorage implements KVStorage {
+  private readonly map;
+  get<T = unknown>(key: string): Promise<T | undefined>;
+  put<T = unknown>(key: string, value: T): Promise<void>;
+  delete(key: string): Promise<boolean>;
+  list<T = unknown>(options?: {
+    prefix?: string;
+  }): Promise<Map<string, T>>;
+}
+//#endregion
+export { KVStorage, MemoryKVStorage };
+//# sourceMappingURL=storage.d.ts.map

package/dist/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","names":[],"sources":["../src/storage.ts"],"sourcesContent":[],"mappings":";;AAQA;;;;;;;AAI4D,UAJ3C,SAAA,CAI2C;EAAR,GAAA,CAAA,IAAA,OAAA,CAAA,CAAA,GAAA,EAAA,MAAA,CAAA,EAHnB,OAGmB,CAHX,CAGW,GAAA,SAAA,CAAA;EAAO,GAAA,CAAA,IAAA,OAAA,CAAA,CAAA,GAAA,EAAA,MAAA,EAAA,KAAA,EAFpB,CAEoB,CAAA,EAFhB,OAEgB,CAAA,IAAA,CAAA;EAe9C,MAAA,CAAA,GAAA,EAAA,MAAgB,CAAA,EAhBN,OAgBM,CAAA,OAAA,CAAA;EAGkB,IAAA,CAAA,IAAA,OAAA,CAAA,CAAA,OAKF,CALE,EAAA;IAAR,MAAA,CAAA,EAAA,MAAA;EAKM,CAAA,CAAA,EAvBO,OAuBP,CAvBe,GAuBf,CAAA,MAAA,EAvB2B,CAuB3B,CAAA,CAAA;;;;;;;;cARhC,eAAA,YAA2B;;iCAGD,QAAQ;uCAKF,IAAI;uBAIpB;;;MAIiC,QAAQ,YAAY"}

package/dist/storage.js

@@ -0,0 +1,33 @@
+//#region src/storage.ts
+function clone(value) {
+	return typeof structuredClone === "function" ? structuredClone(value) : JSON.parse(JSON.stringify(value));
+}
+/**
+* In-memory {@link KVStorage} that mirrors the Durable Object storage semantics
+* (structured-clone on write, lexicographic key ordering on `list`). Use it for
+* local development, tests, and conformance — it behaves like the real DO store
+* without the Workers runtime.
+*/
+var MemoryKVStorage = class {
+	map = /* @__PURE__ */ new Map();
+	async get(key) {
+		const value = this.map.get(key);
+		return value === void 0 ? void 0 : clone(value);
+	}
+	async put(key, value) {
+		this.map.set(key, clone(value));
+	}
+	async delete(key) {
+		return this.map.delete(key);
+	}
+	async list(options = {}) {
+		const prefix = options.prefix ?? "";
+		const out = /* @__PURE__ */ new Map();
+		for (const key of [...this.map.keys()].sort()) if (key.startsWith(prefix)) out.set(key, clone(this.map.get(key)));
+		return out;
+	}
+};
+
+//#endregion
+export { MemoryKVStorage };
+//# sourceMappingURL=storage.js.map

package/dist/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","names":[],"sources":["../src/storage.ts"],"sourcesContent":["/**\n * The subset of Cloudflare's `DurableObjectStorage` API that the store uses.\n * Cloudflare's real storage is a structural superset of this, so a Durable\n * Object's `state.storage` satisfies it directly.\n *\n * `list()` returns entries ordered lexicographically by key — the property the\n * store relies on for message ordering via zero-padded sequence keys.\n */\nexport interface KVStorage {\n  get<T = unknown>(key: string): Promise<T | undefined>\n  put<T = unknown>(key: string, value: T): Promise<void>\n  delete(key: string): Promise<boolean>\n  list<T = unknown>(options?: { prefix?: string }): Promise<Map<string, T>>\n}\n\nfunction clone<T>(value: T): T {\n  return typeof structuredClone === 'function'\n    ? structuredClone(value)\n    : (JSON.parse(JSON.stringify(value)) as T)\n}\n\n/**\n * In-memory {@link KVStorage} that mirrors the Durable Object storage semantics\n * (structured-clone on write, lexicographic key ordering on `list`). Use it for\n * local development, tests, and conformance — it behaves like the real DO store\n * without the Workers runtime.\n */\nexport class MemoryKVStorage implements KVStorage {\n  private readonly map = new Map<string, unknown>()\n\n  async get<T = unknown>(key: string): Promise<T | undefined> {\n    const value = this.map.get(key)\n    return value === undefined ? undefined : (clone(value) as T)\n  }\n\n  async put<T = unknown>(key: string, value: T): Promise<void> {\n    this.map.set(key, clone(value))\n  }\n\n  async delete(key: string): Promise<boolean> {\n    return this.map.delete(key)\n  }\n\n  async list<T = unknown>(options: { prefix?: string } = {}): Promise<Map<string, T>> {\n    const prefix = options.prefix ?? ''\n    const out = new Map<string, T>()\n    for (const key of [...this.map.keys()].sort()) {\n      if (key.startsWith(prefix)) out.set(key, clone(this.map.get(key)) as T)\n    }\n    return out\n  }\n}\n"],"mappings":";AAeA,SAAS,MAAS,OAAa;AAC7B,QAAO,OAAO,oBAAoB,aAC9B,gBAAgB,MAAM,GACrB,KAAK,MAAM,KAAK,UAAU,MAAM,CAAC;;;;;;;;AASxC,IAAa,kBAAb,MAAkD;CAChD,AAAiB,sBAAM,IAAI,KAAsB;CAEjD,MAAM,IAAiB,KAAqC;EAC1D,MAAM,QAAQ,KAAK,IAAI,IAAI,IAAI;AAC/B,SAAO,UAAU,SAAY,SAAa,MAAM,MAAM;;CAGxD,MAAM,IAAiB,KAAa,OAAyB;AAC3D,OAAK,IAAI,IAAI,KAAK,MAAM,MAAM,CAAC;;CAGjC,MAAM,OAAO,KAA+B;AAC1C,SAAO,KAAK,IAAI,OAAO,IAAI;;CAG7B,MAAM,KAAkB,UAA+B,EAAE,EAA2B;EAClF,MAAM,SAAS,QAAQ,UAAU;EACjC,MAAM,sBAAM,IAAI,KAAgB;AAChC,OAAK,MAAM,OAAO,CAAC,GAAG,KAAK,IAAI,MAAM,CAAC,CAAC,MAAM,CAC3C,KAAI,IAAI,WAAW,OAAO,CAAE,KAAI,IAAI,KAAK,MAAM,KAAK,IAAI,IAAI,IAAI,CAAC,CAAM;AAEzE,SAAO"}

package/dist/store.d.ts

@@ -0,0 +1,33 @@
+import { KVStorage } from "./storage.js";
+import { GetMessagesArgs, Resource, Store, Thread } from "@redtuma/core/store";
+import { RedtumaMessage } from "@redtuma/core";
+
+//#region src/store.d.ts
+
+/**
+ * A {@link Store} persisted in a single Cloudflare Durable Object's key/value
+ * storage. One Durable Object instance typically owns one conversation thread
+ * (or one resource), so its memory is co-located, strongly consistent, and
+ * needs no external database. Pass the DO's `state.storage` (or
+ * {@link MemoryKVStorage} for local/dev/test).
+ */
+declare class DurableObjectStore implements Store {
+  private readonly kv;
+  constructor(kv: KVStorage);
+  saveThread(thread: Thread): Promise<Thread>;
+  getThread(id: string): Promise<Thread | null>;
+  getThreadsByResourceId(resourceId: string): Promise<Thread[]>;
+  deleteThread(id: string): Promise<void>;
+  saveMessages(messages: RedtumaMessage[]): Promise<RedtumaMessage[]>;
+  getMessages({
+    threadId,
+    last
+  }: GetMessagesArgs): Promise<RedtumaMessage[]>;
+  getResource(id: string): Promise<Resource | null>;
+  saveResource(resource: Resource): Promise<Resource>;
+  persistSnapshot(k: string, value: unknown): Promise<void>;
+  loadSnapshot<T = unknown>(k: string): Promise<T | null>;
+}
+//#endregion
+export { DurableObjectStore };
+//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","names":[],"sources":["../src/store.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA0BA;;;;;AAQuC,cAR1B,kBAAA,YAA8B,KAQJ,CAAA;EAAR,iBAAA,EAAA;EAI6B,WAAA,CAAA,EAAA,EAXzB,SAWyB;EAAR,UAAA,CAAA,MAAA,EATzB,MASyB,CAAA,EAThB,OASgB,CATR,MASQ,CAAA;EAKlB,SAAA,CAAA,EAAA,EAAA,MAAA,CAAA,EATH,OASG,CATK,MASL,GAAA,IAAA,CAAA;EAOH,sBAAA,CAAA,UAAA,EAAA,MAAA,CAAA,EAZqB,OAYrB,CAZ6B,MAY7B,EAAA,CAAA;EAA2B,YAAA,CAAA,EAAA,EAAA,MAAA,CAAA,EAPxB,OAOwB,CAAA,IAAA,CAAA;EAAR,YAAA,CAAA,QAAA,EAAnB,cAAmB,EAAA,CAAA,EAAA,OAAA,CAAQ,cAAR,EAAA,CAAA;EAiB5B,WAAA,CAAA;IAAA,QAAA;IAAA;EAAA,CAAA,EAAkB,eAAlB,CAAA,EAAoC,OAApC,CAA4C,cAA5C,EAAA,CAAA;EAAU,WAAA,CAAA,EAAA,EAAA,MAAA,CAAA,EAMC,OAND,CAMS,QANT,GAAA,IAAA,CAAA;EAAQ,YAAA,CAAA,QAAA,EAUT,QAVS,CAAA,EAUE,OAVF,CAUU,QAVV,CAAA;EAA0B,eAAA,CAAA,CAAA,EAAA,MAAA,EAAA,KAAA,EAAA,OAAA,CAAA,EAed,OAfc,CAAA,IAAA,CAAA;EAAR,YAAA,CAAA,IAAA,OAAA,CAAA,CAAA,CAAA,EAAA,MAAA,CAAA,EAmBZ,OAnBY,CAmBJ,CAnBI,GAAA,IAAA,CAAA"}

package/dist/store.js

@@ -0,0 +1,73 @@
+//#region src/store.ts
+const SEQ_WIDTH = 16;
+const pad = (n) => n.toString().padStart(SEQ_WIDTH, "0");
+const key = {
+	thread: (id) => `t:${id}`,
+	threadPrefix: "t:",
+	message: (threadId, seq) => `m:${threadId}:${pad(seq)}`,
+	messagePrefix: (threadId) => `m:${threadId}:`,
+	counter: (threadId) => `c:${threadId}`,
+	resource: (id) => `r:${id}`,
+	snapshot: (k) => `s:${k}`
+};
+/**
+* A {@link Store} persisted in a single Cloudflare Durable Object's key/value
+* storage. One Durable Object instance typically owns one conversation thread
+* (or one resource), so its memory is co-located, strongly consistent, and
+* needs no external database. Pass the DO's `state.storage` (or
+* {@link MemoryKVStorage} for local/dev/test).
+*/
+var DurableObjectStore = class {
+	constructor(kv) {
+		this.kv = kv;
+	}
+	async saveThread(thread) {
+		await this.kv.put(key.thread(thread.id), thread);
+		return thread;
+	}
+	async getThread(id) {
+		return await this.kv.get(key.thread(id)) ?? null;
+	}
+	async getThreadsByResourceId(resourceId) {
+		return [...(await this.kv.list({ prefix: key.threadPrefix })).values()].filter((t) => t.resourceId === resourceId);
+	}
+	async deleteThread(id) {
+		await this.kv.delete(key.thread(id));
+		await this.kv.delete(key.counter(id));
+		const messages = await this.kv.list({ prefix: key.messagePrefix(id) });
+		for (const k of messages.keys()) await this.kv.delete(k);
+	}
+	async saveMessages(messages) {
+		const nextSeq = /* @__PURE__ */ new Map();
+		for (const m of messages) {
+			if (!m.threadId) continue;
+			let seq = nextSeq.get(m.threadId);
+			if (seq === void 0) seq = await this.kv.get(key.counter(m.threadId)) ?? 0;
+			await this.kv.put(key.message(m.threadId, seq), m);
+			nextSeq.set(m.threadId, seq + 1);
+		}
+		for (const [threadId, seq] of nextSeq) await this.kv.put(key.counter(threadId), seq);
+		return messages;
+	}
+	async getMessages({ threadId, last }) {
+		const all = [...(await this.kv.list({ prefix: key.messagePrefix(threadId) })).values()];
+		return typeof last === "number" ? all.slice(-last) : all;
+	}
+	async getResource(id) {
+		return await this.kv.get(key.resource(id)) ?? null;
+	}
+	async saveResource(resource) {
+		await this.kv.put(key.resource(resource.id), resource);
+		return resource;
+	}
+	async persistSnapshot(k, value) {
+		await this.kv.put(key.snapshot(k), value);
+	}
+	async loadSnapshot(k) {
+		return await this.kv.get(key.snapshot(k)) ?? null;
+	}
+};
+
+//#endregion
+export { DurableObjectStore };
+//# sourceMappingURL=store.js.map

package/dist/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","names":["kv: KVStorage"],"sources":["../src/store.ts"],"sourcesContent":["import type { GetMessagesArgs, Resource, Store, Thread } from '@redtuma/core/store'\nimport type { RedtumaMessage } from '@redtuma/core'\nimport type { KVStorage } from './storage'\n\n// Zero-padded sequence width — keeps lexicographic key order equal to numeric\n// order for any realistic thread length.\nconst SEQ_WIDTH = 16\nconst pad = (n: number): string => n.toString().padStart(SEQ_WIDTH, '0')\n\nconst key = {\n  thread: (id: string) => `t:${id}`,\n  threadPrefix: 't:',\n  message: (threadId: string, seq: number) => `m:${threadId}:${pad(seq)}`,\n  messagePrefix: (threadId: string) => `m:${threadId}:`,\n  counter: (threadId: string) => `c:${threadId}`,\n  resource: (id: string) => `r:${id}`,\n  snapshot: (k: string) => `s:${k}`,\n}\n\n/**\n * A {@link Store} persisted in a single Cloudflare Durable Object's key/value\n * storage. One Durable Object instance typically owns one conversation thread\n * (or one resource), so its memory is co-located, strongly consistent, and\n * needs no external database. Pass the DO's `state.storage` (or\n * {@link MemoryKVStorage} for local/dev/test).\n */\nexport class DurableObjectStore implements Store {\n  constructor(private readonly kv: KVStorage) {}\n\n  async saveThread(thread: Thread): Promise<Thread> {\n    await this.kv.put(key.thread(thread.id), thread)\n    return thread\n  }\n\n  async getThread(id: string): Promise<Thread | null> {\n    return (await this.kv.get<Thread>(key.thread(id))) ?? null\n  }\n\n  async getThreadsByResourceId(resourceId: string): Promise<Thread[]> {\n    const threads = await this.kv.list<Thread>({ prefix: key.threadPrefix })\n    return [...threads.values()].filter((t) => t.resourceId === resourceId)\n  }\n\n  async deleteThread(id: string): Promise<void> {\n    await this.kv.delete(key.thread(id))\n    await this.kv.delete(key.counter(id))\n    const messages = await this.kv.list({ prefix: key.messagePrefix(id) })\n    for (const k of messages.keys()) await this.kv.delete(k)\n  }\n\n  async saveMessages(messages: RedtumaMessage[]): Promise<RedtumaMessage[]> {\n    // Per-thread monotonic sequence. DO execution is single-threaded, so this\n    // read-modify-write is race-free within an object.\n    const nextSeq = new Map<string, number>()\n    for (const m of messages) {\n      if (!m.threadId) continue\n      let seq = nextSeq.get(m.threadId)\n      if (seq === undefined) seq = (await this.kv.get<number>(key.counter(m.threadId))) ?? 0\n      await this.kv.put(key.message(m.threadId, seq), m)\n      nextSeq.set(m.threadId, seq + 1)\n    }\n    for (const [threadId, seq] of nextSeq) {\n      await this.kv.put(key.counter(threadId), seq)\n    }\n    return messages\n  }\n\n  async getMessages({ threadId, last }: GetMessagesArgs): Promise<RedtumaMessage[]> {\n    const map = await this.kv.list<RedtumaMessage>({ prefix: key.messagePrefix(threadId) })\n    const all = [...map.values()]\n    return typeof last === 'number' ? all.slice(-last) : all\n  }\n\n  async getResource(id: string): Promise<Resource | null> {\n    return (await this.kv.get<Resource>(key.resource(id))) ?? null\n  }\n\n  async saveResource(resource: Resource): Promise<Resource> {\n    await this.kv.put(key.resource(resource.id), resource)\n    return resource\n  }\n\n  async persistSnapshot(k: string, value: unknown): Promise<void> {\n    await this.kv.put(key.snapshot(k), value)\n  }\n\n  async loadSnapshot<T = unknown>(k: string): Promise<T | null> {\n    return (await this.kv.get<T>(key.snapshot(k))) ?? null\n  }\n}\n"],"mappings":";AAMA,MAAM,YAAY;AAClB,MAAM,OAAO,MAAsB,EAAE,UAAU,CAAC,SAAS,WAAW,IAAI;AAExE,MAAM,MAAM;CACV,SAAS,OAAe,KAAK;CAC7B,cAAc;CACd,UAAU,UAAkB,QAAgB,KAAK,SAAS,GAAG,IAAI,IAAI;CACrE,gBAAgB,aAAqB,KAAK,SAAS;CACnD,UAAU,aAAqB,KAAK;CACpC,WAAW,OAAe,KAAK;CAC/B,WAAW,MAAc,KAAK;CAC/B;;;;;;;;AASD,IAAa,qBAAb,MAAiD;CAC/C,YAAY,AAAiBA,IAAe;EAAf;;CAE7B,MAAM,WAAW,QAAiC;AAChD,QAAM,KAAK,GAAG,IAAI,IAAI,OAAO,OAAO,GAAG,EAAE,OAAO;AAChD,SAAO;;CAGT,MAAM,UAAU,IAAoC;AAClD,SAAQ,MAAM,KAAK,GAAG,IAAY,IAAI,OAAO,GAAG,CAAC,IAAK;;CAGxD,MAAM,uBAAuB,YAAuC;AAElE,SAAO,CAAC,IADQ,MAAM,KAAK,GAAG,KAAa,EAAE,QAAQ,IAAI,cAAc,CAAC,EACrD,QAAQ,CAAC,CAAC,QAAQ,MAAM,EAAE,eAAe,WAAW;;CAGzE,MAAM,aAAa,IAA2B;AAC5C,QAAM,KAAK,GAAG,OAAO,IAAI,OAAO,GAAG,CAAC;AACpC,QAAM,KAAK,GAAG,OAAO,IAAI,QAAQ,GAAG,CAAC;EACrC,MAAM,WAAW,MAAM,KAAK,GAAG,KAAK,EAAE,QAAQ,IAAI,cAAc,GAAG,EAAE,CAAC;AACtE,OAAK,MAAM,KAAK,SAAS,MAAM,CAAE,OAAM,KAAK,GAAG,OAAO,EAAE;;CAG1D,MAAM,aAAa,UAAuD;EAGxE,MAAM,0BAAU,IAAI,KAAqB;AACzC,OAAK,MAAM,KAAK,UAAU;AACxB,OAAI,CAAC,EAAE,SAAU;GACjB,IAAI,MAAM,QAAQ,IAAI,EAAE,SAAS;AACjC,OAAI,QAAQ,OAAW,OAAO,MAAM,KAAK,GAAG,IAAY,IAAI,QAAQ,EAAE,SAAS,CAAC,IAAK;AACrF,SAAM,KAAK,GAAG,IAAI,IAAI,QAAQ,EAAE,UAAU,IAAI,EAAE,EAAE;AAClD,WAAQ,IAAI,EAAE,UAAU,MAAM,EAAE;;AAElC,OAAK,MAAM,CAAC,UAAU,QAAQ,QAC5B,OAAM,KAAK,GAAG,IAAI,IAAI,QAAQ,SAAS,EAAE,IAAI;AAE/C,SAAO;;CAGT,MAAM,YAAY,EAAE,UAAU,QAAoD;EAEhF,MAAM,MAAM,CAAC,IADD,MAAM,KAAK,GAAG,KAAqB,EAAE,QAAQ,IAAI,cAAc,SAAS,EAAE,CAAC,EACnE,QAAQ,CAAC;AAC7B,SAAO,OAAO,SAAS,WAAW,IAAI,MAAM,CAAC,KAAK,GAAG;;CAGvD,MAAM,YAAY,IAAsC;AACtD,SAAQ,MAAM,KAAK,GAAG,IAAc,IAAI,SAAS,GAAG,CAAC,IAAK;;CAG5D,MAAM,aAAa,UAAuC;AACxD,QAAM,KAAK,GAAG,IAAI,IAAI,SAAS,SAAS,GAAG,EAAE,SAAS;AACtD,SAAO;;CAGT,MAAM,gBAAgB,GAAW,OAA+B;AAC9D,QAAM,KAAK,GAAG,IAAI,IAAI,SAAS,EAAE,EAAE,MAAM;;CAG3C,MAAM,aAA0B,GAA8B;AAC5D,SAAQ,MAAM,KAAK,GAAG,IAAO,IAAI,SAAS,EAAE,CAAC,IAAK"}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@redtuma/store-do",
+  "version": "0.1.0",
+  "description": "Redtuma store adapter backed by a Cloudflare Durable Object — edge-native agent memory with no external database.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@redtuma/core": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0",
+    "@redtuma/spec": "0.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/redtuma/redtuma.git",
+    "directory": "stores/do"
+  },
+  "homepage": "https://redtuma.ai",
+  "bugs": "https://github.com/redtuma/redtuma/issues",
+  "keywords": [
+    "ai",
+    "agents",
+    "llm",
+    "typescript",
+    "redtuma",
+    "cloudflare",
+    "durable-objects",
+    "edge"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "verify:workerd": "node integration/verify.mjs",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist .turbo"
+  }
+}