unikvs 0.0.12 → 0.0.13

package/dist/src/unikvs.js

@@ -1,928 +0,0 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _UniKvs_instances, _UniKvs_con, _UniKvs_acSet, _UniKvs_vars, _UniKvs_destinations, _UniKvs_transformers, _UniKvs_valueSchemaResolver, _UniKvs_resolveValueSchema, _UniKvs_close;
-import { combineSignals } from "abort-signal-utils";
-import { asyncmux, Asyncmux } from "asyncmux";
-import logger from "./_logger.js";
-import mergeVariables from "./_merge-variables.js";
-import { isReadableStream } from "./_streams.js";
-import toValueStream from "./_to-value-stream.js";
-import * as v from "./_valibot.js";
-import { KeyNotFoundError, UniKvsIsOpenError, UniKvsIsNotOpenError, PluginOperationAggregateError, } from "./errors.js";
-import UniKvsConfig from "./unikvs-config.js";
-// -------------------------------------------------------------------------------------------------
-//
-// 値の検証
-//
-// -------------------------------------------------------------------------------------------------
-/**
- * プレーン値専用のスキーマに 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, value) {
-    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 VariablesKeySchema = v.string();
-// 配列形式の vars も正当な入力であるため、record スキーマより先に判定する必要があります。
-// record スキーマは配列にもマッチして数値キーのオブジェクトに変換してしまうため、配列形式を先に処理しないと mergeVariables での配列としてのマージが行われません。
-const VariablesSourceSchema = v.union([
-    v.array(v.tuple([VariablesKeySchema, v.unknown()])),
-    v.record(v.any(), v.unknown()),
-]);
-const OpenOptionsSchema = v.object({
-    /**
-     * 処理の中断を通知するためのシグナルです。
-     */
-    signal: v.optional(v.instance(AbortSignal)),
-    /**
-     * 実行時の変数です。
-     */
-    vars: v.optional(VariablesSourceSchema),
-});
-const OpenArgsSchema = v.tuple([v.optional(OpenOptionsSchema)]);
-const CloseOptionsSchema = v.object({
-    /**
-     * 処理の中断を通知するためのシグナルです。
-     */
-    signal: v.optional(v.instance(AbortSignal)),
-    /**
-     * 実行時の変数です。
-     */
-    vars: v.optional(VariablesSourceSchema),
-});
-const CloseArgsSchema = v.tuple([v.optional(CloseOptionsSchema)]);
-const SetOptionsSchema = v.object({
-    key: v.string(),
-    value: v.unknown(),
-    signal: v.optional(v.instance(AbortSignal)),
-    vars: v.optional(VariablesSourceSchema),
-});
-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)),
-    vars: v.optional(VariablesSourceSchema),
-});
-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)),
-    vars: v.optional(VariablesSourceSchema),
-});
-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)),
-    vars: v.optional(VariablesSourceSchema),
-});
-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)),
-    vars: v.optional(VariablesSourceSchema),
-});
-const DeleteArgsSchema = v.union([
-    v.tuple([DeleteOptionsSchema]),
-    v.pipe(v.tuple([DeleteOptionsSchema.entries.key, v.optional(v.omit(DeleteOptionsSchema, ["key"]))]), v.transform(([key, options]) => [{ ...options, key }])),
-]);
-const ClearOptionsSchema = v.object({
-    /**
-     * 処理の中断を通知するためのシグナルです。
-     */
-    signal: v.optional(v.instance(AbortSignal)),
-    /**
-     * 実行時の変数です。
-     */
-    vars: v.optional(VariablesSourceSchema),
-});
-const ClearArgsSchema = v.tuple([v.optional(ClearOptionsSchema)]);
-// -------------------------------------------------------------------------------------------------
-//
-// UniKvs
-//
-// -------------------------------------------------------------------------------------------------
-/**
- * ストリームの読み取りロックを自動解放するための FinalizationRegistry です。
- */
-const ioLockRegistry = typeof FinalizationRegistry !== "function"
-    ? null
-    : new FinalizationRegistry((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}`;
-        });
-    });
-/**
- * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
- */
-export default class UniKvs {
-    static config(options) {
-        return new UniKvsConfig(this, options);
-    }
-    /**
-     * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
-     */
-    constructor(vars, destinations, transformers, valueSchemaResolver = null) {
-        _UniKvs_instances.add(this);
-        /**
-         * 現在の接続状態です。非接続時は null となります。
-         */
-        _UniKvs_con.set(this, void 0);
-        _UniKvs_acSet.set(this, void 0);
-        /**
-         * 基本となる実行変数情報です。
-         */
-        _UniKvs_vars.set(this, void 0);
-        /**
-         * データの永続化先となるストレージと前段パイプラインのリストです。
-         */
-        _UniKvs_destinations.set(this, void 0);
-        /**
-         * データの変換を行うトランスフォーマーのリストです。open/close の管理用に全件を保持します。
-         */
-        _UniKvs_transformers.set(this, void 0);
-        /**
-         * キーに対応する値のスキーマ情報を解決するリゾルバーです。スキーマ未設定時は null となります。
-         */
-        _UniKvs_valueSchemaResolver.set(this, void 0);
-        __classPrivateFieldSet(this, _UniKvs_con, null, "f");
-        __classPrivateFieldSet(this, _UniKvs_acSet, new Set(), "f");
-        __classPrivateFieldSet(this, _UniKvs_vars, { ...vars }, "f");
-        __classPrivateFieldSet(this, _UniKvs_destinations, destinations, "f");
-        __classPrivateFieldSet(this, _UniKvs_transformers, transformers, "f");
-        __classPrivateFieldSet(this, _UniKvs_valueSchemaResolver, valueSchemaResolver, "f");
-    }
-    /**
-     * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
-     */
-    get isOpen() {
-        return __classPrivateFieldGet(this, _UniKvs_con, "f") !== null;
-    }
-    async open(...args) {
-        if (__classPrivateFieldGet(this, _UniKvs_con, "f") !== null) {
-            throw new UniKvsIsOpenError();
-        }
-        const [options = {}] = v.parseInput(OpenArgsSchema, args);
-        const { signal: signalOption, vars: varsOption } = options;
-        const ac = new AbortController();
-        const signal = combineSignals([ac.signal, signalOption]);
-        const vars = mergeVariables(__classPrivateFieldGet(this, _UniKvs_vars, "f"), varsOption);
-        vars["unikvs:action"] = "open";
-        signal.throwIfAborted();
-        __classPrivateFieldGet(this, _UniKvs_acSet, "f").add(ac);
-        const dispose = [];
-        const lock = await asyncmux(this, signal);
-        try {
-            if (__classPrivateFieldGet(this, _UniKvs_con, "f") !== null) {
-                throw new UniKvsIsOpenError();
-            }
-            const openFns = [];
-            // 各ストレージのオープン処理をリストに追加します。
-            for (const { storage } of __classPrivateFieldGet(this, _UniKvs_destinations, "f")) {
-                openFns.push([
-                    async () => {
-                        await storage.open(vars, signal);
-                        dispose.push(async () => {
-                            try {
-                                await storage.close(vars, signal);
-                            }
-                            catch (ex) {
-                                logger.error `Failed to close storage: ${ex}`;
-                            }
-                        });
-                    },
-                    "storage",
-                ]);
-            }
-            // 各トランスフォーマーのオープン処理をリストに追加します。
-            for (const transformer of __classPrivateFieldGet(this, _UniKvs_transformers, "f")) {
-                openFns.push([
-                    async () => {
-                        await transformer.open(vars, signal);
-                        dispose.push(async () => {
-                            try {
-                                await transformer.close(vars, signal);
-                            }
-                            catch (ex) {
-                                logger.error `Failed to close transformer: ${ex}`;
-                            }
-                        });
-                    },
-                    "transformer",
-                ]);
-            }
-            // すべての処理を並列に実行し、エラーが発生した場合は集約します。
-            const errors = [];
-            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();
-            __classPrivateFieldSet(this, _UniKvs_con, {
-                ac,
-                io: new Asyncmux(),
-            }, "f");
-        }
-        catch (ex) {
-            if (dispose.length > 0) {
-                await Promise.all(dispose.map(async (f) => {
-                    await f();
-                }));
-            }
-            throw ex;
-        }
-        finally {
-            __classPrivateFieldGet(this, _UniKvs_acSet, "f").delete(ac);
-            lock.release();
-        }
-    }
-    close(...args) {
-        try {
-            const [options = {}] = v.parseInput(CloseArgsSchema, args);
-            const { signal = AbortSignal.timeout(10e3), vars: varsOption } = options;
-            const vars = mergeVariables(__classPrivateFieldGet(this, _UniKvs_vars, "f"), varsOption);
-            vars["unikvs:action"] = "close";
-            if (__classPrivateFieldGet(this, _UniKvs_con, "f") === null) {
-                const acArr = [...__classPrivateFieldGet(this, _UniKvs_acSet, "f")];
-                __classPrivateFieldGet(this, _UniKvs_acSet, "f").clear();
-                for (const ac of acArr) {
-                    if (!ac.signal.aborted) {
-                        ac.abort(new UniKvsIsNotOpenError());
-                    }
-                }
-                throw new UniKvsIsNotOpenError();
-            }
-            const con = __classPrivateFieldGet(this, _UniKvs_con, "f");
-            const { ac } = con;
-            const acArr = [ac, ...__classPrivateFieldGet(this, _UniKvs_acSet, "f")];
-            __classPrivateFieldGet(this, _UniKvs_acSet, "f").clear();
-            for (const ac of acArr) {
-                if (!ac.signal.aborted) {
-                    ac.abort(new UniKvsIsNotOpenError());
-                }
-            }
-            return __classPrivateFieldGet(this, _UniKvs_instances, "m", _UniKvs_close).call(this, vars, signal, con).catch(async (ex) => {
-                // #close が失敗した場合、コネクションの AbortController はすでに abort 済みであり、以降の操作がすべて即座に失敗する壊れた状態になります。
-                // そこで接続を破棄して isOpen=false の一貫した状態にし、ベストエフォートでプラグインのクローズ処理を実行します。
-                if (__classPrivateFieldGet(this, _UniKvs_con, "f") === con) {
-                    __classPrivateFieldSet(this, _UniKvs_con, null, "f");
-                    const disposeSignal = AbortSignal.timeout(10e3);
-                    await Promise.all([...__classPrivateFieldGet(this, _UniKvs_destinations, "f").map((dest) => dest.storage), ...__classPrivateFieldGet(this, _UniKvs_transformers, "f")].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 [(_UniKvs_con = new WeakMap(), _UniKvs_acSet = new WeakMap(), _UniKvs_vars = new WeakMap(), _UniKvs_destinations = new WeakMap(), _UniKvs_transformers = new WeakMap(), _UniKvs_valueSchemaResolver = new WeakMap(), _UniKvs_instances = new WeakSet(), _UniKvs_resolveValueSchema = function _UniKvs_resolveValueSchema(key) {
-        return __classPrivateFieldGet(this, _UniKvs_valueSchemaResolver, "f")?.resolve(key);
-    }, _UniKvs_close = async function _UniKvs_close(vars, signal, con) {
-        const lock = await asyncmux(this, signal);
-        try {
-            // ロック待機中に接続状態が変更されていないか再確認します。
-            if (__classPrivateFieldGet(this, _UniKvs_con, "f") !== con) {
-                throw new UniKvsIsNotOpenError();
-            }
-            const { io } = __classPrivateFieldGet(this, _UniKvs_con, "f");
-            const lock = await io.lock({ signal });
-            try {
-                const closeFns = [];
-                // ストレージのクローズ処理を登録します。
-                for (const { storage } of __classPrivateFieldGet(this, _UniKvs_destinations, "f")) {
-                    closeFns.push([
-                        async () => {
-                            await storage.close(vars, signal);
-                        },
-                        "storage",
-                    ]);
-                }
-                // トランスフォーマーのクローズ処理を登録します。
-                for (const plugin of __classPrivateFieldGet(this, _UniKvs_transformers, "f")) {
-                    closeFns.push([
-                        async () => {
-                            await plugin.close(vars, signal);
-                        },
-                        "transformer",
-                    ]);
-                }
-                // すべての処理を並列に実行し、エラーが発生した場合は集約します。
-                const errors = [];
-                await Promise.all(closeFns.map(async ([f, plugin]) => {
-                    try {
-                        await f();
-                    }
-                    catch (reason) {
-                        errors.push({ plugin, reason });
-                    }
-                }));
-                if (errors.length > 0) {
-                    throw new PluginOperationAggregateError({ action: "close", errors });
-                }
-            }
-            finally {
-                lock.release();
-            }
-            __classPrivateFieldSet(this, _UniKvs_con, null, "f");
-        }
-        finally {
-            lock.release();
-        }
-    }, Symbol.asyncDispose)]() {
-        if (!this.isOpen) {
-            return;
-        }
-        await this.close({
-            signal: AbortSignal.timeout(10e3),
-        });
-    }
-    async set(...args) {
-        if (__classPrivateFieldGet(this, _UniKvs_con, "f") === null) {
-            throw new UniKvsIsNotOpenError();
-        }
-        const [options] = v.parseInput(SetArgsSchema, args);
-        const { key, signal: signalOption, vars: varsOption } = options;
-        const valueSchema = __classPrivateFieldGet(this, _UniKvs_instances, "m", _UniKvs_resolveValueSchema).call(this, key);
-        const value = valueSchema ? parseSetValue(valueSchema, options.value) : options.value;
-        const { ac, io } = __classPrivateFieldGet(this, _UniKvs_con, "f");
-        const signal = combineSignals([ac.signal, signalOption]);
-        const vars = mergeVariables(__classPrivateFieldGet(this, _UniKvs_vars, "f"), varsOption);
-        vars["unikvs:action"] = "set";
-        vars["unikvs:key"] = key;
-        const lock = await asyncmux(this, signal);
-        try {
-            // ロック待機中に接続状態が変更されていないか再確認します。
-            if (__classPrivateFieldGet(this, _UniKvs_con, "f") === null) {
-                throw new UniKvsIsNotOpenError();
-            }
-            const errors = [];
-            const errorStorageSet = new Set();
-            if (isReadableStream(value)) {
-                // 各ストレージ専用の前段パイプラインを通すため、tee で分岐しながらエンコードストリームを構築します。
-                // 最長の前段パイプラインを基準にし、ストレージの登録順に分岐点を作ります。
-                let longest = [];
-                for (const dest of __classPrivateFieldGet(this, _UniKvs_destinations, "f")) {
-                    if (dest.transformers.length > longest.length) {
-                        longest = dest.transformers;
-                    }
-                }
-                let cur = value;
-                const branches = [];
-                const built = [];
-                try {
-                    let applied = 0;
-                    for (let i = 0; i < __classPrivateFieldGet(this, _UniKvs_destinations, "f").length; i++) {
-                        const dest = __classPrivateFieldGet(this, _UniKvs_destinations, "f")[i];
-                        while (applied < dest.transformers.length) {
-                            const e = await longest[applied].getEncodable(vars, signal);
-                            cur = cur.pipeThrough(e);
-                            applied++;
-                        }
-                        if (i === __classPrivateFieldGet(this, _UniKvs_destinations, "f").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(__classPrivateFieldGet(this, _UniKvs_destinations, "f").map(async (dest, i) => {
-                        // tee ブランチはキャンセルされるまで健康なブランチの読み取り分のチャンクを保持し続けるため、失敗時に放棄したブランチを確実にキャンセルできるよう参照を保持します。
-                        const branch = branches[i];
-                        try {
-                            const w = await dest.storage.getWritable(vars, signal, key);
-                            await branch.pipeTo(w, { signal });
-                        }
-                        catch (reason) {
-                            try {
-                                await branch.cancel(reason);
-                            }
-                            catch {
-                                // キャンセルに失敗してもエラー集約を優先します。
-                            }
-                            errors.push({ reason });
-                            errorStorageSet.add(dest);
-                        }
-                    }));
-                }
-                finally {
-                    lock.release();
-                }
-            }
-            else {
-                // 各ストレージ専用の前段パイプラインでデータをエンコードします。共有プレフィックスは使い回します。
-                let longest = [];
-                for (const dest of __classPrivateFieldGet(this, _UniKvs_destinations, "f")) {
-                    if (dest.transformers.length > longest.length) {
-                        longest = dest.transformers;
-                    }
-                }
-                const prefix = [value];
-                for (const transformer of longest) {
-                    prefix.push(await transformer.encode(vars, signal, prefix[prefix.length - 1]));
-                }
-                const encoded = __classPrivateFieldGet(this, _UniKvs_destinations, "f").map((dest) => prefix[dest.transformers.length]);
-                const lock = await io.lock({ key, signal });
-                try {
-                    await Promise.all(__classPrivateFieldGet(this, _UniKvs_destinations, "f").map(async (dest, i) => {
-                        try {
-                            await dest.storage.write(vars, signal, key, encoded[i]);
-                        }
-                        catch (reason) {
-                            errors.push({ reason });
-                            errorStorageSet.add(dest);
-                        }
-                    }));
-                }
-                finally {
-                    lock.release();
-                }
-            }
-            // エラーが発生した場合は集約します。
-            if (errors.length > 0) {
-                const error = new PluginOperationAggregateError({
-                    plugin: "storage",
-                    action: "write",
-                    errors,
-                });
-                {
-                    const errors = [];
-                    await Promise.all(__classPrivateFieldGet(this, _UniKvs_destinations, "f").map(async (dest) => {
-                        if (errorStorageSet.has(dest)) {
-                            return;
-                        }
-                        try {
-                            await dest.storage.onOtherWriteError(vars, 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();
-        }
-    }
-    async get(...args) {
-        if (__classPrivateFieldGet(this, _UniKvs_con, "f") === null) {
-            throw new UniKvsIsNotOpenError();
-        }
-        const [options] = v.parseInput(GetArgsSchema, args);
-        const { key, signal: signalOption, vars: varsOption } = options;
-        const valueSchema = __classPrivateFieldGet(this, _UniKvs_instances, "m", _UniKvs_resolveValueSchema).call(this, key);
-        const { ac, io } = __classPrivateFieldGet(this, _UniKvs_con, "f");
-        const signal = combineSignals([ac.signal, signalOption]);
-        const vars = mergeVariables(__classPrivateFieldGet(this, _UniKvs_vars, "f"), varsOption);
-        vars["unikvs:action"] = "get";
-        vars["unikvs:key"] = key;
-        const lock = await asyncmux.readonly(this, signal);
-        try {
-            // ロック待機中に接続状態が変更されていないか再確認します。
-            if (__classPrivateFieldGet(this, _UniKvs_con, "f") === null) {
-                throw new UniKvsIsNotOpenError();
-            }
-            const NONE = {};
-            let data = NONE;
-            let transformers = [];
-            const errors = [];
-            const lock = await io.rLock({ key, signal });
-            try {
-                // 各ストレージを巡回し、最初に見つかったデータを取得します。
-                // あるストレージの読み取りに失敗しても、他のストレージからデータを取得できるようにフォールバックします。
-                for (const dest of __classPrivateFieldGet(this, _UniKvs_destinations, "f")) {
-                    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 {
-                lock.release();
-            }
-            if (data === NONE) {
-                const args = { 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);
-            }
-            // 見つかったストレージ専用の前段パイプラインを逆順に適用してデータをデコードします。
-            for (const transformer of transformers.toReversed()) {
-                data = await transformer.decode(vars, signal, data);
-            }
-            // デコード後のデータを検証します。
-            if (valueSchema) {
-                data = v.parseOutput(valueSchema.schema, data);
-            }
-            return data;
-        }
-        finally {
-            lock.release();
-        }
-    }
-    async stream(...args) {
-        if (__classPrivateFieldGet(this, _UniKvs_con, "f") === null) {
-            throw new UniKvsIsNotOpenError();
-        }
-        const [options] = v.parseInput(StreamArgsSchema, args);
-        const { key, signal: signalOption, vars: varsOption } = options;
-        const valueSchema = __classPrivateFieldGet(this, _UniKvs_instances, "m", _UniKvs_resolveValueSchema).call(this, key);
-        const { ac, io } = __classPrivateFieldGet(this, _UniKvs_con, "f");
-        const signal = combineSignals([ac.signal, signalOption]);
-        const vars = mergeVariables(__classPrivateFieldGet(this, _UniKvs_vars, "f"), varsOption);
-        vars["unikvs:action"] = "stream";
-        vars["unikvs:key"] = key;
-        const lock = await asyncmux.readonly(this, signal);
-        try {
-            // ロック待機中に接続状態が変更されていないか再確認します。
-            if (__classPrivateFieldGet(this, _UniKvs_con, "f") === null) {
-                throw new UniKvsIsNotOpenError();
-            }
-            const NONE = {};
-            let r = NONE;
-            let transformers = [];
-            const errors = [];
-            const lock = await io.rLock({ key, signal });
-            try {
-                // 各ストレージを巡回し、最初に見つかったデータを取得します。
-                // あるストレージの読み取りに失敗しても、他のストレージからデータを取得できるようにフォールバックします。
-                for (const dest of __classPrivateFieldGet(this, _UniKvs_destinations, "f")) {
-                    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) {
-                    const args = { 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);
-                }
-                // 見つかったストレージ専用の前段パイプラインを逆順に適用し、デコード用トランスフォームを連結します。
-                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 {
-                            lock.release();
-                        }
-                        catch { }
-                    });
-                }
-                const unregisterToken = {};
-                const valueStream = toValueStream(r, async () => {
-                    try {
-                        ioLockRegistry.unregister(unregisterToken);
-                    }
-                    catch { }
-                    try {
-                        lock.release();
-                    }
-                    catch { }
-                });
-                // 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;
-            }
-        }
-        finally {
-            lock.release();
-        }
-    }
-    async has(...args) {
-        if (__classPrivateFieldGet(this, _UniKvs_con, "f") === null) {
-            throw new UniKvsIsNotOpenError();
-        }
-        const [options] = v.parseInput(HasArgsSchema, args);
-        const { key, signal: signalOption, vars: varsOption } = options;
-        // キーがキースキーマに一致するかを検証します。
-        __classPrivateFieldGet(this, _UniKvs_instances, "m", _UniKvs_resolveValueSchema).call(this, key);
-        const { ac, io } = __classPrivateFieldGet(this, _UniKvs_con, "f");
-        const signal = combineSignals([ac.signal, signalOption]);
-        const vars = mergeVariables(__classPrivateFieldGet(this, _UniKvs_vars, "f"), varsOption);
-        vars["unikvs:action"] = "has";
-        vars["unikvs:key"] = key;
-        const lock = await asyncmux.readonly(this, signal);
-        try {
-            // ロック待機中に接続状態が変更されていないか再確認します。
-            if (__classPrivateFieldGet(this, _UniKvs_con, "f") === null) {
-                throw new UniKvsIsNotOpenError();
-            }
-            const lock = await io.rLock({ key, signal });
-            try {
-                // いずれかのストレージに存在すれば true を返します。
-                // あるストレージの存在確認に失敗しても、他のストレージで存在を確認できるようにフォールバックします。
-                const errors = [];
-                for (const { storage } of __classPrivateFieldGet(this, _UniKvs_destinations, "f")) {
-                    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 = { 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();
-            }
-        }
-        finally {
-            lock.release();
-        }
-    }
-    async delete(...args) {
-        if (__classPrivateFieldGet(this, _UniKvs_con, "f") === null) {
-            throw new UniKvsIsNotOpenError();
-        }
-        const [options] = v.parseInput(DeleteArgsSchema, args);
-        const { key, signal: signalOption, vars: varsOption } = options;
-        // キーがキースキーマに一致するかを検証します。
-        __classPrivateFieldGet(this, _UniKvs_instances, "m", _UniKvs_resolveValueSchema).call(this, key);
-        const { ac, io } = __classPrivateFieldGet(this, _UniKvs_con, "f");
-        const signal = combineSignals([ac.signal, signalOption]);
-        const vars = mergeVariables(__classPrivateFieldGet(this, _UniKvs_vars, "f"), varsOption);
-        vars["unikvs:action"] = "delete";
-        vars["unikvs:key"] = key;
-        const lock = await asyncmux(this, signal);
-        try {
-            // ロック待機中に接続状態が変更されていないか再確認します。
-            if (__classPrivateFieldGet(this, _UniKvs_con, "f") === null) {
-                throw new UniKvsIsNotOpenError();
-            }
-            const lock = await io.lock({ key, signal });
-            try {
-                // すべてのストレージから対象データを削除します。
-                // すべての処理を並列に実行し、エラーが発生した場合は集約します。
-                const errors = [];
-                await Promise.all(__classPrivateFieldGet(this, _UniKvs_destinations, "f").map(async ({ storage }) => {
-                    try {
-                        if (await storage.exists(vars, signal, key)) {
-                            await storage.delete(vars, signal, key);
-                        }
-                    }
-                    catch (reason) {
-                        errors.push({ reason });
-                    }
-                }));
-                if (errors.length > 0) {
-                    throw new PluginOperationAggregateError({ plugin: "storage", action: "delete", errors });
-                }
-            }
-            finally {
-                lock.release();
-            }
-        }
-        finally {
-            lock.release();
-        }
-    }
-    async clear(...args) {
-        if (__classPrivateFieldGet(this, _UniKvs_con, "f") === null) {
-            throw new UniKvsIsNotOpenError();
-        }
-        const [options = {}] = v.parseInput(ClearArgsSchema, args);
-        const { signal: signalOption, vars: varsOption } = options;
-        const { ac, io } = __classPrivateFieldGet(this, _UniKvs_con, "f");
-        const signal = combineSignals([ac.signal, signalOption]);
-        const vars = mergeVariables(__classPrivateFieldGet(this, _UniKvs_vars, "f"), varsOption);
-        vars["unikvs:action"] = "clear";
-        const lock = await asyncmux(this, signal);
-        try {
-            // ロック待機中に接続状態が変更されていないか再確認します。
-            if (__classPrivateFieldGet(this, _UniKvs_con, "f") === null) {
-                throw new UniKvsIsNotOpenError();
-            }
-            const lock = await io.lock({ signal });
-            try {
-                // すべてのストレージで一括削除を実行します。
-                // すべての処理を並列に実行し、エラーが発生した場合は集約します。
-                const errors = [];
-                await Promise.all(__classPrivateFieldGet(this, _UniKvs_destinations, "f").map(async ({ storage }) => {
-                    try {
-                        await storage.clear(vars, signal);
-                    }
-                    catch (reason) {
-                        errors.push({ reason });
-                    }
-                }));
-                if (errors.length > 0) {
-                    throw new PluginOperationAggregateError({ plugin: "storage", action: "clear", errors });
-                }
-            }
-            finally {
-                lock.release();
-            }
-        }
-        finally {
-            lock.release();
-        }
-    }
-}