@unikvs/memory 0.0.10 → 0.0.13

package/README.md

@@ -0,0 +1,3 @@
+# @unikvs/memory
+
+[Document](https://tai-kun.github.io/unikvs/)

package/dist/index.d.ts

@@ -0,0 +1,65 @@
+import { ErrorBase, ErrorOptions, IStorage, KeyNotFoundError, KeyNotFoundErrorArgs, KeyNotFoundErrorMeta } from "@unikvs/core";
+//#region ../src/errors.d.ts
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-error)
+ */
+type InvalidChunkTypeErrorMeta = {
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-key)
+   */
+  readonly key: string;
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-chunk)
+   */
+  readonly chunk: unknown;
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-chunk-type)
+   */
+  readonly chunkType: string;
+};
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-error)
+ */
+type InvalidChunkTypeErrorArgs = ErrorOptions & Omit<InvalidChunkTypeErrorMeta, "chunkType">;
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-error)
+ */
+export declare class InvalidChunkTypeError extends ErrorBase<InvalidChunkTypeErrorMeta> {
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-error)
+   */
+  constructor(args: InvalidChunkTypeErrorArgs);
+}
+//#endregion
+//#region ../src/memory.d.ts
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#usage)
+ */
+type MemoryOptions = {
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#clone)
+   */
+  readonly clone?: (<T>(value: T) => T) | undefined;
+};
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#usage)
+ */
+declare class Memory implements IStorage {
+  #private;
+  readonly name: string;
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#usage)
+   */
+  constructor(options?: MemoryOptions);
+  get isOpen(): boolean;
+  write(c: IStorage.WriteContext, data: any): void;
+  read(c: IStorage.ReadContext): any;
+  exists(c: IStorage.ExistsContext): boolean;
+  delete(c: IStorage.DeleteContext): void;
+  clear(_c: IStorage.ClearContext): void;
+  getWritable(c: IStorage.GetWritableContext): WritableStream<Uint8Array<ArrayBuffer>>;
+  getReadable(c: IStorage.GetReadableContext): ReadableStream<Uint8Array<ArrayBuffer>>;
+}
+//#endregion
+export { type InvalidChunkTypeErrorArgs, type InvalidChunkTypeErrorMeta, KeyNotFoundError, type KeyNotFoundErrorArgs, type KeyNotFoundErrorMeta, Memory, type MemoryOptions };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/errors.ts","../src/memory.ts"],"mappings":";;;;;KASY;;;;WAID;;;;WAKA;;;;WAKA;;;;;KAMC,4BAA4B,eAAe,KAAK;;;;qBAK/C,8BAA8B,UAAU;;;;EAQnD,YAAmB,MAAM;;;;;;;KCnCf;;;;WAID,UAAU,GAAG,OAAO,MAAM;;;;;cAMhB,kBAAkB;;WAMrB;;;;EAUhB,YAAmB,UAAS;MAQjB;EAIX,MAAa,GAAG,SAAS,cAAc;EAIvC,KAAY,GAAG,SAAS;EAUxB,OAAc,GAAG,SAAS;EAM1B,OAAc,GAAG,SAAS;EAQ1B,MAAa,IAAI,SAAS;EAI1B,YAAmB,GAAG,SAAS,qBAAqB,eAAe,WAAW;EAgC9E,YAAmB,GAAG,SAAS,qBAAqB,eAAe,WAAW"}

package/dist/index.js

