unikvs 0.0.10 → 0.0.13

package/dist/index.js

@@ -0,0 +1,4032 @@
+import { ErrorBase, InvalidUsageErrorBase, KeyNotFoundError, ReadonlyVariableError, RepairNotAllowedError, setErrorMessage } from "@unikvs/core";
+import { Asyncmux, asyncmux } from "asyncmux";
+import { callAsyncableFnOnce, callFnOnce } from "call-fn-once";
+import { tryCaptureStackTrace } from "try-capture-stack-trace";
+import { boolean, check, custom, instance, omit, optional, pipe, safeParse, safeParse as safeParse$1, string, union, unknown } from "valibot";
+import { array, object, record, transform, tuple } from "@tai-kun/valibot-extra-lab";
+import { getLogger } from "@logtape/logtape";
+import { combineSignals, throwIfAborted } from "abort-signal-utils";
+//#region ../src/errors.ts
+var _InvalidInputError;
+var _InvalidOutputError;
+var _UniKvsIsOpenError;
+var _UniKvsIsNotOpenError;
+var _StorageIsNotOpenError;
+var _WritableStreamNotSupportedError;
+var _ReadableStreamNotSupportedError;
+var _MultipartWriteNotSupportedError;
+var _MiddlewareIsNotOpenError;
+var _MiddlewareDestinationMissingError;
+var _MiddlewareDestinationFrozenError;
+var _MiddlewareNextNotCalledError;
+var _MiddlewareNextNotAwaitedError;
+var _MiddlewareNextCalledMultipleTimesError;
+var _StreamEncodingNotSupportedError;
+var _StreamDecodingNotSupportedError;
+var _PluginOperationAggregateError;
+var _MissingStorageError;
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+*/
+var InvalidInputError = class extends InvalidUsageErrorBase {
+	constructor(args) {
+		const { value: input, issues, ...options } = args;
+		super({
+			input,
+			issues
+		}, ({ issues: messageIssues }) => messageIssues.map((i) => i.message).join(": "), options);
+	}
+};
+_InvalidInputError = InvalidInputError;
+_InvalidInputError.prototype.name = "UniKvsInvalidInputError";
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+*/
+var InvalidOutputError = class extends InvalidUsageErrorBase {
+	constructor(args) {
+		const { value: output, issues, ...options } = args;
+		super({
+			issues,
+			output
+		}, ({ issues: messageIssues }) => messageIssues.map((i) => i.message).join(": "), options);
+	}
+};
+_InvalidOutputError = InvalidOutputError;
+_InvalidOutputError.prototype.name = "UniKvsInvalidOutputError";
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+*/
+var UniKvsIsOpenError = class extends ErrorBase {
+	constructor(options) {
+		super("UniKvs is open", options);
+	}
+};
+_UniKvsIsOpenError = UniKvsIsOpenError;
+_UniKvsIsOpenError.prototype.name = "UniKvsIsOpenError";
+setErrorMessage(UniKvsIsOpenError, "UniKvs は開いています", "ja");
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+*/
+var UniKvsIsNotOpenError = class extends ErrorBase {
+	constructor(options) {
+		super("UniKvs is not open", options);
+	}
+};
+_UniKvsIsNotOpenError = UniKvsIsNotOpenError;
+_UniKvsIsNotOpenError.prototype.name = "UniKvsIsNotOpenError";
+setErrorMessage(UniKvsIsNotOpenError, "UniKvs は開いていません", "ja");
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+*/
+var StorageIsNotOpenError = class extends ErrorBase {
+	constructor(args) {
+		const { name, ...options } = args;
+		super({ name }, ({ name: messageName }) => `Storage "${messageName}" is not open`, options);
+	}
+};
+_StorageIsNotOpenError = StorageIsNotOpenError;
+_StorageIsNotOpenError.prototype.name = "UniKvsStorageIsNotOpenError";
+setErrorMessage(StorageIsNotOpenError, ({ name }) => `ストレージ "${name}" は開いていません`, "ja");
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+*/
+var WritableStreamNotSupportedError = class extends ErrorBase {
+	constructor(args) {
+		const { name, ...options } = args;
+		super({ name }, ({ name: messageName }) => `Storage "${messageName}" does not support writable stream`, options);
+	}
+};
+_WritableStreamNotSupportedError = WritableStreamNotSupportedError;
+_WritableStreamNotSupportedError.prototype.name = "UniKvsWritableStreamNotSupportedError";
+setErrorMessage(WritableStreamNotSupportedError, ({ name }) => `ストレージ "${name}" は書き込み可能なストリームをサポートしていません`, "ja");
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+*/
+var ReadableStreamNotSupportedError = class extends ErrorBase {
+	constructor(args) {
+		const { name, ...options } = args;
+		super({ name }, ({ name: messageName }) => `Storage "${messageName}" does not support readable stream`, options);
+	}
+};
+_ReadableStreamNotSupportedError = ReadableStreamNotSupportedError;
+_ReadableStreamNotSupportedError.prototype.name = "UniKvsReadableStreamNotSupportedError";
+setErrorMessage(ReadableStreamNotSupportedError, ({ name }) => `ストレージ "${name}" は読み取り可能なストリームをサポートしていません`, "ja");
+/**
+* ストレージがマルチパート書き込みをサポートしていない場合に投げられるエラーです。
+*/
+var MultipartWriteNotSupportedError = class extends ErrorBase {
+	constructor(args) {
+		const { name, ...options } = args;
+		super({ name }, ({ name: messageName }) => `Storage "${messageName}" does not support multipart-write`, options);
+	}
+};
+_MultipartWriteNotSupportedError = MultipartWriteNotSupportedError;
+_MultipartWriteNotSupportedError.prototype.name = "UniKvsMultipartWriteNotSupportedError";
+setErrorMessage(MultipartWriteNotSupportedError, ({ name }) => `ストレージ "${name}" はマルチパート書き込みをサポートしていません`, "ja");
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+*/
+var MiddlewareIsNotOpenError = class extends ErrorBase {
+	constructor(args) {
+		const { name, ...options } = args;
+		super({ name }, ({ name: messageName }) => `Middleware "${messageName}" is not open`, options);
+	}
+};
+_MiddlewareIsNotOpenError = MiddlewareIsNotOpenError;
+_MiddlewareIsNotOpenError.prototype.name = "UniKvsMiddlewareIsNotOpenError";
+setErrorMessage(MiddlewareIsNotOpenError, ({ name }) => `ミドルウェア "${name}" は開いていません`, "ja");
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+*/
+var MiddlewareDestinationMissingError = class extends ErrorBase {
+	constructor(args) {
+		const { name, operation, ...options } = args;
+		super({
+			name,
+			operation
+		}, ({ name: messageName, operation: messageOperation }) => `Middleware "${messageName}" did not set destination for ${messageOperation}.`, options);
+	}
+};
+_MiddlewareDestinationMissingError = MiddlewareDestinationMissingError;
+_MiddlewareDestinationMissingError.prototype.name = "UniKvsMiddlewareDestinationMissingError";
+setErrorMessage(MiddlewareDestinationMissingError, ({ name, operation }) => `ミドルウェア "${name}" は ${operation} の destination を設定しませんでした。`, "ja");
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+*/
+var MiddlewareDestinationFrozenError = class extends ErrorBase {
+	constructor(args) {
+		const { key, action, ...options } = args;
+		super({
+			key,
+			action
+		}, ({ key: messageKey, action: messageAction }) => `Cannot set destination after next() was called for ${messageAction} operation on key ${JSON.stringify(messageKey)}.`, options);
+	}
+};
+_MiddlewareDestinationFrozenError = MiddlewareDestinationFrozenError;
+_MiddlewareDestinationFrozenError.prototype.name = "UniKvsMiddlewareDestinationFrozenError";
+setErrorMessage(MiddlewareDestinationFrozenError, ({ key: messageKey, action: messageAction }) => `next() を呼び出した後に destination を設定できません（${messageAction} 操作、キー ${JSON.stringify(messageKey)}）。`, "ja");
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+*/
+var MiddlewareNextNotCalledError = class extends ErrorBase {
+	constructor(args) {
+		const { name, operation, ...options } = args;
+		super({
+			name,
+			operation
+		}, ({ name: messageName, operation: messageOperation }) => `Middleware "${messageName}" did not call next() for ${messageOperation}.`, options);
+	}
+};
+_MiddlewareNextNotCalledError = MiddlewareNextNotCalledError;
+_MiddlewareNextNotCalledError.prototype.name = "UniKvsMiddlewareNextNotCalledError";
+setErrorMessage(MiddlewareNextNotCalledError, ({ name, operation }) => `ミドルウェア "${name}" は ${operation} で next() を呼びませんでした。`, "ja");
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+*/
+var MiddlewareNextNotAwaitedError = class extends ErrorBase {
+	constructor(args) {
+		const { name, operation, ...options } = args;
+		super({
+			name,
+			operation
+		}, ({ name: messageName, operation: messageOperation }) => `Middleware "${messageName}" did not await next() for ${messageOperation}.`, options);
+	}
+};
+_MiddlewareNextNotAwaitedError = MiddlewareNextNotAwaitedError;
+_MiddlewareNextNotAwaitedError.prototype.name = "UniKvsMiddlewareNextNotAwaitedError";
+setErrorMessage(MiddlewareNextNotAwaitedError, ({ name, operation }) => `ミドルウェア "${name}" は ${operation} で next() を await しませんでした。`, "ja");
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+*/
+var MiddlewareNextCalledMultipleTimesError = class extends ErrorBase {
+	constructor(args) {
+		const { name, operation, ...options } = args;
+		super({
+			name,
+			operation
+		}, ({ name: messageName, operation: messageOperation }) => `Middleware "${messageName}" called next() multiple times for ${messageOperation}.`, options);
+	}
+};
+_MiddlewareNextCalledMultipleTimesError = MiddlewareNextCalledMultipleTimesError;
+_MiddlewareNextCalledMultipleTimesError.prototype.name = "UniKvsMiddlewareNextCalledMultipleTimesError";
+setErrorMessage(MiddlewareNextCalledMultipleTimesError, ({ name, operation }) => `ミドルウェア "${name}" は ${operation} で next() を複数回呼びました。`, "ja");
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+*/
+var StreamEncodingNotSupportedError = class extends ErrorBase {
+	constructor(args) {
+		const { name, ...options } = args;
+		super({ name }, ({ name: messageName }) => `Middleware "${messageName}" does not support stream encoding.`, options);
+	}
+};
+_StreamEncodingNotSupportedError = StreamEncodingNotSupportedError;
+_StreamEncodingNotSupportedError.prototype.name = "UniKvsStreamEncodingNotSupportedError";
+setErrorMessage(StreamEncodingNotSupportedError, ({ name }) => `ミドルウェア "${name}" はストリームのエンコードをサポートしていません。`, "ja");
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+*/
+var StreamDecodingNotSupportedError = class extends ErrorBase {
+	constructor(args) {
+		const { name, ...options } = args;
+		super({ name }, ({ name: messageName }) => `Middleware "${messageName}" does not support decodable stream`, options);
+	}
+};
+_StreamDecodingNotSupportedError = StreamDecodingNotSupportedError;
+_StreamDecodingNotSupportedError.prototype.name = "UniKvsStreamDecodingNotSupportedError";
+setErrorMessage(StreamDecodingNotSupportedError, ({ name }) => `ミドルウェア "${name}" はデコード可能なストリームをサポートしていません`, "ja");
+/**
+* プラグイン種別を正規化します。
+*
+* @param plugin 種別名です。
+*
+* @returns 正規化された種別を返します。
+*/
+function normalizePlugin(plugin) {
+	return plugin;
+}
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+*/
+var PluginOperationAggregateError = class extends ErrorBase {
+	constructor(args) {
+		const { action, errors, plugin, ...options } = args;
+		const normalizedErrors = errors.map((error) => ({
+			plugin: normalizePlugin(error.plugin ?? plugin ?? ""),
+			...error.name !== void 0 ? { name: error.name } : {},
+			...error.index !== void 0 ? { index: error.index } : {},
+			reason: error.reason
+		}));
+		const plugins = [...new Set(normalizedErrors.map((error) => error.plugin))];
+		const [onlyPlugin] = plugins;
+		const meta = {
+			action,
+			errors: normalizedErrors,
+			plugin: plugins.length === 1 && onlyPlugin !== void 0 ? onlyPlugin : "plugin"
+		};
+		super(meta, ({ action: messageAction, errors: messageErrors, plugin: messagePlugin }) => `${messageErrors.length} ${messagePlugin}(s) fail ${messageAction} operation`, options);
+	}
+};
+_PluginOperationAggregateError = PluginOperationAggregateError;
+_PluginOperationAggregateError.prototype.name = "UniKvsPluginOperationAggregateError";
+setErrorMessage(PluginOperationAggregateError, ({ action, errors, plugin }) => `${errors.length} 個の${{
+	plugin: "プラグイン",
+	storage: "ストレージ",
+	middleware: "ミドルウェア"
+}[plugin]}が ${action} 操作に失敗`, "ja");
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+*/
+var MissingStorageError = class extends ErrorBase {
+	constructor(options) {
+		super("At least one storage is required to use UniKvs", options);
+	}
+};
+_MissingStorageError = MissingStorageError;
+_MissingStorageError.prototype.name = "UniKvsMissingStorageError";
+setErrorMessage(MissingStorageError, "UniKvs を使用するためには最低 1 つのストレージが必要です", "ja");
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/checkPrivateRedeclaration.js
+function _checkPrivateRedeclaration(e, t) {
+	if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/classPrivateFieldInitSpec.js
+function _classPrivateFieldInitSpec(e, t, a) {
+	_checkPrivateRedeclaration(e, t), t.set(e, a);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/assertClassBrand.js
+function _assertClassBrand(e, t, n) {
+	if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+	throw new TypeError("Private element is not present on this object");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/classPrivateFieldSet2.js
+function _classPrivateFieldSet2(s, a, r) {
+	return s.set(_assertClassBrand(s, a), r), r;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/classPrivateFieldGet2.js
+function _classPrivateFieldGet2(s, a) {
+	return s.get(_assertClassBrand(s, a));
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/classPrivateMethodInitSpec.js
+function _classPrivateMethodInitSpec(e, a) {
+	_checkPrivateRedeclaration(e, a), a.add(e);
+}
+//#endregion
+//#region ../src/_plugin-lifecycle.ts
+var _plugin = /* @__PURE__ */ new WeakMap();
+var _references = /* @__PURE__ */ new WeakMap();
+var _closeFailed = /* @__PURE__ */ new WeakMap();
+var _PluginLifecycle_brand = /* @__PURE__ */ new WeakSet();
+/**
+* 共有プラグインの参照カウントと実 `close` の再試行を管理します。
+*
+* 同じプラグインを共有する利用者のうち、最初の `open` だけが実際に開き、最後の `close` だけが実際に閉じます。
+* 実 `close` に失敗したときは所有権を残し、次の `close` で再試行できるようにします。
+*
+* @template TOpenContext オープンコンテキストの型です。
+* @template TCloseContext クローズコンテキストの型です。
+*/
+var PluginLifecycle = class {
+	constructor(plugin) {
+		_classPrivateMethodInitSpec(this, _PluginLifecycle_brand);
+		_classPrivateFieldInitSpec(this, _plugin, void 0);
+		_classPrivateFieldInitSpec(this, _references, void 0);
+		_classPrivateFieldInitSpec(this, _closeFailed, void 0);
+		_classPrivateFieldSet2(_plugin, this, plugin);
+		_classPrivateFieldSet2(_references, this, 0);
+		_classPrivateFieldSet2(_closeFailed, this, false);
+	}
+	/**
+	* プラグインを開きます。
+	*
+	* 同じプラグインを共有する利用者のうち、最初の 1 回だけ実際の `open` を呼びます。
+	* この管理対象外で既に開かれているプラグインは open/close の対象外にします。
+	* 参照が残っていても実体が閉じられているときは、既存の参照を失わずに実 open へフォールバックします。
+	* `close` を持たないプラグインは閉じられないため、参照を数えません。
+	*
+	* @param c オープンコンテキストです。
+	*/
+	async open(c) {
+		if (_classPrivateFieldGet2(_plugin, this).open === void 0) return;
+		if (_classPrivateFieldGet2(_plugin, this).close === void 0) {
+			if (_classPrivateFieldGet2(_plugin, this).isOpen) return;
+			await _classPrivateFieldGet2(_plugin, this).open(c);
+			return;
+		}
+		if (_classPrivateFieldGet2(_plugin, this).isOpen && _classPrivateFieldGet2(_references, this) === 0 && !_classPrivateFieldGet2(_closeFailed, this)) return;
+		if (_classPrivateFieldGet2(_references, this) > 0 || _classPrivateFieldGet2(_closeFailed, this)) {
+			if (_classPrivateFieldGet2(_plugin, this).isOpen) {
+				_classPrivateFieldSet2(_references, this, _classPrivateFieldGet2(_references, this) + 1);
+				_classPrivateFieldSet2(_closeFailed, this, false);
+				return;
+			}
+			await _classPrivateFieldGet2(_plugin, this).open(c);
+			_classPrivateFieldSet2(_references, this, _classPrivateFieldGet2(_references, this) + 1);
+			_classPrivateFieldSet2(_closeFailed, this, false);
+			return;
+		}
+		await _classPrivateFieldGet2(_plugin, this).open(c);
+		_classPrivateFieldSet2(_references, this, _classPrivateFieldGet2(_references, this) + 1);
+	}
+	/**
+	* プラグインを閉じます。
+	*
+	* 同じプラグインを共有する利用者のうち、最後の 1 回だけ実際の `close` を呼びます。
+	* 各呼び出しで参照を 1 つ減らし、実 `close` は全参照が解放されたときにだけ呼びます。
+	* 実 `close` に失敗したときは所有権を残し、次の `close` で再試行できるようにします。
+	* `close` を持たないプラグインは open で参照を数えないため、ここでは何もしません。
+	* 実 `close` へ渡すコンテキストは最後に閉じる利用者のものであり、最初に開いた利用者の vars/signal は保持しません。
+	*
+	* @param c クローズコンテキストです。
+	*/
+	async close(c) {
+		if (_classPrivateFieldGet2(_plugin, this).close === void 0) return;
+		if (_classPrivateFieldGet2(_references, this) === 0 && !_classPrivateFieldGet2(_closeFailed, this)) return;
+		if (_classPrivateFieldGet2(_references, this) > 0) _classPrivateFieldSet2(_references, this, _classPrivateFieldGet2(_references, this) - 1);
+		if (_classPrivateFieldGet2(_references, this) > 0) return;
+		if (!_classPrivateFieldGet2(_plugin, this).isOpen) {
+			_classPrivateFieldSet2(_closeFailed, this, false);
+			return;
+		}
+		await _assertClassBrand(_PluginLifecycle_brand, this, _closeReal).call(this, c);
+	}
+	/**
+	* 失敗した実 `close` だけを再試行します。
+	*
+	* 通常の `close` と違い参照を減らしません。close 失敗後に新しい `open` が所有権を引き継いでいる場合は何もしません。
+	* 実体が既に閉じられているときは失敗状態だけを解消します。
+	*
+	* @param c クローズコンテキストです。
+	*/
+	async retryClose(c) {
+		if (_classPrivateFieldGet2(_plugin, this).close === void 0) return;
+		if (!_classPrivateFieldGet2(_closeFailed, this) || _classPrivateFieldGet2(_references, this) > 0) return;
+		if (!_classPrivateFieldGet2(_plugin, this).isOpen) {
+			_classPrivateFieldSet2(_closeFailed, this, false);
+			return;
+		}
+		await _assertClassBrand(_PluginLifecycle_brand, this, _closeReal).call(this, c);
+	}
+};
+/**
+* 実 `close` を実行し、失敗したかどうかを記録します。
+*
+* @param c クローズコンテキストです。
+*/
+async function _closeReal(c) {
+	if (_classPrivateFieldGet2(_plugin, this).close === void 0) return;
+	try {
+		await _classPrivateFieldGet2(_plugin, this).close(c);
+		_classPrivateFieldSet2(_closeFailed, this, false);
+	} catch (ex) {
+		_classPrivateFieldSet2(_closeFailed, this, true);
+		throw ex;
+	}
+}
+//#endregion
+//#region ../src/_middleware.ts
+var _UniKvsMiddleware;
+let _initProto$1;
+function _applyDecs$1(e, t, n, r, o, i) {
+	var a, c, u, s, f, l, p, d = Symbol.metadata || Symbol.for("Symbol.metadata"), m = Object.defineProperty, h = Object.create, y = [h(null), h(null)], v = t.length;
+	function g(t, n, r) {
+		return function(o, i) {
+			n && (i = o, o = e);
+			for (var a = 0; a < t.length; a++) i = t[a].apply(o, r ? [i] : []);
+			return r ? i : o;
+		};
+	}
+	function b(e, t, n, r) {
+		if ("function" != typeof e && (r || void 0 !== e)) throw new TypeError(t + " must " + (n || "be") + " a function" + (r ? "" : " or undefined"));
+		return e;
+	}
+	function applyDec(e, t, n, r, o, i, u, s, f, l, p) {
+		function d(e) {
+			if (!p(e)) throw new TypeError("Attempted to access private element on non-instance");
+		}
+		var h = [].concat(t[0]), v = t[3], w = !u, D = 1 === o, S = 3 === o, j = 4 === o, E = 2 === o;
+		function I(t, n, r) {
+			return function(o, i) {
+				return n && (i = o, o = e), r && r(o), P[t].call(o, i);
+			};
+		}
+		if (!w) {
+			var P = {}, k = [], F = S ? "get" : j || D ? "set" : "value";
+			if (f ? (l || D ? P = {
+				get: _setFunctionName$1(function() {
+					return v(this);
+				}, r, "get"),
+				set: function(e) {
+					t[4](this, e);
+				}
+			} : P[F] = v, l || _setFunctionName$1(P[F], r, E ? "" : F)) : l || (P = Object.getOwnPropertyDescriptor(e, r)), !l && !f) {
+				if ((c = y[+s][r]) && 7 !== (c ^ o)) throw Error("Decorating two elements with the same name (" + P[F].name + ") is not supported yet");
+				y[+s][r] = o < 3 ? 1 : o;
+			}
+		}
+		for (var N = e, O = h.length - 1; O >= 0; O -= n ? 2 : 1) {
+			var T = b(h[O], "A decorator", "be", !0), z = n ? h[O - 1] : void 0, A = {}, H = {
+				kind: [
+					"field",
+					"accessor",
+					"method",
+					"getter",
+					"setter",
+					"class"
+				][o],
+				name: r,
+				metadata: a,
+				addInitializer: function(e, t) {
+					if (e.v) throw new TypeError("attempted to call addInitializer after decoration was finished");
+					b(t, "An initializer", "be", !0), i.push(t);
+				}.bind(null, A)
+			};
+			if (w) c = T.call(z, N, H), A.v = 1, b(c, "class decorators", "return") && (N = c);
+			else if (H.static = s, H.private = f, c = H.access = { has: f ? p.bind() : function(e) {
+				return r in e;
+			} }, j || (c.get = f ? E ? function(e) {
+				return d(e), P.value;
+			} : I("get", 0, d) : function(e) {
+				return e[r];
+			}), E || S || (c.set = f ? I("set", 0, d) : function(e, t) {
+				e[r] = t;
+			}), N = T.call(z, D ? {
+				get: P.get,
+				set: P.set
+			} : P[F], H), A.v = 1, D) {
+				if ("object" == typeof N && N) (c = b(N.get, "accessor.get")) && (P.get = c), (c = b(N.set, "accessor.set")) && (P.set = c), (c = b(N.init, "accessor.init")) && k.unshift(c);
+				else if (void 0 !== N) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined");
+			} else b(N, (l ? "field" : "method") + " decorators", "return") && (l ? k.unshift(N) : P[F] = N);
+		}
+		return o < 2 && u.push(g(k, s, 1), g(i, s, 0)), l || w || (f ? D ? u.splice(-1, 0, I("get", s), I("set", s)) : u.push(E ? P[F] : b.call.bind(P[F])) : m(e, r, P)), N;
+	}
+	function w(e) {
+		return m(e, d, {
+			configurable: !0,
+			enumerable: !0,
+			value: a
+		});
+	}
+	return void 0 !== i && (a = i[d]), a = h(null == a ? null : a), f = [], l = function(e) {
+		e && f.push(g(e));
+	}, p = function(t, r) {
+		for (var i = 0; i < n.length; i++) {
+			var a = n[i], c = a[1], l = 7 & c;
+			if ((8 & c) == t && !l == r) {
+				var p = a[2], d = !!a[3], m = 16 & c;
+				applyDec(t ? e : e.prototype, a, m, d ? "#" + p : _toPropertyKey$1(p), l, l < 2 ? [] : t ? s = s || [] : u = u || [], f, !!t, d, r, t && d ? function(t) {
+					return _checkInRHS$1(t) === e;
+				} : o);
+			}
+		}
+	}, p(8, 0), p(0, 0), p(8, 1), p(0, 1), l(u), l(s), c = f, v || w(e), {
+		e: c,
+		get c() {
+			var n = [];
+			return v && [w(e = applyDec(e, [t], r, e.name, 5, n)), g(n, 1)];
+		}
+	};
+}
+function _toPropertyKey$1(t) {
+	var i = _toPrimitive$1(t, "string");
+	return "symbol" == typeof i ? i : i + "";
+}
+function _toPrimitive$1(t, e) {
+	if ("object" != typeof t || !t) return t;
+	var r;
+	if ("undefined" != typeof Symbol && void 0 !== (r = t[Symbol.toPrimitive])) {
+		var i = r.call(t, e || "default");
+		if ("object" != typeof i) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === e ? String : Number)(t);
+}
+function _setFunctionName$1(e, t, n) {
+	"symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : "");
+	try {
+		Object.defineProperty(e, "name", {
+			configurable: !0,
+			value: n ? n + " " + t : t
+		});
+	} catch (e) {}
+	return e;
+}
+function _checkInRHS$1(e) {
+	if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null"));
+	return e;
+}
+/**
+* 同じオブジェクトに対して同じ `UniKvsMiddleware` インスタンスを返すためのメモです。
+*/
+const instances$1 = /* #__PURE__ */ new WeakMap();
+var _mw = /* @__PURE__ */ new WeakMap();
+var _lifecycle$1 = /* @__PURE__ */ new WeakMap();
+/**
+* `IMiddleware` を `UniKvs` 内部から扱うためのラッパーです。
+*
+* ミドルウェアを安全に使うための検証などの処理が集約されています。
+*/
+var UniKvsMiddleware = class UniKvsMiddleware {
+	constructor(middleware) {
+		_classPrivateFieldInitSpec(this, _mw, void _initProto$1(this));
+		_classPrivateFieldInitSpec(this, _lifecycle$1, void 0);
+		_classPrivateFieldSet2(_mw, this, middleware);
+		_classPrivateFieldSet2(_lifecycle$1, this, new PluginLifecycle(middleware));
+		this.name = middleware.name;
+	}
+	/**
+	* `IMiddleware` から `UniKvs` 内部から扱うためのミドルウェアを作成します。
+	*
+	* @param middleware 元となるミドルウェアです。
+	*
+	* @returns 検証などの機能が集約されたミドルウェアです。
+	*/
+	static from(middleware) {
+		return callFnOnce(instances$1, middleware, () => new UniKvsMiddleware(middleware));
+	}
+	/**
+	* ミドルウェアを開きます。
+	*
+	* @param c オープンコンテキストです。
+	*/
+	async open(c) {
+		await _classPrivateFieldGet2(_lifecycle$1, this).open(c);
+	}
+	/**
+	* ミドルウェアを閉じます。
+	*
+	* @param c クローズコンテキストです。
+	*/
+	async close(c) {
+		await _classPrivateFieldGet2(_lifecycle$1, this).close(c);
+	}
+	/**
+	* 失敗した実 `close` だけを再試行します。
+	*
+	* @param c クローズコンテキストです。
+	*/
+	async retryClose(c) {
+		await _classPrivateFieldGet2(_lifecycle$1, this).retryClose(c);
+	}
+	/**
+	* キーを写像します。
+	*
+	* @param c キー写像コンテキストです。
+	*
+	* @returns 写像後のキーを返します。
+	*/
+	mapKey(c) {
+		if (!_classPrivateFieldGet2(_mw, this).isOpen) throw new MiddlewareIsNotOpenError({ name: this.name });
+		if (_classPrivateFieldGet2(_mw, this).mapKey === void 0) return c.key;
+		return _classPrivateFieldGet2(_mw, this).mapKey(c);
+	}
+	/**
+	* 任意の操作に割り込みます。
+	*
+	* @param c 操作コンテキストです。
+	* @param next 後段の処理です。
+	*/
+	async use(c, next) {
+		if (!_classPrivateFieldGet2(_mw, this).isOpen) throw new MiddlewareIsNotOpenError({ name: this.name });
+		if (_classPrivateFieldGet2(_mw, this).use === void 0) await next();
+		else await _classPrivateFieldGet2(_mw, this).use(c, next);
+	}
+	/**
+	* データをエンコードします。
+	*
+	* @param c エンコードコンテキストです。
+	* @param next 後段の処理です。
+	*/
+	async encode(c, next) {
+		if (!_classPrivateFieldGet2(_mw, this).isOpen) throw new MiddlewareIsNotOpenError({ name: this.name });
+		if (_classPrivateFieldGet2(_mw, this).encode === void 0) {
+			c.destination = c.source;
+			await next();
+		} else await _classPrivateFieldGet2(_mw, this).encode(c, next);
+	}
+	/**
+	* データをデコードします。
+	*
+	* @param c デコードコンテキストです。
+	* @param next 後段の処理です。
+	*/
+	async decode(c, next) {
+		if (!_classPrivateFieldGet2(_mw, this).isOpen) throw new MiddlewareIsNotOpenError({ name: this.name });
+		if (_classPrivateFieldGet2(_mw, this).decode === void 0) {
+			c.destination = c.source;
+			await next();
+		} else await _classPrivateFieldGet2(_mw, this).decode(c, next);
+	}
+	/**
+	* ストリームをエンコードします。
+	*
+	* @param c エンコードストリームコンテキストです。
+	* @param next 後段の処理です。
+	*/
+	async encodeStream(c, next) {
+		if (!_classPrivateFieldGet2(_mw, this).isOpen) throw new MiddlewareIsNotOpenError({ name: this.name });
+		if (_classPrivateFieldGet2(_mw, this).encodeStream === void 0) throw new StreamEncodingNotSupportedError({ name: this.name });
+		await _classPrivateFieldGet2(_mw, this).encodeStream(c, next);
+	}
+	/**
+	* ストリームをデコードします。
+	*
+	* @param c デコードストリームコンテキストです。
+	* @param next 後段の処理です。
+	*/
+	async decodeStream(c, next) {
+		if (!_classPrivateFieldGet2(_mw, this).isOpen) throw new MiddlewareIsNotOpenError({ name: this.name });
+		if (_classPrivateFieldGet2(_mw, this).decodeStream === void 0) throw new StreamDecodingNotSupportedError({ name: this.name });
+		await _classPrivateFieldGet2(_mw, this).decodeStream(c, next);
+	}
+};
+_UniKvsMiddleware = UniKvsMiddleware;
+[_initProto$1] = _applyDecs$1(_UniKvsMiddleware, [], [
+	[
+		asyncmux,
+		2,
+		"open"
+	],
+	[
+		asyncmux,
+		2,
+		"close"
+	],
+	[
+		asyncmux,
+		2,
+		"retryClose"
+	]
+]).e;
+//#endregion
+//#region ../src/_streams.ts
+/**
+* 値が `ReadableStream` のインターフェースを満たすかどうかを判定します。
+*
+* ランタイムによっては `ReadableStream` クラスを継承せずに同じインターフェースを備えたオブジェクトが存在するため、`instanceof` ではなく必要なメソッドの有無で判定します。
+*
+* @param input 判定する値です。
+*
+* @returns `ReadableStream` のインターフェースを満たす場合は `true` を返します。
+*/
+function isReadableStream(input) {
+	if (typeof input !== "object" || input === null) return false;
+	const stream = input;
+	return typeof stream.tee === "function" && typeof stream.cancel === "function" && typeof stream.pipeTo === "function" && typeof stream.getReader === "function" && typeof stream.pipeThrough === "function";
+}
+/**
+* 値が `WritableStream` のインターフェースを満たすかどうかを判定します。
+*
+* ランタイムによっては `WritableStream` クラスを継承せずに同じインターフェースを備えたオブジェクトが存在するため、`instanceof` ではなく必要なメソッドの有無で判定します。
+*
+* @param input 判定する値です。
+*
+* @returns `WritableStream` のインターフェースを満たす場合は `true` を返します。
+*/
+function isWritableStream(input) {
+	if (typeof input !== "object" || input === null) return false;
+	const stream = input;
+	return typeof stream.abort === "function" && typeof stream.close === "function" && typeof stream.getWriter === "function";
+}
+/**
+* ストリームの重複を除いてキャンセルします。
+*
+* 個々のキャンセルに失敗しても無視し、元の例外を優先して伝えます。
+*
+* @param streams キャンセルするストリームです。
+* @param reason キャンセル理由です。
+*/
+async function cancelStreams(streams, reason) {
+	await Promise.all([...new Set(streams)].map(async (stream) => {
+		try {
+			await stream.cancel(reason);
+		} catch {}
+	}));
+}
+//#endregion
+//#region ../src/_valibot.ts
+function parseInput(schema, value, Error = InvalidInputError) {
+	const result = safeParse(schema, value);
+	if (result.success) return result.output;
+	const error = new Error({
+		value,
+		issues: result.issues
+	});
+	tryCaptureStackTrace(error, parseInput);
+	throw error;
+}
+function parseOutput(schema, value, Error = InvalidOutputError) {
+	const result = safeParse(schema, value);
+	if (result.success) return result.output;
+	const error = new Error({
+		value,
+		issues: result.issues
+	});
+	tryCaptureStackTrace(error, parseOutput);
+	throw error;
+}
+//#endregion
+//#region ../src/_streams.schemas.ts
+/**
+* `ReadableStream` のインターフェースを満たすかを検証するためのスキーマです。
+*/
+const ReadableStreamSchema = custom(isReadableStream, "Expected a ReadableStream");
+/**
+* `WritableStream` のインターフェースを満たすかを検証するためのスキーマです。
+*/
+const WritableStreamSchema = custom(isWritableStream, "Expected a WritableStream");
+//#endregion
+//#region ../src/_storage.ts
+var _UniKvsStorage;
+let _initProto;
+function _applyDecs(e, t, n, r, o, i) {
+	var a, c, u, s, f, l, p, d = Symbol.metadata || Symbol.for("Symbol.metadata"), m = Object.defineProperty, h = Object.create, y = [h(null), h(null)], v = t.length;
+	function g(t, n, r) {
+		return function(o, i) {
+			n && (i = o, o = e);
+			for (var a = 0; a < t.length; a++) i = t[a].apply(o, r ? [i] : []);
+			return r ? i : o;
+		};
+	}
+	function b(e, t, n, r) {
+		if ("function" != typeof e && (r || void 0 !== e)) throw new TypeError(t + " must " + (n || "be") + " a function" + (r ? "" : " or undefined"));
+		return e;
+	}
+	function applyDec(e, t, n, r, o, i, u, s, f, l, p) {
+		function d(e) {
+			if (!p(e)) throw new TypeError("Attempted to access private element on non-instance");
+		}
+		var h = [].concat(t[0]), v = t[3], w = !u, D = 1 === o, S = 3 === o, j = 4 === o, E = 2 === o;
+		function I(t, n, r) {
+			return function(o, i) {
+				return n && (i = o, o = e), r && r(o), P[t].call(o, i);
+			};
+		}
+		if (!w) {
+			var P = {}, k = [], F = S ? "get" : j || D ? "set" : "value";
+			if (f ? (l || D ? P = {
+				get: _setFunctionName(function() {
+					return v(this);
+				}, r, "get"),
+				set: function(e) {
+					t[4](this, e);
+				}
+			} : P[F] = v, l || _setFunctionName(P[F], r, E ? "" : F)) : l || (P = Object.getOwnPropertyDescriptor(e, r)), !l && !f) {
+				if ((c = y[+s][r]) && 7 !== (c ^ o)) throw Error("Decorating two elements with the same name (" + P[F].name + ") is not supported yet");
+				y[+s][r] = o < 3 ? 1 : o;
+			}
+		}
+		for (var N = e, O = h.length - 1; O >= 0; O -= n ? 2 : 1) {
+			var T = b(h[O], "A decorator", "be", !0), z = n ? h[O - 1] : void 0, A = {}, H = {
+				kind: [
+					"field",
+					"accessor",
+					"method",
+					"getter",
+					"setter",
+					"class"
+				][o],
+				name: r,
+				metadata: a,
+				addInitializer: function(e, t) {
+					if (e.v) throw new TypeError("attempted to call addInitializer after decoration was finished");
+					b(t, "An initializer", "be", !0), i.push(t);
+				}.bind(null, A)
+			};
+			if (w) c = T.call(z, N, H), A.v = 1, b(c, "class decorators", "return") && (N = c);
+			else if (H.static = s, H.private = f, c = H.access = { has: f ? p.bind() : function(e) {
+				return r in e;
+			} }, j || (c.get = f ? E ? function(e) {
+				return d(e), P.value;
+			} : I("get", 0, d) : function(e) {
+				return e[r];
+			}), E || S || (c.set = f ? I("set", 0, d) : function(e, t) {
+				e[r] = t;
+			}), N = T.call(z, D ? {
+				get: P.get,
+				set: P.set
+			} : P[F], H), A.v = 1, D) {
+				if ("object" == typeof N && N) (c = b(N.get, "accessor.get")) && (P.get = c), (c = b(N.set, "accessor.set")) && (P.set = c), (c = b(N.init, "accessor.init")) && k.unshift(c);
+				else if (void 0 !== N) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined");
+			} else b(N, (l ? "field" : "method") + " decorators", "return") && (l ? k.unshift(N) : P[F] = N);
+		}
+		return o < 2 && u.push(g(k, s, 1), g(i, s, 0)), l || w || (f ? D ? u.splice(-1, 0, I("get", s), I("set", s)) : u.push(E ? P[F] : b.call.bind(P[F])) : m(e, r, P)), N;
+	}
+	function w(e) {
+		return m(e, d, {
+			configurable: !0,
+			enumerable: !0,
+			value: a
+		});
+	}
+	return void 0 !== i && (a = i[d]), a = h(null == a ? null : a), f = [], l = function(e) {
+		e && f.push(g(e));
+	}, p = function(t, r) {
+		for (var i = 0; i < n.length; i++) {
+			var a = n[i], c = a[1], l = 7 & c;
+			if ((8 & c) == t && !l == r) {
+				var p = a[2], d = !!a[3], m = 16 & c;
+				applyDec(t ? e : e.prototype, a, m, d ? "#" + p : _toPropertyKey(p), l, l < 2 ? [] : t ? s = s || [] : u = u || [], f, !!t, d, r, t && d ? function(t) {
+					return _checkInRHS(t) === e;
+				} : o);
+			}
+		}
+	}, p(8, 0), p(0, 0), p(8, 1), p(0, 1), l(u), l(s), c = f, v || w(e), {
+		e: c,
+		get c() {
+			var n = [];
+			return v && [w(e = applyDec(e, [t], r, e.name, 5, n)), g(n, 1)];
+		}
+	};
+}
+function _toPropertyKey(t) {
+	var i = _toPrimitive(t, "string");
+	return "symbol" == typeof i ? i : i + "";
+}
+function _toPrimitive(t, e) {
+	if ("object" != typeof t || !t) return t;
+	var r;
+	if ("undefined" != typeof Symbol && void 0 !== (r = t[Symbol.toPrimitive])) {
+		var i = r.call(t, e || "default");
+		if ("object" != typeof i) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === e ? String : Number)(t);
+}
+function _setFunctionName(e, t, n) {
+	"symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : "");
+	try {
+		Object.defineProperty(e, "name", {
+			configurable: !0,
+			value: n ? n + " " + t : t
+		});
+	} catch (e) {}
+	return e;
+}
+function _checkInRHS(e) {
+	if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null"));
+	return e;
+}
+/**
+* 同じオブジェクトに対して同じ `UniKvsStorage` インスタンスを返すためのメモです。
+*/
+const instances = /* #__PURE__ */ new WeakMap();
+var _io = /* @__PURE__ */ new WeakMap();
+var _lifecycle = /* @__PURE__ */ new WeakMap();
+/**
+* `IStorage` を `UniKvs` 内部から扱うためのラッパーです。
+*
+* ストレージを安全に使うための検証などの処理が集約されています。
+*/
+var UniKvsStorage = class UniKvsStorage {
+	constructor(storage) {
+		_classPrivateFieldInitSpec(this, _io, void _initProto(this));
+		_classPrivateFieldInitSpec(this, _lifecycle, void 0);
+		_classPrivateFieldSet2(_io, this, storage);
+		_classPrivateFieldSet2(_lifecycle, this, new PluginLifecycle(storage));
+		this.name = storage.name;
+	}
+	/**
+	* `IStorage` から `UniKvs` 内部から扱うためのストレージを作成します。
+	*
+	* @param storage 元となるストレージです。
+	*
+	* @returns 検証などの機能が集約されたストレージです。
+	*/
+	static from(storage) {
+		return callFnOnce(instances, storage, () => new UniKvsStorage(storage));
+	}
+	/**
+	* ストレージを開きます。
+	*
+	* @param c オープンコンテキストです。
+	*/
+	async open(c) {
+		await _classPrivateFieldGet2(_lifecycle, this).open(c);
+	}
+	/**
+	* ストレージを閉じます。
+	*
+	* @param c クローズコンテキストです。
+	*/
+	async close(c) {
+		await _classPrivateFieldGet2(_lifecycle, this).close(c);
+	}
+	/**
+	* 失敗した実 `close` だけを再試行します。
+	*
+	* @param c クローズコンテキストです。
+	*/
+	async retryClose(c) {
+		await _classPrivateFieldGet2(_lifecycle, this).retryClose(c);
+	}
+	/**
+	* データを書き込みます。
+	*
+	* @param c 書き込みコンテキストです。
+	* @param data 書き込むデータです。
+	*/
+	async write(c, data) {
+		if (!_classPrivateFieldGet2(_io, this).isOpen) throw new StorageIsNotOpenError({ name: this.name });
+		await _classPrivateFieldGet2(_io, this).write(c, data);
+	}
+	/**
+	* データを読み取ります。
+	*
+	* @param c 読み取りコンテキストです。
+	*
+	* @returns 読み取ったデータを返します。
+	*/
+	async read(c) {
+		if (!_classPrivateFieldGet2(_io, this).isOpen) throw new StorageIsNotOpenError({ name: this.name });
+		return await _classPrivateFieldGet2(_io, this).read(c);
+	}
+	/**
+	* データの存在を確認します。
+	*
+	* @param c 存在確認コンテキストです。
+	*
+	* @returns 存在する場合は `true` を返します。
+	*/
+	async exists(c) {
+		if (!_classPrivateFieldGet2(_io, this).isOpen) throw new StorageIsNotOpenError({ name: this.name });
+		return await _classPrivateFieldGet2(_io, this).exists(c);
+	}
+	/**
+	* データを削除します。
+	*
+	* @param c 削除コンテキストです。
+	*/
+	async delete(c) {
+		if (!_classPrivateFieldGet2(_io, this).isOpen) throw new StorageIsNotOpenError({ name: this.name });
+		await _classPrivateFieldGet2(_io, this).delete(c);
+	}
+	/**
+	* データをすべて削除します。
+	*
+	* @param c クリアコンテキストです。
+	*/
+	async clear(c) {
+		if (!_classPrivateFieldGet2(_io, this).isOpen) throw new StorageIsNotOpenError({ name: this.name });
+		await _classPrivateFieldGet2(_io, this).clear(c);
+	}
+	/**
+	* 読み取り用のストリームを取得します。
+	*
+	* @param c ストリーム取得コンテキストです。
+	*
+	* @returns 読み取り用のストリームを返します。
+	*/
+	async getReadable(c) {
+		if (!_classPrivateFieldGet2(_io, this).isOpen) throw new StorageIsNotOpenError({ name: this.name });
+		if (_classPrivateFieldGet2(_io, this).getReadable === void 0) throw new ReadableStreamNotSupportedError({ name: this.name });
+		const output = await _classPrivateFieldGet2(_io, this).getReadable(c);
+		return parseOutput(ReadableStreamSchema, output);
+	}
+	/**
+	* 書き込み用のストリームを取得します。
+	*
+	* @param c ストリーム取得コンテキストです。
+	*
+	* @returns 書き込み用のストリームを返します。
+	*/
+	async getWritable(c) {
+		if (!_classPrivateFieldGet2(_io, this).isOpen) throw new StorageIsNotOpenError({ name: this.name });
+		if (_classPrivateFieldGet2(_io, this).getWritable === void 0) throw new WritableStreamNotSupportedError({ name: this.name });
+		const output = await _classPrivateFieldGet2(_io, this).getWritable(c);
+		return parseOutput(WritableStreamSchema, output);
+	}
+	/**
+	* 他のストレージへの書き込み失敗を通知します。
+	*
+	* @param c 書き込み失敗通知コンテキストです。
+	* @param err 集約エラーです。
+	*/
+	async onOtherWriteError(c, err) {
+		if (!_classPrivateFieldGet2(_io, this).isOpen) throw new StorageIsNotOpenError({ name: this.name });
+		if (_classPrivateFieldGet2(_io, this).onOtherWriteError === void 0) return;
+		await _classPrivateFieldGet2(_io, this).onOtherWriteError(c, [{
+			errors: err.meta.errors.map((error) => ({
+				plugin: "storage",
+				reason: error.reason
+			})),
+			plugin: "storage"
+		}]);
+	}
+};
+_UniKvsStorage = UniKvsStorage;
+[_initProto] = _applyDecs(_UniKvsStorage, [], [
+	[
+		asyncmux,
+		2,
+		"open"
+	],
+	[
+		asyncmux,
+		2,
+		"close"
+	],
+	[
+		asyncmux,
+		2,
+		"retryClose"
+	]
+]).e;
+//#endregion
+//#region ../src/_unikvs-branch.ts
+/**
+* インスタンスと内部状態の対応表です。
+* コンパイラーによる `#` フィールドのダウンレベルと同様に、`WeakMap` をブランド兼ストレージとして使います。
+*/
+const branchStates = /* #__PURE__ */ new WeakMap();
+/**
+* 分岐先のスナップショットを返します。
+*
+* 親の `fork` で接頭辞付加するために使用します。
+* `new Branch()` で作成された分岐以外の値が渡されたときは例外を投げます。
+* 外部からは使用しません。
+*
+* @param branch スナップショットを取得する分岐です。
+*
+* @returns 分岐先のコピーを返します。
+*/
+function getBranchDestinationsForFork(branch) {
+	const state = branchStates.get(branch);
+	if (!state) throw new TypeError("fork() expects a branch created by new Branch().");
+	return state.destinations.map((dest) => ({
+		storage: dest.storage,
+		middlewares: [...dest.middlewares]
+	}));
+}
+/**
+* 分岐先を親の接頭辞付きで追加します。
+*
+* @param destinations 追加先の分岐先列です。
+* @param prefix 親のミドルウェア列です。
+* @param branch 追加する分岐です。
+*/
+function appendForkDestinations(destinations, prefix, branch) {
+	const prefixSnapshot = [...prefix];
+	for (const dest of getBranchDestinationsForFork(branch)) destinations.push({
+		storage: dest.storage,
+		middlewares: [...prefixSnapshot, ...dest.middlewares]
+	});
+}
+//#endregion
+//#region ../src/unikvs-branch.ts
+var _UniKvsBranch_brand = /* @__PURE__ */ new WeakSet();
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#builder)
+*/
+var UniKvsBranch = class {
+	constructor() {
+		_classPrivateMethodInitSpec(this, _UniKvsBranch_brand);
+		branchStates.set(this, {
+			middlewares: [],
+			destinations: []
+		});
+	}
+	fork(branch) {
+		const state = _assertClassBrand(_UniKvsBranch_brand, this, _branchState).call(this);
+		appendForkDestinations(state.destinations, state.middlewares, branch);
+		return this;
+	}
+	use(middleware) {
+		_assertClassBrand(_UniKvsBranch_brand, this, _branchState).call(this).middlewares.push(UniKvsMiddleware.from(middleware));
+		return this;
+	}
+	persist(storage) {
+		const state = _assertClassBrand(_UniKvsBranch_brand, this, _branchState).call(this);
+		state.destinations.push({
+			storage: UniKvsStorage.from(storage),
+			middlewares: [...state.middlewares]
+		});
+		return this;
+	}
+};
+/**
+* この分岐の構築状態を取得します。
+*
+* @returns 構築状態を返します。
+*/
+function _branchState() {
+	const state = branchStates.get(this);
+	if (state === void 0) throw new Error("分岐の構築状態が見つかりません。");
+	return state;
+}
+//#endregion
+//#region ../src/_contexts.ts
+/**
+* 実行時変数の初期値をエントリー列に正規化します。
+*
+* レコードは `Object.entries` で展開します。
+* 反復子はそのまま返します。
+*
+* @param vars 初期値です。
+*
+* @returns エントリー列を返します。
+*/
+function normalizeVariablesInit(vars) {
+	if (!vars) return [];
+	if (Symbol.iterator in vars) return vars;
+	return Object.entries(vars);
+}
+/**
+* 新しい空の変数ストアを作成します。
+*
+* @param vars 初期値です。
+*
+* @returns 空ストアを返します。
+*/
+function createVariablesStore(vars = []) {
+	return {
+		data: new Map(vars),
+		readonly: /* @__PURE__ */ new Set()
+	};
+}
+var _data = /* @__PURE__ */ new WeakMap();
+var _readonly = /* @__PURE__ */ new WeakMap();
+/**
+* 実行時変数を保持する基底コンテキストです。
+*/
+var PipelineContext = class {
+	/**
+	* コンテキストを作成します。
+	*
+	* @param init 初期値です。
+	*/
+	constructor(init) {
+		_classPrivateFieldInitSpec(this, _data, void 0);
+		_classPrivateFieldInitSpec(this, _readonly, void 0);
+		const { store } = init;
+		if (store) {
+			_classPrivateFieldSet2(_data, this, store.data);
+			_classPrivateFieldSet2(_readonly, this, store.readonly);
+		} else {
+			_classPrivateFieldSet2(_data, this, /* @__PURE__ */ new Map());
+			_classPrivateFieldSet2(_readonly, this, /* @__PURE__ */ new Set());
+		}
+		const vars = normalizeVariablesInit(init.vars);
+		for (const [name, value] of vars) _classPrivateFieldGet2(_data, this).set(name, value);
+	}
+	/**
+	* 変数の値を読み取ります。
+	*
+	* @param name 変数名です。
+	*
+	* @returns 変数の値を返します。
+	*/
+	get(name) {
+		return _classPrivateFieldGet2(_data, this).get(name);
+	}
+	/**
+	* 変数の値を書き込みます。
+	*
+	* @param name 変数名です。
+	* @param value 設定する値です。
+	*
+	* @returns 自身を返します。
+	*/
+	set(name, value) {
+		if (_classPrivateFieldGet2(_readonly, this).has(name)) throw new ReadonlyVariableError({ name });
+		_classPrivateFieldGet2(_data, this).set(name, value);
+		return this;
+	}
+	/**
+	* 変数の値を設定し、読み取り専用にします。
+	*
+	* @param name 変数名です。
+	* @param value 設定する値です。
+	*
+	* @returns 自身を返します。
+	*/
+	setReadonly(name, value) {
+		if (_classPrivateFieldGet2(_readonly, this).has(name)) throw new ReadonlyVariableError({ name });
+		_classPrivateFieldGet2(_data, this).set(name, value);
+		_classPrivateFieldGet2(_readonly, this).add(name);
+		return this;
+	}
+};
+var MapKeyContext = class extends PipelineContext {
+	/**
+	* コンテキストを作成します。
+	*
+	* @param init 初期値です。
+	*/
+	constructor(init) {
+		const { key, vars, store } = init;
+		super({
+			vars,
+			store
+		});
+		this.key = key;
+	}
+};
+var ActionContext = class extends PipelineContext {
+	/**
+	* コンテキストを作成します。
+	*
+	* @param init 初期値です。
+	*/
+	constructor(init) {
+		const { vars, store, action, signal } = init;
+		super({
+			vars,
+			store
+		});
+		this.action = action;
+		this.signal = signal;
+	}
+};
+var LifecycleContext = class extends ActionContext {};
+/**
+* 開始処理のコンテキストです。
+*/
+var OpenContext = class extends LifecycleContext {
+	/**
+	* コンテキストを作成します。
+	*
+	* @param init 初期値です。
+	*/
+	constructor(init) {
+		super({
+			...init,
+			action: "open"
+		});
+	}
+};
+/**
+* 終了処理のコンテキストです。
+*/
+var CloseContext = class extends LifecycleContext {
+	/**
+	* コンテキストを作成します。
+	*
+	* @param init 初期値です。
+	*/
+	constructor(init) {
+		super({
+			...init,
+			action: "close"
+		});
+	}
+};
+var KeyedActionContext = class extends ActionContext {
+	/**
+	* コンテキストを作成します。
+	*
+	* @param init 初期値です。
+	*/
+	constructor(init) {
+		const { key, ...superInit } = init;
+		super(superInit);
+		this.key = key;
+	}
+};
+/**
+* 書き込み処理のコンテキストです。
+*/
+var SetContext = class extends KeyedActionContext {
+	/**
+	* コンテキストを作成します。
+	*
+	* @param init 初期値です。
+	*/
+	constructor(init) {
+		super({
+			...init,
+			action: "set"
+		});
+	}
+};
+/**
+* 読み取り処理のコンテキストです。
+*/
+var GetContext = class extends KeyedActionContext {
+	/**
+	* コンテキストを作成します。
+	*
+	* @param init 初期値です。
+	*/
+	constructor(init) {
+		const { repair = {
+			enabled: false,
+			targets: []
+		}, ...superInit } = init;
+		super({
+			...superInit,
+			action: "get"
+		});
+		this.repair = repair;
+	}
+};
+/**
+* ストリーム処理のコンテキストです。
+*/
+var StreamContext = class extends KeyedActionContext {
+	/**
+	* コンテキストを作成します。
+	*
+	* @param init 初期値です。
+	*/
+	constructor(init) {
+		const { repair = {
+			enabled: false,
+			targets: []
+		}, ...superInit } = init;
+		super({
+			...superInit,
+			action: "stream"
+		});
+		this.repair = repair;
+	}
+};
+/**
+* 存在確認のコンテキストです。
+*/
+var HasContext = class extends KeyedActionContext {
+	/**
+	* コンテキストを作成します。
+	*
+	* @param init 初期値です。
+	*/
+	constructor(init) {
+		super({
+			...init,
+			action: "has"
+		});
+	}
+};
+/**
+* 削除処理のコンテキストです。
+*/
+var DeleteContext = class extends KeyedActionContext {
+	/**
+	* コンテキストを作成します。
+	*
+	* @param init 初期値です。
+	*/
+	constructor(init) {
+		super({
+			...init,
+			action: "delete"
+		});
+	}
+};
+/**
+* 全削除のコンテキストです。
+*/
+var ClearContext = class extends ActionContext {
+	/**
+	* コンテキストを作成します。
+	*
+	* @param init 初期値です。
+	*/
+	constructor(init) {
+		super({
+			...init,
+			action: "clear"
+		});
+	}
+};
+/**
+* 値変換の基底コンテキストです。
+*/
+var TransformContext = class extends KeyedActionContext {
+	/**
+	* コンテキストを作成します。
+	*
+	* @param init 初期値です。
+	*/
+	constructor(init) {
+		const { source, ...superInit } = init;
+		super(superInit);
+		this.source = source;
+	}
+};
+/**
+* データ変換の基底コンテキストです。
+*/
+var TransformDataContext = class extends TransformContext {};
+/**
+* 符号化のコンテキストです。
+*/
+var EncodeContext = class extends TransformDataContext {
+	/**
+	* コンテキストを作成します。
+	*
+	* @param init 初期値です。
+	*/
+	constructor(init) {
+		super({
+			...init,
+			action: "set"
+		});
+	}
+};
+/**
+* 復号のコンテキストです。
+*/
+var DecodeContext = class extends TransformDataContext {
+	/**
+	* コンテキストを作成します。
+	*
+	* @param init 初期値です。
+	*/
+	constructor(init) {
+		super({
+			...init,
+			action: "get"
+		});
+	}
+};
+/**
+* ストリーム変換の基底コンテキストです。
+*/
+var TransformStreamContext = class extends TransformContext {};
+/**
+* ストリーム符号化のコンテキストです。
+*/
+var EncodeStreamContext = class extends TransformStreamContext {
+	/**
+	* コンテキストを作成します。
+	*
+	* @param init 初期値です。
+	*/
+	constructor(init) {
+		super({
+			...init,
+			action: "set"
+		});
+	}
+};
+/**
+* ストリーム復号のコンテキストです。
+*/
+var DecodeStreamContext = class extends TransformStreamContext {
+	/**
+	* コンテキストを作成します。
+	*
+	* @param init 初期値です。
+	*/
+	constructor(init) {
+		super({
+			...init,
+			action: "stream"
+		});
+	}
+};
+//#endregion
+//#region ../src/_logger.ts
+const logger = getLogger("unikvs");
+const repairLogger = getLogger(["@unikvs/*", "@unikvs/allow-repair"]);
+//#endregion
+//#region ../src/_pipeline-graph.helpers.ts
+/**
+* 対象判定に通る葉だけを登録順に絞ります。
+*
+* 全葉が対象なら複製せず `node.allLeaves` を返します。
+*
+* @param node 対象の節です。
+* @param isActive 書き込み対象とする葉を判定します。
+*
+* @returns 対象の葉を登録順に返します。
+*/
+function activeLeavesOf(node, isActive) {
+	const active = node.allLeaves.filter(isActive);
+	if (active.length === node.allLeaves.length) return node.allLeaves;
+	return active;
+}
+/**
+* 葉と節を登録順に並べた静的な項目列を作成します。
+*
+* 各操作の走査はこの並びをそのまま読みます。
+* 並べ替え用の順序は項目に保持せず、作成時のローカル変数で解決します。
+*
+* @param leaves この節で終端する葉です。
+* @param children 子の節です。
+*
+* @returns 登録順に並べた項目列を返します。
+*/
+function createEntries(leaves, children) {
+	return [...leaves.map((leaf) => ({
+		entry: {
+			kind: "leaf",
+			leaf
+		},
+		order: leaf.index
+	})), ...children.map((child) => {
+		const [firstLeaf] = child.allLeaves;
+		if (firstLeaf === void 0) throw new Error("子節に葉が存在しません。");
+		return {
+			entry: {
+				kind: "node",
+				node: child
+			},
+			order: firstLeaf.index
+		};
+	})].toSorted((a, b) => a.order - b.order).map((item) => item.entry);
+}
+/**
+* 変換後のデータが設定されていることを検証し、変換後のデータを返します。
+*
+* ミドルウェアが `destination` を設定しなかったときに投げます。
+*
+* @param middleware 対象のミドルウェアです。
+* @param ctx 検証するコンテキストです。
+* @param operation エラーに付与する操作名です。
+*
+* @returns 変換後のデータを返します。
+*/
+function requireDestination(middleware, ctx, operation) {
+	if ("destination" in ctx) return ctx.destination;
+	throw new MiddlewareDestinationMissingError({
+		name: middleware.name,
+		operation
+	});
+}
+/**
+* 変換後のストリームが設定されていることを検証し、型を検証したストリームを返します。
+*
+* ミドルウェアが `destination` を設定しなかったときに投げます。
+* ストリームの場合は存在確認に加えて `ReadableStream` の型も検証します。
+*
+* @param middleware 対象のミドルウェアです。
+* @param ctx 検証するコンテキストです。
+* @param operation エラーに付与する操作名です。
+*
+* @returns 変換後のストリームを返します。
+*/
+function requireStreamDestination(middleware, ctx, operation) {
+	const destination = requireDestination(middleware, ctx, operation);
+	return parseOutput(ReadableStreamSchema, destination);
+}
+/**
+* コンテキストの `destination` を凍結します。
+*
+* パイプラインの `next` から同期的に呼び出します。
+* 凍結後の読み取りはできますが、書き込むと `MiddlewareDestinationFrozenError` を投げます。
+*
+* @param ctx 凍結するコンテキストです。
+*/
+function freezeDestination(ctx) {
+	const { destination } = ctx;
+	Object.defineProperty(ctx, "destination", {
+		get() {
+			return destination;
+		},
+		set() {
+			throw new MiddlewareDestinationFrozenError({
+				key: ctx.key,
+				action: ctx.action
+			});
+		},
+		enumerable: true,
+		configurable: true
+	});
+}
+/**
+* 単一ミドルウェアの `mapKey` を実行します。
+*
+* 共有ストアを参照するため、カスタム変数の下流変更が写像にも見えます。
+*
+* @param middleware 対象のミドルウェアです。
+* @param key 写像前のキーです。
+* @param scope 操作共通の実行時情報です。
+*
+* @returns 写像後のキーを返します。
+*/
+function applyMapKey(middleware, key, scope) {
+	const c = new MapKeyContext({
+		key,
+		store: scope.store
+	});
+	return middleware.mapKey(c);
+}
+//#endregion
+//#region ../src/_pipeline-leaf-resolver.ts
+var _rootKey = /* @__PURE__ */ new WeakMap();
+var _scope = /* @__PURE__ */ new WeakMap();
+var _nodeCache = /* @__PURE__ */ new WeakMap();
+/**
+* 単一操作のスコープで葉の写像キーを解決します。
+*
+* 新 `mapKey` は同期的であり、中断シグナルも受け付けないため、共有節の写像は操作内で 1 回だけ実行され、結果を使い回します。
+* 並行解決でも `Map` キャッシュにより重複しません (`resolve` 自体が同期的であるため、競合しません)。
+*/
+var LeafResolver = class {
+	/**
+	* 通常は `PipelineGraph.createResolver` から生成します。
+	*
+	* @param scope 操作共通の実行時情報です。
+	*/
+	constructor(scope) {
+		_classPrivateFieldInitSpec(this, _rootKey, void 0);
+		_classPrivateFieldInitSpec(this, _scope, void 0);
+		_classPrivateFieldInitSpec(this, _nodeCache, void 0);
+		_classPrivateFieldSet2(_rootKey, this, scope.key);
+		_classPrivateFieldSet2(_scope, this, scope);
+		_classPrivateFieldSet2(_nodeCache, this, /* @__PURE__ */ new Map());
+	}
+	/**
+	* 葉の写像キーを解決します。
+	*
+	* @param leaf 解決する葉です。
+	*
+	* @returns 解決済みの葉を返します。
+	*/
+	resolve(leaf) {
+		let key = _classPrivateFieldGet2(_rootKey, this);
+		for (const node of leaf.path) {
+			const cached = _classPrivateFieldGet2(_nodeCache, this).get(node);
+			if (cached !== void 0) {
+				key = cached;
+				continue;
+			}
+			const mapped = applyMapKey(node.middleware, key, _classPrivateFieldGet2(_scope, this));
+			_classPrivateFieldGet2(_nodeCache, this).set(node, mapped);
+			key = mapped;
+		}
+		return {
+			key,
+			leaf
+		};
+	}
+};
+//#endregion
+//#region ../src/_pipeline-graph.ts
+let _Symbol$iterator;
+/**
+* 節を前順で列挙するための再帰ヘルパーです。
+*
+* @param node 列挙を開始する節です。
+*
+* @yields 前順の節です。
+*/
+function* visit(node) {
+	yield node;
+	for (const entry of node.entries) if (entry.kind === "node") yield* visit(entry.node);
+}
+/**
+* 直通区間をまとめて葉名簿と全葉を確定します。
+*
+* @param node 確定する節です。
+*/
+function finalize(node) {
+	if (node.leaves.length === 0 && node.children.length === 1) {
+		const [child] = node.children;
+		if (child === void 0) throw new Error("直通区間の子節が存在しません。");
+		finalize(child);
+		node.entries = [{
+			kind: "node",
+			node: child
+		}];
+		node.allLeaves = child.allLeaves;
+		node.leafNames = child.leafNames;
+	} else {
+		const leaves = [...node.leaves];
+		for (const child of node.children) {
+			finalize(child);
+			leaves.push(...child.allLeaves);
+		}
+		leaves.sort((a, b) => a.index - b.index);
+		const [singleLeaf] = leaves;
+		node.entries = createEntries(node.leaves, node.children);
+		node.allLeaves = leaves;
+		if (leaves.length === 1 && singleLeaf !== void 0) node.leafNames = singleLeaf.nameNames;
+		else node.leafNames = Object.freeze(leaves.map((leaf) => leaf.name));
+	}
+}
+var _leaves = /* @__PURE__ */ new WeakMap();
+var _entries$1 = /* @__PURE__ */ new WeakMap();
+var _middlewares$1 = /* @__PURE__ */ new WeakMap();
+var _isSingleLeaf = /* @__PURE__ */ new WeakMap();
+_Symbol$iterator = Symbol.iterator;
+/**
+* コンパイル済みのパイプライン・グラフです。
+*
+* 宛先の変換チェーンをミドルウェアのインスタンス同一性で共有する根付き木として保持し、操作ごとの走査・エンコード・書き戻し・ストリーム構築を提供します。
+*
+* 不変条件 :
+* - 葉（`leaves`）と各節の項目（`entries`）は宛先の登録順です。
+* - 名簿（`leafNames` / `nameNames`）は凍結された配列で、直通区間では参照を共有します。
+* - 共有節は 1 操作内で 1 回だけ `encode`/`encodeStream`/`mapKey` を実行します。分岐点ではプレーン値のエンコード結果を共有し、ストリームは tee で分岐します。
+* - 書き戻しの拒否は、走査中と書き込み中の 2 経路で分類します。いずれも即時に確定します。
+*/
+var PipelineGraph = class PipelineGraph {
+	constructor(leaves, entries, middlewares) {
+		_classPrivateFieldInitSpec(this, _leaves, void 0);
+		_classPrivateFieldInitSpec(this, _entries$1, void 0);
+		_classPrivateFieldInitSpec(this, _middlewares$1, void 0);
+		_classPrivateFieldInitSpec(this, _isSingleLeaf, void 0);
+		_classPrivateFieldSet2(_leaves, this, leaves);
+		_classPrivateFieldSet2(_entries$1, this, entries);
+		_classPrivateFieldSet2(_middlewares$1, this, middlewares);
+		_classPrivateFieldSet2(_isSingleLeaf, this, leaves.length === 1);
+	}
+	/**
+	* 宛先定義の列を trie にコンパイルします。
+	*
+	* ミドルウェアはインスタンス同一性で共有します。同一インスタンスが複数の節に現れても、`open`/`close`/`use` の対象には初出の 1 件だけを保持します。
+	*
+	* @param destinations コンパイルする宛先定義です。
+	*
+	* @returns コンパイル済みのパイプライン・グラフを返します。
+	*/
+	static compile(destinations) {
+		const rootLeaves = [];
+		const rootChildren = [];
+		const allLeaves = [];
+		const middlewares = [];
+		const seenMiddlewares = /* @__PURE__ */ new Set();
+		for (const dest of destinations) {
+			const index = allLeaves.length;
+			const name = dest.storage.name;
+			const path = [];
+			let parent = null;
+			let canRepair = false;
+			let siblings = rootChildren;
+			for (const middleware of dest.middlewares) {
+				let node = siblings.find((candidate) => candidate.middleware === middleware);
+				if (node === void 0) {
+					node = {
+						leaves: [],
+						entries: [],
+						children: [],
+						allLeaves: [],
+						leafNames: [],
+						middleware
+					};
+					siblings.push(node);
+					if (!seenMiddlewares.has(middleware)) {
+						seenMiddlewares.add(middleware);
+						middlewares.push(middleware);
+					}
+				}
+				if (middleware.name === "AllowRepair") canRepair = true;
+				path.push(node);
+				parent = node;
+				siblings = node.children;
+			}
+			const leaf = {
+				name,
+				path,
+				index,
+				storage: dest.storage,
+				canRepair,
+				nameNames: Object.freeze([name])
+			};
+			if (parent === null) rootLeaves.push(leaf);
+			else parent.leaves.push(leaf);
+			allLeaves.push(leaf);
+		}
+		for (const child of rootChildren) finalize(child);
+		let rootEntries;
+		let rootAllLeaves;
+		if (rootLeaves.length === 0 && rootChildren.length === 1) {
+			const [child] = rootChildren;
+			if (child === void 0) throw new Error("根直下の子節が存在しません。");
+			rootEntries = [{
+				kind: "node",
+				node: child
+			}];
+			rootAllLeaves = child.allLeaves;
+		} else {
+			const collected = [...rootLeaves];
+			for (const child of rootChildren) collected.push(...child.allLeaves);
+			rootEntries = createEntries(rootLeaves, rootChildren);
+			rootAllLeaves = collected.toSorted((a, b) => a.index - b.index);
+		}
+		return new PipelineGraph(rootAllLeaves, rootEntries, middlewares);
+	}
+	/**
+	* 全葉です。登録順に保持します。
+	*/
+	get leaves() {
+		return _classPrivateFieldGet2(_leaves, this);
+	}
+	/**
+	* `open`/`close`/`use` の対象となるミドルウェアです。
+	* 初出順・重複なしです。
+	*/
+	get middlewares() {
+		return _classPrivateFieldGet2(_middlewares$1, this);
+	}
+	/**
+	* 全葉数が 1 件かどうかです。
+	*/
+	get isSingleLeaf() {
+		return _classPrivateFieldGet2(_isSingleLeaf, this);
+	}
+	/**
+	* 葉数です。
+	*/
+	get size() {
+		return _classPrivateFieldGet2(_leaves, this).length;
+	}
+	/**
+	* 葉を登録順に列挙します。
+	*/
+	[_Symbol$iterator]() {
+		return _classPrivateFieldGet2(_leaves, this)[Symbol.iterator]();
+	}
+	/**
+	* 節を根から前順 (親が子より前、兄弟は登録順) に列挙します。
+	*
+	* 構造の確認・保守用です。操作の走査には使用しません。
+	*
+	* @yields 前順の節です。
+	*/
+	*nodes() {
+		for (const entry of _classPrivateFieldGet2(_entries$1, this)) if (entry.kind === "node") yield* visit(entry.node);
+	}
+	/**
+	* 単一操作のスコープでキー写像をメモ化するリゾルバーを生成します。
+	*
+	* 新 `mapKey` は同期的であるため、リゾルバーも同期的です。共有節の写像は操作内で 1 回だけ実行されます。
+	*
+	* @param key 根のキー (論理キー) です。
+	* @param vars 根の実行時変数です。
+	*
+	* @returns 葉リゾルバーを返します。
+	*/
+	createResolver(scope) {
+		return new LeafResolver(scope);
+	}
+	/**
+	* 葉の経路のミドルウェアを逆順に適用してデータをデコードします。
+	*
+	* 各段の前後で中断を確認します。
+	*
+	* @param leaf デコード元の葉です。
+	* @param scope 操作共通の実行時情報です。`key` は論理キーです。
+	* @param data デコードするデータです。
+	*
+	* @returns デコード済みのデータを返します。
+	*/
+	async decode(leaf, scope, data) {
+		const reversed = leaf.path.toReversed();
+		async function run(index, input) {
+			const maybeNode = reversed[index];
+			if (maybeNode === void 0) return input;
+			const node = maybeNode;
+			const ctx = new DecodeContext({
+				key: scope.key,
+				store: scope.store,
+				signal: scope.signal,
+				source: input
+			});
+			let downstreamResult;
+			let hasDownstream = false;
+			let nextCalled = false;
+			let nextSettled = false;
+			function next() {
+				if (nextCalled) return Promise.reject(new MiddlewareNextCalledMultipleTimesError({
+					name: node.middleware.name,
+					operation: "decode"
+				}));
+				nextCalled = true;
+				let decoded;
+				try {
+					decoded = requireDestination(node.middleware, ctx, "decode");
+					freezeDestination(ctx);
+				} catch (ex) {
+					return Promise.reject(ex);
+				}
+				return Promise.try(async () => {
+					try {
+						downstreamResult = await run(index + 1, decoded);
+						hasDownstream = true;
+					} finally {
+						nextSettled = true;
+					}
+				});
+			}
+			await node.middleware.decode(ctx, next);
+			scope.signal.throwIfAborted();
+			if (!nextCalled) throw new MiddlewareNextNotCalledError({
+				name: node.middleware.name,
+				operation: "decode"
+			});
+			if (!nextSettled) throw new MiddlewareNextNotAwaitedError({
+				name: node.middleware.name,
+				operation: "decode"
+			});
+			const destination = requireDestination(node.middleware, ctx, "decode");
+			if (hasDownstream) return downstreamResult;
+			return destination;
+		}
+		return run(0, data);
+	}
+	/**
+	* 葉の経路のミドルウェアを逆順に `pipeThrough` してストリームをデコードします。
+	*
+	* @param leaf デコード元の葉です。
+	* @param scope 操作共通の実行時情報です。`key` は論理キーです。
+	* @param source 入力ストリームです。
+	*
+	* @returns デコード済みのストリームを返します。
+	*/
+	async decodeStream(leaf, scope, source) {
+		const pipes = [];
+		try {
+			const reversed = leaf.path.toReversed();
+			async function run(index, input) {
+				const maybeNode = reversed[index];
+				if (maybeNode === void 0) return input;
+				const node = maybeNode;
+				const ctx = new DecodeStreamContext({
+					key: scope.key,
+					store: scope.store,
+					signal: scope.signal,
+					source: input
+				});
+				let downstreamResult;
+				let nextCalled = false;
+				let nextSettled = false;
+				function next() {
+					if (nextCalled) return Promise.reject(new MiddlewareNextCalledMultipleTimesError({
+						name: node.middleware.name,
+						operation: "decode"
+					}));
+					nextCalled = true;
+					let decoded;
+					try {
+						decoded = requireStreamDestination(node.middleware, ctx, "decode");
+						freezeDestination(ctx);
+					} catch (ex) {
+						return Promise.reject(ex);
+					}
+					return Promise.try(async () => {
+						try {
+							downstreamResult = await run(index + 1, decoded);
+						} finally {
+							nextSettled = true;
+						}
+					});
+				}
+				try {
+					await node.middleware.decodeStream(ctx, next);
+					scope.signal.throwIfAborted();
+					if (!nextCalled) throw new MiddlewareNextNotCalledError({
+						name: node.middleware.name,
+						operation: "decode"
+					});
+					if (!nextSettled) throw new MiddlewareNextNotAwaitedError({
+						name: node.middleware.name,
+						operation: "decode"
+					});
+					const output = requireStreamDestination(node.middleware, ctx, "decode");
+					pipes.push(output);
+					if (downstreamResult !== void 0) return downstreamResult;
+					return output;
+				} catch (ex) {
+					if (ctx.destination !== void 0) pipes.push(ctx.destination);
+					throw ex;
+				}
+			}
+			return await run(0, source);
+		} catch (ex) {
+			await cancelStreams(pipes, ex);
+			throw ex;
+		}
+	}
+	/**
+	* 共有節を 1 回だけ実行しながら、全葉向けのプレーン値をエンコードします。
+	*
+	* エンコード中の失敗は生の例外として投げます。
+	*
+	* @param scope 操作共通の実行時情報です。`key` は論理キーです。
+	* @param data エンコードするデータです。
+	*
+	* @returns 登録順のエンコード結果を返します。
+	*/
+	async encode(scope, data) {
+		const targets = [];
+		async function walk(node, input, parentKey) {
+			scope.signal.throwIfAborted();
+			const ctx = new EncodeContext({
+				key: scope.key,
+				store: scope.store,
+				signal: scope.signal,
+				source: input
+			});
+			let nodeKey = parentKey;
+			let nextCalled = false;
+			let nextSettled = false;
+			function next() {
+				if (nextCalled) return Promise.reject(new MiddlewareNextCalledMultipleTimesError({
+					name: node.middleware.name,
+					operation: "encode"
+				}));
+				nextCalled = true;
+				let encoded;
+				try {
+					encoded = requireDestination(node.middleware, ctx, "encode");
+					freezeDestination(ctx);
+				} catch (ex) {
+					return Promise.reject(ex);
+				}
+				return Promise.try(async () => {
+					try {
+						nodeKey = applyMapKey(node.middleware, parentKey, scope);
+						for (const entry of node.entries) if (entry.kind === "node") await walk(entry.node, encoded, nodeKey);
+						else targets.push({
+							key: nodeKey,
+							data: encoded,
+							leaf: entry.leaf
+						});
+					} finally {
+						nextSettled = true;
+					}
+				});
+			}
+			await node.middleware.encode(ctx, next);
+			scope.signal.throwIfAborted();
+			if (!nextCalled) throw new MiddlewareNextNotCalledError({
+				name: node.middleware.name,
+				operation: "encode"
+			});
+			if (!nextSettled) throw new MiddlewareNextNotAwaitedError({
+				name: node.middleware.name,
+				operation: "encode"
+			});
+		}
+		for (const entry of _classPrivateFieldGet2(_entries$1, this)) if (entry.kind === "node") await walk(entry.node, data, scope.key);
+		else targets.push({
+			key: scope.key,
+			data,
+			leaf: entry.leaf
+		});
+		targets.sort((a, b) => a.leaf.index - b.leaf.index);
+		return targets;
+	}
+	/**
+	* 書き戻し対象の葉へ、共有節を 1 回だけ実行しながら再エンコードして書き込みます。
+	*
+	* 葉への書き込みは並列に開始し、対象単位の拒否は記録だけして他の対象の開始を止めません。
+	* 走査中に確定した拒否は即座に投げます。書き込み中に判明した拒否も、応答のない他の書き込みを待たずに確定させます。
+	* 拒否がなければ全タスクの終了を待ちます。
+	*
+	* @param scope 操作共通の実行時情報です。`key` は論理キーです。
+	* @param targets 書き戻し対象の葉です。登録順に渡します。
+	* @param throwOnRepairDenied 書き戻し拒否をエラーとして投げるかどうかです。
+	* @param data デコード済みの原データです。
+	* @param write 葉への書き込み処理です。
+	*/
+	async repair(scope, targets, throwOnRepairDenied, data, write) {
+		if (targets.length === 0) return;
+		const targetSet = new Set(targets);
+		const isTarget = (leaf) => targetSet.has(leaf);
+		const writeTasks = [];
+		let traversalDenial = null;
+		const writeDenials = [];
+		const writeDenialSignal = Promise.withResolvers();
+		const writeLeaf = (leaf, input, writeKey) => {
+			writeTasks.push((async () => {
+				try {
+					await write(leaf, writeKey, input);
+				} catch (ex) {
+					if (scope.signal.aborted) return;
+					if (ex instanceof RepairNotAllowedError) {
+						repairLogger.warn`Failed to repair a storage: ${ex}`;
+						if (throwOnRepairDenied) {
+							writeDenials.push(new RepairNotAllowedError({
+								cause: ex,
+								names: [leaf.name]
+							}));
+							writeDenialSignal.resolve();
+						}
+						return;
+					}
+					logger.error`Failed to repair a storage: ${ex}`;
+				}
+			})());
+		};
+		const recordTraversalDenial = (denied) => {
+			traversalDenial ?? (traversalDenial = denied);
+		};
+		const skipDenied = (leaf) => {
+			if (scope.signal.aborted) return;
+			repairLogger.warn`Skipped repair for a storage without AllowRepair: ${leaf.name}`;
+			if (throwOnRepairDenied) recordTraversalDenial(new RepairNotAllowedError({ names: [leaf.name] }));
+		};
+		const walk = async (node, input, parentKey) => {
+			const activeLeaves = activeLeavesOf(node, isTarget);
+			const [firstLeaf] = activeLeaves;
+			if (firstLeaf === void 0) return;
+			const shared = activeLeaves.length >= 2;
+			if (!(shared || firstLeaf.canRepair)) {
+				scope.signal.throwIfAborted();
+				for (const entry of node.entries) if (entry.kind === "node") await walk(entry.node, input, parentKey);
+				else {
+					if (!isTarget(entry.leaf)) continue;
+					if (!entry.leaf.canRepair) {
+						skipDenied(entry.leaf);
+						continue;
+					}
+					writeLeaf(entry.leaf, input, parentKey);
+				}
+				return;
+			}
+			scope.signal.throwIfAborted();
+			const ctx = new EncodeContext({
+				key: scope.key,
+				store: scope.store,
+				signal: scope.signal,
+				source: input
+			});
+			let nodeKey = parentKey;
+			let nextCalled = false;
+			let nextSettled = false;
+			let downstreamStarted = false;
+			function next() {
+				if (nextCalled) return Promise.reject(new MiddlewareNextCalledMultipleTimesError({
+					name: node.middleware.name,
+					operation: "encode"
+				}));
+				nextCalled = true;
+				let encoded;
+				try {
+					encoded = requireDestination(node.middleware, ctx, "encode");
+					freezeDestination(ctx);
+				} catch (ex) {
+					return Promise.reject(ex);
+				}
+				return Promise.try(async () => {
+					try {
+						nodeKey = applyMapKey(node.middleware, parentKey, scope);
+						scope.signal.throwIfAborted();
+						downstreamStarted = true;
+						for (const entry of node.entries) if (entry.kind === "node") await walk(entry.node, encoded, nodeKey);
+						else {
+							if (!isTarget(entry.leaf)) continue;
+							if (!entry.leaf.canRepair) {
+								skipDenied(entry.leaf);
+								continue;
+							}
+							writeLeaf(entry.leaf, encoded, nodeKey);
+						}
+					} finally {
+						nextSettled = true;
+					}
+				});
+			}
+			try {
+				await node.middleware.encode(ctx, next);
+				scope.signal.throwIfAborted();
+				if (!nextCalled) throw new MiddlewareNextNotCalledError({
+					name: node.middleware.name,
+					operation: "encode"
+				});
+				if (!nextSettled) throw new MiddlewareNextNotAwaitedError({
+					name: node.middleware.name,
+					operation: "encode"
+				});
+			} catch (ex) {
+				if (scope.signal.aborted) {
+					if (shared) throw ex;
+					return;
+				}
+				if (ex instanceof MiddlewareNextNotCalledError || ex instanceof MiddlewareNextNotAwaitedError || ex instanceof MiddlewareNextCalledMultipleTimesError || ex instanceof MiddlewareDestinationMissingError || ex instanceof MiddlewareDestinationFrozenError) throw ex;
+				if (downstreamStarted) {
+					if (ex instanceof RepairNotAllowedError) {
+						if (throwOnRepairDenied) throw ex;
+						repairLogger.warn`Failed to repair a storage: ${ex}`;
+						return;
+					}
+					logger.error`Failed to repair a storage: ${ex}`;
+					return;
+				}
+				if (ex instanceof RepairNotAllowedError) {
+					repairLogger.warn`Failed to repair a storage: ${ex}`;
+					if (throwOnRepairDenied) {
+						const denied = new RepairNotAllowedError({
+							cause: ex,
+							names: activeLeaves.map((leaf) => leaf.name)
+						});
+						if (shared) throw denied;
+						recordTraversalDenial(denied);
+					}
+				} else logger.error`Failed to repair a storage: ${ex}`;
+			}
+		};
+		for (const entry of _classPrivateFieldGet2(_entries$1, this)) if (entry.kind === "node") await walk(entry.node, data, scope.key);
+		else {
+			if (!isTarget(entry.leaf)) continue;
+			if (!entry.leaf.canRepair) {
+				skipDenied(entry.leaf);
+				continue;
+			}
+			writeLeaf(entry.leaf, data, scope.key);
+		}
+		if (traversalDenial !== null) throw traversalDenial;
+		await Promise.race([Promise.allSettled(writeTasks), writeDenialSignal.promise]);
+		const [firstDenial] = writeDenials;
+		if (firstDenial !== void 0) throw firstDenial;
+	}
+	/**
+	* 共有節を 1 回だけ実行しながらストリームエンコード木を構築します。
+	*
+	* 新 Middleware の `encodeStream` は `c.source.pipeThrough(...)` で変換し `c.destination` に設定します。
+	* 共有節の実行は 1 回だけであり、分岐点では tee で入力を分けます。
+	* 計画段階の失敗は何も構築せずに伝播するため、呼び出し側が `streams` のソースをキャンセルします。
+	* tee とパイプの構築後の失敗は、`streams` に収集したストリーム (分割した読み取り側を含む) を内部でキャンセルしてから伝播します。
+	* 呼び出し側はどちらの失敗でも `streams` をキャンセルできます。
+	*
+	* @param scope 操作共通の実行時情報です。`key` は論理キーです。
+	* @param source 入力ストリームです。
+	* @param streams 構築したストリームを収集する集合です。呼び出し側がソースを事前に追加します。
+	* @param options 構築オプションです。
+	*
+	* @returns 構築結果を返します。
+	*/
+	async buildEncodeTree(scope, source, streams, options = {}) {
+		const { isActive, onNodeError } = options;
+		const targets = [];
+		let readStream = source;
+		const walk = async (node, input, parentKey) => {
+			const activeLeaves = isActive === void 0 ? node.allLeaves : activeLeavesOf(node, isActive);
+			if (activeLeaves.length === 0) return null;
+			scope.signal.throwIfAborted();
+			const ctx = new EncodeStreamContext({
+				key: scope.key,
+				store: scope.store,
+				signal: scope.signal,
+				source: input
+			});
+			let nodeKey = parentKey;
+			let output;
+			let nextCalled = false;
+			let nextSettled = false;
+			let downstreamStarted = false;
+			let downstreamError;
+			let hasDownstreamError = false;
+			let emptyBranches = false;
+			function next() {
+				if (nextCalled) return Promise.reject(new MiddlewareNextCalledMultipleTimesError({
+					name: node.middleware.name,
+					operation: "encode"
+				}));
+				nextCalled = true;
+				let encoded;
+				try {
+					encoded = requireStreamDestination(node.middleware, ctx, "encode");
+					freezeDestination(ctx);
+				} catch (ex) {
+					return Promise.reject(ex);
+				}
+				return Promise.try(async () => {
+					try {
+						output = encoded;
+						streams.add(output);
+						nodeKey = applyMapKey(node.middleware, parentKey, scope);
+						scope.signal.throwIfAborted();
+						downstreamStarted = true;
+						const branchEntries = node.entries.filter((entry) => {
+							if (entry.kind === "leaf") return isActive === void 0 || isActive(entry.leaf);
+							const leaves = entry.node.allLeaves;
+							return isActive === void 0 || leaves.some(isActive);
+						});
+						if (branchEntries.length === 0) {
+							emptyBranches = true;
+							return;
+						}
+						const assigned = [];
+						let current = output;
+						for (let i = 0; i < branchEntries.length; i++) if (i < branchEntries.length - 1) {
+							const [branch, rest] = current.tee();
+							streams.add(branch);
+							streams.add(rest);
+							assigned.push(branch);
+							current = rest;
+						} else assigned.push(current);
+						for (let i = 0; i < branchEntries.length; i++) {
+							const entry = branchEntries[i];
+							const stream = assigned[i];
+							if (entry === void 0 || stream === void 0) throw new Error("分岐の項目またはストリームが存在しません。");
+							if (entry.kind === "leaf") targets.push({
+								key: nodeKey,
+								leaf: entry.leaf,
+								stream
+							});
+							else if (await walk(entry.node, stream, nodeKey) === null) Promise.try(() => stream.cancel(/* @__PURE__ */ new Error("Skipped branch"))).catch(() => {});
+						}
+					} catch (ex) {
+						downstreamError = ex;
+						hasDownstreamError = true;
+						throw ex;
+					} finally {
+						nextSettled = true;
+					}
+				});
+			}
+			try {
+				await node.middleware.encodeStream(ctx, next);
+				scope.signal.throwIfAborted();
+				if (!nextCalled) throw new MiddlewareNextNotCalledError({
+					name: node.middleware.name,
+					operation: "encode"
+				});
+				if (!nextSettled) throw new MiddlewareNextNotAwaitedError({
+					name: node.middleware.name,
+					operation: "encode"
+				});
+			} catch (ex) {
+				if (ctx.destination !== void 0) streams.add(ctx.destination);
+				if (scope.signal.aborted) throw ex;
+				if (ex instanceof MiddlewareNextNotCalledError || ex instanceof MiddlewareNextNotAwaitedError || ex instanceof MiddlewareNextCalledMultipleTimesError || ex instanceof MiddlewareDestinationMissingError || ex instanceof MiddlewareDestinationFrozenError) throw ex;
+				if (downstreamStarted) {
+					if (hasDownstreamError && ex === downstreamError) throw ex;
+					if (onNodeError !== void 0) {
+						if (ex instanceof RepairNotAllowedError) {
+							if (onNodeError(ex, activeLeaves)) return output === void 0 ? null : {
+								key: nodeKey,
+								output
+							};
+						}
+						logger.error`Failed to repair a storage: ${ex}`;
+						return output === void 0 ? null : {
+							key: nodeKey,
+							output
+						};
+					}
+					throw ex;
+				}
+				if (onNodeError !== void 0 && onNodeError(ex, activeLeaves)) {
+					const abandoned = output ?? ctx.destination;
+					if (abandoned !== void 0) Promise.try(() => abandoned.cancel(ex)).catch(() => {});
+					return null;
+				}
+				throw ex;
+			}
+			if (emptyBranches || output === void 0) return null;
+			return {
+				key: nodeKey,
+				output
+			};
+		};
+		try {
+			let rootInput = source;
+			if (options.splitRead === true) {
+				const [repairInput, read] = source.tee();
+				streams.add(repairInput);
+				streams.add(read);
+				rootInput = repairInput;
+				readStream = read;
+			}
+			if (_classPrivateFieldGet2(_leaves, this).filter((leaf) => isActive === void 0 || isActive(leaf)).length === 0 && _classPrivateFieldGet2(_entries$1, this).length === 0) return {
+				targets,
+				readStream
+			};
+			const rootBranchEntries = _classPrivateFieldGet2(_entries$1, this).filter((entry) => {
+				if (entry.kind === "leaf") return isActive === void 0 || isActive(entry.leaf);
+				return isActive === void 0 || entry.node.allLeaves.some(isActive);
+			});
+			if (rootBranchEntries.length > 0) {
+				const assigned = [];
+				let current = rootInput;
+				for (let i = 0; i < rootBranchEntries.length; i++) if (i < rootBranchEntries.length - 1) {
+					const [branch, rest] = current.tee();
+					streams.add(branch);
+					streams.add(rest);
+					assigned.push(branch);
+					current = rest;
+				} else assigned.push(current);
+				for (let i = 0; i < rootBranchEntries.length; i++) {
+					const entry = rootBranchEntries[i];
+					const stream = assigned[i];
+					if (entry === void 0 || stream === void 0) throw new Error("分岐の項目またはストリームが存在しません。");
+					if (entry.kind === "leaf") {
+						if (isActive === void 0 || isActive(entry.leaf)) targets.push({
+							key: scope.key,
+							leaf: entry.leaf,
+							stream
+						});
+					} else try {
+						if (await walk(entry.node, stream, scope.key) === null) Promise.try(() => stream.cancel(/* @__PURE__ */ new Error("Skipped branch"))).catch(() => {});
+					} catch (ex) {
+						if (onNodeError) {
+							if (onNodeError(ex, entry.node.allLeaves.filter((leaf) => isActive === void 0 || isActive(leaf)))) {
+								Promise.try(() => stream.cancel(ex)).catch(() => {});
+								continue;
+							}
+						}
+						throw ex;
+					}
+				}
+			}
+		} catch (ex) {
+			await cancelStreams(streams, ex);
+			throw ex;
+		}
+		targets.sort((a, b) => a.leaf.index - b.leaf.index);
+		return {
+			targets,
+			readStream
+		};
+	}
+};
+//#endregion
+//#region ../src/_unikvs.schemas.ts
+const VariablesKeySchema = string();
+const VariablesInitSchema = pipe(union([custom((input) => typeof input === "object" && input !== null && Symbol.iterator in input, "Expected a Iterable object"), record(VariablesKeySchema, unknown())]), transform((input) => {
+	if (Symbol.iterator in input) return [...input];
+	return Object.entries(input);
+}));
+const VariablesArgsSchema = tuple([VariablesInitSchema]);
+const OpenOptionsSchema = object({
+	/**
+	* 処理の中断を通知するためのシグナルです。
+	*/
+	signal: optional(instance(AbortSignal)),
+	/**
+	* 実行時の変数です。
+	*/
+	vars: optional(VariablesInitSchema)
+});
+const OpenArgsSchema = tuple([optional(OpenOptionsSchema)]);
+const CloseOptionsSchema = object({
+	/**
+	* 処理の中断を通知するためのシグナルです。
+	*/
+	signal: optional(instance(AbortSignal)),
+	/**
+	* 実行時の変数です。
+	*/
+	vars: optional(VariablesInitSchema)
+});
+const CloseArgsSchema = tuple([optional(CloseOptionsSchema)]);
+const SetOptionsSchema = object({
+	key: string(),
+	vars: optional(VariablesInitSchema),
+	value: unknown(),
+	signal: optional(instance(AbortSignal))
+});
+const SetArgsSchema = union([tuple([SetOptionsSchema]), pipe(tuple([
+	SetOptionsSchema.entries.key,
+	SetOptionsSchema.entries.value,
+	optional(omit(SetOptionsSchema, ["key", "value"]))
+]), transform(([key, value, options]) => [{
+	...options,
+	key,
+	value
+}]))]);
+const GetOptionsSchema = object({
+	key: string(),
+	vars: optional(VariablesInitSchema),
+	repair: optional(boolean()),
+	signal: optional(instance(AbortSignal)),
+	throwOnRepairDenied: optional(boolean())
+});
+const GetArgsSchema = union([tuple([GetOptionsSchema]), pipe(tuple([GetOptionsSchema.entries.key, optional(omit(GetOptionsSchema, ["key"]))]), transform(([key, options]) => [{
+	...options,
+	key
+}]))]);
+const StreamOptionsSchema = object({
+	key: string(),
+	vars: optional(VariablesInitSchema),
+	repair: optional(boolean()),
+	signal: optional(instance(AbortSignal)),
+	throwOnRepairDenied: optional(boolean())
+});
+const StreamArgsSchema = union([tuple([StreamOptionsSchema]), pipe(tuple([StreamOptionsSchema.entries.key, optional(omit(StreamOptionsSchema, ["key"]))]), transform(([key, options]) => [{
+	...options,
+	key
+}]))]);
+const HasOptionsSchema = object({
+	key: string(),
+	vars: optional(VariablesInitSchema),
+	signal: optional(instance(AbortSignal))
+});
+const HasArgsSchema = union([tuple([HasOptionsSchema]), pipe(tuple([HasOptionsSchema.entries.key, optional(omit(HasOptionsSchema, ["key"]))]), transform(([key, options]) => [{
+	...options,
+	key
+}]))]);
+const DeleteOptionsSchema = object({
+	key: string(),
+	vars: optional(VariablesInitSchema),
+	signal: optional(instance(AbortSignal))
+});
+const DeleteArgsSchema = union([tuple([DeleteOptionsSchema]), pipe(tuple([DeleteOptionsSchema.entries.key, optional(omit(DeleteOptionsSchema, ["key"]))]), transform(([key, options]) => [{
+	...options,
+	key
+}]))]);
+const ClearOptionsSchema = object({
+	/**
+	* 処理の中断を通知するためのシグナルです。
+	*/
+	signal: optional(instance(AbortSignal)),
+	/**
+	* 実行時の変数です。
+	*/
+	vars: optional(VariablesInitSchema)
+});
+const ClearArgsSchema = tuple([optional(ClearOptionsSchema)]);
+//#endregion
+//#region ../src/_value-schemas.ts
+/**
+* スキーマ付きの値であることを識別するためのブランドです。
+*
+* 同じライブラリーが複数読み込まれた環境でも認識できるようにグローバルシンボルを使用します。
+*/
+const VALUE_SCHEMA_BRAND = /* #__PURE__ */ Symbol.for("unikvs:VALUE_SCHEMA_BRAND");
+var _entries = /* @__PURE__ */ new WeakMap();
+/**
+* オブジェクト形式のスキーマ定義からスキーマ情報を解決します。
+*/
+var RecordValueSchemaResolver = class {
+	constructor(entries) {
+		_classPrivateFieldInitSpec(this, _entries, void 0);
+		_classPrivateFieldSet2(_entries, this, new Map(Object.entries(entries)));
+	}
+	resolve(key) {
+		return _classPrivateFieldGet2(_entries, this).get(key);
+	}
+};
+var _entries2 = /* @__PURE__ */ new WeakMap();
+var _keySchema = /* @__PURE__ */ new WeakMap();
+/**
+* 配列形式のスキーマ定義からスキーマ情報を解決します。
+*
+* キースキーマに最初に一致した定義を採用します。
+*/
+var EntriesValueSchemaResolver = class {
+	constructor(entries) {
+		_classPrivateFieldInitSpec(this, _entries2, void 0);
+		_classPrivateFieldInitSpec(this, _keySchema, void 0);
+		_classPrivateFieldSet2(_entries2, this, entries);
+		if (entries.length > 0) _classPrivateFieldSet2(_keySchema, this, union(entries.map(([keySchema]) => keySchema)));
+	}
+	resolve(key) {
+		let resolved;
+		for (const [keySchema, valueSchema] of _classPrivateFieldGet2(_entries2, this)) if (safeParse$1(keySchema, key).success) {
+			resolved = valueSchema;
+			break;
+		}
+		if (resolved === void 0 && _classPrivateFieldGet2(_keySchema, this)) {
+			const result = safeParse$1(_classPrivateFieldGet2(_keySchema, this), key);
+			if (!result.success) throw new InvalidInputError({
+				value: key,
+				issues: result.issues
+			});
+		}
+		return resolved;
+	}
+};
+/**
+* 検証済みのスキーマ定義からスキーマリゾルバーを生成します。
+*
+* @param schema 検証済みのスキーマ定義です。
+*
+* @returns スキーマリゾルバーを返します。
+*/
+function createValueSchemaResolver(schema) {
+	if (Array.isArray(schema)) return new EntriesValueSchemaResolver(schema);
+	return new RecordValueSchemaResolver(schema);
+}
+//#endregion
+//#region ../src/_to-value-stream.ts
+/**
+* 与えられた `IReadableStream` を `IValueStream` に変換します。
+*
+* @template T ストリームが保持する値の型です。
+*
+* @param readableStream 変換対象となる `IReadableStream` インスタンスです。
+* @param onAsyncDispose ストリーム破棄時の処理です。
+* @param onBeforeDispose ソースストリームをキャンセルする前に呼ばれる処理です。
+*
+* @returns 非同期イテレーターが付与された `ValueStream` インスタンスを返します。
+*/
+function toValueStream(readableStream, onAsyncDispose, onBeforeDispose) {
+	const cacheMap = /* @__PURE__ */ new Map();
+	const reader = readableStream.getReader();
+	async function disposeValueStream() {
+		await callAsyncableFnOnce(cacheMap, "dispose", async () => {
+			try {
+				onBeforeDispose?.();
+				await reader.cancel();
+			} catch (ex) {
+				logger.error`Failed to cancel the source stream: ${ex}`;
+			}
+			await onAsyncDispose();
+		});
+	}
+	const valueStream = new ReadableStream({
+		async pull(controller) {
+			try {
+				const { done, value } = await reader.read();
+				if (done) {
+					await disposeValueStream();
+					controller.close();
+				} else controller.enqueue(value);
+			} catch (ex) {
+				await disposeValueStream().catch((disposeError) => {
+					logger.error`Failed to dispose value stream: ${disposeError}`;
+				});
+				controller.error(ex);
+			}
+		},
+		async cancel() {
+			await disposeValueStream();
+		}
+	});
+	return Object.assign(valueStream, { [Symbol.asyncDispose]: disposeValueStream }, { dispose: disposeValueStream }, { async *[Symbol.asyncIterator]() {
+		const r = this.getReader();
+		try {
+			while (true) {
+				const { done, value } = await r.read();
+				if (done) break;
+				yield value;
+			}
+		} catch (ex) {
+			try {
+				await r.cancel(ex);
+			} catch (cancelError) {
+				logger.error`Failed to cancel reader: ${cancelError}`;
+			}
+			throw ex;
+		} finally {
+			try {
+				await disposeValueStream();
+			} catch (ex) {
+				logger.error`Failed to dispose value stream: ${ex}`;
+			}
+			try {
+				r.releaseLock();
+			} catch (ex) {
+				logger.error`Failed to release reader's lock: ${ex}`;
+			}
+		}
+	} });
+}
+//#endregion
+//#region ../src/_value-validation.ts
+/**
+* プレーン値専用のスキーマに ReadableStream が渡されたことを報告するためのスキーマです。
+*/
+const PlainValueInputSchema = pipe(unknown(), check((input) => !isReadableStream(input), "Expected a plain value, but received a ReadableStream"));
+/**
+* ストリーム専用のスキーマにプレーン値が渡されたことを報告するためのスキーマです。
+*/
+const StreamValueInputSchema = pipe(unknown(), 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") parseInput(PlainValueInputSchema, value);
+		return value.pipeThrough(new TransformStream({ transform(chunk, controller) {
+			controller.enqueue(parseInput(info.schema, chunk));
+		} }));
+	}
+	if (info.kind === "stream") parseInput(StreamValueInputSchema, value);
+	return parseInput(info.schema, value);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+	}, e = {}, n = [];
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o() {
+				try {
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
+				}
+			}), n.push({
+				v: e,
+				d: o,
+				a: r
+			});
+		} else r && n.push({
+			d: e,
+			a: r
+		});
+		return e;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d() {
+			var o, t = this.e, s = 0;
+			function next() {
+				for (; o = n.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+					} else s |= 1;
+				} catch (r) {
+					return err(r);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
+			}
+			return next();
+		}
+	};
+}
+//#endregion
+//#region ../src/unikvs.ts
+let _Symbol$asyncDispose;
+/**
+* ストリームの読み取りロックを自動解放するための FinalizationRegistry です。
+*/
+const ioLockRegistry = typeof FinalizationRegistry !== "function" ? null : new FinalizationRegistry((held) => {
+	if (!held.lock.released) held.lock.release();
+	held.dispose().catch((ex) => {
+		logger.error`Failed to dispose value stream: ${ex}`;
+	});
+});
+var _con = /* @__PURE__ */ new WeakMap();
+var _acSet = /* @__PURE__ */ new WeakMap();
+var _baseVars = /* @__PURE__ */ new WeakMap();
+var _pipeline = /* @__PURE__ */ new WeakMap();
+var _valueSchemaResolver$1 = /* @__PURE__ */ new WeakMap();
+var _UniKvs_brand = /* @__PURE__ */ new WeakSet();
+_Symbol$asyncDispose = Symbol.asyncDispose;
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#client-operations)
+*/
+var UniKvs = class {
+	/**
+	* @internal
+	*/
+	constructor(vars, pipeline, valueSchemaResolver = null) {
+		_classPrivateMethodInitSpec(this, _UniKvs_brand);
+		_classPrivateFieldInitSpec(this, _con, void 0);
+		_classPrivateFieldInitSpec(this, _acSet, void 0);
+		_classPrivateFieldInitSpec(this, _baseVars, void 0);
+		_classPrivateFieldInitSpec(this, _pipeline, void 0);
+		_classPrivateFieldInitSpec(this, _valueSchemaResolver$1, void 0);
+		_classPrivateFieldSet2(_con, this, null);
+		_classPrivateFieldSet2(_acSet, this, /* @__PURE__ */ new Set());
+		_classPrivateFieldSet2(_baseVars, this, vars);
+		_classPrivateFieldSet2(_pipeline, this, pipeline);
+		_classPrivateFieldSet2(_valueSchemaResolver$1, this, valueSchemaResolver);
+	}
+	setVars(...args) {
+		const [vars] = parseInput(VariablesArgsSchema, args);
+		_classPrivateFieldSet2(_baseVars, this, vars);
+		return this;
+	}
+	assignVars(...args) {
+		const [vars] = parseInput(VariablesArgsSchema, args);
+		const map = new Map(_classPrivateFieldGet2(_baseVars, this));
+		for (const [name, value] of vars) map.set(name, value);
+		_classPrivateFieldSet2(_baseVars, this, [...map]);
+		return this;
+	}
+	defaultsVars(...args) {
+		const [vars] = parseInput(VariablesArgsSchema, args);
+		const map = new Map(vars);
+		for (const [name, value] of _classPrivateFieldGet2(_baseVars, this)) map.set(name, value);
+		_classPrivateFieldSet2(_baseVars, this, [...map]);
+		return this;
+	}
+	get isOpen() {
+		return _classPrivateFieldGet2(_con, this) !== null;
+	}
+	async open(...args) {
+		if (_classPrivateFieldGet2(_con, this) !== null) throw new UniKvsIsOpenError();
+		const [options = {}] = parseInput(OpenArgsSchema, args);
+		const { vars: varsOption, signal: signalOption } = options;
+		const ac = new AbortController();
+		const signal = combineSignals([ac.signal, signalOption]);
+		const operationVars = _assertClassBrand(_UniKvs_brand, this, _createOperationVars).call(this, varsOption);
+		throwIfAborted(signal);
+		_classPrivateFieldGet2(_acSet, this).add(ac);
+		const dispose = [];
+		try {
+			try {
+				var _usingCtx$1 = _usingCtx();
+				_usingCtx$1.u(await asyncmux(this, signal));
+				try {
+					if (_classPrivateFieldGet2(_con, this) !== null) throw new UniKvsIsOpenError();
+					const openFns = [];
+					for (const [index, leaf] of _classPrivateFieldGet2(_pipeline, this).leaves.entries()) openFns.push([
+						async () => {
+							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 [index, middleware] of _classPrivateFieldGet2(_pipeline, this).middlewares.entries()) openFns.push([
+						async () => {
+							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}`;
+								}
+							});
+						},
+						"middleware",
+						middleware.name,
+						index
+					]);
+					const errors = [];
+					await Promise.all(openFns.map(async ([f, plugin, name, index]) => {
+						try {
+							await f();
+						} catch (ex) {
+							errors.push({
+								name,
+								index,
+								plugin,
+								reason: ex
+							});
+						}
+					}));
+					if (errors.length > 0) {
+						if (signal.aborted && errors.every((error) => error.reason === signal.reason)) throw signal.reason;
+						throw new PluginOperationAggregateError({
+							action: "open",
+							errors
+						});
+					}
+					throwIfAborted(signal);
+					_classPrivateFieldSet2(_con, this, {
+						ac,
+						io: new Asyncmux()
+					});
+				} catch (ex) {
+					if (dispose.length > 0) await Promise.all(dispose.map(async (f) => {
+						await f();
+					}));
+					throw ex;
+				}
+			} catch (_) {
+				_usingCtx$1.e = _;
+			} finally {
+				_usingCtx$1.d();
+			}
+		} finally {
+			_classPrivateFieldGet2(_acSet, this).delete(ac);
+		}
+	}
+	close(...args) {
+		try {
+			const [options = {}] = parseInput(CloseArgsSchema, args);
+			const { vars: varsOption, signal = AbortSignal.timeout(1e4) } = options;
+			const operationVars = _assertClassBrand(_UniKvs_brand, this, _createOperationVars).call(this, varsOption);
+			if (_classPrivateFieldGet2(_con, this) === null) {
+				const acArr = [..._classPrivateFieldGet2(_acSet, this)];
+				_classPrivateFieldGet2(_acSet, this).clear();
+				for (const ac of acArr) if (!ac.signal.aborted) ac.abort(new UniKvsIsNotOpenError());
+				throw new UniKvsIsNotOpenError();
+			}
+			const con = _classPrivateFieldGet2(_con, this);
+			const { ac } = con;
+			const acArr = [ac, ..._classPrivateFieldGet2(_acSet, this)];
+			_classPrivateFieldGet2(_acSet, this).clear();
+			for (const targetAc of acArr) if (!targetAc.signal.aborted) targetAc.abort(new UniKvsIsNotOpenError());
+			const progress = { pluginsStarted: false };
+			return _assertClassBrand(_UniKvs_brand, this, _close).call(this, operationVars, signal, con, progress).catch(async (closeError) => {
+				if (_classPrivateFieldGet2(_con, this) === con) {
+					_classPrivateFieldSet2(_con, this, null);
+					if (!progress.pluginsStarted) {
+						const disposeSignal = AbortSignal.timeout(1e4);
+						await Promise.all([..._classPrivateFieldGet2(_pipeline, this).leaves.map((leaf) => leaf.storage), ..._classPrivateFieldGet2(_pipeline, this).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 closeError;
+			});
+		} catch (ex) {
+			return Promise.reject(ex);
+		}
+	}
+	async [_Symbol$asyncDispose]() {
+		if (!this.isOpen) return;
+		await this.close({ signal: AbortSignal.timeout(1e4) });
+	}
+	async set(...args) {
+		if (_classPrivateFieldGet2(_con, this) === null) throw new UniKvsIsNotOpenError();
+		const [options] = parseInput(SetArgsSchema, args);
+		const { key, vars: varsOption, signal: signalOption } = options;
+		const valueSchema = _assertClassBrand(_UniKvs_brand, this, _resolveValueSchema).call(this, key);
+		const value = valueSchema ? parseSetValue(valueSchema, options.value) : options.value;
+		const { ac, io } = _classPrivateFieldGet2(_con, this);
+		const signal = combineSignals([ac.signal, signalOption]);
+		const store = _assertClassBrand(_UniKvs_brand, this, _createOperationStore).call(this, varsOption);
+		const stream = isReadableStream(value) ? value : null;
+		let ownsStream = stream !== null;
+		try {
+			try {
+				var _usingCtx6 = _usingCtx();
+				_usingCtx6.u(await asyncmux.readonly(this, signal));
+				if (_classPrivateFieldGet2(_con, this) === null) throw new UniKvsIsNotOpenError();
+				const useContext = new SetContext({
+					key,
+					store,
+					signal
+				});
+				await _assertClassBrand(_UniKvs_brand, this, _use).call(this, "write", useContext);
+				throwIfAborted(signal);
+				if (stream !== null) {
+					ownsStream = false;
+					await _assertClassBrand(_UniKvs_brand, this, _setStream).call(this, io, signal, key, store, stream);
+				} else await _assertClassBrand(_UniKvs_brand, this, _setPlain).call(this, io, signal, key, store, value);
+			} catch (_) {
+				_usingCtx6.e = _;
+			} finally {
+				_usingCtx6.d();
+			}
+		} catch (ex) {
+			if (ownsStream && stream !== null) try {
+				await stream.cancel(ex);
+			} catch {}
+			throw ex;
+		}
+	}
+	async get(...args) {
+		try {
+			var _usingCtx7 = _usingCtx();
+			if (_classPrivateFieldGet2(_con, this) === null) throw new UniKvsIsNotOpenError();
+			const [options] = parseInput(GetArgsSchema, args);
+			const { key, vars: varsOption, repair = false, signal: signalOption, throwOnRepairDenied = false } = options;
+			const valueSchema = _assertClassBrand(_UniKvs_brand, this, _resolveValueSchema).call(this, key);
+			const { ac, io } = _classPrivateFieldGet2(_con, this);
+			const signal = combineSignals([ac.signal, signalOption]);
+			const store = _assertClassBrand(_UniKvs_brand, this, _createOperationStore).call(this, varsOption);
+			_usingCtx7.u(await asyncmux.readonly(this, signal));
+			if (_classPrivateFieldGet2(_con, this) === null) throw new UniKvsIsNotOpenError();
+			const leafNames = _classPrivateFieldGet2(_pipeline, this).leaves.map((leaf) => leaf.name);
+			const useContext = new GetContext({
+				key,
+				store,
+				repair: repair ? {
+					enabled: true,
+					targets: leafNames
+				} : {
+					enabled: false,
+					targets: []
+				},
+				signal
+			});
+			await _assertClassBrand(_UniKvs_brand, this, _use).call(this, "read", useContext);
+			throwIfAborted(signal);
+			let data = void 0;
+			let hit = null;
+			const missing = [];
+			const errors = [];
+			try {
+				var _usingCtx8 = _usingCtx();
+				_usingCtx8.u(await (repair ? io.lock({
+					key,
+					signal
+				}) : io.rLock({
+					key,
+					signal
+				})));
+				const resolver = _classPrivateFieldGet2(_pipeline, this).createResolver({
+					key,
+					store,
+					signal
+				});
+				for (const leaf of _classPrivateFieldGet2(_pipeline, this)) {
+					const resolved = resolver.resolve(leaf);
+					const existsContext = new HasContext({
+						key: resolved.key,
+						store,
+						signal
+					});
+					const readRepair = repair ? {
+						enabled: true,
+						targets: leafNames
+					} : {
+						enabled: false,
+						targets: []
+					};
+					const readContext = new GetContext({
+						key: resolved.key,
+						store,
+						repair: readRepair,
+						signal
+					});
+					try {
+						if (!await leaf.storage.exists(existsContext)) {
+							missing.push(leaf);
+							continue;
+						}
+						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}`;
+					}
+				}
+				if (hit === null) throw _assertClassBrand(_UniKvs_brand, this, _notFound).call(this, key, errors);
+				if (repair) data = await _assertClassBrand(_UniKvs_brand, this, _repairPlain).call(this, data, hit, missing, store, key, signal, throwOnRepairDenied);
+			} catch (_) {
+				_usingCtx8.e = _;
+			} finally {
+				_usingCtx8.d();
+			}
+			if (!repair) data = await _classPrivateFieldGet2(_pipeline, this).decode(hit.leaf, {
+				key,
+				store,
+				signal
+			}, data);
+			if (valueSchema) data = parseOutput(valueSchema.schema, data);
+			return data;
+		} catch (_) {
+			_usingCtx7.e = _;
+		} finally {
+			_usingCtx7.d();
+		}
+	}
+	async stream(...args) {
+		if (_classPrivateFieldGet2(_con, this) === null) throw new UniKvsIsNotOpenError();
+		const [options] = parseInput(StreamArgsSchema, args);
+		const { key, vars: varsOption, repair = false, signal: signalOption, throwOnRepairDenied = false } = options;
+		const valueSchema = _assertClassBrand(_UniKvs_brand, this, _resolveValueSchema).call(this, key);
+		const { ac, io } = _classPrivateFieldGet2(_con, this);
+		const signal = combineSignals([ac.signal, signalOption]);
+		const store = _assertClassBrand(_UniKvs_brand, this, _createOperationStore).call(this, varsOption);
+		try {
+			var _usingCtx9 = _usingCtx();
+			_usingCtx9.u(await asyncmux.readonly(this, signal));
+			if (_classPrivateFieldGet2(_con, this) === null) throw new UniKvsIsNotOpenError();
+			const leafNames = _classPrivateFieldGet2(_pipeline, this).leaves.map((leaf) => leaf.name);
+			const useContext = new StreamContext({
+				key,
+				store,
+				repair: repair ? {
+					enabled: true,
+					targets: leafNames
+				} : {
+					enabled: false,
+					targets: []
+				},
+				signal
+			});
+			await _assertClassBrand(_UniKvs_brand, this, _use).call(this, "read", useContext);
+			throwIfAborted(signal);
+			const NONE = {};
+			let r = NONE;
+			let hit = null;
+			const missing = [];
+			const errors = [];
+			const fillBranches = [];
+			const fillTasks = [];
+			let repairAc = null;
+			let cancelFills = null;
+			const ioLock = await (repair ? io.lock({
+				key,
+				signal
+			}) : io.rLock({
+				key,
+				signal
+			}));
+			try {
+				const resolver = _classPrivateFieldGet2(_pipeline, this).createResolver({
+					key,
+					store,
+					signal
+				});
+				for (const leaf of _classPrivateFieldGet2(_pipeline, this)) {
+					const resolved = resolver.resolve(leaf);
+					const existsContext = new HasContext({
+						key: resolved.key,
+						store,
+						signal
+					});
+					const readableRepair = repair ? {
+						enabled: true,
+						targets: leafNames
+					} : {
+						enabled: false,
+						targets: []
+					};
+					const readableContext = new StreamContext({
+						key: resolved.key,
+						store,
+						repair: readableRepair,
+						signal
+					});
+					try {
+						if (!await leaf.storage.exists(existsContext)) {
+							missing.push(leaf);
+							continue;
+						}
+						r = await leaf.storage.getReadable(readableContext);
+						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}`;
+					}
+				}
+				if (hit === null) throw _assertClassBrand(_UniKvs_brand, this, _notFound).call(this, key, errors);
+				repairAc = repair ? new AbortController() : null;
+				const repairSignal = repairAc ? combineSignals([signal, repairAc.signal]) : signal;
+				const fill = (target) => {
+					fillBranches.push(target.stream);
+					fillTasks.push((async () => {
+						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) {
+							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) => {
+					repairAc?.abort(reason);
+					await Promise.all(fillBranches.map(async (branch) => {
+						try {
+							await branch.cancel(reason);
+						} catch {}
+					}));
+					await Promise.all(fillTasks);
+				};
+				r = await _classPrivateFieldGet2(_pipeline, this).decodeStream(hit.leaf, {
+					key,
+					store,
+					signal
+				}, r);
+				if (repair) {
+					const repairSet = /* @__PURE__ */ new Set();
+					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 = /* @__PURE__ */ new Set([r]);
+						const tree = await _classPrivateFieldGet2(_pipeline, this).buildEncodeTree({
+							key,
+							store,
+							signal
+						}, r, streams, {
+							isActive: (leaf) => repairSet.has(leaf),
+							splitRead: true,
+							onNodeError: (ex, activeLeaves) => {
+								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);
+					}
+					throwIfAborted(signal);
+				}
+				if (valueSchema) r = r.pipeThrough(new TransformStream({ transform(chunk, controller) {
+					controller.enqueue(parseOutput(valueSchema.schema, chunk));
+				} }));
+				let completed = false;
+				if (repairAc) r = r.pipeThrough(new TransformStream({
+					flush() {
+						completed = true;
+					},
+					transform(chunk, controller) {
+						controller.enqueue(chunk);
+					}
+				}));
+				const beforeDispose = () => {
+					if (!completed) repairAc?.abort(signal.reason);
+				};
+				const dispose = async () => {
+					try {
+						await Promise.all(fillTasks);
+					} finally {
+						try {
+							ioLock.release();
+						} catch {}
+					}
+				};
+				if (!ioLockRegistry) return toValueStream(r, dispose, beforeDispose);
+				const unregisterToken = {};
+				const valueStream = toValueStream(r, async () => {
+					try {
+						ioLockRegistry.unregister(unregisterToken);
+					} catch {}
+					await dispose();
+				}, beforeDispose);
+				ioLockRegistry.register(valueStream, {
+					lock: ioLock,
+					dispose: valueStream.dispose
+				}, unregisterToken);
+				return valueStream;
+			} catch (ex) {
+				await cancelFills?.(ex);
+				if (r !== NONE) try {
+					await r.cancel(ex);
+				} catch {}
+				ioLock.release();
+				throw ex;
+			}
+		} catch (_) {
+			_usingCtx9.e = _;
+		} finally {
+			_usingCtx9.d();
+		}
+	}
+	async has(...args) {
+		try {
+			var _usingCtx10 = _usingCtx();
+			if (_classPrivateFieldGet2(_con, this) === null) throw new UniKvsIsNotOpenError();
+			const [options] = parseInput(HasArgsSchema, args);
+			const { key, vars: varsOption, signal: signalOption } = options;
+			_assertClassBrand(_UniKvs_brand, this, _resolveValueSchema).call(this, key);
+			const { ac, io } = _classPrivateFieldGet2(_con, this);
+			const signal = combineSignals([ac.signal, signalOption]);
+			const store = _assertClassBrand(_UniKvs_brand, this, _createOperationStore).call(this, varsOption);
+			_usingCtx10.u(await asyncmux.readonly(this, signal));
+			if (_classPrivateFieldGet2(_con, this) === null) throw new UniKvsIsNotOpenError();
+			const useContext = new HasContext({
+				key,
+				store,
+				signal
+			});
+			await _assertClassBrand(_UniKvs_brand, this, _use).call(this, "read", useContext);
+			throwIfAborted(signal);
+			_usingCtx10.u(await io.rLock({
+				key,
+				signal
+			}));
+			const errors = [];
+			const resolver = _classPrivateFieldGet2(_pipeline, this).createResolver({
+				key,
+				store,
+				signal
+			});
+			for (const leaf of _classPrivateFieldGet2(_pipeline, this)) {
+				const resolved = resolver.resolve(leaf);
+				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;
+					errors.push({
+						name: leaf.name,
+						index: leaf.index,
+						reason: ex
+					});
+					logger.error`Failed to check existence in a storage: ${ex}`;
+				}
+			}
+			if (errors.length > 0) throw _assertClassBrand(_UniKvs_brand, this, _notFound).call(this, key, errors);
+			return false;
+		} catch (_) {
+			_usingCtx10.e = _;
+		} finally {
+			_usingCtx10.d();
+		}
+	}
+	async delete(...args) {
+		try {
+			var _usingCtx11 = _usingCtx();
+			if (_classPrivateFieldGet2(_con, this) === null) throw new UniKvsIsNotOpenError();
+			const [options] = parseInput(DeleteArgsSchema, args);
+			const { key, vars: varsOption, signal: signalOption } = options;
+			_assertClassBrand(_UniKvs_brand, this, _resolveValueSchema).call(this, key);
+			const { ac, io } = _classPrivateFieldGet2(_con, this);
+			const signal = combineSignals([ac.signal, signalOption]);
+			const store = _assertClassBrand(_UniKvs_brand, this, _createOperationStore).call(this, varsOption);
+			_usingCtx11.u(await asyncmux.readonly(this, signal));
+			if (_classPrivateFieldGet2(_con, this) === null) throw new UniKvsIsNotOpenError();
+			const useContext = new DeleteContext({
+				key,
+				store,
+				signal
+			});
+			await _assertClassBrand(_UniKvs_brand, this, _use).call(this, "delete", useContext);
+			_usingCtx11.u(await io.lock({
+				key,
+				signal
+			}));
+			const errors = [];
+			const resolver = _classPrivateFieldGet2(_pipeline, this).createResolver({
+				key,
+				store,
+				signal
+			});
+			await Promise.all(_classPrivateFieldGet2(_pipeline, this).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
+					});
+				}
+			}));
+			if (errors.length > 0) throw new PluginOperationAggregateError({
+				action: "delete",
+				errors,
+				plugin: "storage"
+			});
+		} catch (_) {
+			_usingCtx11.e = _;
+		} finally {
+			_usingCtx11.d();
+		}
+	}
+	async clear(...args) {
+		try {
+			var _usingCtx12 = _usingCtx();
+			if (_classPrivateFieldGet2(_con, this) === null) throw new UniKvsIsNotOpenError();
+			const [options = {}] = parseInput(ClearArgsSchema, args);
+			const { vars: varsOption, signal: signalOption } = options;
+			const { ac, io } = _classPrivateFieldGet2(_con, this);
+			const signal = combineSignals([ac.signal, signalOption]);
+			const store = _assertClassBrand(_UniKvs_brand, this, _createOperationStore).call(this, varsOption);
+			_usingCtx12.u(await asyncmux.readonly(this, signal));
+			if (_classPrivateFieldGet2(_con, this) === null) throw new UniKvsIsNotOpenError();
+			_usingCtx12.u(await io.lock({ signal }));
+			const useContext = new ClearContext({
+				store,
+				signal
+			});
+			await _assertClassBrand(_UniKvs_brand, this, _use).call(this, "clear", useContext);
+			throwIfAborted(signal);
+			const errors = [];
+			await Promise.all(_classPrivateFieldGet2(_pipeline, this).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
+					});
+				}
+			}));
+			if (errors.length > 0) throw new PluginOperationAggregateError({
+				action: "clear",
+				errors,
+				plugin: "storage"
+			});
+		} catch (_) {
+			_usingCtx12.e = _;
+		} finally {
+			_usingCtx12.d();
+		}
+	}
+};
+/**
+* 基本変数と操作固有変数を結合した実行時変数マップを作成します。
+*
+* @param vars 操作固有の変数です。
+*
+* @returns 結合した変数マップを返します。
+*/
+function _createOperationVars(vars) {
+	const map = new Map(_classPrivateFieldGet2(_baseVars, this));
+	if (vars) for (const [k, v] of vars) map.set(k, v);
+	return map;
+}
+/**
+* 操作内で共有される変数ストアを作成します。
+*
+* 同一操作内の全コンテキスト (`use`/`encode`/`decode`/ ストレージ) で共有され、下流の `set` が上流の `await next()` 後の `get` に見えます。
+*
+* @param vars 操作固有の変数です。
+*
+* @returns 共有ストアを返します。
+*/
+function _createOperationStore(vars) {
+	return createVariablesStore([..._classPrivateFieldGet2(_baseVars, this), ...vars ?? []]);
+}
+/**
+* キーに対応する値のスキーマ情報を解決します。
+*
+* @param key 解決するキーです。
+*
+* @returns 対応するスキーマ情報を返します。スキーマ未設定または対応する定義がない場合は `undefined` を返します。
+*/
+function _resolveValueSchema(key) {
+	return _classPrivateFieldGet2(_valueSchemaResolver$1, this)?.resolve(key);
+}
+/**
+* すべての宛先で読み取りに失敗したときのエラーを組み立てます。
+*
+* @param key 読み取ったキーです。
+* @param errors 収集した失敗です。
+*
+* @returns `KeyNotFoundError` を返します。
+*/
+function _notFound(key, errors) {
+	const args = { key };
+	switch (errors.length) {
+		case 0: break;
+		case 1: {
+			const [firstError] = errors;
+			if (firstError !== void 0) args.cause = firstError.reason;
+			break;
+		}
+		default: args.cause = new PluginOperationAggregateError({
+			action: "read",
+			errors,
+			plugin: "storage"
+		});
+	}
+	return new KeyNotFoundError(args);
+}
+async function _close(operationVars, signal, con, progress) {
+	try {
+		var _usingCtx3 = _usingCtx();
+		_usingCtx3.u(await asyncmux(this, signal));
+		if (_classPrivateFieldGet2(_con, this) !== con) throw new UniKvsIsNotOpenError();
+		const { io } = _classPrivateFieldGet2(_con, this);
+		_usingCtx3.u(await io.lock({ signal }));
+		const closeFns = [];
+		for (const [index, leaf] of _classPrivateFieldGet2(_pipeline, this).leaves.entries()) {
+			const createContext = () => new CloseContext({
+				vars: new Map(operationVars).entries(),
+				signal
+			});
+			const createRetryContext = () => new CloseContext({
+				vars: new Map(operationVars).entries(),
+				signal: AbortSignal.timeout(1e4)
+			});
+			closeFns.push([
+				() => leaf.storage.close(createContext()),
+				() => leaf.storage.retryClose(createRetryContext()),
+				"storage",
+				leaf.name,
+				index
+			]);
+		}
+		for (const [index, plugin] of _classPrivateFieldGet2(_pipeline, this).middlewares.entries()) {
+			const createContext = () => new CloseContext({
+				vars: new Map(operationVars).entries(),
+				signal
+			});
+			const createRetryContext = () => new CloseContext({
+				vars: new Map(operationVars).entries(),
+				signal: AbortSignal.timeout(1e4)
+			});
+			closeFns.push([
+				() => plugin.close(createContext()),
+				() => plugin.retryClose(createRetryContext()),
+				"middleware",
+				plugin.name,
+				index
+			]);
+		}
+		progress.pluginsStarted = true;
+		const errors = [];
+		const retries = [];
+		await Promise.all(closeFns.map(async ([f, retry, plugin, name, index]) => {
+			try {
+				await f();
+			} catch (ex) {
+				errors.push({
+					name,
+					index,
+					plugin,
+					reason: ex
+				});
+				retries.push(retry);
+			}
+		}));
+		if (errors.length > 0) {
+			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
+			});
+		}
+		_classPrivateFieldSet2(_con, this, null);
+	} catch (_) {
+		_usingCtx3.e = _;
+	} finally {
+		_usingCtx3.d();
+	}
+}
+/**
+* 書き込み失敗の集約と、成功した宛先への通知を行います。
+*
+* @param targets 書き込みを試みた対象です。
+* @param failed 失敗した葉の集合です。
+* @param errors 集約する失敗です。
+* @param signal 中断シグナルです。
+*/
+async function _finishWrites(targets, store, failed, errors, signal) {
+	if (errors.length === 0) return;
+	const error = new PluginOperationAggregateError({
+		action: "write",
+		errors,
+		plugin: "storage"
+	});
+	const notifyErrors = [];
+	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` をオニオン実行し、失敗時は集約して投げます。
+*
+* 同一コンテキストオブジェクトを全ミドルウェアで共有し、`next` で下流をネスト実行するため、下流の `set` が上流の `await next()` 後の `get` に見えます。
+* `encode`/`decode` と同じく `next()` の呼び出し規約を検証し、違反したときは操作を実行せず失敗させます (fail-close)。
+* いずれかのミドルウェアが投げたときは即時に確定し、後段は実行しません (fail-fast)。
+* 失敗は集約エラー (単一件) として投げます。
+*
+* @param action 集約エラーに付与する操作名です。
+* @param c 共有の `use` コンテキストです。
+*/
+async function _use(action, c) {
+	throwIfAborted(c.signal);
+	const middlewares = _classPrivateFieldGet2(_pipeline, this).middlewares;
+	const dispatch = async (index) => {
+		const maybeMiddleware = middlewares[index];
+		if (maybeMiddleware === void 0) return;
+		const middleware = maybeMiddleware;
+		let nextCalled = false;
+		let nextSettled = false;
+		let downstreamError;
+		let hasDownstreamError = false;
+		function next() {
+			if (nextCalled) {
+				const rejection = Promise.reject(new MiddlewareNextCalledMultipleTimesError({
+					name: middleware.name,
+					operation: "use"
+				}));
+				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;
+				}
+			});
+			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;
+			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 function _setPlain(io, signal, key, store, value) {
+	try {
+		var _usingCtx4 = _usingCtx();
+		const targets = await _classPrivateFieldGet2(_pipeline, this).encode({
+			key,
+			store,
+			signal
+		}, value);
+		_usingCtx4.u(await io.lock({
+			key,
+			signal
+		}));
+		const errors = [];
+		const failed = /* @__PURE__ */ new Set();
+		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 _assertClassBrand(_UniKvs_brand, this, _finishWrites).call(this, targets, store, failed, errors, signal);
+	} catch (_) {
+		_usingCtx4.e = _;
+	} finally {
+		_usingCtx4.d();
+	}
+}
+/**
+* ストリーム値の並列書き込みを行います。
+*
+* @param io 多重化インスタンスです。
+* @param signal 中断シグナルです。
+* @param key 書き込みキーです。
+* @param store 操作内で共有される変数ストアです。
+* @param value 書き込むストリームです。
+*/
+async function _setStream(io, signal, key, store, value) {
+	try {
+		var _usingCtx5 = _usingCtx();
+		const streams = /* @__PURE__ */ new Set([value]);
+		let tree;
+		try {
+			tree = await _classPrivateFieldGet2(_pipeline, this).buildEncodeTree({
+				key,
+				store,
+				signal
+			}, value, streams);
+		} catch (ex) {
+			await cancelStreams(streams, ex);
+			throw ex;
+		}
+		_usingCtx5.u(await io.lock({
+			key,
+			signal
+		}).catch(async (ex) => {
+			await cancelStreams(streams, ex);
+			throw ex;
+		}));
+		const errors = [];
+		const failed = /* @__PURE__ */ new Set();
+		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) {
+				try {
+					await target.stream.cancel(ex);
+				} catch {}
+				errors.push({
+					name: target.leaf.name,
+					index: target.leaf.index,
+					reason: ex
+				});
+				failed.add(target.leaf);
+			}
+		}));
+		await _assertClassBrand(_UniKvs_brand, this, _finishWrites).call(this, tree.targets, store, failed, errors, signal);
+	} catch (_) {
+		_usingCtx5.e = _;
+	} finally {
+		_usingCtx5.d();
+	}
+}
+/**
+* 読み取り元のチェーン全体を逆順にデコードし、書き戻し対象向けに再エンコードして書き込みます。
+*
+* @param data 読み取ったデータです。
+* @param hit 読み取り元の葉です。
+* @param missing 読み取りに失敗または不在だった葉です。
+* @param store 操作内で共有される変数ストアです。
+* @param key キーです。
+* @param signal 中断シグナルです。
+* @param throwOnRepairDenied 書き戻し拒否をエラーとして投げるかどうかです。
+*
+* @returns デコード済みの原データを返します。
+*/
+async function _repairPlain(data, hit, missing, store, key, signal, throwOnRepairDenied) {
+	const raw = await _classPrivateFieldGet2(_pipeline, this).decode(hit.leaf, {
+		key,
+		store,
+		signal
+	}, data);
+	await _classPrivateFieldGet2(_pipeline, this).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;
+}
+//#endregion
+//#region ../src/unikvs-builder.ts
+/**
+* 値が Valibot のスキーマであるかどうかを判定します。
+*/
+function isGenericSchema(input) {
+	return typeof input === "object" && input !== null && "~run" in input && typeof input["~run"] === "function";
+}
+/**
+* 値がスキーマ情報であるかどうかを判定します。
+*/
+function isValueSchemaInfo(input) {
+	return typeof input === "object" && input !== null && VALUE_SCHEMA_BRAND in input && input[VALUE_SCHEMA_BRAND] === true;
+}
+const UniKvsBuilderOptionsSchema = object({
+	/**
+	* キーと値のスキーマ定義です。
+	*/
+	schema: optional(union([array(tuple([custom(isGenericSchema), custom(isValueSchemaInfo)])), record(string(), custom(isValueSchemaInfo))])),
+	/**
+	* 基本となる実行時変数です。
+	*/
+	vars: optional(VariablesInitSchema)
+});
+const UniKvsBuilderArgsSchema = tuple([optional(UniKvsBuilderOptionsSchema)]);
+var _destinations = /* @__PURE__ */ new WeakMap();
+var _middlewares = /* @__PURE__ */ new WeakMap();
+var _valueSchemaResolver = /* @__PURE__ */ new WeakMap();
+var _vars = /* @__PURE__ */ new WeakMap();
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#builder)
+*/
+var UniKvsBuilder = class {
+	constructor(...args) {
+		_classPrivateFieldInitSpec(this, _destinations, void 0);
+		_classPrivateFieldInitSpec(this, _middlewares, void 0);
+		_classPrivateFieldInitSpec(this, _valueSchemaResolver, void 0);
+		_classPrivateFieldInitSpec(this, _vars, void 0);
+		const [options = {}] = parseInput(UniKvsBuilderArgsSchema, args);
+		const { vars, schema } = options;
+		_classPrivateFieldSet2(_destinations, this, []);
+		_classPrivateFieldSet2(_middlewares, this, []);
+		_classPrivateFieldSet2(_valueSchemaResolver, this, null);
+		_classPrivateFieldSet2(_vars, this, new Map(vars));
+		if (schema) _classPrivateFieldSet2(_valueSchemaResolver, this, createValueSchemaResolver(schema));
+	}
+	fork(branch) {
+		appendForkDestinations(_classPrivateFieldGet2(_destinations, this), _classPrivateFieldGet2(_middlewares, this), branch);
+		return this;
+	}
+	use(middleware) {
+		_classPrivateFieldGet2(_middlewares, this).push(UniKvsMiddleware.from(middleware));
+		return this;
+	}
+	persist(storage) {
+		_classPrivateFieldGet2(_destinations, this).push({
+			storage: UniKvsStorage.from(storage),
+			middlewares: [..._classPrivateFieldGet2(_middlewares, this)]
+		});
+		return this;
+	}
+	setVars(...args) {
+		const [vars] = parseInput(VariablesArgsSchema, args);
+		_classPrivateFieldGet2(_vars, this).clear();
+		for (const [name, value] of vars) _classPrivateFieldGet2(_vars, this).set(name, value);
+		return this;
+	}
+	assignVars(...args) {
+		const [vars] = parseInput(VariablesArgsSchema, args);
+		const target = _classPrivateFieldGet2(_vars, this);
+		const source = vars;
+		for (const [name, value] of source) target.set(name, value);
+		return this;
+	}
+	defaultsVars(...args) {
+		const [vars] = parseInput(VariablesArgsSchema, args);
+		const target = new Map(vars);
+		const source = _classPrivateFieldGet2(_vars, this);
+		for (const [name, value] of source) target.set(name, value);
+		this.setVars(target);
+		return this;
+	}
+	build() {
+		if (_classPrivateFieldGet2(_destinations, this).length === 0) throw new MissingStorageError();
+		return new UniKvs([..._classPrivateFieldGet2(_vars, this).entries()], PipelineGraph.compile([..._classPrivateFieldGet2(_destinations, this)]), _classPrivateFieldGet2(_valueSchemaResolver, this));
+	}
+};
+//#endregion
+//#region ../src/value-schemas.ts
+/**
+* スキーマ情報を内部オブジェクトとして生成します。
+*/
+function createValueSchemaDescriptor(kind, schema) {
+	return {
+		[VALUE_SCHEMA_BRAND]: true,
+		kind,
+		schema
+	};
+}
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#value-types)
+*/
+function PlainValue(schema) {
+	return createValueSchemaDescriptor("plain", schema);
+}
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#value-types)
+*/
+function StreamValue(schema) {
+	return createValueSchemaDescriptor("stream", schema);
+}
+/**
+* [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#value-types)
+*/
+function Value(schema) {
+	return createValueSchemaDescriptor("any", schema);
+}
+//#endregion
+export { UniKvsBranch as Branch, UniKvsBranch, UniKvsBuilder as Builder, UniKvsBuilder, InvalidInputError, InvalidOutputError, InvalidUsageErrorBase, KeyNotFoundError, MiddlewareDestinationFrozenError, MiddlewareDestinationMissingError, MiddlewareIsNotOpenError, MiddlewareNextCalledMultipleTimesError, MiddlewareNextNotAwaitedError, MiddlewareNextNotCalledError, MissingStorageError, MultipartWriteNotSupportedError, PlainValue, PluginOperationAggregateError, ReadableStreamNotSupportedError, StorageIsNotOpenError, StreamDecodingNotSupportedError, StreamEncodingNotSupportedError, StreamValue, UniKvs, UniKvsIsNotOpenError, UniKvsIsOpenError, Value, WritableStreamNotSupportedError };
+
+//# sourceMappingURL=index.js.map