@nhtio/adk 0.1.0-master-f0aa531d

package/batteries/storage/in_memory/index.d.ts

@@ -0,0 +1,106 @@
+/**
+ * In-memory spool readers and stores for tests, scripts, and non-durable prototypes.
+ *
+ * @module @nhtio/adk/batteries/storage/in_memory
+ *
+ * @remarks
+ * Opt-in in-memory persistence battery. Provides {@link InMemorySpoolReader} (a sync
+ * {@link @nhtio/adk!SpoolReader} over a string) plus {@link InMemorySpoolStore} (a `Map<callId, bytes>`
+ * with a `write()` method that returns a fresh reader bound to the stored bytes).
+ *
+ * Use this when:
+ *
+ * - Writing unit or functional tests that need a real `SpoolReader` over known bytes.
+ * - Running a REPL or one-shot script where persistence beyond the process lifetime is not
+ *   needed.
+ * - Prototyping an agent before deciding on a real disk/object-store-backed persistence layer.
+ *
+ * Do **not** use this for production agents that need durability across process restarts —
+ * everything lives in process memory and is lost on exit.
+ */
+import type { SpoolReader } from "../../../common";
+/**
+ * Sync in-memory {@link @nhtio/adk!SpoolReader} over a `string` body.
+ *
+ * @remarks
+ * Splits the supplied content on `\n` at construction time and caches the resulting line array
+ * plus the UTF-8 byte length. All three `SpoolReader` methods resolve synchronously from the
+ * cache — no I/O happens after construction.
+ *
+ * Empty input yields a reader with `lineCount() === 0` and `byteLength() === 0`. A trailing
+ * newline produces a final empty line: `"a\nb\n".split('\n') === ['a', 'b', '']`. This matches
+ * the JavaScript `String.prototype.split` contract and lets a `lineCount()` consumer
+ * distinguish "two lines, no trailing newline" from "two lines, trailing newline".
+ */
+export declare class InMemorySpoolReader implements SpoolReader {
+    #private;
+    constructor(content: string);
+    line(index: number): string | undefined;
+    byteLength(): number;
+    lineCount(): number;
+    readAll(): string;
+}
+/**
+ * In-memory "give bytes, get a reader" persistence layer keyed by `callId`.
+ *
+ * @remarks
+ * Stores the canonical UTF-8 string form of each value. `Uint8Array` inputs are decoded via
+ * `TextDecoder` once at write time — subsequent `read()` calls return a reader over the cached
+ * string with no further decoding.
+ *
+ * Each `write()` and each `read()` returns a *fresh* {@link InMemorySpoolReader} — the store
+ * owns the bytes, the reader is a view. Mutating the store after handing out a reader does not
+ * invalidate the reader.
+ *
+ * @example
+ * ```ts
+ * const store = new InMemorySpoolStore()
+ * const bytes = await tool.executor(ctx)(args)
+ * const reader = store.write(callId, bytes)
+ * const Ctor = tool.artifactConstructor?.() ?? SpooledArtifact
+ * const artifact = new Ctor(reader)
+ * ```
+ */
+export declare class InMemorySpoolStore {
+    #private;
+    /**
+     * Persists `bytes` under `callId` and returns a reader over them.
+     *
+     * @remarks
+     * `Uint8Array` inputs are decoded as UTF-8. Re-writing the same `callId` replaces the prior
+     * entry; readers handed out before the rewrite continue to view the old bytes (they hold their
+     * own snapshot via the `InMemorySpoolReader` constructor).
+     *
+     * @param callId - Identifier used to retrieve the bytes via {@link InMemorySpoolStore.read}.
+     * @param bytes - The bytes to store, as a `string` or `Uint8Array`.
+     * @returns A fresh {@link InMemorySpoolReader} bound to the stored bytes.
+     */
+    write(callId: string, bytes: string | Uint8Array): InMemorySpoolReader;
+    /**
+     * Returns a reader over the bytes previously written under `callId`, or `undefined` if the
+     * entry has not been written or has been deleted.
+     *
+     * @param callId - Identifier supplied to a prior {@link InMemorySpoolStore.write} call.
+     * @returns A fresh {@link InMemorySpoolReader} bound to the stored bytes, or `undefined`.
+     */
+    read(callId: string): InMemorySpoolReader | undefined;
+    /**
+     * Removes the entry under `callId`.
+     *
+     * @param callId - Identifier whose entry should be removed.
+     * @returns `true` if an entry existed and was removed; `false` otherwise.
+     */
+    delete(callId: string): boolean;
+    /**
+     * Removes every entry from the store.
+     *
+     * @remarks
+     * Existing readers handed out by prior `write()` / `read()` calls remain valid — they hold
+     * their own snapshot.
+     */
+    clear(): void;
+    /**
+     * Returns the number of entries currently in the store.
+     */
+    get size(): number;
+}

