unikvs 0.0.9 → 0.0.12

package/src/unikvs.ts

@@ -1,32 +1,40 @@
-import type { Context, IStorage, IReadableStream } from "@unikvs/core";
+import type { Variables, IStorage, IReadableStream } from "@unikvs/core";
 import { combineSignals } from "abort-signal-utils";
 import { type AsyncmuxLock, asyncmux, Asyncmux } from "asyncmux";
 
 import logger from "./_logger.js";
-import mergeContext from "./_merge-context.js";
+import mergeVariables from "./_merge-variables.js";
 import UniKvsStorage from "./_storage.js";
+import { isReadableStream } from "./_streams.js";
 import toValueStream from "./_to-value-stream.js";
 import UniKvsTransformer from "./_transformer.js";
 import * as v from "./_valibot.js";
-import type { ContextSource } from "./context.types.js";
 import {
+  type KeyNotFoundErrorArgs,
   KeyNotFoundError,
   UniKvsIsOpenError,
-  PluginOperationAggregateError,
   UniKvsIsNotOpenError,
+  PluginOperationAggregateError,
 } from "./errors.js";
 import UniKvsConfig, {
   type Value,
   type PlainValue,
   type StreamValue,
+  type UniKvsSchema,
   type KeyValueMapping,
+  type ValueSchemaInfo,
+  type UniKvsConfigOptions,
   type $InferPlainValueData,
   type IUniKvsConfigBuilder,
+  type IValueSchemaResolver,
   type KeyofKeyValueMapping,
+  type $InferKeyValueMapping,
+  type $InferPlainValueInput,
   type $InferStreamValueChunkData,
 } from "./unikvs-config.js";
 import type { ValueOf } from "./utils.types.js";
 import type { ValueStream } from "./value-stream.types.js";
+import type { VariablesSource } from "./variables.types.js";
 
 // -------------------------------------------------------------------------------------------------
 //
@@ -35,18 +43,14 @@ import type { ValueStream } from "./value-stream.types.js";
 // -------------------------------------------------------------------------------------------------
 
 /**
- * 設定可能な値の型定義です。
- *
- * @template TValue 値の型定義です。
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#value-types)
  */
 export type SetValue<TValue extends Value> =
-  | $InferPlainValueData<TValue>
-  | (TValue extends StreamValue<infer TChunkData> ? ReadableStream<TChunkData> : never);
+  | $InferPlainValueInput<TValue>
+  | (TValue extends StreamValue<any, infer TChunkInput> ? ReadableStream<TChunkInput> : never);
 
 /**
- * プレーンな値を持つキーのみを抽出する型定義です。
- *
- * @template TKeyValueMapping キーと値のマッピング定義です。
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#value-types)
  */
 export type KeyofKeyValueMappingHasPlainValue<TKeyValueMapping extends KeyValueMapping> = ValueOf<{
   [TKey in KeyofKeyValueMapping<TKeyValueMapping>]: PlainValue extends TKeyValueMapping[TKey]
@@ -55,9 +59,7 @@ export type KeyofKeyValueMappingHasPlainValue<TKeyValueMapping extends KeyValueM
 }>;
 
 /**
- * ストリーム形式の値を持つキーのみを抽出する型定義です。
- *
- * @template TKeyValueMapping キーと値のマッピング定義です。
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#value-types)
  */
 export type KeyofKeyValueMappingHasStreamValue<TKeyValueMapping extends KeyValueMapping> = ValueOf<{
   [TKey in KeyofKeyValueMapping<TKeyValueMapping>]: StreamValue extends TKeyValueMapping[TKey]
@@ -65,17 +67,78 @@ export type KeyofKeyValueMappingHasStreamValue<TKeyValueMapping extends KeyValue
     : never;
 }>;
 
+// -------------------------------------------------------------------------------------------------
+//
+// 値の検証
+//
+// -------------------------------------------------------------------------------------------------
+
+/**
+ * プレーン値専用のスキーマに ReadableStream が渡されたことを報告するためのスキーマです。
+ */
+const PlainValueInputSchema = v.pipe(
+  v.unknown(),
+  v.check(
+    (input) => !isReadableStream(input),
+    "Expected a plain value, but received a ReadableStream",
+  ),
+);
+
+/**
+ * ストリーム専用のスキーマにプレーン値が渡されたことを報告するためのスキーマです。
+ */
+const StreamValueInputSchema = v.pipe(
+  v.unknown(),
+  v.check(isReadableStream, "Expected a ReadableStream, but received a plain value"),
+);
+
+/**
+ * スキーマ情報に基づいて `set` の入力値を検証します。
+ *
+ * プレーン値はその場で検証し、ストリームはチャンクごとに検証するストリームに変換します。
+ *
+ * @param info キーに対応するスキーマ情報です。
+ * @param value 検証する入力値です。
+ * @returns 検証済みの入力値を返します。
+ */
+function parseSetValue(info: ValueSchemaInfo, value: unknown): unknown {
+  if (isReadableStream(value)) {
+    if (info.kind === "plain") {
+      // 必ず検証に失敗するため、InvalidInputError が投げられます。
+      v.parseInput(PlainValueInputSchema, value);
+    }
+
+    // 入力チャンクを検証し、変換後の値を後続のパイプラインへ流します。
+    return value.pipeThrough(
+      new TransformStream({
+        transform(chunk, controller) {
+          controller.enqueue(v.parseInput(info.schema, chunk));
+        },
+      }),
+    );
+  }
+
+  if (info.kind === "stream") {
+    // 必ず検証に失敗するため、InvalidInputError が投げられます。
+    v.parseInput(StreamValueInputSchema, value);
+  }
+
+  return v.parseInput(info.schema, value);
+}
+
 // -------------------------------------------------------------------------------------------------
 //
 // スキーマ
 //
 // -------------------------------------------------------------------------------------------------
 
-const ContextKeySchema = v.string();
+const VariablesKeySchema = v.string();
 
