@codebelt/classy-store 0.0.2 → 0.1.1

package/dist/react/react.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_snapshot = require('../snapshot-CR8nA2Ob.cjs');
+const require_snapshot = require('../snapshot-CbVbxG7s.cjs');
 let proxy_compare = require("proxy-compare");
 let react = require("react");
 
@@ -55,7 +55,36 @@ function getAutoTrackSnapshot(proxyStore, affected, proxyCache, prevSnapRef, wra
 	wrappedRef.current = wrapped;
 	return wrapped;
 }
+/**
+* Create a component-scoped reactive store that lives for the lifetime of the
+* component. When the component unmounts, the store becomes unreferenced and is
+* garbage collected (all internal bookkeeping uses `WeakMap`).
+*
+* The factory function runs **once** per mount (via `useState` initializer).
+* Each component instance gets its own isolated store.
+*
+* Use the returned proxy with `useStore()` to read state in the same component
+* or pass it down via props/context to share within a subtree.
+*
+* @param factory - A function that returns a class instance (or plain object).
+*                  Called once per component mount.
+* @returns A reactive store proxy scoped to the component's lifetime.
+*
+* @example
+* ```tsx
+* function Counter() {
+*   const store = useLocalStore(() => new CounterStore());
+*   const count = useStore(store, s => s.count);
+*   return <button onClick={() => store.increment()}>{count}</button>;
+* }
+* ```
+*/
+function useLocalStore(factory) {
+	const [store] = (0, react.useState)(() => require_snapshot.createClassyStore(factory()));
+	return store;
+}
 
 //#endregion
+exports.useLocalStore = useLocalStore;
 exports.useStore = useStore;
 //# sourceMappingURL=react.cjs.map