package/batteries/storage/in_memory.cjs

@@ -0,0 +1,121 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/batteries/storage/in_memory/index.ts
+/**
+* Sync in-memory {@link @nhtio/adk!SpoolReader} over a `string` body.
+*
+* @remarks
+* Splits the supplied content on `\n` at construction time and caches the resulting line array
+* plus the UTF-8 byte length. All three `SpoolReader` methods resolve synchronously from the
+* cache — no I/O happens after construction.
+*
+* Empty input yields a reader with `lineCount() === 0` and `byteLength() === 0`. A trailing
+* newline produces a final empty line: `"a\nb\n".split('\n') === ['a', 'b', '']`. This matches
+* the JavaScript `String.prototype.split` contract and lets a `lineCount()` consumer
+* distinguish "two lines, no trailing newline" from "two lines, trailing newline".
+*/
+var InMemorySpoolReader = class {
+	#content;
+	#lines;
+	#bytes;
+	constructor(content) {
+		this.#content = content;
+		this.#lines = content === "" ? [] : content.split("\n");
+		this.#bytes = new TextEncoder().encode(content).length;
+	}
+	line(index) {
+		return this.#lines[index];
+	}
+	byteLength() {
+		return this.#bytes;
+	}
+	lineCount() {
+		return this.#lines.length;
+	}
+	readAll() {
+		return this.#content;
+	}
+};
+/**
+* In-memory "give bytes, get a reader" persistence layer keyed by `callId`.
+*
+* @remarks
+* Stores the canonical UTF-8 string form of each value. `Uint8Array` inputs are decoded via
+* `TextDecoder` once at write time — subsequent `read()` calls return a reader over the cached
+* string with no further decoding.
+*
+* Each `write()` and each `read()` returns a *fresh* {@link InMemorySpoolReader} — the store
+* owns the bytes, the reader is a view. Mutating the store after handing out a reader does not
+* invalidate the reader.
+*
+* @example
+* ```ts
+* const store = new InMemorySpoolStore()
+* const bytes = await tool.executor(ctx)(args)
+* const reader = store.write(callId, bytes)
+* const Ctor = tool.artifactConstructor?.() ?? SpooledArtifact
+* const artifact = new Ctor(reader)
+* ```
+*/
+var InMemorySpoolStore = class {
+	#entries = /* @__PURE__ */ new Map();
+	#decoder = new TextDecoder();
+	/**
+	* Persists `bytes` under `callId` and returns a reader over them.
+	*
+	* @remarks
+	* `Uint8Array` inputs are decoded as UTF-8. Re-writing the same `callId` replaces the prior
+	* entry; readers handed out before the rewrite continue to view the old bytes (they hold their
+	* own snapshot via the `InMemorySpoolReader` constructor).
+	*
+	* @param callId - Identifier used to retrieve the bytes via {@link InMemorySpoolStore.read}.
+	* @param bytes - The bytes to store, as a `string` or `Uint8Array`.
+	* @returns A fresh {@link InMemorySpoolReader} bound to the stored bytes.
+	*/
+	write(callId, bytes) {
+		const text = typeof bytes === "string" ? bytes : this.#decoder.decode(bytes);
+		this.#entries.set(callId, text);
+		return new InMemorySpoolReader(text);
+	}
+	/**
+	* Returns a reader over the bytes previously written under `callId`, or `undefined` if the
+	* entry has not been written or has been deleted.
+	*
+	* @param callId - Identifier supplied to a prior {@link InMemorySpoolStore.write} call.
+	* @returns A fresh {@link InMemorySpoolReader} bound to the stored bytes, or `undefined`.
+	*/
+	read(callId) {
+		const text = this.#entries.get(callId);
+		if (text === void 0) return void 0;
+		return new InMemorySpoolReader(text);
+	}
+	/**
+	* Removes the entry under `callId`.
+	*
+	* @param callId - Identifier whose entry should be removed.
+	* @returns `true` if an entry existed and was removed; `false` otherwise.
+	*/
+	delete(callId) {
+		return this.#entries.delete(callId);
+	}
+	/**
+	* Removes every entry from the store.
+	*
+	* @remarks
+	* Existing readers handed out by prior `write()` / `read()` calls remain valid — they hold
+	* their own snapshot.
+	*/
+	clear() {
+		this.#entries.clear();
+	}
+	/**
+	* Returns the number of entries currently in the store.
+	*/
+	get size() {
+		return this.#entries.size;
+	}
+};
+//#endregion
+exports.InMemorySpoolReader = InMemorySpoolReader;
+exports.InMemorySpoolStore = InMemorySpoolStore;
+
+//# sourceMappingURL=in_memory.cjs.map