-const ContextSourceSchema = v.union([
+// 配列形式の vars も正当な入力であるため、record スキーマより先に判定する必要があります。
+// record スキーマは配列にもマッチして数値キーのオブジェクトに変換してしまうため、配列形式を先に処理しないと mergeVariables での配列としてのマージが行われません。
+const VariablesSourceSchema = v.union([
+  v.array(v.tuple([VariablesKeySchema, v.unknown()])),
   v.record(v.any(), v.unknown()),
-  v.array(v.tuple([ContextKeySchema, v.unknown()])),
 ]);
 
 const OpenOptionsSchema = v.object({
@@ -85,9 +148,9 @@ const OpenOptionsSchema = v.object({
   signal: v.optional(v.instance(AbortSignal)),
 
   /**
-   * 実行時のコンテキスト情報です。
+   * 実行時の変数です。
    */
-  context: v.optional(ContextSourceSchema),
+  vars: v.optional(VariablesSourceSchema),
 });
 
 const OpenArgsSchema = v.tuple([v.optional(OpenOptionsSchema)]);
@@ -99,9 +162,9 @@ const CloseOptionsSchema = v.object({
   signal: v.optional(v.instance(AbortSignal)),
 
   /**
-   * 実行時のコンテキスト情報です。
+   * 実行時の変数です。
    */
-  context: v.optional(ContextSourceSchema),
+  vars: v.optional(VariablesSourceSchema),
 });
 
 const CloseArgsSchema = v.tuple([v.optional(CloseOptionsSchema)]);
@@ -110,7 +173,7 @@ const SetOptionsSchema = v.object({
   key: v.string(),
   value: v.unknown(),
   signal: v.optional(v.instance(AbortSignal)),
-  context: v.optional(ContextSourceSchema),
+  vars: v.optional(VariablesSourceSchema),
 });
 
 const SetArgsSchema = v.union([
@@ -128,7 +191,7 @@ const SetArgsSchema = v.union([
 const GetOptionsSchema = v.object({
   key: v.string(),
   signal: v.optional(v.instance(AbortSignal)),
-  context: v.optional(ContextSourceSchema),
+  vars: v.optional(VariablesSourceSchema),
 });
 
 const GetArgsSchema = v.union([
@@ -142,7 +205,7 @@ const GetArgsSchema = v.union([
 const StreamOptionsSchema = v.object({
   key: v.string(),
   signal: v.optional(v.instance(AbortSignal)),
-  context: v.optional(ContextSourceSchema),
+  vars: v.optional(VariablesSourceSchema),
 });
 
 const StreamArgsSchema = v.union([
@@ -156,7 +219,7 @@ const StreamArgsSchema = v.union([
 const HasOptionsSchema = v.object({
   key: v.string(),
   signal: v.optional(v.instance(AbortSignal)),
-  context: v.optional(ContextSourceSchema),
+  vars: v.optional(VariablesSourceSchema),
 });
 
 const HasArgsSchema = v.union([
@@ -170,7 +233,7 @@ const HasArgsSchema = v.union([
 const DeleteOptionsSchema = v.object({
   key: v.string(),
   signal: v.optional(v.instance(AbortSignal)),
-  context: v.optional(ContextSourceSchema),
+  vars: v.optional(VariablesSourceSchema),
 });
 
 const DeleteArgsSchema = v.union([
@@ -188,9 +251,9 @@ const ClearOptionsSchema = v.object({
   signal: v.optional(v.instance(AbortSignal)),
 
   /**
-   * 実行時のコンテキスト情報です。
+   * 実行時の変数です。
    */
-  context: v.optional(ContextSourceSchema),
+  vars: v.optional(VariablesSourceSchema),
 });
 
 const ClearArgsSchema = v.tuple([v.optional(ClearOptionsSchema)]);
@@ -202,136 +265,125 @@ const ClearArgsSchema = v.tuple([v.optional(ClearOptionsSchema)]);
 // -------------------------------------------------------------------------------------------------
 
 /**
- * オープン操作時のオプションです。
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
  */
 export type OpenOptions = v.InferInput<typeof OpenOptionsSchema>;
 
 /**
- * クローズ操作時のオプションです。
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
  */
 export type CloseOptions = v.InferInput<typeof CloseOptionsSchema>;
 
 /**
- * 保存操作時のオプションです。
- *
- * @template TKeyValueMapping キーと値のマッピング定義です。
- * @template TKey 対象となるキーの型です。
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
  */
 export type SetOptions<
   TKeyValueMapping extends KeyValueMapping = KeyValueMapping,
   TKey extends KeyofKeyValueMapping<TKeyValueMapping> = KeyofKeyValueMapping<TKeyValueMapping>,
 > = {
   /**
-   * 操作対象を識別するためのキーです。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
    */
   readonly key: TKey;
 
   /**
-   * 保存する値です。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
    */
   readonly value: SetValue<TKeyValueMapping[TKey]>;
 
   /**
-   * 処理の中断を通知するためのシグナルです。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#variables-and-cancellation)
    */
   readonly signal?: AbortSignal | undefined;
 
   /**
-   * 実行時のコンテキスト情報です。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#variables-and-cancellation)
    */
-  readonly context?: ContextSource | undefined;
+  readonly vars?: VariablesSource | undefined;
 };
 
 /**
- * 取得操作時のオプションです。
- *
- * @template TKey 対象となるキーの型です。
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
  */
 export type GetOptions<TKey = IStorage.Key> = {
   /**
-   * 操作対象を識別するためのキーです。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
    */
   readonly key: TKey;
 
   /**
-   * 処理の中断を通知するためのシグナルです。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#variables-and-cancellation)
    */
   readonly signal?: AbortSignal | undefined;
 
   /**
-   * 実行時のコンテキスト情報です。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#variables-and-cancellation)
    */
-  readonly context?: ContextSource | undefined;
+  readonly vars?: VariablesSource | undefined;
 };
 
 /**
- * ストリーム取得操作時のオプションです。
- *
- * @template TKey 対象となるキーの型です。
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#value-stream)
  */
 export type StreamOptions<TKey = IStorage.Key> = {
   /**
-   * 操作対象を識別するためのキーです。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#value-stream)
    */
   readonly key: TKey;
 
   /**
-   * 処理の中断を通知するためのシグナルです。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#variables-and-cancellation)
    */
   readonly signal?: AbortSignal | undefined;
 
   /**
-   * 実行時のコンテキスト情報です。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#variables-and-cancellation)
    */
-  readonly context?: ContextSource | undefined;
+  readonly vars?: VariablesSource | undefined;
 };
 
 /**
- * 存在確認操作時のオプションです。
- *
- * @template TKey 対象となるキーの型です。
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
  */
 export type HasOptions<TKey = IStorage.Key> = {
   /**
-   * 操作対象を識別するためのキーです。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
    */
   readonly key: TKey;
 
   /**
-   * 処理の中断を通知するためのシグナルです。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#variables-and-cancellation)
    */
   readonly signal?: AbortSignal | undefined;
 
   /**
-   * 実行時のコンテキスト情報です。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#variables-and-cancellation)
    */
-  readonly context?: ContextSource | undefined;
+  readonly vars?: VariablesSource | undefined;
 };
 
 /**
- * 削除操作時のオプションです。
- *
- * @template TKey 対象となるキーの型です。
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
  */
 export type DeleteOptions<TKey = IStorage.Key> = {
   /**
-   * 操作対象を識別するためのキーです。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
    */
   readonly key: TKey;
 
   /**
-   * 処理の中断を通知するためのシグナルです。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#variables-and-cancellation)
    */
   readonly signal?: AbortSignal | undefined;
 
   /**
-   * 実行時のコンテキスト情報です。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#variables-and-cancellation)
    */
-  readonly context?: ContextSource | undefined;
+  readonly vars?: VariablesSource | undefined;
 };
 
 /**
- * 全削除操作時のオプションです。
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
  */
 export type ClearOptions = v.InferInput<typeof ClearOptionsSchema>;
 
@@ -347,12 +399,31 @@ export type ClearOptions = v.InferInput<typeof ClearOptionsSchema>;
 const ioLockRegistry =
   typeof FinalizationRegistry !== "function"
     ? null
-    : new FinalizationRegistry<AsyncmuxLock>((lock) => {
-        if (!lock.released) {
-          lock.release();
+    : new FinalizationRegistry<IoLockRegistryHeld>((held) => {
+        if (!held.lock.released) {
+          held.lock.release();
         }
+
+        // valueStream が読み取られないまま GC されたとき、ソースストリームが保持するリソース (S3 レスポンスボディなど) を解放するために破棄します。
+        // dispose は valueStream 自身を参照しないため、これを保持しても valueStream のガベージコレクションを妨げません。
+        // 失敗しても対処できないので無視します。
+        held.dispose().catch((ex) => {
+          logger.error`Failed to dispose value stream: ${ex}`;
+        });
       });
 
+type IoLockRegistryHeld = {
+  /**
+   * stream 操作で取得したキーの読み取りロックです。
+   */
+  readonly lock: AsyncmuxLock;
+
+  /**
+   * {@linkcode ValueStream.dispose} です。ソースストリームのキャンセルとロック解放を行います。
+   */
+  readonly dispose: () => Promise<void>;
+};
+
 /**
  * 接続状態を管理する内部オブジェクトです。
  */
@@ -369,42 +440,45 @@ type Connection = {
 };
 
 /**
- * UniKvs メインクラスです。
- *
- * 複数のストレージとトランスフォーマーを統合して KVS 操作を提供します。
- *
- * @template TKeyValueMapping キーと値のマッピング定義です。
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#config-builder)
+ */
+export type UniKvsDestination = {
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#config-builder)
+   */
+  readonly storage: UniKvsStorage;
+
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#config-builder)
+   */
+  readonly transformers: readonly UniKvsTransformer[];
+};
+
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
  */
 export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueMapping> {
   /**
-   * UniKvs の設定ビルダーを作成します。
-   *
-   * @template TKeyValueMapping マッピング定義です。
-   * @returns 設定ビルダーのインスタンスです。
-   * @example
-   * ```typescript
-   * import { Compression } from "@unikvs/compression";
-   * import { FileSystem } from "@unikvs/fs.node";
-   * import { UniKvs, type Value } from "unikvs";
-   *
-   * const kvs = UniKvs.config<{
-   *   foo: Value<Uint8Array<ArrayBuffer>>;
-   * }>()
-   *   .appendTransformer(new Compression("gzip"))
-   *   .appendStorage(new FileSystem(".tmp"))
-   *   .create();
-   *
-   * await kvs.open();
-   *
-   * await kvs.set("foo", Uint8Array.from([0, 1, 2]));
-   *
-   * await kvs.close();
-   * ```
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#config-builder)
    */
   public static config<
     TKeyValueMapping extends KeyValueMapping,
-  >(): IUniKvsConfigBuilder<TKeyValueMapping> {
-    return new UniKvsConfig(this);
+  >(): IUniKvsConfigBuilder<TKeyValueMapping>;
+
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#config-builder)
+   */
+  public static config<const TSchema extends UniKvsSchema>(options: {
+    readonly schema: TSchema;
+  }): IUniKvsConfigBuilder<$InferKeyValueMapping<TSchema>>;
+
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#config-builder)
+   */
+  public static config(options?: UniKvsConfigOptions): IUniKvsConfigBuilder;
+
+  public static config(options?: UniKvsConfigOptions): IUniKvsConfigBuilder<any> {
+    return new UniKvsConfig(this, options);
   }
 
   /**
@@ -415,54 +489,61 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   readonly #acSet: Set<AbortController>;
 
   /**
-   * 基本となる実行コンテキスト情報です。
+   * 基本となる実行変数情報です。
    */
-  readonly #context: Readonly<Context>;
+  readonly #vars: Readonly<Variables>;
 
   /**
-   * データの永続化先となるストレージのリストです。
+   * データの永続化先となるストレージと前段パイプラインのリストです。
    */
-  readonly #destinations: readonly [UniKvsStorage, ...UniKvsStorage[]];
+  readonly #destinations: readonly [UniKvsDestination, ...UniKvsDestination[]];
 
   /**
-   * データの変換を行うトランスフォーマーのリストです。
+   * データの変換を行うトランスフォーマーのリストです。open/close の管理用に全件を保持します。
    */
   readonly #transformers: readonly UniKvsTransformer[];
 
   /**
-   * インスタンスを初期化します。
-   *
-   * @internal UniKvs の設定ビルダー経由で使用します。
-   * @param context コンテキストです。
-   * @param destinations ストレージのリストです。
-   * @param transformers トランスフォーマーのリストです。
+   * キーに対応する値のスキーマ情報を解決するリゾルバーです。スキーマ未設定時は null となります。
+   */
+  readonly #valueSchemaResolver: IValueSchemaResolver | null;
+
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
    */
   public constructor(
-    context: Readonly<Context>,
-    destinations: readonly [UniKvsStorage, ...UniKvsStorage[]],
+    vars: Readonly<Variables>,
+    destinations: readonly [UniKvsDestination, ...UniKvsDestination[]],
     transformers: readonly UniKvsTransformer[],
+    valueSchemaResolver: IValueSchemaResolver | null = null,
   ) {
     this.#con = null;
     this.#acSet = new Set();
-    this.#context = { ...context };
+    this.#vars = { ...vars };
     this.#destinations = destinations;
     this.#transformers = transformers;
+    this.#valueSchemaResolver = valueSchemaResolver;
   }
 
   /**
-   * UniKvs が利用可能であるかを確認します。
+   * キーに対応する値のスキーマ情報を解決します。
    *
-   * @returns 利用可能である場合は true、そうでない場合は false を返します。
+   * @param key 解決するキーです。
+   * @returns 対応するスキーマ情報を返します。スキーマ未設定または対応する定義がない場合は `undefined` を返します。
+   */
+  #resolveValueSchema(key: string): ValueSchemaInfo | undefined {
+    return this.#valueSchemaResolver?.resolve(key);
+  }
+
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
    */
   public get isOpen(): boolean {
     return this.#con !== null;
   }
 
   /**
-   * すべてのストレージとトランスフォーマーを初期化します。
-   *
-   * @param options オープン時のオプションです。
-   * @returns 完了を通知する Promise です。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
    */
   public open(options?: OpenOptions): Promise<void>;
 
@@ -472,13 +553,13 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     }
 
     const [options = {}] = v.parseInput(OpenArgsSchema, args);
-    const { signal: signalOption, context: contextOption } = options;
+    const { signal: signalOption, vars: varsOption } = options;
 
     const ac = new AbortController();
     const signal = combineSignals([ac.signal, signalOption]);
 
-    const context = mergeContext(this.#context, contextOption);
-    context["unikvs:action"] = "open";
+    const vars = mergeVariables(this.#vars, varsOption);
+    vars["unikvs:action"] = "open";
 
     signal.throwIfAborted();
 
@@ -495,14 +576,14 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
       const openFns: [() => Promise<void>, plugin: "storage" | "transformer"][] = [];
 
       // 各ストレージのオープン処理をリストに追加します。
-      for (const storage of this.#destinations) {
+      for (const { storage } of this.#destinations) {
         openFns.push([
           async () => {
-            await storage.open(context, signal);
+            await storage.open(vars, signal);
 
             dispose.push(async () => {
               try {
-                await storage.close(context, signal);
+                await storage.close(vars, signal);
               } catch (ex) {
                 logger.error`Failed to close storage: ${ex}`;
               }
@@ -516,11 +597,11 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
       for (const transformer of this.#transformers) {
         openFns.push([
           async () => {
-            await transformer.open(context, signal);
+            await transformer.open(vars, signal);
 
             dispose.push(async () => {
               try {
-                await transformer.close(context, signal);
+                await transformer.close(vars, signal);
               } catch (ex) {
                 logger.error`Failed to close transformer: ${ex}`;
               }
@@ -542,9 +623,18 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
         }),
       );
       if (errors.length > 0) {
+        // 中断以外の失敗が混在しない場合は、abort 理由が集約エラーに埋もれないようにそのまま投げます。
+        if (signal.aborted && errors.every((error) => error.reason === signal.reason)) {
+          throw signal.reason;
+        }
+
         throw new PluginOperationAggregateError({ action: "open", errors });
       }
 
+      // すべてのプラグインのオープンが成功した後も、待機中に中断されていないか最終確認します。
+      // 中断済みのシグナルを持つ接続を作成すると、isOpen が true でありながら以降のすべての操作が即座に失敗する壊れた状態になります。
+      signal.throwIfAborted();
+
       this.#con = {
         ac,
         io: new Asyncmux(),
@@ -565,7 +655,7 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     }
   }
 
-  async #close(context: Context, signal: AbortSignal, con: Connection): Promise<void> {
+  async #close(vars: Variables, signal: AbortSignal, con: Connection): Promise<void> {
     const lock = await asyncmux(this, signal);
     try {
       // ロック待機中に接続状態が変更されていないか再確認します。
@@ -579,10 +669,10 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
         const closeFns: [() => Promise<void>, plugin: "storage" | "transformer"][] = [];
 
         // ストレージのクローズ処理を登録します。
-        for (const plugin of this.#destinations) {
+        for (const { storage } of this.#destinations) {
           closeFns.push([
             async () => {
-              await plugin.close(context, signal);
+              await storage.close(vars, signal);
             },
             "storage",
           ]);
@@ -592,7 +682,7 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
         for (const plugin of this.#transformers) {
           closeFns.push([
             async () => {
-              await plugin.close(context, signal);
+              await plugin.close(vars, signal);
             },
             "transformer",
           ]);
@@ -623,20 +713,17 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   }
 
   /**
-   * ストレージをクローズします。
-   *
-   * @param options クローズ時のオプションです。
-   * @returns 完了を通知する Promise です。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
    */
   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 { signal = AbortSignal.timeout(10e3), vars: varsOption } = options;
 
-      const context = mergeContext(this.#context, contextOption);
-      context["unikvs:action"] = "close";
+      const vars = mergeVariables(this.#vars, varsOption);
+      vars["unikvs:action"] = "close";
 
       if (this.#con === null) {
         const acArr = [...this.#acSet];
@@ -650,7 +737,8 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
         throw new UniKvsIsNotOpenError();
       }
 
-      const { ac } = this.#con;
+      const con = this.#con;
+      const { ac } = con;
       const acArr = [ac, ...this.#acSet];
       this.#acSet.clear();
       for (const ac of acArr) {
@@ -659,12 +747,36 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
         }
       }
 
-      return this.#close(context, signal, this.#con);
+      return this.#close(vars, signal, con).catch(async (ex) => {
+        // #close が失敗した場合、コネクションの AbortController はすでに abort 済みであり、以降の操作がすべて即座に失敗する壊れた状態になります。
+        // そこで接続を破棄して isOpen=false の一貫した状態にし、ベストエフォートでプラグインのクローズ処理を実行します。
+        if (this.#con === con) {
+          this.#con = null;
+
+          const disposeSignal = AbortSignal.timeout(10e3);
+          await Promise.all(
+            [...this.#destinations.map((dest) => dest.storage), ...this.#transformers].map(
+              async (plugin) => {
+                try {
+                  await plugin.close(vars, disposeSignal);
+                } catch (reason) {
+                  logger.error`Failed to close plugin after close failure: ${reason}`;
+                }
+              },
+            ),
+          );
+        }
+
+        throw ex;
+      });
     } catch (ex) {
       return Promise.reject(ex);
     }
   }
 
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
+   */
   async [Symbol.asyncDispose](): Promise<void> {
     if (!this.isOpen) {
       return;
@@ -676,24 +788,14 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   }
 
   /**
-   * 指定したオプションで値を保存します。
-   *
-   * @template TKey 対象キーの型定義です。
-   * @param options セット操作のオプション一式です。
-   * @returns 完了を通知する Promise です。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
    */
   public set<const TKey extends KeyofKeyValueMapping<TKeyValueMapping>>(
     options: SetOptions<TKeyValueMapping, TKey>,
   ): Promise<void>;
 
   /**
-   * 指定したキーに値を保存します。
-   *
-   * @template TKey 対象キーの型定義です。
-   * @param key 操作対象を識別するためのキーです。
-   * @param value 保存する値です。
-   * @param options 追加のオプションです。
-   * @returns 完了を通知する Promise です。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
    */
   public set<const TKey extends KeyofKeyValueMapping<TKeyValueMapping>>(
     key: TKey,
@@ -707,14 +809,17 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     }
 
     const [options] = v.parseInput(SetArgsSchema, args);
-    const { key, value, signal: signalOption, context: contextOption } = options;
+    const { key, signal: signalOption, vars: varsOption } = options;
+
+    const valueSchema = this.#resolveValueSchema(key);
+    const value = valueSchema ? parseSetValue(valueSchema, options.value) : options.value;
 
     const { ac, io } = this.#con;
     const signal = combineSignals([ac.signal, signalOption]);
 
-    const context = mergeContext(this.#context, contextOption);
-    context["unikvs:action"] = "set";
-    context["unikvs:key"] = key;
+    const vars = mergeVariables(this.#vars, varsOption);
+    vars["unikvs:action"] = "set";
+    vars["unikvs:key"] = key;
 
     const lock = await asyncmux(this, signal);
     try {
@@ -724,31 +829,76 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
       }
 
       const errors: { reason: unknown }[] = [];
-      const errorStorageSet = new Set<UniKvsStorage>();
-      if (value instanceof ReadableStream) {
-        // 各トランスフォーマーを通してデータをエンコードストリームへ変換します。
-        let data = value;
-        for (const transformer of this.#transformers) {
-          const e = await transformer.getEncodable(context, signal);
-          data = data.pipeThrough(e);
+      const errorStorageSet = new Set<UniKvsDestination>();
+      if (isReadableStream(value)) {
+        // 各ストレージ専用の前段パイプラインを通すため、tee で分岐しながらエンコードストリームを構築します。
+        // 最長の前段パイプラインを基準にし、ストレージの登録順に分岐点を作ります。
+        let longest: readonly UniKvsTransformer[] = [];
+        for (const dest of this.#destinations) {
+          if (dest.transformers.length > longest.length) {
+            longest = dest.transformers;
+          }
+        }
+        let cur: ReadableStream = value;
+        const branches: ReadableStream[] = [];
+        const built: ReadableStream[] = [];
+        try {
+          let applied = 0;
+          for (let i = 0; i < this.#destinations.length; i++) {
+            const dest = this.#destinations[i]!;
+            while (applied < dest.transformers.length) {
+              const e = await longest[applied]!.getEncodable(vars, signal);
+              cur = cur.pipeThrough(e);
+              applied++;
+            }
+            if (i === this.#destinations.length - 1) {
+              branches[i] = cur;
+            } else {
+              const [branch, rest] = cur.tee();
+              branches[i] = branch;
+              built.push(branch);
+              cur = rest;
+            }
+          }
+        } catch (ex) {
+          // チェーンの構築中に失敗した場合、パイプが保持するソースストリームのリソースを解放するためにキャンセルします。
+          // キャンセルしないとソースストリームはロックされたままリークします。
+          try {
+            await cur.cancel(ex);
+          } catch {
+            // キャンセルに失敗しても元の例外の伝播を優先します。
+          }
+          await Promise.all(
+            built.map(async (branch) => {
+              try {
+                await branch.cancel(ex);
+              } catch {
+                // キャンセルに失敗しても元の例外の伝播を優先します。
+              }
+            }),
+          );
+
+          throw ex;
         }
 
         const lock = await io.lock({ key, signal });
         try {
           await Promise.all(
-            this.#destinations.map(async (storage, i) => {
+            this.#destinations.map(async (dest, i) => {
+              // tee ブランチはキャンセルされるまで健康なブランチの読み取り分のチャンクを保持し続けるため、失敗時に放棄したブランチを確実にキャンセルできるよう参照を保持します。
+              const branch = branches[i]!;
               try {
-                // 複数のストレージがある場合は、tee メソッドを使用してストリームを分岐させます。
-                let r = data;
-                if (i !== this.#destinations.length - 1) {
-                  [r, data] = data.tee();
+                const w = await dest.storage.getWritable(vars, signal, key);
+                await branch.pipeTo(w, { signal });
+              } catch (reason) {
+                try {
+                  await branch.cancel(reason);
+                } catch {
+                  // キャンセルに失敗してもエラー集約を優先します。
                 }
 
-                const w = await storage.getWritable(context, signal, key);
-                await r.pipeTo(w, { signal });
-              } catch (reason) {
                 errors.push({ reason });
-                errorStorageSet.add(storage);
+                errorStorageSet.add(dest);
               }
             }),
           );
@@ -756,21 +906,28 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
           lock.release();
         }
       } else {
-        // 登録されているトランスフォーマーを順番に適用してデータをエンコードします。
-        let data = value;
-        for (const transformer of this.#transformers) {
-          data = await transformer.encode(context, signal, data);
+        // 各ストレージ専用の前段パイプラインでデータをエンコードします。共有プレフィックスは使い回します。
+        let longest: readonly UniKvsTransformer[] = [];
+        for (const dest of this.#destinations) {
+          if (dest.transformers.length > longest.length) {
+            longest = dest.transformers;
+          }
+        }
+        const prefix: unknown[] = [value];
+        for (const transformer of longest) {
+          prefix.push(await transformer.encode(vars, signal, prefix[prefix.length - 1]));
         }
+        const encoded = this.#destinations.map((dest) => prefix[dest.transformers.length]);
 
         const lock = await io.lock({ key, signal });
         try {
           await Promise.all(
-            this.#destinations.map(async (storage) => {
+            this.#destinations.map(async (dest, i) => {
               try {
-                await storage.write(context, signal, key, data);
+                await dest.storage.write(vars, signal, key, encoded[i]);
               } catch (reason) {
                 errors.push({ reason });
-                errorStorageSet.add(storage);
+                errorStorageSet.add(dest);
               }
             }),
           );
@@ -789,13 +946,13 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
         {
           const errors: unknown[] = [];
           await Promise.all(
-            this.#destinations.map(async (storage) => {
-              if (errorStorageSet.has(storage)) {
+            this.#destinations.map(async (dest) => {
+              if (errorStorageSet.has(dest)) {
                 return;
               }
 
               try {
-                await storage.onOtherWriteError(context, signal, key, error);
+                await dest.storage.onOtherWriteError(vars, signal, key, error);
               } catch (ex) {
                 errors.push(ex);
               }
@@ -814,23 +971,14 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   }
 
   /**
-   * 指定したオプションで値を取得します。
-   *
-   * @template TKey 対象キーの型定義です。
-   * @param options 取得操作のオプション一式です。
-   * @returns 取得した値を返します。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
    */
   public get<const TKey extends KeyofKeyValueMappingHasPlainValue<TKeyValueMapping>>(
     options: GetOptions<TKey>,
   ): Promise<$InferPlainValueData<TKeyValueMapping[TKey]>>;
 
   /**
-   * 指定したキーから値を取得します。
-   *
-   * @template TKey 対象キーの型定義です。
-   * @param key 操作対象を識別するためのキーです。
-   * @param options 追加のオプションです。
-   * @returns 取得した値を返します。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
    */
   public get<const TKey extends KeyofKeyValueMappingHasPlainValue<TKeyValueMapping>>(
     key: TKey,
@@ -843,14 +991,16 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     }
 
     const [options] = v.parseInput(GetArgsSchema, args);
-    const { key, signal: signalOption, context: contextOption } = options;
+    const { key, signal: signalOption, vars: varsOption } = options;
+
+    const valueSchema = this.#resolveValueSchema(key);
 
     const { ac, io } = this.#con;
     const signal = combineSignals([ac.signal, signalOption]);
 
-    const context = mergeContext(this.#context, contextOption);
-    context["unikvs:action"] = "get";
-    context["unikvs:key"] = key;
+    const vars = mergeVariables(this.#vars, varsOption);
+    vars["unikvs:action"] = "get";
+    vars["unikvs:key"] = key;
 
     const lock = await asyncmux.readonly(this, signal);
     try {
@@ -861,14 +1011,27 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
 
       const NONE = {};
       let data: any = NONE;
+      let transformers: readonly UniKvsTransformer[] = [];
+      const errors: { reason: unknown }[] = [];
 
       const lock = await io.rLock({ key, signal });
       try {
         // 各ストレージを巡回し、最初に見つかったデータを取得します。
-        for (const storage of this.#destinations) {
-          if (await storage.exists(context, signal, key)) {
-            data = await storage.read(context, signal, key);
+        // あるストレージの読み取りに失敗しても、他のストレージからデータを取得できるようにフォールバックします。
+        for (const dest of this.#destinations) {
+          try {
+            if (!(await dest.storage.exists(vars, signal, key))) {
+              continue;
+            }
+            data = await dest.storage.read(vars, signal, key);
+            transformers = dest.transformers;
             break;
+          } catch (ex) {
+            if (signal.aborted) {
+              throw ex;
+            }
+            errors.push({ reason: ex });
+            logger.error`Failed to read from a storage: ${ex}`;
           }
         }
       } finally {
@@ -876,14 +1039,32 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
       }
 
       if (data === NONE) {
-        throw new KeyNotFoundError({ key });
+        const args: KeyNotFoundErrorArgs = { key };
+        switch (errors.length) {
+          case 0:
+            break;
+          case 1:
+            args.cause = errors[0]!.reason;
+            break;
+          default:
+            args.cause = new PluginOperationAggregateError({
+              plugin: "storage",
+              action: "read",
+              errors,
+            });
+        }
+
+        throw new KeyNotFoundError(args);
       }
 
-      // トランスフォーマーを逆順に適用してデータをデコードします。
-      if (this.#transformers.length > 0) {
-        for (const transformer of this.#transformers.toReversed()) {
-          data = await transformer.decode(context, signal, data);
-        }
+      // 見つかったストレージ専用の前段パイプラインを逆順に適用してデータをデコードします。
+      for (const transformer of transformers.toReversed()) {
+        data = await transformer.decode(vars, signal, data);
+      }
+
+      // デコード後のデータを検証します。
+      if (valueSchema) {
+        data = v.parseOutput(valueSchema.schema, data);
       }
 
       return data;
@@ -893,23 +1074,14 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   }
 
   /**
-   * 指定したオプションでストリームを取得します。
-   *
-   * @template TKey 対象キーの型定義です。
-   * @param options ストリーム取得操作のオプション一式です。
-   * @returns 取得したストリームを返します。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#value-stream)
    */
   public stream<const TKey extends KeyofKeyValueMappingHasStreamValue<TKeyValueMapping>>(
     options: StreamOptions<TKey>,
   ): Promise<ValueStream<$InferStreamValueChunkData<TKeyValueMapping[TKey]>>>;
 
   /**
-   * 指定したキーからストリームを取得します。
-   *
-   * @template TKey 対象キーの型定義です。
-   * @param key 操作対象を識別するためのキーです。
-   * @param options 追加のオプションです。
-   * @returns 取得したストリームを返します。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#value-stream)
    */
   public stream<const TKey extends KeyofKeyValueMappingHasStreamValue<TKeyValueMapping>>(
     key: TKey,
@@ -922,16 +1094,18 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     }
 
     const [options] = v.parseInput(StreamArgsSchema, args);
-    const { key, signal: signalOption, context: contextOption } = options;
+    const { key, signal: signalOption, vars: varsOption } = options;
+
+    const valueSchema = this.#resolveValueSchema(key);
 
     const { ac, io } = this.#con;
     const signal = combineSignals([ac.signal, signalOption]);
 
-    const context = mergeContext(this.#context, contextOption);
-    context["unikvs:action"] = "stream";
-    context["unikvs:key"] = key;
+    const vars = mergeVariables(this.#vars, varsOption);
+    vars["unikvs:action"] = "stream";
+    vars["unikvs:key"] = key;
 
-    const lock = await asyncmux(this, signal);
+    const lock = await asyncmux.readonly(this, signal);
     try {
       // ロック待機中に接続状態が変更されていないか再確認します。
       if (this.#con === null) {
@@ -940,34 +1114,70 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
 
       const NONE: any = {};
       let r: IReadableStream = NONE;
+      let transformers: readonly UniKvsTransformer[] = [];
+      const errors: { reason: unknown }[] = [];
 
       const lock = await io.rLock({ key, signal });
       try {
         // 各ストレージを巡回し、最初に見つかったデータを取得します。
-        for (const storage of this.#destinations) {
-          if (await storage.exists(context, signal, key)) {
-            r = await storage.getReadable(context, signal, key);
+        // あるストレージの読み取りに失敗しても、他のストレージからデータを取得できるようにフォールバックします。
+        for (const dest of this.#destinations) {
+          try {
+            if (!(await dest.storage.exists(vars, signal, key))) {
+              continue;
+            }
+
+            r = await dest.storage.getReadable(vars, signal, key);
+            transformers = dest.transformers;
             break;
+          } catch (ex) {
+            if (signal.aborted) {
+              throw ex;
+            }
+
+            errors.push({ reason: ex });
+            logger.error`Failed to read from a storage: ${ex}`;
           }
         }
 
         if (r === NONE) {
-          throw new KeyNotFoundError({ key });
+          const args: KeyNotFoundErrorArgs = { key };
+          switch (errors.length) {
+            case 0:
+              break;
+            case 1:
+              args.cause = errors[0]!.reason;
+              break;
+            default:
+              args.cause = new PluginOperationAggregateError({
+                plugin: "storage",
+                action: "read",
+                errors,
+              });
+          }
+
+          throw new KeyNotFoundError(args);
         }
 
-        // トランスフォーマーを逆順に適用し、デコード用トランスフォームを連結します。
-        if (this.#transformers.length > 0) {
-          for (const transformer of this.#transformers.toReversed()) {
-            const d = await transformer.getDecodable(context, signal);
-            r = r.pipeThrough(d);
-          }
+        // 見つかったストレージ専用の前段パイプラインを逆順に適用し、デコード用トランスフォームを連結します。
+        for (const transformer of transformers.toReversed()) {
+          const d = await transformer.getDecodable(vars, signal);
+          r = r.pipeThrough(d);
+        }
+
+        // デコード後のチャンクを検証します。
+        if (valueSchema) {
+          r = r.pipeThrough(
+            new TransformStream({
+              transform(chunk, controller) {
+                controller.enqueue(v.parseOutput(valueSchema.schema, chunk));
+              },
+            }),
+          );
         }
 
         if (!ioLockRegistry) {
           return toValueStream(r, async () => {
-            try {
-              await r.cancel();
-            } catch {}
             try {
               lock.release();
             } catch {}
@@ -979,19 +1189,30 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
           try {
             ioLockRegistry.unregister(unregisterToken);
           } catch {}
-          try {
-            await r.cancel();
-          } catch {}
           try {
             lock.release();
           } catch {}
         });
 
-        // valueStream が GC されるタイミングでストリームが終了していなければロックを自動解放します。
-        ioLockRegistry.register(valueStream, lock, unregisterToken);
+        // valueStream が GC されるタイミングでストリームが終了していなければロックを自動解放するとともに、ソースストリームが保持するリソース (S3 レスポンスボディなど) を解放できるように dispose を記録します。
+        ioLockRegistry.register(
+          valueStream,
+          {
+            lock,
+            dispose: valueStream.dispose,
+          },
+          unregisterToken,
+        );
 
         return valueStream;
       } catch (ex) {
+        if (r !== NONE) {
+          // getReadable 成功後のセットアップ中に失敗した場合、ソースストリームが保持するリソース (S3 レスポンスボディなど) を解放するためにキャンセルします。
+          try {
+            await r.cancel(ex);
+          } catch {}
+        }
+
         lock.release();
         throw ex;
       }
@@ -1001,19 +1222,12 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   }
 
   /**
-   * 指定したオプションでキーの存在を確認します。
-   *
-   * @param options 存在確認操作のオプションです。
-   * @returns 存在する場合は true、そうでない場合は false を返します。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
    */
   public has(options: HasOptions<KeyofKeyValueMapping<TKeyValueMapping>>): Promise<boolean>;
 
   /**
-   * 指定したキーが存在するかを確認します。
-   *
-   * @param key 操作対象を識別するためのキーです。
-   * @param options 追加のオプションです。
-   * @returns 存在する場合は true、そうでない場合は false を返します。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
    */
   public has(
     key: KeyofKeyValueMapping<TKeyValueMapping>,
@@ -1026,16 +1240,19 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     }
 
     const [options] = v.parseInput(HasArgsSchema, args);
-    const { key, signal: signalOption, context: contextOption } = options;
+    const { key, signal: signalOption, vars: varsOption } = options;
+
+    // キーがキースキーマに一致するかを検証します。
+    this.#resolveValueSchema(key);
 
     const { ac, io } = this.#con;
     const signal = combineSignals([ac.signal, signalOption]);
 
-    const context = mergeContext(this.#context, contextOption);
-    context["unikvs:action"] = "has";
-    context["unikvs:key"] = key;
+    const vars = mergeVariables(this.#vars, varsOption);
+    vars["unikvs:action"] = "has";
+    vars["unikvs:key"] = key;
 
-    const lock = await asyncmux(this, signal);
+    const lock = await asyncmux.readonly(this, signal);
     try {
       // ロック待機中に接続状態が変更されていないか再確認します。
       if (this.#con === null) {
@@ -1045,12 +1262,40 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
       const lock = await io.rLock({ key, signal });
       try {
         // いずれかのストレージに存在すれば true を返します。
-        for (const storage of this.#destinations) {
-          if (await storage.exists(context, signal, key)) {
-            return true;
+        // あるストレージの存在確認に失敗しても、他のストレージで存在を確認できるようにフォールバックします。
+        const errors: { reason: unknown }[] = [];
+        for (const { storage } of this.#destinations) {
+          try {
+            if (await storage.exists(vars, signal, key)) {
+              return true;
+            }
+          } catch (ex) {
+            if (signal.aborted) {
+              throw ex;
+            }
+            errors.push({ reason: ex });
+            logger.error`Failed to check existence in a storage: ${ex}`;
           }
         }
 
+        // すべてのストレージで存在を確認できなかった場合は結果が不明のため、get() と同様にエラーとして報告します。
+        if (errors.length > 0) {
+          const args: KeyNotFoundErrorArgs = { key };
+          switch (errors.length) {
+            case 1:
+              args.cause = errors[0]!.reason;
+              break;
+            default:
+              args.cause = new PluginOperationAggregateError({
+                plugin: "storage",
+                action: "read",
+                errors,
+              });
+          }
+
+          throw new KeyNotFoundError(args);
+        }
+
         return false;
       } finally {
         lock.release();
@@ -1061,19 +1306,12 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   }
 
   /**
-   * 指定したオプションでキーを削除します。
-   *
-   * @param options 削除操作のオプションです。
-   * @returns 完了を通知する Promise です。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
    */
   public delete(options: DeleteOptions<KeyofKeyValueMapping<TKeyValueMapping>>): Promise<void>;
 
   /**
-   * 指定したキーを削除します。
-   *
-   * @param key 操作対象を識別するためのキーです。
-   * @param options 追加のオプションです。
-   * @returns 完了を通知する Promise です。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
    */
   public delete(
     key: KeyofKeyValueMapping<TKeyValueMapping>,
@@ -1086,14 +1324,17 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     }
 
     const [options] = v.parseInput(DeleteArgsSchema, args);
-    const { key, signal: signalOption, context: contextOption } = options;
+    const { key, signal: signalOption, vars: varsOption } = options;
+
+    // キーがキースキーマに一致するかを検証します。
+    this.#resolveValueSchema(key);
 
     const { ac, io } = this.#con;
     const signal = combineSignals([ac.signal, signalOption]);
 
-    const context = mergeContext(this.#context, contextOption);
-    context["unikvs:action"] = "delete";
-    context["unikvs:key"] = key;
+    const vars = mergeVariables(this.#vars, varsOption);
+    vars["unikvs:action"] = "delete";
+    vars["unikvs:key"] = key;
 
     const lock = await asyncmux(this, signal);
     try {
@@ -1108,10 +1349,10 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
         // すべての処理を並列に実行し、エラーが発生した場合は集約します。
         const errors: { reason: unknown }[] = [];
         await Promise.all(
-          this.#destinations.map(async (storage) => {
+          this.#destinations.map(async ({ storage }) => {
             try {
-              if (await storage.exists(context, signal, key)) {
-                await storage.delete(context, signal, key);
+              if (await storage.exists(vars, signal, key)) {
+                await storage.delete(vars, signal, key);
               }
             } catch (reason) {
               errors.push({ reason });
@@ -1130,10 +1371,7 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   }
 
   /**
-   * すべてのストレージ内のデータを全削除します。
-   *
-   * @param options クリア操作のオプションです。
-   * @returns 完了を通知する Promise です。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
    */
   public async clear(options?: ClearOptions): Promise<void>;
 
@@ -1143,13 +1381,13 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
     }
 
     const [options = {}] = v.parseInput(ClearArgsSchema, args);
-    const { signal: signalOption, context: contextOption } = options;
+    const { signal: signalOption, vars: varsOption } = options;
 
     const { ac, io } = this.#con;
     const signal = combineSignals([ac.signal, signalOption]);
 
-    const context = mergeContext(this.#context, contextOption);
-    context["unikvs:action"] = "clear";
+    const vars = mergeVariables(this.#vars, varsOption);
+    vars["unikvs:action"] = "clear";
 
     const lock = await asyncmux(this, signal);
     try {
@@ -1164,9 +1402,9 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
         // すべての処理を並列に実行し、エラーが発生した場合は集約します。
         const errors: { reason: unknown }[] = [];
         await Promise.all(
-          this.#destinations.map(async (storage) => {
+          this.#destinations.map(async ({ storage }) => {
             try {
-              await storage.clear(context, signal);
+              await storage.clear(vars, signal);
             } catch (reason) {
               errors.push({ reason });
             }