unikvs 0.0.10 → 0.0.13

package/src/unikvs.ts

@@ -1,677 +1,590 @@
-import type { Context, IStorage, IReadableStream } from "@unikvs/core";
-import { combineSignals } from "abort-signal-utils";
-import { type AsyncmuxLock, asyncmux, Asyncmux } from "asyncmux";
+import { type IMiddleware, type IReadableStream, RepairNotAllowedError } from "@unikvs/core";
+import { combineSignals, throwIfAborted } from "abort-signal-utils";
+import { type AsyncmuxLock, Asyncmux, asyncmux } from "asyncmux";
 
-import logger from "./_logger.js";
-import mergeContext from "./_merge-context.js";
-import UniKvsStorage from "./_storage.js";
+import {
+  type VariablesInit,
+  type VariablesEntry,
+  type VariablesStore,
+  GetContext,
+  HasContext,
+  SetContext,
+  OpenContext,
+  ClearContext,
+  CloseContext,
+  DeleteContext,
+  StreamContext,
+  createVariablesStore,
+} from "./_contexts.js";
+import { logger, repairLogger } from "./_logger.js";
+import type UniKvsMiddleware from "./_middleware.js";
+import type { PipelineGraph } from "./_pipeline-graph.js";
+import type { PipelineLeaf, ResolvedLeaf, StreamEncodeTarget } from "./_pipeline-graph.types.js";
+import { cancelStreams, 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 {
+  GetArgsSchema,
+  HasArgsSchema,
+  SetArgsSchema,
+  OpenArgsSchema,
+  ClearArgsSchema,
+  CloseArgsSchema,
+  DeleteArgsSchema,
+  StreamArgsSchema,
+  VariablesArgsSchema,
+} from "./_unikvs.schemas.js";
+import { parseInput, parseOutput } from "./_valibot.js";
+import type {
+  ValueSchemaInfo,
+  $InferPlainValueData,
+  IValueSchemaResolver,
+  $InferStreamValueChunkData,
+} from "./_value-schemas.js";
+import { parseSetValue } from "./_value-validation.js";
 import {
   type KeyNotFoundErrorArgs,
   KeyNotFoundError,
   UniKvsIsOpenError,
-  PluginOperationAggregateError,
   UniKvsIsNotOpenError,
+  MiddlewareNextNotCalledError,
+  MiddlewareNextNotAwaitedError,
+  PluginOperationAggregateError,
+  MiddlewareNextCalledMultipleTimesError,
 } from "./errors.js";
-import UniKvsConfig, {
-  type Value,
-  type PlainValue,
-  type StreamValue,
-  type KeyValueMapping,
-  type $InferPlainValueData,
-  type IUniKvsConfigBuilder,
-  type KeyofKeyValueMapping,
-  type $InferStreamValueChunkData,
-} from "./unikvs-config.js";
-import type { ValueOf } from "./utils.types.js";
-import type { ValueStream } from "./value-stream.types.js";
-
-// -------------------------------------------------------------------------------------------------
-//
-// ユーティリテー
-//
-// -------------------------------------------------------------------------------------------------
-
-/**
- * 設定可能な値の型定義です。
- *
- * @template TValue 値の型定義です。
- */
-export type SetValue<TValue extends Value> =
-  | $InferPlainValueData<TValue>
-  | (TValue extends StreamValue<infer TChunkData> ? ReadableStream<TChunkData> : never);
+import type { IValueStream } from "./types.js";
+import type { KeyValueMapping } from "./unikvs-branch.js";
+import type {
+  SetValue,
+  GetOptions,
+  HasOptions,
+  SetOptions,
+  OpenOptions,
+  ClearOptions,
+  CloseOptions,
+  DeleteOptions,
+  StreamOptions,
+  KeyofKeyValueMapping,
+  KeyofKeyValueMappingHasPlainValue,
+  KeyofKeyValueMappingHasStreamValue,
+} from "./unikvs.types.js";
 
 /**
- * プレーンな値を持つキーのみを抽出する型定義です。
- *
- * @template TKeyValueMapping キーと値のマッピング定義です。
- */
-export type KeyofKeyValueMappingHasPlainValue<TKeyValueMapping extends KeyValueMapping> = ValueOf<{
-  [TKey in KeyofKeyValueMapping<TKeyValueMapping>]: PlainValue extends TKeyValueMapping[TKey]
-    ? TKey
-    : never;
-}>;
-
-/**
- * ストリーム形式の値を持つキーのみを抽出する型定義です。
- *
- * @template TKeyValueMapping キーと値のマッピング定義です。
+ * ストリームの読み取りロックを自動解放するための FinalizationRegistry です。
  */
-export type KeyofKeyValueMappingHasStreamValue<TKeyValueMapping extends KeyValueMapping> = ValueOf<{
-  [TKey in KeyofKeyValueMapping<TKeyValueMapping>]: StreamValue extends TKeyValueMapping[TKey]
-    ? TKey
-    : never;
-}>;
-
-// -------------------------------------------------------------------------------------------------
-//
-// スキーマ
-//
-// -------------------------------------------------------------------------------------------------
-
-const ContextKeySchema = v.string();
-
-// 配列形式の context も正当な入力であるため、record スキーマより先に判定する必要があります。
-// record スキーマは配列にもマッチして数値キーのオブジェクトに変換してしまうため、配列形式を先に処理しないと mergeContext での配列としてのマージが行われません。
-const ContextSourceSchema = v.union([
-  v.array(v.tuple([ContextKeySchema, v.unknown()])),
-  v.record(v.any(), v.unknown()),
-]);
-
-const OpenOptionsSchema = v.object({
-  /**
-   * 処理の中断を通知するためのシグナルです。
-   */
-  signal: v.optional(v.instance(AbortSignal)),
-
-  /**
-   * 実行時のコンテキスト情報です。
-   */
-  context: v.optional(ContextSourceSchema),
-});
-
-const OpenArgsSchema = v.tuple([v.optional(OpenOptionsSchema)]);
+const ioLockRegistry =
+  typeof FinalizationRegistry !== "function"
+    ? null
+    : new FinalizationRegistry<IoLockRegistryHeld>((held) => {
+        if (!held.lock.released) {
+          held.lock.release();
+        }
 
-const CloseOptionsSchema = v.object({
-  /**
-   * 処理の中断を通知するためのシグナルです。
-   */
-  signal: v.optional(v.instance(AbortSignal)),
+        // GC で回収された ValueStream のロックを解放し、ソースのリソースも破棄します。
+        // dispose は valueStream を参照しないため、GC を妨げません。失敗したときはログに残すだけにします。
+        // oxlint-disable-next-line promise/prefer-await-to-then
+        held.dispose().catch((ex) => {
+          logger.error`Failed to dispose value stream: ${ex}`;
+        });
+      });
 
+type IoLockRegistryHeld = {
   /**
-   * 実行時のコンテキスト情報です。
-   */
-  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({
-  /**
-   * 処理の中断を通知するためのシグナルです。
+   * stream 操作で取得したキーの読み取りロックです。
    */
-  signal: v.optional(v.instance(AbortSignal)),
+  readonly lock: AsyncmuxLock;
 
   /**
-   * 実行時のコンテキスト情報です。
+   * {@linkcode ValueStream.dispose} です。ソースストリームのキャンセルとロック解放を行います。
    */
-  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>;
+  readonly dispose: () => Promise<void>;
+};
 
 /**
- * 保存操作時のオプションです。
- *
- * @template TKeyValueMapping キーと値のマッピング定義です。
- * @template TKey 対象となるキーの型です。
+ * 接続状態を管理する内部オブジェクトです。
  */
-export type SetOptions<
-  TKeyValueMapping extends KeyValueMapping = KeyValueMapping,
-  TKey extends KeyofKeyValueMapping<TKeyValueMapping> = KeyofKeyValueMapping<TKeyValueMapping>,
-> = {
-  /**
-   * 操作対象を識別するためのキーです。
-   */
-  readonly key: TKey;
-
-  /**
-   * 保存する値です。
-   */
-  readonly value: SetValue<TKeyValueMapping[TKey]>;
-
+type Connection = {
   /**
-   * 処理の中断を通知するためのシグナルです。
+   * 接続全体を管理する AbortController です。
    */
-  readonly signal?: AbortSignal | undefined;
+  readonly ac: AbortController;
 
   /**
-   * 実行時のコンテキスト情報です。
+   * I/O の多重化を制御する Asyncmux インスタンスです。
    */
-  readonly context?: ContextSource | undefined;
+  readonly io: Asyncmux;
 };
 
 /**
- * 取得操作時のオプションです。
- *
- * @template TKey 対象となるキーの型です。
+ * プラグイン操作の失敗を集約するための 1 件分の記録です。
  */
-export type GetOptions<TKey = IStorage.Key> = {
+type PluginErrorRecord = {
   /**
-   * 操作対象を識別するためのキーです。
+   * 失敗したプラグインの名前です。
    */
-  readonly key: TKey;
+  readonly name: string;
 
   /**
-   * 処理の中断を通知するためのシグナルです。
+   * 宛先またはプラグインの登録順 (0 起点) です。
    */
-  readonly signal?: AbortSignal | undefined;
+  readonly index: number;
 
   /**
-   * 実行時のコンテキスト情報です。
+   * 失敗の理由です。
    */
-  readonly context?: ContextSource | undefined;
+  readonly reason: unknown;
 };
 
 /**
- * ストリーム取得操作時のオプションです。
- *
- * @template TKey 対象となるキーの型です。
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
  */
-export type StreamOptions<TKey = IStorage.Key> = {
+export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueMapping> {
   /**
-   * 操作対象を識別するためのキーです。
+   * 現在の接続状態です。非接続時は null となります。
    */
-  readonly key: TKey;
+  #con: Connection | null;
 
-  /**
-   * 処理の中断を通知するためのシグナルです。
-   */
-  readonly signal?: AbortSignal | undefined;
+  readonly #acSet: Set<AbortController>;
 
   /**
-   * 実行時のコンテキスト情報です。
+   * 基本となる実行変数情報です。
+   *
+   * コンストラクターで受け取った初期値をエントリー列で保持します。操作ごとに複写して使用します。
    */
-  readonly context?: ContextSource | undefined;
-};
+  #baseVars: readonly VariablesEntry[];
 
-/**
- * 存在確認操作時のオプションです。
- *
- * @template TKey 対象となるキーの型です。
- */
-export type HasOptions<TKey = IStorage.Key> = {
   /**
-   * 操作対象を識別するためのキーです。
+   * コンパイル済みのパイプライン・グラフです。
    */
-  readonly key: TKey;
+  readonly #pipeline: PipelineGraph;
 
   /**
-   * 処理の中断を通知するためのシグナルです。
+   * キーに対応する値のスキーマ情報を解決するリゾルバーです。スキーマ未設定時は null となります。
    */
-  readonly signal?: AbortSignal | undefined;
+  readonly #valueSchemaResolver: IValueSchemaResolver | null;
 
   /**
-   * 実行時のコンテキスト情報です。
+   * @internal
    */
-  readonly context?: ContextSource | undefined;
-};
+  public constructor(
+    vars: readonly VariablesEntry[],
+    pipeline: PipelineGraph,
+    valueSchemaResolver: IValueSchemaResolver | null = null,
+  ) {
+    this.#con = null;
+    this.#acSet = new Set();
+    this.#baseVars = vars;
+    this.#pipeline = pipeline;
+    this.#valueSchemaResolver = valueSchemaResolver;
+  }
 
-/**
- * 削除操作時のオプションです。
- *
- * @template TKey 対象となるキーの型です。
- */
-export type DeleteOptions<TKey = IStorage.Key> = {
   /**
-   * 操作対象を識別するためのキーです。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#base-vars-set-vars)
    */
-  readonly key: TKey;
+  public setVars(vars: VariablesInit): this;
+  public setVars(...args: unknown[]): this {
+    const [vars] = parseInput(VariablesArgsSchema, args);
+    this.#baseVars = vars;
 
-  /**
-   * 処理の中断を通知するためのシグナルです。
-   */
-  readonly signal?: AbortSignal | undefined;
+    return this;
+  }
 
   /**
-   * 実行時のコンテキスト情報です。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#base-vars-assign-vars)
    */
-  readonly context?: ContextSource | undefined;
-};
+  public assignVars(vars: VariablesInit): this;
+  public assignVars(...args: unknown[]): this {
+    const [vars] = parseInput(VariablesArgsSchema, args);
 
-/**
- * 全削除操作時のオプションです。
- */
-export type ClearOptions = v.InferInput<typeof ClearOptionsSchema>;
+    const map = new Map(this.#baseVars);
 
-// -------------------------------------------------------------------------------------------------
-//
-// UniKvs
-//
-// -------------------------------------------------------------------------------------------------
+    for (const [name, value] of vars) {
+      map.set(name, value);
+    }
 
-/**
- * ストリームの読み取りロックを自動解放するための FinalizationRegistry です。
- */
-const ioLockRegistry =
-  typeof FinalizationRegistry !== "function"
-    ? null
-    : new FinalizationRegistry<IoLockRegistryHeld>((held) => {
-        if (!held.lock.released) {
-          held.lock.release();
-        }
+    this.#baseVars = [...map];
 
-        // valueStream が読み取られないまま GC されたとき、ソースストリームが保持するリソース (S3 レスポンスボディなど) を解放するために破棄します。
-        // dispose は valueStream 自身を参照しないため、これを保持しても valueStream のガベージコレクションを妨げません。
-        // 失敗しても対処できないので無視します。
-        held.dispose().catch((ex) => {
-          logger.error`Failed to dispose value stream: ${ex}`;
-        });
-      });
+    return this;
+  }
 
-type IoLockRegistryHeld = {
   /**
-   * stream 操作で取得したキーの読み取りロックです。
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#base-vars-defaults-vars)
    */
-  readonly lock: AsyncmuxLock;
+  public defaultsVars(vars: VariablesInit): this;
+  public defaultsVars(...args: unknown[]): this {
+    const [vars] = parseInput(VariablesArgsSchema, args);
 
-  /**
-   * {@linkcode ValueStream.dispose} です。ソースストリームのキャンセルとロック解放を行います。
-   */
-  readonly dispose: () => Promise<void>;
-};
+    const map = new Map(vars);
 
-/**
- * 接続状態を管理する内部オブジェクトです。
- */
-type Connection = {
-  /**
-   * 接続全体を管理する AbortController です。
-   */
-  readonly ac: AbortController;
+    for (const [name, value] of this.#baseVars) {
+      map.set(name, value);
+    }
+
+    this.#baseVars = [...map];
+
+    return this;
+  }
 
   /**
-   * I/O の多重化を制御する Asyncmux インスタンスです。
+   * 基本変数と操作固有変数を結合した実行時変数マップを作成します。
+   *
+   * @param vars 操作固有の変数です。
+   *
+   * @returns 結合した変数マップを返します。
    */
-  readonly io: Asyncmux;
-};
+  #createOperationVars(vars: readonly VariablesEntry[] | undefined): Map<string, unknown> {
+    const map = new Map(this.#baseVars);
+
+    if (vars) {
+      for (const [k, v] of vars) {
+        map.set(k, v);
+      }
+    }
+
+    return map;
+  }
 
-/**
- * UniKvs メインクラスです。
- *
- * 複数のストレージとトランスフォーマーを統合して KVS 操作を提供します。
- *
- * @template TKeyValueMapping キーと値のマッピング定義です。
- */
-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";
+   * 同一操作内の全コンテキスト (`use`/`encode`/`decode`/ ストレージ) で共有され、下流の `set` が上流の `await next()` 後の `get` に見えます。
    *
-   * const kvs = UniKvs.config<{
-   *   foo: Value<Uint8Array<ArrayBuffer>>;
-   * }>()
-   *   .appendTransformer(new Compression("gzip"))
-   *   .appendStorage(new FileSystem(".tmp"))
-   *   .create();
+   * @param vars 操作固有の変数です。
    *
-   * await kvs.open();
+   * @returns 共有ストアを返します。
+   */
+  #createOperationStore(vars: readonly VariablesEntry[] | undefined): VariablesStore {
+    return createVariablesStore([...this.#baseVars, ...(vars ?? [])]);
+  }
+
+  /**
+   * キーに対応する値のスキーマ情報を解決します。
    *
-   * await kvs.set("foo", Uint8Array.from([0, 1, 2]));
+   * @param key 解決するキーです。
    *
-   * await kvs.close();
-   * ```
+   * @returns 対応するスキーマ情報を返します。スキーマ未設定または対応する定義がない場合は `undefined` を返します。
    */
-  public static config<
-    TKeyValueMapping extends KeyValueMapping,
-  >(): IUniKvsConfigBuilder<TKeyValueMapping> {
-    return new UniKvsConfig(this);
+  #resolveValueSchema(key: string): ValueSchemaInfo | undefined {
+    return this.#valueSchemaResolver?.resolve(key);
   }
 
   /**
-   * 現在の接続状態です。非接続時は null となります。
+   * すべての宛先で読み取りに失敗したときのエラーを組み立てます。
+   *
+   * @param key 読み取ったキーです。
+   * @param errors 収集した失敗です。
+   *
+   * @returns `KeyNotFoundError` を返します。
    */
-  #con: Connection | null;
+  #notFound(key: string, errors: readonly PluginErrorRecord[]): KeyNotFoundError {
+    const args: KeyNotFoundErrorArgs = { key };
 
-  readonly #acSet: Set<AbortController>;
+    switch (errors.length) {
+      case 0: {
+        break;
+      }
 
-  /**
-   * 基本となる実行コンテキスト情報です。
-   */
-  readonly #context: Readonly<Context>;
+      case 1: {
+        const [firstError] = errors;
 
-  /**
-   * データの永続化先となるストレージのリストです。
-   */
-  readonly #destinations: readonly [UniKvsStorage, ...UniKvsStorage[]];
+        if (firstError !== undefined) {
+          args.cause = firstError.reason;
+        }
 
-  /**
-   * データの変換を行うトランスフォーマーのリストです。
-   */
-  readonly #transformers: readonly UniKvsTransformer[];
+        break;
+      }
 
-  /**
-   * インスタンスを初期化します。
-   *
-   * @internal UniKvs の設定ビルダー経由で使用します。
-   * @param context コンテキストです。
-   * @param destinations ストレージのリストです。
-   * @param transformers トランスフォーマーのリストです。
-   */
-  public constructor(
-    context: Readonly<Context>,
-    destinations: readonly [UniKvsStorage, ...UniKvsStorage[]],
-    transformers: readonly UniKvsTransformer[],
-  ) {
-    this.#con = null;
-    this.#acSet = new Set();
-    this.#context = { ...context };
-    this.#destinations = destinations;
-    this.#transformers = transformers;
+      default: {
+        args.cause = new PluginOperationAggregateError({
+          action: "read",
+          errors,
+          plugin: "storage",
+        });
+      }
+    }
+
+    return new KeyNotFoundError(args);
   }
 
-  /**
-   * UniKvs が利用可能であるかを確認します。
-   *
-   * @returns 利用可能である場合は true、そうでない場合は false を返します。
-   */
   public get isOpen(): boolean {
     return this.#con !== null;
   }
 
-  /**
-   * すべてのストレージとトランスフォーマーを初期化します。
-   *
-   * @param options オープン時のオプションです。
-   * @returns 完了を通知する Promise です。
-   */
   public open(options?: OpenOptions): Promise<void>;
-
   public async open(...args: any): Promise<void> {
     if (this.#con !== null) {
       throw new UniKvsIsOpenError();
     }
 
-    const [options = {}] = v.parseInput(OpenArgsSchema, args);
-    const { signal: signalOption, context: contextOption } = options;
+    const [options = {}] = parseInput(OpenArgsSchema, args);
+    const { vars: varsOption, signal: signalOption } = options;
 
     const ac = new AbortController();
     const signal = combineSignals([ac.signal, signalOption]);
 
-    const context = mergeContext(this.#context, contextOption);
-    context["unikvs:action"] = "open";
-
-    signal.throwIfAborted();
-
+    const operationVars = this.#createOperationVars(varsOption);
+    throwIfAborted(signal);
     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"][] = [];
-
-      // 各ストレージのオープン処理をリストに追加します。
-      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",
-        ]);
-      }
-
-      // 各トランスフォーマーのオープン処理をリストに追加します。
-      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",
-        ]);
-      }
-
-      // すべての処理を並列に実行し、エラーが発生した場合は集約します。
-      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) {
-        // 中断以外の失敗が混在しない場合は、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(),
-      };
-    } catch (ex) {
-      if (dispose.length > 0) {
-        await Promise.all(
-          dispose.map(async (f) => {
-            await f();
-          }),
-        );
-      }
-
-      throw ex;
-    } finally {
-      this.#acSet.delete(ac);
-      lock.release();
-    }
-  }
-
-  async #close(context: Context, signal: AbortSignal, con: Connection): Promise<void> {
-    const lock = await asyncmux(this, signal);
     try {
-      // ロック待機中に接続状態が変更されていないか再確認します。
-      if (this.#con !== con) {
-        throw new UniKvsIsNotOpenError();
-      }
+      using _lock = await asyncmux(this, signal);
 
-      const { io } = this.#con;
-      const lock = await io.lock({ signal });
       try {
-        const closeFns: [() => Promise<void>, plugin: "storage" | "transformer"][] = [];
+        if (this.#con !== null) {
+          throw new UniKvsIsOpenError();
+        }
 
-        // ストレージのクローズ処理を登録します。
-        for (const plugin of this.#destinations) {
-          closeFns.push([
-            async () => {
-              await plugin.close(context, signal);
+        const openFns: [
+          () => Promise<void>,
+          plugin: "storage" | "middleware",
+          name: string,
+          index: number,
+        ][] = [];
+
+        // open/close 用の vars はプラグインごとに複製し、並列実行中の変更が他に見えないようにします。
+        for (const [index, leaf] of this.#pipeline.leaves.entries()) {
+          openFns.push([
+            async (): Promise<void> => {
+              const pluginVars = new Map(operationVars);
+              const c = new OpenContext({
+                vars: pluginVars.entries(),
+                signal,
+              });
+              await leaf.storage.open(c);
+              dispose.push(async () => {
+                try {
+                  const cc = new CloseContext({
+                    vars: pluginVars.entries(),
+                    signal,
+                  });
+                  await leaf.storage.close(cc);
+                } catch (ex) {
+                  logger.error`Failed to close storage: ${ex}`;
+                }
+              });
             },
             "storage",
+            leaf.name,
+            index,
           ]);
         }
 
-        // トランスフォーマーのクローズ処理を登録します。
-        for (const plugin of this.#transformers) {
-          closeFns.push([
-            async () => {
-              await plugin.close(context, signal);
+        // 各ミドルウェアのオープン処理をリストに追加します。
+        // ストレージと同様にプラグインごとに複製し、並列実行中の変更が互いに見えないようにします。
+        for (const [index, middleware] of this.#pipeline.middlewares.entries()) {
+          openFns.push([
+            async (): Promise<void> => {
+              const pluginVars = new Map(operationVars);
+              const c = new OpenContext({
+                vars: pluginVars.entries(),
+                signal,
+              });
+              await middleware.open(c);
+              dispose.push(async () => {
+                try {
+                  const cc = new CloseContext({
+                    vars: pluginVars.entries(),
+                    signal,
+                  });
+                  await middleware.close(cc);
+                } catch (ex) {
+                  logger.error`Failed to close middleware: ${ex}`;
+                }
+              });
             },
-            "transformer",
+            "middleware",
+            middleware.name,
+            index,
           ]);
         }
 
         // すべての処理を並列に実行し、エラーが発生した場合は集約します。
-        const errors: { plugin: "storage" | "transformer"; reason: unknown }[] = [];
+        const errors: {
+          name: string;
+          index: number;
+          plugin: "storage" | "middleware";
+          reason: unknown;
+        }[] = [];
         await Promise.all(
-          closeFns.map(async ([f, plugin]) => {
+          openFns.map(async ([f, plugin, name, index]) => {
             try {
               await f();
-            } catch (reason) {
-              errors.push({ plugin, reason });
+            } catch (ex) {
+              errors.push({
+                name,
+                index,
+                plugin,
+                reason: ex,
+              });
             }
           }),
         );
+
         if (errors.length > 0) {
-          throw new PluginOperationAggregateError({ action: "close", errors });
+          // 中断以外の失敗が混ざっていないときは、abort 理由が集約エラーに埋もれないようそのまま投げます。
+          if (signal.aborted && errors.every((error) => error.reason === signal.reason)) {
+            throw signal.reason;
+          }
+
+          throw new PluginOperationAggregateError({
+            action: "open",
+            errors,
+          });
+        }
+
+        // すべてのプラグインのオープンが成功した後も、待機中に中断されていないか最終確認します。
+        // 中断済みのシグナルを持つ接続を作ると、isOpen が true なのに以降の操作がすべて即座に失敗する不整合な状態になります。
+        throwIfAborted(signal);
+
+        this.#con = {
+          ac,
+          io: new Asyncmux(),
+        };
+      } catch (ex) {
+        if (dispose.length > 0) {
+          await Promise.all(
+            dispose.map(async (f) => {
+              await f();
+            }),
+          );
         }
-      } finally {
-        lock.release();
-      }
 
-      this.#con = null;
+        throw ex;
+      }
     } finally {
-      lock.release();
+      this.#acSet.delete(ac);
     }
   }
 
-  /**
-   * ストレージをクローズします。
-   *
-   * @param options クローズ時のオプションです。
-   * @returns 完了を通知する Promise です。
-   */
-  public close(options?: CloseOptions): Promise<void>;
+  async #close(
+    operationVars: Map<string, unknown>,
+    signal: AbortSignal,
+    con: Connection,
+    progress: { pluginsStarted: boolean },
+  ): Promise<void> {
+    using _lock = await asyncmux(this, signal);
+    // ロック待機中に接続状態が変更されていないか再確認します。
+    if (this.#con !== con) {
+      throw new UniKvsIsNotOpenError();
+    }
+
+    const { io } = this.#con;
+    using _ioLock = await io.lock({ signal });
+    const closeFns: [
+      () => Promise<void>,
+      () => Promise<void>,
+      plugin: "storage" | "middleware",
+      name: string,
+      index: number,
+    ][] = [];
+
+    // ストレージのクローズ処理を登録します。
+    // open と同じ方針でプラグインごとに複製し、並列実行中の変更が互いに見えないようにします。
+    for (const [index, leaf] of this.#pipeline.leaves.entries()) {
+      const createContext = (): CloseContext =>
+        new CloseContext({
+          vars: new Map(operationVars).entries(),
+          signal,
+        });
+      // 再試行は通常 close の失敗 (操作 signal の abort など) に引きずられないよう、新しいタイムアウト signal を使います。
+      const createRetryContext = (): CloseContext =>
+        new CloseContext({
+          vars: new Map(operationVars).entries(),
+          signal: AbortSignal.timeout(10e3),
+        });
+      closeFns.push([
+        (): Promise<void> => leaf.storage.close(createContext()),
+        (): Promise<void> => leaf.storage.retryClose(createRetryContext()),
+        "storage",
+        leaf.name,
+        index,
+      ]);
+    }
+
+    // ミドルウェアのクローズ処理を登録します。
+    for (const [index, plugin] of this.#pipeline.middlewares.entries()) {
+      const createContext = (): CloseContext =>
+        new CloseContext({
+          vars: new Map(operationVars).entries(),
+          signal,
+        });
+      // 再試行は通常 close の失敗 (操作 signal の abort など) に引きずられないよう、新しいタイムアウト signal を使います。
+      const createRetryContext = (): CloseContext =>
+        new CloseContext({
+          vars: new Map(operationVars).entries(),
+          signal: AbortSignal.timeout(10e3),
+        });
+      closeFns.push([
+        (): Promise<void> => plugin.close(createContext()),
+        (): Promise<void> => plugin.retryClose(createRetryContext()),
+        "middleware",
+        plugin.name,
+        index,
+      ]);
+    }
+
+    // すべての処理を並列に実行し、エラーが発生した場合は集約します。
+    progress.pluginsStarted = true;
+    const errors: {
+      name: string;
+      index: number;
+      plugin: "storage" | "middleware";
+      reason: unknown;
+    }[] = [];
+    const retries: (() => Promise<void>)[] = [];
+    await Promise.all(
+      closeFns.map(async ([f, retry, plugin, name, index]) => {
+        try {
+          await f();
+        } catch (ex) {
+          errors.push({
+            name,
+            index,
+            plugin,
+            reason: ex,
+          });
+          // 通常の close で再試行すると、close 失敗後に別の利用者が引き継いだ参照まで解放してしまいます。
+          retries.push(retry);
+        }
+      }),
+    );
+
+    if (errors.length > 0) {
+      // 失敗したプラグインだけを 1 回再試行します。
+      // 成功済みのプラグインを再 close すると、参照カウントが二重に解放され、共有している他の利用者の実体まで閉じてしまうためです。
+      await Promise.all(
+        retries.map(async (f) => {
+          try {
+            await f();
+          } catch (ex) {
+            logger.error`Failed to retry closing a plugin: ${ex}`;
+          }
+        }),
+      );
+
+      throw new PluginOperationAggregateError({
+        action: "close",
+        errors,
+      });
+    }
+
+    this.#con = null;
+  }
 
+  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 [options = {}] = parseInput(CloseArgsSchema, args);
+      const { vars: varsOption, signal = AbortSignal.timeout(10e3) } = options;
 
-      const context = mergeContext(this.#context, contextOption);
-      context["unikvs:action"] = "close";
+      const operationVars = this.#createOperationVars(varsOption);
 
       if (this.#con === null) {
         const acArr = [...this.#acSet];
+
         this.#acSet.clear();
+
         for (const ac of acArr) {
           if (!ac.signal.aborted) {
             ac.abort(new UniKvsIsNotOpenError());
@@ -684,45 +597,53 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
       const con = this.#con;
       const { ac } = con;
       const acArr = [ac, ...this.#acSet];
+
       this.#acSet.clear();
-      for (const ac of acArr) {
-        if (!ac.signal.aborted) {
-          ac.abort(new UniKvsIsNotOpenError());
+
+      for (const targetAc of acArr) {
+        if (!targetAc.signal.aborted) {
+          targetAc.abort(new UniKvsIsNotOpenError());
         }
       }
 
-      return this.#close(context, signal, con).catch(async (ex) => {
-        // #close が失敗した場合、コネクションの AbortController は既に abort 済みであり、以降の操作がすべて即座に失敗する壊れた状態になります。
-        // そこで接続を破棄して isOpen=false の一貫した状態にし、ベストエフォートでプラグインのクローズ処理を実行します。
+      const progress = { pluginsStarted: false };
+
+      return this.#close(operationVars, signal, con, progress).catch(async (closeError) => {
+        // #close が失敗した場合、コネクションの AbortController はすでに abort 済みで、以降の操作がすべて即座に失敗する不整合な状態になります。
+        // そこで接続を破棄して isOpen=false の一貫した状態に戻します。
         if (this.#con === con) {
           this.#con = null;
 
-          const disposeSignal = AbortSignal.timeout(10e3);
-          await Promise.all(
-            [...this.#destinations, ...this.#transformers].map(async (plugin) => {
-              try {
-                await plugin.close(context, disposeSignal);
-              } catch (reason) {
-                logger.error`Failed to close plugin after close failure: ${reason}`;
-              }
-            }),
-          );
+          // プラグインの close 段階まで到達していれば、成功分の参照は解放済みで、失敗分は #close が再試行済みです。
+          // ここで全プラグインを再度閉じると参照を二重解放してしまうため、close 段階に到達できなかったときだけ破棄します。
+          if (!progress.pluginsStarted) {
+            const disposeSignal = AbortSignal.timeout(10e3);
+            await Promise.all(
+              [
+                ...this.#pipeline.leaves.map((leaf) => leaf.storage),
+                ...this.#pipeline.middlewares,
+              ].map(async (plugin) => {
+                try {
+                  const c = new CloseContext({
+                    vars: new Map(operationVars).entries(),
+                    signal: disposeSignal,
+                  });
+                  await plugin.close(c);
+                } catch (disposeError) {
+                  logger.error`Failed to close plugin after close failure: ${disposeError}`;
+                }
+              }),
+            );
+          }
         }
 
-        throw ex;
+        throw closeError;
       });
     } catch (ex) {
       return Promise.reject(ex);
     }
   }
 
-  /**
-   * UniKvs が開いている場合にクローズします。
-   *
-   * `await using` 構文による自動クローズに使用されます。
-   *
-   * @returns 完了を通知する Promise です。
-   */
   async [Symbol.asyncDispose](): Promise<void> {
     if (!this.isOpen) {
       return;
@@ -734,391 +655,933 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
   }
 
   /**
-   * 指定したオプションで値を保存します。
+   * 書き込み失敗の集約と、成功した宛先への通知を行います。
    *
-   * @template TKey 対象キーの型定義です。
-   * @param options セット操作のオプション一式です。
-   * @returns 完了を通知する Promise です。
+   * @param targets 書き込みを試みた対象です。
+   * @param failed 失敗した葉の集合です。
+   * @param errors 集約する失敗です。
+   * @param signal 中断シグナルです。
    */
-  public set<const TKey extends KeyofKeyValueMapping<TKeyValueMapping>>(
-    options: SetOptions<TKeyValueMapping, TKey>,
-  ): Promise<void>;
+  async #finishWrites(
+    targets: readonly {
+      readonly key: string;
+      readonly leaf: PipelineLeaf;
+    }[],
+    store: VariablesStore,
+    failed: ReadonlySet<PipelineLeaf>,
+    errors: PluginErrorRecord[],
+    signal: AbortSignal,
+  ): Promise<void> {
+    if (errors.length === 0) {
+      return;
+    }
+
+    const error = new PluginOperationAggregateError({
+      action: "write",
+      errors,
+      plugin: "storage",
+    });
+    const notifyErrors: unknown[] = [];
+    await Promise.all(
+      targets.map(async (target) => {
+        // 失敗した宛先を除いたすべての宛先へ通知します。通知に失敗しても元の集約エラーは置き換えません。
+        if (failed.has(target.leaf)) {
+          return;
+        }
+
+        try {
+          const c = new SetContext({
+            key: target.key,
+            store,
+            signal,
+          });
+          await target.leaf.storage.onOtherWriteError(c, error);
+        } catch (ex) {
+          notifyErrors.push(ex);
+        }
+      }),
+    );
+
+    if (notifyErrors.length > 0) {
+      logger.error(new AggregateError(notifyErrors, "Failed to handle error"));
+    }
+
+    throw error;
+  }
 
   /**
-   * 指定したキーに値を保存します。
+   * ミドルウェアの `use` をオニオン実行し、失敗時は集約して投げます。
    *
-   * @template TKey 対象キーの型定義です。
-   * @param key 操作対象を識別するためのキーです。
-   * @param value 保存する値です。
-   * @param options 追加のオプションです。
-   * @returns 完了を通知する Promise です。
+   * 同一コンテキストオブジェクトを全ミドルウェアで共有し、`next` で下流をネスト実行するため、下流の `set` が上流の `await next()` 後の `get` に見えます。
+   * `encode`/`decode` と同じく `next()` の呼び出し規約を検証し、違反したときは操作を実行せず失敗させます (fail-close)。
+   * いずれかのミドルウェアが投げたときは即時に確定し、後段は実行しません (fail-fast)。
+   * 失敗は集約エラー (単一件) として投げます。
+   *
+   * @param action 集約エラーに付与する操作名です。
+   * @param c 共有の `use` コンテキストです。
    */
+  async #use(
+    action: "read" | "write" | "delete" | "clear",
+    c: IMiddleware.UseContext,
+  ): Promise<void> {
+    throwIfAborted(c.signal);
+
+    const middlewares = this.#pipeline.middlewares;
+    const dispatch = async (index: number): Promise<void> => {
+      const maybeMiddleware = middlewares[index];
+
+      if (maybeMiddleware === undefined) {
+        return;
+      }
+
+      const middleware: UniKvsMiddleware = maybeMiddleware;
+
+      let nextCalled = false;
+      let nextSettled = false;
+      let downstreamError: unknown;
+      let hasDownstreamError = false;
+
+      function next(): Promise<void> {
+        if (nextCalled) {
+          // 2 回目以降の `next()` は下流を実行せず拒否だけを返します。
+          const rejection = Promise.reject(
+            new MiddlewareNextCalledMultipleTimesError({
+              name: middleware.name,
+              operation: "use",
+            }),
+          );
+          // 呼び出し側が切り離した場合の未処理 rejection を防ぎます。await したときは従来どおり拒否されます。
+          // oxlint-disable-next-line promise/prefer-await-to-then
+          rejection.catch(() => {});
+
+          return rejection;
+        }
+
+        nextCalled = true;
+
+        const promise = Promise.try(async () => {
+          try {
+            await dispatch(index + 1);
+          } catch (ex) {
+            // 下流の失敗を親自身の失敗と取り違えないよう、由来を記録します。
+            downstreamError = ex;
+            hasDownstreamError = true;
+            throw ex;
+          } finally {
+            nextSettled = true;
+          }
+        });
+        // 呼び出し側が切り離した場合の未処理 rejection を防ぎます。await したときは従来どおり拒否されます。
+        // oxlint-disable-next-line promise/prefer-await-to-then
+        promise.catch(() => {});
+
+        return promise;
+      }
+
+      try {
+        await middleware.use(c, next);
+        throwIfAborted(c.signal);
+        if (!nextCalled) {
+          throw new MiddlewareNextNotCalledError({
+            name: middleware.name,
+            operation: "use",
+          });
+        }
+
+        if (!nextSettled) {
+          throw new MiddlewareNextNotAwaitedError({
+            name: middleware.name,
+            operation: "use",
+          });
+        }
+      } catch (ex) {
+        // 中断による失敗はそのまま投げます。
+        if (c.signal.aborted && ex === c.signal.reason) {
+          throw ex;
+        }
+
+        // 規約違反はプログラミングエラーであり、集約せずに投げます。
+        if (
+          ex instanceof MiddlewareNextNotCalledError ||
+          ex instanceof MiddlewareNextNotAwaitedError ||
+          ex instanceof MiddlewareNextCalledMultipleTimesError
+        ) {
+          throw ex;
+        }
+
+        // `next()` から伝播した下流の失敗は再集約せず、そのまま投げます。
+        if (hasDownstreamError && ex === downstreamError) {
+          throw ex;
+        }
+
+        throw new PluginOperationAggregateError({
+          action,
+          errors: [
+            {
+              name: middleware.name,
+              index,
+              reason: ex,
+            },
+          ],
+          plugin: "middleware",
+        });
+      }
+    };
+    await dispatch(0);
+  }
+
+  /**
+   * プレーン値の並列書き込みを行います。
+   *
+   * @param io 多重化インスタンスです。
+   * @param signal 中断シグナルです。
+   * @param key 書き込みキーです。
+   * @param store 操作内で共有される変数ストアです。
+   * @param value 書き込む値です.
+   */
+  async #setPlain(
+    io: Asyncmux,
+    signal: AbortSignal,
+    key: string,
+    store: VariablesStore,
+    value: unknown,
+  ): Promise<void> {
+    const targets = await this.#pipeline.encode(
+      {
+        key,
+        store,
+        signal,
+      },
+      value,
+    );
+    using _ioLock = await io.lock({
+      key,
+      signal,
+    });
+    const errors: PluginErrorRecord[] = [];
+    const failed = new Set<PipelineLeaf>();
+    await Promise.all(
+      targets.map(async (target) => {
+        try {
+          const c = new SetContext({
+            key: target.key,
+            store,
+            signal,
+          });
+          await target.leaf.storage.write(c, target.data);
+        } catch (ex) {
+          errors.push({
+            name: target.leaf.name,
+            index: target.leaf.index,
+            reason: ex,
+          });
+          failed.add(target.leaf);
+        }
+      }),
+    );
+    await this.#finishWrites(targets, store, failed, errors, signal);
+  }
+
+  /**
+   * ストリーム値の並列書き込みを行います。
+   *
+   * @param io 多重化インスタンスです。
+   * @param signal 中断シグナルです。
+   * @param key 書き込みキーです。
+   * @param store 操作内で共有される変数ストアです。
+   * @param value 書き込むストリームです。
+   */
+  async #setStream(
+    io: Asyncmux,
+    signal: AbortSignal,
+    key: string,
+    store: VariablesStore,
+    value: IReadableStream,
+  ): Promise<void> {
+    const streams = new Set<IReadableStream>([value]);
+    let tree;
+
+    try {
+      tree = await this.#pipeline.buildEncodeTree(
+        {
+          key,
+          store,
+          signal,
+        },
+        value,
+        streams,
+      );
+    } catch (ex) {
+      await cancelStreams(streams, ex);
+      throw ex;
+    }
+
+    using _ioLock = await io
+      .lock({
+        key,
+        signal,
+      })
+      .catch(async (ex) => {
+        // キーロックの待機中に中断されたときも、構築済みのストリームをキャンセルします。
+        // ソースストリームをロックしたまま残さないためです。
+        await cancelStreams(streams, ex);
+        throw ex;
+      });
+
+    const errors: PluginErrorRecord[] = [];
+    const failed = new Set<PipelineLeaf>();
+    await Promise.all(
+      tree.targets.map(async (target) => {
+        try {
+          const c = new SetContext({
+            key: target.key,
+            store,
+            signal,
+          });
+          const w = await target.leaf.storage.getWritable(c);
+          await target.stream.pipeTo(w, { signal });
+        } catch (ex) {
+          // tee で分岐したストリームは、片方の分岐をキャンセルするまで他方が読み取ったチャンクを保持し続けるため、失敗時に放棄した分岐は確実にキャンセルします。
+          try {
+            await target.stream.cancel(ex);
+          } catch {
+            // キャンセルに失敗してもエラー集約を優先します。
+          }
+
+          errors.push({
+            name: target.leaf.name,
+            index: target.leaf.index,
+            reason: ex,
+          });
+          failed.add(target.leaf);
+        }
+      }),
+    );
+    await this.#finishWrites(tree.targets, store, failed, errors, signal);
+  }
+
+  public set<const TKey extends KeyofKeyValueMapping<TKeyValueMapping>>(
+    options: SetOptions<TKeyValueMapping, TKey>,
+  ): Promise<void>;
   public set<const TKey extends KeyofKeyValueMapping<TKeyValueMapping>>(
     key: TKey,
     value: SetValue<TKeyValueMapping[TKey]>,
     options?: Omit<SetOptions, "key" | "value">,
   ): Promise<void>;
-
   public async set(...args: any): Promise<void> {
     if (this.#con === null) {
       throw new UniKvsIsNotOpenError();
     }
 
-    const [options] = v.parseInput(SetArgsSchema, args);
-    const { key, value, signal: signalOption, context: contextOption } = options;
+    const [options] = parseInput(SetArgsSchema, args);
+    const { key, vars: varsOption, signal: signalOption } = 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 store = this.#createOperationStore(varsOption);
+
+    // `#setStream` へ所有権を渡す前の失敗では、ソースをロックしたままにしないよう派生ストリームをキャンセルします。
+    const stream = isReadableStream(value) ? value : null;
+    let ownsStream = stream !== null;
 
-    const lock = await asyncmux(this, signal);
     try {
+      using _lock = await asyncmux.readonly(this, signal);
       // ロック待機中に接続状態が変更されていないか再確認します。
       if (this.#con === null) {
         throw new UniKvsIsNotOpenError();
       }
 
-      const errors: { reason: unknown }[] = [];
-      const errorStorageSet = new Set<UniKvsStorage>();
-      if (value instanceof ReadableStream) {
-        // 各トランスフォーマーを通してデータをエンコードストリームへ変換します。
-        let data = value;
-        try {
-          for (const transformer of this.#transformers) {
-            const e = await transformer.getEncodable(context, signal);
-            data = data.pipeThrough(e);
-          }
-        } catch (ex) {
-          // チェーンの構築中に失敗した場合、パイプが保持するソースストリームのリソースを解放するためにキャンセルします。
-          // キャンセルしないとソースストリームはロックされたままリークします。
-          try {
-            await data.cancel(ex);
-          } catch {
-            // キャンセルに失敗しても元の例外の伝播を優先します。
-          }
-
-          throw ex;
-        }
-
-        const lock = await io.lock({ key, signal });
-        try {
-          await Promise.all(
-            this.#destinations.map(async (storage, i) => {
-              // tee ブランチはキャンセルされるまで健康なブランチの読み取り分のチャンクを保持し続けるため、失敗時に放棄したブランチを確実にキャンセルできるよう参照を保持します。
-              let branch: ReadableStream | null = null;
-              try {
-                // 複数のストレージがある場合は、tee メソッドを使用してストリームを分岐させます。
-                let r = data;
-                if (i !== this.#destinations.length - 1) {
-                  [r, data] = data.tee();
-                }
-                branch = r;
-
-                const w = await storage.getWritable(context, signal, key);
-                await r.pipeTo(w, { signal });
-              } catch (reason) {
-                if (branch !== null) {
-                  try {
-                    await branch.cancel(reason);
-                  } catch {
-                    // キャンセルに失敗してもエラー集約を優先します。
-                  }
-                }
-
-                errors.push({ reason });
-                errorStorageSet.add(storage);
-              }
-            }),
-          );
-        } finally {
-          lock.release();
-        }
+      // 書き込み前の `use` による検証を行います。変異は後続のエンコード・書き込みに引き継がれます。
+      const useContext = new SetContext({
+        key,
+        store,
+        signal,
+      });
+      await this.#use("write", useContext);
+      // `use` の完了直後に中断を確認し、後続処理での検出に依存しないようにします。
+      throwIfAborted(signal);
+      // `use` による変異を操作変数に反映します。
+      // ロックはインスタンス (読み取り) からキーの順で取得し、逆順で解放します。
+      if (stream !== null) {
+        // これ以降の後始末は `#setStream` が所有します。
+        ownsStream = false;
+        await this.#setStream(io, signal, key, store, stream);
       } else {
-        // 登録されているトランスフォーマーを順番に適用してデータをエンコードします。
-        let data = value;
-        for (const transformer of this.#transformers) {
-          data = await transformer.encode(context, signal, data);
-        }
-
-        const lock = await io.lock({ key, signal });
+        await this.#setPlain(io, signal, key, store, value);
+      }
+    } catch (ex) {
+      if (ownsStream && stream !== null) {
+        // 消費されないストリームをキャンセルし、ソースの解放を伝播させます。
         try {
-          await Promise.all(
-            this.#destinations.map(async (storage) => {
-              try {
-                await storage.write(context, signal, key, data);
-              } catch (reason) {
-                errors.push({ reason });
-                errorStorageSet.add(storage);
-              }
-            }),
-          );
-        } finally {
-          lock.release();
+          await stream.cancel(ex);
+        } catch {
+          // キャンセルに失敗しても元の例外の伝播を優先します。
         }
       }
 
-      // エラーが発生した場合は集約します。
-      if (errors.length > 0) {
-        const error = new PluginOperationAggregateError({
-          plugin: "storage",
-          action: "write",
-          errors,
-        });
-        {
-          const errors: unknown[] = [];
-          await Promise.all(
-            this.#destinations.map(async (storage) => {
-              if (errorStorageSet.has(storage)) {
-                return;
-              }
-
-              try {
-                await storage.onOtherWriteError(context, signal, key, error);
-              } catch (ex) {
-                errors.push(ex);
-              }
-            }),
-          );
-          if (errors.length > 0) {
-            logger.error(new AggregateError(errors, "Failed to handle error"));
-          }
-        }
-
-        throw error;
-      }
-    } finally {
-      lock.release();
+      throw ex;
     }
   }
 
   /**
-   * 指定したオプションで値を取得します。
+   * 読み取り元のチェーン全体を逆順にデコードし、書き戻し対象向けに再エンコードして書き込みます。
+   *
+   * @param data 読み取ったデータです。
+   * @param hit 読み取り元の葉です。
+   * @param missing 読み取りに失敗または不在だった葉です。
+   * @param store 操作内で共有される変数ストアです。
+   * @param key キーです。
+   * @param signal 中断シグナルです。
+   * @param throwOnRepairDenied 書き戻し拒否をエラーとして投げるかどうかです。
    *
-   * @template TKey 対象キーの型定義です。
-   * @param options 取得操作のオプション一式です。
-   * @returns 取得した値を返します。
+   * @returns デコード済みの原データを返します。
    */
+  async #repairPlain(
+    data: unknown,
+    hit: ResolvedLeaf,
+    missing: readonly PipelineLeaf[],
+    store: VariablesStore,
+    key: string,
+    signal: AbortSignal,
+    throwOnRepairDenied: boolean,
+  ): Promise<unknown> {
+    const raw = await this.#pipeline.decode(
+      hit.leaf,
+      {
+        key,
+        store,
+        signal,
+      },
+      data,
+    );
+    await this.#pipeline.repair(
+      {
+        key,
+        store,
+        signal,
+      },
+      missing,
+      throwOnRepairDenied,
+      raw,
+      async (leaf, writeKey, input) => {
+        const c = new SetContext({
+          key: writeKey,
+          store,
+          signal,
+        });
+        await leaf.storage.write(c, input);
+      },
+    );
+
+    throwIfAborted(signal);
+
+    return raw;
+  }
+
   public get<const TKey extends KeyofKeyValueMappingHasPlainValue<TKeyValueMapping>>(
     options: GetOptions<TKey>,
   ): Promise<$InferPlainValueData<TKeyValueMapping[TKey]>>;