@@ -0,0 +1,129 @@
+import { ErrorBase, KeyNotFoundError, KeyNotFoundError as KeyNotFoundError$1, setErrorMessage } from "@unikvs/core";
+import getTypeName from "type-name";
+//#region ../src/errors.ts
+var _InvalidChunkTypeError;
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-error)
+*/
+var InvalidChunkTypeError = class extends ErrorBase {
+	/**
+	* [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-error)
+	*/
+	constructor(args) {
+		const { key, chunk, ...options } = args;
+		const meta = {
+			key,
+			chunk,
+			chunkType: getTypeName(chunk)
+		};
+		super(meta, ({ key: messageKey, chunkType }) => `Expected chunk for key ${JSON.stringify(messageKey)} is Uint8Array<ArrayBuffer>, but got ${chunkType}`, options);
+	}
+};
+_InvalidChunkTypeError = InvalidChunkTypeError;
+_InvalidChunkTypeError.prototype.name = "MemoryInvalidChunkTypeError";
+setErrorMessage(InvalidChunkTypeError, ({ key: messageKey, chunkType }) => `キー ${JSON.stringify(messageKey)} のチャンク型に Uint8Array<ArrayBuffer> を期待しましたが、${chunkType} を得ました`, "ja");
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/checkPrivateRedeclaration.js
+function _checkPrivateRedeclaration(e, t) {
+	if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/classPrivateFieldInitSpec.js
+function _classPrivateFieldInitSpec(e, t, a) {
+	_checkPrivateRedeclaration(e, t), t.set(e, a);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/assertClassBrand.js
+function _assertClassBrand(e, t, n) {
+	if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+	throw new TypeError("Private element is not present on this object");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/classPrivateFieldSet2.js
+function _classPrivateFieldSet2(s, a, r) {
+	return s.set(_assertClassBrand(s, a), r), r;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/classPrivateFieldGet2.js
+function _classPrivateFieldGet2(s, a) {
+	return s.get(_assertClassBrand(s, a));
+}
+//#endregion
+//#region ../src/memory.ts
+var _map = /* @__PURE__ */ new WeakMap();
+var _clone = /* @__PURE__ */ new WeakMap();
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/memory#usage)
+*/
+var Memory = class {
+	/**
+	* [API Reference](https://tai-kun.github.io/unikvs/packages/memory#usage)
+	*/
+	constructor(options = {}) {
+		_classPrivateFieldInitSpec(this, _map, void 0);
+		_classPrivateFieldInitSpec(this, _clone, void 0);
+		const { clone = (value) => structuredClone(value) } = options;
+		this.name = "Memory";
+		_classPrivateFieldSet2(_map, this, /* @__PURE__ */ new Map());
+		_classPrivateFieldSet2(_clone, this, clone);
+	}
+	get isOpen() {
+		return true;
+	}
+	write(c, data) {
+		_classPrivateFieldGet2(_map, this).set(c.key, _classPrivateFieldGet2(_clone, this).call(this, data));
+	}
+	read(c) {
+		if (!_classPrivateFieldGet2(_map, this).has(c.key)) throw new KeyNotFoundError$1({ key: c.key });
+		const value = _classPrivateFieldGet2(_map, this).get(c.key);
+		return _classPrivateFieldGet2(_clone, this).call(this, value);
+	}
+	exists(c) {
+		return _classPrivateFieldGet2(_map, this).has(c.key);
+	}
+	delete(c) {
+		if (!_classPrivateFieldGet2(_map, this).has(c.key)) throw new KeyNotFoundError$1({ key: c.key });
+		_classPrivateFieldGet2(_map, this).delete(c.key);
+	}
+	clear(_c) {
+		_classPrivateFieldGet2(_map, this).clear();
+	}
+	getWritable(c) {
+		const chunks = [];
+		return new WritableStream({
+			close: () => {
+				const totalLength = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+				const merged = new Uint8Array(totalLength);
+				let offset = 0;
+				for (const chunk of chunks) {
+					merged.set(chunk, offset);
+					offset += chunk.byteLength;
+				}
+				_classPrivateFieldGet2(_map, this).set(c.key, merged);
+			},
+			write: (chunk) => {
+				if (!(chunk instanceof Uint8Array)) throw new InvalidChunkTypeError({
+					key: c.key,
+					chunk
+				});
+				chunks.push(_classPrivateFieldGet2(_clone, this).call(this, chunk));
+			}
+		});
+	}
+	getReadable(c) {
+		if (!_classPrivateFieldGet2(_map, this).has(c.key)) throw new KeyNotFoundError$1({ key: c.key });
+		const value = _classPrivateFieldGet2(_map, this).get(c.key);
+		return new ReadableStream({ pull: (controller) => {
+			if (!(value instanceof Uint8Array)) throw new InvalidChunkTypeError({
+				key: c.key,
+				chunk: value
+			});
+			controller.enqueue(_classPrivateFieldGet2(_clone, this).call(this, value));
+			controller.close();
+		} });
+	}
+};
+//#endregion
+export { InvalidChunkTypeError, KeyNotFoundError, Memory };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["KeyNotFoundError"],"sources":["../src/errors.ts","../src/memory.ts"],"sourcesContent":["import { type ErrorOptions, ErrorBase, setErrorMessage } from \"@unikvs/core\";\nimport getTypeName from \"type-name\";\n\nexport type { KeyNotFoundErrorArgs, KeyNotFoundErrorMeta } from \"@unikvs/core\";\nexport { KeyNotFoundError } from \"@unikvs/core\";\n\n/**\n * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-error)\n */\nexport type InvalidChunkTypeErrorMeta = {\n  /**\n   * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-key)\n   */\n  readonly key: string;\n\n  /**\n   * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-chunk)\n   */\n  readonly chunk: unknown;\n\n  /**\n   * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-chunk-type)\n   */\n  readonly chunkType: string;\n};\n\n/**\n * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-error)\n */\nexport type InvalidChunkTypeErrorArgs = ErrorOptions & Omit<InvalidChunkTypeErrorMeta, \"chunkType\">;\n\n/**\n * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-error)\n */\nexport class InvalidChunkTypeError extends ErrorBase<InvalidChunkTypeErrorMeta> {\n  static {\n    this.prototype.name = \"MemoryInvalidChunkTypeError\";\n  }\n\n  /**\n   * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-error)\n   */\n  public constructor(args: InvalidChunkTypeErrorArgs) {\n    const { key, chunk, ...options } = args;\n    const meta: InvalidChunkTypeErrorMeta = {\n      key,\n      chunk,\n      chunkType: getTypeName(chunk),\n    };\n    super(\n      meta,\n      ({ key: messageKey, chunkType }) =>\n        `Expected chunk for key ${JSON.stringify(messageKey)} is Uint8Array<ArrayBuffer>, but got ${chunkType}`,\n      options,\n    );\n  }\n}\n\nsetErrorMessage(\n  InvalidChunkTypeError,\n  ({ key: messageKey, chunkType }) =>\n    `キー ${JSON.stringify(messageKey)} のチャンク型に Uint8Array<ArrayBuffer> を期待しましたが、${chunkType} を得ました`,\n  \"ja\",\n);\n","import { type IStorage, KeyNotFoundError } from \"@unikvs/core\";\n\nimport { InvalidChunkTypeError } from \"./errors.js\";\n\n/**\n * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#usage)\n */\nexport type MemoryOptions = {\n  /**\n   * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#clone)\n   */\n  readonly clone?: (<T>(value: T) => T) | undefined;\n};\n\n/**\n * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#usage)\n */\nexport default class Memory implements IStorage {\n  /**\n   * キーと値のペアを保持する内部マップです。\n   */\n  readonly #map: Map<string, any>;\n\n  public readonly name: string;\n\n  /**\n   * データの複製に使用する関数です。\n   */\n  readonly #clone: <T>(value: T) => T;\n\n  /**\n   * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#usage)\n   */\n  public constructor(options: MemoryOptions = {}) {\n    const { clone = <T>(value: T): T => structuredClone(value) } = options;\n\n    this.name = \"Memory\";\n    this.#map = new Map();\n    this.#clone = clone;\n  }\n\n  public get isOpen(): boolean {\n    return true;\n  }\n\n  public write(c: IStorage.WriteContext, data: any): void {\n    this.#map.set(c.key, this.#clone(data));\n  }\n\n  public read(c: IStorage.ReadContext): any {\n    if (!this.#map.has(c.key)) {\n      throw new KeyNotFoundError({ key: c.key });\n    }\n\n    const value = this.#map.get(c.key);\n\n    return this.#clone(value);\n  }\n\n  public exists(c: IStorage.ExistsContext): boolean {\n    const exists = this.#map.has(c.key);\n\n    return exists;\n  }\n\n  public delete(c: IStorage.DeleteContext): void {\n    if (!this.#map.has(c.key)) {\n      throw new KeyNotFoundError({ key: c.key });\n    }\n\n    this.#map.delete(c.key);\n  }\n\n  public clear(_c: IStorage.ClearContext): void {\n    this.#map.clear();\n  }\n\n  public getWritable(c: IStorage.GetWritableContext): WritableStream<Uint8Array<ArrayBuffer>> {\n    // メモリーストレージにはネイティブなストリームがないため、書き込まれたチャンクを配列に保持し、クローズ時に結合して保存します。\n    const chunks: Uint8Array[] = [];\n    const stream = new WritableStream<Uint8Array<ArrayBuffer>>({\n      close: (): void => {\n        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);\n        const merged = new Uint8Array(totalLength);\n\n        let offset = 0;\n\n        for (const chunk of chunks) {\n          merged.set(chunk, offset);\n          offset += chunk.byteLength;\n        }\n\n        this.#map.set(c.key, merged);\n      },\n      write: (chunk): void => {\n        if (!(chunk instanceof Uint8Array)) {\n          throw new InvalidChunkTypeError({\n            key: c.key,\n            chunk,\n          });\n        }\n\n        chunks.push(this.#clone(chunk));\n      },\n    });\n\n    return stream;\n  }\n\n  public getReadable(c: IStorage.GetReadableContext): ReadableStream<Uint8Array<ArrayBuffer>> {\n    if (!this.#map.has(c.key)) {\n      throw new KeyNotFoundError({ key: c.key });\n    }\n\n    // メモリーストレージにはネイティブなストリームがないため、既存の値を単一チャンクとしてストリームで送出します。\n    const value = this.#map.get(c.key);\n    const stream = new ReadableStream<Uint8Array<ArrayBuffer>>({\n      pull: (controller): void => {\n        if (!(value instanceof Uint8Array)) {\n          throw new InvalidChunkTypeError({\n            key: c.key,\n            chunk: value,\n          });\n        }\n\n        controller.enqueue(this.#clone(value) as Uint8Array<ArrayBuffer>);\n        controller.close();\n      },\n    });\n\n    return stream;\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,49 +1,47 @@
 {
   "name": "@unikvs/memory",
-  "version": "0.0.10",
-  "description": "",
-  "homepage": "https://github.com/tai-kun/unikvs",
+  "version": "0.0.13",
+  "description": "Storage plugin that stores arbitrary data in memory.",
+  "homepage": "https://tai-kun.github.io/unikvs/",
   "license": "MIT",
-  "author": "tai-kun",
   "repository": {
-    "url": "https://github.com/tai-kun/unikvs"
+    "url": "https://github.com/tai-kun/unikvs",
+    "directory": "packages/memory"
   },
   "files": [
     "dist",
     "src",
     "package.json",
-    "LICENSE"
+    "LICENSE",
+    "README.md"
   ],
   "type": "module",
   "sideEffects": false,
-  "main": "./dist/src/index.js",
-  "types": "./dist/src/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "default": "./dist/src/index.js"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     }
   },
   "dependencies": {
-    "@unikvs/core": "0.0.10",
-    "type-name": "2.0.2"
+    "@unikvs/core": "0.0.13",
+    "type-name": "^2.0.2"
   },
   "devDependencies": {
-    "@tsconfig/node24": "24.0.5",
-    "@tsconfig/strictest": "2.0.8",
-    "@types/node": "24.13.3",
     "@types/type-name": "1.0.32",
-    "@vitest/browser": "4.1.10",
-    "@vitest/browser-playwright": "4.1.10",
-    "npm-check-updates": "20.0.2",
-    "playwright": "1.62.1",
-    "vite": "8.2.1",
-    "vitest": "4.1.10"
+    "@unikvs/testing": "0.0.0",
+    "@vitest/browser-playwright": "5.0.5",
+    "@vitest/coverage-istanbul": "5.0.5",
+    "@vitest/coverage-v8": "5.0.5",
+    "playwright": "1.64.1",
+    "valibot": "1.5.0",
+    "vite-plus": "1.3.0"
   },
   "peerDependencies": {
-    "@logtape/logtape": "2.0.0"
+    "@logtape/logtape": "^2.0.0"
   },
+  "readme": "README.md",
   "scripts": {
-    "build": "tsc --project ./.config/tsconfig.build.json"
+    "build": "vp -C .config pack"
   }
 }

package/src/errors.ts

@@ -1,75 +1,36 @@
-import { ErrorBase, type ErrorOptions, setErrorMessage } from "@unikvs/core";
+import { type ErrorOptions, ErrorBase, setErrorMessage } from "@unikvs/core";
 import getTypeName from "type-name";
 
-/**
- * 指定されたキーがストレージ内に存在しないことを示すエラーメタデータ型です。
- */
-export type KeyNotFoundErrorMeta = {
-  /**
-   * 存在しなかったキーです。
-   */
-  readonly key: string;
-};
-
-/**
- * {@link KeyNotFoundError} のコンストラクター引数型です。
- *
- * エラーの追加情報 (`cause`) も含みます。
- */
-export type KeyNotFoundErrorArgs = ErrorOptions & KeyNotFoundErrorMeta;
-
-/**
- * 読み取りまたは削除を実行しようとしたキーがストレージ内に存在しない場合に投げられるエラーです。
- */
-export class KeyNotFoundError extends ErrorBase<KeyNotFoundErrorMeta> {
-  static {
-    this.prototype.name = "MemoryKeyNotFoundError";
-  }
-
-  /**
-   * KeyNotFoundError インスタンスを初期化します。
-   *
-   * @param args エラーメタデータとエラーの追加情報です。
-   */
-  public constructor(args: KeyNotFoundErrorArgs) {
-    const { key, ...options } = args;
-    const meta: KeyNotFoundErrorMeta = { key };
-    super(meta, ({ key }) => `Key not found: ${key}`, options);
-  }
-}
-
-setErrorMessage(KeyNotFoundError, ({ key }) => `キー ${key} が見つかりません`, "ja");
+export type { KeyNotFoundErrorArgs, KeyNotFoundErrorMeta } from "@unikvs/core";
+export { KeyNotFoundError } from "@unikvs/core";
 
 /**
- * ストリーム書き込み時に無効なチャンク型が渡されたことを示すエラーメタデータ型です。
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-error)
  */
 export type InvalidChunkTypeErrorMeta = {
   /**
-   * 書き込み先または読み取り元のキーです。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-key)
    */
   readonly key: string;
 
   /**
-   * 型が無効だったチャンクの値です。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-chunk)
    */
   readonly chunk: unknown;
 
   /**
-   * 実際に渡されたチャンク値の型名です。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-chunk-type)
    */
   readonly chunkType: string;
 };
 
 /**
- * {@link InvalidChunkTypeError} のコンストラクター引数型です。
- *
- * `chunkType` はコンストラクター内部で自動的に設定されるため、引数からは除外されています。
- * また、エラーの追加情報 (`cause`) も含みます。
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-error)
  */
 export type InvalidChunkTypeErrorArgs = ErrorOptions & Omit<InvalidChunkTypeErrorMeta, "chunkType">;
 
 /**
- * `getWritable` が返すストリームに `Uint8Array<ArrayBuffer>` 以外の値が書き込まれた場合に投げられるエラーです。
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-error)
  */
 export class InvalidChunkTypeError extends ErrorBase<InvalidChunkTypeErrorMeta> {
   static {
@@ -77,17 +38,19 @@ export class InvalidChunkTypeError extends ErrorBase<InvalidChunkTypeErrorMeta>
   }
 
   /**
-   * InvalidChunkTypeError インスタンスを初期化します。
-   *
-   * @param args エラーメタデータとエラーの追加情報です。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#invalid-chunk-type-error)
    */
   public constructor(args: InvalidChunkTypeErrorArgs) {
     const { key, chunk, ...options } = args;
-    const meta: InvalidChunkTypeErrorMeta = { key, chunk, chunkType: getTypeName(chunk) };
+    const meta: InvalidChunkTypeErrorMeta = {
+      key,
+      chunk,
+      chunkType: getTypeName(chunk),
+    };
     super(
       meta,
-      ({ key, chunkType }) =>
-        `Expected chunk for key ${JSON.stringify(key)} is Uint8Array<ArrayBuffer>, but got ${chunkType}`,
+      ({ key: messageKey, chunkType }) =>
+        `Expected chunk for key ${JSON.stringify(messageKey)} is Uint8Array<ArrayBuffer>, but got ${chunkType}`,
       options,
     );
   }
@@ -95,7 +58,7 @@ export class InvalidChunkTypeError extends ErrorBase<InvalidChunkTypeErrorMeta>
 
 setErrorMessage(
   InvalidChunkTypeError,
-  ({ key, chunkType }) =>
-    `キー ${JSON.stringify(key)} のチャンク型に Uint8Array<ArrayBuffer> を期待しましたが、${chunkType} を得ました`,
+  ({ key: messageKey, chunkType }) =>
+    `キー ${JSON.stringify(messageKey)} のチャンク型に Uint8Array<ArrayBuffer> を期待しましたが、${chunkType} を得ました`,
   "ja",
 );

package/src/index.ts

@@ -1,8 +1,8 @@
 export type {
-  KeyNotFoundErrorMeta,
   KeyNotFoundErrorArgs,
-  InvalidChunkTypeErrorMeta,
+  KeyNotFoundErrorMeta,
   InvalidChunkTypeErrorArgs,
+  InvalidChunkTypeErrorMeta,
 } from "./errors.js";
 export { KeyNotFoundError, InvalidChunkTypeError } from "./errors.js";
 

package/src/memory.ts

@@ -1,170 +1,129 @@
-import type { IStorage } from "@unikvs/core";
+import { type IStorage, KeyNotFoundError } from "@unikvs/core";
 
-import { KeyNotFoundError, InvalidChunkTypeError } from "./errors.js";
+import { InvalidChunkTypeError } from "./errors.js";
 
 /**
- * メモリーを永続化先として使用するストレージクラスです。
- *
- * アプリケーションの実行中のみデータを保持し、プロセス終了時に破棄されます。
- * 全ての操作が同期で完了するため、非同期処理のオーバーヘッドがありません。
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#usage)
+ */
+export type MemoryOptions = {
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#clone)
+   */
+  readonly clone?: (<T>(value: T) => T) | undefined;
+};
+
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#usage)
  */
 export default class Memory implements IStorage {
   /**
    * キーと値のペアを保持する内部マップです。
    */
-  private readonly map: Map<string, any>;
+  readonly #map: Map<string, any>;
+
+  public readonly name: string;
 
   /**
-   * ストレージの名前です。デバッグやエラーメッセージなどに使用されます。
+   * データの複製に使用する関数です。
    */
-  public readonly name: string;
+  readonly #clone: <T>(value: T) => T;
 
   /**
-   * Memory インスタンスを初期化します。
-   *
-   * 内部のマップを初期化し、常にオープン状態として動作します。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/memory#usage)
    */
-  public constructor() {
+  public constructor(options: MemoryOptions = {}) {
+    const { clone = <T>(value: T): T => structuredClone(value) } = options;
+
     this.name = "Memory";
-    this.map = new Map();
+    this.#map = new Map();
+    this.#clone = clone;
   }
 
-  /**
-   * メモリーストレージは常に利用可能なため、常に `true` を返します。
-   */
   public get isOpen(): boolean {
     return true;
   }
 
-  /**
-   * 指定されたデータを、対応するキーでストレージに保存します。
-   *
-   * @param args.key 保存先のキーです。
-   * @param args.data 保存するデータです。
-   */
-  public write(args: Pick<IStorage.WriteArgs<any>, "key" | "data">): void {
-    const { key, data } = args;
-    this.map.set(key, data);
+  public write(c: IStorage.WriteContext, data: any): void {
+    this.#map.set(c.key, this.#clone(data));
   }
 
-  /**
-   * 指定されたキーに対応するデータをストレージから取得します。
-   *
-   * @param args.key 取得元のキーです。
-   * @returns キーに対応するデータです。
-   * @throws キーがストレージ内に存在しない場合に {@link KeyNotFoundError} を投げます。
-   */
-  public read(args: Pick<IStorage.ReadArgs, "key">): any {
-    const { key } = args;
-    if (!this.map.has(key)) {
-      throw new KeyNotFoundError({ key });
+  public read(c: IStorage.ReadContext): any {
+    if (!this.#map.has(c.key)) {
+      throw new KeyNotFoundError({ key: c.key });
     }
 
-    const value = this.map.get(key);
+    const value = this.#map.get(c.key);
 
-    return value;
+    return this.#clone(value);
   }
 
-  /**
-   * 指定されたキーに対応するデータがストレージ内に存在するかを確認します。
-   *
-   * @param args.key 確認するキーです。
-   * @returns キーに対応するデータが存在する場合は true、それ以外は false です。
-   */
-  public exists(args: Pick<IStorage.ExistsArgs, "key">): boolean {
-    const { key } = args;
-    const exists = this.map.has(key);
+  public exists(c: IStorage.ExistsContext): boolean {
+    const exists = this.#map.has(c.key);
 
     return exists;
   }
 
-  /**
-   * 指定されたキーに対応するデータをストレージから削除します。
-   *
-   * @param args.key 削除するキーです。
-   * @throws キーがストレージ内に存在しない場合に {@link KeyNotFoundError} を投げます。
-   */
-  public delete(args: Pick<IStorage.DeleteArgs, "key">): void {
-    const { key } = args;
-    if (!this.map.has(key)) {
-      throw new KeyNotFoundError({ key });
+  public delete(c: IStorage.DeleteContext): void {
+    if (!this.#map.has(c.key)) {
+      throw new KeyNotFoundError({ key: c.key });
     }
 
-    this.map.delete(key);
+    this.#map.delete(c.key);
   }
 
-  /**
-   * ストレージ内のすべてのデータを完全に消去します。
-   */
-  public clear(): void {
-    this.map.clear();
+  public clear(_c: IStorage.ClearContext): void {
+    this.#map.clear();
   }
 
-  /**
-   * 指定されたキーに対応する書き込み可能なストリームを取得します。
-   *
-   * メモリーストレージにはネイティブなストリームがないため、書き込まれたチャンクをメモリー上に保持し、ストリームがクローズされたときに結合して保存します。
-   *
-   * @param args.key 書き込み先のキーです。
-   * @returns 書き込み可能なストリームです。
-   */
-  public getWritable(
-    args: Pick<IStorage.GetWritableArgs, "key">,
-  ): WritableStream<Uint8Array<ArrayBuffer>> {
-    const { key } = args;
+  public getWritable(c: IStorage.GetWritableContext): WritableStream<Uint8Array<ArrayBuffer>> {
     // メモリーストレージにはネイティブなストリームがないため、書き込まれたチャンクを配列に保持し、クローズ時に結合して保存します。
     const chunks: Uint8Array[] = [];
     const stream = new WritableStream<Uint8Array<ArrayBuffer>>({
-      write: (chunk) => {
-        if (!(chunk instanceof Uint8Array)) {
-          throw new InvalidChunkTypeError({ key, chunk });
-        }
-
-        chunks.push(chunk);
-      },
-      close: () => {
-        const totalLength = chunks.reduce((sum, c) => sum + c.byteLength, 0);
+      close: (): void => {
+        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
         const merged = new Uint8Array(totalLength);
 
         let offset = 0;
-        for (const c of chunks) {
-          merged.set(c, offset);
-          offset += c.byteLength;
+
+        for (const chunk of chunks) {
+          merged.set(chunk, offset);
+          offset += chunk.byteLength;
+        }
+
+        this.#map.set(c.key, merged);
+      },
+      write: (chunk): void => {
+        if (!(chunk instanceof Uint8Array)) {
+          throw new InvalidChunkTypeError({
+            key: c.key,
+            chunk,
+          });
         }
 
-        this.map.set(key, merged);
+        chunks.push(this.#clone(chunk));
       },
     });
 
     return stream;
   }
 
-  /**
-   * 指定されたキーに対応する読み取り可能なストリームを取得します。
-   *
-   * メモリーストレージにはネイティブなストリームがないため、既存の値を単一チャンクとしてストリームで送出します。
-   *
-   * @param args.key 読み取り元のキーです。
-   * @returns 読み取り可能なストリームです。
-   * @throws キーがストレージ内に存在しない場合に {@link KeyNotFoundError} を投げます。
-   */
-  public getReadable(
-    args: Pick<IStorage.GetReadableArgs, "key">,
-  ): ReadableStream<Uint8Array<ArrayBuffer>> {
-    const { key } = args;
-    if (!this.map.has(key)) {
-      throw new KeyNotFoundError({ key });
+  public getReadable(c: IStorage.GetReadableContext): ReadableStream<Uint8Array<ArrayBuffer>> {
+    if (!this.#map.has(c.key)) {
+      throw new KeyNotFoundError({ key: c.key });
     }
 
     // メモリーストレージにはネイティブなストリームがないため、既存の値を単一チャンクとしてストリームで送出します。
-    const value = this.map.get(key);
+    const value = this.#map.get(c.key);
     const stream = new ReadableStream<Uint8Array<ArrayBuffer>>({
-      pull: (controller) => {
+      pull: (controller): void => {
         if (!(value instanceof Uint8Array)) {
-          throw new InvalidChunkTypeError({ key, chunk: value });
+          throw new InvalidChunkTypeError({
+            key: c.key,
+            chunk: value,
+          });
         }
 
-        controller.enqueue(value as Uint8Array<ArrayBuffer>);
+        controller.enqueue(this.#clone(value) as Uint8Array<ArrayBuffer>);
         controller.close();
       },
     });

package/dist/src/errors.d.ts

@@ -1,63 +0,0 @@
-import { ErrorBase, type ErrorOptions } from "@unikvs/core";
-/**
- * 指定されたキーがストレージ内に存在しないことを示すエラーメタデータ型です。
- */
-export type KeyNotFoundErrorMeta = {
-    /**
-     * 存在しなかったキーです。
-     */
-    readonly key: string;
-};
-/**
- * {@link KeyNotFoundError} のコンストラクター引数型です。
- *
- * エラーの追加情報 (`cause`) も含みます。
- */
-export type KeyNotFoundErrorArgs = ErrorOptions & KeyNotFoundErrorMeta;
-/**
- * 読み取りまたは削除を実行しようとしたキーがストレージ内に存在しない場合に投げられるエラーです。
- */
-export declare class KeyNotFoundError extends ErrorBase<KeyNotFoundErrorMeta> {
-    /**
-     * KeyNotFoundError インスタンスを初期化します。
-     *
-     * @param args エラーメタデータとエラーの追加情報です。
-     */
-    constructor(args: KeyNotFoundErrorArgs);
-}
-/**
- * ストリーム書き込み時に無効なチャンク型が渡されたことを示すエラーメタデータ型です。
- */
-export type InvalidChunkTypeErrorMeta = {
-    /**
-     * 書き込み先または読み取り元のキーです。
-     */
-    readonly key: string;
-    /**
-     * 型が無効だったチャンクの値です。
-     */
-    readonly chunk: unknown;
-    /**
-     * 実際に渡されたチャンク値の型名です。
-     */
-    readonly chunkType: string;
-};
-/**
- * {@link InvalidChunkTypeError} のコンストラクター引数型です。
- *
- * `chunkType` はコンストラクター内部で自動的に設定されるため、引数からは除外されています。
- * また、エラーの追加情報 (`cause`) も含みます。
- */
-export type InvalidChunkTypeErrorArgs = ErrorOptions & Omit<InvalidChunkTypeErrorMeta, "chunkType">;
-/**
- * `getWritable` が返すストリームに `Uint8Array<ArrayBuffer>` 以外の値が書き込まれた場合に投げられるエラーです。
- */
-export declare class InvalidChunkTypeError extends ErrorBase<InvalidChunkTypeErrorMeta> {
-    /**
-     * InvalidChunkTypeError インスタンスを初期化します。
-     *
-     * @param args エラーメタデータとエラーの追加情報です。
-     */
-    constructor(args: InvalidChunkTypeErrorArgs);
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/src/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,YAAY,EAAmB,MAAM,cAAc,CAAC;AAG7E;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,YAAY,GAAG,oBAAoB,CAAC;AAEvE;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,SAAS,CAAC,oBAAoB,CAAC;IAKnE;;;;OAIG;IACH,YAAmB,IAAI,EAAE,oBAAoB,EAI5C;CACF;AAID;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IAExB;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,yBAAyB,GAAG,YAAY,GAAG,IAAI,CAAC,yBAAyB,EAAE,WAAW,CAAC,CAAC;AAEpG;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,SAAS,CAAC,yBAAyB,CAAC;IAK7E;;;;OAIG;IACH,YAAmB,IAAI,EAAE,yBAAyB,EASjD;CACF"}

package/dist/src/errors.js

@@ -1,43 +0,0 @@
-var _a, _b;
-import { ErrorBase, setErrorMessage } from "@unikvs/core";
-import getTypeName from "type-name";
-/**
- * 読み取りまたは削除を実行しようとしたキーがストレージ内に存在しない場合に投げられるエラーです。
- */
-export class KeyNotFoundError extends ErrorBase {
-    /**
-     * KeyNotFoundError インスタンスを初期化します。
-     *
-     * @param args エラーメタデータとエラーの追加情報です。
-     */
-    constructor(args) {
-        const { key, ...options } = args;
-        const meta = { key };
-        super(meta, ({ key }) => `Key not found: ${key}`, options);
-    }
-}
-_a = KeyNotFoundError;
-(() => {
-    _a.prototype.name = "MemoryKeyNotFoundError";
-})();
-setErrorMessage(KeyNotFoundError, ({ key }) => `キー ${key} が見つかりません`, "ja");
-/**
- * `getWritable` が返すストリームに `Uint8Array<ArrayBuffer>` 以外の値が書き込まれた場合に投げられるエラーです。
- */
-export class InvalidChunkTypeError extends ErrorBase {
-    /**
-     * InvalidChunkTypeError インスタンスを初期化します。
-     *
-     * @param args エラーメタデータとエラーの追加情報です。
-     */
-    constructor(args) {
-        const { key, chunk, ...options } = args;
-        const meta = { key, chunk, chunkType: getTypeName(chunk) };
-        super(meta, ({ key, chunkType }) => `Expected chunk for key ${JSON.stringify(key)} is Uint8Array<ArrayBuffer>, but got ${chunkType}`, options);
-    }
-}
-_b = InvalidChunkTypeError;
-(() => {
-    _b.prototype.name = "MemoryInvalidChunkTypeError";
-})();
-setErrorMessage(InvalidChunkTypeError, ({ key, chunkType }) => `キー ${JSON.stringify(key)} のチャンク型に Uint8Array<ArrayBuffer> を期待しましたが、${chunkType} を得ました`, "ja");

package/dist/src/index.d.ts

@@ -1,5 +0,0 @@
-export type { KeyNotFoundErrorMeta, KeyNotFoundErrorArgs, InvalidChunkTypeErrorMeta, InvalidChunkTypeErrorArgs, } from "./errors.js";
-export { KeyNotFoundError, InvalidChunkTypeError } from "./errors.js";
-export type * from "./memory.js";
-export { default as Memory } from "./memory.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,oBAAoB,EACpB,oBAAoB,EACpB,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEtE,mBAAmB,aAAa,CAAC;AACjC,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,aAAa,CAAC"}

package/dist/src/index.js

@@ -1,2 +0,0 @@
-export { KeyNotFoundError, InvalidChunkTypeError } from "./errors.js";
-export { default as Memory } from "./memory.js";

package/dist/src/memory.d.ts

@@ -1,80 +0,0 @@
-import type { IStorage } from "@unikvs/core";
-/**
- * メモリーを永続化先として使用するストレージクラスです。
- *
- * アプリケーションの実行中のみデータを保持し、プロセス終了時に破棄されます。
- * 全ての操作が同期で完了するため、非同期処理のオーバーヘッドがありません。
- */
-export default class Memory implements IStorage {
-    /**
-     * キーと値のペアを保持する内部マップです。
-     */
-    private readonly map;
-    /**
-     * ストレージの名前です。デバッグやエラーメッセージなどに使用されます。
-     */
-    readonly name: string;
-    /**
-     * Memory インスタンスを初期化します。
-     *
-     * 内部のマップを初期化し、常にオープン状態として動作します。
-     */
-    constructor();
-    /**
-     * メモリーストレージは常に利用可能なため、常に `true` を返します。
-     */
-    get isOpen(): boolean;
-    /**
-     * 指定されたデータを、対応するキーでストレージに保存します。
-     *
-     * @param args.key 保存先のキーです。
-     * @param args.data 保存するデータです。
-     */
-    write(args: Pick<IStorage.WriteArgs<any>, "key" | "data">): void;
-    /**
-     * 指定されたキーに対応するデータをストレージから取得します。
-     *
-     * @param args.key 取得元のキーです。
-     * @returns キーに対応するデータです。
-     * @throws キーがストレージ内に存在しない場合に {@link KeyNotFoundError} を投げます。
-     */
-    read(args: Pick<IStorage.ReadArgs, "key">): any;
-    /**
-     * 指定されたキーに対応するデータがストレージ内に存在するかを確認します。
-     *
-     * @param args.key 確認するキーです。
-     * @returns キーに対応するデータが存在する場合は true、それ以外は false です。
-     */
-    exists(args: Pick<IStorage.ExistsArgs, "key">): boolean;
-    /**
-     * 指定されたキーに対応するデータをストレージから削除します。
-     *
-     * @param args.key 削除するキーです。
-     * @throws キーがストレージ内に存在しない場合に {@link KeyNotFoundError} を投げます。
-     */
-    delete(args: Pick<IStorage.DeleteArgs, "key">): void;
-    /**
-     * ストレージ内のすべてのデータを完全に消去します。
-     */
-    clear(): void;
-    /**
-     * 指定されたキーに対応する書き込み可能なストリームを取得します。
-     *
-     * メモリーストレージにはネイティブなストリームがないため、書き込まれたチャンクをメモリー上に保持し、ストリームがクローズされたときに結合して保存します。
-     *
-     * @param args.key 書き込み先のキーです。
-     * @returns 書き込み可能なストリームです。
-     */
-    getWritable(args: Pick<IStorage.GetWritableArgs, "key">): WritableStream<Uint8Array<ArrayBuffer>>;
-    /**
-     * 指定されたキーに対応する読み取り可能なストリームを取得します。
-     *
-     * メモリーストレージにはネイティブなストリームがないため、既存の値を単一チャンクとしてストリームで送出します。
-     *
-     * @param args.key 読み取り元のキーです。
-     * @returns 読み取り可能なストリームです。
-     * @throws キーがストレージ内に存在しない場合に {@link KeyNotFoundError} を投げます。
-     */
-    getReadable(args: Pick<IStorage.GetReadableArgs, "key">): ReadableStream<Uint8Array<ArrayBuffer>>;
-}
-//# sourceMappingURL=memory.d.ts.map

package/dist/src/memory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAI7C;;;;;GAKG;AACH,MAAM,CAAC,OAAO,OAAO,MAAO,YAAW,QAAQ;IAC7C;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAmB;IAEvC;;OAEG;IACH,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B;;;;OAIG;IACH,cAGC;IAED;;OAEG;IACH,IAAW,MAAM,IAAI,OAAO,CAE3B;IAED;;;;;OAKG;IACI,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,GAAG,IAAI,CAGtE;IAED;;;;;;OAMG;IACI,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,GAAG,CASrD;IAED;;;;;OAKG;IACI,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC,GAAG,OAAO,CAK7D;IAED;;;;;OAKG;IACI,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC,GAAG,IAAI,CAO1D;IAED;;OAEG;IACI,KAAK,IAAI,IAAI,CAEnB;IAED;;;;;;;OAOG;IACI,WAAW,CAChB,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,KAAK,CAAC,GAC1C,cAAc,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CA2BzC;IAED;;;;;;;;OAQG;IACI,WAAW,CAChB,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,KAAK,CAAC,GAC1C,cAAc,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAoBzC;CACF"}

package/dist/src/memory.js

@@ -1,138 +0,0 @@
-import { KeyNotFoundError, InvalidChunkTypeError } from "./errors.js";
-/**
- * メモリーを永続化先として使用するストレージクラスです。
- *
- * アプリケーションの実行中のみデータを保持し、プロセス終了時に破棄されます。
- * 全ての操作が同期で完了するため、非同期処理のオーバーヘッドがありません。
- */
-export default class Memory {
-    /**
-     * Memory インスタンスを初期化します。
-     *
-     * 内部のマップを初期化し、常にオープン状態として動作します。
-     */
-    constructor() {
-        this.name = "Memory";
-        this.map = new Map();
-    }
-    /**
-     * メモリーストレージは常に利用可能なため、常に `true` を返します。
-     */
-    get isOpen() {
-        return true;
-    }
-    /**
-     * 指定されたデータを、対応するキーでストレージに保存します。
-     *
-     * @param args.key 保存先のキーです。
-     * @param args.data 保存するデータです。
-     */
-    write(args) {
-        const { key, data } = args;
-        this.map.set(key, data);
-    }
-    /**
-     * 指定されたキーに対応するデータをストレージから取得します。
-     *
-     * @param args.key 取得元のキーです。
-     * @returns キーに対応するデータです。
-     * @throws キーがストレージ内に存在しない場合に {@link KeyNotFoundError} を投げます。
-     */
-    read(args) {
-        const { key } = args;
-        if (!this.map.has(key)) {
-            throw new KeyNotFoundError({ key });
-        }
-        const value = this.map.get(key);
-        return value;
-    }
-    /**
-     * 指定されたキーに対応するデータがストレージ内に存在するかを確認します。
-     *
-     * @param args.key 確認するキーです。
-     * @returns キーに対応するデータが存在する場合は true、それ以外は false です。
-     */
-    exists(args) {
-        const { key } = args;
-        const exists = this.map.has(key);
-        return exists;
-    }
-    /**
-     * 指定されたキーに対応するデータをストレージから削除します。
-     *
-     * @param args.key 削除するキーです。
-     * @throws キーがストレージ内に存在しない場合に {@link KeyNotFoundError} を投げます。
-     */
-    delete(args) {
-        const { key } = args;
-        if (!this.map.has(key)) {
-            throw new KeyNotFoundError({ key });
-        }
-        this.map.delete(key);
-    }
-    /**
-     * ストレージ内のすべてのデータを完全に消去します。
-     */
-    clear() {
-        this.map.clear();
-    }
-    /**
-     * 指定されたキーに対応する書き込み可能なストリームを取得します。
-     *
-     * メモリーストレージにはネイティブなストリームがないため、書き込まれたチャンクをメモリー上に保持し、ストリームがクローズされたときに結合して保存します。
-     *
-     * @param args.key 書き込み先のキーです。
-     * @returns 書き込み可能なストリームです。
-     */
-    getWritable(args) {
-        const { key } = args;
-        // メモリーストレージにはネイティブなストリームがないため、書き込まれたチャンクを配列に保持し、クローズ時に結合して保存します。
-        const chunks = [];
-        const stream = new WritableStream({
-            write: (chunk) => {
-                if (!(chunk instanceof Uint8Array)) {
-                    throw new InvalidChunkTypeError({ key, chunk });
-                }
-                chunks.push(chunk);
-            },
-            close: () => {
-                const totalLength = chunks.reduce((sum, c) => sum + c.byteLength, 0);
-                const merged = new Uint8Array(totalLength);
-                let offset = 0;
-                for (const c of chunks) {
-                    merged.set(c, offset);
-                    offset += c.byteLength;
-                }
-                this.map.set(key, merged);
-            },
-        });
-        return stream;
-    }
-    /**
-     * 指定されたキーに対応する読み取り可能なストリームを取得します。
-     *
-     * メモリーストレージにはネイティブなストリームがないため、既存の値を単一チャンクとしてストリームで送出します。
-     *
-     * @param args.key 読み取り元のキーです。
-     * @returns 読み取り可能なストリームです。
-     * @throws キーがストレージ内に存在しない場合に {@link KeyNotFoundError} を投げます。
-     */
-    getReadable(args) {
-        const { key } = args;
-        if (!this.map.has(key)) {
-            throw new KeyNotFoundError({ key });
-        }
-        // メモリーストレージにはネイティブなストリームがないため、既存の値を単一チャンクとしてストリームで送出します。
-        const value = this.map.get(key);
-        const stream = new ReadableStream({
-            pull: (controller) => {
-                if (!(value instanceof Uint8Array)) {
-                    throw new InvalidChunkTypeError({ key, chunk: value });
-                }
-                controller.enqueue(value);
-                controller.close();
-            },
-        });
-        return stream;
-    }
-}