package/dist/react/react.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"react.cjs","names":["subscribe","coreSubscribe","snapshot"],"sources":["../../src/react/react.ts"],"sourcesContent":["import {createProxy, isChanged} from 'proxy-compare';\nimport {useCallback, useRef, useSyncExternalStore} from 'react';\nimport {subscribe as coreSubscribe, getInternal} from '../core/core';\nimport {snapshot} from '../snapshot/snapshot';\nimport type {Snapshot} from '../types';\n\n// ── Overloads ─────────────────────────────────────────────────────────────────\n\n/**\n * Subscribe to a store proxy with an explicit selector.\n *\n * Re-renders only when the selected value changes (compared via `Object.is`\n * by default, or a custom `isEqual`).\n *\n * @param proxyStore - A reactive proxy created by `store()`.\n * @param selector  - Picks data from the immutable snapshot.\n * @param isEqual   - Optional custom equality function (default: `Object.is`).\n */\nexport function useStore<T extends object, S>(\n  proxyStore: T,\n  selector: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): S;\n\n/**\n * Subscribe to a store proxy **without** a selector (auto-tracked mode).\n *\n * Returns a `proxy-compare` tracking proxy over the immutable snapshot.\n * The component only re-renders when a property it actually read changes.\n *\n * @param proxyStore - A reactive proxy created by `store()`.\n */\nexport function useStore<T extends object>(proxyStore: T): Snapshot<T>;\n\n// ── Implementation ────────────────────────────────────────────────────────────\n\nexport function useStore<T extends object, S>(\n  proxyStore: T,\n  selector?: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): Snapshot<T> | S {\n  // Validate that the argument is actually a store proxy (throws if not).\n  getInternal(proxyStore);\n\n  // Stable subscribe function (internal identity never changes for a given store).\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => coreSubscribe(proxyStore, onStoreChange),\n    [proxyStore],\n  );\n\n  // ── Refs used by both modes (always allocated to satisfy Rules of Hooks) ──\n\n  // Selector mode refs\n  const snapRef = useRef<Snapshot<T> | undefined>(undefined);\n  const resultRef = useRef<S | undefined>(undefined);\n\n  // Auto-track mode refs\n  const affected = useRef(new WeakMap<object, unknown>()).current;\n  const proxyCache = useRef(new WeakMap<object, unknown>()).current;\n  const prevSnapRef = useRef<Snapshot<T> | undefined>(undefined);\n  const wrappedRef = useRef<Snapshot<T> | undefined>(undefined);\n\n  // ── Single getSnapshot for useSyncExternalStore ───────────────────────────\n\n  const getSnapshot = (): Snapshot<T> | S =>\n    selector\n      ? getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual)\n      : getAutoTrackSnapshot(\n          proxyStore,\n          affected,\n          proxyCache,\n          prevSnapRef,\n          wrappedRef,\n        );\n\n  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n}\n\n// ── Selector mode logic (pure function, no hooks) ─────────────────────────────\n\n/**\n * `getSnapshot` implementation for selector mode.\n *\n * Fast-paths when the snapshot reference hasn't changed (O(1)). Otherwise\n * runs the selector against the new snapshot and compares the result to the\n * previous one via `Object.is` (or a custom `isEqual`). Returns the previous\n * result reference when equal, preventing unnecessary React re-renders.\n *\n * Pure function -- no hooks, safe to call from `useSyncExternalStore`.\n */\nfunction getSelectorSnapshot<T extends object, S>(\n  proxyStore: T,\n  snapRef: React.RefObject<Snapshot<T> | undefined>,\n  resultRef: React.RefObject<S | undefined>,\n  selector: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): S {\n  const nextSnap = snapshot(proxyStore);\n\n  // Fast path: same snapshot reference → same result.\n  if (snapRef.current === nextSnap && resultRef.current !== undefined) {\n    return resultRef.current;\n  }\n\n  const nextResult = selector(nextSnap);\n  snapRef.current = nextSnap;\n\n  // Check equality with previous result.\n  if (\n    resultRef.current !== undefined &&\n    (isEqual\n      ? isEqual(resultRef.current, nextResult)\n      : Object.is(resultRef.current, nextResult))\n  ) {\n    return resultRef.current;\n  }\n\n  resultRef.current = nextResult;\n  return nextResult;\n}\n\n// ── Auto-tracked (selectorless) mode logic (pure function, no hooks) ──────────\n\n/**\n * `getSnapshot` implementation for auto-tracked (selectorless) mode.\n *\n * Uses `proxy-compare` to diff only the properties the component actually read.\n * If the snapshot reference is the same, returns the cached tracking proxy.\n * If the snapshot changed but no tracked property differs (`isChanged` returns\n * false), also returns the cached proxy -- avoiding re-render. Only when a\n * relevant property changed does it create a new `createProxy` wrapper.\n *\n * Pure function -- no hooks, safe to call from `useSyncExternalStore`.\n */\nfunction getAutoTrackSnapshot<T extends object>(\n  proxyStore: T,\n  affected: WeakMap<object, unknown>,\n  proxyCache: WeakMap<object, unknown>,\n  prevSnapRef: React.RefObject<Snapshot<T> | undefined>,\n  wrappedRef: React.RefObject<Snapshot<T> | undefined>,\n): Snapshot<T> {\n  const nextSnap = snapshot(proxyStore);\n\n  // If the raw snapshot is the same reference, nothing changed.\n  if (prevSnapRef.current === nextSnap) {\n    return wrappedRef.current as Snapshot<T>;\n  }\n\n  // Check if any property the component actually read has changed.\n  if (\n    prevSnapRef.current !== undefined &&\n    !isChanged(prevSnapRef.current, nextSnap, affected)\n  ) {\n    // No property the component cares about changed → return same wrapped proxy.\n    return wrappedRef.current as Snapshot<T>;\n  }\n\n  // Something relevant changed — create a new tracking proxy.\n  prevSnapRef.current = nextSnap;\n  const wrapped = createProxy(nextSnap, affected, proxyCache) as Snapshot<T>;\n  wrappedRef.current = wrapped;\n  return wrapped;\n}\n"],"mappings":";;;;;;AAoCA,SAAgB,SACd,YACA,UACA,SACiB;AAEjB,8BAAY,WAAW;CAGvB,MAAMA,sCACH,kBAA8BC,2BAAc,YAAY,cAAc,EACvE,CAAC,WAAW,CACb;CAKD,MAAM,4BAA0C,OAAU;CAC1D,MAAM,8BAAkC,OAAU;CAGlD,MAAM,6CAAkB,IAAI,SAA0B,CAAC,CAAC;CACxD,MAAM,+CAAoB,IAAI,SAA0B,CAAC,CAAC;CAC1D,MAAM,gCAA8C,OAAU;CAC9D,MAAM,+BAA6C,OAAU;CAI7D,MAAM,oBACJ,WACI,oBAAoB,YAAY,SAAS,WAAW,UAAU,QAAQ,GACtE,qBACE,YACA,UACA,YACA,aACA,WACD;AAEP,wCAA4BD,aAAW,aAAa,YAAY;;;;;;;;;;;;AAelE,SAAS,oBACP,YACA,SACA,WACA,UACA,SACG;CACH,MAAM,WAAWE,0BAAS,WAAW;AAGrC,KAAI,QAAQ,YAAY,YAAY,UAAU,YAAY,OACxD,QAAO,UAAU;CAGnB,MAAM,aAAa,SAAS,SAAS;AACrC,SAAQ,UAAU;AAGlB,KACE,UAAU,YAAY,WACrB,UACG,QAAQ,UAAU,SAAS,WAAW,GACtC,OAAO,GAAG,UAAU,SAAS,WAAW,EAE5C,QAAO,UAAU;AAGnB,WAAU,UAAU;AACpB,QAAO;;;;;;;;;;;;;AAgBT,SAAS,qBACP,YACA,UACA,YACA,aACA,YACa;CACb,MAAM,WAAWA,0BAAS,WAAW;AAGrC,KAAI,YAAY,YAAY,SAC1B,QAAO,WAAW;AAIpB,KACE,YAAY,YAAY,UACxB,8BAAW,YAAY,SAAS,UAAU,SAAS,CAGnD,QAAO,WAAW;AAIpB,aAAY,UAAU;CACtB,MAAM,yCAAsB,UAAU,UAAU,WAAW;AAC3D,YAAW,UAAU;AACrB,QAAO"}
+{"version":3,"file":"react.cjs","names":["subscribe","coreSubscribe","snapshot","createClassyStore"],"sources":["../../src/react/react.ts"],"sourcesContent":["import {createProxy, isChanged} from 'proxy-compare';\nimport {useCallback, useRef, useState, useSyncExternalStore} from 'react';\nimport {\n  subscribe as coreSubscribe,\n  createClassyStore,\n  getInternal,\n} from '../core/core';\nimport {snapshot} from '../snapshot/snapshot';\nimport type {Snapshot} from '../types';\n\n// ── Overloads ─────────────────────────────────────────────────────────────────\n\n/**\n * Subscribe to a store proxy with an explicit selector.\n *\n * Re-renders only when the selected value changes (compared via `Object.is`\n * by default, or a custom `isEqual`).\n *\n * @param proxyStore - A reactive proxy created by `store()`.\n * @param selector  - Picks data from the immutable snapshot.\n * @param isEqual   - Optional custom equality function (default: `Object.is`).\n */\nexport function useStore<T extends object, S>(\n  proxyStore: T,\n  selector: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): S;\n\n/**\n * Subscribe to a store proxy **without** a selector (auto-tracked mode).\n *\n * Returns a `proxy-compare` tracking proxy over the immutable snapshot.\n * The component only re-renders when a property it actually read changes.\n *\n * @param proxyStore - A reactive proxy created by `store()`.\n */\nexport function useStore<T extends object>(proxyStore: T): Snapshot<T>;\n\n// ── Implementation ────────────────────────────────────────────────────────────\n\nexport function useStore<T extends object, S>(\n  proxyStore: T,\n  selector?: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): Snapshot<T> | S {\n  // Validate that the argument is actually a store proxy (throws if not).\n  getInternal(proxyStore);\n\n  // Stable subscribe function (internal identity never changes for a given store).\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => coreSubscribe(proxyStore, onStoreChange),\n    [proxyStore],\n  );\n\n  // ── Refs used by both modes (always allocated to satisfy Rules of Hooks) ──\n\n  // Selector mode refs\n  const snapRef = useRef<Snapshot<T> | undefined>(undefined);\n  const resultRef = useRef<S | undefined>(undefined);\n\n  // Auto-track mode refs\n  const affected = useRef(new WeakMap<object, unknown>()).current;\n  const proxyCache = useRef(new WeakMap<object, unknown>()).current;\n  const prevSnapRef = useRef<Snapshot<T> | undefined>(undefined);\n  const wrappedRef = useRef<Snapshot<T> | undefined>(undefined);\n\n  // ── Single getSnapshot for useSyncExternalStore ───────────────────────────\n\n  const getSnapshot = (): Snapshot<T> | S =>\n    selector\n      ? getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual)\n      : getAutoTrackSnapshot(\n          proxyStore,\n          affected,\n          proxyCache,\n          prevSnapRef,\n          wrappedRef,\n        );\n\n  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n}\n\n// ── Selector mode logic (pure function, no hooks) ─────────────────────────────\n\n/**\n * `getSnapshot` implementation for selector mode.\n *\n * Fast-paths when the snapshot reference hasn't changed (O(1)). Otherwise\n * runs the selector against the new snapshot and compares the result to the\n * previous one via `Object.is` (or a custom `isEqual`). Returns the previous\n * result reference when equal, preventing unnecessary React re-renders.\n *\n * Pure function -- no hooks, safe to call from `useSyncExternalStore`.\n */\nfunction getSelectorSnapshot<T extends object, S>(\n  proxyStore: T,\n  snapRef: React.RefObject<Snapshot<T> | undefined>,\n  resultRef: React.RefObject<S | undefined>,\n  selector: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): S {\n  const nextSnap = snapshot(proxyStore);\n\n  // Fast path: same snapshot reference → same result.\n  if (snapRef.current === nextSnap && resultRef.current !== undefined) {\n    return resultRef.current;\n  }\n\n  const nextResult = selector(nextSnap);\n  snapRef.current = nextSnap;\n\n  // Check equality with previous result.\n  if (\n    resultRef.current !== undefined &&\n    (isEqual\n      ? isEqual(resultRef.current, nextResult)\n      : Object.is(resultRef.current, nextResult))\n  ) {\n    return resultRef.current;\n  }\n\n  resultRef.current = nextResult;\n  return nextResult;\n}\n\n// ── Auto-tracked (selectorless) mode logic (pure function, no hooks) ──────────\n\n/**\n * `getSnapshot` implementation for auto-tracked (selectorless) mode.\n *\n * Uses `proxy-compare` to diff only the properties the component actually read.\n * If the snapshot reference is the same, returns the cached tracking proxy.\n * If the snapshot changed but no tracked property differs (`isChanged` returns\n * false), also returns the cached proxy -- avoiding re-render. Only when a\n * relevant property changed does it create a new `createProxy` wrapper.\n *\n * Pure function -- no hooks, safe to call from `useSyncExternalStore`.\n */\nfunction getAutoTrackSnapshot<T extends object>(\n  proxyStore: T,\n  affected: WeakMap<object, unknown>,\n  proxyCache: WeakMap<object, unknown>,\n  prevSnapRef: React.RefObject<Snapshot<T> | undefined>,\n  wrappedRef: React.RefObject<Snapshot<T> | undefined>,\n): Snapshot<T> {\n  const nextSnap = snapshot(proxyStore);\n\n  // If the raw snapshot is the same reference, nothing changed.\n  if (prevSnapRef.current === nextSnap) {\n    return wrappedRef.current as Snapshot<T>;\n  }\n\n  // Check if any property the component actually read has changed.\n  if (\n    prevSnapRef.current !== undefined &&\n    !isChanged(prevSnapRef.current, nextSnap, affected)\n  ) {\n    // No property the component cares about changed → return same wrapped proxy.\n    return wrappedRef.current as Snapshot<T>;\n  }\n\n  // Something relevant changed — create a new tracking proxy.\n  prevSnapRef.current = nextSnap;\n  const wrapped = createProxy(nextSnap, affected, proxyCache) as Snapshot<T>;\n  wrappedRef.current = wrapped;\n  return wrapped;\n}\n\n// ── Component-scoped store ────────────────────────────────────────────────────\n\n/**\n * Create a component-scoped reactive store that lives for the lifetime of the\n * component. When the component unmounts, the store becomes unreferenced and is\n * garbage collected (all internal bookkeeping uses `WeakMap`).\n *\n * The factory function runs **once** per mount (via `useState` initializer).\n * Each component instance gets its own isolated store.\n *\n * Use the returned proxy with `useStore()` to read state in the same component\n * or pass it down via props/context to share within a subtree.\n *\n * @param factory - A function that returns a class instance (or plain object).\n *                  Called once per component mount.\n * @returns A reactive store proxy scoped to the component's lifetime.\n *\n * @example\n * ```tsx\n * function Counter() {\n *   const store = useLocalStore(() => new CounterStore());\n *   const count = useStore(store, s => s.count);\n *   return <button onClick={() => store.increment()}>{count}</button>;\n * }\n * ```\n */\nexport function useLocalStore<T extends object>(factory: () => T): T {\n  const [store] = useState(() => createClassyStore(factory()));\n  return store;\n}\n"],"mappings":";;;;;;AAwCA,SAAgB,SACd,YACA,UACA,SACiB;AAEjB,8BAAY,WAAW;CAGvB,MAAMA,sCACH,kBAA8BC,2BAAc,YAAY,cAAc,EACvE,CAAC,WAAW,CACb;CAKD,MAAM,4BAA0C,OAAU;CAC1D,MAAM,8BAAkC,OAAU;CAGlD,MAAM,6CAAkB,IAAI,SAA0B,CAAC,CAAC;CACxD,MAAM,+CAAoB,IAAI,SAA0B,CAAC,CAAC;CAC1D,MAAM,gCAA8C,OAAU;CAC9D,MAAM,+BAA6C,OAAU;CAI7D,MAAM,oBACJ,WACI,oBAAoB,YAAY,SAAS,WAAW,UAAU,QAAQ,GACtE,qBACE,YACA,UACA,YACA,aACA,WACD;AAEP,wCAA4BD,aAAW,aAAa,YAAY;;;;;;;;;;;;AAelE,SAAS,oBACP,YACA,SACA,WACA,UACA,SACG;CACH,MAAM,WAAWE,0BAAS,WAAW;AAGrC,KAAI,QAAQ,YAAY,YAAY,UAAU,YAAY,OACxD,QAAO,UAAU;CAGnB,MAAM,aAAa,SAAS,SAAS;AACrC,SAAQ,UAAU;AAGlB,KACE,UAAU,YAAY,WACrB,UACG,QAAQ,UAAU,SAAS,WAAW,GACtC,OAAO,GAAG,UAAU,SAAS,WAAW,EAE5C,QAAO,UAAU;AAGnB,WAAU,UAAU;AACpB,QAAO;;;;;;;;;;;;;AAgBT,SAAS,qBACP,YACA,UACA,YACA,aACA,YACa;CACb,MAAM,WAAWA,0BAAS,WAAW;AAGrC,KAAI,YAAY,YAAY,SAC1B,QAAO,WAAW;AAIpB,KACE,YAAY,YAAY,UACxB,8BAAW,YAAY,SAAS,UAAU,SAAS,CAGnD,QAAO,WAAW;AAIpB,aAAY,UAAU;CACtB,MAAM,yCAAsB,UAAU,UAAU,WAAW;AAC3D,YAAW,UAAU;AACrB,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BT,SAAgB,cAAgC,SAAqB;CACnE,MAAM,CAAC,mCAAwBC,mCAAkB,SAAS,CAAC,CAAC;AAC5D,QAAO"}

package/dist/react/react.d.cts

