unikvs 0.0.5 → 0.0.7

package/src/unikvs.ts

@@ -67,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>;
 
 /**
  * 保存操作時のオプションです。
@@ -223,126 +333,7 @@ export type DeleteOptions<TKey = IStorage.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>;
 
 // -------------------------------------------------------------------------------------------------
 //
@@ -369,12 +360,12 @@ type Connection = {
   /**
    * 接続全体を管理する AbortController です。
    */
-  readonly conAc: AbortController;
+  readonly ac: AbortController;
 
   /**
    * I/O の多重化を制御する Asyncmux インスタンスです。
    */
-  readonly ioMux: Asyncmux;
+  readonly io: Asyncmux;
 };
 
 /**
@@ -421,6 +412,8 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
    */
   #con: Connection | null;
 
+  readonly #acSet: Set<AbortController>;
+
   /**
    * 基本となる実行コンテキスト情報です。
    */
@@ -450,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;
   }
@@ -464,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;
   }
 
   /**
@@ -476,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 = {}] = v.parseInput(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.release();
       }
-    } 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 = {}] = v.parseInput(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"][] = [];
 
@@ -644,12 +615,56 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
       } finally {
         lock.release();
       }
-    } finally {
+
       this.#con = null;
+    } 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);
+    }
+  }
+
   async [Symbol.asyncDispose](): Promise<void> {
     if (!this.isOpen) {
       return;
@@ -661,41 +676,41 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   }
 
   /**
-   * 指定したキーに値を保存します。
+   * 指定したオプションで値を保存します。
    *
    * @template TKey 対象キーの型定義です。
-   * @param key 操作対象を識別するためのキーです。
-   * @param value 保存する値です。
-   * @param options 追加のオプションです。
+   * @param options セット操作のオプション一式です。
    * @returns 完了を通知する Promise です。
    */
   public set<const TKey extends KeyofKeyValueMapping<TKeyValueMapping>>(
-    key: TKey,
-    value: SetValue<TKeyValueMapping[TKey]>,
-    options?: Omit<SetOptions, "key" | "value">,
+    options: SetOptions<TKeyValueMapping, TKey>,
   ): Promise<void>;
 
   /**
-   * 指定したオプションで値を保存します。
+   * 指定したキーに値を保存します。
    *
    * @template TKey 対象キーの型定義です。
-   * @param options セット操作のオプション一式です。
+   * @param key 操作対象を識別するためのキーです。
+   * @param value 保存する値です。
+   * @param options 追加のオプションです。
    * @returns 完了を通知する Promise です。
    */
   public set<const TKey extends KeyofKeyValueMapping<TKeyValueMapping>>(
-    options: SetOptions<TKeyValueMapping, TKey>,
+    key: TKey,
+    value: SetValue<TKeyValueMapping[TKey]>,
+    options?: Omit<SetOptions, "key" | "value">,
   ): Promise<void>;
 
   public async set(...args: any): Promise<void> {
-    if (!this.#con) {
+    if (this.#con === null) {
       throw new UniKvsIsNotOpenError();
     }
 
     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";
@@ -704,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();
       }
 
@@ -718,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) => {
@@ -747,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) => {
@@ -799,39 +814,39 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   }
 
   /**
-   * 指定したキーから値を取得します。
+   * 指定したオプションで値を取得します。
    *
    * @template TKey 対象キーの型定義です。
-   * @param key 操作対象を識別するためのキーです。
-   * @param options 追加のオプションです。
+   * @param options 取得操作のオプション一式です。
    * @returns 取得した値を返します。
    */
   public get<const TKey extends KeyofKeyValueMappingHasPlainValue<TKeyValueMapping>>(
-    key: TKey,
-    options?: Omit<GetOptions, "key">,
+    options: GetOptions<TKey>,
   ): Promise<$InferPlainValueData<TKeyValueMapping[TKey]>>;
 
   /**
-   * 指定したオプションで値を取得します。
+   * 指定したキーから値を取得します。
    *
    * @template TKey 対象キーの型定義です。
-   * @param options 取得操作のオプション一式です。
+   * @param key 操作対象を識別するためのキーです。
+   * @param options 追加のオプションです。
    * @returns 取得した値を返します。
    */
   public get<const TKey extends KeyofKeyValueMappingHasPlainValue<TKeyValueMapping>>(
-    options: GetOptions<TKey>,
+    key: TKey,
+    options?: Omit<GetOptions, "key">,
   ): Promise<$InferPlainValueData<TKeyValueMapping[TKey]>>;
 
   public async get(...args: any): Promise<unknown> {
-    if (!this.#con) {
+    if (this.#con === null) {
       throw new UniKvsIsNotOpenError();
     }
 
     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";
@@ -840,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: any = NONE;
 
-      const lock = await ioMux.rLock({ key, signal });
+      const lock = await io.rLock({ key, signal });
       try {
         // 各ストレージを巡回し、最初に見つかったデータを取得します。
         for (const storage of this.#destinations) {
@@ -878,39 +893,39 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   }
 
   /**
-   * 指定したキーからストリームを取得します。
+   * 指定したオプションでストリームを取得します。
    *
    * @template TKey 対象キーの型定義です。
-   * @param key 操作対象を識別するためのキーです。
-   * @param options 追加のオプションです。
+   * @param options ストリーム取得操作のオプション一式です。
    * @returns 取得したストリームを返します。
    */
   public stream<const TKey extends KeyofKeyValueMappingHasStreamValue<TKeyValueMapping>>(
-    key: TKey,
-    options?: Omit<StreamOptions, "key">,
+    options: StreamOptions<TKey>,
   ): Promise<ValueStream<$InferStreamValueChunkData<TKeyValueMapping[TKey]>>>;
 
   /**
-   * 指定したオプションでストリームを取得します。
+   * 指定したキーからストリームを取得します。
    *
    * @template TKey 対象キーの型定義です。
-   * @param options ストリーム取得操作のオプション一式です。
+   * @param key 操作対象を識別するためのキーです。
+   * @param options 追加のオプションです。
    * @returns 取得したストリームを返します。
    */
   public stream<const TKey extends KeyofKeyValueMappingHasStreamValue<TKeyValueMapping>>(
-    options: StreamOptions<TKey>,
+    key: TKey,
+    options?: Omit<StreamOptions, "key">,
   ): Promise<ValueStream<$InferStreamValueChunkData<TKeyValueMapping[TKey]>>>;
 
   public async stream(...args: any): Promise<ValueStream> {
-    if (!this.#con) {
+    if (this.#con === null) {
       throw new UniKvsIsNotOpenError();
     }
 
     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";
@@ -919,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) {
@@ -985,6 +1000,14 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     }
   }
 
+  /**
+   * 指定したオプションでキーの存在を確認します。
+   *
+   * @param options 存在確認操作のオプションです。
+   * @returns 存在する場合は true、そうでない場合は false を返します。
+   */
+  public has(options: HasOptions<KeyofKeyValueMapping<TKeyValueMapping>>): Promise<boolean>;
+
   /**
    * 指定したキーが存在するかを確認します。
    *
@@ -997,24 +1020,16 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     options?: Omit<HasOptions, "key">,
   ): Promise<boolean>;
 
-  /**
-   * 指定したオプションでキーの存在を確認します。
-   *
-   * @param options 存在確認操作のオプションです。
-   * @returns 存在する場合は true、そうでない場合は false を返します。
-   */
-  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] = 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";
@@ -1023,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) {
@@ -1045,6 +1060,14 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     }
   }
 
+  /**
+   * 指定したオプションでキーを削除します。
+   *
+   * @param options 削除操作のオプションです。
+   * @returns 完了を通知する Promise です。
+   */
+  public delete(options: DeleteOptions<KeyofKeyValueMapping<TKeyValueMapping>>): Promise<void>;
+
   /**
    * 指定したキーを削除します。
    *
@@ -1057,24 +1080,16 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     options?: Omit<DeleteOptions, "key">,
   ): Promise<void>;
 
-  /**
-   * 指定したオプションでキーを削除します。
-   *
-   * @param options 削除操作のオプションです。
-   * @returns 完了を通知する Promise です。
-   */
-  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] = 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";
@@ -1083,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 {
         // すべてのストレージから対象データを削除します。
         // すべての処理を並列に実行し、エラーが発生した場合は集約します。
@@ -1123,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 = {}] = 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";
@@ -1139,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 {
         // すべてのストレージで一括削除を実行します。
         // すべての処理を並列に実行し、エラーが発生した場合は集約します。