unikvs 0.0.4 → 0.0.6

package/src/unikvs.ts

@@ -1,14 +1,13 @@
-import type { Context, IReadableStream, Key } from "@unikvs/core";
+import type { Context, IReadableStream, IStorage } from "@unikvs/core";
 import { asyncmux, Asyncmux, type AsyncmuxLock } from "asyncmux";
-import * as v from "valibot";
 
 import combineSignals from "./_combine-signals.js";
 import logger from "./_logger.js";
 import mergeContext from "./_merge-context.js";
-import { UniKvsStorage } from "./_storage.js";
+import UniKvsStorage from "./_storage.js";
 import toValueStream from "./_to-value-stream.js";
 import UniKvsTransformer from "./_transformer.js";
-import { parse } from "./_valibot.js";
+import * as v from "./_valibot.js";
 import type { ContextSource } from "./context.types.js";
 import {
   KeyNotFoundError,
@@ -68,39 +67,149 @@ export type KeyofKeyValueMappingHasStreamValue<TKeyValueMapping extends KeyValue
 
 // -------------------------------------------------------------------------------------------------
 //
-// 型定義
+// スキーマ
 //
 // -------------------------------------------------------------------------------------------------
 
-/**
- * オープン操作時のオプションです。
- */
-export type OpenOptions = {
+const ContextKeySchema = v.string();
+
+const ContextSourceSchema = v.union([
+  v.record(v.any(), v.unknown()),
+  v.array(v.tuple([ContextKeySchema, v.unknown()])),
+]);
+
+const OpenOptionsSchema = v.object({
   /**
    * 処理の中断を通知するためのシグナルです。
    */
-  readonly signal?: AbortSignal | undefined;
+  signal: v.optional(v.instance(AbortSignal)),
 
   /**
    * 実行時のコンテキスト情報です。
    */
-  readonly context?: ContextSource | undefined;
-};
+  context: v.optional(ContextSourceSchema),
+});
 
-/**
- * クローズ操作時のオプションです。
- */
-export type CloseOptions = {
+const OpenArgsSchema = v.tuple([v.optional(OpenOptionsSchema)]);
+
+const CloseOptionsSchema = v.object({
   /**
    * 処理の中断を通知するためのシグナルです。
    */
-  readonly signal?: AbortSignal | undefined;
+  signal: v.optional(v.instance(AbortSignal)),
 
   /**
    * 実行時のコンテキスト情報です。
    */
-  readonly context?: ContextSource | undefined;
-};
+  context: v.optional(ContextSourceSchema),
+});
+
+const CloseArgsSchema = v.tuple([v.optional(CloseOptionsSchema)]);
+
+const SetOptionsSchema = v.object({
+  key: v.string(),
+  value: v.unknown(),
+  signal: v.optional(v.instance(AbortSignal)),
+  context: v.optional(ContextSourceSchema),
+});
+
+const SetArgsSchema = v.union([
+  v.tuple([SetOptionsSchema]),
+  v.pipe(
+    v.tuple([
+      SetOptionsSchema.entries.key,
+      SetOptionsSchema.entries.value,
+      v.optional(v.omit(SetOptionsSchema, ["key", "value"])),
+    ]),
+    v.transform(([key, value, options]) => [{ ...options, key, value }]),
+  ),
+]);
+
+const GetOptionsSchema = v.object({
+  key: v.string(),
+  signal: v.optional(v.instance(AbortSignal)),
+  context: v.optional(ContextSourceSchema),
+});
+
+const GetArgsSchema = v.union([
+  v.tuple([GetOptionsSchema]),
+  v.pipe(
+    v.tuple([GetOptionsSchema.entries.key, v.optional(v.omit(GetOptionsSchema, ["key"]))]),
+    v.transform(([key, options]) => [{ ...options, key }]),
+  ),
+]);
+
+const StreamOptionsSchema = v.object({
+  key: v.string(),
+  signal: v.optional(v.instance(AbortSignal)),
+  context: v.optional(ContextSourceSchema),
+});
+
+const StreamArgsSchema = v.union([
+  v.tuple([StreamOptionsSchema]),
+  v.pipe(
+    v.tuple([StreamOptionsSchema.entries.key, v.optional(v.omit(StreamOptionsSchema, ["key"]))]),
+    v.transform(([key, options]) => [{ ...options, key }]),
+  ),
+]);
+
+const HasOptionsSchema = v.object({
+  key: v.string(),
+  signal: v.optional(v.instance(AbortSignal)),
+  context: v.optional(ContextSourceSchema),
+});
+
+const HasArgsSchema = v.union([
+  v.tuple([HasOptionsSchema]),
+  v.pipe(
+    v.tuple([HasOptionsSchema.entries.key, v.optional(v.omit(HasOptionsSchema, ["key"]))]),
+    v.transform(([key, options]) => [{ ...options, key }]),
+  ),
+]);
+
+const DeleteOptionsSchema = v.object({
+  key: v.string(),
+  signal: v.optional(v.instance(AbortSignal)),
+  context: v.optional(ContextSourceSchema),
+});
+
+const DeleteArgsSchema = v.union([
+  v.tuple([DeleteOptionsSchema]),
+  v.pipe(
+    v.tuple([DeleteOptionsSchema.entries.key, v.optional(v.omit(DeleteOptionsSchema, ["key"]))]),
+    v.transform(([key, options]) => [{ ...options, key }]),
+  ),
+]);
+
+const ClearOptionsSchema = v.object({
+  /**
+   * 処理の中断を通知するためのシグナルです。
+   */
+  signal: v.optional(v.instance(AbortSignal)),
+
+  /**
+   * 実行時のコンテキスト情報です。
+   */
+  context: v.optional(ContextSourceSchema),
+});
+
+const ClearArgsSchema = v.tuple([v.optional(ClearOptionsSchema)]);
+
+// -------------------------------------------------------------------------------------------------
+//
+// 型定義
+//
+// -------------------------------------------------------------------------------------------------
+
+/**
+ * オープン操作時のオプションです。
+ */
+export type OpenOptions = v.InferInput<typeof OpenOptionsSchema>;
+
+/**
+ * クローズ操作時のオプションです。
+ */
+export type CloseOptions = v.InferInput<typeof CloseOptionsSchema>;
 
 /**
  * 保存操作時のオプションです。
@@ -138,7 +247,7 @@ export type SetOptions<
  *
  * @template TKey 対象となるキーの型です。
  */
-export type GetOptions<TKey = Key> = {
+export type GetOptions<TKey = IStorage.Key> = {
   /**
    * 操作対象を識別するためのキーです。
    */
@@ -160,7 +269,7 @@ export type GetOptions<TKey = Key> = {
  *
  * @template TKey 対象となるキーの型です。
  */
-export type StreamOptions<TKey = Key> = {
+export type StreamOptions<TKey = IStorage.Key> = {
   /**
    * 操作対象を識別するためのキーです。
    */
@@ -182,7 +291,7 @@ export type StreamOptions<TKey = Key> = {
  *
  * @template TKey 対象となるキーの型です。
  */
-export type HasOptions<TKey = Key> = {
+export type HasOptions<TKey = IStorage.Key> = {
   /**
    * 操作対象を識別するためのキーです。
    */
@@ -204,7 +313,7 @@ export type HasOptions<TKey = Key> = {
  *
  * @template TKey 対象となるキーの型です。
  */
-export type DeleteOptions<TKey = Key> = {
+export type DeleteOptions<TKey = IStorage.Key> = {
   /**
    * 操作対象を識別するためのキーです。
    */
@@ -224,126 +333,7 @@ export type DeleteOptions<TKey = Key> = {
 /**
  * 全削除操作時のオプションです。
  */
-export type ClearOptions = {
-  /**
-   * 処理の中断を通知するためのシグナルです。
-   */
-  readonly signal?: AbortSignal | undefined;
-
-  /**
-   * 実行時のコンテキスト情報です。
-   */
-  readonly context?: ContextSource | undefined;
-};
-
-// -------------------------------------------------------------------------------------------------
-//
-// スキーマ
-//
-// -------------------------------------------------------------------------------------------------
-
-const ContextKeySchema = v.union([v.string(), v.symbol(), v.number()]);
-
-const ContextSourceSchema = v.union([
-  v.record(v.any(), v.unknown()),
-  v.array(v.tuple([ContextKeySchema, v.unknown()])),
-]);
-
-const OpenOptionsSchema = v.object({
-  signal: v.optional(v.instance(AbortSignal)),
-  context: v.optional(ContextSourceSchema),
-});
-
-const OpenArgsSchema = v.tuple([v.optional(OpenOptionsSchema)]);
-
-const CloseOptionsSchema = v.object({
-  signal: v.optional(v.instance(AbortSignal)),
-  context: v.optional(ContextSourceSchema),
-});
-
-const CloseArgsSchema = v.tuple([v.optional(CloseOptionsSchema)]);
-
-const SetOptionsSchema = v.object({
-  key: v.string(),
-  value: v.unknown(),
-  signal: v.optional(v.instance(AbortSignal)),
-  context: v.optional(ContextSourceSchema),
-});
-
-const SetArgsSchema = v.union([
-  v.tuple([SetOptionsSchema]),
-  v.pipe(
-    v.tuple([
-      SetOptionsSchema.entries.key,
-      SetOptionsSchema.entries.value,
-      v.optional(v.omit(SetOptionsSchema, ["key", "value"])),
-    ]),
-    v.transform(([key, value, options]) => [{ ...options, key, value }]),
-  ),
-]);
-
-const GetOptionsSchema = v.object({
-  key: v.string(),
-  signal: v.optional(v.instance(AbortSignal)),
-  context: v.optional(ContextSourceSchema),
-});
-
-const GetArgsSchema = v.union([
-  v.tuple([GetOptionsSchema]),
-  v.pipe(
-    v.tuple([GetOptionsSchema.entries.key, v.optional(v.omit(GetOptionsSchema, ["key"]))]),
-    v.transform(([key, options]) => [{ ...options, key }]),
-  ),
-]);
-
-const StreamOptionsSchema = v.object({
-  key: v.string(),
-  signal: v.optional(v.instance(AbortSignal)),
-  context: v.optional(ContextSourceSchema),
-});
-
-const StreamArgsSchema = v.union([
-  v.tuple([StreamOptionsSchema]),
-  v.pipe(
-    v.tuple([StreamOptionsSchema.entries.key, v.optional(v.omit(StreamOptionsSchema, ["key"]))]),
-    v.transform(([key, options]) => [{ ...options, key }]),
-  ),
-]);
-
-const HasOptionsSchema = v.object({
-  key: v.string(),
-  signal: v.optional(v.instance(AbortSignal)),
-  context: v.optional(ContextSourceSchema),
-});
-
-const HasArgsSchema = v.union([
-  v.tuple([HasOptionsSchema]),
-  v.pipe(
-    v.tuple([HasOptionsSchema.entries.key, v.optional(v.omit(HasOptionsSchema, ["key"]))]),
-    v.transform(([key, options]) => [{ ...options, key }]),
-  ),
-]);
-
-const DeleteOptionsSchema = v.object({
-  key: v.string(),
-  signal: v.optional(v.instance(AbortSignal)),
-  context: v.optional(ContextSourceSchema),
-});
-
-const DeleteArgsSchema = v.union([
-  v.tuple([DeleteOptionsSchema]),
-  v.pipe(
-    v.tuple([DeleteOptionsSchema.entries.key, v.optional(v.omit(DeleteOptionsSchema, ["key"]))]),
-    v.transform(([key, options]) => [{ ...options, key }]),
-  ),
-]);
-
-const ClearOptionsSchema = v.object({
-  signal: v.optional(v.instance(AbortSignal)),
-  context: v.optional(ContextSourceSchema),
-});
-
-const ClearArgsSchema = v.tuple([v.optional(ClearOptionsSchema)]);
+export type ClearOptions = v.InferInput<typeof ClearOptionsSchema>;
 
 // -------------------------------------------------------------------------------------------------
 //
@@ -359,7 +349,7 @@ const ioLockRegistry: FinalizationRegistry<AsyncmuxLock> | null =
     ? null
     : new FinalizationRegistry((lock) => {
         try {
-          lock.unlock();
+          lock.release();
         } catch {}
       });
 
@@ -370,12 +360,12 @@ type Connection = {
   /**
    * 接続全体を管理する AbortController です。
    */
-  readonly conAc: AbortController;
+  readonly ac: AbortController;
 
   /**
    * I/O の多重化を制御する Asyncmux インスタンスです。
    */
-  readonly ioMux: Asyncmux;
+  readonly io: Asyncmux;
 };
 
 /**
@@ -422,6 +412,8 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
    */
   #con: Connection | null;
 
+  readonly #acSet: Set<AbortController>;
+
   /**
    * 基本となる実行コンテキスト情報です。
    */
@@ -451,10 +443,8 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     transformers: readonly UniKvsTransformer[],
   ) {
     this.#con = null;
-    this.#context = {
-      ...context,
-      "unikvs:instance": this,
-    };
+    this.#acSet = new Set();
+    this.#context = { ...context };
     this.#destinations = destinations;
     this.#transformers = transformers;
   }
@@ -465,7 +455,7 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
    * @returns 利用可能である場合は true、そうでない場合は false を返します。
    */
   public get isOpen(): boolean {
-    return !!this.#con;
+    return this.#con !== null;
   }
 
   /**
@@ -477,134 +467,114 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   public open(options?: OpenOptions): Promise<void>;
 
   public async open(...args: any): Promise<void> {
-    if (this.#con) {
+    if (this.#con !== null) {
       throw new UniKvsIsOpenError();
     }
 
-    this.#con = {
-      conAc: new AbortController(),
-      ioMux: new Asyncmux(),
-    };
-    try {
-      const [options = {}] = parse(OpenArgsSchema, args);
-      const { signal: signalOption, context: contextOption } = options;
+    const [options = {}] = v.parseInput(OpenArgsSchema, args);
+    const { signal: signalOption, context: contextOption } = options;
 
-      const { conAc } = this.#con;
-      const signal = combineSignals([conAc.signal, signalOption]);
+    const ac = new AbortController();
+    const signal = combineSignals([ac.signal, signalOption]);
 
-      const context = mergeContext(this.#context, contextOption);
-      context["unikvs:action"] = "open";
+    const context = mergeContext(this.#context, contextOption);
+    context["unikvs:action"] = "open";
+
+    signal.throwIfAborted();
+
+    this.#acSet.add(ac);
+
+    const dispose: (() => Promise<void>)[] = [];
+
+    const lock = await asyncmux(this, signal);
+    try {
+      if (this.#con !== null) {
+        throw new UniKvsIsOpenError();
+      }
 
       const openFns: [() => Promise<void>, plugin: "storage" | "transformer"][] = [];
-      const dispose: (() => Promise<void>)[] = [];
-      const lock = await asyncmux(this, signal);
-      try {
-        // ロック待機中に接続状態が変更されていないか再確認します。
-        if (this.#con.conAc !== conAc) {
-          throw new UniKvsIsOpenError();
-        }
 
-        // 各ストレージのオープン処理をリストに追加します。
-        for (const storage of this.#destinations) {
-          openFns.push([
-            async () => {
-              await storage.open(context, signal);
+      // 各ストレージのオープン処理をリストに追加します。
+      for (const storage of this.#destinations) {
+        openFns.push([
+          async () => {
+            await storage.open(context, signal);
 
-              dispose.push(async () => {
-                try {
-                  await storage.close(context, signal);
-                } catch (ex) {
-                  logger.error`Failed to close storage: ${ex}`;
-                }
-              });
-            },
-            "storage",
-          ]);
-        }
+            dispose.push(async () => {
+              try {
+                await storage.close(context, signal);
+              } catch (ex) {
+                logger.error`Failed to close storage: ${ex}`;
+              }
+            });
+          },
+          "storage",
+        ]);
+      }
 
-        // 各トランスフォーマーのオープン処理をリストに追加します。
-        for (const transformer of this.#transformers) {
-          openFns.push([
-            async () => {
-              await transformer.open(context, signal);
+      // 各トランスフォーマーのオープン処理をリストに追加します。
+      for (const transformer of this.#transformers) {
+        openFns.push([
+          async () => {
+            await transformer.open(context, signal);
 
-              dispose.push(async () => {
-                try {
-                  await transformer.close(context, signal);
-                } catch (ex) {
-                  logger.error`Failed to close transformer: ${ex}`;
-                }
-              });
-            },
-            "transformer",
-          ]);
-        }
+            dispose.push(async () => {
+              try {
+                await transformer.close(context, signal);
+              } catch (ex) {
+                logger.error`Failed to close transformer: ${ex}`;
+              }
+            });
+          },
+          "transformer",
+        ]);
+      }
 
-        // すべての処理を並列に実行し、エラーが発生した場合は集約します。
-        const errors: { plugin: "storage" | "transformer"; reason: unknown }[] = [];
+      // すべての処理を並列に実行し、エラーが発生した場合は集約します。
+      const errors: { plugin: "storage" | "transformer"; reason: unknown }[] = [];
+      await Promise.all(
+        openFns.map(async ([f, plugin]) => {
+          try {
+            await f();
+          } catch (reason) {
+            errors.push({ plugin, reason });
+          }
+        }),
+      );
+      if (errors.length > 0) {
+        throw new PluginOperationAggregateError({ action: "open", errors });
+      }
+
+      this.#con = {
+        ac,
+        io: new Asyncmux(),
+      };
+    } catch (ex) {
+      if (dispose.length > 0) {
         await Promise.all(
-          openFns.map(async ([f, plugin]) => {
-            try {
-              await f();
-            } catch (reason) {
-              errors.push({ plugin, reason });
-            }
+          dispose.map(async (f) => {
+            await f();
           }),
         );
-        if (errors.length > 0) {
-          throw new PluginOperationAggregateError({ action: "open", errors });
-        }
-      } catch (ex) {
-        this.#con = null; // unlock の前に null に戻します。
-
-        if (dispose.length > 0) {
-          await Promise.all(
-            dispose.map(async (f) => {
-              await f();
-            }),
-          );
-        }
-
-        throw ex;
-      } finally {
-        lock.unlock();
       }
-    } catch (ex) {
-      this.#con = null;
+
       throw ex;
+    } finally {
+      this.#acSet.delete(ac);
+      lock.release();
     }
   }
 
-  /**
-   * ストレージをクローズします。
-   *
-   * @param options クローズ時のオプションです。
-   * @returns 完了を通知する Promise です。
-   */
-  public close(options?: CloseOptions): Promise<void>;
-
-  public async close(...args: any): Promise<void> {
-    if (!this.#con) {
-      throw new UniKvsIsNotOpenError();
-    }
-
-    const [options = {}] = parse(CloseArgsSchema, args);
-    const { signal = AbortSignal.timeout(10e3), context: contextOption } = options;
-
-    const context = mergeContext(this.#context, contextOption);
-    context["unikvs:action"] = "close";
-
-    const { conAc, ioMux } = this.#con;
-    conAc.abort(new UniKvsIsNotOpenError()); // 実行中の他の操作をすべて中断させるために signal を発火させます。
-
+  async #close(context: Context, signal: AbortSignal, con: Connection): Promise<void> {
     const lock = await asyncmux(this, signal);
     try {
       // ロック待機中に接続状態が変更されていないか再確認します。
-      if (!this.#con) {
+      if (this.#con !== con) {
         throw new UniKvsIsNotOpenError();
       }
 
-      const lock = await ioMux.lock({ signal });
+      const { io } = this.#con;
+      const lock = await io.lock({ signal });
       try {
         const closeFns: [() => Promise<void>, plugin: "storage" | "transformer"][] = [];
 
@@ -643,11 +613,55 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
           throw new PluginOperationAggregateError({ action: "close", errors });
         }
       } finally {
-        lock.unlock();
+        lock.release();
       }
-    } finally {
+
       this.#con = null;
-      lock.unlock();
+    } finally {
+      lock.release();
+    }
+  }
+
+  /**
+   * ストレージをクローズします。
+   *
+   * @param options クローズ時のオプションです。
+   * @returns 完了を通知する Promise です。
+   */
+  public close(options?: CloseOptions): Promise<void>;
+
+  public close(...args: any): Promise<void> {
+    try {
+      const [options = {}] = v.parseInput(CloseArgsSchema, args);
+      const { signal = AbortSignal.timeout(10e3), context: contextOption } = options;
+
+      const context = mergeContext(this.#context, contextOption);
+      context["unikvs:action"] = "close";
+
+      if (this.#con === null) {
+        const acArr = [...this.#acSet];
+        this.#acSet.clear();
+        for (const ac of acArr) {
+          if (!ac.signal.aborted) {
+            ac.abort(new UniKvsIsNotOpenError());
+          }
+        }
+
+        throw new UniKvsIsNotOpenError();
+      }
+
+      const { ac } = this.#con;
+      const acArr = [ac, ...this.#acSet];
+      this.#acSet.clear();
+      for (const ac of acArr) {
+        if (!ac.signal.aborted) {
+          ac.abort(new UniKvsIsNotOpenError());
+        }
+      }
+
+      return this.#close(context, signal, this.#con);
+    } catch (ex) {
+      return Promise.reject(ex);
     }
   }
 
@@ -688,15 +702,15 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   ): Promise<void>;
 
   public async set(...args: any): Promise<void> {
-    if (!this.#con) {
+    if (this.#con === null) {
       throw new UniKvsIsNotOpenError();
     }
 
-    const [options] = parse(SetArgsSchema, args);
+    const [options] = v.parseInput(SetArgsSchema, args);
     const { key, value, signal: signalOption, context: contextOption } = options;
 
-    const { conAc, ioMux } = this.#con;
-    const signal = combineSignals([conAc.signal, signalOption]);
+    const { ac, io } = this.#con;
+    const signal = combineSignals([ac.signal, signalOption]);
 
     const context = mergeContext(this.#context, contextOption);
     context["unikvs:action"] = "set";
@@ -705,7 +719,7 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     const lock = await asyncmux(this, signal);
     try {
       // ロック待機中に接続状態が変更されていないか再確認します。
-      if (!this.#con) {
+      if (this.#con === null) {
         throw new UniKvsIsNotOpenError();
       }
 
@@ -719,7 +733,7 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
           data = data.pipeThrough(e);
         }
 
-        const lock = await ioMux.lock({ key, signal });
+        const lock = await io.lock({ key, signal });
         try {
           await Promise.all(
             this.#destinations.map(async (storage, i) => {
@@ -739,7 +753,7 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
             }),
           );
         } finally {
-          lock.unlock();
+          lock.release();
         }
       } else {
         // 登録されているトランスフォーマーを順番に適用してデータをエンコードします。
@@ -748,7 +762,7 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
           data = await transformer.encode(context, signal, data);
         }
 
-        const lock = await ioMux.lock({ key, signal });
+        const lock = await io.lock({ key, signal });
         try {
           await Promise.all(
             this.#destinations.map(async (storage) => {
@@ -761,7 +775,7 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
             }),
           );
         } finally {
-          lock.unlock();
+          lock.release();
         }
       }
 
@@ -795,7 +809,7 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
         throw error;
       }
     } finally {
-      lock.unlock();
+      lock.release();
     }
   }
 
@@ -824,15 +838,15 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   ): Promise<$InferPlainValueData<TKeyValueMapping[TKey]>>;
 
   public async get(...args: any): Promise<unknown> {
-    if (!this.#con) {
+    if (this.#con === null) {
       throw new UniKvsIsNotOpenError();
     }
 
-    const [options] = parse(GetArgsSchema, args);
+    const [options] = v.parseInput(GetArgsSchema, args);
     const { key, signal: signalOption, context: contextOption } = options;
 
-    const { conAc, ioMux } = this.#con;
-    const signal = combineSignals([conAc.signal, signalOption]);
+    const { ac, io } = this.#con;
+    const signal = combineSignals([ac.signal, signalOption]);
 
     const context = mergeContext(this.#context, contextOption);
     context["unikvs:action"] = "get";
@@ -841,14 +855,14 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     const lock = await asyncmux.readonly(this, signal);
     try {
       // ロック待機中に接続状態が変更されていないか再確認します。
-      if (!this.#con) {
+      if (this.#con === null) {
         throw new UniKvsIsNotOpenError();
       }
 
       const NONE = {};
-      let data = NONE;
+      let data: any = NONE;
 
-      const lock = await ioMux.rLock({ key, signal });
+      const lock = await io.rLock({ key, signal });
       try {
         // 各ストレージを巡回し、最初に見つかったデータを取得します。
         for (const storage of this.#destinations) {
@@ -858,7 +872,7 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
           }
         }
       } finally {
-        lock.unlock();
+        lock.release();
       }
 
       if (data === NONE) {
@@ -874,7 +888,7 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
 
       return data;
     } finally {
-      lock.unlock();
+      lock.release();
     }
   }
 
@@ -903,15 +917,15 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   ): Promise<ValueStream<$InferStreamValueChunkData<TKeyValueMapping[TKey]>>>;
 
   public async stream(...args: any): Promise<ValueStream> {
-    if (!this.#con) {
+    if (this.#con === null) {
       throw new UniKvsIsNotOpenError();
     }
 
-    const [options] = parse(StreamArgsSchema, args);
+    const [options] = v.parseInput(StreamArgsSchema, args);
     const { key, signal: signalOption, context: contextOption } = options;
 
-    const { conAc, ioMux } = this.#con;
-    const signal = combineSignals([conAc.signal, signalOption]);
+    const { ac, io } = this.#con;
+    const signal = combineSignals([ac.signal, signalOption]);
 
     const context = mergeContext(this.#context, contextOption);
     context["unikvs:action"] = "stream";
@@ -920,14 +934,14 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     const lock = await asyncmux(this, signal);
     try {
       // ロック待機中に接続状態が変更されていないか再確認します。
-      if (!this.#con) {
+      if (this.#con === null) {
         throw new UniKvsIsNotOpenError();
       }
 
       const NONE: any = {};
       let r: IReadableStream = NONE;
 
-      const lock = await ioMux.rLock({ key, signal });
+      const lock = await io.rLock({ key, signal });
       try {
         // 各ストレージを巡回し、最初に見つかったデータを取得します。
         for (const storage of this.#destinations) {
@@ -955,7 +969,7 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
               await r.cancel();
             } catch {}
             try {
-              lock.unlock();
+              lock.release();
             } catch {}
           });
         }
@@ -969,7 +983,7 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
             await r.cancel();
           } catch {}
           try {
-            lock.unlock();
+            lock.release();
           } catch {}
         });
 
@@ -978,11 +992,11 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
 
         return valueStream;
       } catch (ex) {
-        lock.unlock();
+        lock.release();
         throw ex;
       }
     } finally {
-      lock.unlock();
+      lock.release();
     }
   }
 
@@ -1007,15 +1021,15 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   public has(options: HasOptions<KeyofKeyValueMapping<TKeyValueMapping>>): Promise<boolean>;
 
   public async has(...args: any): Promise<boolean> {
-    if (!this.#con) {
+    if (this.#con === null) {
       throw new UniKvsIsNotOpenError();
     }
 
-    const [options] = parse(HasArgsSchema, args);
+    const [options] = v.parseInput(HasArgsSchema, args);
     const { key, signal: signalOption, context: contextOption } = options;
 
-    const { conAc, ioMux } = this.#con;
-    const signal = combineSignals([conAc.signal, signalOption]);
+    const { ac, io } = this.#con;
+    const signal = combineSignals([ac.signal, signalOption]);
 
     const context = mergeContext(this.#context, contextOption);
     context["unikvs:action"] = "has";
@@ -1024,11 +1038,11 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     const lock = await asyncmux(this, signal);
     try {
       // ロック待機中に接続状態が変更されていないか再確認します。
-      if (!this.#con) {
+      if (this.#con === null) {
         throw new UniKvsIsNotOpenError();
       }
 
-      const lock = await ioMux.rLock({ key, signal });
+      const lock = await io.rLock({ key, signal });
       try {
         // いずれかのストレージに存在すれば true を返します。
         for (const storage of this.#destinations) {
@@ -1039,10 +1053,10 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
 
         return false;
       } finally {
-        lock.unlock();
+        lock.release();
       }
     } finally {
-      lock.unlock();
+      lock.release();
     }
   }
 
@@ -1067,15 +1081,15 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   public delete(options: DeleteOptions<KeyofKeyValueMapping<TKeyValueMapping>>): Promise<void>;
 
   public async delete(...args: any): Promise<void> {
-    if (!this.#con) {
+    if (this.#con === null) {
       throw new UniKvsIsNotOpenError();
     }
 
-    const [options] = parse(DeleteArgsSchema, args);
+    const [options] = v.parseInput(DeleteArgsSchema, args);
     const { key, signal: signalOption, context: contextOption } = options;
 
-    const { conAc, ioMux } = this.#con;
-    const signal = combineSignals([conAc.signal, signalOption]);
+    const { ac, io } = this.#con;
+    const signal = combineSignals([ac.signal, signalOption]);
 
     const context = mergeContext(this.#context, contextOption);
     context["unikvs:action"] = "delete";
@@ -1084,11 +1098,11 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     const lock = await asyncmux(this, signal);
     try {
       // ロック待機中に接続状態が変更されていないか再確認します。
-      if (!this.#con) {
+      if (this.#con === null) {
         throw new UniKvsIsNotOpenError();
       }
 
-      const lock = await ioMux.lock({ key, signal });
+      const lock = await io.lock({ key, signal });
       try {
         // すべてのストレージから対象データを削除します。
         // すべての処理を並列に実行し、エラーが発生した場合は集約します。
@@ -1108,10 +1122,10 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
           throw new PluginOperationAggregateError({ plugin: "storage", action: "delete", errors });
         }
       } finally {
-        lock.unlock();
+        lock.release();
       }
     } finally {
-      lock.unlock();
+      lock.release();
     }
   }
 
@@ -1124,15 +1138,15 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   public async clear(options?: ClearOptions): Promise<void>;
 
   public async clear(...args: any): Promise<void> {
-    if (!this.#con) {
+    if (this.#con === null) {
       throw new UniKvsIsNotOpenError();
     }
 
-    const [options = {}] = parse(ClearArgsSchema, args);
+    const [options = {}] = v.parseInput(ClearArgsSchema, args);
     const { signal: signalOption, context: contextOption } = options;
 
-    const { conAc, ioMux } = this.#con;
-    const signal = combineSignals([conAc.signal, signalOption]);
+    const { ac, io } = this.#con;
+    const signal = combineSignals([ac.signal, signalOption]);
 
     const context = mergeContext(this.#context, contextOption);
     context["unikvs:action"] = "clear";
@@ -1140,11 +1154,11 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     const lock = await asyncmux(this, signal);
     try {
       // ロック待機中に接続状態が変更されていないか再確認します。
-      if (!this.#con) {
+      if (this.#con === null) {
         throw new UniKvsIsNotOpenError();
       }
 
-      const lock = await ioMux.lock({ signal });
+      const lock = await io.lock({ signal });
       try {
         // すべてのストレージで一括削除を実行します。
         // すべての処理を並列に実行し、エラーが発生した場合は集約します。
@@ -1162,10 +1176,10 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
           throw new PluginOperationAggregateError({ plugin: "storage", action: "clear", errors });
         }
       } finally {
-        lock.unlock();
+        lock.release();
       }
     } finally {
-      lock.unlock();
+      lock.release();
     }
   }
 }