@@ -21,6 +21,31 @@ declare function useStore<T extends object, S>(proxyStore: T, selector: (snap: S
  * @param proxyStore - A reactive proxy created by `store()`.
  */
 declare function useStore<T extends object>(proxyStore: T): Snapshot<T>;
+/**
+ * Create a component-scoped reactive store that lives for the lifetime of the
+ * component. When the component unmounts, the store becomes unreferenced and is
+ * garbage collected (all internal bookkeeping uses `WeakMap`).
+ *
+ * The factory function runs **once** per mount (via `useState` initializer).
+ * Each component instance gets its own isolated store.
+ *
+ * Use the returned proxy with `useStore()` to read state in the same component
+ * or pass it down via props/context to share within a subtree.
+ *
+ * @param factory - A function that returns a class instance (or plain object).
+ *                  Called once per component mount.
+ * @returns A reactive store proxy scoped to the component's lifetime.
+ *
+ * @example
+ * ```tsx
+ * function Counter() {
+ *   const store = useLocalStore(() => new CounterStore());
+ *   const count = useStore(store, s => s.count);
+ *   return <button onClick={() => store.increment()}>{count}</button>;
+ * }
+ * ```
+ */
+declare function useLocalStore<T extends object>(factory: () => T): T;
 //#endregion
-export { useStore };
+export { useLocalStore, useStore };
 //# sourceMappingURL=react.d.cts.map

package/dist/react/react.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"react.d.cts","names":[],"sources":["../../src/react/react.ts"],"mappings":";;;;;AAkBA;;;;;;;;iBAAgB,QAAA,qBAAA,CACd,UAAA,EAAY,CAAA,EACZ,QAAA,GAAW,IAAA,EAAM,QAAA,CAAS,CAAA,MAAO,CAAA,EACjC,OAAA,IAAW,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,eACnB,CAAA;;;;;;;;;iBAUa,QAAA,kBAAA,CAA2B,UAAA,EAAY,CAAA,GAAI,QAAA,CAAS,CAAA"}
+{"version":3,"file":"react.d.cts","names":[],"sources":["../../src/react/react.ts"],"mappings":";;;;;AAsBA;;;;;;;;iBAAgB,QAAA,qBAAA,CACd,UAAA,EAAY,CAAA,EACZ,QAAA,GAAW,IAAA,EAAM,QAAA,CAAS,CAAA,MAAO,CAAA,EACjC,OAAA,IAAW,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,eACnB,CAAA;;;;;;;;;iBAUa,QAAA,kBAAA,CAA2B,UAAA,EAAY,CAAA,GAAI,QAAA,CAAS,CAAA;;;;;;;;;;;;AAApE;;;;;;;;;;;;;iBA8JgB,aAAA,kBAAA,CAAgC,OAAA,QAAe,CAAA,GAAI,CAAA"}

package/dist/react/react.d.mts

@@ -1,4 +1,4 @@
-import { t as Snapshot } from "../types-vWYkF3tH.mjs";
+import { t as Snapshot } from "../types-Cf8Fp7kA.mjs";
 
 //#region src/react/react.d.ts
 /**
@@ -21,6 +21,31 @@ declare function useStore<T extends object, S>(proxyStore: T, selector: (snap: S
  * @param proxyStore - A reactive proxy created by `store()`.
  */
 declare function useStore<T extends object>(proxyStore: T): Snapshot<T>;
+/**
+ * Create a component-scoped reactive store that lives for the lifetime of the
+ * component. When the component unmounts, the store becomes unreferenced and is
+ * garbage collected (all internal bookkeeping uses `WeakMap`).
+ *
+ * The factory function runs **once** per mount (via `useState` initializer).
+ * Each component instance gets its own isolated store.
+ *
+ * Use the returned proxy with `useStore()` to read state in the same component
+ * or pass it down via props/context to share within a subtree.
+ *
+ * @param factory - A function that returns a class instance (or plain object).
+ *                  Called once per component mount.
+ * @returns A reactive store proxy scoped to the component's lifetime.
+ *
+ * @example
+ * ```tsx
+ * function Counter() {
+ *   const store = useLocalStore(() => new CounterStore());
+ *   const count = useStore(store, s => s.count);
+ *   return <button onClick={() => store.increment()}>{count}</button>;
+ * }
+ * ```
+ */
+declare function useLocalStore<T extends object>(factory: () => T): T;
 //#endregion
-export { useStore };
+export { useLocalStore, useStore };
 //# sourceMappingURL=react.d.mts.map

package/dist/react/react.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"react.d.mts","names":[],"sources":["../../src/react/react.ts"],"mappings":";;;;;AAkBA;;;;;;;;iBAAgB,QAAA,qBAAA,CACd,UAAA,EAAY,CAAA,EACZ,QAAA,GAAW,IAAA,EAAM,QAAA,CAAS,CAAA,MAAO,CAAA,EACjC,OAAA,IAAW,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,eACnB,CAAA;;;;;;;;;iBAUa,QAAA,kBAAA,CAA2B,UAAA,EAAY,CAAA,GAAI,QAAA,CAAS,CAAA"}
+{"version":3,"file":"react.d.mts","names":[],"sources":["../../src/react/react.ts"],"mappings":";;;;;AAsBA;;;;;;;;iBAAgB,QAAA,qBAAA,CACd,UAAA,EAAY,CAAA,EACZ,QAAA,GAAW,IAAA,EAAM,QAAA,CAAS,CAAA,MAAO,CAAA,EACjC,OAAA,IAAW,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,eACnB,CAAA;;;;;;;;;iBAUa,QAAA,kBAAA,CAA2B,UAAA,EAAY,CAAA,GAAI,QAAA,CAAS,CAAA;;;;;;;;;;;;AAApE;;;;;;;;;;;;;iBA8JgB,aAAA,kBAAA,CAAgC,OAAA,QAAe,CAAA,GAAI,CAAA"}

package/dist/react/react.mjs

@@ -1,6 +1,6 @@
-import { a as subscribe, n as getInternal, t as snapshot } from "../snapshot-C8JDLu8L.mjs";
+import { a as subscribe, n as createClassyStore, r as getInternal, t as snapshot } from "../snapshot-COzEerMu.mjs";
 import { createProxy, isChanged } from "proxy-compare";