-
-  /**
-   * 指定したキーから値を取得します。
-   *
-   * @template TKey 対象キーの型定義です。
-   * @param key 操作対象を識別するためのキーです。
-   * @param options 追加のオプションです。
-   * @returns 取得した値を返します。
-   */
   public get<const TKey extends KeyofKeyValueMappingHasPlainValue<TKeyValueMapping>>(
     key: TKey,
     options?: Omit<GetOptions, "key">,
   ): Promise<$InferPlainValueData<TKeyValueMapping[TKey]>>;
-
   public async get(...args: any): Promise<unknown> {
     if (this.#con === null) {
       throw new UniKvsIsNotOpenError();
     }
 
-    const [options] = v.parseInput(GetArgsSchema, args);
-    const { key, signal: signalOption, context: contextOption } = options;
+    const [options] = parseInput(GetArgsSchema, args);
+    const {
+      key,
+      vars: varsOption,
+      repair = false,
+      signal: signalOption,
+      throwOnRepairDenied = false,
+    } = 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 store = this.#createOperationStore(varsOption);
 
-    const lock = await asyncmux.readonly(this, signal);
-    try {
-      // ロック待機中に接続状態が変更されていないか再確認します。
-      if (this.#con === null) {
-        throw new UniKvsIsNotOpenError();
-      }
+    using _lock = await asyncmux.readonly(this, signal);
+    // ロック待機中に接続状態が変更されていないか再確認します。
+    if (this.#con === null) {
+      throw new UniKvsIsNotOpenError();
+    }
 
-      const NONE = {};
-      let data: any = NONE;
-      const errors: { reason: unknown }[] = [];
+    // 読み取り前の `use` による検証を行います。書き戻し要求は `repair` フィールドで伝えます。
+    const leafNames = this.#pipeline.leaves.map((leaf) => leaf.name);
+    const useContext = new GetContext({
+      key,
+      store,
+      repair: repair
+        ? {
+            enabled: true,
+            targets: leafNames as [string, ...string[]],
+          }
+        : {
+            enabled: false,
+            targets: [],
+          },
+      signal,
+    });
+    await this.#use("read", useContext);
+    // `use` の完了直後に中断を確認し、後続処理での検出に依存しないようにします。
+    throwIfAborted(signal);
+    let data: unknown = undefined;
+    let hit: ResolvedLeaf | null = null;
+    const missing: PipelineLeaf[] = [];
+    const errors: PluginErrorRecord[] = [];
+
+    // 書き戻し時は、読み取りから書き込みまでを同じキーの書き込みと直列化するため、書き込みロックを取得します。
+    {
+      using _ioLock = await (repair
+        ? io.lock({
+            key,
+            signal,
+          })
+        : io.rLock({
+            key,
+            signal,
+          }));
+      // 登録順が読み取りの優先順です。先頭で見つかればそこで終え、失敗したときは次の宛先を試します。
+      const resolver = this.#pipeline.createResolver({
+        key,
+        store,
+        signal,
+      });
 
-      const lock = await io.rLock({ key, signal });
-      try {
-        // 各ストレージを巡回し、最初に見つかったデータを取得します。
-        // あるストレージの読み取りに失敗しても、他のストレージからデータを取得できるようにフォールバックします。
-        for (const storage of this.#destinations) {
-          try {
-            if (!(await storage.exists(context, signal, key))) {
-              continue;
-            }
-            data = await storage.read(context, signal, key);
-            break;
-          } catch (ex) {
-            if (signal.aborted) {
-              throw ex;
+      for (const leaf of this.#pipeline) {
+        const resolved = resolver.resolve(leaf);
+        const existsContext = new HasContext({
+          key: resolved.key,
+          store,
+          signal,
+        });
+        const readRepair = repair
+          ? {
+              enabled: true as const,
+              targets: leafNames as [string, ...string[]],
             }
-            errors.push({ reason: ex });
-            logger.error`Failed to read from a storage: ${ex}`;
+          : {
+              enabled: false as const,
+              targets: [] as const,
+            };
+        const readContext = new GetContext({
+          key: resolved.key,
+          store,
+          repair: readRepair,
+          signal,
+        });
+
+        try {
+          if (!(await leaf.storage.exists(existsContext))) {
+            missing.push(leaf);
+            continue;
           }
-        }
-      } finally {
-        lock.release();
-      }
 
-      if (data === NONE) {
-        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,
-            });
+          data = await leaf.storage.read(readContext);
+          hit = resolved;
+          break;
+        } catch (ex) {
+          if (signal.aborted) {
+            throw ex;
+          }
+
+          errors.push({
+            name: leaf.name,
+            index: leaf.index,
+            reason: ex,
+          });
+          logger.error`Failed to read from a storage: ${ex}`;
         }
+      }
 
-        throw new KeyNotFoundError(args);
+      if (hit === null) {
+        throw this.#notFound(key, errors);
       }
 
-      // トランスフォーマーを逆順に適用してデータをデコードします。
-      if (this.#transformers.length > 0) {
-        for (const transformer of this.#transformers.toReversed()) {
-          data = await transformer.decode(context, signal, data);
-        }
+      if (repair) {
+        // 後段で見つかったデータをすべてデコードして原データに戻します。
+        data = await this.#repairPlain(data, hit, missing, store, key, signal, throwOnRepairDenied);
       }
+    }
 
-      return data;
-    } finally {
-      lock.release();
+    if (!repair) {
+      // 見つかったストレージ専用の前段パイプラインを逆順に適用して、データをデコードします。
+      data = await this.#pipeline.decode(
+        hit.leaf,
+        {
+          key,
+          store,
+          signal,
+        },
+        data,
+      );
     }
+
+    // デコード後のデータを検証します。
+    if (valueSchema) {
+      data = parseOutput(valueSchema.schema, data);
+    }
+
+    return data;
   }
 