package/batteries/storage/in_memory.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"in_memory.cjs","names":["#content","#lines","#bytes","#entries","#decoder"],"sources":["../../../src/batteries/storage/in_memory/index.ts"],"sourcesContent":["/**\n * In-memory spool readers and stores for tests, scripts, and non-durable prototypes.\n *\n * @module @nhtio/adk/batteries/storage/in_memory\n *\n * @remarks\n * Opt-in in-memory persistence battery. Provides {@link InMemorySpoolReader} (a sync\n * {@link @nhtio/adk!SpoolReader} over a string) plus {@link InMemorySpoolStore} (a `Map<callId, bytes>`\n * with a `write()` method that returns a fresh reader bound to the stored bytes).\n *\n * Use this when:\n *\n * - Writing unit or functional tests that need a real `SpoolReader` over known bytes.\n * - Running a REPL or one-shot script where persistence beyond the process lifetime is not\n *   needed.\n * - Prototyping an agent before deciding on a real disk/object-store-backed persistence layer.\n *\n * Do **not** use this for production agents that need durability across process restarts —\n * everything lives in process memory and is lost on exit.\n */\n\nimport type { SpoolReader } from '@nhtio/adk/common'\n\n/**\n * Sync in-memory {@link @nhtio/adk!SpoolReader} over a `string` body.\n *\n * @remarks\n * Splits the supplied content on `\\n` at construction time and caches the resulting line array\n * plus the UTF-8 byte length. All three `SpoolReader` methods resolve synchronously from the\n * cache — no I/O happens after construction.\n *\n * Empty input yields a reader with `lineCount() === 0` and `byteLength() === 0`. A trailing\n * newline produces a final empty line: `\"a\\nb\\n\".split('\\n') === ['a', 'b', '']`. This matches\n * the JavaScript `String.prototype.split` contract and lets a `lineCount()` consumer\n * distinguish \"two lines, no trailing newline\" from \"two lines, trailing newline\".\n */\nexport class InMemorySpoolReader implements SpoolReader {\n  readonly #content: string\n  readonly #lines: string[]\n  readonly #bytes: number\n\n  constructor(content: string) {\n    this.#content = content\n    this.#lines = content === '' ? [] : content.split('\\n')\n    this.#bytes = new TextEncoder().encode(content).length\n  }\n\n  line(index: number): string | undefined {\n    return this.#lines[index]\n  }\n\n  byteLength(): number {\n    return this.#bytes\n  }\n\n  lineCount(): number {\n    return this.#lines.length\n  }\n\n  readAll(): string {\n    return this.#content\n  }\n}\n\n/**\n * In-memory \"give bytes, get a reader\" persistence layer keyed by `callId`.\n *\n * @remarks\n * Stores the canonical UTF-8 string form of each value. `Uint8Array` inputs are decoded via\n * `TextDecoder` once at write time — subsequent `read()` calls return a reader over the cached\n * string with no further decoding.\n *\n * Each `write()` and each `read()` returns a *fresh* {@link InMemorySpoolReader} — the store\n * owns the bytes, the reader is a view. Mutating the store after handing out a reader does not\n * invalidate the reader.\n *\n * @example\n * ```ts\n * const store = new InMemorySpoolStore()\n * const bytes = await tool.executor(ctx)(args)\n * const reader = store.write(callId, bytes)\n * const Ctor = tool.artifactConstructor?.() ?? SpooledArtifact\n * const artifact = new Ctor(reader)\n * ```\n */\nexport class InMemorySpoolStore {\n  readonly #entries = new Map<string, string>()\n  readonly #decoder = new TextDecoder()\n\n  /**\n   * Persists `bytes` under `callId` and returns a reader over them.\n   *\n   * @remarks\n   * `Uint8Array` inputs are decoded as UTF-8. Re-writing the same `callId` replaces the prior\n   * entry; readers handed out before the rewrite continue to view the old bytes (they hold their\n   * own snapshot via the `InMemorySpoolReader` constructor).\n   *\n   * @param callId - Identifier used to retrieve the bytes via {@link InMemorySpoolStore.read}.\n   * @param bytes - The bytes to store, as a `string` or `Uint8Array`.\n   * @returns A fresh {@link InMemorySpoolReader} bound to the stored bytes.\n   */\n  write(callId: string, bytes: string | Uint8Array): InMemorySpoolReader {\n    const text = typeof bytes === 'string' ? bytes : this.#decoder.decode(bytes)\n    this.#entries.set(callId, text)\n    return new InMemorySpoolReader(text)\n  }\n\n  /**\n   * Returns a reader over the bytes previously written under `callId`, or `undefined` if the\n   * entry has not been written or has been deleted.\n   *\n   * @param callId - Identifier supplied to a prior {@link InMemorySpoolStore.write} call.\n   * @returns A fresh {@link InMemorySpoolReader} bound to the stored bytes, or `undefined`.\n   */\n  read(callId: string): InMemorySpoolReader | undefined {\n    const text = this.#entries.get(callId)\n    if (text === undefined) return undefined\n    return new InMemorySpoolReader(text)\n  }\n\n  /**\n   * Removes the entry under `callId`.\n   *\n   * @param callId - Identifier whose entry should be removed.\n   * @returns `true` if an entry existed and was removed; `false` otherwise.\n   */\n  delete(callId: string): boolean {\n    return this.#entries.delete(callId)\n  }\n\n  /**\n   * Removes every entry from the store.\n   *\n   * @remarks\n   * Existing readers handed out by prior `write()` / `read()` calls remain valid — they hold\n   * their own snapshot.\n   */\n  clear(): void {\n    this.#entries.clear()\n  }\n\n  /**\n   * Returns the number of entries currently in the store.\n   */\n  get size(): number {\n    return this.#entries.size\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAoCA,IAAa,sBAAb,MAAwD;CACtD;CACA;CACA;CAEA,YAAY,SAAiB;EAC3B,KAAKA,WAAW;EAChB,KAAKC,SAAS,YAAY,KAAK,CAAC,IAAI,QAAQ,MAAM,IAAI;EACtD,KAAKC,SAAS,IAAI,YAAY,EAAE,OAAO,OAAO,EAAE;CAClD;CAEA,KAAK,OAAmC;EACtC,OAAO,KAAKD,OAAO;CACrB;CAEA,aAAqB;EACnB,OAAO,KAAKC;CACd;CAEA,YAAoB;EAClB,OAAO,KAAKD,OAAO;CACrB;CAEA,UAAkB;EAChB,OAAO,KAAKD;CACd;AACF;;;;;;;;;;;;;;;;;;;;;;AAuBA,IAAa,qBAAb,MAAgC;CAC9B,2BAAoB,IAAI,IAAoB;CAC5C,WAAoB,IAAI,YAAY;;;;;;;;;;;;;CAcpC,MAAM,QAAgB,OAAiD;EACrE,MAAM,OAAO,OAAO,UAAU,WAAW,QAAQ,KAAKI,SAAS,OAAO,KAAK;EAC3E,KAAKD,SAAS,IAAI,QAAQ,IAAI;EAC9B,OAAO,IAAI,oBAAoB,IAAI;CACrC;;;;;;;;CASA,KAAK,QAAiD;EACpD,MAAM,OAAO,KAAKA,SAAS,IAAI,MAAM;EACrC,IAAI,SAAS,KAAA,GAAW,OAAO,KAAA;EAC/B,OAAO,IAAI,oBAAoB,IAAI;CACrC;;;;;;;CAQA,OAAO,QAAyB;EAC9B,OAAO,KAAKA,SAAS,OAAO,MAAM;CACpC;;;;;;;;CASA,QAAc;EACZ,KAAKA,SAAS,MAAM;CACtB;;;;CAKA,IAAI,OAAe;EACjB,OAAO,KAAKA,SAAS;CACvB;AACF"}