-import { useCallback, useRef, useSyncExternalStore } from "react";
+import { useCallback, useRef, useState, useSyncExternalStore } from "react";
 
 //#region src/react/react.ts
 function useStore(proxyStore, selector, isEqual) {
@@ -54,7 +54,35 @@ function getAutoTrackSnapshot(proxyStore, affected, proxyCache, prevSnapRef, wra
 	wrappedRef.current = wrapped;
 	return wrapped;
 }
+/**
+* Create a component-scoped reactive store that lives for the lifetime of the
+* component. When the component unmounts, the store becomes unreferenced and is
+* garbage collected (all internal bookkeeping uses `WeakMap`).
+*
+* The factory function runs **once** per mount (via `useState` initializer).
+* Each component instance gets its own isolated store.
+*
+* Use the returned proxy with `useStore()` to read state in the same component
+* or pass it down via props/context to share within a subtree.
+*
+* @param factory - A function that returns a class instance (or plain object).
+*                  Called once per component mount.
+* @returns A reactive store proxy scoped to the component's lifetime.
+*
+* @example
+* ```tsx
+* function Counter() {
+*   const store = useLocalStore(() => new CounterStore());
+*   const count = useStore(store, s => s.count);
+*   return <button onClick={() => store.increment()}>{count}</button>;
+* }
+* ```
+*/
+function useLocalStore(factory) {
+	const [store] = useState(() => createClassyStore(factory()));
+	return store;
+}
 
 //#endregion
-export { useStore };
+export { useLocalStore, useStore };
 //# sourceMappingURL=react.mjs.map

package/dist/react/react.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"react.mjs","names":["subscribe","coreSubscribe"],"sources":["../../src/react/react.ts"],"sourcesContent":["import {createProxy, isChanged} from 'proxy-compare';\nimport {useCallback, useRef, useSyncExternalStore} from 'react';\nimport {subscribe as coreSubscribe, getInternal} from '../core/core';\nimport {snapshot} from '../snapshot/snapshot';\nimport type {Snapshot} from '../types';\n\n// ── Overloads ─────────────────────────────────────────────────────────────────\n\n/**\n * Subscribe to a store proxy with an explicit selector.\n *\n * Re-renders only when the selected value changes (compared via `Object.is`\n * by default, or a custom `isEqual`).\n *\n * @param proxyStore - A reactive proxy created by `store()`.\n * @param selector  - Picks data from the immutable snapshot.\n * @param isEqual   - Optional custom equality function (default: `Object.is`).\n */\nexport function useStore<T extends object, S>(\n  proxyStore: T,\n  selector: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): S;\n\n/**\n * Subscribe to a store proxy **without** a selector (auto-tracked mode).\n *\n * Returns a `proxy-compare` tracking proxy over the immutable snapshot.\n * The component only re-renders when a property it actually read changes.\n *\n * @param proxyStore - A reactive proxy created by `store()`.\n */\nexport function useStore<T extends object>(proxyStore: T): Snapshot<T>;\n\n// ── Implementation ────────────────────────────────────────────────────────────\n\nexport function useStore<T extends object, S>(\n  proxyStore: T,\n  selector?: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): Snapshot<T> | S {\n  // Validate that the argument is actually a store proxy (throws if not).\n  getInternal(proxyStore);\n\n  // Stable subscribe function (internal identity never changes for a given store).\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => coreSubscribe(proxyStore, onStoreChange),\n    [proxyStore],\n  );\n\n  // ── Refs used by both modes (always allocated to satisfy Rules of Hooks) ──\n\n  // Selector mode refs\n  const snapRef = useRef<Snapshot<T> | undefined>(undefined);\n  const resultRef = useRef<S | undefined>(undefined);\n\n  // Auto-track mode refs\n  const affected = useRef(new WeakMap<object, unknown>()).current;\n  const proxyCache = useRef(new WeakMap<object, unknown>()).current;\n  const prevSnapRef = useRef<Snapshot<T> | undefined>(undefined);\n  const wrappedRef = useRef<Snapshot<T> | undefined>(undefined);\n\n  // ── Single getSnapshot for useSyncExternalStore ───────────────────────────\n\n  const getSnapshot = (): Snapshot<T> | S =>\n    selector\n      ? getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual)\n      : getAutoTrackSnapshot(\n          proxyStore,\n          affected,\n          proxyCache,\n          prevSnapRef,\n          wrappedRef,\n        );\n\n  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n}\n\n// ── Selector mode logic (pure function, no hooks) ─────────────────────────────\n\n/**\n * `getSnapshot` implementation for selector mode.\n *\n * Fast-paths when the snapshot reference hasn't changed (O(1)). Otherwise\n * runs the selector against the new snapshot and compares the result to the\n * previous one via `Object.is` (or a custom `isEqual`). Returns the previous\n * result reference when equal, preventing unnecessary React re-renders.\n *\n * Pure function -- no hooks, safe to call from `useSyncExternalStore`.\n */\nfunction getSelectorSnapshot<T extends object, S>(\n  proxyStore: T,\n  snapRef: React.RefObject<Snapshot<T> | undefined>,\n  resultRef: React.RefObject<S | undefined>,\n  selector: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): S {\n  const nextSnap = snapshot(proxyStore);\n\n  // Fast path: same snapshot reference → same result.\n  if (snapRef.current === nextSnap && resultRef.current !== undefined) {\n    return resultRef.current;\n  }\n\n  const nextResult = selector(nextSnap);\n  snapRef.current = nextSnap;\n\n  // Check equality with previous result.\n  if (\n    resultRef.current !== undefined &&\n    (isEqual\n      ? isEqual(resultRef.current, nextResult)\n      : Object.is(resultRef.current, nextResult))\n  ) {\n    return resultRef.current;\n  }\n\n  resultRef.current = nextResult;\n  return nextResult;\n}\n\n// ── Auto-tracked (selectorless) mode logic (pure function, no hooks) ──────────\n\n/**\n * `getSnapshot` implementation for auto-tracked (selectorless) mode.\n *\n * Uses `proxy-compare` to diff only the properties the component actually read.\n * If the snapshot reference is the same, returns the cached tracking proxy.\n * If the snapshot changed but no tracked property differs (`isChanged` returns\n * false), also returns the cached proxy -- avoiding re-render. Only when a\n * relevant property changed does it create a new `createProxy` wrapper.\n *\n * Pure function -- no hooks, safe to call from `useSyncExternalStore`.\n */\nfunction getAutoTrackSnapshot<T extends object>(\n  proxyStore: T,\n  affected: WeakMap<object, unknown>,\n  proxyCache: WeakMap<object, unknown>,\n  prevSnapRef: React.RefObject<Snapshot<T> | undefined>,\n  wrappedRef: React.RefObject<Snapshot<T> | undefined>,\n): Snapshot<T> {\n  const nextSnap = snapshot(proxyStore);\n\n  // If the raw snapshot is the same reference, nothing changed.\n  if (prevSnapRef.current === nextSnap) {\n    return wrappedRef.current as Snapshot<T>;\n  }\n\n  // Check if any property the component actually read has changed.\n  if (\n    prevSnapRef.current !== undefined &&\n    !isChanged(prevSnapRef.current, nextSnap, affected)\n  ) {\n    // No property the component cares about changed → return same wrapped proxy.\n    return wrappedRef.current as Snapshot<T>;\n  }\n\n  // Something relevant changed — create a new tracking proxy.\n  prevSnapRef.current = nextSnap;\n  const wrapped = createProxy(nextSnap, affected, proxyCache) as Snapshot<T>;\n  wrappedRef.current = wrapped;\n  return wrapped;\n}\n"],"mappings":";;;;;AAoCA,SAAgB,SACd,YACA,UACA,SACiB;AAEjB,aAAY,WAAW;CAGvB,MAAMA,cAAY,aACf,kBAA8BC,UAAc,YAAY,cAAc,EACvE,CAAC,WAAW,CACb;CAKD,MAAM,UAAU,OAAgC,OAAU;CAC1D,MAAM,YAAY,OAAsB,OAAU;CAGlD,MAAM,WAAW,uBAAO,IAAI,SAA0B,CAAC,CAAC;CACxD,MAAM,aAAa,uBAAO,IAAI,SAA0B,CAAC,CAAC;CAC1D,MAAM,cAAc,OAAgC,OAAU;CAC9D,MAAM,aAAa,OAAgC,OAAU;CAI7D,MAAM,oBACJ,WACI,oBAAoB,YAAY,SAAS,WAAW,UAAU,QAAQ,GACtE,qBACE,YACA,UACA,YACA,aACA,WACD;AAEP,QAAO,qBAAqBD,aAAW,aAAa,YAAY;;;;;;;;;;;;AAelE,SAAS,oBACP,YACA,SACA,WACA,UACA,SACG;CACH,MAAM,WAAW,SAAS,WAAW;AAGrC,KAAI,QAAQ,YAAY,YAAY,UAAU,YAAY,OACxD,QAAO,UAAU;CAGnB,MAAM,aAAa,SAAS,SAAS;AACrC,SAAQ,UAAU;AAGlB,KACE,UAAU,YAAY,WACrB,UACG,QAAQ,UAAU,SAAS,WAAW,GACtC,OAAO,GAAG,UAAU,SAAS,WAAW,EAE5C,QAAO,UAAU;AAGnB,WAAU,UAAU;AACpB,QAAO;;;;;;;;;;;;;AAgBT,SAAS,qBACP,YACA,UACA,YACA,aACA,YACa;CACb,MAAM,WAAW,SAAS,WAAW;AAGrC,KAAI,YAAY,YAAY,SAC1B,QAAO,WAAW;AAIpB,KACE,YAAY,YAAY,UACxB,CAAC,UAAU,YAAY,SAAS,UAAU,SAAS,CAGnD,QAAO,WAAW;AAIpB,aAAY,UAAU;CACtB,MAAM,UAAU,YAAY,UAAU,UAAU,WAAW;AAC3D,YAAW,UAAU;AACrB,QAAO"}
+{"version":3,"file":"react.mjs","names":["subscribe","coreSubscribe"],"sources":["../../src/react/react.ts"],"sourcesContent":["import {createProxy, isChanged} from 'proxy-compare';\nimport {useCallback, useRef, useState, useSyncExternalStore} from 'react';\nimport {\n  subscribe as coreSubscribe,\n  createClassyStore,\n  getInternal,\n} from '../core/core';\nimport {snapshot} from '../snapshot/snapshot';\nimport type {Snapshot} from '../types';\n\n// ── Overloads ─────────────────────────────────────────────────────────────────\n\n/**\n * Subscribe to a store proxy with an explicit selector.\n *\n * Re-renders only when the selected value changes (compared via `Object.is`\n * by default, or a custom `isEqual`).\n *\n * @param proxyStore - A reactive proxy created by `store()`.\n * @param selector  - Picks data from the immutable snapshot.\n * @param isEqual   - Optional custom equality function (default: `Object.is`).\n */\nexport function useStore<T extends object, S>(\n  proxyStore: T,\n  selector: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): S;\n\n/**\n * Subscribe to a store proxy **without** a selector (auto-tracked mode).\n *\n * Returns a `proxy-compare` tracking proxy over the immutable snapshot.\n * The component only re-renders when a property it actually read changes.\n *\n * @param proxyStore - A reactive proxy created by `store()`.\n */\nexport function useStore<T extends object>(proxyStore: T): Snapshot<T>;\n\n// ── Implementation ────────────────────────────────────────────────────────────\n\nexport function useStore<T extends object, S>(\n  proxyStore: T,\n  selector?: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): Snapshot<T> | S {\n  // Validate that the argument is actually a store proxy (throws if not).\n  getInternal(proxyStore);\n\n  // Stable subscribe function (internal identity never changes for a given store).\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => coreSubscribe(proxyStore, onStoreChange),\n    [proxyStore],\n  );\n\n  // ── Refs used by both modes (always allocated to satisfy Rules of Hooks) ──\n\n  // Selector mode refs\n  const snapRef = useRef<Snapshot<T> | undefined>(undefined);\n  const resultRef = useRef<S | undefined>(undefined);\n\n  // Auto-track mode refs\n  const affected = useRef(new WeakMap<object, unknown>()).current;\n  const proxyCache = useRef(new WeakMap<object, unknown>()).current;\n  const prevSnapRef = useRef<Snapshot<T> | undefined>(undefined);\n  const wrappedRef = useRef<Snapshot<T> | undefined>(undefined);\n\n  // ── Single getSnapshot for useSyncExternalStore ───────────────────────────\n\n  const getSnapshot = (): Snapshot<T> | S =>\n    selector\n      ? getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual)\n      : getAutoTrackSnapshot(\n          proxyStore,\n          affected,\n          proxyCache,\n          prevSnapRef,\n          wrappedRef,\n        );\n\n  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n}\n\n// ── Selector mode logic (pure function, no hooks) ─────────────────────────────\n\n/**\n * `getSnapshot` implementation for selector mode.\n *\n * Fast-paths when the snapshot reference hasn't changed (O(1)). Otherwise\n * runs the selector against the new snapshot and compares the result to the\n * previous one via `Object.is` (or a custom `isEqual`). Returns the previous\n * result reference when equal, preventing unnecessary React re-renders.\n *\n * Pure function -- no hooks, safe to call from `useSyncExternalStore`.\n */\nfunction getSelectorSnapshot<T extends object, S>(\n  proxyStore: T,\n  snapRef: React.RefObject<Snapshot<T> | undefined>,\n  resultRef: React.RefObject<S | undefined>,\n  selector: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): S {\n  const nextSnap = snapshot(proxyStore);\n\n  // Fast path: same snapshot reference → same result.\n  if (snapRef.current === nextSnap && resultRef.current !== undefined) {\n    return resultRef.current;\n  }\n\n  const nextResult = selector(nextSnap);\n  snapRef.current = nextSnap;\n\n  // Check equality with previous result.\n  if (\n    resultRef.current !== undefined &&\n    (isEqual\n      ? isEqual(resultRef.current, nextResult)\n      : Object.is(resultRef.current, nextResult))\n  ) {\n    return resultRef.current;\n  }\n\n  resultRef.current = nextResult;\n  return nextResult;\n}\n\n// ── Auto-tracked (selectorless) mode logic (pure function, no hooks) ──────────\n\n/**\n * `getSnapshot` implementation for auto-tracked (selectorless) mode.\n *\n * Uses `proxy-compare` to diff only the properties the component actually read.\n * If the snapshot reference is the same, returns the cached tracking proxy.\n * If the snapshot changed but no tracked property differs (`isChanged` returns\n * false), also returns the cached proxy -- avoiding re-render. Only when a\n * relevant property changed does it create a new `createProxy` wrapper.\n *\n * Pure function -- no hooks, safe to call from `useSyncExternalStore`.\n */\nfunction getAutoTrackSnapshot<T extends object>(\n  proxyStore: T,\n  affected: WeakMap<object, unknown>,\n  proxyCache: WeakMap<object, unknown>,\n  prevSnapRef: React.RefObject<Snapshot<T> | undefined>,\n  wrappedRef: React.RefObject<Snapshot<T> | undefined>,\n): Snapshot<T> {\n  const nextSnap = snapshot(proxyStore);\n\n  // If the raw snapshot is the same reference, nothing changed.\n  if (prevSnapRef.current === nextSnap) {\n    return wrappedRef.current as Snapshot<T>;\n  }\n\n  // Check if any property the component actually read has changed.\n  if (\n    prevSnapRef.current !== undefined &&\n    !isChanged(prevSnapRef.current, nextSnap, affected)\n  ) {\n    // No property the component cares about changed → return same wrapped proxy.\n    return wrappedRef.current as Snapshot<T>;\n  }\n\n  // Something relevant changed — create a new tracking proxy.\n  prevSnapRef.current = nextSnap;\n  const wrapped = createProxy(nextSnap, affected, proxyCache) as Snapshot<T>;\n  wrappedRef.current = wrapped;\n  return wrapped;\n}\n\n// ── Component-scoped store ────────────────────────────────────────────────────\n\n/**\n * Create a component-scoped reactive store that lives for the lifetime of the\n * component. When the component unmounts, the store becomes unreferenced and is\n * garbage collected (all internal bookkeeping uses `WeakMap`).\n *\n * The factory function runs **once** per mount (via `useState` initializer).\n * Each component instance gets its own isolated store.\n *\n * Use the returned proxy with `useStore()` to read state in the same component\n * or pass it down via props/context to share within a subtree.\n *\n * @param factory - A function that returns a class instance (or plain object).\n *                  Called once per component mount.\n * @returns A reactive store proxy scoped to the component's lifetime.\n *\n * @example\n * ```tsx\n * function Counter() {\n *   const store = useLocalStore(() => new CounterStore());\n *   const count = useStore(store, s => s.count);\n *   return <button onClick={() => store.increment()}>{count}</button>;\n * }\n * ```\n */\nexport function useLocalStore<T extends object>(factory: () => T): T {\n  const [store] = useState(() => createClassyStore(factory()));\n  return store;\n}\n"],"mappings":";;;;;AAwCA,SAAgB,SACd,YACA,UACA,SACiB;AAEjB,aAAY,WAAW;CAGvB,MAAMA,cAAY,aACf,kBAA8BC,UAAc,YAAY,cAAc,EACvE,CAAC,WAAW,CACb;CAKD,MAAM,UAAU,OAAgC,OAAU;CAC1D,MAAM,YAAY,OAAsB,OAAU;CAGlD,MAAM,WAAW,uBAAO,IAAI,SAA0B,CAAC,CAAC;CACxD,MAAM,aAAa,uBAAO,IAAI,SAA0B,CAAC,CAAC;CAC1D,MAAM,cAAc,OAAgC,OAAU;CAC9D,MAAM,aAAa,OAAgC,OAAU;CAI7D,MAAM,oBACJ,WACI,oBAAoB,YAAY,SAAS,WAAW,UAAU,QAAQ,GACtE,qBACE,YACA,UACA,YACA,aACA,WACD;AAEP,QAAO,qBAAqBD,aAAW,aAAa,YAAY;;;;;;;;;;;;AAelE,SAAS,oBACP,YACA,SACA,WACA,UACA,SACG;CACH,MAAM,WAAW,SAAS,WAAW;AAGrC,KAAI,QAAQ,YAAY,YAAY,UAAU,YAAY,OACxD,QAAO,UAAU;CAGnB,MAAM,aAAa,SAAS,SAAS;AACrC,SAAQ,UAAU;AAGlB,KACE,UAAU,YAAY,WACrB,UACG,QAAQ,UAAU,SAAS,WAAW,GACtC,OAAO,GAAG,UAAU,SAAS,WAAW,EAE5C,QAAO,UAAU;AAGnB,WAAU,UAAU;AACpB,QAAO;;;;;;;;;;;;;AAgBT,SAAS,qBACP,YACA,UACA,YACA,aACA,YACa;CACb,MAAM,WAAW,SAAS,WAAW;AAGrC,KAAI,YAAY,YAAY,SAC1B,QAAO,WAAW;AAIpB,KACE,YAAY,YAAY,UACxB,CAAC,UAAU,YAAY,SAAS,UAAU,SAAS,CAGnD,QAAO,WAAW;AAIpB,aAAY,UAAU;CACtB,MAAM,UAAU,YAAY,UAAU,UAAU,WAAW;AAC3D,YAAW,UAAU;AACrB,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BT,SAAgB,cAAgC,SAAqB;CACnE,MAAM,CAAC,SAAS,eAAe,kBAAkB,SAAS,CAAC,CAAC;AAC5D,QAAO"}