-  /**
-   * 指定したオプションでストリームを取得します。
-   *
-   * @template TKey 対象キーの型定義です。
-   * @param options ストリーム取得操作のオプション一式です。
-   * @returns 取得したストリームを返します。
-   */
   public stream<const TKey extends KeyofKeyValueMappingHasStreamValue<TKeyValueMapping>>(
     options: StreamOptions<TKey>,
-  ): Promise<ValueStream<$InferStreamValueChunkData<TKeyValueMapping[TKey]>>>;
-
-  /**
-   * 指定したキーからストリームを取得します。
-   *
-   * @template TKey 対象キーの型定義です。
-   * @param key 操作対象を識別するためのキーです。
-   * @param options 追加のオプションです。
-   * @returns 取得したストリームを返します。
-   */
+  ): Promise<IValueStream<$InferStreamValueChunkData<TKeyValueMapping[TKey]>>>;
   public stream<const TKey extends KeyofKeyValueMappingHasStreamValue<TKeyValueMapping>>(
     key: TKey,
     options?: Omit<StreamOptions, "key">,
-  ): Promise<ValueStream<$InferStreamValueChunkData<TKeyValueMapping[TKey]>>>;
-
-  public async stream(...args: any): Promise<ValueStream> {
+  ): Promise<IValueStream<$InferStreamValueChunkData<TKeyValueMapping[TKey]>>>;
+  public async stream(...args: any): Promise<IValueStream> {
     if (this.#con === null) {
       throw new UniKvsIsNotOpenError();
     }
 
-    const [options] = v.parseInput(StreamArgsSchema, args);
-    const { key, signal: signalOption, context: contextOption } = options;
+    const [options] = parseInput(StreamArgsSchema, args);
+    const {
+      key,
+      vars: varsOption,
+      repair = false,
+      signal: signalOption,
+      throwOnRepairDenied = false,
+    } = 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 store = this.#createOperationStore(varsOption);
 
-    const lock = await asyncmux.readonly(this, signal);
-    try {
+    {
+      using _lock = await asyncmux.readonly(this, signal);
       // ロック待機中に接続状態が変更されていないか再確認します。
       if (this.#con === null) {
         throw new UniKvsIsNotOpenError();
       }
 
+      // 読み取り前の `use` による検証を行います。書き戻し要求は `repair` フィールドで伝えます。
+      const leafNames = this.#pipeline.leaves.map((leaf) => leaf.name);
+      const useContext = new StreamContext({
+        key,
+        store,
+        repair: repair
+          ? {
+              enabled: true,
+              targets: leafNames as [string, ...string[]],
+            }
+          : {
+              enabled: false,
+              targets: [],
+            },
+        signal,
+      });
+      await this.#use("read", useContext);
+      // `use` の完了直後に中断を確認し、後続処理での検出に依存しないようにします。
+      throwIfAborted(signal);
+      // NONE は getReadable の呼び出し前を表す番兵値です。
       const NONE: any = {};
       let r: IReadableStream = NONE;
-      const errors: { reason: unknown }[] = [];
+      let hit: ResolvedLeaf | null = null;
+      const missing: PipelineLeaf[] = [];
+      const errors: PluginErrorRecord[] = [];
+      const fillBranches: IReadableStream[] = [];
+      const fillTasks: Promise<void>[] = [];
+      let repairAc: AbortController | null = null;
+      let cancelFills: ((reason: unknown) => Promise<void>) | null = null;
+
+      // 書き戻し時は、読み取りから書き込みまでを同じキーの書き込みと直列化するため、書き込みロックを取得します。
+      // キーロックは ValueStream の dispose まで保持するため、明示的に解放します。
+      const ioLock = await (repair
+        ? io.lock({
+            key,
+            signal,
+          })
+        : io.rLock({
+            key,
+            signal,
+          }));
 
-      const lock = await io.rLock({ key, signal });
       try {
-        // 各ストレージを巡回し、最初に見つかったデータを取得します。
-        // あるストレージの読み取りに失敗しても、他のストレージからデータを取得できるようにフォールバックします。
-        for (const storage of this.#destinations) {
+        // 登録順が読み取りの優先順です。先頭で見つかればそこで終え、失敗したときは次の宛先を試します。
+        const resolver = this.#pipeline.createResolver({
+          key,
+          store,
+          signal,
+        });
+
+        for (const leaf of this.#pipeline) {
+          const resolved = resolver.resolve(leaf);
+          const existsContext = new HasContext({
+            key: resolved.key,
+            store,
+            signal,
+          });
+          const readableRepair = repair
+            ? {
+                enabled: true as const,
+                targets: leafNames as [string, ...string[]],
+              }
+            : {
+                enabled: false as const,
+                targets: [] as const,
+              };
+          const readableContext = new StreamContext({
+            key: resolved.key,
+            store,
+            repair: readableRepair,
+            signal,
+          });
+
           try {
-            if (!(await storage.exists(context, signal, key))) {
+            if (!(await leaf.storage.exists(existsContext))) {
+              missing.push(leaf);
               continue;
             }
 
-            r = await storage.getReadable(context, signal, key);
+            r = await leaf.storage.getReadable(readableContext);
+            hit = resolved;
             break;
           } catch (ex) {
             if (signal.aborted) {
               throw ex;
             }
 
-            errors.push({ reason: ex });
+            errors.push({
+              name: leaf.name,
+              index: leaf.index,
+              reason: ex,
+            });
             logger.error`Failed to read from a storage: ${ex}`;
           }
         }
 
-        if (r === NONE) {
-          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,
-              });
+        if (hit === null) {
+          throw this.#notFound(key, errors);
+        }
+
+        // 書き戻しが有効なときだけ、ストリームが途中で破棄されたら進行中の書き戻しも中断できるようにします。
+        repairAc = repair ? new AbortController() : null;
+        const repairSignal = repairAc ? combineSignals([signal, repairAc.signal]) : signal;
+
+        // 書き戻しはできる範囲で行います。失敗してもログに残すだけで、読み取りは続けます。
+        const fill = (target: StreamEncodeTarget): void => {
+          fillBranches.push(target.stream);
+          fillTasks.push(
+            (async (): Promise<void> => {
+              try {
+                const wc = new SetContext({
+                  key: target.key,
+                  store,
+                  signal: repairSignal,
+                });
+                const w = await target.leaf.storage.getWritable(wc);
+                await target.stream.pipeTo(w, { signal: repairSignal });
+              } catch (ex) {
+                // パイプが中断されたときは分岐を解放し、tee が後続のチャンクを保持し続けないようにします。
+                try {
+                  await target.stream.cancel(ex);
+                } catch {
+                  // 解放に失敗しても書き戻しの失敗処理を優先します。
+                }
+
+                // 意図的な中断時はエラーではありません。
+                if (repairSignal.aborted) {
+                  return;
+                }
+
+                if (ex instanceof RepairNotAllowedError) {
+                  repairLogger.warn`Failed to repair a storage: ${ex}`;
+
+                  return;
+                }
+
+                logger.error`Failed to repair a storage: ${ex}`;
+              }
+            })(),
+          );
+        };
+
+        // セットアップに失敗したときは、構築済みの分岐と進行中の書き戻しを中断します。
+        cancelFills = async (reason: unknown): Promise<void> => {
+          repairAc?.abort(reason);
+          await Promise.all(
+            fillBranches.map(async (branch) => {
+              try {
+                await branch.cancel(reason);
+              } catch {
+                // 解放に失敗しても残りの分岐の解放を優先します。
+              }
+            }),
+          );
+          await Promise.all(fillTasks);
+        };
+
+        // 読み取り元をすべてデコードして原データに戻します。
+        // 書き戻しの分岐は読み取りパスと分離します。
+        r = await this.#pipeline.decodeStream(
+          hit.leaf,
+          {
+            key,
+            store,
+            signal,
+          },
+          r,
+        );
+
+        if (repair) {
+          // 許可のない宛先を先に除外します。throwOnRepairDenied が真のときはここでエラーを確定します。
+          const repairSet = new Set<PipelineLeaf>();
+
+          for (const leaf of missing) {
+            if (!leaf.canRepair) {
+              // 意図的な中断時はエラーではありません。
+              if (signal.aborted) {
+                continue;
+              }
+
+              repairLogger.warn`Skipped repair for a storage without AllowRepair: ${leaf.name}`;
+
+              if (throwOnRepairDenied) {
+                throw new RepairNotAllowedError({ names: [leaf.name] });
+              }
+
+              continue;
+            }
+
+            repairSet.add(leaf);
+          }
+
+          if (repairSet.size > 0) {
+            // 読み取りパスを変更しないよう、書き戻し側だけを構築して分岐後の読み取り側を返します。
+            const streams = new Set<IReadableStream>([r]);
+            const tree = await this.#pipeline.buildEncodeTree(
+              {
+                key,
+                store,
+                signal,
+              },
+              r,
+              streams,
+              {
+                isActive: (leaf: PipelineLeaf) => repairSet.has(leaf),
+                splitRead: true,
+                onNodeError: (ex: unknown, activeLeaves: readonly PipelineLeaf[]) => {
+                  // 意図的な中断時は中断理由で失敗します。
+                  throwIfAborted(signal);
+
+                  if (ex instanceof RepairNotAllowedError) {
+                    repairLogger.warn`Failed to repair a storage: ${ex}`;
+
+                    if (throwOnRepairDenied) {
+                      throw new RepairNotAllowedError({
+                        cause: ex,
+                        names: activeLeaves.map((leaf) => leaf.name),
+                      });
+                    }
+
+                    return true;
+                  }
+
+                  logger.error`Failed to repair a storage: ${ex}`;
+
+                  throw ex;
+                },
+              },
+            );
+            r = tree.readStream;
+
+            for (const target of tree.targets) {
+              fill(target);
+            }
           }
 
-          throw new KeyNotFoundError(args);
+          throwIfAborted(signal);
         }
 
-        // トランスフォーマーを逆順に適用し、デコード用トランスフォームを連結します。
-        for (const transformer of this.#transformers.toReversed()) {
-          const d = await transformer.getDecodable(context, signal);
-          r = r.pipeThrough(d);
+        // デコード後のチャンクを検証します。
+        if (valueSchema) {
+          r = r.pipeThrough(
+            new TransformStream({
+              transform(chunk, controller): void {
+                controller.enqueue(parseOutput(valueSchema.schema, chunk));
+              },
+            }),
+          );
         }
 
-        if (!ioLockRegistry) {
-          return toValueStream(r, async () => {
+        // ストリームを読み切ったかを監視します。読み切ったときは書き戻しの完了を待ち、途中で破棄されたときは書き戻しを中断します。
+        let completed = false;
+
+        if (repairAc) {
+          r = r.pipeThrough(
+            new TransformStream({
+              flush(): void {
+                completed = true;
+              },
+              transform(chunk, controller): void {
+                controller.enqueue(chunk);
+              },
+            }),
+          );
+        }
+
+        // 破棄時は、ソースストリームをキャンセルする前に進行中の書き戻しを中断します。
+        // tee で分岐したストリームはすべての分岐のキャンセルが揃うまで元のキャンセルが完了しないためです。
+        const beforeDispose = (): void => {
+          if (!completed) {
+            repairAc?.abort(signal.reason);
+          }
+        };
+
+        // キーロックは ValueStream の dispose まで保持します。fill の完了を待ってから解放します。
+        const dispose = async (): Promise<void> => {
+          try {
+            await Promise.all(fillTasks);
+          } finally {
             try {
-              lock.release();
-            } catch {}
-          });
+              ioLock.release();
+            } catch {
+              // 解放済みでも dispose を失敗させません。
+            }
+          }
+        };
+
+        if (!ioLockRegistry) {
+          return toValueStream(r, dispose, beforeDispose);
         }
 
         const unregisterToken = {};
-        const valueStream = toValueStream(r, async () => {
-          try {
-            ioLockRegistry.unregister(unregisterToken);
-          } catch {}
-          try {
-            lock.release();
-          } catch {}
-        });
+        const valueStream = toValueStream(
+          r,
+          async () => {
+            try {
+              ioLockRegistry.unregister(unregisterToken);
+            } catch {
+              // 未登録でも dispose を失敗させません。
+            }
+
+            await dispose();
+          },
+          beforeDispose,
+        );
 
-        // valueStream が GC されるタイミングでストリームが終了していなければロックを自動解放するとともに、ソースストリームが保持するリソース (S3 レスポンスボディなど) を解放できるように dispose を記録します。
+        // valueStream が GC される時点でストリームが終わっていなければロックを自動解放します。あわせて、ソースストリームが保持するリソース (S3 レスポンスボディなど) を解放できるよう dispose を記録します。
         ioLockRegistry.register(
           valueStream,
           {
-            lock,
+            lock: ioLock,
             dispose: valueStream.dispose,
           },
           unregisterToken,
@@ -1126,229 +1589,251 @@ export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueM
 
         return valueStream;
       } catch (ex) {
+        await cancelFills?.(ex);
+
         if (r !== NONE) {
-          // getReadable 成功後のセットアップ中に失敗した場合、ソースストリームが保持するリソース (S3 レスポンスボディなど) を解放するためにキャンセルします。
+          // getReadable の成功後にセットアップで失敗したときは、ソースストリームが保持するリソース (S3 レスポンスボディなど) を解放するためキャンセルします。
           try {
             await r.cancel(ex);
-          } catch {}
+          } catch {
+            // キャンセルに失敗しても元の例外の伝播を優先します。
+          }
         }
 
-        lock.release();
+        ioLock.release();
+
         throw ex;
       }
-    } finally {
-      lock.release();
     }
   }
 