package/batteries/storage/in_memory.mjs

@@ -0,0 +1,119 @@
+//#region src/batteries/storage/in_memory/index.ts
+/**
+* Sync in-memory {@link @nhtio/adk!SpoolReader} over a `string` body.
+*
+* @remarks
+* Splits the supplied content on `\n` at construction time and caches the resulting line array
+* plus the UTF-8 byte length. All three `SpoolReader` methods resolve synchronously from the
+* cache — no I/O happens after construction.
+*
+* Empty input yields a reader with `lineCount() === 0` and `byteLength() === 0`. A trailing
+* newline produces a final empty line: `"a\nb\n".split('\n') === ['a', 'b', '']`. This matches
+* the JavaScript `String.prototype.split` contract and lets a `lineCount()` consumer
+* distinguish "two lines, no trailing newline" from "two lines, trailing newline".
+*/
+var InMemorySpoolReader = class {
+	#content;
+	#lines;
+	#bytes;
+	constructor(content) {
+		this.#content = content;
+		this.#lines = content === "" ? [] : content.split("\n");
+		this.#bytes = new TextEncoder().encode(content).length;
+	}
+	line(index) {
+		return this.#lines[index];
+	}
+	byteLength() {
+		return this.#bytes;
+	}
+	lineCount() {
+		return this.#lines.length;
+	}
+	readAll() {
+		return this.#content;
+	}
+};
+/**
+* In-memory "give bytes, get a reader" persistence layer keyed by `callId`.
+*
+* @remarks
+* Stores the canonical UTF-8 string form of each value. `Uint8Array` inputs are decoded via
+* `TextDecoder` once at write time — subsequent `read()` calls return a reader over the cached
+* string with no further decoding.
+*
+* Each `write()` and each `read()` returns a *fresh* {@link InMemorySpoolReader} — the store
+* owns the bytes, the reader is a view. Mutating the store after handing out a reader does not
+* invalidate the reader.
+*
+* @example
+* ```ts
+* const store = new InMemorySpoolStore()
+* const bytes = await tool.executor(ctx)(args)
+* const reader = store.write(callId, bytes)
+* const Ctor = tool.artifactConstructor?.() ?? SpooledArtifact
+* const artifact = new Ctor(reader)
+* ```
+*/
+var InMemorySpoolStore = class {
+	#entries = /* @__PURE__ */ new Map();
+	#decoder = new TextDecoder();
+	/**
+	* Persists `bytes` under `callId` and returns a reader over them.
+	*
+	* @remarks
+	* `Uint8Array` inputs are decoded as UTF-8. Re-writing the same `callId` replaces the prior
+	* entry; readers handed out before the rewrite continue to view the old bytes (they hold their
+	* own snapshot via the `InMemorySpoolReader` constructor).
+	*
+	* @param callId - Identifier used to retrieve the bytes via {@link InMemorySpoolStore.read}.
+	* @param bytes - The bytes to store, as a `string` or `Uint8Array`.
+	* @returns A fresh {@link InMemorySpoolReader} bound to the stored bytes.
+	*/
+	write(callId, bytes) {
+		const text = typeof bytes === "string" ? bytes : this.#decoder.decode(bytes);
+		this.#entries.set(callId, text);
+		return new InMemorySpoolReader(text);
+	}
+	/**
+	* Returns a reader over the bytes previously written under `callId`, or `undefined` if the
+	* entry has not been written or has been deleted.
+	*
+	* @param callId - Identifier supplied to a prior {@link InMemorySpoolStore.write} call.
+	* @returns A fresh {@link InMemorySpoolReader} bound to the stored bytes, or `undefined`.
+	*/
+	read(callId) {
+		const text = this.#entries.get(callId);
+		if (text === void 0) return void 0;
+		return new InMemorySpoolReader(text);
+	}
+	/**
+	* Removes the entry under `callId`.
+	*
+	* @param callId - Identifier whose entry should be removed.
+	* @returns `true` if an entry existed and was removed; `false` otherwise.
+	*/
+	delete(callId) {
+		return this.#entries.delete(callId);
+	}
+	/**
+	* Removes every entry from the store.
+	*
+	* @remarks
+	* Existing readers handed out by prior `write()` / `read()` calls remain valid — they hold
+	* their own snapshot.
+	*/
+	clear() {
+		this.#entries.clear();
+	}
+	/**
+	* Returns the number of entries currently in the store.
+	*/
+	get size() {
+		return this.#entries.size;
+	}
+};
+//#endregion
+export { InMemorySpoolReader, InMemorySpoolStore };
+
+//# sourceMappingURL=in_memory.mjs.map

