@asaidimu/utils-store 10.2.16 → 10.2.18

package/index.mjs

@@ -1 +1,2402 @@
-import{createEventBus as e}from"@core/events";import{Debouncer as t,Latch as n,Once as r,Serializer as i,SharedResource as a}from"@core/sync";import{v4 as o}from"uuid";import{Logger as s}from"@core/logger";const c=Symbol.for(`delete`),l=e=>Array.isArray(e)?[...e]:{...e};function u(e){let t=e?.deleteMarker||c;function n(e){if(e==null)return e;if(Array.isArray(e))return e.filter(e=>e!==t).map(e=>typeof e==`object`&&e&&!Array.isArray(e)?n(e):e);if(typeof e==`object`){let r={};for(let[i,a]of Object.entries(e))if(a!==t)if(typeof a==`object`&&a){let e=n(a);e!==void 0&&(r[i]=e)}else r[i]=a;return r}return e===t?void 0:e}function r(e,r){if(typeof e!=`object`||!e)return typeof r==`object`&&r?n(r):r===t?{}:r;if(typeof r!=`object`||!r)return e;let i=l(e),a=[{target:i,source:r}];for(;a.length>0;){let{target:e,source:n}=a.pop();for(let r of Object.keys(n)){let i=n[r];if(i===t){delete e[r];continue}if(Array.isArray(i)){e[r]=i;continue}typeof i==`object`&&i?(e[r]=l(r in e&&typeof e[r]==`object`&&e[r]!==null?e[r]:{}),a.push({target:e[r],source:i})):e[r]=i}}return i}return r}const d=u(),f=[`map`,`filter`,`reduce`,`forEach`,`find`,`findIndex`,`some`,`every`,`includes`,`flatMap`,`flat`,`slice`,`splice`];var p=class{reactiveSelectors=new Map;pathBasedCache=new Map;dependencyMap=new Map;getState;eventBus;unsubscribeFromStore;constructor(e,t){this.getState=e,this.eventBus=t,this.unsubscribeFromStore=this.eventBus.subscribe(`update:complete`,this.handleStoreUpdate)}handleStoreUpdate=e=>{let t=new Set;for(let n of e.deltas){let e=n.path;for(let[n,r]of this.dependencyMap)if(n===e||n.startsWith(e+`.`)||e.startsWith(n+`.`))for(let e of r)t.add(e)}for(let e of t){let t=this.reactiveSelectors.get(e);t&&this.evaluateEntry(t)}};evaluateEntry(e){let t;try{t=e.selector(this.getState())}catch{t=void 0}if(t!==e.lastResult){e.lastResult=t;for(let n of e.subscribers)n(t);this.eventBus.emit({name:`selector:changed`,payload:{selectorId:e.id,newResult:t,timestamp:Date.now()}})}}createReactiveSelector(e){let t=m(e),n=[...t].sort().join(`|`),r=this.pathBasedCache.get(n);if(r)return r.cleanupTimer!==void 0&&(clearTimeout(r.cleanupTimer),r.cleanupTimer=void 0),r.reactiveSelectorInstance;let i=`sel-${Math.random().toString(36).slice(2,9)}`,a={id:i,selector:e,lastResult:e(this.getState()),accessedPaths:t,subscribers:new Set,count:0,cleanupTimer:void 0,pathCacheKey:n,reactiveSelectorInstance:null};for(let e of t)this.dependencyMap.has(e)||this.dependencyMap.set(e,new Set),this.dependencyMap.get(e).add(i);let o={id:i,get:()=>{try{return a.selector(this.getState())}catch{return}},subscribe:e=>(a.cleanupTimer!==void 0&&(clearTimeout(a.cleanupTimer),a.cleanupTimer=void 0),a.subscribers.add(e),a.count++,()=>{a.subscribers.delete(e),a.count--,a.count===0&&(a.cleanupTimer=setTimeout(()=>{a.count===0&&this.evictEntry(a)},0))})};return a.reactiveSelectorInstance=o,this.reactiveSelectors.set(i,a),this.pathBasedCache.set(n,a),this.eventBus.emit({name:`selector:accessed`,payload:{selectorId:i,accessedPaths:t,duration:0,timestamp:Date.now()}}),o}evictEntry(e){for(let t of e.accessedPaths){let n=this.dependencyMap.get(t);n&&(n.delete(e.id),n.size===0&&this.dependencyMap.delete(t))}this.reactiveSelectors.delete(e.id),this.pathBasedCache.delete(e.pathCacheKey)}dispose(){this.unsubscribeFromStore(),this.reactiveSelectors.clear(),this.dependencyMap.clear(),this.pathBasedCache.clear()}};function m(e,t=`.`){let n=new Set,r=new Map,i=(e=``)=>{if(r.has(e))return r.get(e);let a=new Proxy(()=>{},{get:(r,a)=>{if(typeof a==`symbol`||a===`then`)return;if(a===`valueOf`||a===`toString`)throw Error(`Cannot perform logic, arithmetic, or string operations inside a selector.`);if(f.includes(a))throw Error(`Array method .${a}() is not allowed in selectors.`);let o=e?`${e}${t}${a}`:a;return e&&n.delete(e),n.add(o),i(o)},has:()=>{throw Error(`The 'in' operator is not allowed in selectors.`)},apply:()=>{throw Error(`Selectors cannot call functions or methods.`)}});return r.set(e,a),a};try{e(i())}catch(e){throw Error(`Selector failed during path analysis. Selectors must be simple property accessors only. Error: ${e instanceof Error?e.message:String(e)}`)}return Array.from(n)}function h(e,t){if(e===t)return!0;if(e&&t&&typeof e==`object`&&typeof t==`object`){if(e.constructor!==t.constructor)return!1;let n,r;if(Array.isArray(e)){if(n=e.length,n!=t.length)return!1;for(r=n;r-->0;)if(!h(e[r],t[r]))return!1;return!0}let[i,a]=[Object.keys(e),Object.keys(t)];if(n=i.length,n!==a.length)return!1;for(r=n;r-->0;){let n=i[r];if(!Object.prototype.hasOwnProperty.call(t,n)||!h(e[n],t[n]))return!1}return!0}return e!==e&&t!==t}function g(e){let t=e?.deleteMarker||c;function n(e,n){let r=[],i=[{pathStr:``,orig:e||{},part:n||{}}];for(;i.length>0;){let{pathStr:e,orig:n,part:a}=i.pop();if(a!=null&&!h(n,a))if(typeof a==`object`&&!Array.isArray(a))for(let o of Object.keys(a)){let s=e?e+`.`+o:o,c=a[o],l=n&&typeof n==`object`?n[o]:void 0;if(c===t){l!==void 0&&r.push({path:s,oldValue:l,newValue:void 0});continue}typeof c==`object`&&c?i.push({pathStr:s,orig:l,part:c}):h(l,c)||r.push({path:s,oldValue:l,newValue:c})}else e&&r.push({path:e,oldValue:n,newValue:a})}return r}return n}function _(e){let t=e?.deleteMarker||c;function n(e){let n=new Set,r=[{obj:e,currentPath:``}];for(;r.length>0;){let{obj:e,currentPath:i}=r.pop();if(!(typeof e!=`object`||!e||Array.isArray(e)))for(let a of Object.keys(e)){let o=i?`${i}.${a}`:a;n.add(o);let s=e[a];typeof s==`object`&&s&&!Array.isArray(s)&&s!==t&&r.push({obj:s,currentPath:o})}}return Array.from(n)}return n}const v=g(),y=_();var b=class{updateBus;diff;cache;constructor(e,t,n){this.updateBus=t,this.diff=n,this.cache=structuredClone(e)}get(e){return e?structuredClone(this.cache):this.cache}applyChanges(e,t=!1,n=!1,r=[]){if(t)return this.cache=n?structuredClone(e):e,this.notifyListeners([]),[];r.length===0&&(r=[e]);let i=this.get(!1),a=new Map;for(let e=0;e<r.length;e++){let t=r[e],n=this.diff(i,t);for(let e=0;e<n.length;e++){let t=n[e];a.set(t.path,t)}}let o=a.size?[...a.values()]:[];if(o.length>0){this.cache=n?structuredClone(e):e;let t=new Set;for(let e=0;e<o.length;e++){let n=o[e].path;for(;n&&!t.has(n);){t.add(n);let e=n.lastIndexOf(`.`);if(e<0)break;n=n.slice(0,e)}}this.notifyListeners(t)}return o}notifyListeners(e){for(let t of e)this.updateBus.emit({name:`update`,payload:t})}},x=class{eventBus;executionState;merge;logger;middleware=[];blockingMiddleware=[];constructor(e,t,n,r){this.eventBus=e,this.executionState=t,this.merge=n,this.logger=r}async executeBlocking(e,t){for(let{fn:n,name:r,id:i}of this.blockingMiddleware){let a={id:i,name:r,startTime:Date.now()};this.executionState.runningMiddleware={id:i,name:r,startTime:Date.now()},this.emitMiddlewareLifecycle(`start`,{id:i,name:r,type:`blocking`});try{let o=await Promise.resolve(n(e,t));if(a.endTime=Date.now(),a.duration=a.endTime-a.startTime,o===!1)return a.blocked=!0,this.emitMiddlewareLifecycle(`blocked`,{id:i,name:r,duration:a.duration}),this.emit(this.eventBus,{name:`middleware:executed`,payload:a}),{blocked:!0};this.emitMiddlewareLifecycle(`complete`,{id:i,name:r,type:`blocking`,duration:a.duration}),this.emit(this.eventBus,{name:`middleware:executed`,payload:{...a,blocked:!1}})}catch(e){return a.endTime=Date.now(),a.duration=a.endTime-a.startTime,a.error=e instanceof Error?e:Error(String(e)),a.blocked=!0,this.emitMiddlewareError(i,r,a.error,a.duration),this.emit(this.eventBus,{name:`middleware:executed`,payload:a}),{blocked:!0,error:a.error}}finally{this.executionState.runningMiddleware=null}}return{blocked:!1}}async executeTransform(e,t){let n=e,r=t;for(let{fn:e,name:i,id:a}of this.middleware){let o={id:a,name:i,startTime:Date.now()};this.executionState.runningMiddleware={id:a,name:i,startTime:Date.now()},this.emitMiddlewareLifecycle(`start`,{id:a,name:i,type:`transform`});try{let s=await Promise.resolve(e(n,t));o.endTime=Date.now(),o.duration=o.endTime-o.startTime,o.blocked=!1,s&&typeof s==`object`&&(n=this.merge(n,s),r=this.merge(r,s)),this.emit(this.eventBus,{name:`middleware:executed`,payload:o}),this.emitMiddlewareLifecycle(`complete`,{id:a,name:i,type:`transform`,duration:o.duration})}catch(e){o.endTime=Date.now(),o.duration=o.endTime-o.startTime,o.error=e instanceof Error?e:Error(String(e)),o.blocked=!1,this.emit(this.eventBus,{name:`middleware:executed`,payload:o}),this.emitMiddlewareError(a,i,o.error,o.duration),this.logger.error(`Middleware error`,{name:i,error:e})}finally{this.executionState.runningMiddleware=null}}return r}addMiddleware(e,t=`unnamed-middleware`){let n=this.generateId();return this.middleware.push({fn:e,name:t,id:n}),this.updateExecutionState(),n}addBlockingMiddleware(e,t=`unnamed-blocking-middleware`){let n=this.generateId();return this.blockingMiddleware.push({fn:e,name:t,id:n}),this.updateExecutionState(),n}removeMiddleware(e){let t=this.middleware.length+this.blockingMiddleware.length;return this.middleware=this.middleware.filter(t=>t.id!==e),this.blockingMiddleware=this.blockingMiddleware.filter(t=>t.id!==e),this.updateExecutionState(),this.middleware.length+this.blockingMiddleware.length<t}updateExecutionState(){this.executionState.middlewares=[...this.middleware.map(e=>e.name),...this.blockingMiddleware.map(e=>e.name)]}emitMiddlewareLifecycle(e,t){this.emit(this.eventBus,{name:`middleware:${e}`,payload:{...t,timestamp:Date.now()}})}emitMiddlewareError(e,t,n,r){this.emit(this.eventBus,{name:`middleware:error`,payload:{id:e,name:t,error:n,duration:r,timestamp:Date.now()}})}generateId(){return crypto.randomUUID?crypto.randomUUID():`${Date.now()}-${Math.random().toString(36).substring(2,15)}`}emit(e,t){queueMicrotask(()=>{e.emit(t)})}};let S;function C(e){return e||(S||=new s([]),S)}var w=class{eventBus;coreState;persistence;instanceID;persistenceReady=!1;backgroundQueue=[];isProcessingQueue=!1;maxRetries=3;retryDelay=1e3;queueProcessor;pendingRetries=new Set;logger;constructor(e,t,n,r){this.eventBus=e,this.coreState=t,this.instanceID=n,this.maxRetries=r?.maxRetries??3,this.retryDelay=r?.retryDelay??1e3,this.logger=r?.logger??C()}async initialize(e){e?await this.setPersistence(e):this.setPersistenceReady()}isReady(){return this.persistenceReady}handleStateChange(e,t){if(!this.persistence||e.length===0)return;let n={id:`${Date.now()}-${Math.random().toString(36).slice(2,11)}`,state:structuredClone(t),changedPaths:[...e],timestamp:Date.now(),retries:0};this.backgroundQueue.push(n),this.scheduleQueueProcessing(),this.emit(this.eventBus,{name:`persistence:queued`,payload:{taskId:n.id,changedPaths:e,queueSize:this.backgroundQueue.length,timestamp:n.timestamp}})}getQueueStatus(){return{queueSize:this.backgroundQueue.length,isProcessing:this.isProcessingQueue,pendingRetries:this.pendingRetries.size,oldestTask:this.backgroundQueue[0]?.timestamp}}async flush(){this.isProcessingQueue&&await new Promise(e=>{let t=()=>{this.isProcessingQueue?setTimeout(t,10):e()};t()}),await this.processQueue()}discardQueue(){let e=this.backgroundQueue.length+this.pendingRetries.size;this.backgroundQueue=[],this.pendingRetries.clear(),this.queueProcessor&&=(clearTimeout(this.queueProcessor),void 0),this.emit(this.eventBus,{name:`persistence:queue_cleared`,payload:{clearedTasks:e,timestamp:Date.now()}})}scheduleQueueProcessing(){this.queueProcessor||this.isProcessingQueue||(this.queueProcessor=setTimeout(()=>{this.processQueue().catch(e=>{this.logger.error(`Queue processing failed`,{error:e})})},10))}async processQueue(){if(!(this.isProcessingQueue||this.backgroundQueue.length===0)){this.isProcessingQueue=!0,this.queueProcessor=void 0;try{for(;this.backgroundQueue.length>0;){let e=this.backgroundQueue.shift();await this.processTask(e)}}finally{this.isProcessingQueue=!1}}}async processTask(e){try{await this.persistence.set(this.instanceID,e.state)?this.emit(this.eventBus,{name:`persistence:success`,payload:{taskId:e.id,changedPaths:e.changedPaths,duration:Date.now()-e.timestamp,timestamp:Date.now()}}):await this.handleTaskFailure(e,Error(`Persistence returned false`))}catch(t){await this.handleTaskFailure(e,t)}}async handleTaskFailure(e,t){if(e.retries++,e.retries<=this.maxRetries){let n=this.retryDelay*2**(e.retries-1);this.emit(this.eventBus,{name:`persistence:retry`,payload:{taskId:e.id,attempt:e.retries,maxRetries:this.maxRetries,nextRetryIn:n,error:t,timestamp:Date.now()}}),this.pendingRetries.add(e.id),setTimeout(()=>{this.pendingRetries.has(e.id)&&(this.pendingRetries.delete(e.id),this.backgroundQueue.unshift(e),this.scheduleQueueProcessing())},n)}else this.emit(this.eventBus,{name:`persistence:failed`,payload:{taskId:e.id,changedPaths:e.changedPaths,attempts:e.retries,error:t,timestamp:Date.now()}})}setPersistenceReady(){this.persistenceReady=!0,this.emit(this.eventBus,{name:`persistence:ready`,payload:{timestamp:Date.now()}})}async setPersistence(e){this.persistence=e;try{let e=await this.persistence.get();e&&this.coreState.applyChanges(e)}catch(e){this.logger.error(`Failed to initialize persistence`,{error:e}),this.emit(this.eventBus,{name:`persistence:init_error`,payload:{error:e,timestamp:Date.now()}})}finally{this.setPersistenceReady()}this.persistence.subscribe(this.instanceID,async e=>{let t=this.coreState.applyChanges(e);t.length>0&&this.emit(this.eventBus,{name:`update:complete`,payload:{changedPaths:t,source:`external`,timestamp:Date.now()}})})}dispose(){this.discardQueue(),this.isProcessingQueue=!1,this.persistenceReady=!1}emit(e,t){queueMicrotask(()=>{e.emit(t)})}},T=class{eventBus;coreState;executionState;constructor(e,t,n){this.eventBus=e,this.coreState=t,this.executionState=n}async execute(e){let t=this.coreState.get(!0);this.executionState.transactionActive=!0,this.emit(this.eventBus,{name:`transaction:start`,payload:{timestamp:Date.now()}});try{let t=await Promise.resolve(e());return this.emit(this.eventBus,{name:`transaction:complete`,payload:{timestamp:Date.now()}}),this.executionState.transactionActive=!1,t}catch(e){throw this.coreState.applyChanges(t,!0,!1),this.emit(this.eventBus,{name:`transaction:error`,payload:{error:e instanceof Error?e:Error(String(e)),timestamp:Date.now()}}),this.executionState.transactionActive=!1,e}}emit(e,t){queueMicrotask(()=>{e.emit(t)})}},E=class{updateCount=0;listenerExecutions=0;averageUpdateTime=0;largestUpdateSize=0;mostActiveListenerPaths=[];totalUpdates=0;blockedUpdates=0;averageUpdateDuration=0;middlewareExecutions=0;transactionCount=0;totalEventsFired=0;totalActionsDispatched=0;totalActionsSucceeded=0;totalActionsFailed=0;averageActionDuration=0;updateTimes=[];actionTimes=[];pathExecutionCounts=new Map;constructor(e){this.setupEventListeners(e)}getMetrics(){return{updateCount:this.updateCount,listenerExecutions:this.listenerExecutions,averageUpdateTime:this.averageUpdateTime,largestUpdateSize:this.largestUpdateSize,mostActiveListenerPaths:[...this.mostActiveListenerPaths],totalUpdates:this.totalUpdates,blockedUpdates:this.blockedUpdates,averageUpdateDuration:this.averageUpdateDuration,middlewareExecutions:this.middlewareExecutions,transactionCount:this.transactionCount,totalEventsFired:this.totalEventsFired,totalActionsDispatched:this.totalActionsDispatched,totalActionsSucceeded:this.totalActionsSucceeded,totalActionsFailed:this.totalActionsFailed,averageActionDuration:this.averageActionDuration}}setupEventListeners(e){let t=e.emit;e.emit=n=>(this.totalEventsFired++,t.call(e,n)),e.subscribe(`update:complete`,e=>{if(this.totalUpdates++,e.blocked){this.blockedUpdates++;return}if(e.duration){this.updateTimes.push(e.duration),this.updateTimes.length>100&&this.updateTimes.shift();let t=this.updateTimes.reduce((e,t)=>e+t,0)/this.updateTimes.length;this.averageUpdateTime=t,this.averageUpdateDuration=t}e.deltas?.length&&(this.updateCount++,this.largestUpdateSize=Math.max(this.largestUpdateSize,e.deltas.length),e.deltas.forEach(e=>{let t=this.pathExecutionCounts.get(e.path)||0;this.pathExecutionCounts.set(e.path,t+1)}),this.mostActiveListenerPaths=Array.from(this.pathExecutionCounts.entries()).sort(([,e],[,t])=>t-e).slice(0,5).map(([e])=>e))}),e.subscribe(`middleware:start`,()=>{this.middlewareExecutions++}),e.subscribe(`transaction:start`,()=>{this.transactionCount++}),e.subscribe(`action:start`,()=>{this.totalActionsDispatched++}),e.subscribe(`action:complete`,e=>{this.totalActionsSucceeded++,e.duration&&(this.actionTimes.push(e.duration),this.actionTimes.length>100&&this.actionTimes.shift(),this.averageActionDuration=this.actionTimes.reduce((e,t)=>e+t,0)/this.actionTimes.length)}),e.subscribe(`action:error`,()=>{this.totalActionsFailed++})}reset(){this.updateCount=0,this.listenerExecutions=0,this.averageUpdateTime=0,this.largestUpdateSize=0,this.mostActiveListenerPaths=[],this.totalUpdates=0,this.blockedUpdates=0,this.averageUpdateDuration=0,this.middlewareExecutions=0,this.transactionCount=0,this.totalEventsFired=0,this.totalActionsDispatched=0,this.totalActionsSucceeded=0,this.totalActionsFailed=0,this.averageActionDuration=0,this.updateTimes=[],this.actionTimes=[],this.pathExecutionCounts.clear()}getDetailedMetrics(){return{pathExecutionCounts:new Map(this.pathExecutionCounts),recentUpdateTimes:[...this.updateTimes],successRate:this.totalUpdates>0?(this.totalUpdates-this.blockedUpdates)/this.totalUpdates:1,averagePathsPerUpdate:this.updateCount>0?Array.from(this.pathExecutionCounts.values()).reduce((e,t)=>e+t,0)/this.updateCount:0}}dispose(){this.reset()}},D=class extends Error{constructor(){super(`Action Cancelled by Debounce`),this.name=`ActionCancelledError`}},O=class extends Error{constructor({action:e}){super(`Unknown action: "${e}"`),this.name=`UnknownActionError`}};const k=()=>{},A={name:`UNDEFINED ACTION`,status:()=>!1,subscribe:e=>()=>{}};var j=class{eventBus;set;registrations=new Map;constructor(e,t){this.eventBus=e,this.set=t}register(e){let n={action:{name:e.name,id:o(),action:e.fn,debounce:e.debounce?{...e.debounce,condition:e.debounce.condition??(()=>!0)}:void 0},debouncer:e.debounce&&e.debounce.delay>0?new t({delay:e.debounce.delay}):void 0,previousArgs:void 0,running:!1,subscription:{listeners:new Set,watcher:null,watchers:new a(()=>[this.eventBus.subscribe(`action:start`,t=>t.name===e.name&&this.notifyStatusListeners(e.name)),this.eventBus.subscribe(`action:complete`,t=>t.name===e.name&&this.notifyStatusListeners(e.name)),this.eventBus.subscribe(`action:error`,t=>t.name===e.name&&this.notifyStatusListeners(e.name))],e=>e?.forEach(e=>e()),{gracePeriod:`microtask`})}};return this.registrations.set(e.name,n),()=>{let t=this.registrations.get(e.name);t&&(t.debouncer?.cancel(),this.registrations.delete(e.name))}}async dispatch(e,...t){let n=this.registrations.get(e);if(!n)throw new O({action:e});let{action:r,debouncer:i}=n,{debounce:a}=r;if(!i||!a)return this.executeAction(n,t);let o=a.condition(n.previousArgs,t);if(n.previousArgs=t,!o)return this.executeAction(n,t);let s=await i.do(()=>this.executeAction(n,t));if(s.status===`cancelled`)throw new D;if(s.status===`error`&&s.error)throw s.error;return s.value}async executeAction(e,t){let n=Date.now();e.running=!0,this.emit(this.eventBus,{name:`action:start`,payload:{actionId:e.action.id,name:e.action.name,params:t||[],timestamp:n}});try{let r=await this.set(n=>e.action.action(n,...t),{actionId:e.action.id}),i=Date.now();return e.running=!1,this.emit(this.eventBus,{name:`action:complete`,payload:{actionId:e.action.id,name:e.action.name,params:t,startTime:n,endTime:i,duration:i-n,result:r}}),r}catch(r){let i=Date.now();throw e.running=!1,this.emit(this.eventBus,{name:`action:error`,payload:{actionId:e.action.id,name:e.action.name,params:t,startTime:n,endTime:i,duration:i-n,error:r}}),r}}running(e){let t=this.registrations.get(e);return t?t.running:!1}subscribe(e,t){let n=this.registrations.get(e);return n?(n.subscription.listeners.add(t),n.subscription.watchers.acquire(),()=>{n.subscription.listeners.delete(t),n.subscription.watchers?.release()}):k}watch(e){let t=this.registrations.get(e);return t?(t.subscription.watcher||(t.subscription.watcher={name:e,status:()=>this.running(e),subscribe:t=>this.subscribe(e,t)}),t.subscription.watcher):A}notifyStatusListeners(e){let t=this.registrations.get(e).subscription.listeners;t&&t.forEach(e=>e())}emit(e,t){queueMicrotask(()=>{e.emit(t)})}dispose(){for(let e of this.registrations.values())e.debouncer?.cancel(),e.subscription.watchers.forceCleanup,e.subscription.listeners.clear();this.registrations.clear()}},M=class{coreState;middlewareEngine;persistenceHandler;transactionManager;metricsCollector;selectorManager;actions;updateSerializer=new i({yieldMode:`macrotask`,capacity:1e3});readyLatch=new n;disposeOnce=new r;updateBus;eventBus;executionState;instanceID=o();merge;diff;logger;constructor(t,n,r=c,i){this.logger=C(i?.logger),this.eventBus=e(i?.broadcastChannel?{batch:{size:0,delay:0},broadcast:{channel:i.broadcastChannel}}:void 0),this.updateBus=e(i?.broadcastChannel?{batch:{size:0,delay:0},broadcast:{channel:i.broadcastChannel}}:void 0),this.executionState={executing:!1,changes:null,pendingChanges:[],middlewares:[],runningMiddleware:null,transactionActive:!1},this.merge=u({deleteMarker:r}),this.diff=g({deleteMarker:r}),this.coreState=new b(t,this.updateBus,this.diff),this.middlewareEngine=new x(this.eventBus,this.executionState,this.merge,this.logger),this.persistenceHandler=new w(this.eventBus,this.coreState,this.instanceID,{maxRetries:i?.persistenceMaxRetries,retryDelay:i?.persistenceRetryDelay,logger:this.logger}),this.transactionManager=new T(this.eventBus,this.coreState,this.executionState),this.metricsCollector=new E(this.eventBus),this.actions=new j(this.eventBus,this.set.bind(this)),this.persistenceHandler.initialize(n),this.setupPersistenceListener(),this.setupReadyLatch(),this.selectorManager=new p(this.get.bind(this),this.eventBus)}isReady(){return this.readyLatch.isOpen()}async ready(e){return this.readyLatch.wait(e)}state(){return this.executionState.executing=this.updateSerializer.running(),this.executionState}get(e){return this.coreState.get(e??!1)}subset(e,t=`.`){let n={},r=this.get();for(let i of e)n[i]=i.split(t).reduce((e,t)=>e&&e[t]!==void 0?e[t]:void 0,r);return n}select(e){return this.checkDisposed(),this.selectorManager.createReactiveSelector(e)}register(e){return this.checkDisposed(),this.actions.register(e)}async dispatch(e,...t){return this.checkDisposed(),this.actions.dispatch(e,...t)}async set(e,t={}){this.checkDisposed();let n=await this.updateSerializer.do(()=>this._performUpdate(e,t));if(n.error)throw n.error;return n.value}async _performUpdate(e,t){let n=Date.now();this.emit(this.eventBus,{name:`update:start`,payload:{timestamp:n,actionId:t.actionId}});try{if(t.force){let r=this.get(!1),i=typeof e==`function`?e(r):e;this.coreState.applyChanges(i,!0);let a=Date.now();return this.emit(this.eventBus,{name:`update:complete`,payload:{deltas:[],duration:a-n,timestamp:Date.now(),actionId:t.actionId,newState:i}}),i}let r,i=this.get(!1);if(typeof e==`function`){let t=e(i);r=t instanceof Promise?await t:t}else r=e;let a=await this.middlewareEngine.executeBlocking(i,r);if(a.blocked)throw a.error||Error(`Update blocked by middleware`);let o=this.merge(i,r),s=await this.middlewareEngine.executeTransform(o,r),c=this.merge(o,s),l=this.coreState.applyChanges(c,!1,!1,[r,s]),u=Date.now(),d=this.get(!1);return this.emit(this.eventBus,{name:`update:complete`,payload:{deltas:l,duration:u-n,timestamp:Date.now(),actionId:t.actionId,newState:d}}),d}catch(e){throw this.emit(this.eventBus,{name:`update:complete`,payload:{blocked:!0,error:e,timestamp:Date.now(),actionId:t.actionId,newState:this.get(!1)}}),e}finally{this.executionState.executing=!1,this.executionState.changes=null,this.executionState.runningMiddleware=null,this.executionState.pendingChanges=[]}}setupReadyLatch(){if(this.persistenceHandler.isReady())this.readyLatch.open();else{let e=this.eventBus.subscribe(`persistence:ready`,()=>{this.readyLatch.isOpen()||this.readyLatch.open(),e()})}}setupPersistenceListener(){this.updateBus.subscribe(`update`,e=>{e&&this.persistenceHandler.isReady()&&this.persistenceHandler.handleStateChange([e],this.get(!1))})}watch(e,t,n){let r=Array.isArray(e)?e:[e],i=e===``||r.length===0;return this.updateBus.subscribe(`update`,e=>{(i||r.includes(e))&&(t(this.get(!1)),this.metricsCollector.listenerExecutions++)},n)}watchAction(e){return this.checkDisposed(),this.actions.watch(e)}debouncedSetter(e){let n=new t({delay:e.delay,leading:e.leading});return(e,t={})=>{n.fire(()=>this.set(e,t))}}id(){return this.instanceID}async transaction(e,t){this.checkDisposed();let n=await this.transactionManager.execute(e);return t?.flush&&await this.flush(),n}use(e){this.checkDisposed();let t=(e.block?this.middlewareEngine.addBlockingMiddleware:this.middlewareEngine.addMiddleware).bind(this.middlewareEngine)(e.action,e.name);return()=>this.middlewareEngine.removeMiddleware(t)}metrics(){return this.metricsCollector.getMetrics()}on(e,t){return this.checkDisposed(),this.eventBus.subscribe(e,t)}getPersistenceStatus(){return this.persistenceHandler.getQueueStatus()}async flush(){return this.persistenceHandler.flush()}discardPersistenceQueue(){this.persistenceHandler.discardQueue()}dispose(){return this.disposeOnce.do(async()=>{await this.flush(),this.updateSerializer.close(),this.eventBus?.clear({permanent:!0}),this.updateBus?.clear({permanent:!0}),this.actions.dispose(),this.persistenceHandler.dispose(),this.metricsCollector.dispose(),this.selectorManager.dispose(),this.coreState=null,this.middlewareEngine=null,this.transactionManager=null,this.actions=null})}checkDisposed(){if(this.disposed())throw Error(`StoreExecutionDone: Cannot perform operations on a disposed store.`)}disposed(){return this.disposeOnce.done()}emit(e,t){queueMicrotask(()=>{e.emit(t)})}},N=class{stores=new Map;storeToOnce=new WeakMap;finalizer;onEvict;logger;constructor(e){this.onEvict=e?.onEvict,this.logger=C(e?.logger),this.finalizer=new FinalizationRegistry(({storeId:e,ref:t})=>{try{this.stores.get(e)===t&&(this.stores.delete(e),this.onEvict?.(e))}catch(t){this.logger.error(`StoreRegistry Finalizer error`,{storeId:e,error:t})}})}async get(e,t={}){let n=this.stores.get(e)?.deref();if(!n){n=new r({throws:!1});let t=new WeakRef(n);this.stores.set(e,t),this.finalizer.register(n,{storeId:e,ref:t},n)}let i=await n.do(async()=>{let e=new M(t.state||{},t.persistence,t.deleteMarker,t.options);return await e.ready(),e},t.timeout);if(i.error)throw this.stores.get(e)?.deref()===n&&(this.stores.delete(e),this.finalizer.unregister(n)),i.error;let a=i.value;return this.storeToOnce.set(a,n),a}getSync(e,t={}){let n=this.stores.get(e)?.deref();if(!n){n=new r({throws:!1});let t=new WeakRef(n);this.stores.set(e,t),this.finalizer.register(n,{storeId:e,ref:t},n)}let i=n.doSync(()=>new M(t.state||{},t.persistence,t.deleteMarker,t.options));if(i.error)throw this.stores.get(e)?.deref()===n&&(this.stores.delete(e),this.finalizer.unregister(n)),i.error;let a=i.value;return this.storeToOnce.set(a,n),a}async release(e){let t=this.stores.get(e);if(t){let n=t.deref();if(n&&(this.finalizer.unregister(n),n.done())){let t=n.get();if(t){try{await t.dispose()}catch(t){this.logger.error(`StoreRegistry Error disposing store during release`,{storeId:e,error:t})}this.storeToOnce.delete(t)}}return this.stores.delete(e)}return!1}async clear(){for(let e of this.stores.values()){let t=e.deref();if(t&&(this.finalizer.unregister(t),t.done())){let e=t.get();if(e){try{await e.dispose()}catch{}this.storeToOnce.delete(e)}}}this.stores.clear()}has(e){return this.stores.has(e)}get size(){return this.stores.size}},P=class{store;eventHistory=[];stateHistory=[];unsubscribers=[];isTimeTraveling=!1;devTools=null;middlewareExecutions=[];activeTransactionCount=0;activeBatches=new Set;maxEvents;maxStateHistory;enableConsoleLogging;isSilent;logEvents;performanceThresholds;logger;constructor(e,t={}){this.store=e,this.maxEvents=t.maxEvents??500,this.maxStateHistory=t.maxStateHistory??20,this.enableConsoleLogging=t.enableConsoleLogging??!1,this.isSilent=t.silent??!1,this.logger=C(t.logger),this.logEvents={updates:t.logEvents?.updates??!0,middleware:t.logEvents?.middleware??!0,transactions:t.logEvents?.transactions??!0,actions:t.logEvents?.actions??!0,selectors:t.logEvents?.selectors??!0},this.performanceThresholds={updateTime:t.performanceThresholds?.updateTime??50,middlewareTime:t.performanceThresholds?.middlewareTime??20},this.recordStateSnapshot([]),this.setupEventListeners()}_consoleLog(e,...t){if(this.isSilent)return;if(e===`group`||e===`groupEnd`||e===`table`){typeof console[e]==`function`&&console[e](...t);return}let n=typeof t[0]==`string`?t[0]:String(t[0]??``),r=t.length>1?{detail:t.slice(1)}:void 0;switch(e){case`log`:this.logger.log(n,r);break;case`warn`:this.logger.warn(n,r);break;case`error`:this.logger.error(n,r);break;case`debug`:this.logger.debug(n,r);break}}setupEventListeners(){for(let e of[`update:start`,`update:complete`,`middleware:start`,`middleware:complete`,`middleware:error`,`middleware:blocked`,`transaction:start`,`transaction:complete`,`transaction:error`,`middleware:executed`,`action:start`,`action:complete`,`action:error`,`selector:accessed`]){let t=e.startsWith(`update`)&&this.logEvents.updates||e.startsWith(`middleware`)&&this.logEvents.middleware||e.startsWith(`transaction`)&&this.logEvents.transactions||e.startsWith(`action`)&&this.logEvents.actions||e.startsWith(`selector`)&&this.logEvents.selectors;this.unsubscribers.push(this.store.on(e,n=>{this.isTimeTraveling||(e===`update:complete`&&!n.blocked&&this.recordStateSnapshot(n.deltas),e===`middleware:executed`?this.middlewareExecutions.push(n):e===`transaction:start`?this.activeTransactionCount++:(e===`transaction:complete`||e===`transaction:error`)&&(this.activeTransactionCount=Math.max(0,this.activeTransactionCount-1)),n.batchId&&(e.endsWith(`start`)?this.activeBatches.add(n.batchId):(e.endsWith(`complete`)||e.endsWith(`error`))&&this.activeBatches.delete(n.batchId)),this.recordEvent(e,n),this.enableConsoleLogging&&t&&this._log(e,n),this._checkPerformance(e,n))}))}}recordStateSnapshot(e){let t={state:this.store.get(!0),timestamp:Date.now(),deltas:e};this.stateHistory.unshift(t),this.stateHistory.length>this.maxStateHistory&&this.stateHistory.pop()}recordEvent(e,t){let n={type:e,timestamp:Date.now(),data:structuredClone(t)};this.eventHistory.unshift(n),this.eventHistory.length>this.maxEvents&&this.eventHistory.pop()}getEventHistory(){return structuredClone(this.eventHistory)}getStateHistory(){return structuredClone(this.stateHistory)}getMiddlewareExecutions(){return this.middlewareExecutions}getTransactionStatus(){return{activeTransactions:this.activeTransactionCount,activeBatches:Array.from(this.activeBatches)}}createLoggingMiddleware(e={}){let{logLevel:t=`debug`,logUpdates:n=!0}=e;return(e,r)=>(n&&this.logger[t](`State Update`,{update:r}),r)}createValidationMiddleware(e){return(t,n)=>{let r=e(t,n);return typeof r==`boolean`?r:(!r.valid&&r.reason&&this._consoleLog(`warn`,`Validation failed:`,r.reason),r.valid)}}getRecentChanges(e=5){let t=[],n=Math.min(e,this.stateHistory.length);for(let e=0;e<n;e++){let n=this.stateHistory[e];if(!n.deltas||n.deltas.length===0)continue;let r={},i={},a=(e,t,n)=>{t.reduce((e,r,i)=>(i===t.length-1?e[r]=n:e[r]=e[r]??{},e[r]),e)};for(let e of n.deltas){let t=e.path.split(`.`);a(r,t,e.oldValue),a(i,t,e.newValue)}t.push({timestamp:n.timestamp,changedPaths:n.deltas.map(e=>e.path),from:r,to:i})}return t}clearHistory(){this.eventHistory=[],this.stateHistory.length>0&&(this.stateHistory=[this.stateHistory[0]])}getHistoryForAction(e){return this.eventHistory.filter(t=>t.data?.actionId===e)}async replay(e){let t=this.eventHistory.filter(e=>e.type===`update:start`)[e];t?.data.update?(this._consoleLog(`log`,`Replaying event at index ${e}:`,t),await this.store.set(t.data.update,{force:!0})):this._consoleLog(`warn`,`No replayable event found at index ${e}.`)}createTimeTravel(){let e=0,t=[],n=this.store.on(`update:complete`,n=>{!this.isTimeTraveling&&!n.blocked&&(t=[],e=0)});this.unsubscribers.push(n);let r=()=>this.stateHistory.length,i=()=>e<r()-1,a=()=>t.length>0;return{canUndo:i,canRedo:a,undo:async()=>{if(!i())return;t.unshift(this.stateHistory[e]),e++;let n=this.stateHistory[e].state;this.isTimeTraveling=!0,await this.store.set({...n},{force:!0}),this.isTimeTraveling=!1},redo:async()=>{if(!a())return;let n=t.shift();e--,this.isTimeTraveling=!0,await this.store.set({...n.state},{force:!0}),this.isTimeTraveling=!1},length:r,clear:()=>{t=[],e=0}}}async saveSession(e){let t=this.store.id(),n={eventHistory:this.eventHistory,stateHistory:this.stateHistory};return Promise.resolve(e.set(t,n))}async loadSession(e){let t=await Promise.resolve(e.get());return t?(this.eventHistory=t.eventHistory||[],this.stateHistory=t.stateHistory||[],this.stateHistory.length>0&&await this.store.set(this.stateHistory[0].state,{force:!0}),!0):!1}exportSession(){let e={eventHistory:this.eventHistory,stateHistory:this.stateHistory},t=new Blob([JSON.stringify(e,null,2)],{type:`application/json`}),n=URL.createObjectURL(t),r=document.createElement(`a`);r.href=n,r.download=`store-observer-session-${new Date().toISOString()}.json`,r.click(),URL.revokeObjectURL(n)}importSession(e){return new Promise((t,n)=>{let r=new FileReader;r.onload=async e=>{try{let n=JSON.parse(e.target?.result);this.eventHistory=n.eventHistory||[],this.stateHistory=n.stateHistory||[],this.stateHistory.length>0&&await this.store.set(this.stateHistory[0].state,{force:!0}),t()}catch(e){n(e)}},r.onerror=e=>n(e),r.readAsText(e)})}disconnect(){this.unsubscribers.forEach(e=>e()),this.unsubscribers=[],this.devTools?.disconnect(),this.clearHistory()}_log(e,t){let n=new Date(t.timestamp||Date.now()).toISOString().split(`T`)[1].replace(`Z`,``);if(e===`update:start`)this._consoleLog(`group`,`%c⚡ Store Update Started [${n}]`,`color: #4a6da7`);else if(e===`update:complete`){if(t.blocked)this._consoleLog(`warn`,`%c✋ Update Blocked [${n}]`,`color: #bf8c0a`,t.error);else{let e=t.deltas||[];e.length>0&&(this._consoleLog(`log`,`%c✅ Update Complete [${n}] - ${e.length} paths changed in ${t.duration?.toFixed(2)}ms`,`color: #2a9d8f`),this._consoleLog(`table`,e.map(e=>({path:e.path,oldValue:e.oldValue,newValue:e.newValue}))))}this._consoleLog(`groupEnd`)}else e===`middleware:start`?this._consoleLog(`debug`,`%c◀ Middleware \"${t.name}\" started [${n}] (${t.type})`,`color: #8c8c8c`):e===`middleware:complete`?this._consoleLog(`debug`,`%c▶ Middleware \"${t.name}\" completed [${n}] in ${t.duration?.toFixed(2)}ms`,`color: #7c9c7c`):e===`middleware:error`?this._consoleLog(`error`,`%c❌ Middleware \"${t.name}\" error [${n}]:`,`color: #e63946`,t.error):e===`middleware:blocked`?this._consoleLog(`warn`,`%c🛑 Middleware \"${t.name}\" blocked update [${n}]`,`color: #e76f51`):e===`transaction:start`?this._consoleLog(`group`,`%c📦 Transaction Started [${n}]`,`color: #6d597a`):e===`transaction:complete`?(this._consoleLog(`log`,`%c📦 Transaction Complete [${n}]`,`color: #355070`),this._consoleLog(`groupEnd`)):e===`transaction:error`?(this._consoleLog(`error`,`%c📦 Transaction Error [${n}]:`,`color: #e56b6f`,t.error),this._consoleLog(`groupEnd`)):e===`action:start`?this._consoleLog(`group`,`%c🚀 Action \"${t.name}\" Started [${n}]`,`color: #9b59b6`,{params:t.params}):e===`action:complete`?(this._consoleLog(`log`,`%c✔️ Action \"${t.name}\" Complete [${n}] in ${t.duration?.toFixed(2)}ms`,`color: #2ecc71`),this._consoleLog(`groupEnd`)):e===`action:error`?(this._consoleLog(`error`,`%c🔥 Action \"${t.name}\" Error [${n}]:`,`color: #e74c3c`,t.error),this._consoleLog(`groupEnd`)):e===`selector:accessed`&&this._consoleLog(`debug`,`%c👀 Selector Accessed [${n}] in ${t.duration?.toFixed(2)}ms`,`color: #f1c40f`,{accessedPaths:t.accessedPaths,selectorId:t.selectorId})}_checkPerformance(e,t){this.enableConsoleLogging&&(e===`update:complete`&&!t.blocked&&t.duration>this.performanceThresholds.updateTime&&this._consoleLog(`warn`,`%c⚠️ Slow update detected [${t.duration.toFixed(2)}ms]`,`color: #ff9f1c`,{deltas:t.deltas,threshold:this.performanceThresholds.updateTime}),e===`middleware:complete`&&t.duration>this.performanceThresholds.middlewareTime&&this._consoleLog(`warn`,`%c⚠️ Slow middleware \"${t.name}\" [${t.duration.toFixed(2)}ms]`,`color: #ff9f1c`,{threshold:this.performanceThresholds.middlewareTime}))}};export{D as ActionCancelledError,j as ActionManager,c as DELETE_SYMBOL,M as ReactiveDataStore,p as SelectorManager,P as StoreObserver,N as StoreRegistry,O as UnknownActionError,m as buildPaths,_ as createDerivePaths,g as createDiff,u as createMerge,C as createStoreLogger,y as derivePaths,v as diff,d as merge,l as shallowClone};
+import { createEventBus } from "@asaidimu/utils-events";
+import { Debouncer, Latch, Once, Serializer, SharedResource } from "@asaidimu/utils-sync";
+import { v4 } from "uuid";
+import { Logger } from "@asaidimu/utils-logger";
+
+//#region src/store/types.ts
+/**
+* A unique symbol used within DeepPartial objects to explicitly signal that a property
+* should be deleted from the state object.
+*/
+const DELETE_SYMBOL = Symbol.for("delete");
+
+//#endregion
+//#region src/store/merge.ts
+/**
+* Creates a shallow clone of an object or array.
+*/
+const shallowClone = (obj) => {
+	if (Array.isArray(obj)) return [...obj];
+	return { ...obj };
+};
+/**
+* Creates a deep merge function with configurable options.
+*
+* @param {object} options - Configuration options for the merge function.
+* @param {symbol} [options.deleteMarker=Symbol.for("delete")] - A custom symbol to mark properties for deletion during merge.
+*/
+function createMerge(options) {
+	const deleteSymbol = options?.deleteMarker || DELETE_SYMBOL;
+	/**
+	* Recursively strips deleteSymbol from an object or array.
+	*
+	* Used only when `original` is not an object and `changes` is being
+	* used as the base result directly. In normal operation (T extends object),
+	* `original` is always an object and this path is not reached.
+	*
+	* Note: arrays in this context are filtered for deleteSymbol elements
+	* and their object elements are cleaned recursively, consistent with the
+	* contract that deleteSymbol has no meaning *inside* arrays during a
+	* normal merge — but when an array is the entire result of this edge-case
+	* path, cleaning is the safe choice.
+	*/
+	function cleanObject(obj) {
+		if (obj === null || obj === void 0) return obj;
+		if (Array.isArray(obj)) return obj.filter((item) => item !== deleteSymbol).map((item) => typeof item === "object" && item !== null && !Array.isArray(item) ? cleanObject(item) : item);
+		if (typeof obj === "object") {
+			const result = {};
+			for (const [key, value] of Object.entries(obj)) {
+				if (value === deleteSymbol) continue;
+				if (typeof value === "object" && value !== null) {
+					const cleaned = cleanObject(value);
+					if (cleaned !== void 0) result[key] = cleaned;
+				} else result[key] = value;
+			}
+			return result;
+		}
+		return obj === deleteSymbol ? void 0 : obj;
+	}
+	/**
+	* Deep merges changes into an original object immutably.
+	*
+	* - The original object and changes object are not modified.
+	* - Arrays are replaced entirely, not element-merged. deleteSymbol has
+	*   no meaning inside arrays — if you need to remove an array element,
+	*   pass the desired array directly.
+	* - Object properties set to deleteSymbol are removed from the result.
+	* - Uses an iterative stack to avoid call-stack overflows on deep objects.
+	*
+	* @template T The type of the original object.
+	* @param {T} original The base object to merge into.
+	* @param {DeepPartial<T>} changes The patch to apply.
+	* @returns {T} A new object with changes applied.
+	*
+	* @example
+	* const merge = createMerge();
+	* merge({ a: 1, b: { c: 2 } }, { b: { c: 3, d: 4 } });
+	* // → { a: 1, b: { c: 3, d: 4 } }
+	*
+	* merge({ a: 1, b: 2 }, { b: Symbol.for('delete') });
+	* // → { a: 1 }
+	*
+	* merge({ a: 1, tags: ['x', 'y'] }, { tags: ['z'] });
+	* // → { a: 1, tags: ['z'] }  (array replaced wholesale)
+	*/
+	function mergeFn(original, changes) {
+		if (typeof original !== "object" || original === null) {
+			if (typeof changes === "object" && changes !== null) return cleanObject(changes);
+			return changes === deleteSymbol ? {} : changes;
+		}
+		if (typeof changes !== "object" || changes === null) return original;
+		const result = shallowClone(original);
+		const stack = [{
+			target: result,
+			source: changes
+		}];
+		while (stack.length > 0) {
+			const { target, source } = stack.pop();
+			for (const key of Object.keys(source)) {
+				const sourceValue = source[key];
+				if (sourceValue === deleteSymbol) {
+					delete target[key];
+					continue;
+				}
+				if (Array.isArray(sourceValue)) {
+					target[key] = sourceValue;
+					continue;
+				}
+				if (typeof sourceValue === "object" && sourceValue !== null) {
+					target[key] = shallowClone(key in target && typeof target[key] === "object" && target[key] !== null ? target[key] : {});
+					stack.push({
+						target: target[key],
+						source: sourceValue
+					});
+				} else target[key] = sourceValue;
+			}
+		}
+		return result;
+	}
+	return mergeFn;
+}
+/**
+* @deprecated Use `createMerge()` instead.
+* Provided for backward compatibility with `Symbol.for("delete")` as the default delete marker.
+*/
+const merge = createMerge();
+
+//#endregion
+//#region src/store/selector.ts
+const ARRAY_METHODS = [
+	"map",
+	"filter",
+	"reduce",
+	"forEach",
+	"find",
+	"findIndex",
+	"some",
+	"every",
+	"includes",
+	"flatMap",
+	"flat",
+	"slice",
+	"splice"
+];
+/**
+* Manages reactive selectors with static path tracking.
+*
+* Selectors MUST be simple property accesses only — no transformations,
+* no iterations, no conditionals. Use store effects for derivations instead.
+*
+* Cache strategy: paths-only.
+* Because selectors are guaranteed to be pure property accessors, two selectors
+* that access the same set of paths are semantically identical and share a single
+* SelectorEntry. There is no WeakMap ref-cache (refs are unstable for inline
+* arrows) and no function-body component in the key (redundant given the
+* invariant). The sorted, pipe-joined path set is the complete identity of a
+* selector.
+*
+* Lifetime: reference-counted with deferred cleanup.
+* When the subscriber count reaches zero we schedule cleanup on a setTimeout(0)
+* rather than destroying the entry immediately. This absorbs React Strict Mode's
+* subscribe → unsubscribe → re-subscribe cycle, which otherwise causes a
+* re-initialisation storm (new id, lost lastResult, spurious re-renders).
+* If count is still zero when the timer fires, the entry is genuinely abandoned
+* and is evicted cleanly.
+*
+* @template T - The type of the root state object.
+*/
+var SelectorManager = class {
+	reactiveSelectors = /* @__PURE__ */ new Map();
+	/**
+	* Single source of truth for caching. Key: sorted paths joined by "|".
+	* Maps to the live SelectorEntry (not just the ReactiveSelector facade),
+	* so ref-counting and deferred cleanup operate on the same object.
+	*/
+	pathBasedCache = /* @__PURE__ */ new Map();
+	/** Reverse lookup: Path -> Set of Selector IDs for O(1) update dispatch. */
+	dependencyMap = /* @__PURE__ */ new Map();
+	getState;
+	eventBus;
+	unsubscribeFromStore;
+	constructor(getState, eventBus) {
+		this.getState = getState;
+		this.eventBus = eventBus;
+		this.unsubscribeFromStore = this.eventBus.subscribe("update:complete", this.handleStoreUpdate);
+	}
+	handleStoreUpdate = (payload) => {
+		const selectorsToEvaluate = /* @__PURE__ */ new Set();
+		const divider = ".";
+		for (const delta of payload.deltas) {
+			const changedPath = delta.path;
+			for (const [registeredPath, dependents] of this.dependencyMap) if (registeredPath === changedPath || registeredPath.startsWith(changedPath + divider) || changedPath.startsWith(registeredPath + divider)) for (const id of dependents) selectorsToEvaluate.add(id);
+		}
+		for (const id of selectorsToEvaluate) {
+			const entry = this.reactiveSelectors.get(id);
+			if (entry) this.evaluateEntry(entry);
+		}
+	};
+	evaluateEntry(entry) {
+		let newResult;
+		try {
+			newResult = entry.selector(this.getState());
+		} catch {
+			newResult = void 0;
+		}
+		if (newResult !== entry.lastResult) {
+			entry.lastResult = newResult;
+			for (const cb of entry.subscribers) cb(newResult);
+			this.eventBus.emit({
+				name: "selector:changed",
+				payload: {
+					selectorId: entry.id,
+					newResult,
+					timestamp: Date.now()
+				}
+			});
+		}
+	}
+	createReactiveSelector(selector) {
+		const accessedPaths = buildPaths(selector);
+		const pathCacheKey = [...accessedPaths].sort().join("|");
+		const cachedEntry = this.pathBasedCache.get(pathCacheKey);
+		if (cachedEntry) {
+			if (cachedEntry.cleanupTimer !== void 0) {
+				clearTimeout(cachedEntry.cleanupTimer);
+				cachedEntry.cleanupTimer = void 0;
+			}
+			return cachedEntry.reactiveSelectorInstance;
+		}
+		const id = `sel-${Math.random().toString(36).slice(2, 9)}`;
+		const entry = {
+			id,
+			selector,
+			lastResult: selector(this.getState()),
+			accessedPaths,
+			subscribers: /* @__PURE__ */ new Set(),
+			count: 0,
+			cleanupTimer: void 0,
+			pathCacheKey,
+			reactiveSelectorInstance: null
+		};
+		for (const path of accessedPaths) {
+			if (!this.dependencyMap.has(path)) this.dependencyMap.set(path, /* @__PURE__ */ new Set());
+			this.dependencyMap.get(path).add(id);
+		}
+		const reactiveSelector = {
+			id,
+			/**
+			* Always recomputes from current state.
+			*
+			* useSyncExternalStore requires getSnapshot() to be consistent with
+			* the external store at the moment it is called — returning a cached
+			* lastResult risks a stale snapshot if state changed between the last
+			* evaluateEntry call and this render. Direct recomputation is safe
+			* because selectors are pure, cheap property accessors.
+			*
+			* If the selector throws (e.g. accessing a path that has been deleted
+			* from state), we return undefined rather than crashing the caller.
+			* This mirrors evaluateEntry's behaviour so get() and subscribers
+			* stay consistent.
+			*/
+			get: () => {
+				try {
+					return entry.selector(this.getState());
+				} catch {
+					return;
+				}
+			},
+			/**
+			* subscribe is the hot path for useSyncExternalStore.
+			*
+			* Cancels any pending deferred cleanup so React Strict Mode's
+			* unsubscribe → re-subscribe cycle never destroys a live entry.
+			* Returns a stable unsubscribe function whose only job is
+			* ref-counting and scheduling deferred cleanup.
+			*/
+			subscribe: (callback) => {
+				if (entry.cleanupTimer !== void 0) {
+					clearTimeout(entry.cleanupTimer);
+					entry.cleanupTimer = void 0;
+				}
+				entry.subscribers.add(callback);
+				entry.count++;
+				return () => {
+					entry.subscribers.delete(callback);
+					entry.count--;
+					if (entry.count === 0) entry.cleanupTimer = setTimeout(() => {
+						if (entry.count === 0) this.evictEntry(entry);
+					}, 0);
+				};
+			}
+		};
+		entry.reactiveSelectorInstance = reactiveSelector;
+		this.reactiveSelectors.set(id, entry);
+		this.pathBasedCache.set(pathCacheKey, entry);
+		this.eventBus.emit({
+			name: "selector:accessed",
+			payload: {
+				selectorId: id,
+				accessedPaths,
+				duration: 0,
+				timestamp: Date.now()
+			}
+		});
+		return reactiveSelector;
+	}
+	/**
+	* Fully removes a selector entry from all internal maps.
+	* Only called from the deferred cleanup timer, after confirming count === 0.
+	*/
+	evictEntry(entry) {
+		for (const path of entry.accessedPaths) {
+			const dependents = this.dependencyMap.get(path);
+			if (dependents) {
+				dependents.delete(entry.id);
+				if (dependents.size === 0) this.dependencyMap.delete(path);
+			}
+		}
+		this.reactiveSelectors.delete(entry.id);
+		this.pathBasedCache.delete(entry.pathCacheKey);
+	}
+	dispose() {
+		this.unsubscribeFromStore();
+		this.reactiveSelectors.clear();
+		this.dependencyMap.clear();
+		this.pathBasedCache.clear();
+	}
+};
+/**
+* Builds an array of leaf paths accessed by a selector.
+* Uses static proxy-based analysis — the selector is run with a proxy tree,
+* never against real state.
+*
+* Works reliably ONLY for simple property access patterns:
+*   state.user.name
+*   state.items[0].value
+*   state.config.theme.colors.primary
+*
+* Does NOT work for (and will throw):
+*   state.items.map(...)          — array iteration
+*   state.user.isAdmin ? ... : .. — conditionals (valueOf coercion)
+*   state.a + state.b             — arithmetic (valueOf coercion)
+*   'key' in state                — in operator
+*
+* @param selector - The selector function to analyse
+* @param divider  - The path separator (default: ".")
+* @returns Sorted array of leaf paths accessed by the selector
+*
+* @throws {Error} If the selector attempts any operation beyond property access
+*/
+function buildPaths(selector, divider = ".") {
+	const leafPaths = /* @__PURE__ */ new Set();
+	const proxyCache = /* @__PURE__ */ new Map();
+	const createProxy = (currentPathString = "") => {
+		if (proxyCache.has(currentPathString)) return proxyCache.get(currentPathString);
+		const proxy = new Proxy(() => {}, {
+			get: (_, prop) => {
+				if (typeof prop === "symbol" || prop === "then") return;
+				if (prop === "valueOf" || prop === "toString") throw new Error("Cannot perform logic, arithmetic, or string operations inside a selector.");
+				if (ARRAY_METHODS.includes(prop)) throw new Error(`Array method .${prop}() is not allowed in selectors.`);
+				const newPathString = currentPathString ? `${currentPathString}${divider}${prop}` : prop;
+				if (currentPathString) leafPaths.delete(currentPathString);
+				leafPaths.add(newPathString);
+				return createProxy(newPathString);
+			},
+			has: () => {
+				throw new Error("The 'in' operator is not allowed in selectors.");
+			},
+			apply: () => {
+				throw new Error("Selectors cannot call functions or methods.");
+			}
+		});
+		proxyCache.set(currentPathString, proxy);
+		return proxy;
+	};
+	try {
+		selector(createProxy());
+	} catch (error) {
+		throw new Error(`Selector failed during path analysis. Selectors must be simple property accessors only. Error: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return Array.from(leafPaths);
+}
+
+//#endregion
+//#region src/store/diff.ts
+/**
+* A performant deep equality check for any value.
+* Faster than JSON.stringify for comparisons.
+*/
+function isEqual(a, b) {
+	if (a === b) return true;
+	if (a && b && typeof a === "object" && typeof b === "object") {
+		if (a.constructor !== b.constructor) return false;
+		let length, i;
+		if (Array.isArray(a)) {
+			length = a.length;
+			if (length != b.length) return false;
+			for (i = length; i-- > 0;) if (!isEqual(a[i], b[i])) return false;
+			return true;
+		}
+		const [aKeys, bKeys] = [Object.keys(a), Object.keys(b)];
+		length = aKeys.length;
+		if (length !== bKeys.length) return false;
+		for (i = length; i-- > 0;) {
+			const key = aKeys[i];
+			if (!Object.prototype.hasOwnProperty.call(b, key) || !isEqual(a[key], b[key])) return false;
+		}
+		return true;
+	}
+	return a !== a && b !== b;
+}
+/**
+* Creates a diff function with configurable options.
+*
+* @param {object} options - Configuration options for the diff function.
+* @param {symbol} [options.deleteMarker] - A custom symbol to mark properties for deletion.
+*/
+function createDiff(options) {
+	const deleteSymbol = options?.deleteMarker || DELETE_SYMBOL;
+	function diffFn(original, partial) {
+		const deltas = [];
+		const stack = [{
+			pathStr: "",
+			orig: original || {},
+			part: partial || {}
+		}];
+		while (stack.length > 0) {
+			const { pathStr, orig, part } = stack.pop();
+			if (part === null || part === void 0) continue;
+			if (!isEqual(orig, part)) {
+				if (typeof part === "object" && !Array.isArray(part)) for (const key of Object.keys(part)) {
+					const newPathStr = pathStr ? pathStr + "." + key : key;
+					const partValue = part[key];
+					const origValue = orig && typeof orig === "object" ? orig[key] : void 0;
+					if (partValue === deleteSymbol) {
+						if (origValue !== void 0) deltas.push({
+							path: newPathStr,
+							oldValue: origValue,
+							newValue: void 0
+						});
+						continue;
+					}
+					if (typeof partValue === "object" && partValue !== null) stack.push({
+						pathStr: newPathStr,
+						orig: origValue,
+						part: partValue
+					});
+					else if (!isEqual(origValue, partValue)) deltas.push({
+						path: newPathStr,
+						oldValue: origValue,
+						newValue: partValue
+					});
+				}
+				else if (pathStr) deltas.push({
+					path: pathStr,
+					oldValue: orig,
+					newValue: part
+				});
+			}
+		}
+		return deltas;
+	}
+	return diffFn;
+}
+/**
+* Creates a derivePaths function with configurable options.
+*
+* @param {object} options - Configuration options for the derivePaths function.
+* @param {symbol} [options.deleteMarker=Symbol.for("delete")] - A custom symbol to mark properties for deletion.
+*/
+function createDerivePaths(options) {
+	const deleteSymbol = options?.deleteMarker || DELETE_SYMBOL;
+	/**
+	* Computes all touched paths from a DeepPartial changes object.
+	* Each key at every level of nesting is a path, including intermediate
+	* parent paths. The stack naturally visits parents before children, so
+	* parent paths are added as each object level is processed — no
+	* secondary backfill loop needed.
+	*/
+	function derivePathsFn(changes) {
+		const paths = /* @__PURE__ */ new Set();
+		const stack = [{
+			obj: changes,
+			currentPath: ""
+		}];
+		while (stack.length > 0) {
+			const { obj, currentPath } = stack.pop();
+			if (obj === null || obj === void 0 || typeof obj !== "object" || Array.isArray(obj)) continue;
+			for (const key of Object.keys(obj)) {
+				const newPath = currentPath ? `${currentPath}.${key}` : key;
+				paths.add(newPath);
+				const value = obj[key];
+				if (typeof value === "object" && value !== null && !Array.isArray(value) && value !== deleteSymbol) stack.push({
+					obj: value,
+					currentPath: newPath
+				});
+			}
+		}
+		return Array.from(paths);
+	}
+	return derivePathsFn;
+}
+/**
+* @deprecated Use `createDiff()` instead.
+* Provided for backward compatibility with `Symbol.for("delete")` as the default delete marker.
+*/
+const diff = createDiff();
+/**
+* @deprecated Use `createDerivePaths()` instead.
+* Provided for backward compatibility with `Symbol.for("delete")` as the default delete marker.
+*/
+const derivePaths = createDerivePaths();
+
+//#endregion
+//#region src/store/state.ts
+/**
+* Core state management component - handles pure state operations
+*/
+var StateManager = class {
+	updateBus;
+	diff;
+	cache;
+	/**
+	* Creates an instance of CoreStateManager.
+	* @param initialData The initial state of the store.
+	* @param updateBus The event bus to notify listeners of updates.
+	* @param diff The function to calculate the difference between two states.
+	*/
+	constructor(initialData, updateBus, diff) {
+		this.updateBus = updateBus;
+		this.diff = diff;
+		this.cache = structuredClone(initialData);
+	}
+	/**
+	* Gets the current state of the store.
+	* @param clone If true, returns a deep clone of the state. Defaults to false.
+	* @returns The current state.
+	*/
+	get(clone) {
+		if (clone) return structuredClone(this.cache);
+		return this.cache;
+	}
+	/**
+	* Applies changes to the state and notifies listeners.
+	* @param newState The new state to apply.
+	* @returns An array of paths that were changed.
+	*/
+	applyChanges(newState, force = false, clone = false, changes = []) {
+		if (force) {
+			this.cache = clone ? structuredClone(newState) : newState;
+			this.notifyListeners([]);
+			return [];
+		}
+		if (changes.length === 0) changes = [newState];
+		const state = this.get(false);
+		const deltaMap = /* @__PURE__ */ new Map();
+		for (let i = 0; i < changes.length; i++) {
+			const partial = changes[i];
+			const diffs = this.diff(state, partial);
+			for (let j = 0; j < diffs.length; j++) {
+				const d = diffs[j];
+				deltaMap.set(d.path, d);
+			}
+		}
+		const deltas = deltaMap.size ? [...deltaMap.values()] : [];
+		if (deltas.length > 0) {
+			this.cache = clone ? structuredClone(newState) : newState;
+			const changed = /* @__PURE__ */ new Set();
+			for (let i = 0; i < deltas.length; i++) {
+				let p = deltas[i].path;
+				while (p) {
+					if (!changed.has(p)) changed.add(p);
+					else break;
+					const dot = p.lastIndexOf(".");
+					if (dot < 0) break;
+					p = p.slice(0, dot);
+				}
+			}
+			this.notifyListeners(changed);
+		}
+		return deltas;
+	}
+	/**
+	* Notifies listeners of changes to the state.
+	* @param changedPaths An array of paths that were changed.
+	*/
+	notifyListeners(changedPaths) {
+		for (const changed of changedPaths) this.updateBus.emit({
+			name: "update",
+			payload: changed
+		});
+	}
+};
+
+//#endregion
+//#region src/store/middleware.ts
+/**
+* Middleware execution engine - handles all middleware processing
+*/
+var MiddlewareEngine = class {
+	eventBus;
+	executionState;
+	merge;
+	logger;
+	middleware = [];
+	blockingMiddleware = [];
+	constructor(eventBus, executionState, merge, logger) {
+		this.eventBus = eventBus;
+		this.executionState = executionState;
+		this.merge = merge;
+		this.logger = logger;
+	}
+	async executeBlocking(currentState, partialUpdate) {
+		for (const { fn, name, id } of this.blockingMiddleware) {
+			const execInfo = {
+				id,
+				name,
+				startTime: Date.now()
+			};
+			this.executionState.runningMiddleware = {
+				id,
+				name,
+				startTime: Date.now()
+			};
+			this.emitMiddlewareLifecycle("start", {
+				id,
+				name,
+				type: "blocking"
+			});
+			try {
+				const result = await Promise.resolve(fn(currentState, partialUpdate));
+				execInfo.endTime = Date.now();
+				execInfo.duration = execInfo.endTime - execInfo.startTime;
+				if (result === false) {
+					execInfo.blocked = true;
+					this.emitMiddlewareLifecycle("blocked", {
+						id,
+						name,
+						duration: execInfo.duration
+					});
+					this.emit(this.eventBus, {
+						name: "middleware:executed",
+						payload: execInfo
+					});
+					return { blocked: true };
+				}
+				this.emitMiddlewareLifecycle("complete", {
+					id,
+					name,
+					type: "blocking",
+					duration: execInfo.duration
+				});
+				this.emit(this.eventBus, {
+					name: "middleware:executed",
+					payload: {
+						...execInfo,
+						blocked: false
+					}
+				});
+			} catch (error) {
+				execInfo.endTime = Date.now();
+				execInfo.duration = execInfo.endTime - execInfo.startTime;
+				execInfo.error = error instanceof Error ? error : new Error(String(error));
+				execInfo.blocked = true;
+				this.emitMiddlewareError(id, name, execInfo.error, execInfo.duration);
+				this.emit(this.eventBus, {
+					name: "middleware:executed",
+					payload: execInfo
+				});
+				return {
+					blocked: true,
+					error: execInfo.error
+				};
+			} finally {
+				this.executionState.runningMiddleware = null;
+			}
+		}
+		return { blocked: false };
+	}
+	async executeTransform(initialState, partialUpdate) {
+		let currentState = initialState;
+		let changes = partialUpdate;
+		for (const { fn, name, id } of this.middleware) {
+			const execInfo = {
+				id,
+				name,
+				startTime: Date.now()
+			};
+			this.executionState.runningMiddleware = {
+				id,
+				name,
+				startTime: Date.now()
+			};
+			this.emitMiddlewareLifecycle("start", {
+				id,
+				name,
+				type: "transform"
+			});
+			try {
+				const middlewareResult = await Promise.resolve(fn(currentState, partialUpdate));
+				execInfo.endTime = Date.now();
+				execInfo.duration = execInfo.endTime - execInfo.startTime;
+				execInfo.blocked = false;
+				if (middlewareResult && typeof middlewareResult === "object") {
+					currentState = this.merge(currentState, middlewareResult);
+					changes = this.merge(changes, middlewareResult);
+				}
+				this.emit(this.eventBus, {
+					name: "middleware:executed",
+					payload: execInfo
+				});
+				this.emitMiddlewareLifecycle("complete", {
+					id,
+					name,
+					type: "transform",
+					duration: execInfo.duration
+				});
+			} catch (e) {
+				execInfo.endTime = Date.now();
+				execInfo.duration = execInfo.endTime - execInfo.startTime;
+				execInfo.error = e instanceof Error ? e : new Error(String(e));
+				execInfo.blocked = false;
+				this.emit(this.eventBus, {
+					name: "middleware:executed",
+					payload: execInfo
+				});
+				this.emitMiddlewareError(id, name, execInfo.error, execInfo.duration);
+				this.logger.error("Middleware error", {
+					name,
+					error: e
+				});
+			} finally {
+				this.executionState.runningMiddleware = null;
+			}
+		}
+		return changes;
+	}
+	addMiddleware(middleware, name = "unnamed-middleware") {
+		const id = this.generateId();
+		this.middleware.push({
+			fn: middleware,
+			name,
+			id
+		});
+		this.updateExecutionState();
+		return id;
+	}
+	addBlockingMiddleware(middleware, name = "unnamed-blocking-middleware") {
+		const id = this.generateId();
+		this.blockingMiddleware.push({
+			fn: middleware,
+			name,
+			id
+		});
+		this.updateExecutionState();
+		return id;
+	}
+	removeMiddleware(id) {
+		const initialLength = this.middleware.length + this.blockingMiddleware.length;
+		this.middleware = this.middleware.filter((m) => m.id !== id);
+		this.blockingMiddleware = this.blockingMiddleware.filter((m) => m.id !== id);
+		this.updateExecutionState();
+		return this.middleware.length + this.blockingMiddleware.length < initialLength;
+	}
+	updateExecutionState() {
+		this.executionState.middlewares = [...this.middleware.map((m) => m.name), ...this.blockingMiddleware.map((m) => m.name)];
+	}
+	emitMiddlewareLifecycle(phase, data) {
+		this.emit(this.eventBus, {
+			name: `middleware:${phase}`,
+			payload: {
+				...data,
+				timestamp: Date.now()
+			}
+		});
+	}
+	emitMiddlewareError(id, name, error, duration) {
+		this.emit(this.eventBus, {
+			name: "middleware:error",
+			payload: {
+				id,
+				name,
+				error,
+				duration,
+				timestamp: Date.now()
+			}
+		});
+	}
+	generateId() {
+		return crypto.randomUUID ? crypto.randomUUID() : `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+	}
+	emit(bus, event) {
+		queueMicrotask(() => {
+			bus.emit(event);
+		});
+	}
+};
+
+//#endregion
+//#region src/store/logger.ts
+let noopLogger;
+function createStoreLogger(logger) {
+	if (logger) return logger;
+	if (!noopLogger) noopLogger = new Logger([]);
+	return noopLogger;
+}
+
+//#endregion
+//#region src/store/persistence.ts
+/**
+* Persistence management component - handles all persistence operations
+* Supports background persistence for better UI performance.
+*/
+var PersistenceHandler = class {
+	eventBus;
+	coreState;
+	persistence;
+	instanceID;
+	persistenceReady = false;
+	backgroundQueue = [];
+	isProcessingQueue = false;
+	maxRetries = 3;
+	retryDelay = 1e3;
+	queueProcessor;
+	/**
+	* Tracks tasks that are pending retry. These are held outside the main
+	* queue until their backoff delay has elapsed, at which point they are
+	* re-inserted. This prevents the processQueue while-loop from immediately
+	* picking up a retried task before its delay has passed.
+	*/
+	pendingRetries = /* @__PURE__ */ new Set();
+	logger;
+	constructor(eventBus, coreState, instanceID, options) {
+		this.eventBus = eventBus;
+		this.coreState = coreState;
+		this.instanceID = instanceID;
+		this.maxRetries = options?.maxRetries ?? 3;
+		this.retryDelay = options?.retryDelay ?? 1e3;
+		this.logger = options?.logger ?? createStoreLogger();
+	}
+	async initialize(persistence) {
+		if (persistence) await this.setPersistence(persistence);
+		else this.setPersistenceReady();
+	}
+	isReady() {
+		return this.persistenceReady;
+	}
+	/**
+	* Handle state changes with background persistence.
+	* Returns immediately for optimistic updates.
+	*/
+	handleStateChange(changedPaths, state) {
+		if (!this.persistence || changedPaths.length === 0) return;
+		const task = {
+			id: `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
+			state: structuredClone(state),
+			changedPaths: [...changedPaths],
+			timestamp: Date.now(),
+			retries: 0
+		};
+		this.backgroundQueue.push(task);
+		this.scheduleQueueProcessing();
+		this.emit(this.eventBus, {
+			name: "persistence:queued",
+			payload: {
+				taskId: task.id,
+				changedPaths,
+				queueSize: this.backgroundQueue.length,
+				timestamp: task.timestamp
+			}
+		});
+	}
+	/**
+	* Get current persistence queue status.
+	*/
+	getQueueStatus() {
+		return {
+			queueSize: this.backgroundQueue.length,
+			isProcessing: this.isProcessingQueue,
+			pendingRetries: this.pendingRetries.size,
+			oldestTask: this.backgroundQueue[0]?.timestamp
+		};
+	}
+	/**
+	* Force immediate processing of the persistence queue.
+	* Waits for any in-progress processing to complete first.
+	*/
+	async flush() {
+		if (this.isProcessingQueue) await new Promise((resolve) => {
+			const check = () => {
+				if (!this.isProcessingQueue) resolve();
+				else setTimeout(check, 10);
+			};
+			check();
+		});
+		await this.processQueue();
+	}
+	/**
+	* Discards all pending (unprocessed) tasks in the queue.
+	* Any tasks currently being processed or awaiting retry are also dropped.
+	* WARNING: This will result in data loss for any queued writes that have
+	* not yet been persisted. Prefer flush() for safe teardown.
+	*/
+	discardQueue() {
+		const discardedTasks = this.backgroundQueue.length + this.pendingRetries.size;
+		this.backgroundQueue = [];
+		this.pendingRetries.clear();
+		if (this.queueProcessor) {
+			clearTimeout(this.queueProcessor);
+			this.queueProcessor = void 0;
+		}
+		this.emit(this.eventBus, {
+			name: "persistence:queue_cleared",
+			payload: {
+				clearedTasks: discardedTasks,
+				timestamp: Date.now()
+			}
+		});
+	}
+	scheduleQueueProcessing() {
+		if (this.queueProcessor || this.isProcessingQueue) return;
+		this.queueProcessor = setTimeout(() => {
+			this.processQueue().catch((error) => {
+				this.logger.error("Queue processing failed", { error });
+			});
+		}, 10);
+	}
+	async processQueue() {
+		if (this.isProcessingQueue || this.backgroundQueue.length === 0) return;
+		this.isProcessingQueue = true;
+		this.queueProcessor = void 0;
+		try {
+			while (this.backgroundQueue.length > 0) {
+				const task = this.backgroundQueue.shift();
+				await this.processTask(task);
+			}
+		} finally {
+			this.isProcessingQueue = false;
+		}
+	}
+	async processTask(task) {
+		try {
+			if (await this.persistence.set(this.instanceID, task.state)) this.emit(this.eventBus, {
+				name: "persistence:success",
+				payload: {
+					taskId: task.id,
+					changedPaths: task.changedPaths,
+					duration: Date.now() - task.timestamp,
+					timestamp: Date.now()
+				}
+			});
+			else await this.handleTaskFailure(task, /* @__PURE__ */ new Error("Persistence returned false"));
+		} catch (error) {
+			await this.handleTaskFailure(task, error);
+		}
+	}
+	async handleTaskFailure(task, error) {
+		task.retries++;
+		if (task.retries <= this.maxRetries) {
+			const delay = this.retryDelay * Math.pow(2, task.retries - 1);
+			this.emit(this.eventBus, {
+				name: "persistence:retry",
+				payload: {
+					taskId: task.id,
+					attempt: task.retries,
+					maxRetries: this.maxRetries,
+					nextRetryIn: delay,
+					error,
+					timestamp: Date.now()
+				}
+			});
+			this.pendingRetries.add(task.id);
+			setTimeout(() => {
+				if (this.pendingRetries.has(task.id)) {
+					this.pendingRetries.delete(task.id);
+					this.backgroundQueue.unshift(task);
+					this.scheduleQueueProcessing();
+				}
+			}, delay);
+		} else this.emit(this.eventBus, {
+			name: "persistence:failed",
+			payload: {
+				taskId: task.id,
+				changedPaths: task.changedPaths,
+				attempts: task.retries,
+				error,
+				timestamp: Date.now()
+			}
+		});
+	}
+	setPersistenceReady() {
+		this.persistenceReady = true;
+		this.emit(this.eventBus, {
+			name: "persistence:ready",
+			payload: { timestamp: Date.now() }
+		});
+	}
+	async setPersistence(persistence) {
+		this.persistence = persistence;
+		try {
+			const persistedState = await this.persistence.get();
+			if (persistedState) this.coreState.applyChanges(persistedState);
+		} catch (error) {
+			this.logger.error("Failed to initialize persistence", { error });
+			this.emit(this.eventBus, {
+				name: "persistence:init_error",
+				payload: {
+					error,
+					timestamp: Date.now()
+				}
+			});
+		} finally {
+			this.setPersistenceReady();
+		}
+		this.persistence.subscribe(this.instanceID, async (state) => {
+			const changedPaths = this.coreState.applyChanges(state);
+			if (changedPaths.length > 0) this.emit(this.eventBus, {
+				name: "update:complete",
+				payload: {
+					changedPaths,
+					source: "external",
+					timestamp: Date.now()
+				}
+			});
+		});
+	}
+	/**
+	* Cleanup method for proper resource disposal.
+	* Discards any unprocessed tasks — call flush() first if writes must not be lost.
+	*/
+	async dispose() {
+		this.discardQueue();
+		this.isProcessingQueue = false;
+		this.persistenceReady = false;
+		await (this.persistence?.close && this.persistence.close());
+	}
+	emit(bus, event) {
+		queueMicrotask(() => {
+			bus.emit(event);
+		});
+	}
+};
+
+//#endregion
+//#region src/store/transactions.ts
+/**
+* Transaction management component - handles transactional operations
+*/
+var TransactionManager = class {
+	eventBus;
+	coreState;
+	executionState;
+	constructor(eventBus, coreState, executionState) {
+		this.eventBus = eventBus;
+		this.coreState = coreState;
+		this.executionState = executionState;
+	}
+	async execute(operation) {
+		const snapshot = this.coreState.get(true);
+		this.executionState.transactionActive = true;
+		this.emit(this.eventBus, {
+			name: "transaction:start",
+			payload: { timestamp: Date.now() }
+		});
+		try {
+			const result = await Promise.resolve(operation());
+			this.emit(this.eventBus, {
+				name: "transaction:complete",
+				payload: { timestamp: Date.now() }
+			});
+			this.executionState.transactionActive = false;
+			return result;
+		} catch (error) {
+			this.coreState.applyChanges(snapshot, true, false);
+			this.emit(this.eventBus, {
+				name: "transaction:error",
+				payload: {
+					error: error instanceof Error ? error : new Error(String(error)),
+					timestamp: Date.now()
+				}
+			});
+			this.executionState.transactionActive = false;
+			throw error;
+		}
+	}
+	emit(bus, event) {
+		queueMicrotask(() => {
+			bus.emit(event);
+		});
+	}
+};
+
+//#endregion
+//#region src/store/metrics.ts
+/**
+* Event-driven metrics collector - derives metrics from event stream
+* Now properly implements the full StoreMetrics interface
+*/
+var MetricsCollector = class {
+	updateCount = 0;
+	listenerExecutions = 0;
+	averageUpdateTime = 0;
+	largestUpdateSize = 0;
+	mostActiveListenerPaths = [];
+	totalUpdates = 0;
+	blockedUpdates = 0;
+	averageUpdateDuration = 0;
+	middlewareExecutions = 0;
+	transactionCount = 0;
+	totalEventsFired = 0;
+	totalActionsDispatched = 0;
+	totalActionsSucceeded = 0;
+	totalActionsFailed = 0;
+	averageActionDuration = 0;
+	updateTimes = [];
+	actionTimes = [];
+	pathExecutionCounts = /* @__PURE__ */ new Map();
+	constructor(eventBus) {
+		this.setupEventListeners(eventBus);
+	}
+	getMetrics() {
+		return {
+			updateCount: this.updateCount,
+			listenerExecutions: this.listenerExecutions,
+			averageUpdateTime: this.averageUpdateTime,
+			largestUpdateSize: this.largestUpdateSize,
+			mostActiveListenerPaths: [...this.mostActiveListenerPaths],
+			totalUpdates: this.totalUpdates,
+			blockedUpdates: this.blockedUpdates,
+			averageUpdateDuration: this.averageUpdateDuration,
+			middlewareExecutions: this.middlewareExecutions,
+			transactionCount: this.transactionCount,
+			totalEventsFired: this.totalEventsFired,
+			totalActionsDispatched: this.totalActionsDispatched,
+			totalActionsSucceeded: this.totalActionsSucceeded,
+			totalActionsFailed: this.totalActionsFailed,
+			averageActionDuration: this.averageActionDuration
+		};
+	}
+	setupEventListeners(eventBus) {
+		const originalEmit = eventBus.emit;
+		eventBus.emit = (event) => {
+			this.totalEventsFired++;
+			return originalEmit.call(eventBus, event);
+		};
+		eventBus.subscribe("update:complete", (data) => {
+			this.totalUpdates++;
+			if (data.blocked) {
+				this.blockedUpdates++;
+				return;
+			}
+			if (data.duration) {
+				this.updateTimes.push(data.duration);
+				if (this.updateTimes.length > 100) this.updateTimes.shift();
+				const average = this.updateTimes.reduce((a, b) => a + b, 0) / this.updateTimes.length;
+				this.averageUpdateTime = average;
+				this.averageUpdateDuration = average;
+			}
+			if (data.deltas?.length) {
+				this.updateCount++;
+				this.largestUpdateSize = Math.max(this.largestUpdateSize, data.deltas.length);
+				data.deltas.forEach((delta) => {
+					const current = this.pathExecutionCounts.get(delta.path) || 0;
+					this.pathExecutionCounts.set(delta.path, current + 1);
+				});
+				this.mostActiveListenerPaths = Array.from(this.pathExecutionCounts.entries()).sort(([, a], [, b]) => b - a).slice(0, 5).map(([path]) => path);
+			}
+		});
+		eventBus.subscribe("middleware:start", () => {
+			this.middlewareExecutions++;
+		});
+		eventBus.subscribe("transaction:start", () => {
+			this.transactionCount++;
+		});
+		eventBus.subscribe("action:start", () => {
+			this.totalActionsDispatched++;
+		});
+		eventBus.subscribe("action:complete", (data) => {
+			this.totalActionsSucceeded++;
+			if (data.duration) {
+				this.actionTimes.push(data.duration);
+				if (this.actionTimes.length > 100) this.actionTimes.shift();
+				this.averageActionDuration = this.actionTimes.reduce((a, b) => a + b, 0) / this.actionTimes.length;
+			}
+		});
+		eventBus.subscribe("action:error", () => {
+			this.totalActionsFailed++;
+		});
+	}
+	/**
+	* Reset all metrics to initial state
+	*/
+	reset() {
+		this.updateCount = 0;
+		this.listenerExecutions = 0;
+		this.averageUpdateTime = 0;
+		this.largestUpdateSize = 0;
+		this.mostActiveListenerPaths = [];
+		this.totalUpdates = 0;
+		this.blockedUpdates = 0;
+		this.averageUpdateDuration = 0;
+		this.middlewareExecutions = 0;
+		this.transactionCount = 0;
+		this.totalEventsFired = 0;
+		this.totalActionsDispatched = 0;
+		this.totalActionsSucceeded = 0;
+		this.totalActionsFailed = 0;
+		this.averageActionDuration = 0;
+		this.updateTimes = [];
+		this.actionTimes = [];
+		this.pathExecutionCounts.clear();
+	}
+	/**
+	* Get detailed metrics breakdown
+	*/
+	getDetailedMetrics() {
+		return {
+			pathExecutionCounts: new Map(this.pathExecutionCounts),
+			recentUpdateTimes: [...this.updateTimes],
+			successRate: this.totalUpdates > 0 ? (this.totalUpdates - this.blockedUpdates) / this.totalUpdates : 1,
+			averagePathsPerUpdate: this.updateCount > 0 ? Array.from(this.pathExecutionCounts.values()).reduce((a, b) => a + b, 0) / this.updateCount : 0
+		};
+	}
+	/**
+	* Cleanup method for proper resource disposal
+	*/
+	dispose() {
+		this.reset();
+	}
+};
+
+//#endregion
+//#region src/store/actions.ts
+var ActionCancelledError = class extends Error {
+	constructor() {
+		super("Action Cancelled by Debounce");
+		this.name = "ActionCancelledError";
+	}
+};
+var UnknownActionError = class extends Error {
+	constructor({ action }) {
+		super(`Unknown action: "${action}"`);
+		this.name = "UnknownActionError";
+	}
+};
+const sentinel = () => {};
+const sentinelWatcher = {
+	name: "UNDEFINED ACTION",
+	status: () => false,
+	subscribe: (_) => () => {}
+};
+var ActionManager = class {
+	eventBus;
+	set;
+	registrations = /* @__PURE__ */ new Map();
+	constructor(eventBus, set) {
+		this.eventBus = eventBus;
+		this.set = set;
+	}
+	register(action) {
+		const registration = {
+			action: {
+				name: action.name,
+				id: v4(),
+				action: action.fn,
+				debounce: action.debounce ? {
+					...action.debounce,
+					condition: action.debounce.condition ?? (() => true)
+				} : void 0
+			},
+			debouncer: action.debounce && action.debounce.delay > 0 ? new Debouncer({ delay: action.debounce.delay }) : void 0,
+			previousArgs: void 0,
+			running: false,
+			subscription: {
+				listeners: /* @__PURE__ */ new Set(),
+				watcher: null,
+				watchers: new SharedResource(() => [
+					this.eventBus.subscribe("action:start", (p) => p.name === action.name && this.notifyStatusListeners(action.name)),
+					this.eventBus.subscribe("action:complete", (p) => p.name === action.name && this.notifyStatusListeners(action.name)),
+					this.eventBus.subscribe("action:error", (p) => p.name === action.name && this.notifyStatusListeners(action.name))
+				], (unsubs) => unsubs?.forEach((unsub) => unsub()), { gracePeriod: "microtask" })
+			}
+		};
+		this.registrations.set(action.name, registration);
+		return () => {
+			const reg = this.registrations.get(action.name);
+			if (!reg) return;
+			reg.debouncer?.cancel();
+			this.registrations.delete(action.name);
+		};
+	}
+	async dispatch(name, ...params) {
+		const reg = this.registrations.get(name);
+		if (!reg) throw new UnknownActionError({ action: name });
+		const { action, debouncer } = reg;
+		const { debounce } = action;
+		if (!debouncer || !debounce) return this.executeAction(reg, params);
+		const shouldDebounce = debounce.condition(reg.previousArgs, params);
+		reg.previousArgs = params;
+		if (!shouldDebounce) return this.executeAction(reg, params);
+		const debouncerResult = await debouncer.do(() => this.executeAction(reg, params));
+		if (debouncerResult.status === "cancelled") throw new ActionCancelledError();
+		if (debouncerResult.status === "error" && debouncerResult.error) throw debouncerResult.error;
+		return debouncerResult.value;
+	}
+	async executeAction(reg, params) {
+		const startTime = Date.now();
+		reg.running = true;
+		this.emit(this.eventBus, {
+			name: "action:start",
+			payload: {
+				actionId: reg.action.id,
+				name: reg.action.name,
+				params: params || [],
+				timestamp: startTime
+			}
+		});
+		try {
+			const result = await this.set((s) => reg.action.action(s, ...params), { actionId: reg.action.id });
+			const endTime = Date.now();
+			reg.running = false;
+			this.emit(this.eventBus, {
+				name: "action:complete",
+				payload: {
+					actionId: reg.action.id,
+					name: reg.action.name,
+					params,
+					startTime,
+					endTime,
+					duration: endTime - startTime,
+					result
+				}
+			});
+			return result;
+		} catch (error) {
+			const endTime = Date.now();
+			reg.running = false;
+			this.emit(this.eventBus, {
+				name: "action:error",
+				payload: {
+					actionId: reg.action.id,
+					name: reg.action.name,
+					params,
+					startTime,
+					endTime,
+					duration: endTime - startTime,
+					error
+				}
+			});
+			throw error;
+		}
+	}
+	running(name) {
+		const reg = this.registrations.get(name);
+		return reg ? reg.running : false;
+	}
+	subscribe(name, callback) {
+		const reg = this.registrations.get(name);
+		if (!reg) return sentinel;
+		reg.subscription.listeners.add(callback);
+		reg.subscription.watchers.acquire();
+		return () => {
+			reg.subscription.listeners.delete(callback);
+			reg.subscription.watchers?.release();
+		};
+	}
+	watch(name) {
+		const reg = this.registrations.get(name);
+		if (!reg) return sentinelWatcher;
+		if (!reg.subscription.watcher) reg.subscription.watcher = {
+			name,
+			status: () => this.running(name),
+			subscribe: (callback) => this.subscribe(name, callback)
+		};
+		return reg.subscription.watcher;
+	}
+	notifyStatusListeners(name) {
+		const listeners = this.registrations.get(name).subscription.listeners;
+		if (listeners) listeners.forEach((fn) => fn());
+	}
+	emit(bus, event) {
+		queueMicrotask(() => {
+			bus.emit(event);
+		});
+	}
+	dispose() {
+		for (const reg of this.registrations.values()) {
+			reg.debouncer?.cancel();
+			reg.subscription.watchers.forceCleanup;
+			reg.subscription.listeners.clear();
+		}
+		this.registrations.clear();
+	}
+};
+
+//#endregion
+//#region src/store/store.ts
+/**
+* Reactive Data Store Implementation - Updated for Concurrency and Performance
+* The public API is preserved for test compatibility.
+*/
+/**
+* Main ReactiveDataStore - a robust, type-safe state management solution.
+* It features optimistic updates, a Serializer-based update queue for safe serial
+* execution with backpressure, a Latch for async readiness gating, and decoupled
+* persistence.
+*
+* @template T The type of the data object managed by the store.
+*/
+var ReactiveDataStore = class {
+	/** Manages the core application state. */
+	coreState;
+	/** Orchestrates and executes middleware for state changes. */
+	middlewareEngine;
+	/** Manages saving state changes to a persistence layer. */
+	persistenceHandler;
+	/** Manages atomic state updates via transactions. */
+	transactionManager;
+	/** Collects and provides performance metrics for the store. */
+	metricsCollector;
+	selectorManager;
+	actions;
+	/**
+	* Serializer enforces FIFO serial execution of all state updates.
+	*
+	* Replaces the bare `Promise<T | void>` chain. Benefits over the old pattern:
+	* - Backpressure: rejects when the queue exceeds capacity rather than growing
+	*   unboundedly under write pressure.
+	* - Clean shutdown: `close()` in dispose() immediately rejects any subsequent
+	*   `set()` calls with a clear error instead of silently enqueuing them.
+	* - Observability: `updateSerializer.running()` and `updateSerializer.pending()`
+	*   replace the manually-managed `executionState.executing` flag.
+	* - Error isolation: errors in one update do not corrupt the queue — the
+	*   Serializer's mutex is always released in its own `finally` block.
+	*/
+	updateSerializer = new Serializer({
+		yieldMode: "macrotask",
+		capacity: 1e3
+	});
+	/**
+	* Latch that opens once the store is fully initialised (persistence loaded).
+	*
+	* Replaces the poll-only `isReady(): boolean` pattern. Callers can now
+	* `await store.ready()` with an optional timeout rather than polling or
+	* subscribing to an internal event. `isReady()` is preserved as `latch.isOpen()`
+	* for synchronous checks and backwards compatibility.
+	*/
+	readyLatch = new Latch();
+	disposeOnce = new Once();
+	updateBus;
+	eventBus;
+	executionState;
+	instanceID = v4();
+	merge;
+	diff;
+	logger;
+	/**
+	* Creates a new ReactiveDataStore instance.
+	*/
+	constructor(initialData, persistence, deleteMarker = DELETE_SYMBOL, options) {
+		this.logger = createStoreLogger(options?.logger);
+		this.eventBus = createEventBus(options?.broadcastChannel ? {
+			batch: {
+				size: 0,
+				delay: 0
+			},
+			broadcast: { channel: options.broadcastChannel }
+		} : void 0);
+		this.updateBus = createEventBus(options?.broadcastChannel ? {
+			batch: {
+				size: 0,
+				delay: 0
+			},
+			broadcast: { channel: options.broadcastChannel }
+		} : void 0);
+		this.executionState = {
+			executing: false,
+			changes: null,
+			pendingChanges: [],
+			middlewares: [],
+			runningMiddleware: null,
+			transactionActive: false
+		};
+		this.merge = createMerge({ deleteMarker });
+		this.diff = createDiff({ deleteMarker });
+		this.coreState = new StateManager(initialData, this.updateBus, this.diff);
+		this.middlewareEngine = new MiddlewareEngine(this.eventBus, this.executionState, this.merge, this.logger);
+		this.persistenceHandler = new PersistenceHandler(this.eventBus, this.coreState, this.instanceID, {
+			maxRetries: options?.persistenceMaxRetries,
+			retryDelay: options?.persistenceRetryDelay,
+			logger: this.logger
+		});
+		this.transactionManager = new TransactionManager(this.eventBus, this.coreState, this.executionState);
+		this.metricsCollector = new MetricsCollector(this.eventBus);
+		this.actions = new ActionManager(this.eventBus, this.set.bind(this));
+		this.persistenceHandler.initialize(persistence);
+		this.setupPersistenceListener();
+		this.setupReadyLatch();
+		this.selectorManager = new SelectorManager(this.get.bind(this), this.eventBus);
+	}
+	/**
+	* Returns true if the store has finished initialising (persistence loaded).
+	* For async flows, prefer `await store.ready()` over polling this.
+	*/
+	isReady() {
+		return this.readyLatch.isOpen();
+	}
+	/**
+	* Returns a promise that resolves once the store is fully initialised.
+	* Safe to call multiple times — all callers share the same latch.
+	*
+	* @param timeout - Optional maximum wait time in milliseconds.
+	* @throws {TimeoutError} If the store does not become ready within the timeout.
+	*
+	* @example
+	* await store.ready();
+	* const state = store.get();
+	*/
+	async ready(timeout) {
+		return this.readyLatch.wait(timeout);
+	}
+	state() {
+		this.executionState.executing = this.updateSerializer.running();
+		return this.executionState;
+	}
+	/**
+	* Gets the current state. Optimized default to return reference (false) for performance.
+	* @param clone If `true`, returns a deep clone (use sparingly).
+	* @returns The current state object.
+	*/
+	get(clone) {
+		return this.coreState.get(clone ?? false);
+	}
+	subset(paths, separator = ".") {
+		const result = {};
+		const state = this.get();
+		for (const path of paths) result[path] = path.split(separator).reduce((acc, key) => {
+			return acc && acc[key] !== void 0 ? acc[key] : void 0;
+		}, state);
+		return result;
+	}
+	select(selector) {
+		this.checkDisposed();
+		return this.selectorManager.createReactiveSelector(selector);
+	}
+	register(action) {
+		this.checkDisposed();
+		return this.actions.register(action);
+	}
+	async dispatch(name, ...params) {
+		this.checkDisposed();
+		return this.actions.dispatch(name, ...params);
+	}
+	/**
+	* Enqueues a state update for serial execution.
+	*
+	* Uses a `Serializer` internally, which guarantees:
+	* - FIFO ordering of all updates.
+	* - No concurrent execution — each update waits for the previous to complete.
+	* - Backpressure: throws if the queue exceeds capacity.
+	* - Clean rejection after `dispose()`.
+	*
+	* @returns A Promise that resolves with the new state T.
+	*/
+	async set(update, options = {}) {
+		this.checkDisposed();
+		const result = await this.updateSerializer.do(() => this._performUpdate(update, options));
+		if (result.error) throw result.error;
+		return result.value;
+	}
+	/**
+	* Internal logic for performing a single, sequential state update.
+	* Always called inside the Serializer — never call directly.
+	*/
+	async _performUpdate(update, options) {
+		const startTime = Date.now();
+		this.emit(this.eventBus, {
+			name: "update:start",
+			payload: {
+				timestamp: startTime,
+				actionId: options.actionId
+			}
+		});
+		try {
+			if (options.force) {
+				const currentState = this.get(false);
+				const finalState = typeof update === "function" ? update(currentState) : update;
+				this.coreState.applyChanges(finalState, true);
+				const endTime = Date.now();
+				this.emit(this.eventBus, {
+					name: "update:complete",
+					payload: {
+						deltas: [],
+						duration: endTime - startTime,
+						timestamp: Date.now(),
+						actionId: options.actionId,
+						newState: finalState
+					}
+				});
+				return finalState;
+			}
+			let partialState;
+			const currentState = this.get(false);
+			if (typeof update === "function") {
+				const res = update(currentState);
+				partialState = res instanceof Promise ? await res : res;
+			} else partialState = update;
+			const blockingResult = await this.middlewareEngine.executeBlocking(currentState, partialState);
+			if (blockingResult.blocked) throw blockingResult.error || /* @__PURE__ */ new Error("Update blocked by middleware");
+			const merged = this.merge(currentState, partialState);
+			const processed = await this.middlewareEngine.executeTransform(merged, partialState);
+			const finalState = this.merge(merged, processed);
+			const deltas = this.coreState.applyChanges(finalState, false, false, [partialState, processed]);
+			const endTime = Date.now();
+			const newState = this.get(false);
+			this.emit(this.eventBus, {
+				name: "update:complete",
+				payload: {
+					deltas,
+					duration: endTime - startTime,
+					timestamp: Date.now(),
+					actionId: options.actionId,
+					newState
+				}
+			});
+			return newState;
+		} catch (error) {
+			this.emit(this.eventBus, {
+				name: "update:complete",
+				payload: {
+					blocked: true,
+					error,
+					timestamp: Date.now(),
+					actionId: options.actionId,
+					newState: this.get(false)
+				}
+			});
+			throw error;
+		} finally {
+			this.executionState.executing = false;
+			this.executionState.changes = null;
+			this.executionState.runningMiddleware = null;
+			this.executionState.pendingChanges = [];
+		}
+	}
+	/**
+	* Opens the readyLatch once the persistence layer signals it is ready.
+	* The latch can only open once — subsequent `persistence:ready` events are no-ops.
+	*/
+	setupReadyLatch() {
+		if (!this.persistenceHandler.isReady()) {
+			const unsub = this.eventBus.subscribe("persistence:ready", () => {
+				if (!this.readyLatch.isOpen()) this.readyLatch.open();
+				unsub();
+			});
+		} else this.readyLatch.open();
+	}
+	setupPersistenceListener() {
+		this.updateBus.subscribe("update", (path) => {
+			if (path && this.persistenceHandler.isReady()) this.persistenceHandler.handleStateChange([path], this.get(false));
+		});
+	}
+	watch(path, callback, options) {
+		const all = Array.isArray(path) ? path : [path];
+		const isRoot = path === "" || all.length === 0;
+		return this.updateBus.subscribe("update", (changedPath) => {
+			if (isRoot || all.includes(changedPath)) {
+				callback(this.get(false));
+				this.metricsCollector.listenerExecutions++;
+			}
+		}, options);
+	}
+	/**
+	* Subscribes to execution‑status changes of a registered action.
+	*
+	* The provided callback is called **every time** the action transitions
+	* between idle and running (i.e. on `action:start`, `action:complete`, or
+	* `action:error` for the given name). The current status can also be read
+	* synchronously with `isActionRunning(name)`.
+	*
+	* **Deferred listener teardown**
+	* To avoid unnecessary churn when subscriptions are rapidly created and
+	* destroyed, the underlying event listeners are not removed immediately
+	* on unsubscribe. Instead, a *pending reset* is queued via `queueMicrotask`.
+	* If a new subscription for the same action arrives before that microtask
+	* executes, the reset is silently cancelled and the already‑established
+	* listeners are reused. This keeps the subscription infrastructure stable
+	* and prevents cascading notifications that could otherwise arise from
+	* repeated subscribe‑unsubscribe‑subscribe cycles.
+	*
+	* @param name - The name of the action to watch.
+	* @returns ActionWatcher
+	*/
+	watchAction(name) {
+		this.checkDisposed();
+		return this.actions.watch(name);
+	}
+	/**
+	* Creates a debounced version of `set()` using a `Debouncer`.
+	*
+	* Useful for high-frequency write sources (e.g. text input, scroll position)
+	* where you want to collapse rapid updates into a single state write after a
+	* quiet period.
+	*
+	* @param delay - Quiet period in milliseconds before the update is applied.
+	* @param leading - If true, also applies the first update immediately.
+	* @returns A debounced setter function with the same signature as `set()`.
+	*
+	* @example
+	* const debouncedSet = store.debouncedSetter({ delay: 200 });
+	* inputEl.addEventListener("input", (e) => {
+	*   debouncedSet((s) => ({ ...s, query: e.target.value }));
+	* });
+	*/
+	debouncedSetter(options) {
+		const debouncer = new Debouncer({
+			delay: options.delay,
+			leading: options.leading
+		});
+		return (update, setOptions = {}) => {
+			debouncer.fire(() => this.set(update, setOptions));
+		};
+	}
+	id() {
+		return this.instanceID;
+	}
+	async transaction(operation, options) {
+		this.checkDisposed();
+		const result = await this.transactionManager.execute(operation);
+		if (options?.flush) await this.flush();
+		return result;
+	}
+	use(props) {
+		this.checkDisposed();
+		const id = (props.block ? this.middlewareEngine.addBlockingMiddleware : this.middlewareEngine.addMiddleware).bind(this.middlewareEngine)(props.action, props.name);
+		return () => this.middlewareEngine.removeMiddleware(id);
+	}
+	metrics() {
+		return this.metricsCollector.getMetrics();
+	}
+	on(event, listener) {
+		this.checkDisposed();
+		return this.eventBus.subscribe(event, listener);
+	}
+	getPersistenceStatus() {
+		return this.persistenceHandler.getQueueStatus();
+	}
+	async flush() {
+		return this.persistenceHandler.flush();
+	}
+	/**
+	* Discards all pending persistence tasks.
+	* WARNING: Any queued writes not yet persisted will be lost.
+	* Call flushPersistence() first if writes must not be lost.
+	*/
+	discardPersistenceQueue() {
+		this.persistenceHandler.discardQueue();
+	}
+	/**
+	* Disposes the store and all owned resources.
+	*
+	* Closes the update Serializer — any `set()` calls after dispose() will
+	* reject immediately with `SerializerExecutionDone` rather than silently
+	* enqueuing work against a dead store.
+	*/
+	dispose() {
+		return this.disposeOnce.do(async () => {
+			await this.flush();
+			this.updateSerializer.close();
+			this.eventBus?.clear({ permanent: true });
+			this.updateBus?.clear({ permanent: true });
+			this.actions.dispose();
+			await this.persistenceHandler.dispose();
+			this.metricsCollector.dispose();
+			this.selectorManager.dispose();
+			this.coreState = null;
+			this.middlewareEngine = null;
+			this.transactionManager = null;
+			this.actions = null;
+		});
+	}
+	checkDisposed() {
+		if (this.disposed()) throw new Error("StoreExecutionDone: Cannot perform operations on a disposed store.");
+	}
+	disposed() {
+		return this.disposeOnce.done();
+	}
+	emit(bus, event) {
+		queueMicrotask(() => {
+			bus.emit(event);
+		});
+	}
+};
+
+//#endregion
+//#region src/store/registry.ts
+/**
+* A memory-safe, single-flight registry for ReactiveDataStores.
+* Uses WeakRefs and FinalizationRegistry to allow stores to be garbage collected
+* when no longer in use, automatically cleaning up internal references.
+*/
+var StoreRegistry = class {
+	stores = /* @__PURE__ */ new Map();
+	storeToOnce = /* @__PURE__ */ new WeakMap();
+	finalizer;
+	onEvict;
+	logger;
+	constructor(options) {
+		this.onEvict = options?.onEvict;
+		this.logger = createStoreLogger(options?.logger);
+		this.finalizer = new FinalizationRegistry(({ storeId, ref }) => {
+			try {
+				if (this.stores.get(storeId) === ref) {
+					this.stores.delete(storeId);
+					this.onEvict?.(storeId);
+				}
+			} catch (error) {
+				this.logger.error("StoreRegistry Finalizer error", {
+					storeId,
+					error
+				});
+			}
+		});
+	}
+	/**
+	* Get an existing store for storeId, or create a new one via an always-cached Once primitive.
+	* Ensures only one instantiation occurs even under concurrent calls.
+	* * @param storeId - Unique identifier for the store.
+	* @param initialState - The initial state to seed the store if it is created.
+	* @param timeout - Optional timeout (ms) for store initialization.
+	*/
+	async get(storeId, options = {}) {
+		let once = this.stores.get(storeId)?.deref();
+		if (!once) {
+			once = new Once({ throws: false });
+			const newRef = new WeakRef(once);
+			this.stores.set(storeId, newRef);
+			this.finalizer.register(once, {
+				storeId,
+				ref: newRef
+			}, once);
+		}
+		const result = await once.do(async () => {
+			const store = new ReactiveDataStore(options.state || {}, options.persistence, options.deleteMarker, options.options);
+			await store.ready();
+			return store;
+		}, options.timeout);
+		if (result.error) {
+			if (this.stores.get(storeId)?.deref() === once) {
+				this.stores.delete(storeId);
+				this.finalizer.unregister(once);
+			}
+			throw result.error;
+		}
+		const store = result.value;
+		this.storeToOnce.set(store, once);
+		return store;
+	}
+	getSync(storeId, options = {}) {
+		let once = this.stores.get(storeId)?.deref();
+		if (!once) {
+			once = new Once({ throws: false });
+			const newRef = new WeakRef(once);
+			this.stores.set(storeId, newRef);
+			this.finalizer.register(once, {
+				storeId,
+				ref: newRef
+			}, once);
+		}
+		const result = once.doSync(() => {
+			return new ReactiveDataStore(options.state || {}, options.persistence, options.deleteMarker, options.options);
+		});
+		if (result.error) {
+			if (this.stores.get(storeId)?.deref() === once) {
+				this.stores.delete(storeId);
+				this.finalizer.unregister(once);
+			}
+			throw result.error;
+		}
+		const store = result.value;
+		this.storeToOnce.set(store, once);
+		return store;
+	}
+	/**
+	* Manually remove a store registry entry, unregistering its finalizer and disposing it.
+	* @param storeId - Unique identifier for the store.
+	* @returns True if a store was actively removed, false otherwise.
+	*/
+	async release(storeId) {
+		const ref = this.stores.get(storeId);
+		if (ref) {
+			const once = ref.deref();
+			if (once) {
+				this.finalizer.unregister(once);
+				if (once.done()) {
+					const store = once.get();
+					if (store) {
+						try {
+							await store.dispose();
+						} catch (e) {
+							this.logger.error("StoreRegistry Error disposing store during release", {
+								storeId,
+								error: e
+							});
+						}
+						this.storeToOnce.delete(store);
+					}
+				}
+			}
+			return this.stores.delete(storeId);
+		}
+		return false;
+	}
+	/**
+	* Clears all stores from the registry, disposes them, and unregisters all finalizers.
+	*/
+	async clear() {
+		for (const ref of this.stores.values()) {
+			const once = ref.deref();
+			if (once) {
+				this.finalizer.unregister(once);
+				if (once.done()) {
+					const store = once.get();
+					if (store) {
+						try {
+							await store.dispose();
+						} catch {}
+						this.storeToOnce.delete(store);
+					}
+				}
+			}
+		}
+		this.stores.clear();
+	}
+	/**
+	* Get the store if it exists and has successfully finished initialization.
+	* Does not trigger initialization if the store is missing or pending.
+	*/
+	has(storeId) {
+		return this.stores.has(storeId);
+	}
+	/**
+	* Returns the current number of tracked stores.
+	* Note: This includes entries that may have lost external references but haven't been GC'd yet.
+	*/
+	get size() {
+		return this.stores.size;
+	}
+};
+
+//#endregion
+//#region src/store/observer.ts
+/**
+* @class StoreObserver
+* @description Connects to a DataStore to capture state changes, events, and performance data.
+* @template T The type of the store's state object.
+*/
+var StoreObserver = class {
+	store;
+	eventHistory = [];
+	stateHistory = [];
+	unsubscribers = [];
+	isTimeTraveling = false;
+	devTools = null;
+	middlewareExecutions = [];
+	activeTransactionCount = 0;
+	activeBatches = /* @__PURE__ */ new Set();
+	maxEvents;
+	maxStateHistory;
+	enableConsoleLogging;
+	isSilent;
+	logEvents;
+	performanceThresholds;
+	logger;
+	/**
+	* @param store The DataStore instance to observe.
+	* @param options Configuration options for the observer.
+	*/
+	constructor(store, options = {}) {
+		this.store = store;
+		this.maxEvents = options.maxEvents ?? 500;
+		this.maxStateHistory = options.maxStateHistory ?? 20;
+		this.enableConsoleLogging = options.enableConsoleLogging ?? false;
+		this.isSilent = options.silent ?? false;
+		this.logger = createStoreLogger(options.logger);
+		this.logEvents = {
+			updates: options.logEvents?.updates ?? true,
+			middleware: options.logEvents?.middleware ?? true,
+			transactions: options.logEvents?.transactions ?? true,
+			actions: options.logEvents?.actions ?? true,
+			selectors: options.logEvents?.selectors ?? true
+		};
+		this.performanceThresholds = {
+			updateTime: options.performanceThresholds?.updateTime ?? 50,
+			middlewareTime: options.performanceThresholds?.middlewareTime ?? 20
+		};
+		this.recordStateSnapshot([]);
+		this.setupEventListeners();
+	}
+	/**
+	* @private
+	* Centralized logging method. Routes to the structured logger for level-based calls
+	* (log, warn, error, debug) and to raw console for group/table calls which have no
+	* logger equivalent. Respects the `isSilent` flag.
+	* @param method The console method to call ('log', 'warn', 'error', 'group', 'groupEnd', 'table', 'debug').
+	* @param args Arguments to pass to the console/log method.
+	*/
+	_consoleLog(method, ...args) {
+		if (this.isSilent) return;
+		if (method === "group" || method === "groupEnd" || method === "table") {
+			if (typeof console[method] === "function") console[method](...args);
+			return;
+		}
+		const message = typeof args[0] === "string" ? args[0] : String(args[0] ?? "");
+		const data = args.length > 1 ? { detail: args.slice(1) } : void 0;
+		switch (method) {
+			case "log":
+				this.logger.log(message, data);
+				break;
+			case "warn":
+				this.logger.warn(message, data);
+				break;
+			case "error":
+				this.logger.error(message, data);
+				break;
+			case "debug":
+				this.logger.debug(message, data);
+				break;
+		}
+	}
+	/**
+	* @private
+	* Sets up listeners for all relevant store events.
+	*/
+	setupEventListeners() {
+		for (const event of [
+			"update:start",
+			"update:complete",
+			"middleware:start",
+			"middleware:complete",
+			"middleware:error",
+			"middleware:blocked",
+			"transaction:start",
+			"transaction:complete",
+			"transaction:error",
+			"middleware:executed",
+			"action:start",
+			"action:complete",
+			"action:error",
+			"selector:accessed"
+		]) {
+			const shouldLog = event.startsWith("update") && this.logEvents.updates || event.startsWith("middleware") && this.logEvents.middleware || event.startsWith("transaction") && this.logEvents.transactions || event.startsWith("action") && this.logEvents.actions || event.startsWith("selector") && this.logEvents.selectors;
+			this.unsubscribers.push(this.store.on(event, (data) => {
+				if (this.isTimeTraveling) return;
+				if (event === "update:complete" && !data.blocked) this.recordStateSnapshot(data.deltas);
+				if (event === "middleware:executed") this.middlewareExecutions.push(data);
+				else if (event === "transaction:start") this.activeTransactionCount++;
+				else if (event === "transaction:complete" || event === "transaction:error") this.activeTransactionCount = Math.max(0, this.activeTransactionCount - 1);
+				if (data.batchId) {
+					if (event.endsWith("start")) this.activeBatches.add(data.batchId);
+					else if (event.endsWith("complete") || event.endsWith("error")) this.activeBatches.delete(data.batchId);
+				}
+				this.recordEvent(event, data);
+				if (this.enableConsoleLogging && shouldLog) this._log(event, data);
+				this._checkPerformance(event, data);
+			}));
+		}
+	}
+	/**
+	* @private
+	* Records a new state snapshot and manages the state history limit.
+	* @param deltas The state changes that led to this snapshot.
+	*/
+	recordStateSnapshot(deltas) {
+		const snapshot = {
+			state: this.store.get(true),
+			timestamp: Date.now(),
+			deltas
+		};
+		this.stateHistory.unshift(snapshot);
+		if (this.stateHistory.length > this.maxStateHistory) this.stateHistory.pop();
+	}
+	/**
+	* @private
+	* Records a debug event and manages the event history limit.
+	* @param type The type of event.
+	* @param data The data payload of the event.
+	*/
+	recordEvent(type, data) {
+		const event = {
+			type,
+			timestamp: Date.now(),
+			data: structuredClone(data)
+		};
+		this.eventHistory.unshift(event);
+		if (this.eventHistory.length > this.maxEvents) this.eventHistory.pop();
+	}
+	/**
+	* Returns a cloned copy of the recorded event history.
+	* @returns Array of debug events.
+	*/
+	getEventHistory() {
+		return structuredClone(this.eventHistory);
+	}
+	/**
+	* Returns a cloned copy of the recorded state history (snapshots).
+	* @returns Array of state snapshots.
+	*/
+	getStateHistory() {
+		return structuredClone(this.stateHistory);
+	}
+	/**
+	* Returns middleware execution history from the state.
+	* @returns Array of middleware executions.
+	*/
+	getMiddlewareExecutions() {
+		return this.middlewareExecutions;
+	}
+	/**
+	* Returns current transaction status.
+	* @returns Object with transaction status information.
+	*/
+	getTransactionStatus() {
+		return {
+			activeTransactions: this.activeTransactionCount,
+			activeBatches: Array.from(this.activeBatches)
+		};
+	}
+	/**
+	* Creates a standard middleware that logs all updates.
+	* @param options Options for the logging middleware.
+	* @returns A middleware function.
+	*/
+	createLoggingMiddleware(options = {}) {
+		const { logLevel = "debug", logUpdates = true } = options;
+		return (_, update) => {
+			if (logUpdates) this.logger[logLevel]("State Update", { update });
+			return update;
+		};
+	}
+	/**
+	* Creates a middleware that validates updates against a schema.
+	* Uses the internal `_consoleLog` for warnings.
+	* @param validator Function that validates updates.
+	* @returns A blocking middleware function.
+	*/
+	createValidationMiddleware(validator) {
+		return (state, update) => {
+			const result = validator(state, update);
+			if (typeof result === "boolean") return result;
+			if (!result.valid && result.reason) this._consoleLog("warn", "Validation failed:", result.reason);
+			return result.valid;
+		};
+	}
+	/**
+	* Returns a simplified view of recent state changes.
+	* @param limit Maximum number of state changes to compare. Defaults to 5.
+	* @returns Array of state difference objects.
+	*/
+	getRecentChanges(limit = 5) {
+		const changes = [];
+		const historyLimit = Math.min(limit, this.stateHistory.length);
+		for (let i = 0; i < historyLimit; i++) {
+			const snapshot = this.stateHistory[i];
+			if (!snapshot.deltas || snapshot.deltas.length === 0) continue;
+			const from = {};
+			const to = {};
+			const setNestedValue = (obj, parts, value) => {
+				parts.reduce((o, key, index) => {
+					if (index === parts.length - 1) o[key] = value;
+					else o[key] = o[key] ?? {};
+					return o[key];
+				}, obj);
+			};
+			for (const delta of snapshot.deltas) {
+				const pathParts = delta.path.split(".");
+				setNestedValue(from, pathParts, delta.oldValue);
+				setNestedValue(to, pathParts, delta.newValue);
+			}
+			changes.push({
+				timestamp: snapshot.timestamp,
+				changedPaths: snapshot.deltas.map((d) => d.path),
+				from,
+				to
+			});
+		}
+		return changes;
+	}
+	/**
+	* Clears both the event and state history, preserving only the initial state snapshot.
+	*/
+	clearHistory() {
+		this.eventHistory = [];
+		if (this.stateHistory.length > 0) this.stateHistory = [this.stateHistory[0]];
+	}
+	/**
+	* Filters and returns events related to a specific action ID.
+	* @param actionId The ID of the action to filter by.
+	* @returns Array of debug events associated with the action.
+	*/
+	getHistoryForAction(actionId) {
+		return this.eventHistory.filter((event) => event.data?.actionId === actionId);
+	}
+	/**
+	* Attempts to replay a state update from history using the recorded update payload.
+	* @param eventIndex The index of the replayable event (an "update:start" event) in the history array.
+	*/
+	async replay(eventIndex) {
+		const eventToReplay = this.eventHistory.filter((e) => e.type === "update:start")[eventIndex];
+		if (eventToReplay?.data.update) {
+			this._consoleLog("log", `Replaying event at index ${eventIndex}:`, eventToReplay);
+			await this.store.set(eventToReplay.data.update, { force: true });
+		} else this._consoleLog("warn", `No replayable event found at index ${eventIndex}.`);
+	}
+	/**
+	* Creates a time-travel utility object with undo/redo capabilities.
+	* @returns An object with methods for time-travel navigation.
+	*/
+	createTimeTravel() {
+		let currentIndex = 0;
+		let future = [];
+		const unsubscribe = this.store.on("update:complete", (data) => {
+			if (!this.isTimeTraveling && !data.blocked) {
+				future = [];
+				currentIndex = 0;
+			}
+		});
+		this.unsubscribers.push(unsubscribe);
+		const getHistoryLength = () => this.stateHistory.length;
+		const canUndo = () => currentIndex < getHistoryLength() - 1;
+		const canRedo = () => future.length > 0;
+		const undo = async () => {
+			if (!canUndo()) return;
+			future.unshift(this.stateHistory[currentIndex]);
+			currentIndex++;
+			const previousState = this.stateHistory[currentIndex].state;
+			this.isTimeTraveling = true;
+			await this.store.set({ ...previousState }, { force: true });
+			this.isTimeTraveling = false;
+		};
+		const redo = async () => {
+			if (!canRedo()) return;
+			const nextSnapshot = future.shift();
+			currentIndex--;
+			this.isTimeTraveling = true;
+			await this.store.set({ ...nextSnapshot.state }, { force: true });
+			this.isTimeTraveling = false;
+		};
+		const clear = () => {
+			future = [];
+			currentIndex = 0;
+		};
+		return {
+			canUndo,
+			canRedo,
+			undo,
+			redo,
+			length: getHistoryLength,
+			clear
+		};
+	}
+	/**
+	* Saves the current observer session (events and state history) using a persistence mechanism.
+	* @param persistence An object implementing the SimplePersistence interface.
+	* @returns A promise that resolves to true if the session was saved successfully.
+	*/
+	async saveSession(persistence) {
+		const id = this.store.id();
+		const sessionData = {
+			eventHistory: this.eventHistory,
+			stateHistory: this.stateHistory
+		};
+		return Promise.resolve(persistence.set(id, sessionData));
+	}
+	/**
+	* Loads a previously saved observer session and restores the state to the latest saved snapshot.
+	* @param persistence An object implementing the SimplePersistence interface.
+	* @returns A promise that resolves to true if a session was loaded.
+	*/
+	async loadSession(persistence) {
+		const sessionData = await Promise.resolve(persistence.get());
+		if (sessionData) {
+			this.eventHistory = sessionData.eventHistory || [];
+			this.stateHistory = sessionData.stateHistory || [];
+			if (this.stateHistory.length > 0) await this.store.set(this.stateHistory[0].state, { force: true });
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Exports the current session data as a JSON file, initiating a browser download.
+	*/
+	exportSession() {
+		const sessionData = {
+			eventHistory: this.eventHistory,
+			stateHistory: this.stateHistory
+		};
+		const blob = new Blob([JSON.stringify(sessionData, null, 2)], { type: "application/json" });
+		const url = URL.createObjectURL(blob);
+		const a = document.createElement("a");
+		a.href = url;
+		a.download = `store-observer-session-${(/* @__PURE__ */ new Date()).toISOString()}.json`;
+		a.click();
+		URL.revokeObjectURL(url);
+	}
+	/**
+	* Imports a session from a JSON file, restoring event history and state.
+	* @param file The file object (e.g., from an <input type="file"> event) to import.
+	* @returns A promise that resolves when the import is complete.
+	*/
+	importSession(file) {
+		return new Promise((resolve, reject) => {
+			const reader = new FileReader();
+			reader.onload = async (event) => {
+				try {
+					const sessionData = JSON.parse(event.target?.result);
+					this.eventHistory = sessionData.eventHistory || [];
+					this.stateHistory = sessionData.stateHistory || [];
+					if (this.stateHistory.length > 0) await this.store.set(this.stateHistory[0].state, { force: true });
+					resolve();
+				} catch (error) {
+					reject(error);
+				}
+			};
+			reader.onerror = (error) => reject(error);
+			reader.readAsText(file);
+		});
+	}
+	/**
+	* Cleans up the observer by unsubscribing all event listeners and clearing history.
+	*/
+	disconnect() {
+		this.unsubscribers.forEach((unsubscribe) => unsubscribe());
+		this.unsubscribers = [];
+		this.devTools?.disconnect();
+		this.clearHistory();
+	}
+	/**
+	* @private
+	* Logs an event to the console with appropriate formatting.
+	* Uses `this._consoleLog` for all output.
+	* @param type Event type.
+	* @param data Event data.
+	*/
+	_log(type, data) {
+		const timestamp = new Date(data.timestamp || Date.now()).toISOString().split("T")[1].replace("Z", "");
+		if (type === "update:start") this._consoleLog("group", `%c⚡ Store Update Started [${timestamp}]`, "color: #4a6da7");
+		else if (type === "update:complete") {
+			if (data.blocked) this._consoleLog("warn", `%c✋ Update Blocked [${timestamp}]`, "color: #bf8c0a", data.error);
+			else {
+				const deltas = data.deltas || [];
+				if (deltas.length > 0) {
+					this._consoleLog("log", `%c✅ Update Complete [${timestamp}] - ${deltas.length} paths changed in ${data.duration?.toFixed(2)}ms`, "color: #2a9d8f");
+					this._consoleLog("table", deltas.map((d) => ({
+						path: d.path,
+						oldValue: d.oldValue,
+						newValue: d.newValue
+					})));
+				}
+			}
+			this._consoleLog("groupEnd");
+		} else if (type === "middleware:start") this._consoleLog("debug", `%c◀ Middleware \"${data.name}\" started [${timestamp}] (${data.type})`, "color: #8c8c8c");
+		else if (type === "middleware:complete") this._consoleLog("debug", `%c▶ Middleware \"${data.name}\" completed [${timestamp}] in ${data.duration?.toFixed(2)}ms`, "color: #7c9c7c");
+		else if (type === "middleware:error") this._consoleLog("error", `%c❌ Middleware \"${data.name}\" error [${timestamp}]:`, "color: #e63946", data.error);
+		else if (type === "middleware:blocked") this._consoleLog("warn", `%c🛑 Middleware \"${data.name}\" blocked update [${timestamp}]`, "color: #e76f51");
+		else if (type === "transaction:start") this._consoleLog("group", `%c📦 Transaction Started [${timestamp}]`, "color: #6d597a");
+		else if (type === "transaction:complete") {
+			this._consoleLog("log", `%c📦 Transaction Complete [${timestamp}]`, "color: #355070");
+			this._consoleLog("groupEnd");
+		} else if (type === "transaction:error") {
+			this._consoleLog("error", `%c📦 Transaction Error [${timestamp}]:`, "color: #e56b6f", data.error);
+			this._consoleLog("groupEnd");
+		} else if (type === "action:start") this._consoleLog("group", `%c🚀 Action \"${data.name}\" Started [${timestamp}]`, "color: #9b59b6", { params: data.params });
+		else if (type === "action:complete") {
+			this._consoleLog("log", `%c✔️ Action \"${data.name}\" Complete [${timestamp}] in ${data.duration?.toFixed(2)}ms`, "color: #2ecc71");
+			this._consoleLog("groupEnd");
+		} else if (type === "action:error") {
+			this._consoleLog("error", `%c🔥 Action \"${data.name}\" Error [${timestamp}]:`, "color: #e74c3c", data.error);
+			this._consoleLog("groupEnd");
+		} else if (type === "selector:accessed") this._consoleLog("debug", `%c👀 Selector Accessed [${timestamp}] in ${data.duration?.toFixed(2)}ms`, "color: #f1c40f", {
+			accessedPaths: data.accessedPaths,
+			selectorId: data.selectorId
+		});
+	}
+	/**
+	* @private
+	* Checks for performance issues in the events.
+	* Uses `this._consoleLog` for all output.
+	* @param type Event type.
+	* @param data Event data.
+	*/
+	_checkPerformance(type, data) {
+		if (!this.enableConsoleLogging) return;
+		if (type === "update:complete" && !data.blocked && data.duration > this.performanceThresholds.updateTime) this._consoleLog("warn", `%c⚠️ Slow update detected [${data.duration.toFixed(2)}ms]`, "color: #ff9f1c", {
+			deltas: data.deltas,
+			threshold: this.performanceThresholds.updateTime
+		});
+		if (type === "middleware:complete" && data.duration > this.performanceThresholds.middlewareTime) this._consoleLog("warn", `%c⚠️ Slow middleware \"${data.name}\" [${data.duration.toFixed(2)}ms]`, "color: #ff9f1c", { threshold: this.performanceThresholds.middlewareTime });
+	}
+};
+
+//#endregion
+export { ActionCancelledError, ActionManager, DELETE_SYMBOL, ReactiveDataStore, SelectorManager, StoreObserver, StoreRegistry, UnknownActionError, buildPaths, createDerivePaths, createDiff, createMerge, createStoreLogger, derivePaths, diff, merge, shallowClone };