-  /**
-   * 指定したオプションでキーの存在を確認します。
-   *
-   * @param options 存在確認操作のオプションです。
-   * @returns 存在する場合は true、そうでない場合は false を返します。
-   */
   public has(options: HasOptions<KeyofKeyValueMapping<TKeyValueMapping>>): Promise<boolean>;
-
-  /**
-   * 指定したキーが存在するかを確認します。
-   *
-   * @param key 操作対象を識別するためのキーです。
-   * @param options 追加のオプションです。
-   * @returns 存在する場合は true、そうでない場合は false を返します。
-   */
   public has(
     key: KeyofKeyValueMapping<TKeyValueMapping>,
     options?: Omit<HasOptions, "key">,
   ): Promise<boolean>;
-
   public async has(...args: any): Promise<boolean> {
     if (this.#con === null) {
       throw new UniKvsIsNotOpenError();
     }
 
-    const [options] = v.parseInput(HasArgsSchema, args);
-    const { key, signal: signalOption, context: contextOption } = options;
+    const [options] = parseInput(HasArgsSchema, args);
+    const { key, vars: varsOption, signal: signalOption } = 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 store = this.#createOperationStore(varsOption);
 
-    const lock = await asyncmux.readonly(this, signal);
-    try {
-      // ロック待機中に接続状態が変更されていないか再確認します。
-      if (this.#con === null) {
-        throw new UniKvsIsNotOpenError();
-      }
+    using _lock = await asyncmux.readonly(this, signal);
+    // ロック待機中に接続状態が変更されていないか再確認します。
+    if (this.#con === null) {
+      throw new UniKvsIsNotOpenError();
+    }
 
-      const lock = await io.rLock({ key, signal });
-      try {
-        // いずれかのストレージに存在すれば true を返します。
-        // あるストレージの存在確認に失敗しても、他のストレージで存在を確認できるようにフォールバックします。
-        const errors: { reason: unknown }[] = [];
-        for (const storage of this.#destinations) {
-          try {
-            if (await storage.exists(context, 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}`;
-          }
-        }
+    // 存在確認に先立ち、各ミドルウェアの `use` を実行します。
+    // `use` による vars の変更は後続の解決・走査に引き継がれます。
+    const useContext = new HasContext({
+      key,
+      store,
+      signal,
+    });
+    await this.#use("read", useContext);
+    // `use` の完了直後に中断を確認し、後続処理での検出に依存しないようにします。
+    throwIfAborted(signal);
 
-        // すべてのストレージで存在を確認できなかった場合は結果が不明のため、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,
-              });
-          }
+    using _ioLock = await io.rLock({
+      key,
+      signal,
+    });
+    // 登録順に走査し、いずれかのストレージに存在すれば true を返します。
+    // exists に失敗したときは次のストレージを試します。
+    const errors: PluginErrorRecord[] = [];
+    const resolver = this.#pipeline.createResolver({
+      key,
+      store,
+      signal,
+    });
+
+    for (const leaf of this.#pipeline) {
+      const resolved = resolver.resolve(leaf);
 
-          throw new KeyNotFoundError(args);
+      try {
+        const c = new HasContext({
+          key: resolved.key,
+          store,
+          signal,
+        });
+
+        if (await leaf.storage.exists(c)) {
+          return true;
+        }
+      } catch (ex) {
+        if (signal.aborted) {
+          throw ex;
         }
 
-        return false;
-      } finally {
-        lock.release();
+        errors.push({
+          name: leaf.name,
+          index: leaf.index,
+          reason: ex,
+        });
+
+        logger.error`Failed to check existence in a storage: ${ex}`;
       }
-    } finally {
-      lock.release();
     }
+
+    // すべてのストレージで存在を確認できなかったときは結果が不明なため、get() と同様にエラーとして報告します。
+    if (errors.length > 0) {
+      throw this.#notFound(key, errors);
+    }
+
+    return false;
   }
 
-  /**
-   * 指定したオプションでキーを削除します。
-   *
-   * @param options 削除操作のオプションです。
-   * @returns 完了を通知する Promise です。
-   */
   public delete(options: DeleteOptions<KeyofKeyValueMapping<TKeyValueMapping>>): Promise<void>;
-
-  /**
-   * 指定したキーを削除します。
-   *
-   * @param key 操作対象を識別するためのキーです。
-   * @param options 追加のオプションです。
-   * @returns 完了を通知する Promise です。
-   */
   public delete(
     key: KeyofKeyValueMapping<TKeyValueMapping>,
     options?: Omit<DeleteOptions, "key">,
   ): Promise<void>;
-
   public async delete(...args: any): Promise<void> {
     if (this.#con === null) {
       throw new UniKvsIsNotOpenError();
     }
 
-    const [options] = v.parseInput(DeleteArgsSchema, args);
-    const { key, signal: signalOption, context: contextOption } = options;
+    const [options] = parseInput(DeleteArgsSchema, args);
+    const { key, vars: varsOption, signal: signalOption } = 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 store = this.#createOperationStore(varsOption);
 
-    const lock = await asyncmux(this, signal);
-    try {
-      // ロック待機中に接続状態が変更されていないか再確認します。
-      if (this.#con === null) {
-        throw new UniKvsIsNotOpenError();
-      }
+    using _lock = await asyncmux.readonly(this, signal);
+    // ロック待機中に接続状態が変更されていないか再確認します。
+    if (this.#con === null) {
+      throw new UniKvsIsNotOpenError();
+    }
 
-      const lock = await io.lock({ key, signal });
-      try {
-        // すべてのストレージから対象データを削除します。
-        // すべての処理を並列に実行し、エラーが発生した場合は集約します。
-        const errors: { reason: unknown }[] = [];
-        await Promise.all(
-          this.#destinations.map(async (storage) => {
-            try {
-              if (await storage.exists(context, signal, key)) {
-                await storage.delete(context, signal, key);
-              }
-            } catch (reason) {
-              errors.push({ reason });
-            }
-          }),
-        );
-        if (errors.length > 0) {
-          throw new PluginOperationAggregateError({ plugin: "storage", action: "delete", errors });
+    // 削除に先立ち、各ミドルウェアの `use` を実行します。
+    // `use` による vars の変更は後続の解決・削除に引き継がれます。
+    const useContext = new DeleteContext({
+      key,
+      store,
+      signal,
+    });
+    await this.#use("delete", useContext);
+
+    using _ioLock = await io.lock({
+      key,
+      // `use` の完了直後に中断を確認し、後続処理での検出に依存しないようにします。
+      signal,
+    });
+    // 全宛先を並列に削除し、失敗は宛先の index 付きで集約します。
+    const errors: PluginErrorRecord[] = [];
+    const resolver = this.#pipeline.createResolver({
+      key,
+      store,
+      signal,
+    });
+    await Promise.all(
+      this.#pipeline.leaves.map(async (leaf) => {
+        const resolved = resolver.resolve(leaf);
+        const existsContext = new HasContext({
+          key: resolved.key,
+          store,
+          signal,
+        });
+        const deleteContext = new DeleteContext({
+          key: resolved.key,
+          store,
+          signal,
+        });
+
+        try {
+          if (await leaf.storage.exists(existsContext)) {
+            await leaf.storage.delete(deleteContext);
+          }
+        } catch (ex) {
+          errors.push({
+            name: leaf.name,
+            index: leaf.index,
+            reason: ex,
+          });
         }
-      } finally {
-        lock.release();
-      }
-    } finally {
-      lock.release();
+      }),
+    );
+
+    if (errors.length > 0) {
+      throw new PluginOperationAggregateError({
+        action: "delete",
+        errors,
+        plugin: "storage",
+      });
     }
   }
 
-  /**
-   * すべてのストレージ内のデータを全削除します。
-   *
-   * @param options クリア操作のオプションです。
-   * @returns 完了を通知する Promise です。
-   */
   public async clear(options?: ClearOptions): Promise<void>;
-
   public async clear(...args: any): Promise<void> {
     if (this.#con === null) {
       throw new UniKvsIsNotOpenError();
     }
 
-    const [options = {}] = v.parseInput(ClearArgsSchema, args);
-    const { signal: signalOption, context: contextOption } = options;
+    const [options = {}] = parseInput(ClearArgsSchema, args);
+    const { vars: varsOption, signal: signalOption } = options;
 
     const { ac, io } = this.#con;
     const signal = combineSignals([ac.signal, signalOption]);
 
-    const context = mergeContext(this.#context, contextOption);
-    context["unikvs:action"] = "clear";
+    const store = this.#createOperationStore(varsOption);
 
-    const lock = await asyncmux(this, signal);
-    try {
-      // ロック待機中に接続状態が変更されていないか再確認します。
-      if (this.#con === null) {
-        throw new UniKvsIsNotOpenError();
-      }
+    using _lock = await asyncmux.readonly(this, signal);
+    // ロック待機中に接続状態が変更されていないか再確認します。
+    if (this.#con === null) {
+      throw new UniKvsIsNotOpenError();
+    }
 
-      const lock = await io.lock({ signal });
-      try {
-        // すべてのストレージで一括削除を実行します。
-        // すべての処理を並列に実行し、エラーが発生した場合は集約します。
-        const errors: { reason: unknown }[] = [];
-        await Promise.all(
-          this.#destinations.map(async (storage) => {
-            try {
-              await storage.clear(context, signal);
-            } catch (reason) {
-              errors.push({ reason });
-            }
-          }),
-        );
-        if (errors.length > 0) {
-          throw new PluginOperationAggregateError({ plugin: "storage", action: "clear", errors });
+    using _ioLock = await io.lock({ signal });
+    // 全ミドルウェアの `use` を実行します。
+    const useContext = new ClearContext({
+      store,
+      signal,
+    });
+    await this.#use("clear", useContext);
+    // `use` の完了直後に中断を確認し、後続処理での検出に依存しないようにします。
+    throwIfAborted(signal);
+    // 一括削除は全宛先で並列に実行し、失敗は宛先の index 付きで集約します。
+    const errors: PluginErrorRecord[] = [];
+    await Promise.all(
+      this.#pipeline.leaves.map(async (leaf, index) => {
+        try {
+          const c = new ClearContext({
+            store,
+            signal,
+          });
+          await leaf.storage.clear(c);
+        } catch (ex) {
+          errors.push({
+            name: leaf.name,
+            index,
+            reason: ex,
+          });
         }
-      } finally {
-        lock.release();
-      }
-    } finally {
-      lock.release();
+      }),
+    );
+
+    if (errors.length > 0) {
+      throw new PluginOperationAggregateError({
+        action: "clear",
+        errors,
+        plugin: "storage",
+      });
     }
   }
 }