package/batteries/storage/in_memory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"in_memory.mjs","names":["#content","#lines","#bytes","#entries","#decoder"],"sources":["../../../src/batteries/storage/in_memory/index.ts"],"sourcesContent":["/**\n * In-memory spool readers and stores for tests, scripts, and non-durable prototypes.\n *\n * @module @nhtio/adk/batteries/storage/in_memory\n *\n * @remarks\n * Opt-in in-memory persistence battery. Provides {@link InMemorySpoolReader} (a sync\n * {@link @nhtio/adk!SpoolReader} over a string) plus {@link InMemorySpoolStore} (a `Map<callId, bytes>`\n * with a `write()` method that returns a fresh reader bound to the stored bytes).\n *\n * Use this when:\n *\n * - Writing unit or functional tests that need a real `SpoolReader` over known bytes.\n * - Running a REPL or one-shot script where persistence beyond the process lifetime is not\n *   needed.\n * - Prototyping an agent before deciding on a real disk/object-store-backed persistence layer.\n *\n * Do **not** use this for production agents that need durability across process restarts —\n * everything lives in process memory and is lost on exit.\n */\n\nimport type { SpoolReader } from '@nhtio/adk/common'\n\n/**\n * Sync in-memory {@link @nhtio/adk!SpoolReader} over a `string` body.\n *\n * @remarks\n * Splits the supplied content on `\\n` at construction time and caches the resulting line array\n * plus the UTF-8 byte length. All three `SpoolReader` methods resolve synchronously from the\n * cache — no I/O happens after construction.\n *\n * Empty input yields a reader with `lineCount() === 0` and `byteLength() === 0`. A trailing\n * newline produces a final empty line: `\"a\\nb\\n\".split('\\n') === ['a', 'b', '']`. This matches\n * the JavaScript `String.prototype.split` contract and lets a `lineCount()` consumer\n * distinguish \"two lines, no trailing newline\" from \"two lines, trailing newline\".\n */\nexport class InMemorySpoolReader implements SpoolReader {\n  readonly #content: string\n  readonly #lines: string[]\n  readonly #bytes: number\n\n  constructor(content: string) {\n    this.#content = content\n    this.#lines = content === '' ? [] : content.split('\\n')\n    this.#bytes = new TextEncoder().encode(content).length\n  }\n\n  line(index: number): string | undefined {\n    return this.#lines[index]\n  }\n\n  byteLength(): number {\n    return this.#bytes\n  }\n\n  lineCount(): number {\n    return this.#lines.length\n  }\n\n  readAll(): string {\n    return this.#content\n  }\n}\n\n/**\n * In-memory \"give bytes, get a reader\" persistence layer keyed by `callId`.\n *\n * @remarks\n * Stores the canonical UTF-8 string form of each value. `Uint8Array` inputs are decoded via\n * `TextDecoder` once at write time — subsequent `read()` calls return a reader over the cached\n * string with no further decoding.\n *\n * Each `write()` and each `read()` returns a *fresh* {@link InMemorySpoolReader} — the store\n * owns the bytes, the reader is a view. Mutating the store after handing out a reader does not\n * invalidate the reader.\n *\n * @example\n * ```ts\n * const store = new InMemorySpoolStore()\n * const bytes = await tool.executor(ctx)(args)\n * const reader = store.write(callId, bytes)\n * const Ctor = tool.artifactConstructor?.() ?? SpooledArtifact\n * const artifact = new Ctor(reader)\n * ```\n */\nexport class InMemorySpoolStore {\n  readonly #entries = new Map<string, string>()\n  readonly #decoder = new TextDecoder()\n\n  /**\n   * Persists `bytes` under `callId` and returns a reader over them.\n   *\n   * @remarks\n   * `Uint8Array` inputs are decoded as UTF-8. Re-writing the same `callId` replaces the prior\n   * entry; readers handed out before the rewrite continue to view the old bytes (they hold their\n   * own snapshot via the `InMemorySpoolReader` constructor).\n   *\n   * @param callId - Identifier used to retrieve the bytes via {@link InMemorySpoolStore.read}.\n   * @param bytes - The bytes to store, as a `string` or `Uint8Array`.\n   * @returns A fresh {@link InMemorySpoolReader} bound to the stored bytes.\n   */\n  write(callId: string, bytes: string | Uint8Array): InMemorySpoolReader {\n    const text = typeof bytes === 'string' ? bytes : this.#decoder.decode(bytes)\n    this.#entries.set(callId, text)\n    return new InMemorySpoolReader(text)\n  }\n\n  /**\n   * Returns a reader over the bytes previously written under `callId`, or `undefined` if the\n   * entry has not been written or has been deleted.\n   *\n   * @param callId - Identifier supplied to a prior {@link InMemorySpoolStore.write} call.\n   * @returns A fresh {@link InMemorySpoolReader} bound to the stored bytes, or `undefined`.\n   */\n  read(callId: string): InMemorySpoolReader | undefined {\n    const text = this.#entries.get(callId)\n    if (text === undefined) return undefined\n    return new InMemorySpoolReader(text)\n  }\n\n  /**\n   * Removes the entry under `callId`.\n   *\n   * @param callId - Identifier whose entry should be removed.\n   * @returns `true` if an entry existed and was removed; `false` otherwise.\n   */\n  delete(callId: string): boolean {\n    return this.#entries.delete(callId)\n  }\n\n  /**\n   * Removes every entry from the store.\n   *\n   * @remarks\n   * Existing readers handed out by prior `write()` / `read()` calls remain valid — they hold\n   * their own snapshot.\n   */\n  clear(): void {\n    this.#entries.clear()\n  }\n\n  /**\n   * Returns the number of entries currently in the store.\n   */\n  get size(): number {\n    return this.#entries.size\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAoCA,IAAa,sBAAb,MAAwD;CACtD;CACA;CACA;CAEA,YAAY,SAAiB;EAC3B,KAAKA,WAAW;EAChB,KAAKC,SAAS,YAAY,KAAK,CAAC,IAAI,QAAQ,MAAM,IAAI;EACtD,KAAKC,SAAS,IAAI,YAAY,EAAE,OAAO,OAAO,EAAE;CAClD;CAEA,KAAK,OAAmC;EACtC,OAAO,KAAKD,OAAO;CACrB;CAEA,aAAqB;EACnB,OAAO,KAAKC;CACd;CAEA,YAAoB;EAClB,OAAO,KAAKD,OAAO;CACrB;CAEA,UAAkB;EAChB,OAAO,KAAKD;CACd;AACF;;;;;;;;;;;;;;;;;;;;;;AAuBA,IAAa,qBAAb,MAAgC;CAC9B,2BAAoB,IAAI,IAAoB;CAC5C,WAAoB,IAAI,YAAY;;;;;;;;;;;;;CAcpC,MAAM,QAAgB,OAAiD;EACrE,MAAM,OAAO,OAAO,UAAU,WAAW,QAAQ,KAAKI,SAAS,OAAO,KAAK;EAC3E,KAAKD,SAAS,IAAI,QAAQ,IAAI;EAC9B,OAAO,IAAI,oBAAoB,IAAI;CACrC;;;;;;;;CASA,KAAK,QAAiD;EACpD,MAAM,OAAO,KAAKA,SAAS,IAAI,MAAM;EACrC,IAAI,SAAS,KAAA,GAAW,OAAO,KAAA;EAC/B,OAAO,IAAI,oBAAoB,IAAI;CACrC;;;;;;;CAQA,OAAO,QAAyB;EAC9B,OAAO,KAAKA,SAAS,OAAO,MAAM;CACpC;;;;;;;;CASA,QAAc;EACZ,KAAKA,SAAS,MAAM;CACtB;;;;CAKA,IAAI,OAAe;EACjB,OAAO,KAAKA,SAAS;CACvB;AACF"}

package/batteries/storage/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Environment-neutral aggregate barrel for bundled storage batteries.
+ *
+ * @module @nhtio/adk/batteries/storage
+ *
+ * @remarks
+ * Aggregate barrel for the storage batteries. Re-exports only **environment-neutral** storage
+ * helpers — currently just the in-memory battery — so that consumers can import this barrel from
+ * either Node or the browser without dragging in environment-specific runtime requirements.
+ *
+ * Environment-specific batteries are reachable only through their own subpath:
+ *
+ * - `@nhtio/adk/batteries/storage/flydrive` — Node-only (uses `node:stream`).
+ * - `@nhtio/adk/batteries/storage/opfs` — browser-only (uses the OPFS API).
+ *
+ * Deep-import the subpath you need; don't expect either to be re-exported from this barrel.
+ */
+export * from "./in_memory/index";