@composy/store-core 0.0.1

package/dist/index.js

@@ -0,0 +1,1852 @@
+/*!
+* ***********************************
+* @composy/store-core v0.0.1      *
+* Built with rollup               *
+* Build time: 2024-08-17 11:27:33 *
+* Build mode: production          *
+* Minified: No                    *
+* ***********************************
+*/
+"use strict";
+(function(global, factory) {
+	typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.LDesignStoreCore = {}));
+})(this, function(exports) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region src/core/pub-sub.ts
+	function createPubSub() {
+		const subscribers = /* @__PURE__ */ new Set();
+		const subscribe = (callback, options = {}) => {
+			const info = {
+				callback,
+				options
+			};
+			subscribers.add(info);
+			return () => {
+				subscribers.delete(info);
+			};
+		};
+		const publish = (value, oldValue) => {
+			subscribers.forEach((info) => {
+				try {
+					info.callback(value, oldValue);
+				} catch (error) {
+					console.error("[PubSub] 订阅回调执行出错:", error);
+				}
+			});
+		};
+		const clear = () => {
+			subscribers.clear();
+		};
+		const size = () => {
+			return subscribers.size;
+		};
+		return {
+			subscribe,
+			publish,
+			clear,
+			size
+		};
+	}
+	function createPubSubWithValue(initialValue) {
+		let currentValue = initialValue;
+		const pubsub = createPubSub();
+		const getValue = () => currentValue;
+		const setValue = (value) => {
+			const oldValue = currentValue;
+			currentValue = value;
+			pubsub.publish(value, oldValue);
+		};
+		const subscribe = (callback, options = {}) => {
+			const unsubscribe = pubsub.subscribe(callback, options);
+			if (options.immediate) callback(currentValue);
+			return unsubscribe;
+		};
+		return {
+			subscribe,
+			publish: pubsub.publish,
+			clear: pubsub.clear,
+			size: pubsub.size,
+			getValue,
+			setValue
+		};
+	}
+	//#endregion
+	//#region src/core/async-action.ts
+	function delay(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+	function createAsyncAction(fn, options = {}) {
+		const { retryCount = 0, retryDelay = 1e3, timeout = 0, resetOnExecute = true } = options;
+		const _state = {
+			data: null,
+			error: null,
+			loading: false,
+			executionCount: 0,
+			lastExecutedAt: null
+		};
+		const statePubSub = createPubSub();
+		const successPubSub = createPubSub();
+		const errorPubSub = createPubSub();
+		let abortController = null;
+		const notify = () => {
+			statePubSub.publish({ ..._state });
+		};
+		const executeWithRetry = async (args, retriesLeft) => {
+			try {
+				return await fn(...args);
+			} catch (error) {
+				if (retriesLeft > 0 && !abortController?.signal.aborted) {
+					await delay(retryDelay);
+					if (abortController?.signal.aborted) throw new Error("Aborted");
+					return executeWithRetry(args, retriesLeft - 1);
+				}
+				throw error;
+			}
+		};
+		const execute = async (...args) => {
+			if (abortController) abortController.abort();
+			abortController = new AbortController();
+			if (resetOnExecute) _state.error = null;
+			_state.loading = true;
+			_state.executionCount++;
+			_state.lastExecutedAt = Date.now();
+			notify();
+			try {
+				let result;
+				if (timeout > 0) {
+					const timeoutPromise = new Promise((_, reject) => {
+						setTimeout(() => reject(/* @__PURE__ */ new Error(`Timeout after ${timeout}ms`)), timeout);
+					});
+					result = await Promise.race([executeWithRetry(args, retryCount), timeoutPromise]);
+				} else result = await executeWithRetry(args, retryCount);
+				if (!abortController.signal.aborted) {
+					_state.data = result;
+					_state.error = null;
+					_state.loading = false;
+					notify();
+					successPubSub.publish(result);
+				}
+				return result;
+			} catch (error) {
+				if (!abortController.signal.aborted) {
+					const err = error instanceof Error ? error : new Error(String(error));
+					_state.error = err;
+					_state.loading = false;
+					notify();
+					errorPubSub.publish(err);
+				}
+				throw error;
+			}
+		};
+		const reset = () => {
+			if (abortController) {
+				abortController.abort();
+				abortController = null;
+			}
+			_state.data = null;
+			_state.error = null;
+			_state.loading = false;
+			_state.executionCount = 0;
+			_state.lastExecutedAt = null;
+			notify();
+		};
+		const abort = () => {
+			if (abortController) {
+				abortController.abort();
+				abortController = null;
+			}
+			if (_state.loading) {
+				_state.loading = false;
+				_state.error = /* @__PURE__ */ new Error("Aborted");
+				notify();
+			}
+		};
+		return {
+			get state() {
+				return { ..._state };
+			},
+			execute,
+			reset,
+			abort,
+			subscribe: (callback) => statePubSub.subscribe(callback),
+			onSuccess: (callback) => successPubSub.subscribe(callback),
+			onError: (callback) => errorPubSub.subscribe(callback)
+		};
+	}
+	//#endregion
+	//#region src/core/event-bus.ts
+	function createEventBus() {
+		const listeners = /* @__PURE__ */ new Map();
+		const getListeners = (type) => {
+			let set = listeners.get(type);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				listeners.set(type, set);
+			}
+			return set;
+		};
+		const on = (type, listener) => {
+			const set = getListeners(type);
+			set.add(listener);
+			return () => {
+				set.delete(listener);
+				if (set.size === 0) listeners.delete(type);
+			};
+		};
+		const off = (type, listener) => {
+			if (listener) {
+				const set = listeners.get(type);
+				if (set) {
+					set.delete(listener);
+					if (set.size === 0) listeners.delete(type);
+				}
+			} else listeners.delete(type);
+		};
+		const once = (type, listener) => {
+			const wrappedListener = (data) => {
+				listener(data);
+				off(type, wrappedListener);
+			};
+			return on(type, wrappedListener);
+		};
+		const emit = (type, payload) => {
+			const data = {
+				type,
+				payload,
+				timestamp: Date.now()
+			};
+			const typeListeners = listeners.get(type);
+			if (typeListeners) typeListeners.forEach((listener) => listener(data));
+			const wildcardListeners = listeners.get("*");
+			if (wildcardListeners) wildcardListeners.forEach((listener) => listener(data));
+		};
+		const clear = () => {
+			listeners.clear();
+		};
+		return {
+			on,
+			once,
+			off,
+			emit,
+			clear
+		};
+	}
+	const globalEventBus = createEventBus();
+	//#endregion
+	//#region src/core/base-store.ts
+	function isPromiseLike(value) {
+		return !!value && typeof value.then === "function";
+	}
+	async function runCallbacks(callbacks, value) {
+		for (const callback of callbacks) await callback(value);
+	}
+	var BaseStore = class {
+		/**
+		* 构造函数
+		*
+		* @param definition - Store 定义
+		* @param _options - Store 配置选项
+		*/
+		constructor(definition, _options = {}) {
+			/** 状态订阅管理器 */
+			this.stateSubscribers = createPubSub();
+			/** Action 订阅管理器 */
+			this.actionSubscribers = createPubSub();
+			/** 是否已销毁 */
+			this.disposed = false;
+			this.$id = definition.id;
+			this.initialStateFactory = definition.state;
+			this._state = definition.state();
+			this.getters = this.createGetters(definition.getters || {});
+			this.actions = this.createActions(definition.actions || {});
+			globalEventBus.emit("store:created", { storeId: this.$id });
+		}
+		/**
+		* 获取当前状态
+		*/
+		get $state() {
+			return this._state;
+		}
+		/**
+		* 设置状态
+		*/
+		set $state(newState) {
+			this._state = newState;
+		}
+		/**
+		* 重置状态到初始值
+		*/
+		$reset() {
+			this.checkDisposed();
+			const oldState = { ...this._state };
+			this._state = this.initialStateFactory();
+			this.notifyStateChange({
+				type: "direct",
+				storeId: this.$id,
+				oldState
+			});
+		}
+		/**
+		* 批量更新状态
+		*/
+		$patch(partialState) {
+			this.checkDisposed();
+			const oldState = { ...this._state };
+			if (typeof partialState === "function") {
+				partialState(this._state);
+				this.notifyStateChange({
+					type: "patch function",
+					storeId: this.$id,
+					oldState
+				});
+			} else {
+				Object.assign(this._state, partialState);
+				this.notifyStateChange({
+					type: "patch object",
+					storeId: this.$id,
+					oldState,
+					events: Object.keys(partialState)
+				});
+			}
+		}
+		/**
+		* 订阅状态变化
+		*/
+		$subscribe(callback, options = {}) {
+			this.checkDisposed();
+			return this.stateSubscribers.subscribe(({ mutation, state }) => callback(mutation, state), { immediate: options.immediate });
+		}
+		/**
+		* 订阅 Action 调用
+		*/
+		$onAction(callback) {
+			this.checkDisposed();
+			return this.actionSubscribers.subscribe(callback);
+		}
+		/**
+		* 销毁 Store
+		*/
+		$dispose() {
+			if (this.disposed) return;
+			this.disposed = true;
+			this.stateSubscribers.clear();
+			this.actionSubscribers.clear();
+			globalEventBus.emit("store:disposed", { storeId: this.$id });
+		}
+		/**
+		* 通知状态变化
+		*/
+		notifyStateChange(mutation) {
+			this.stateSubscribers.publish({
+				mutation,
+				state: this._state
+			});
+			globalEventBus.emit("state:changed", {
+				storeId: this.$id,
+				state: this._state,
+				mutation
+			});
+		}
+		/**
+		* 通知 Action 调用
+		*/
+		notifyAction(context) {
+			this.actionSubscribers.publish(context);
+		}
+		/**
+		* 检查是否已销毁
+		*/
+		checkDisposed() {
+			if (this.disposed) throw new Error(`[Store] Store "${this.$id}" \u5DF2\u88AB\u9500\u6BC1`);
+		}
+		createGetters(gettersDefinition) {
+			const getterCache = {};
+			for (const key of Object.keys(gettersDefinition)) Object.defineProperty(getterCache, key, {
+				enumerable: true,
+				get: () => gettersDefinition[key](this._state)
+			});
+			return getterCache;
+		}
+		createActions(actionsDefinition) {
+			const actionCache = {};
+			for (const key of Object.keys(actionsDefinition)) {
+				const action = actionsDefinition[key];
+				actionCache[key] = ((...args) => {
+					this.checkDisposed();
+					const afterCallbacks = [];
+					const errorCallbacks = [];
+					const context = {
+						after: (callback) => afterCallbacks.push(callback),
+						args,
+						name: key,
+						onError: (callback) => errorCallbacks.push(callback),
+						storeId: this.$id
+					};
+					this.notifyAction(context);
+					try {
+						const result = action.apply(this, args);
+						if (isPromiseLike(result)) return result.then(async (resolvedResult) => {
+							await runCallbacks(afterCallbacks, resolvedResult);
+							return resolvedResult;
+						}).catch(async (error) => {
+							await runCallbacks(errorCallbacks, error);
+							throw error;
+						});
+						runCallbacks(afterCallbacks, result);
+						return result;
+					} catch (error) {
+						runCallbacks(errorCallbacks, error);
+						throw error;
+					}
+				});
+			}
+			return actionCache;
+		}
+	};
+	//#endregion
+	//#region src/core/batch-manager.ts
+	function createBatchManager(onFlush) {
+		let batchDepth = 0;
+		const pendingStores = /* @__PURE__ */ new Set();
+		const flush = () => {
+			if (pendingStores.size > 0) {
+				const stores = new Set(pendingStores);
+				pendingStores.clear();
+				onFlush?.(stores);
+			}
+		};
+		const start = () => {
+			batchDepth++;
+		};
+		const end = () => {
+			if (batchDepth === 0) return;
+			batchDepth--;
+			if (batchDepth === 0) flush();
+		};
+		const markDirty = (storeId) => {
+			pendingStores.add(storeId);
+			if (batchDepth === 0) flush();
+		};
+		const batch2 = (fn) => {
+			start();
+			try {
+				return fn();
+			} finally {
+				end();
+			}
+		};
+		const isBatching = () => batchDepth > 0;
+		return {
+			start,
+			end,
+			markDirty,
+			batch: batch2,
+			isBatching
+		};
+	}
+	let globalBatchManager = null;
+	function getGlobalBatchManager() {
+		if (!globalBatchManager) globalBatchManager = createBatchManager();
+		return globalBatchManager;
+	}
+	function setGlobalBatchManager(manager) {
+		globalBatchManager = manager;
+	}
+	function batch(fn) {
+		return getGlobalBatchManager().batch(fn);
+	}
+	//#endregion
+	//#region src/core/create-store.ts
+	function createStore(definition) {
+		let instance = null;
+		return () => {
+			if (instance) return instance;
+			const store = new BaseStore(definition);
+			const originalDispose = store.$dispose.bind(store);
+			store.$dispose = () => {
+				originalDispose();
+				instance = null;
+			};
+			instance = store;
+			return store;
+		};
+	}
+	//#endregion
+	//#region src/engine/plugin.ts
+	const storeStateKeys = {
+		BUS: "store:bus",
+		PINIA: "store:pinia",
+		API: "store:api",
+		REGISTRY: "store:registry",
+		RUNTIME: "store:runtime"
+	};
+	const storeEventKeys = {
+		INSTALLED: "store:installed",
+		UNINSTALLED: "store:uninstalled"
+	};
+	function resolveEngine(context) {
+		const value = context;
+		if (value && typeof value === "object" && "engine" in value) return value.engine ?? {};
+		return value ?? {};
+	}
+	function resolvePluginContext(context) {
+		return context && typeof context === "object" ? context : void 0;
+	}
+	function resolveDefaultApp(engine, context, payload) {
+		const payloadObject = payload;
+		return payloadObject?.app ?? payloadObject?.framework?.app ?? engine.getApp?.() ?? context?.framework?.app;
+	}
+	function createRegisteredApi(name, version, runtime) {
+		return {
+			name,
+			version,
+			pinia: runtime.pinia,
+			getStore: runtime.storeAPI.getStore,
+			hasStore: runtime.storeAPI.hasStore,
+			getStoreIds: runtime.storeAPI.getStoreIds,
+			resetAll: runtime.storeAPI.resetAll
+		};
+	}
+	function registerEngineApi(engine, name, version, runtime) {
+		if (!engine.api?.register) return;
+		const api = createRegisteredApi(name, version, runtime);
+		engine.api.unregister?.(name);
+		if (engine.api.register.length >= 2) {
+			engine.api.register(name, api);
+			return;
+		}
+		engine.api.register(api);
+	}
+	function syncEngineState(engine, name, options, runtime) {
+		engine.state?.set?.(storeStateKeys.RUNTIME, runtime);
+		engine.state?.set?.(storeStateKeys.PINIA, runtime.pinia);
+		engine.state?.set?.(storeStateKeys.API, runtime.storeAPI);
+		engine.state?.set?.(storeStateKeys.REGISTRY, runtime.registry);
+		engine.state?.set?.(storeStateKeys.BUS, globalEventBus);
+		engine.state?.set?.(`plugins.${name}`, runtime.storeAPI);
+		engine.state?.set?.(`plugins.${name}.config`, options);
+	}
+	function clearEngineState(engine, name) {
+		engine.state?.delete?.(storeStateKeys.RUNTIME);
+		engine.state?.delete?.(storeStateKeys.PINIA);
+		engine.state?.delete?.(storeStateKeys.API);
+		engine.state?.delete?.(storeStateKeys.REGISTRY);
+		engine.state?.delete?.(storeStateKeys.BUS);
+		engine.state?.delete?.(`plugins.${name}`);
+		engine.state?.delete?.(`plugins.${name}.config`);
+	}
+	function registerContainerServices(context, runtime) {
+		if (!context?.container?.singleton) return;
+		try {
+			context.container.singleton("pinia", runtime.pinia);
+			context.container.singleton("storeAPI", runtime.storeAPI);
+			context.container.singleton("storeRegistry", runtime.registry);
+			context.container.singleton("storeRuntime", runtime);
+		} catch {}
+	}
+	function createStoreEngineBridge(options) {
+		const { createRuntime, debug = false, name = "store", onRuntimeChange, version = "1.0.0" } = options;
+		let activeEngine = {};
+		let activeContext;
+		let runtime = null;
+		let runtimeOwner = null;
+		const bindRuntime = (nextRuntime, owner) => {
+			const previousRuntime = runtime;
+			const previousOwner = runtimeOwner;
+			runtime = nextRuntime;
+			runtimeOwner = owner;
+			onRuntimeChange?.(nextRuntime);
+			syncEngineState(activeEngine, name, options, nextRuntime);
+			registerEngineApi(activeEngine, name, version, nextRuntime);
+			registerContainerServices(activeContext, nextRuntime);
+			if (previousRuntime && previousRuntime !== nextRuntime && previousOwner === "engine") previousRuntime.dispose?.();
+			return nextRuntime;
+		};
+		const ensureRuntime = () => {
+			if (runtime && runtimeOwner === "engine") return runtime;
+			return createRuntime();
+		};
+		const attachToApp = (app) => {
+			const installedRuntime = options.getRuntimeFromApp?.(app);
+			if (installedRuntime) return bindRuntime(installedRuntime, "external");
+			const nextRuntime = ensureRuntime();
+			const mountedRuntime = options.attachToApp ? options.attachToApp(app, nextRuntime) : nextRuntime;
+			return bindRuntime(mountedRuntime, mountedRuntime === nextRuntime ? "engine" : "external");
+		};
+		const install = async (context) => {
+			activeEngine = resolveEngine(context);
+			activeContext = resolvePluginContext(context);
+			const app = options.resolveApp ? options.resolveApp(activeEngine, activeContext ?? {}, void 0) : resolveDefaultApp(activeEngine, activeContext);
+			if (app && (!options.isApp || options.isApp(app))) attachToApp(app);
+			else {
+				bindRuntime(ensureRuntime(), "engine");
+				activeEngine.events?.once?.("app:created", (payload) => {
+					const createdApp = options.resolveApp ? options.resolveApp(activeEngine, activeContext ?? {}, payload) : resolveDefaultApp(activeEngine, activeContext, payload);
+					if (createdApp && (!options.isApp || options.isApp(createdApp))) attachToApp(createdApp);
+				});
+			}
+			await activeEngine.events?.emit?.(storeEventKeys.INSTALLED, {
+				name,
+				version,
+				pinia: runtime?.pinia,
+				storeAPI: runtime?.storeAPI
+			});
+			if (debug) activeEngine.logger?.info?.("[StoreEngineBridge] installed");
+		};
+		const uninstall = async (context) => {
+			const engine = context ? resolveEngine(context) : activeEngine;
+			engine.api?.unregister?.(name);
+			clearEngineState(engine, name);
+			await engine.events?.emit?.(storeEventKeys.UNINSTALLED, { name });
+			if (runtime && runtimeOwner === "engine") runtime.dispose?.();
+			runtime = null;
+			runtimeOwner = null;
+			onRuntimeChange?.(null);
+			if (debug) engine.logger?.info?.("[StoreEngineBridge] uninstalled");
+		};
+		return {
+			attachToApp,
+			getRuntime: () => runtime,
+			install,
+			uninstall
+		};
+	}
+	//#endregion
+	//#region src/errors/index.ts
+	var StoreErrorCode = /* @__PURE__ */ ((StoreErrorCode2) => {
+		StoreErrorCode2["STORE_DISPOSED"] = "STORE_DISPOSED";
+		StoreErrorCode2["STORE_NOT_FOUND"] = "STORE_NOT_FOUND";
+		StoreErrorCode2["STORE_ALREADY_EXISTS"] = "STORE_ALREADY_EXISTS";
+		StoreErrorCode2["INVALID_STATE"] = "INVALID_STATE";
+		StoreErrorCode2["INVALID_ACTION"] = "INVALID_ACTION";
+		StoreErrorCode2["SERIALIZATION_ERROR"] = "SERIALIZATION_ERROR";
+		StoreErrorCode2["DESERIALIZATION_ERROR"] = "DESERIALIZATION_ERROR";
+		StoreErrorCode2["STORAGE_ERROR"] = "STORAGE_ERROR";
+		StoreErrorCode2["PLUGIN_ERROR"] = "PLUGIN_ERROR";
+		StoreErrorCode2["MIDDLEWARE_ERROR"] = "MIDDLEWARE_ERROR";
+		StoreErrorCode2["SUBSCRIPTION_ERROR"] = "SUBSCRIPTION_ERROR";
+		StoreErrorCode2["TIMEOUT_ERROR"] = "TIMEOUT_ERROR";
+		StoreErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+		return StoreErrorCode2;
+	})(StoreErrorCode || {});
+	var ErrorSeverity = /* @__PURE__ */ ((ErrorSeverity2) => {
+		ErrorSeverity2["WARNING"] = "warning";
+		ErrorSeverity2["ERROR"] = "error";
+		ErrorSeverity2["FATAL"] = "fatal";
+		return ErrorSeverity2;
+	})(ErrorSeverity || {});
+	var StoreError = class StoreError extends Error {
+		/**
+		* 创建 Store 错误
+		*
+		* @param message - 错误消息
+		* @param code - 错误代码
+		* @param context - 错误上下文
+		* @param severity - 错误严重级别
+		* @param cause - 原始错误
+		*/
+		constructor(message, code = "UNKNOWN_ERROR", context = {}, severity = "error", cause) {
+			super(message);
+			this.name = "StoreError";
+			this.code = code;
+			this.context = {
+				...context,
+				timestamp: context.timestamp ?? Date.now()
+			};
+			this.severity = severity;
+			this.cause = cause;
+			Object.setPrototypeOf(this, StoreError.prototype);
+			if (Error.captureStackTrace) Error.captureStackTrace(this, StoreError);
+		}
+		/**
+		* 转换为 JSON
+		*/
+		toJSON() {
+			return {
+				name: this.name,
+				message: this.message,
+				code: this.code,
+				context: this.context,
+				severity: this.severity,
+				stack: this.stack
+			};
+		}
+		/**
+		* 格式化错误信息
+		*/
+		format() {
+			const parts = [`[${this.code}] ${this.message}`];
+			if (this.context.storeId) parts.push(`Store: ${this.context.storeId}`);
+			if (this.context.action) parts.push(`Action: ${this.context.action}`);
+			return parts.join(" | ");
+		}
+	};
+	var StoreDisposedError = class StoreDisposedError extends StoreError {
+		constructor(storeId, action) {
+			super(`Store "${storeId}" \u5DF2\u88AB\u9500\u6BC1\uFF0C\u65E0\u6CD5\u6267\u884C\u64CD\u4F5C${action ? `: ${action}` : ""}`, "STORE_DISPOSED", {
+				storeId,
+				action
+			}, "error");
+			this.name = "StoreDisposedError";
+			Object.setPrototypeOf(this, StoreDisposedError.prototype);
+		}
+	};
+	var StoreNotFoundError = class StoreNotFoundError extends StoreError {
+		constructor(storeId) {
+			super(`Store "${storeId}" \u4E0D\u5B58\u5728`, "STORE_NOT_FOUND", { storeId }, "error");
+			this.name = "StoreNotFoundError";
+			Object.setPrototypeOf(this, StoreNotFoundError.prototype);
+		}
+	};
+	var StoreAlreadyExistsError = class StoreAlreadyExistsError extends StoreError {
+		constructor(storeId) {
+			super(`Store "${storeId}" \u5DF2\u5B58\u5728`, "STORE_ALREADY_EXISTS", { storeId }, "warning");
+			this.name = "StoreAlreadyExistsError";
+			Object.setPrototypeOf(this, StoreAlreadyExistsError.prototype);
+		}
+	};
+	var InvalidStateError = class InvalidStateError extends StoreError {
+		constructor(message, storeId, data) {
+			super(message, "INVALID_STATE", {
+				storeId,
+				data
+			}, "error");
+			this.name = "InvalidStateError";
+			Object.setPrototypeOf(this, InvalidStateError.prototype);
+		}
+	};
+	var SerializationError = class SerializationError extends StoreError {
+		constructor(message, cause, storeId) {
+			super(message, "SERIALIZATION_ERROR", { storeId }, "error", cause);
+			this.name = "SerializationError";
+			Object.setPrototypeOf(this, SerializationError.prototype);
+		}
+	};
+	var DeserializationError = class DeserializationError extends StoreError {
+		constructor(message, cause, storeId) {
+			super(message, "DESERIALIZATION_ERROR", { storeId }, "error", cause);
+			this.name = "DeserializationError";
+			Object.setPrototypeOf(this, DeserializationError.prototype);
+		}
+	};
+	var StorageError = class StorageError extends StoreError {
+		constructor(message, cause, storeId) {
+			super(message, "STORAGE_ERROR", { storeId }, "error", cause);
+			this.name = "StorageError";
+			Object.setPrototypeOf(this, StorageError.prototype);
+		}
+	};
+	var PluginError = class PluginError extends StoreError {
+		constructor(message, pluginName, cause) {
+			super(message, "PLUGIN_ERROR", { plugin: pluginName }, "error", cause);
+			this.name = "PluginError";
+			Object.setPrototypeOf(this, PluginError.prototype);
+		}
+	};
+	var MiddlewareError = class MiddlewareError extends StoreError {
+		constructor(message, middlewareName, cause) {
+			super(message, "MIDDLEWARE_ERROR", { middleware: middlewareName }, "error", cause);
+			this.name = "MiddlewareError";
+			Object.setPrototypeOf(this, MiddlewareError.prototype);
+		}
+	};
+	var SubscriptionError = class SubscriptionError extends StoreError {
+		constructor(message, cause, storeId) {
+			super(message, "SUBSCRIPTION_ERROR", { storeId }, "warning", cause);
+			this.name = "SubscriptionError";
+			Object.setPrototypeOf(this, SubscriptionError.prototype);
+		}
+	};
+	var TimeoutError = class TimeoutError extends StoreError {
+		constructor(message, storeId, action) {
+			super(message, "TIMEOUT_ERROR", {
+				storeId,
+				action
+			}, "error");
+			this.name = "TimeoutError";
+			Object.setPrototypeOf(this, TimeoutError.prototype);
+		}
+	};
+	const errorUtils = {
+		/**
+		* 判断是否为 Store 错误
+		*/
+		isStoreError(error) {
+			return error instanceof StoreError;
+		},
+		/**
+		* 判断是否为特定类型的错误
+		*/
+		isErrorCode(error, code) {
+			return error instanceof StoreError && error.code === code;
+		},
+		/**
+		* 包装错误为 Store 错误
+		*/
+		wrap(error, code = "UNKNOWN_ERROR", context = {}) {
+			if (error instanceof StoreError) return error;
+			return new StoreError(error instanceof Error ? error.message : String(error), code, context, "error", error instanceof Error ? error : void 0);
+		},
+		/**
+		* 安全执行函数，捕获并包装错误
+		*/
+		async tryCatch(fn, code = "UNKNOWN_ERROR", context = {}) {
+			try {
+				return await fn();
+			} catch (error) {
+				throw errorUtils.wrap(error, code, context);
+			}
+		},
+		/**
+		* 创建错误日志记录器
+		*/
+		createLogger(prefix) {
+			return {
+				error(error) {
+					console.error(`[${prefix}]`, error.format());
+					if (error.cause) console.error(`[${prefix}] Caused by:`, error.cause);
+				},
+				warn(error) {
+					console.warn(`[${prefix}]`, error.format());
+				},
+				log(error) {
+					if (error.severity === "fatal" || error.severity === "error") this.error(error);
+					else this.warn(error);
+				}
+			};
+		}
+	};
+	//#endregion
+	//#region src/utils/debounce-throttle.ts
+	function debounce(fn, delay, immediate = false) {
+		let timer = null;
+		let lastArgs = null;
+		const debounced = ((...args) => {
+			lastArgs = args;
+			if (timer) clearTimeout(timer);
+			if (immediate && !timer) {
+				fn(...args);
+				timer = setTimeout(() => {
+					timer = null;
+					lastArgs = null;
+				}, delay);
+			} else timer = setTimeout(() => {
+				fn(...args);
+				timer = null;
+				lastArgs = null;
+			}, delay);
+		});
+		debounced.cancel = () => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+				lastArgs = null;
+			}
+		};
+		debounced.flush = () => {
+			if (timer && lastArgs) {
+				clearTimeout(timer);
+				fn(...lastArgs);
+				timer = null;
+				lastArgs = null;
+			}
+		};
+		debounced.pending = () => timer !== null;
+		return debounced;
+	}
+	function throttle(fn, interval, options = {}) {
+		const { leading = true, trailing = true } = options;
+		let timer = null;
+		let lastTime = 0;
+		let lastArgs = null;
+		const throttled = ((...args) => {
+			const now = Date.now();
+			const remaining = interval - (now - lastTime);
+			lastArgs = args;
+			if (remaining <= 0 || remaining > interval) {
+				if (timer) {
+					clearTimeout(timer);
+					timer = null;
+				}
+				lastTime = now;
+				if (leading || lastTime !== 0) fn(...args);
+				lastArgs = null;
+			} else if (!timer && trailing) timer = setTimeout(() => {
+				lastTime = trailing ? Date.now() : 0;
+				timer = null;
+				if (lastArgs) {
+					fn(...lastArgs);
+					lastArgs = null;
+				}
+			}, remaining);
+		});
+		throttled.cancel = () => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			lastTime = 0;
+			lastArgs = null;
+		};
+		return throttled;
+	}
+	//#endregion
+	//#region src/utils/deep-clone.ts
+	const hasOwnProperty = Object.prototype.hasOwnProperty;
+	function hasOwnKey(value, key) {
+		return hasOwnProperty.call(value, key);
+	}
+	function isObject(value) {
+		return value !== null && typeof value === "object";
+	}
+	function isPlainObject(value) {
+		if (!isObject(value)) return false;
+		const proto = Object.getPrototypeOf(value);
+		return proto === null || proto === Object.prototype;
+	}
+	function isStructuredCloneable(value) {
+		if (value === null || value === void 0) return true;
+		if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") return true;
+		if (typeof value === "bigint") return true;
+		if (typeof value === "function" || typeof value === "symbol") return false;
+		if (value instanceof Date || value instanceof RegExp) return true;
+		if (value instanceof ArrayBuffer || value instanceof DataView) return true;
+		if (value instanceof Map || value instanceof Set) return true;
+		if (ArrayBuffer.isView(value)) return true;
+		if (Array.isArray(value)) return value.every((item) => isStructuredCloneable(item));
+		if (isPlainObject(value)) return Object.values(value).every((v) => isStructuredCloneable(v));
+		return false;
+	}
+	function deepClone(value, options = {}) {
+		const { useStructuredClone: preferStructuredClone = true, cloneFunctions = false, cloneSymbols = false, maxDepth = Infinity, customCloner } = options;
+		if (preferStructuredClone && typeof structuredClone === "function" && isStructuredCloneable(value)) try {
+			return structuredClone(value);
+		} catch {}
+		const cache = /* @__PURE__ */ new WeakMap();
+		function cloneInternal(val, depth) {
+			if (val === null || val === void 0) return val;
+			if (typeof val === "boolean" || typeof val === "number" || typeof val === "string") return val;
+			if (typeof val === "bigint") return val;
+			if (typeof val === "symbol") return cloneSymbols ? Symbol(val.description) : val;
+			if (typeof val === "function") return cloneFunctions ? val.bind({}) : val;
+			if (depth > maxDepth) return val;
+			if (customCloner) {
+				const customResult = customCloner(val, (v) => cloneInternal(v, depth + 1));
+				if (customResult !== void 0) return customResult;
+			}
+			if (typeof val === "object" && val !== null) {
+				if (cache.has(val)) return cache.get(val);
+			}
+			if (val instanceof Date) return new Date(val.getTime());
+			if (val instanceof RegExp) {
+				const result = new RegExp(val.source, val.flags);
+				result.lastIndex = val.lastIndex;
+				return result;
+			}
+			if (val instanceof Error) {
+				const result = new val.constructor(val.message);
+				result.stack = val.stack;
+				result.name = val.name;
+				return result;
+			}
+			if (val instanceof Map) {
+				const result = /* @__PURE__ */ new Map();
+				cache.set(val, result);
+				val.forEach((v, k) => {
+					result.set(cloneInternal(k, depth + 1), cloneInternal(v, depth + 1));
+				});
+				return result;
+			}
+			if (val instanceof Set) {
+				const result = /* @__PURE__ */ new Set();
+				cache.set(val, result);
+				val.forEach((v) => {
+					result.add(cloneInternal(v, depth + 1));
+				});
+				return result;
+			}
+			if (val instanceof ArrayBuffer) return val.slice(0);
+			if (ArrayBuffer.isView(val) && !(val instanceof DataView)) {
+				const TypedArrayConstructor = val.constructor;
+				return new TypedArrayConstructor(val.buffer.slice(0));
+			}
+			if (Array.isArray(val)) {
+				const result = [];
+				cache.set(val, result);
+				for (let i = 0; i < val.length; i++) result[i] = cloneInternal(val[i], depth + 1);
+				return result;
+			}
+			if (isPlainObject(val)) {
+				const result = {};
+				cache.set(val, result);
+				const keys = Object.keys(val);
+				for (const key of keys) result[key] = cloneInternal(val[key], depth + 1);
+				if (cloneSymbols) {
+					const symbolKeys = Object.getOwnPropertySymbols(val);
+					for (const sym of symbolKeys) result[sym] = cloneInternal(val[sym], depth + 1);
+				}
+				return result;
+			}
+			return val;
+		}
+		return cloneInternal(value, 0);
+	}
+	function shallowClone(value) {
+		if (value === null || value === void 0) return value;
+		if (typeof value !== "object") return value;
+		if (Array.isArray(value)) return [...value];
+		if (value instanceof Map) return new Map(value);
+		if (value instanceof Set) return new Set(value);
+		if (value instanceof Date) return new Date(value.getTime());
+		return { ...value };
+	}
+	function deepMerge(target, ...sources) {
+		return deepMergeWithOptions(target, {}, ...sources);
+	}
+	function deepMergeWithOptions(target, options, ...sources) {
+		const { arrayStrategy = "replace", clone = true, maxDepth = Infinity } = options;
+		function mergeInternal(targetObj, sourceObj, depth) {
+			if (depth > maxDepth) return targetObj;
+			for (const key of Object.keys(sourceObj)) {
+				const sourceValue = sourceObj[key];
+				const targetValue = targetObj[key];
+				if (Array.isArray(sourceValue)) if (arrayStrategy === "concat" && Array.isArray(targetValue)) targetObj[key] = [...targetValue, ...sourceValue];
+				else if (arrayStrategy === "merge" && Array.isArray(targetValue)) {
+					const result2 = [...targetValue];
+					sourceValue.forEach((item, index) => {
+						if (isPlainObject(item) && isPlainObject(result2[index])) result2[index] = mergeInternal(result2[index], item, depth + 1);
+						else result2[index] = clone ? deepClone(item) : item;
+					});
+					targetObj[key] = result2;
+				} else targetObj[key] = clone ? deepClone(sourceValue) : sourceValue;
+				else if (isPlainObject(sourceValue)) if (isPlainObject(targetValue)) targetObj[key] = mergeInternal(targetValue, sourceValue, depth + 1);
+				else targetObj[key] = clone ? deepClone(sourceValue) : sourceValue;
+				else targetObj[key] = clone && isObject(sourceValue) ? deepClone(sourceValue) : sourceValue;
+			}
+			return targetObj;
+		}
+		let result = target;
+		for (const source of sources) if (source !== null && source !== void 0) result = mergeInternal(result, source, 0);
+		return result;
+	}
+	function deepEqual(a, b) {
+		if (a === b) return true;
+		if (a === null || b === null || a === void 0 || b === void 0) return a === b;
+		if (typeof a !== typeof b) return false;
+		if (typeof a !== "object") return a === b;
+		if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+		if (a instanceof RegExp && b instanceof RegExp) return a.source === b.source && a.flags === b.flags;
+		if (a instanceof Map && b instanceof Map) {
+			if (a.size !== b.size) return false;
+			for (const [key, value] of a) if (!b.has(key) || !deepEqual(value, b.get(key))) return false;
+			return true;
+		}
+		if (a instanceof Set && b instanceof Set) {
+			if (a.size !== b.size) return false;
+			for (const value of a) if (!b.has(value)) return false;
+			return true;
+		}
+		if (Array.isArray(a) && Array.isArray(b)) {
+			if (a.length !== b.length) return false;
+			for (let i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i])) return false;
+			return true;
+		}
+		if (isPlainObject(a) && isPlainObject(b)) {
+			const keysA = Object.keys(a);
+			const keysB = Object.keys(b);
+			if (keysA.length !== keysB.length) return false;
+			for (const key of keysA) {
+				if (!hasOwnKey(b, key)) return false;
+				if (!deepEqual(a[key], b[key])) return false;
+			}
+			return true;
+		}
+		return false;
+	}
+	function deepFreeze(obj) {
+		const propNames = Object.getOwnPropertyNames(obj);
+		for (const name of propNames) {
+			const value = obj[name];
+			if (value && typeof value === "object") deepFreeze(value);
+		}
+		return Object.freeze(obj);
+	}
+	//#endregion
+	//#region src/utils/selector.ts
+	const ARRAY_INDEX_RE = /^\d+$/;
+	function createSelector(selector, equalityFn = Object.is) {
+		let lastState;
+		let lastResult;
+		let initialized = false;
+		return (state) => {
+			if (initialized && lastState === state) return lastResult;
+			const result = selector(state);
+			if (!initialized || !equalityFn(result, lastResult)) lastResult = result;
+			lastState = state;
+			initialized = true;
+			return lastResult;
+		};
+	}
+	function createSelectorWithDeps(dependencies, combiner, options = {}) {
+		const { equalityFn = Object.is, trackHitRate = false } = options;
+		let lastDeps;
+		let lastResult;
+		let initialized = false;
+		let hits = 0;
+		let calls = 0;
+		const selector = (state) => {
+			if (trackHitRate) calls++;
+			const deps = dependencies.map((dep) => dep(state));
+			if (initialized && lastDeps) {
+				let changed = false;
+				for (let i = 0; i < deps.length; i++) if (!Object.is(deps[i], lastDeps[i])) {
+					changed = true;
+					break;
+				}
+				if (!changed) {
+					if (trackHitRate) hits++;
+					return lastResult;
+				}
+			}
+			const result = combiner(...deps);
+			if (!initialized || !equalityFn(result, lastResult)) lastResult = result;
+			lastDeps = deps;
+			initialized = true;
+			return lastResult;
+		};
+		if (trackHitRate) selector.getHitRate = () => {
+			return calls > 0 ? hits / calls : 0;
+		};
+		return selector;
+	}
+	function combineSelectors(selectors, combiner) {
+		return (state) => {
+			return combiner(...selectors.map((selector) => selector(state)));
+		};
+	}
+	function createCachedSelector(selector, options = {}) {
+		const { maxSize = 10 } = options;
+		const cache = /* @__PURE__ */ new Map();
+		const memoizedSelector = (state) => {
+			if (cache.has(state)) {
+				const cached = cache.get(state);
+				cache.delete(state);
+				cache.set(state, cached);
+				return cached;
+			}
+			const result = selector(state);
+			if (cache.size >= maxSize) {
+				const firstKey = cache.keys().next().value;
+				if (firstKey !== void 0) cache.delete(firstKey);
+			}
+			cache.set(state, result);
+			return result;
+		};
+		memoizedSelector.clearCache = () => cache.clear();
+		memoizedSelector.getCacheSize = () => cache.size;
+		return memoizedSelector;
+	}
+	function createMemoizedSelector(selector, options = {}) {
+		return createSelector(selector, options.equalityFn);
+	}
+	function getByPath(obj, path, defaultValue) {
+		if (!path || path.length === 0) return obj;
+		const keys = path.replace(/\[([^\]]+)\]/g, ".$1").split(".").filter(Boolean);
+		let result = obj;
+		for (const key of keys) {
+			if (result === null || result === void 0) return defaultValue;
+			if (typeof result !== "object") return defaultValue;
+			result = result[key];
+		}
+		return result === void 0 ? defaultValue : result;
+	}
+	function setByPath(obj, path, value) {
+		if (!path || path.length === 0) return false;
+		const keys = path.replace(/\[([^\]]+)\]/g, ".$1").split(".").filter(Boolean);
+		let current = obj;
+		for (let i = 0; i < keys.length - 1; i++) {
+			const key = keys[i];
+			const nextKey = keys[i + 1] ?? "";
+			const nextValue = current[key] ?? (ARRAY_INDEX_RE.test(nextKey) ? [] : {});
+			current[key] = nextValue;
+			current = current[key];
+		}
+		const lastKey = keys[keys.length - 1];
+		current[lastKey] = value;
+		return true;
+	}
+	function deleteByPath(obj, path) {
+		if (!path || path.length === 0) return false;
+		const keys = path.replace(/\[([^\]]+)\]/g, ".$1").split(".").filter(Boolean);
+		let current = obj;
+		for (let i = 0; i < keys.length - 1; i++) {
+			const key = keys[i];
+			if (current[key] === void 0 || current[key] === null) return false;
+			current = current[key];
+		}
+		const lastKey = keys[keys.length - 1];
+		if (lastKey in current) {
+			if (Array.isArray(current)) {
+				const index = Number.parseInt(lastKey, 10);
+				if (!Number.isNaN(index)) {
+					current.splice(index, 1);
+					return true;
+				}
+			}
+			delete current[lastKey];
+			return true;
+		}
+		return false;
+	}
+	function hasPath(obj, path) {
+		if (!path || path.length === 0) return true;
+		const keys = path.replace(/\[([^\]]+)\]/g, ".$1").split(".").filter(Boolean);
+		let current = obj;
+		for (const key of keys) {
+			if (current === null || current === void 0) return false;
+			if (typeof current !== "object") return false;
+			if (!(key in current)) return false;
+			current = current[key];
+		}
+		return true;
+	}
+	//#endregion
+	//#region src/middleware/logger.ts
+	const defaultOptions$2 = {
+		logState: true,
+		logAction: true,
+		collapsed: true,
+		timestamp: true,
+		level: "log"
+	};
+	const LOG_COLORS = {
+		prevState: "color: #9E9E9E; font-weight: bold",
+		action: "color: #03A9F4; font-weight: bold",
+		nextState: "color: #4CAF50; font-weight: bold",
+		error: "color: #F44336; font-weight: bold",
+		duration: "color: #9C27B0; font-weight: normal",
+		title: "color: inherit; font-weight: bold"
+	};
+	function formatTime(date) {
+		return `${date.getHours().toString().padStart(2, "0")}:${date.getMinutes().toString().padStart(2, "0")}:${date.getSeconds().toString().padStart(2, "0")}.${date.getMilliseconds().toString().padStart(3, "0")}`;
+	}
+	function formatDuration(startTime, endTime) {
+		const duration = endTime - startTime;
+		if (duration < 1) return "< 1ms";
+		return `${duration.toFixed(2)}ms`;
+	}
+	function safeCloneState(state) {
+		try {
+			return deepClone(state);
+		} catch {
+			return { ...state };
+		}
+	}
+	function createLoggerMiddleware(options = {}) {
+		const opts = {
+			...defaultOptions$2,
+			...options
+		};
+		const logger = opts.logger ?? console;
+		return {
+			name: "logger",
+			priority: 0,
+			handler: async (context, next) => {
+				const { storeId, type, state, payload } = context;
+				if (opts.filter && !opts.filter(context)) {
+					await next();
+					return;
+				}
+				const isStateChange = type.startsWith("state:");
+				const isAction = type.startsWith("action:");
+				if (isStateChange && !opts.logState || isAction && !opts.logAction) {
+					await next();
+					return;
+				}
+				const timestamp = opts.timestamp ? formatTime(/* @__PURE__ */ new Date()) : "";
+				const prefix = `[Store: ${storeId}]`;
+				const startTime = performance.now();
+				const prevState = safeCloneState(state);
+				const groupTitle = timestamp ? `${timestamp} ${prefix} ${type}` : `${prefix} ${type}`;
+				const startGroup = () => {
+					if (opts.collapsed && typeof logger.groupCollapsed === "function") logger.groupCollapsed(`%c${groupTitle}`, LOG_COLORS.title);
+					else if (typeof logger.group === "function") logger.group(`%c${groupTitle}`, LOG_COLORS.title);
+				};
+				const endGroup = () => {
+					if (typeof logger.groupEnd === "function") logger.groupEnd();
+				};
+				startGroup();
+				try {
+					const logFn = logger[opts.level ?? "log"] ?? logger.log;
+					if (typeof logFn === "function") {
+						logFn.call(logger, "%c prev state", LOG_COLORS.prevState, prevState);
+						if (payload !== void 0) logFn.call(logger, "%c payload", LOG_COLORS.action, payload);
+					}
+					await next();
+					const endTime = performance.now();
+					if (typeof logFn === "function") {
+						logFn.call(logger, "%c next state", LOG_COLORS.nextState, safeCloneState(context.state));
+						logFn.call(logger, "%c duration", LOG_COLORS.duration, formatDuration(startTime, endTime));
+					}
+				} catch (error) {
+					if (typeof logger.error === "function") logger.error("%c error", LOG_COLORS.error, error);
+					throw new MiddlewareError(`\u65E5\u5FD7\u4E2D\u95F4\u4EF6\u6267\u884C\u9519\u8BEF: ${error instanceof Error ? error.message : String(error)}`, "logger", error instanceof Error ? error : void 0);
+				} finally {
+					endGroup();
+				}
+			}
+		};
+	}
+	function createSimpleLoggerMiddleware(options = {}) {
+		const { includePayload = true, format, filter } = options;
+		return {
+			name: "simple-logger",
+			priority: 0,
+			handler: async (context, next) => {
+				const { storeId, type, payload } = context;
+				if (filter && !filter(context)) {
+					await next();
+					return;
+				}
+				const message = format ? format(context) : `[Store: ${storeId}] ${type}`;
+				if (includePayload && payload !== void 0) console.info(message, payload);
+				else console.info(message);
+				await next();
+			}
+		};
+	}
+	//#endregion
+	//#region src/middleware/middleware-manager.ts
+	function createMiddlewareManager() {
+		const middlewares = /* @__PURE__ */ new Map();
+		let sortedMiddlewares = null;
+		const getSortedMiddlewares = () => {
+			if (sortedMiddlewares === null) sortedMiddlewares = Array.from(middlewares.values()).sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
+			return sortedMiddlewares;
+		};
+		const invalidateCache = () => {
+			sortedMiddlewares = null;
+		};
+		const use = (middleware) => {
+			if (middlewares.has(middleware.name)) console.warn(`[Middleware] \u4E2D\u95F4\u4EF6 "${middleware.name}" \u5DF2\u5B58\u5728\uFF0C\u5C06\u88AB\u8986\u76D6`);
+			middlewares.set(middleware.name, middleware);
+			invalidateCache();
+		};
+		const remove = (name) => {
+			if (middlewares.delete(name)) invalidateCache();
+		};
+		const get = (name) => {
+			return middlewares.get(name);
+		};
+		const has = (name) => {
+			return middlewares.has(name);
+		};
+		const execute = async (context) => {
+			const sorted = getSortedMiddlewares();
+			if (sorted.length === 0) return;
+			const dispatch = async (index) => {
+				const middleware = sorted[index];
+				if (!middleware) return;
+				let called = false;
+				const next = async () => {
+					if (called) throw new Error(`[Middleware] next() called multiple times in "${middleware.name}"`);
+					called = true;
+					await dispatch(index + 1);
+				};
+				await middleware.handler(context, next);
+			};
+			await dispatch(0);
+		};
+		const getAll = () => {
+			return getSortedMiddlewares();
+		};
+		const clear = () => {
+			middlewares.clear();
+			invalidateCache();
+		};
+		return {
+			use,
+			remove,
+			get,
+			has,
+			execute,
+			getAll,
+			clear
+		};
+	}
+	let globalMiddlewareManager = null;
+	function getGlobalMiddlewareManager() {
+		if (!globalMiddlewareManager) globalMiddlewareManager = createMiddlewareManager();
+		return globalMiddlewareManager;
+	}
+	function setGlobalMiddlewareManager(manager) {
+		globalMiddlewareManager = manager;
+	}
+	//#endregion
+	//#region src/middleware/persist.ts
+	const defaultOptions$1 = {
+		keyPrefix: "ldesign-store:",
+		storage: "localStorage",
+		debounce: 100,
+		serialize: JSON.stringify,
+		deserialize: JSON.parse
+	};
+	function resolveOptions(options) {
+		return {
+			...defaultOptions$1,
+			...options
+		};
+	}
+	function getStorage(type) {
+		if (typeof window === "undefined") return null;
+		return type === "localStorage" ? localStorage : sessionStorage;
+	}
+	function createPersistMiddleware(options = {}) {
+		const opts = resolveOptions(options);
+		const storage = getStorage(opts.storage);
+		const debouncedSave = /* @__PURE__ */ new Map();
+		const getKey = (storeId) => {
+			return `${opts.keyPrefix}${storeId}`;
+		};
+		const filterState = (storeId, state) => {
+			const paths = opts.paths?.[storeId];
+			if (!paths || paths.length === 0) return state;
+			const filtered = {};
+			for (const path of paths) {
+				const keys = path.split(".");
+				let source = state;
+				let target = filtered;
+				for (let i = 0; i < keys.length; i++) {
+					const key = keys[i];
+					if (i === keys.length - 1) target[key] = source?.[key];
+					else {
+						target[key] = target[key] || {};
+						target = target[key];
+						source = source?.[key];
+					}
+				}
+			}
+			return filtered;
+		};
+		const saveState = (storeId, state) => {
+			if (!storage) return;
+			try {
+				const filteredState = filterState(storeId, state);
+				const serialized = opts.serialize(filteredState);
+				storage.setItem(getKey(storeId), serialized);
+			} catch (error) {
+				console.error(`[Persist] \u4FDD\u5B58\u72B6\u6001\u5931\u8D25 (${storeId}):`, error);
+			}
+		};
+		const getDebouncedSave = (storeId) => {
+			let fn = debouncedSave.get(storeId);
+			if (!fn) {
+				fn = debounce((state) => saveState(storeId, state), opts.debounce);
+				debouncedSave.set(storeId, fn);
+			}
+			return fn;
+		};
+		return {
+			name: "persist",
+			priority: 100,
+			handler: async (context, next) => {
+				await next();
+				const { storeId, type, state } = context;
+				if (!type.startsWith("state:")) return;
+				if (opts.stores && !opts.stores.includes(storeId)) return;
+				getDebouncedSave(storeId)(state);
+			}
+		};
+	}
+	function restoreState(storeId, options = {}) {
+		const opts = resolveOptions(options);
+		const storage = getStorage(opts.storage);
+		if (!storage) return null;
+		try {
+			const key = `${opts.keyPrefix}${storeId}`;
+			const data = storage.getItem(key);
+			if (data) return opts.deserialize(data);
+		} catch (error) {
+			console.error(`[Persist] \u6062\u590D\u72B6\u6001\u5931\u8D25 (${storeId}):`, error);
+		}
+		return null;
+	}
+	//#endregion
+	//#region src/middleware/time-travel.ts
+	const defaultOptions = {
+		maxHistory: 100,
+		enabled: true
+	};
+	function createTimeTravelMiddleware(options = {}) {
+		const opts = {
+			...defaultOptions,
+			...options
+		};
+		const maxHistory = opts.maxHistory ?? defaultOptions.maxHistory ?? 100;
+		const history = [];
+		let currentIndex = -1;
+		let isTraveling = false;
+		let restoreCallback = () => {};
+		const addSnapshot = (snapshot) => {
+			if (!opts.enabled || isTraveling) return;
+			if (currentIndex < history.length - 1) history.splice(currentIndex + 1);
+			history.push(snapshot);
+			currentIndex = history.length - 1;
+			if (history.length > maxHistory) {
+				history.shift();
+				currentIndex--;
+			}
+		};
+		const controller = {
+			/**
+			* 撤销操作
+			* 将当前指针前移一步，恢复到上一个历史快照状态
+			*/
+			undo: () => {
+				if (!controller.canUndo()) return;
+				isTraveling = true;
+				currentIndex--;
+				const snapshot = history[currentIndex];
+				restoreCallback(snapshot.storeId, deepClone(snapshot.state));
+				isTraveling = false;
+			},
+			/**
+			* 重做操作
+			* 将当前指针后移一步，恢复到下一个历史快照状态
+			*/
+			redo: () => {
+				if (!controller.canRedo()) return;
+				isTraveling = true;
+				currentIndex++;
+				const snapshot = history[currentIndex];
+				restoreCallback(snapshot.storeId, deepClone(snapshot.state));
+				isTraveling = false;
+			},
+			/**
+			* 跳转到指定历史索引
+			* 将当前指针直接移动到指定位置，恢复对应的快照状态
+			*
+			* @param index - 目标历史索引（0-based）
+			*/
+			goto: (index) => {
+				if (index < 0 || index >= history.length) return;
+				isTraveling = true;
+				currentIndex = index;
+				const snapshot = history[currentIndex];
+				restoreCallback(snapshot.storeId, deepClone(snapshot.state));
+				isTraveling = false;
+			},
+			/**
+			* 获取完整的快照历史（返回深拷贝，防止外部修改内部历史记录）
+			* @returns 历史快照数组的深拷贝
+			*/
+			getHistory: () => deepClone(history),
+			/**
+			* 获取当前快照指针索引
+			* @returns 当前索引值，-1 表示无快照
+			*/
+			getCurrentIndex: () => currentIndex,
+			/**
+			* 判断是否可以撤销
+			* 当前索引大于 0 时，说明前面还有历史快照
+			* @returns 是否可以执行 undo 操作
+			*/
+			canUndo: () => currentIndex > 0,
+			/**
+			* 判断是否可以重做
+			* 当前索引小于历史长度 - 1 时，说明后面还有快照
+			* @returns 是否可以执行 redo 操作
+			*/
+			canRedo: () => currentIndex < history.length - 1,
+			/**
+			* 清除所有历史快照并重置指针
+			* 通常在 Store 销毁或需要重置历史时调用
+			*/
+			clear: () => {
+				history.length = 0;
+				currentIndex = -1;
+			}
+		};
+		controller.__setRestoreCallback = (callback) => {
+			restoreCallback = callback;
+		};
+		return {
+			middleware: {
+				name: "time-travel",
+				priority: 50,
+				/**
+				* 中间件处理函数
+				* 只拦截 "state:" 类型的操作（状态变更操作），其他类型直接放行
+				* 正在时间旅行时也不记录快照，避免循环
+				*
+				* @param context - 中间件上下文，包含 storeId、操作类型、状态等信息
+				* @param next - 调用下一个中间件或最终操作的函数
+				*/
+				handler: async (context, next) => {
+					const { storeId, type, state } = context;
+					if (!type.startsWith("state:") || isTraveling) {
+						await next();
+						return;
+					}
+					const snapshot = {
+						timestamp: Date.now(),
+						state: deepClone(state),
+						type,
+						storeId
+					};
+					await next();
+					addSnapshot(snapshot);
+				}
+			},
+			controller
+		};
+	}
+	function setRestoreCallback(controller, callback) {
+		const controllerWithSetter = controller;
+		if (typeof controllerWithSetter.__setRestoreCallback === "function") {
+			controllerWithSetter.__setRestoreCallback(callback);
+			return;
+		}
+		console.warn("[TimeTravel] 请使用 createTimeTravelMiddleware 返回的 controller");
+	}
+	//#endregion
+	//#region src/middleware/validation.ts
+	function createValidationMiddleware(options) {
+		const { rules, onValidationError, blocking = false, patchOnly = false } = options;
+		let lastErrors = [];
+		async function validateState(storeId, state) {
+			const storeRules = rules[storeId];
+			if (!storeRules) return {
+				valid: true,
+				errors: []
+			};
+			const errors = [];
+			for (const [field, fieldRules] of Object.entries(storeRules)) {
+				const ruleList = Array.isArray(fieldRules) ? fieldRules : [fieldRules];
+				const value = state[field];
+				for (const rule of ruleList) try {
+					if (!await rule.validate(value, state)) errors.push({
+						storeId,
+						field,
+						message: rule.message,
+						value
+					});
+				} catch {
+					errors.push({
+						storeId,
+						field,
+						message: rule.message || `Validation error on field "${field}"`,
+						value
+					});
+				}
+			}
+			return {
+				valid: errors.length === 0,
+				errors
+			};
+		}
+		return {
+			middleware: {
+				name: "validation",
+				priority: 5,
+				handler: async (context, next) => {
+					const { storeId, type, state } = context;
+					if (!(patchOnly ? type === "state:patch" : type.startsWith("state:")) || !rules[storeId]) {
+						await next();
+						return;
+					}
+					await next();
+					const result = await validateState(storeId, state);
+					if (!result.valid) {
+						lastErrors = result.errors;
+						onValidationError?.(result);
+						if (blocking) throw new Error(`[Validation] ${storeId}: ${result.errors.map((e) => e.message).join("; ")}`);
+					} else lastErrors = lastErrors.filter((e) => e.storeId !== storeId);
+				}
+			},
+			validate: validateState,
+			getErrors: () => [...lastErrors],
+			clearErrors: () => {
+				lastErrors = [];
+			}
+		};
+	}
+	//#endregion
+	//#region src/plugins/define-plugin.ts
+	function defineStorePlugin(options) {
+		return {
+			name: options.name,
+			version: options.version,
+			description: options.description,
+			install: options.install,
+			uninstall: options.uninstall,
+			onStoreCreated: options.onStoreCreated,
+			onStoreDisposed: options.onStoreDisposed,
+			onStateChange: options.onStateChange
+		};
+	}
+	function createPluginFactory(factory) {
+		return (options) => {
+			return defineStorePlugin(factory(options));
+		};
+	}
+	function composePlugins(plugins) {
+		return {
+			name: "composed-plugins",
+			version: "1.0.0",
+			async install(context, options) {
+				for (const plugin of plugins) await plugin.install(context, options);
+			},
+			async uninstall(context) {
+				for (let i = plugins.length - 1; i >= 0; i--) await plugins[i].uninstall?.(context);
+			},
+			onStoreCreated(store) {
+				plugins.forEach((plugin) => plugin.onStoreCreated?.(store));
+			},
+			onStoreDisposed(store) {
+				plugins.forEach((plugin) => plugin.onStoreDisposed?.(store));
+			},
+			onStateChange(storeId, state, oldState) {
+				plugins.forEach((plugin) => plugin.onStateChange?.(storeId, state, oldState));
+			}
+		};
+	}
+	//#endregion
+	//#region src/plugins/plugin-manager.ts
+	function createPluginManager() {
+		const plugins = /* @__PURE__ */ new Map();
+		const contexts = /* @__PURE__ */ new Map();
+		const use = (plugin, options) => {
+			if (plugins.has(plugin.name)) console.warn(`[Plugin] \u63D2\u4EF6 "${plugin.name}" \u5DF2\u5B58\u5728\uFF0C\u5C06\u88AB\u8986\u76D6`);
+			plugins.set(plugin.name, plugin);
+			const context = {
+				storeManager: {
+					getStore: () => null,
+					hasStore: () => false,
+					getStoreIds: () => []
+				},
+				storeId: "",
+				store: null,
+				options: options || {}
+			};
+			contexts.set(plugin.name, context);
+		};
+		const remove = (name) => {
+			const plugin = plugins.get(name);
+			const context = contexts.get(name);
+			if (plugin && context) plugin.uninstall?.(context);
+			plugins.delete(name);
+			contexts.delete(name);
+		};
+		const get = (name) => {
+			return plugins.get(name);
+		};
+		const has = (name) => {
+			return plugins.has(name);
+		};
+		const getAll = () => {
+			return new Map(plugins);
+		};
+		const size = () => {
+			return plugins.size;
+		};
+		const clear = () => {
+			plugins.forEach((plugin, name) => {
+				const context = contexts.get(name);
+				if (context) plugin.uninstall?.(context);
+			});
+			plugins.clear();
+			contexts.clear();
+		};
+		return {
+			use,
+			remove,
+			get,
+			has,
+			getAll,
+			size,
+			clear
+		};
+	}
+	let globalPluginManager = null;
+	function getGlobalPluginManager() {
+		if (!globalPluginManager) globalPluginManager = createPluginManager();
+		return globalPluginManager;
+	}
+	function setGlobalPluginManager(manager) {
+		globalPluginManager = manager;
+	}
+	//#endregion
+	//#region src/index.ts
+	const version = "1.0.0";
+	const name = "@composy/store-core";
+	//#endregion
+	exports.BaseStore = BaseStore;
+	exports.DeserializationError = DeserializationError;
+	exports.ErrorSeverity = ErrorSeverity;
+	exports.InvalidStateError = InvalidStateError;
+	exports.MiddlewareError = MiddlewareError;
+	exports.PluginError = PluginError;
+	exports.SerializationError = SerializationError;
+	exports.StorageError = StorageError;
+	exports.StoreAlreadyExistsError = StoreAlreadyExistsError;
+	exports.StoreDisposedError = StoreDisposedError;
+	exports.StoreError = StoreError;
+	exports.StoreErrorCode = StoreErrorCode;
+	exports.StoreNotFoundError = StoreNotFoundError;
+	exports.SubscriptionError = SubscriptionError;
+	exports.TimeoutError = TimeoutError;
+	exports.batch = batch;
+	exports.combineSelectors = combineSelectors;
+	exports.composePlugins = composePlugins;
+	exports.createAsyncAction = createAsyncAction;
+	exports.createBatchManager = createBatchManager;
+	exports.createCachedSelector = createCachedSelector;
+	exports.createEventBus = createEventBus;
+	exports.createLoggerMiddleware = createLoggerMiddleware;
+	exports.createMemoizedSelector = createMemoizedSelector;
+	exports.createMiddlewareManager = createMiddlewareManager;
+	exports.createPersistMiddleware = createPersistMiddleware;
+	exports.createPluginFactory = createPluginFactory;
+	exports.createPluginManager = createPluginManager;
+	exports.createPubSub = createPubSub;
+	exports.createPubSubWithValue = createPubSubWithValue;
+	exports.createSelector = createSelector;
+	exports.createSelectorWithDeps = createSelectorWithDeps;
+	exports.createSimpleLoggerMiddleware = createSimpleLoggerMiddleware;
+	exports.createStore = createStore;
+	exports.createStoreEngineBridge = createStoreEngineBridge;
+	exports.createTimeTravelMiddleware = createTimeTravelMiddleware;
+	exports.createValidationMiddleware = createValidationMiddleware;
+	exports.debounce = debounce;
+	exports.deepClone = deepClone;
+	exports.deepEqual = deepEqual;
+	exports.deepFreeze = deepFreeze;
+	exports.deepMerge = deepMerge;
+	exports.deepMergeWithOptions = deepMergeWithOptions;
+	exports.defineStorePlugin = defineStorePlugin;
+	exports.deleteByPath = deleteByPath;
+	exports.errorUtils = errorUtils;
+	exports.getByPath = getByPath;
+	exports.getGlobalBatchManager = getGlobalBatchManager;
+	exports.getGlobalMiddlewareManager = getGlobalMiddlewareManager;
+	exports.getGlobalPluginManager = getGlobalPluginManager;
+	exports.globalEventBus = globalEventBus;
+	exports.hasPath = hasPath;
+	exports.isObject = isObject;
+	exports.isPlainObject = isPlainObject;
+	exports.name = name;
+	exports.restoreState = restoreState;
+	exports.setByPath = setByPath;
+	exports.setGlobalBatchManager = setGlobalBatchManager;
+	exports.setGlobalMiddlewareManager = setGlobalMiddlewareManager;
+	exports.setGlobalPluginManager = setGlobalPluginManager;
+	exports.setRestoreCallback = setRestoreCallback;
+	exports.shallowClone = shallowClone;
+	exports.storeEventKeys = storeEventKeys;
+	exports.storeStateKeys = storeStateKeys;
+	exports.throttle = throttle;
+	exports.version = version;
+});
+/*! End of @composy/store-core | Powered by @composy/builder */
+//# sourceMappingURL=index.js.map