package/dist/{snapshot-C8JDLu8L.mjs → snapshot-COzEerMu.mjs}

@@ -87,12 +87,33 @@ function recordDep(internal, prop, value) {
 	});
 }
 /**
+* Record a computed getter dependency on the active tracker (if any).
+* Unlike `recordDep`, this creates a `'computed'` dep entry that validates
+* through the computed cache rather than re-executing the raw getter.
+*/
+function recordComputedDep(internal, prop, value) {
+	const tracker = activeTracker();
+	if (!tracker) return;
+	if (tracker.internal !== internal) return;
+	tracker.deps.push({
+		kind: "computed",
+		internal,
+		prop,
+		value
+	});
+}
+/**
 * Check whether all dependencies from a previous computation are still valid.
 */
 function areDepsValid(deps) {
 	for (const dep of deps) if (dep.kind === "version") {
 		if (!Object.is(Reflect.get(dep.parentTarget, dep.prop), dep.internal.target)) return false;
 		if (dep.internal.version !== dep.version) return false;
+	} else if (dep.kind === "computed") {
+		const cached = dep.internal.computedCache.get(dep.prop);
+		if (!cached) return false;
+		if (!areDepsValid(cached.deps)) return false;
+		if (!Object.is(cached.value, dep.value)) return false;
 	} else {
 		if (!Reflect.has(dep.target, dep.prop)) return false;
 		if (!Object.is(Reflect.get(dep.target, dep.prop), dep.value)) return false;
@@ -125,7 +146,7 @@ function evaluateComputed(internal, prop, getterFn, receiver) {
 }
 /**
 * Retrieve the internal bookkeeping for a store proxy.
-* Throws if the object was not created with `store()`.
+* Throws if the object was not created with `createClassyStore()`.
 */
 function getInternal(proxy) {
 	const internal = internalsMap.get(proxy);
@@ -199,7 +220,11 @@ function createStoreProxy(target, parent) {
 		},
 		get(_target, prop, receiver) {
 			const getterDesc = findGetterDescriptor(_target, prop);
-			if (getterDesc?.get) return evaluateComputed(internal, prop, getterDesc.get, receiver);
+			if (getterDesc?.get) {
+				const value = evaluateComputed(internal, prop, getterDesc.get, receiver);
+				recordComputedDep(internal, prop, value);
+				return value;
+			}
 			const value = Reflect.get(_target, prop);
 			if (typeof value === "function") {
 				if (Array.isArray(_target)) return value.bind(receiver);
@@ -247,15 +272,20 @@ function createStoreProxy(target, parent) {
 *
 * @param instance - A class instance (or plain object) to make reactive.
 * @returns The same object wrapped in a reactive Proxy.
+*
+* @example
+* ```ts
+* const myStore = createClassyStore(new MyClass());
+* ```
 */
-function store(instance) {
+function createClassyStore(instance) {
 	return createStoreProxy(instance, null);
 }
 /**
 * Subscribe to store changes. The callback fires once per batched mutation
 * (coalesced via `queueMicrotask`), not once per individual property write.
 *
-* @param proxy - A reactive proxy created by `store()`.
+* @param proxy - A reactive proxy created by `createClassyStore()`.
 * @param callback - Invoked after each batched mutation.
 * @returns An unsubscribe function. Call it to stop receiving notifications.
 */
@@ -283,7 +313,7 @@ function getVersion(proxy) {
 * Version-stamped snapshot cache for tracked (proxied) sub-trees.
 * Key: raw target object → [version, frozen snapshot].
 */
-const snapCache = /* @__PURE__ */ new WeakMap();
+const snapshotCache = /* @__PURE__ */ new WeakMap();
 /**
 * Cache for untracked nested objects (never accessed through the proxy).
 * Key: the raw mutable object → frozen deep clone.
@@ -302,7 +332,7 @@ const snapshotGetterCache = /* @__PURE__ */ new WeakMap();
 * boundaries: if `this.items` hasn't changed between snapshots (same
 * reference via structural sharing), the getter returns the same result.
 */
-const crossSnapMemo = /* @__PURE__ */ new WeakMap();
+const crossSnapshotMemo = /* @__PURE__ */ new WeakMap();
 /**
 * Run a getter against the snapshot with dependency tracking.
 *
@@ -336,7 +366,7 @@ function computeWithTracking(snap, getterFn) {
 * guarantees stable refs for unchanged sub-trees). For getter properties
 * this invokes the getter (which is itself memoized), then compares.
 */
-function areMemoedDepsValid(currentSnap, deps) {
+function areMemoizedDepsValid(currentSnap, deps) {
 	for (const dep of deps) {
 		const currentValue = Reflect.get(currentSnap, dep.prop, currentSnap);
 		if (!Object.is(currentValue, dep.value)) return false;
@@ -355,16 +385,16 @@ function areMemoedDepsValid(currentSnap, deps) {
 function evaluateSnapshotGetter(currentSnap, target, key, getterFn) {
 	const perSnapCache = snapshotGetterCache.get(currentSnap);
 	if (perSnapCache?.has(key)) return perSnapCache.get(key);
-	let memoMap = crossSnapMemo.get(target);
+	let memoMap = crossSnapshotMemo.get(target);
 	const prev = memoMap?.get(key);
 	let result;
-	if (prev && areMemoedDepsValid(currentSnap, prev.deps)) result = prev.result;
+	if (prev && areMemoizedDepsValid(currentSnap, prev.deps)) result = prev.result;
 	else {
 		const computation = computeWithTracking(currentSnap, getterFn);
 		result = computation.result;
 		if (!memoMap) {
 			memoMap = /* @__PURE__ */ new Map();
-			crossSnapMemo.set(target, memoMap);
+			crossSnapshotMemo.set(target, memoMap);
 		}
 		memoMap.set(key, {
 			deps: computation.deps,
@@ -478,7 +508,7 @@ function installMemoizedGetters(snap, target) {
 * are installed as lazy-memoizing accessors via `installMemoizedGetters`.
 */
 function createSnapshotRecursive(target, internal) {
-	const cached = snapCache.get(target);
+	const cached = snapshotCache.get(target);
 	if (cached && cached[0] === internal.version) return cached[1];
 	let snap;
 	if (Array.isArray(target)) {
@@ -495,7 +525,7 @@ function createSnapshotRecursive(target, internal) {
 		installMemoizedGetters(snap, target);
 	}
 	Object.freeze(snap);
-	snapCache.set(target, [internal.version, snap]);
+	snapshotCache.set(target, [internal.version, snap]);
 	return snap;
 }
 /**
@@ -511,7 +541,7 @@ function createSnapshotRecursive(target, internal) {
 * per snapshot and their results are stable across snapshots when dependencies
 * haven't changed (cross-snapshot memoization).
 *
-* @param proxyStore - A reactive proxy created by `store()`.
+* @param proxyStore - A reactive proxy created by `createClassyStore()`.
 * @returns A deeply frozen plain-JS object (Snapshot<T>).
 */
 function snapshot(proxyStore) {
@@ -520,5 +550,5 @@ function snapshot(proxyStore) {
 }
 
 //#endregion
-export { subscribe as a, store as i, getInternal as n, PROXYABLE as o, getVersion as r, findGetterDescriptor as s, snapshot as t };
-//# sourceMappingURL=snapshot-C8JDLu8L.mjs.map
+export { subscribe as a, getVersion as i, createClassyStore as n, PROXYABLE as o, getInternal as r, findGetterDescriptor as s, snapshot as t };
+//# sourceMappingURL=snapshot-COzEerMu.mjs.map

package/dist/snapshot-COzEerMu.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-COzEerMu.mjs","names":[],"sources":["../src/utils/internal/internal.ts","../src/core/core.ts","../src/snapshot/snapshot.ts"],"sourcesContent":["const objectProto = Object.getPrototypeOf({});\n\n/**\n * Symbol that class instances can use to opt-in to deep proxying.\n * Classes with `static [PROXYABLE] = true` will be wrapped by the store proxy\n * just like plain objects, enabling nested reactivity.\n */\nexport const PROXYABLE = Symbol.for('@codebelt/classy-store.proxyable');\n\n/**\n * Returns `true` if `value` is a plain object (created via `{}` or `new Object()`).\n * Needed by `canProxy()` to distinguish plain objects (which should be deep-proxied)\n * from class instances, Date, Map, etc. (which should not).\n */\nexport function isPlainObject(\n  value: unknown,\n): value is Record<string | symbol, unknown> {\n  if (typeof value !== 'object' || value === null) return false;\n  const proto = Object.getPrototypeOf(value);\n  return proto === objectProto || proto === null;\n}\n\n/**\n * Central gatekeeper for the proxy system: determines which values get wrapped\n * in child proxies (`core.ts`) or deep-cloned in snapshots (`snapshot.ts`).\n *\n * Returns `true` for arrays, plain objects, and class instances that opt-in\n * via `static [PROXYABLE] = true`. Everything else (Date, Map, Set, class\n * instances without PROXYABLE, primitives) is left as-is.\n */\nexport function canProxy(value: unknown): value is object {\n  if (typeof value !== 'object' || value === null) return false;\n  if (Array.isArray(value)) return true;\n  // Allow class instances that opt-in via the PROXYABLE symbol.\n  const ctor = (value as {constructor?: unknown}).constructor;\n  if (ctor && (ctor as Record<symbol, unknown>)[PROXYABLE]) {\n    return true;\n  }\n  return isPlainObject(value);\n}\n\n/**\n * Walk the prototype chain of `target` looking for a getter descriptor for `prop`.\n * Returns the first (most-derived) getter found, or `undefined` if none exists.\n *\n * Used by `core.ts` (GET trap) to detect class getters for memoized evaluation,\n * and by `snapshot.ts` to skip own-property copying for getter-backed keys.\n */\nexport function findGetterDescriptor(\n  target: object,\n  prop: string | symbol,\n): PropertyDescriptor | undefined {\n  let proto: object | null = target;\n  while (proto) {\n    const desc = Object.getOwnPropertyDescriptor(proto, prop);\n    if (desc?.get) return desc;\n    proto = Object.getPrototypeOf(proto);\n  }\n  return undefined;\n}\n","import type {DepEntry, StoreInternal} from '../types';\nimport {canProxy, findGetterDescriptor} from '../utils/internal/internal';\n\n// ── Global state ──────────────────────────────────────────────────────────────\n\n/** Global version counter shared across all stores. */\nlet globalVersion = 0;\n\n/** Maps every store proxy → its internal bookkeeping. */\nconst internalsMap = new WeakMap<object, StoreInternal>();\n\n// ── Dependency tracking for computed getters ──────────────────────────────────\n\n/**\n * Stack of active dependency trackers. Each entry records which properties\n * a getter reads during evaluation. A stack (not a single variable) is needed\n * because getter A can read getter B, which pushes a second tracker.\n */\nconst trackerStack: {internal: StoreInternal; deps: DepEntry[]}[] = [];\n\n/** Returns the tracker currently recording deps, or `null` if none is active. */\nfunction activeTracker() {\n  return trackerStack.length > 0 ? trackerStack[trackerStack.length - 1] : null;\n}\n\n/**\n * Record a dependency on the active tracker (if any).\n * Called from the GET trap whenever a non-getter, non-method property is read.\n */\nfunction recordDep(\n  internal: StoreInternal,\n  prop: string | symbol,\n  value: unknown,\n): void {\n  const tracker = activeTracker();\n  if (!tracker) return;\n\n  // Only record deps for reads on the SAME proxy that owns the getter.\n  // Child-proxy reads don't need explicit tracking because child mutations\n  // bubble up via version numbers on the parent's childInternals.\n  if (tracker.internal !== internal) return;\n\n  const childInternal = internal.childInternals.get(prop);\n  if (childInternal) {\n    tracker.deps.push({\n      kind: 'version',\n      internal: childInternal,\n      version: childInternal.version,\n      parentTarget: internal.target,\n      prop,\n    });\n  } else {\n    tracker.deps.push({kind: 'value', target: internal.target, prop, value});\n  }\n}\n\n/**\n * Record a computed getter dependency on the active tracker (if any).\n * Unlike `recordDep`, this creates a `'computed'` dep entry that validates\n * through the computed cache rather than re-executing the raw getter.\n */\nfunction recordComputedDep(\n  internal: StoreInternal,\n  prop: string | symbol,\n  value: unknown,\n): void {\n  const tracker = activeTracker();\n  if (!tracker) return;\n  if (tracker.internal !== internal) return;\n\n  tracker.deps.push({kind: 'computed', internal, prop, value});\n}\n\n/**\n * Check whether all dependencies from a previous computation are still valid.\n */\nfunction areDepsValid(deps: DepEntry[]): boolean {\n  for (const dep of deps) {\n    if (dep.kind === 'version') {\n      // Verify the parent property still references the same child object.\n      // If the property was replaced entirely (e.g., store.items = newArray),\n      // the old child internal is detached and its version never changes.\n      // This check catches that case.\n      if (\n        !Object.is(Reflect.get(dep.parentTarget, dep.prop), dep.internal.target)\n      )\n        return false;\n      if (dep.internal.version !== dep.version) return false;\n    } else if (dep.kind === 'computed') {\n      // Validate through the computed cache — never re-execute the raw getter.\n      const cached = dep.internal.computedCache.get(dep.prop);\n      if (!cached) return false; // no cache → must recompute\n      if (!areDepsValid(cached.deps)) return false; // nested deps changed\n      if (!Object.is(cached.value, dep.value)) return false; // value changed\n    } else {\n      // Check that the property still exists — if it was deleted and\n      // dep.value was `undefined`, Object.is(undefined, undefined) would\n      // incorrectly pass without this guard.\n      if (!Reflect.has(dep.target, dep.prop)) return false;\n      if (!Object.is(Reflect.get(dep.target, dep.prop), dep.value))\n        return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Evaluate a computed getter with memoization.\n * Returns the cached value if dependencies haven't changed.\n * Otherwise re-evaluates with dependency tracking and caches the result.\n */\nfunction evaluateComputed(\n  internal: StoreInternal,\n  prop: string | symbol,\n  getterFn: () => unknown,\n  receiver: object,\n): unknown {\n  const cached = internal.computedCache.get(prop);\n  if (cached && areDepsValid(cached.deps)) {\n    return cached.value;\n  }\n\n  // Push a new tracker frame for this getter evaluation.\n  const frame = {internal, deps: [] as DepEntry[]};\n  trackerStack.push(frame);\n  try {\n    const value = getterFn.call(receiver);\n    internal.computedCache.set(prop, {value, deps: frame.deps});\n    return value;\n  } finally {\n    trackerStack.pop();\n  }\n}\n\n// ── Public helpers ────────────────────────────────────────────────────────────\n\n/**\n * Retrieve the internal bookkeeping for a store proxy.\n * Throws if the object was not created with `createClassyStore()`.\n */\nexport function getInternal(proxy: object): StoreInternal {\n  const internal = internalsMap.get(proxy);\n  if (!internal)\n    throw new Error('@codebelt/classy-store: object is not a store proxy');\n  return internal;\n}\n\n// ── Notification batching ─────────────────────────────────────────────────────\n\n/**\n * Bump version from the mutated node up to the root, invalidate snapshot caches,\n * and schedule a single microtask notification (deduped at the root level).\n *\n * Version propagation is what enables structural sharing in snapshots: unchanged\n * children keep their old version, so the snapshot cache returns the same frozen ref.\n */\nfunction scheduleNotify(internal: StoreInternal): void {\n  let current: StoreInternal | null = internal;\n  while (current) {\n    current.version = ++globalVersion;\n    current = current.parent;\n  }\n\n  const root = getRoot(internal);\n  if (!root.notifyScheduled) {\n    root.notifyScheduled = true;\n    queueMicrotask(() => {\n      root.notifyScheduled = false;\n      for (const listener of root.listeners) {\n        listener();\n      }\n    });\n  }\n}\n\n/** Walk the parent chain to find the root StoreInternal (the notification hub). */\nfunction getRoot(internal: StoreInternal): StoreInternal {\n  let current = internal;\n  while (current.parent) {\n    current = current.parent;\n  }\n  return current;\n}\n\n// ── Create proxy (recursive) ──────────────────────────────────────────────────\n\n/**\n * Create an ES6 Proxy around `target` with SET/GET/DELETE traps.\n *\n * This is the core of the library's reactivity. The proxy intercepts:\n * - **SET**: compares old/new with `Object.is`, cleans up child proxies on replacement,\n *   forwards the write, and schedules a batched notification.\n * - **GET**: detects class getters (memoized), binds methods to the proxy, lazily wraps\n *   nested objects/arrays in child proxies, and records dependencies for computed getters.\n * - **DELETE**: cleans up child proxies and schedules notification.\n *\n * Nested objects are recursively wrapped on first access (lazy deep proxy).\n */\nfunction createStoreProxy<T extends object>(\n  target: T,\n  parent: StoreInternal | null,\n): T {\n  const internal: StoreInternal = {\n    target,\n    version: ++globalVersion,\n    listeners: new Set(),\n    childProxies: new Map(),\n    childInternals: new Map(),\n    parent,\n    notifyScheduled: false,\n    computedCache: new Map(),\n  };\n\n  /** Cache for bound methods so we return the same reference each time. */\n  const boundMethods = new Map<\n    string | symbol,\n    (...args: unknown[]) => unknown\n  >();\n\n  const proxy = new Proxy(target, {\n    set(_target, prop, value, _receiver) {\n      const oldValue = Reflect.get(_target, prop);\n      if (Object.is(oldValue, value)) return true; // noop — same value\n\n      // If the new value replaces a child proxy, clean it up.\n      if (internal.childProxies.has(prop)) {\n        internal.childProxies.delete(prop);\n        internal.childInternals.delete(prop);\n      }\n\n      Reflect.set(_target, prop, value);\n      scheduleNotify(internal);\n      return true;\n    },\n\n    get(_target, prop, receiver) {\n      // 1. Check for getters on the prototype chain (computed values).\n      const getterDesc = findGetterDescriptor(_target, prop);\n      if (getterDesc?.get) {\n        // Memoized: evaluate with dependency tracking, return cached if deps unchanged.\n        const value = evaluateComputed(\n          internal,\n          prop,\n          getterDesc.get,\n          receiver,\n        );\n        // Record as a computed dependency for any parent getter currently tracking.\n        // Uses 'computed' dep kind so validation goes through the cache, not raw getter.\n        recordComputedDep(internal, prop, value);\n        return value;\n      }\n\n      const value = Reflect.get(_target, prop);\n\n      // 2. Methods: bind to the proxy so `this.prop = x` goes through SET trap.\n      if (typeof value === 'function') {\n        // Array prototype methods should not be cached the same way as class methods.\n        if (Array.isArray(_target)) {\n          return value.bind(receiver);\n        }\n        const cached = boundMethods.get(prop);\n        if (cached) return cached;\n        const bound = (value as (...args: unknown[]) => unknown).bind(receiver);\n        boundMethods.set(prop, bound);\n        return bound;\n      }\n\n      // 3. Nested plain objects/arrays: lazy-wrap in a child proxy.\n      if (canProxy(value)) {\n        let childProxy = internal.childProxies.get(prop);\n        if (!childProxy) {\n          childProxy = createStoreProxy(value as object, internal);\n          internal.childProxies.set(prop, childProxy);\n          const childInternal = internalsMap.get(childProxy) as StoreInternal;\n          internal.childInternals.set(prop, childInternal);\n        }\n        // Record dependency AFTER ensuring child proxy/internal exists.\n        recordDep(internal, prop, value);\n        return childProxy;\n      }\n\n      // 4. Primitives — record dependency and return.\n      recordDep(internal, prop, value);\n      return value;\n    },\n\n    deleteProperty(_target, prop) {\n      if (internal.childProxies.has(prop)) {\n        internal.childProxies.delete(prop);\n        internal.childInternals.delete(prop);\n      }\n      const deleted = Reflect.deleteProperty(_target, prop);\n      if (deleted) {\n        scheduleNotify(internal);\n      }\n      return deleted;\n    },\n  });\n\n  internalsMap.set(proxy, internal);\n  return proxy;\n}\n\n// ── Public API ────────────────────────────────────────────────────────────────\n\n/**\n * Wraps a class instance in a reactive proxy.\n *\n * - Mutations (property writes, array push/splice, etc.) are intercepted and\n *   batched into a single notification per microtask.\n * - Class getters are automatically memoized — they only recompute when a\n *   dependency they read changes.\n * - Methods are automatically bound so `this` mutations go through the proxy.\n *\n * @param instance - A class instance (or plain object) to make reactive.\n * @returns The same object wrapped in a reactive Proxy.\n *\n * @example\n * ```ts\n * const myStore = createClassyStore(new MyClass());\n * ```\n */\nexport function createClassyStore<T extends object>(instance: T): T {\n  return createStoreProxy(instance, null);\n}\n\n/**\n * Subscribe to store changes. The callback fires once per batched mutation\n * (coalesced via `queueMicrotask`), not once per individual property write.\n *\n * @param proxy - A reactive proxy created by `createClassyStore()`.\n * @param callback - Invoked after each batched mutation.\n * @returns An unsubscribe function. Call it to stop receiving notifications.\n */\nexport function subscribe(proxy: object, callback: () => void): () => void {\n  const internal = getInternal(proxy);\n  // Always subscribe on the root so notifications fire regardless of\n  // whether the user subscribes to the root proxy or a child proxy.\n  const root = getRoot(internal);\n  root.listeners.add(callback);\n  return () => {\n    root.listeners.delete(callback);\n  };\n}\n\n/**\n * Returns the current version number of a store proxy.\n *\n * Versions are monotonically increasing and bump on any mutation in the\n * store's subtree (child mutations propagate up to the root). Useful for\n * debugging, custom cache invalidation, or testing whether a store has changed.\n */\nexport function getVersion(proxy: object): number {\n  return getInternal(proxy).version;\n}\n","import {getInternal} from '../core/core';\nimport type {Snapshot, StoreInternal} from '../types';\nimport {canProxy, findGetterDescriptor} from '../utils/internal/internal';\n\n// ── Caches ────────────────────────────────────────────────────────────────────\n\n/**\n * Version-stamped snapshot cache for tracked (proxied) sub-trees.\n * Key: raw target object → [version, frozen snapshot].\n */\nconst snapshotCache = new WeakMap<object, [version: number, snap: object]>();\n\n/**\n * Cache for untracked nested objects (never accessed through the proxy).\n * Key: the raw mutable object → frozen deep clone.\n * Safe because untracked objects can't be mutated through the proxy.\n */\nconst untrackedCache = new WeakMap<object, object>();\n\n/**\n * Per-snapshot, per-getter cache. Ensures repeated access to the same getter\n * on the same frozen snapshot returns the identical reference.\n */\nconst snapshotGetterCache = new WeakMap<\n  object,\n  Map<string | symbol, unknown>\n>();\n\n// ── Cross-snapshot getter memoization ─────────────────────────────────────────\n\n/**\n * A dependency recorded during getter execution.\n * prop: the property name read on `this`.\n * value: the value returned (reference).\n */\ntype GetterDep = {prop: string | symbol; value: unknown};\n\n/**\n * Cached result of a snapshot getter with the dependencies it read,\n * used for cross-snapshot memoization. When a new snapshot is created,\n * we check if the deps are still reference-equal (via structural sharing)\n * and return the cached result if so -- avoiding re-execution of the getter.\n */\ntype GetterMemoEntry = {deps: GetterDep[]; result: unknown};\n\n/**\n * Cross-snapshot getter memoization cache.\n * Keyed by raw class instance (target), maps each getter name to its last\n * deps + result. This enables getter result stability across snapshot\n * boundaries: if `this.items` hasn't changed between snapshots (same\n * reference via structural sharing), the getter returns the same result.\n */\nconst crossSnapshotMemo = new WeakMap<\n  object,\n  Map<string | symbol, GetterMemoEntry>\n>();\n\n/**\n * Run a getter against the snapshot with dependency tracking.\n *\n * Creates a lightweight Proxy that intercepts `this.prop` reads and records\n * which properties (and their values/references) the getter accessed. The\n * Proxy delegates to the real frozen snapshot for actual values, so getters\n * that read other getters trigger the memoized getter chain correctly.\n */\nfunction computeWithTracking(\n  snap: object,\n  getterFn: () => unknown,\n): {deps: GetterDep[]; result: unknown} {\n  const deps: GetterDep[] = [];\n  const readProps = new Set<string | symbol>();\n\n  // Use an empty non-frozen target — we delegate everything to `snap`.\n  const handler: ProxyHandler<object> = {\n    get(_dummyTarget, prop, _receiver) {\n      // Delegate to the real snapshot (receiver = snap so installed getters\n      // run with `this = snap`, triggering their own memoization chain).\n      const value = Reflect.get(snap, prop, snap);\n      if (!readProps.has(prop)) {\n        readProps.add(prop);\n        deps.push({prop, value});\n      }\n      return value;\n    },\n  };\n\n  const tracked = new Proxy({}, handler);\n  const result = getterFn.call(tracked);\n  return {deps, result};\n}\n\n/**\n * Check if all previously recorded deps still hold on the current snapshot.\n * For data properties this is a reference comparison (structural sharing\n * guarantees stable refs for unchanged sub-trees). For getter properties\n * this invokes the getter (which is itself memoized), then compares.\n */\nfunction areMemoizedDepsValid(currentSnap: object, deps: GetterDep[]): boolean {\n  for (const dep of deps) {\n    const currentValue = Reflect.get(currentSnap, dep.prop, currentSnap);\n    if (!Object.is(currentValue, dep.value)) return false;\n  }\n  return true;\n}\n\n/**\n * Evaluate a snapshot getter with two layers of caching:\n *\n * 1. **Per-snapshot cache** — same getter on the same frozen snapshot always\n *    returns the same reference.\n * 2. **Cross-snapshot memo** — if the properties the getter read last time are\n *    structurally the same (reference equality via structural sharing), the\n *    previous result is returned without re-running the getter body.\n */\nfunction evaluateSnapshotGetter(\n  currentSnap: object,\n  target: object,\n  key: string | symbol,\n  getterFn: () => unknown,\n): unknown {\n  // ── Per-snapshot fast path ──\n  const perSnapCache = snapshotGetterCache.get(currentSnap);\n  if (perSnapCache?.has(key)) return perSnapCache.get(key);\n\n  // ── Cross-snapshot memo ──\n  let memoMap = crossSnapshotMemo.get(target);\n  const prev = memoMap?.get(key);\n\n  let result: unknown;\n\n  if (prev && areMemoizedDepsValid(currentSnap, prev.deps)) {\n    // Dependencies unchanged → reuse previous result.\n    result = prev.result;\n  } else {\n    // Compute fresh with dep tracking.\n    const computation = computeWithTracking(currentSnap, getterFn);\n    result = computation.result;\n\n    // Save cross-snapshot memo.\n    if (!memoMap) {\n      memoMap = new Map();\n      crossSnapshotMemo.set(target, memoMap);\n    }\n    memoMap.set(key, {deps: computation.deps, result});\n  }\n\n  // Save per-snapshot cache.\n  let cache = snapshotGetterCache.get(currentSnap);\n  if (!cache) {\n    cache = new Map();\n    snapshotGetterCache.set(currentSnap, cache);\n  }\n  cache.set(key, result);\n\n  return result;\n}\n\n// ── Internal helpers ──────────────────────────────────────────────────────────\n\n/**\n * Resolve a single property value into its snapshot equivalent.\n *\n * - If the key has a tracked child internal → recurse (version-cached, structural sharing).\n * - If the value is a nested plain object/array without tracking → deep-clone & freeze (cached by identity).\n * - Otherwise → return the value as-is (primitive, Date, Map, function, etc.).\n */\nfunction snapshotValue(\n  value: unknown,\n  parentInternal: StoreInternal,\n  key: string | symbol,\n): unknown {\n  const childInternal = parentInternal.childInternals.get(key);\n  if (childInternal) {\n    return createSnapshotRecursive(childInternal.target, childInternal);\n  }\n  if (canProxy(value)) {\n    return deepFreezeClone(value as object);\n  }\n  return value;\n}\n\n/**\n * Deep-clone and freeze a plain object or array that is NOT tracked by a proxy.\n * Cached by raw object identity for structural sharing across snapshots.\n */\nfunction deepFreezeClone(value: object): object {\n  const cached = untrackedCache.get(value);\n  if (cached) return cached;\n\n  let clone: Record<string | symbol, unknown> | unknown[];\n\n  if (Array.isArray(value)) {\n    clone = [];\n    for (let i = 0; i < value.length; i++) {\n      const item = value[i];\n      (clone as unknown[])[i] = canProxy(item)\n        ? deepFreezeClone(item as object)\n        : item;\n    }\n  } else {\n    clone = Object.create(Object.getPrototypeOf(value));\n    for (const key of Reflect.ownKeys(value)) {\n      const desc = Object.getOwnPropertyDescriptor(value, key);\n      if (!desc || !('value' in desc)) continue;\n      const item = desc.value;\n      (clone as Record<string | symbol, unknown>)[key] = canProxy(item)\n        ? deepFreezeClone(item as object)\n        : item;\n    }\n  }\n\n  Object.freeze(clone);\n  untrackedCache.set(value, clone);\n  return clone;\n}\n\n/**\n * Collect all getter descriptors from the prototype chain of `target`.\n * Returns an array of [propertyName, getterFunction] pairs.\n *\n * Only includes getters defined on the prototype (class getters), not on the\n * instance itself. When a getter is overridden in a subclass, the most-derived\n * version wins (we walk from the instance's direct prototype upward and skip\n * keys already seen).\n */\nfunction collectGetters(\n  target: object,\n): Array<[string | symbol, () => unknown]> {\n  const getters: Array<[string | symbol, () => unknown]> = [];\n  const seen = new Set<string | symbol>();\n  let proto: object | null = Object.getPrototypeOf(target);\n  while (proto && proto !== Object.prototype) {\n    for (const key of Reflect.ownKeys(proto)) {\n      if (key === 'constructor') continue;\n      if (seen.has(key)) continue; // most-derived version already collected\n      const desc = Object.getOwnPropertyDescriptor(proto, key);\n      if (desc?.get) {\n        getters.push([key, desc.get]);\n        seen.add(key);\n      }\n    }\n    proto = Object.getPrototypeOf(proto);\n  }\n  return getters;\n}\n\n/**\n * Install lazy-memoizing getters on a snapshot object.\n *\n * Each getter uses cross-snapshot memoization:\n * - Tracks which `this` properties the getter reads on first evaluation.\n * - On subsequent snapshots, if those properties are structurally the same\n *   (thanks to structural sharing), the previous result is returned.\n * - Within the same snapshot, repeated accesses always return the same ref.\n */\nfunction installMemoizedGetters(\n  snap: Record<string | symbol, unknown>,\n  target: object,\n): void {\n  const getters = collectGetters(target);\n  for (const [key, getterFn] of getters) {\n    Object.defineProperty(snap, key, {\n      get() {\n        return evaluateSnapshotGetter(this as object, target, key, getterFn);\n      },\n      enumerable: true,\n      configurable: true, // required so Object.freeze can make it non-configurable\n    });\n  }\n}\n\n/**\n * Recursively creates a frozen snapshot from a tracked (proxied) sub-tree.\n *\n * Each node checks its version-stamped cache first (O(1) hit). On a miss,\n * it builds a new frozen object by recursing into child internals (tracked\n * sub-trees) and deep-cloning untracked nested objects. Unchanged children\n * return the same cached reference, achieving structural sharing -- the key\n * to efficient `Object.is` equality in selectors.\n *\n * For class instances, the prototype chain is preserved and class getters\n * are installed as lazy-memoizing accessors via `installMemoizedGetters`.\n */\nfunction createSnapshotRecursive<T extends object>(\n  target: T,\n  internal: StoreInternal,\n): T {\n  // Cache hit: version unchanged → return the same frozen snapshot reference.\n  const cached = snapshotCache.get(target);\n  if (cached && cached[0] === internal.version) {\n    return cached[1] as T;\n  }\n\n  let snap: Record<string | symbol, unknown> | unknown[];\n\n  if (Array.isArray(target)) {\n    snap = [];\n    for (let i = 0; i < target.length; i++) {\n      (snap as unknown[])[i] = snapshotValue(target[i], internal, String(i));\n    }\n  } else {\n    // Preserve the prototype chain and install memoized getters on the snapshot.\n    snap = Object.create(Object.getPrototypeOf(target));\n    for (const key of Reflect.ownKeys(target)) {\n      // Skip prototype getters — they re-evaluate via the preserved prototype.\n      if (findGetterDescriptor(target, key)?.get) continue;\n\n      const desc = Object.getOwnPropertyDescriptor(target, key);\n      if (!desc || !('value' in desc)) continue;\n\n      (snap as Record<string | symbol, unknown>)[key] = snapshotValue(\n        desc.value,\n        internal,\n        key,\n      );\n    }\n\n    // Install lazy-memoizing getters with cross-snapshot caching.\n    installMemoizedGetters(snap as Record<string | symbol, unknown>, target);\n  }\n\n  Object.freeze(snap);\n  // Cache AFTER populating + freezing. The reference is stable.\n  snapshotCache.set(target, [internal.version, snap]);\n  return snap as T;\n}\n\n// ── Public API ────────────────────────────────────────────────────────────────\n\n/**\n * Creates an immutable, deeply-frozen snapshot of the store proxy's current state.\n *\n * **Structural sharing:** unchanged sub-trees reuse the previous snapshot's\n * object reference, so `===` comparison can cheaply detect changes.\n *\n * **Version-cached:** calling `snapshot()` multiple times without intervening\n * mutations returns the identical snapshot object (O(1) cache hit).\n *\n * **Getters:** class getters are automatically memoized — they compute once\n * per snapshot and their results are stable across snapshots when dependencies\n * haven't changed (cross-snapshot memoization).\n *\n * @param proxyStore - A reactive proxy created by `createClassyStore()`.\n * @returns A deeply frozen plain-JS object (Snapshot<T>).\n */\nexport function snapshot<T extends object>(proxyStore: T): Snapshot<T> {\n  const internal = getInternal(proxyStore);\n  return createSnapshotRecursive(internal.target, internal) as Snapshot<T>;\n}\n"],"mappings":"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"}