@codebelt/classy-store 0.0.2 → 0.1.0

package/dist/index.cjs

@@ -1,9 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_snapshot = require('./snapshot-CR8nA2Ob.cjs');
+const require_snapshot = require('./snapshot-BKVFJLuo.cjs');
 
 //#region src/collections/collections.ts
 /**
-* A Map-like class backed by a plain array so `store()` can proxy mutations.
+* A Map-like class backed by a plain array so `createClassyStore()` can proxy mutations.
 *
 * Native `Map` uses internal slots that ES6 Proxy can't intercept, so mutations
 * like `.set()` would be invisible to the store. `ReactiveMap` solves this by
@@ -11,7 +11,7 @@ const require_snapshot = require('./snapshot-CR8nA2Ob.cjs');
 *
 * Usage:
 * ```ts
-* const myStore = store({ users: reactiveMap<string, User>() });
+* const myStore = createClassyStore({ users: reactiveMap<string, User>() });
 * myStore.users.set('id1', { name: 'Alice' }); // reactive
 * ```
 */
@@ -80,7 +80,7 @@ var ReactiveMap = class {
 	}
 };
 /**
-* A Set-like class backed by a plain array so `store()` can proxy mutations.
+* A Set-like class backed by a plain array so `createClassyStore()` can proxy mutations.
 *
 * Native `Set` uses internal slots that ES6 Proxy can't intercept, so mutations
 * like `.add()` would be invisible to the store. `ReactiveSet` solves this by
@@ -88,7 +88,7 @@ var ReactiveMap = class {
 *
 * Usage:
 * ```ts
-* const myStore = store({ tags: reactiveSet<string>(['urgent']) });
+* const myStore = createClassyStore({ tags: reactiveSet<string>(['urgent']) });
 * myStore.tags.add('bug'); // reactive
 * ```
 */
@@ -149,7 +149,7 @@ var ReactiveSet = class {
 };
 /**
 * Creates a reactive Map-like collection backed by a plain array.
-* Wrap the parent object with `store()` for full reactivity.
+* Wrap the parent object with `createClassyStore()` for full reactivity.
 *
 * @param initial - Optional iterable of `[key, value]` pairs.
 */
@@ -158,7 +158,7 @@ function reactiveMap(initial) {
 }
 /**
 * Creates a reactive Set-like collection backed by a plain array.
-* Wrap the parent object with `store()` for full reactivity.
+* Wrap the parent object with `createClassyStore()` for full reactivity.
 *
 * @param initial - Optional iterable of values.
 */
@@ -192,11 +192,11 @@ function shallowEqual(a, b) {
 }
 
 //#endregion
+exports.createClassyStore = require_snapshot.createClassyStore;
 exports.getVersion = require_snapshot.getVersion;
 exports.reactiveMap = reactiveMap;
 exports.reactiveSet = reactiveSet;
 exports.shallowEqual = shallowEqual;
 exports.snapshot = require_snapshot.snapshot;
-exports.store = require_snapshot.store;
 exports.subscribe = require_snapshot.subscribe;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["PROXYABLE"],"sources":["../src/collections/collections.ts","../src/utils/equality/equality.ts"],"sourcesContent":["import {PROXYABLE} from '../utils/internal/internal';\n\n// ── ReactiveMap ───────────────────────────────────────────────────────────────\n\n/**\n * A Map-like class backed by a plain array so `store()` can proxy mutations.\n *\n * Native `Map` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.set()` would be invisible to the store. `ReactiveMap` solves this by\n * storing entries in a plain array (`_entries`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = store({ users: reactiveMap<string, User>() });\n * myStore.users.set('id1', { name: 'Alice' }); // reactive\n * ```\n */\nexport class ReactiveMap<K, V> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _entries: [K, V][] = [];\n\n  /** Deduplicates initial entries by key (last value wins, matching native `Map`). */\n  constructor(initial?: Iterable<[K, V]>) {\n    if (initial) {\n      for (const [k, v] of initial) {\n        const index = this._entries.findIndex(([ek]) => Object.is(ek, k));\n        if (index !== -1) {\n          this._entries[index] = [k, v];\n        } else {\n          this._entries.push([k, v]);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of entries. */\n  get size(): number {\n    return this._entries.length;\n  }\n\n  /** Returns the value for `key`, or `undefined`. O(n) linear scan. */\n  get(key: K): V | undefined {\n    const entry = this._entries.find(([k]) => Object.is(k, key));\n    return entry ? entry[1] : undefined;\n  }\n\n  /** Returns `true` if `key` exists. O(n) linear scan. */\n  has(key: K): boolean {\n    return this._entries.some(([k]) => Object.is(k, key));\n  }\n\n  /** Sets `key` to `value`. Updates in-place if key exists, appends otherwise. */\n  set(key: K, value: V): this {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index !== -1) {\n      this._entries[index] = [key, value];\n    } else {\n      this._entries.push([key, value]);\n    }\n    return this;\n  }\n\n  /** Removes the entry for `key`. Returns `true` if found. */\n  delete(key: K): boolean {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index === -1) return false;\n    this._entries.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all entries. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._entries.splice(0, this._entries.length);\n  }\n\n  /** Returns an iterator over the keys. */\n  keys(): IterableIterator<K> {\n    return this._entries.map(([k]) => k)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<V> {\n    return this._entries.map(([, v]) => v)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [key, value] pairs. */\n  entries(): IterableIterator<[K, V]> {\n    return this._entries.map(([k, v]) => [k, v] as [K, V])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each entry, matching the native `Map.forEach` signature. */\n  forEach(callback: (value: V, key: K, map: ReactiveMap<K, V>) => void): void {\n    for (const [k, v] of this._entries) {\n      callback(v, k, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over [key, value] pairs. */\n  [Symbol.iterator](): IterableIterator<[K, V]> {\n    return this.entries();\n  }\n}\n\n// ── ReactiveSet ───────────────────────────────────────────────────────────────\n\n/**\n * A Set-like class backed by a plain array so `store()` can proxy mutations.\n *\n * Native `Set` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.add()` would be invisible to the store. `ReactiveSet` solves this by\n * storing items in a plain array (`_items`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = store({ tags: reactiveSet<string>(['urgent']) });\n * myStore.tags.add('bug'); // reactive\n * ```\n */\nexport class ReactiveSet<T> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _items: T[] = [];\n\n  /** Deduplicates initial values using `Object.is` comparison. */\n  constructor(initial?: Iterable<T>) {\n    if (initial) {\n      for (const v of initial) {\n        if (!this._items.some((item) => Object.is(item, v))) {\n          this._items.push(v);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of unique items. */\n  get size(): number {\n    return this._items.length;\n  }\n\n  /** Returns `true` if `value` exists. O(n) linear scan. */\n  has(value: T): boolean {\n    return this._items.some((item) => Object.is(item, value));\n  }\n\n  /** Adds `value` if not already present (no-op for duplicates). */\n  add(value: T): this {\n    if (!this.has(value)) {\n      this._items.push(value);\n    }\n    return this;\n  }\n\n  /** Removes `value`. Returns `true` if found. */\n  delete(value: T): boolean {\n    const index = this._items.findIndex((item) => Object.is(item, value));\n    if (index === -1) return false;\n    this._items.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all items. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._items.splice(0, this._items.length);\n  }\n\n  /** Returns an iterator over the values (same as `values()`, matching Set API). */\n  keys(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [value, value] pairs, matching the native Set API. */\n  entries(): IterableIterator<[T, T]> {\n    return this._items.map((v) => [v, v] as [T, T])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each item, matching the native `Set.forEach` signature. */\n  forEach(callback: (value: T, key: T, set: ReactiveSet<T>) => void): void {\n    for (const v of this._items) {\n      callback(v, v, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over values. */\n  [Symbol.iterator](): IterableIterator<T> {\n    return this.values();\n  }\n}\n\n// ── Factory functions ─────────────────────────────────────────────────────────\n\n/**\n * Creates a reactive Map-like collection backed by a plain array.\n * Wrap the parent object with `store()` for full reactivity.\n *\n * @param initial - Optional iterable of `[key, value]` pairs.\n */\nexport function reactiveMap<K, V>(\n  initial?: Iterable<[K, V]>,\n): ReactiveMap<K, V> {\n  return new ReactiveMap(initial);\n}\n\n/**\n * Creates a reactive Set-like collection backed by a plain array.\n * Wrap the parent object with `store()` for full reactivity.\n *\n * @param initial - Optional iterable of values.\n */\nexport function reactiveSet<T>(initial?: Iterable<T>): ReactiveSet<T> {\n  return new ReactiveSet(initial);\n}\n","/**\n * Shallow-equal comparison for objects and arrays.\n * Useful as a custom `isEqual` for `useStore` selectors that return objects/arrays.\n *\n * - Primitives compared with `Object.is`.\n * - Arrays: length + element-wise `Object.is`.\n * - Objects: key count + value-wise `Object.is`.\n */\nexport function shallowEqual<T>(a: T, b: T): boolean {\n  if (Object.is(a, b)) return true;\n  if (\n    typeof a !== 'object' ||\n    a === null ||\n    typeof b !== 'object' ||\n    b === null\n  ) {\n    return false;\n  }\n\n  if (Array.isArray(a) && Array.isArray(b)) {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!Object.is(a[i], b[i])) return false;\n    }\n    return true;\n  }\n\n  const keysA = Object.keys(a);\n  const keysB = Object.keys(b);\n  if (keysA.length !== keysB.length) return false;\n\n  for (const key of keysA) {\n    if (\n      !Object.hasOwn(b, key) ||\n      !Object.is(\n        (a as Record<string, unknown>)[key],\n        (b as Record<string, unknown>)[key],\n      )\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.cjs","names":["PROXYABLE"],"sources":["../src/collections/collections.ts","../src/utils/equality/equality.ts"],"sourcesContent":["import {PROXYABLE} from '../utils/internal/internal';\n\n// ── ReactiveMap ───────────────────────────────────────────────────────────────\n\n/**\n * A Map-like class backed by a plain array so `createClassyStore()` can proxy mutations.\n *\n * Native `Map` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.set()` would be invisible to the store. `ReactiveMap` solves this by\n * storing entries in a plain array (`_entries`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = createClassyStore({ users: reactiveMap<string, User>() });\n * myStore.users.set('id1', { name: 'Alice' }); // reactive\n * ```\n */\nexport class ReactiveMap<K, V> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _entries: [K, V][] = [];\n\n  /** Deduplicates initial entries by key (last value wins, matching native `Map`). */\n  constructor(initial?: Iterable<[K, V]>) {\n    if (initial) {\n      for (const [k, v] of initial) {\n        const index = this._entries.findIndex(([ek]) => Object.is(ek, k));\n        if (index !== -1) {\n          this._entries[index] = [k, v];\n        } else {\n          this._entries.push([k, v]);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of entries. */\n  get size(): number {\n    return this._entries.length;\n  }\n\n  /** Returns the value for `key`, or `undefined`. O(n) linear scan. */\n  get(key: K): V | undefined {\n    const entry = this._entries.find(([k]) => Object.is(k, key));\n    return entry ? entry[1] : undefined;\n  }\n\n  /** Returns `true` if `key` exists. O(n) linear scan. */\n  has(key: K): boolean {\n    return this._entries.some(([k]) => Object.is(k, key));\n  }\n\n  /** Sets `key` to `value`. Updates in-place if key exists, appends otherwise. */\n  set(key: K, value: V): this {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index !== -1) {\n      this._entries[index] = [key, value];\n    } else {\n      this._entries.push([key, value]);\n    }\n    return this;\n  }\n\n  /** Removes the entry for `key`. Returns `true` if found. */\n  delete(key: K): boolean {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index === -1) return false;\n    this._entries.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all entries. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._entries.splice(0, this._entries.length);\n  }\n\n  /** Returns an iterator over the keys. */\n  keys(): IterableIterator<K> {\n    return this._entries.map(([k]) => k)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<V> {\n    return this._entries.map(([, v]) => v)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [key, value] pairs. */\n  entries(): IterableIterator<[K, V]> {\n    return this._entries.map(([k, v]) => [k, v] as [K, V])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each entry, matching the native `Map.forEach` signature. */\n  forEach(callback: (value: V, key: K, map: ReactiveMap<K, V>) => void): void {\n    for (const [k, v] of this._entries) {\n      callback(v, k, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over [key, value] pairs. */\n  [Symbol.iterator](): IterableIterator<[K, V]> {\n    return this.entries();\n  }\n}\n\n// ── ReactiveSet ───────────────────────────────────────────────────────────────\n\n/**\n * A Set-like class backed by a plain array so `createClassyStore()` can proxy mutations.\n *\n * Native `Set` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.add()` would be invisible to the store. `ReactiveSet` solves this by\n * storing items in a plain array (`_items`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = createClassyStore({ tags: reactiveSet<string>(['urgent']) });\n * myStore.tags.add('bug'); // reactive\n * ```\n */\nexport class ReactiveSet<T> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _items: T[] = [];\n\n  /** Deduplicates initial values using `Object.is` comparison. */\n  constructor(initial?: Iterable<T>) {\n    if (initial) {\n      for (const v of initial) {\n        if (!this._items.some((item) => Object.is(item, v))) {\n          this._items.push(v);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of unique items. */\n  get size(): number {\n    return this._items.length;\n  }\n\n  /** Returns `true` if `value` exists. O(n) linear scan. */\n  has(value: T): boolean {\n    return this._items.some((item) => Object.is(item, value));\n  }\n\n  /** Adds `value` if not already present (no-op for duplicates). */\n  add(value: T): this {\n    if (!this.has(value)) {\n      this._items.push(value);\n    }\n    return this;\n  }\n\n  /** Removes `value`. Returns `true` if found. */\n  delete(value: T): boolean {\n    const index = this._items.findIndex((item) => Object.is(item, value));\n    if (index === -1) return false;\n    this._items.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all items. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._items.splice(0, this._items.length);\n  }\n\n  /** Returns an iterator over the values (same as `values()`, matching Set API). */\n  keys(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [value, value] pairs, matching the native Set API. */\n  entries(): IterableIterator<[T, T]> {\n    return this._items.map((v) => [v, v] as [T, T])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each item, matching the native `Set.forEach` signature. */\n  forEach(callback: (value: T, key: T, set: ReactiveSet<T>) => void): void {\n    for (const v of this._items) {\n      callback(v, v, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over values. */\n  [Symbol.iterator](): IterableIterator<T> {\n    return this.values();\n  }\n}\n\n// ── Factory functions ─────────────────────────────────────────────────────────\n\n/**\n * Creates a reactive Map-like collection backed by a plain array.\n * Wrap the parent object with `createClassyStore()` for full reactivity.\n *\n * @param initial - Optional iterable of `[key, value]` pairs.\n */\nexport function reactiveMap<K, V>(\n  initial?: Iterable<[K, V]>,\n): ReactiveMap<K, V> {\n  return new ReactiveMap(initial);\n}\n\n/**\n * Creates a reactive Set-like collection backed by a plain array.\n * Wrap the parent object with `createClassyStore()` for full reactivity.\n *\n * @param initial - Optional iterable of values.\n */\nexport function reactiveSet<T>(initial?: Iterable<T>): ReactiveSet<T> {\n  return new ReactiveSet(initial);\n}\n","/**\n * Shallow-equal comparison for objects and arrays.\n * Useful as a custom `isEqual` for `useStore` selectors that return objects/arrays.\n *\n * - Primitives compared with `Object.is`.\n * - Arrays: length + element-wise `Object.is`.\n * - Objects: key count + value-wise `Object.is`.\n */\nexport function shallowEqual<T>(a: T, b: T): boolean {\n  if (Object.is(a, b)) return true;\n  if (\n    typeof a !== 'object' ||\n    a === null ||\n    typeof b !== 'object' ||\n    b === null\n  ) {\n    return false;\n  }\n\n  if (Array.isArray(a) && Array.isArray(b)) {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!Object.is(a[i], b[i])) return false;\n    }\n    return true;\n  }\n\n  const keysA = Object.keys(a);\n  const keysB = Object.keys(b);\n  if (keysA.length !== keysB.length) return false;\n\n  for (const key of keysA) {\n    if (\n      !Object.hasOwn(b, key) ||\n      !Object.is(\n        (a as Record<string, unknown>)[key],\n        (b as Record<string, unknown>)[key],\n      )\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n"],"mappings":"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"}

package/dist/index.d.cts

@@ -10,7 +10,7 @@ declare const PROXYABLE: unique symbol;
 //#endregion
 //#region src/collections/collections.d.ts
 /**
- * A Map-like class backed by a plain array so `store()` can proxy mutations.
+ * A Map-like class backed by a plain array so `createClassyStore()` can proxy mutations.
  *
  * Native `Map` uses internal slots that ES6 Proxy can't intercept, so mutations
  * like `.set()` would be invisible to the store. `ReactiveMap` solves this by
@@ -18,7 +18,7 @@ declare const PROXYABLE: unique symbol;
  *
  * Usage:
  * ```ts
- * const myStore = store({ users: reactiveMap<string, User>() });
+ * const myStore = createClassyStore({ users: reactiveMap<string, User>() });
  * myStore.users.set('id1', { name: 'Alice' }); // reactive
  * ```
  */
@@ -52,7 +52,7 @@ declare class ReactiveMap<K, V> {
   [Symbol.iterator](): IterableIterator<[K, V]>;
 }
 /**
- * A Set-like class backed by a plain array so `store()` can proxy mutations.
+ * A Set-like class backed by a plain array so `createClassyStore()` can proxy mutations.
  *
  * Native `Set` uses internal slots that ES6 Proxy can't intercept, so mutations
  * like `.add()` would be invisible to the store. `ReactiveSet` solves this by
@@ -60,7 +60,7 @@ declare class ReactiveMap<K, V> {
  *
  * Usage:
  * ```ts
- * const myStore = store({ tags: reactiveSet<string>(['urgent']) });
+ * const myStore = createClassyStore({ tags: reactiveSet<string>(['urgent']) });
  * myStore.tags.add('bug'); // reactive
  * ```
  */
@@ -93,14 +93,14 @@ declare class ReactiveSet<T> {
 }
 /**
  * Creates a reactive Map-like collection backed by a plain array.
- * Wrap the parent object with `store()` for full reactivity.
+ * Wrap the parent object with `createClassyStore()` for full reactivity.
  *
  * @param initial - Optional iterable of `[key, value]` pairs.
  */
 declare function reactiveMap<K, V>(initial?: Iterable<[K, V]>): ReactiveMap<K, V>;
 /**
  * Creates a reactive Set-like collection backed by a plain array.
- * Wrap the parent object with `store()` for full reactivity.
+ * Wrap the parent object with `createClassyStore()` for full reactivity.
  *
  * @param initial - Optional iterable of values.
  */
@@ -118,13 +118,18 @@ declare function reactiveSet<T>(initial?: Iterable<T>): ReactiveSet<T>;
  *
  * @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());
+ * ```
  */
-declare function store<T extends object>(instance: T): T;
+declare function createClassyStore<T extends object>(instance: T): T;
 /**
  * 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.
  */
@@ -152,7 +157,7 @@ declare function getVersion(proxy: object): number;
  * 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>).
  */
 declare function snapshot<T extends object>(proxyStore: T): Snapshot<T>;
@@ -168,5 +173,5 @@ declare function snapshot<T extends object>(proxyStore: T): Snapshot<T>;
  */
 declare function shallowEqual<T>(a: T, b: T): boolean;
 //#endregion
-export { type ReactiveMap, type ReactiveSet, type Snapshot, getVersion, reactiveMap, reactiveSet, shallowEqual, snapshot, store, subscribe };
+export { type ReactiveMap, type ReactiveSet, type Snapshot, createClassyStore, getVersion, reactiveMap, reactiveSet, shallowEqual, snapshot, subscribe };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/utils/internal/internal.ts","../src/collections/collections.ts","../src/core/core.ts","../src/snapshot/snapshot.ts","../src/utils/equality/equality.ts"],"mappings":";;;;;;AAOA;;cAAa,SAAA;;;;;AAAb;;;;;;;;ACUA;;;cAAa,WAAA;EAAA,QACH,SAAA;EAGM;EAAd,QAAA,GAAW,CAAA,EAAG,CAAA;EAGqB;cAAvB,OAAA,GAAU,QAAA,EAAU,CAAA,EAAG,CAAA;EAmB1B;EAAA,IALL,IAAA,CAAA;EAWK;EANT,GAAA,CAAI,GAAA,EAAK,CAAA,GAAI,CAAA;EAWM;EALnB,GAAA,CAAI,GAAA,EAAK,CAAA;EA6BgB;EAxBzB,GAAA,CAAI,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA;EA6BQ;EAlB3B,MAAA,CAAO,GAAA,EAAK,CAAA;EAuBiB;EAf7B,KAAA,CAAA;EAeW;EAVX,IAAA,CAAA,GAAQ,gBAAA,CAAiB,CAAA;EAeS;EAVlC,MAAA,CAAA,GAAU,gBAAA,CAAiB,CAAA;EAU8B;EALzD,OAAA,CAAA,GAAW,gBAAA,EAAkB,CAAA,EAAG,CAAA;EAYO;EAPvC,OAAA,CAAQ,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,GAAA,EAAK,CAAA,EAAG,GAAA,EAAK,WAAA,CAAY,CAAA,EAAG,CAAA;EAOpC;EAAA,CAApB,MAAA,CAAO,QAAA,KAAa,gBAAA,EAAkB,CAAA,EAAG,CAAA;AAAA;;;;;;;;;;;;;;cAoB/B,WAAA;EAAA,QACH,SAAA;EA9EJ;EAiFJ,MAAA,EAAQ,CAAA;EA3ER;cA8EY,OAAA,GAAU,QAAA,CAAS,CAAA;EA9E3B;EAAA,IAyFA,IAAA,CAAA;EApFK;EAyFT,GAAA,CAAI,KAAA,EAAO,CAAA;EAzFQ;EA8FnB,GAAA,CAAI,KAAA,EAAO,CAAA;EAnFX;EA2FA,MAAA,CAAO,KAAA,EAAO,CAAA;EA3FP;EAmGP,KAAA,CAAA;EAtFA;EA2FA,IAAA,CAAA,GAAQ,gBAAA,CAAiB,CAAA;EA3FA;EAgGzB,MAAA,CAAA,GAAU,gBAAA,CAAiB,CAAA;EA3FjB;EAgGV,OAAA,CAAA,GAAW,gBAAA,EAAkB,CAAA,EAAG,CAAA;EA3FhC;EAgGA,OAAA,CAAQ,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,GAAA,EAAK,CAAA,EAAG,GAAA,EAAK,WAAA,CAAY,CAAA;EAhGzB;EAAA,CAuG5B,MAAA,CAAO,QAAA,KAAa,gBAAA,CAAiB,CAAA;AAAA;;;;;;;iBAaxB,WAAA,MAAA,CACd,OAAA,GAAU,QAAA,EAAU,CAAA,EAAG,CAAA,KACtB,WAAA,CAAY,CAAA,EAAG,CAAA;;;;;;;iBAUF,WAAA,GAAA,CAAe,OAAA,GAAU,QAAA,CAAS,CAAA,IAAK,WAAA,CAAY,CAAA;;;;AAvMnE;;;;;;;;;;;iBCmRgB,KAAA,kBAAA,CAAwB,QAAA,EAAU,CAAA,GAAI,CAAA;;;;;;;;;iBAYtC,SAAA,CAAU,KAAA,UAAe,QAAA;;;;;;;;iBAkBzB,UAAA,CAAW,KAAA;;;;;AF3T3B;;;;;;;;ACUA;;;;;;iBEwUgB,QAAA,kBAAA,CAA2B,UAAA,EAAY,CAAA,GAAI,QAAA,CAAS,CAAA;;;;;;AHlVpE;;;;;iBICgB,YAAA,GAAA,CAAgB,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/utils/internal/internal.ts","../src/collections/collections.ts","../src/core/core.ts","../src/snapshot/snapshot.ts","../src/utils/equality/equality.ts"],"mappings":";;;;;;AAOA;;cAAa,SAAA;;;;;AAAb;;;;;;;;ACUA;;;cAAa,WAAA;EAAA,QACH,SAAA;EAGM;EAAd,QAAA,GAAW,CAAA,EAAG,CAAA;EAGqB;cAAvB,OAAA,GAAU,QAAA,EAAU,CAAA,EAAG,CAAA;EAmB1B;EAAA,IALL,IAAA,CAAA;EAWK;EANT,GAAA,CAAI,GAAA,EAAK,CAAA,GAAI,CAAA;EAWM;EALnB,GAAA,CAAI,GAAA,EAAK,CAAA;EA6BgB;EAxBzB,GAAA,CAAI,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA;EA6BQ;EAlB3B,MAAA,CAAO,GAAA,EAAK,CAAA;EAuBiB;EAf7B,KAAA,CAAA;EAeW;EAVX,IAAA,CAAA,GAAQ,gBAAA,CAAiB,CAAA;EAeS;EAVlC,MAAA,CAAA,GAAU,gBAAA,CAAiB,CAAA;EAU8B;EALzD,OAAA,CAAA,GAAW,gBAAA,EAAkB,CAAA,EAAG,CAAA;EAYO;EAPvC,OAAA,CAAQ,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,GAAA,EAAK,CAAA,EAAG,GAAA,EAAK,WAAA,CAAY,CAAA,EAAG,CAAA;EAOpC;EAAA,CAApB,MAAA,CAAO,QAAA,KAAa,gBAAA,EAAkB,CAAA,EAAG,CAAA;AAAA;;;;;;;;;;;;;;cAoB/B,WAAA;EAAA,QACH,SAAA;EA9EJ;EAiFJ,MAAA,EAAQ,CAAA;EA3ER;cA8EY,OAAA,GAAU,QAAA,CAAS,CAAA;EA9E3B;EAAA,IAyFA,IAAA,CAAA;EApFK;EAyFT,GAAA,CAAI,KAAA,EAAO,CAAA;EAzFQ;EA8FnB,GAAA,CAAI,KAAA,EAAO,CAAA;EAnFX;EA2FA,MAAA,CAAO,KAAA,EAAO,CAAA;EA3FP;EAmGP,KAAA,CAAA;EAtFA;EA2FA,IAAA,CAAA,GAAQ,gBAAA,CAAiB,CAAA;EA3FA;EAgGzB,MAAA,CAAA,GAAU,gBAAA,CAAiB,CAAA;EA3FjB;EAgGV,OAAA,CAAA,GAAW,gBAAA,EAAkB,CAAA,EAAG,CAAA;EA3FhC;EAgGA,OAAA,CAAQ,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,GAAA,EAAK,CAAA,EAAG,GAAA,EAAK,WAAA,CAAY,CAAA;EAhGzB;EAAA,CAuG5B,MAAA,CAAO,QAAA,KAAa,gBAAA,CAAiB,CAAA;AAAA;;;;;;;iBAaxB,WAAA,MAAA,CACd,OAAA,GAAU,QAAA,EAAU,CAAA,EAAG,CAAA,KACtB,WAAA,CAAY,CAAA,EAAG,CAAA;;;;;;;iBAUF,WAAA,GAAA,CAAe,OAAA,GAAU,QAAA,CAAS,CAAA,IAAK,WAAA,CAAY,CAAA;;;;;;;;AAvMnE;;;;;;;;;;;;iBCiRgB,iBAAA,kBAAA,CAAoC,QAAA,EAAU,CAAA,GAAI,CAAA;;;;;;;;;iBAYlD,SAAA,CAAU,KAAA,UAAe,QAAA;;;;;;;;iBAkBzB,UAAA,CAAW,KAAA;;;;;AFzT3B;;;;;;;;ACUA;;;;;;iBEwUgB,QAAA,kBAAA,CAA2B,UAAA,EAAY,CAAA,GAAI,QAAA,CAAS,CAAA;;;;;;AHlVpE;;;;;iBICgB,YAAA,GAAA,CAAgB,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA"}

package/dist/index.d.mts

@@ -10,7 +10,7 @@ declare const PROXYABLE: unique symbol;
 //#endregion
 //#region src/collections/collections.d.ts
 /**
- * A Map-like class backed by a plain array so `store()` can proxy mutations.
+ * A Map-like class backed by a plain array so `createClassyStore()` can proxy mutations.
  *
  * Native `Map` uses internal slots that ES6 Proxy can't intercept, so mutations
  * like `.set()` would be invisible to the store. `ReactiveMap` solves this by
@@ -18,7 +18,7 @@ declare const PROXYABLE: unique symbol;
  *
  * Usage:
  * ```ts
- * const myStore = store({ users: reactiveMap<string, User>() });
+ * const myStore = createClassyStore({ users: reactiveMap<string, User>() });
  * myStore.users.set('id1', { name: 'Alice' }); // reactive
  * ```
  */
@@ -52,7 +52,7 @@ declare class ReactiveMap<K, V> {
   [Symbol.iterator](): IterableIterator<[K, V]>;
 }
 /**
- * A Set-like class backed by a plain array so `store()` can proxy mutations.
+ * A Set-like class backed by a plain array so `createClassyStore()` can proxy mutations.
  *
  * Native `Set` uses internal slots that ES6 Proxy can't intercept, so mutations
  * like `.add()` would be invisible to the store. `ReactiveSet` solves this by
@@ -60,7 +60,7 @@ declare class ReactiveMap<K, V> {
  *
  * Usage:
  * ```ts
- * const myStore = store({ tags: reactiveSet<string>(['urgent']) });
+ * const myStore = createClassyStore({ tags: reactiveSet<string>(['urgent']) });
  * myStore.tags.add('bug'); // reactive
  * ```
  */
@@ -93,14 +93,14 @@ declare class ReactiveSet<T> {
 }
 /**
  * Creates a reactive Map-like collection backed by a plain array.
- * Wrap the parent object with `store()` for full reactivity.
+ * Wrap the parent object with `createClassyStore()` for full reactivity.
  *
  * @param initial - Optional iterable of `[key, value]` pairs.
  */
 declare function reactiveMap<K, V>(initial?: Iterable<[K, V]>): ReactiveMap<K, V>;
 /**
  * Creates a reactive Set-like collection backed by a plain array.
- * Wrap the parent object with `store()` for full reactivity.
+ * Wrap the parent object with `createClassyStore()` for full reactivity.
  *
  * @param initial - Optional iterable of values.
  */
@@ -118,13 +118,18 @@ declare function reactiveSet<T>(initial?: Iterable<T>): ReactiveSet<T>;
  *
  * @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());
+ * ```
  */
-declare function store<T extends object>(instance: T): T;
+declare function createClassyStore<T extends object>(instance: T): T;
 /**
  * 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.
  */
@@ -152,7 +157,7 @@ declare function getVersion(proxy: object): number;
  * 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>).
  */
 declare function snapshot<T extends object>(proxyStore: T): Snapshot<T>;
@@ -168,5 +173,5 @@ declare function snapshot<T extends object>(proxyStore: T): Snapshot<T>;
  */
 declare function shallowEqual<T>(a: T, b: T): boolean;
 //#endregion
-export { type ReactiveMap, type ReactiveSet, type Snapshot, getVersion, reactiveMap, reactiveSet, shallowEqual, snapshot, store, subscribe };
+export { type ReactiveMap, type ReactiveSet, type Snapshot, createClassyStore, getVersion, reactiveMap, reactiveSet, shallowEqual, snapshot, subscribe };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/utils/internal/internal.ts","../src/collections/collections.ts","../src/core/core.ts","../src/snapshot/snapshot.ts","../src/utils/equality/equality.ts"],"mappings":";;;;;;AAOA;;cAAa,SAAA;;;;;AAAb;;;;;;;;ACUA;;;cAAa,WAAA;EAAA,QACH,SAAA;EAGM;EAAd,QAAA,GAAW,CAAA,EAAG,CAAA;EAGqB;cAAvB,OAAA,GAAU,QAAA,EAAU,CAAA,EAAG,CAAA;EAmB1B;EAAA,IALL,IAAA,CAAA;EAWK;EANT,GAAA,CAAI,GAAA,EAAK,CAAA,GAAI,CAAA;EAWM;EALnB,GAAA,CAAI,GAAA,EAAK,CAAA;EA6BgB;EAxBzB,GAAA,CAAI,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA;EA6BQ;EAlB3B,MAAA,CAAO,GAAA,EAAK,CAAA;EAuBiB;EAf7B,KAAA,CAAA;EAeW;EAVX,IAAA,CAAA,GAAQ,gBAAA,CAAiB,CAAA;EAeS;EAVlC,MAAA,CAAA,GAAU,gBAAA,CAAiB,CAAA;EAU8B;EALzD,OAAA,CAAA,GAAW,gBAAA,EAAkB,CAAA,EAAG,CAAA;EAYO;EAPvC,OAAA,CAAQ,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,GAAA,EAAK,CAAA,EAAG,GAAA,EAAK,WAAA,CAAY,CAAA,EAAG,CAAA;EAOpC;EAAA,CAApB,MAAA,CAAO,QAAA,KAAa,gBAAA,EAAkB,CAAA,EAAG,CAAA;AAAA;;;;;;;;;;;;;;cAoB/B,WAAA;EAAA,QACH,SAAA;EA9EJ;EAiFJ,MAAA,EAAQ,CAAA;EA3ER;cA8EY,OAAA,GAAU,QAAA,CAAS,CAAA;EA9E3B;EAAA,IAyFA,IAAA,CAAA;EApFK;EAyFT,GAAA,CAAI,KAAA,EAAO,CAAA;EAzFQ;EA8FnB,GAAA,CAAI,KAAA,EAAO,CAAA;EAnFX;EA2FA,MAAA,CAAO,KAAA,EAAO,CAAA;EA3FP;EAmGP,KAAA,CAAA;EAtFA;EA2FA,IAAA,CAAA,GAAQ,gBAAA,CAAiB,CAAA;EA3FA;EAgGzB,MAAA,CAAA,GAAU,gBAAA,CAAiB,CAAA;EA3FjB;EAgGV,OAAA,CAAA,GAAW,gBAAA,EAAkB,CAAA,EAAG,CAAA;EA3FhC;EAgGA,OAAA,CAAQ,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,GAAA,EAAK,CAAA,EAAG,GAAA,EAAK,WAAA,CAAY,CAAA;EAhGzB;EAAA,CAuG5B,MAAA,CAAO,QAAA,KAAa,gBAAA,CAAiB,CAAA;AAAA;;;;;;;iBAaxB,WAAA,MAAA,CACd,OAAA,GAAU,QAAA,EAAU,CAAA,EAAG,CAAA,KACtB,WAAA,CAAY,CAAA,EAAG,CAAA;;;;;;;iBAUF,WAAA,GAAA,CAAe,OAAA,GAAU,QAAA,CAAS,CAAA,IAAK,WAAA,CAAY,CAAA;;;;AAvMnE;;;;;;;;;;;iBCmRgB,KAAA,kBAAA,CAAwB,QAAA,EAAU,CAAA,GAAI,CAAA;;;;;;;;;iBAYtC,SAAA,CAAU,KAAA,UAAe,QAAA;;;;;;;;iBAkBzB,UAAA,CAAW,KAAA;;;;;AF3T3B;;;;;;;;ACUA;;;;;;iBEwUgB,QAAA,kBAAA,CAA2B,UAAA,EAAY,CAAA,GAAI,QAAA,CAAS,CAAA;;;;;;AHlVpE;;;;;iBICgB,YAAA,GAAA,CAAgB,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/utils/internal/internal.ts","../src/collections/collections.ts","../src/core/core.ts","../src/snapshot/snapshot.ts","../src/utils/equality/equality.ts"],"mappings":";;;;;;AAOA;;cAAa,SAAA;;;;;AAAb;;;;;;;;ACUA;;;cAAa,WAAA;EAAA,QACH,SAAA;EAGM;EAAd,QAAA,GAAW,CAAA,EAAG,CAAA;EAGqB;cAAvB,OAAA,GAAU,QAAA,EAAU,CAAA,EAAG,CAAA;EAmB1B;EAAA,IALL,IAAA,CAAA;EAWK;EANT,GAAA,CAAI,GAAA,EAAK,CAAA,GAAI,CAAA;EAWM;EALnB,GAAA,CAAI,GAAA,EAAK,CAAA;EA6BgB;EAxBzB,GAAA,CAAI,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA;EA6BQ;EAlB3B,MAAA,CAAO,GAAA,EAAK,CAAA;EAuBiB;EAf7B,KAAA,CAAA;EAeW;EAVX,IAAA,CAAA,GAAQ,gBAAA,CAAiB,CAAA;EAeS;EAVlC,MAAA,CAAA,GAAU,gBAAA,CAAiB,CAAA;EAU8B;EALzD,OAAA,CAAA,GAAW,gBAAA,EAAkB,CAAA,EAAG,CAAA;EAYO;EAPvC,OAAA,CAAQ,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,GAAA,EAAK,CAAA,EAAG,GAAA,EAAK,WAAA,CAAY,CAAA,EAAG,CAAA;EAOpC;EAAA,CAApB,MAAA,CAAO,QAAA,KAAa,gBAAA,EAAkB,CAAA,EAAG,CAAA;AAAA;;;;;;;;;;;;;;cAoB/B,WAAA;EAAA,QACH,SAAA;EA9EJ;EAiFJ,MAAA,EAAQ,CAAA;EA3ER;cA8EY,OAAA,GAAU,QAAA,CAAS,CAAA;EA9E3B;EAAA,IAyFA,IAAA,CAAA;EApFK;EAyFT,GAAA,CAAI,KAAA,EAAO,CAAA;EAzFQ;EA8FnB,GAAA,CAAI,KAAA,EAAO,CAAA;EAnFX;EA2FA,MAAA,CAAO,KAAA,EAAO,CAAA;EA3FP;EAmGP,KAAA,CAAA;EAtFA;EA2FA,IAAA,CAAA,GAAQ,gBAAA,CAAiB,CAAA;EA3FA;EAgGzB,MAAA,CAAA,GAAU,gBAAA,CAAiB,CAAA;EA3FjB;EAgGV,OAAA,CAAA,GAAW,gBAAA,EAAkB,CAAA,EAAG,CAAA;EA3FhC;EAgGA,OAAA,CAAQ,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,GAAA,EAAK,CAAA,EAAG,GAAA,EAAK,WAAA,CAAY,CAAA;EAhGzB;EAAA,CAuG5B,MAAA,CAAO,QAAA,KAAa,gBAAA,CAAiB,CAAA;AAAA;;;;;;;iBAaxB,WAAA,MAAA,CACd,OAAA,GAAU,QAAA,EAAU,CAAA,EAAG,CAAA,KACtB,WAAA,CAAY,CAAA,EAAG,CAAA;;;;;;;iBAUF,WAAA,GAAA,CAAe,OAAA,GAAU,QAAA,CAAS,CAAA,IAAK,WAAA,CAAY,CAAA;;;;;;;;AAvMnE;;;;;;;;;;;;iBCiRgB,iBAAA,kBAAA,CAAoC,QAAA,EAAU,CAAA,GAAI,CAAA;;;;;;;;;iBAYlD,SAAA,CAAU,KAAA,UAAe,QAAA;;;;;;;;iBAkBzB,UAAA,CAAW,KAAA;;;;;AFzT3B;;;;;;;;ACUA;;;;;;iBEwUgB,QAAA,kBAAA,CAA2B,UAAA,EAAY,CAAA,GAAI,QAAA,CAAS,CAAA;;;;;;AHlVpE;;;;;iBICgB,YAAA,GAAA,CAAgB,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA"}

package/dist/index.mjs

@@ -1,8 +1,8 @@
-import { a as subscribe, i as store, o as PROXYABLE, r as getVersion, t as snapshot } from "./snapshot-C8JDLu8L.mjs";
+import { a as subscribe, i as getVersion, n as createClassyStore, o as PROXYABLE, t as snapshot } from "./snapshot-P0QPV1ER.mjs";
 
 //#region src/collections/collections.ts
 /**
-* A Map-like class backed by a plain array so `store()` can proxy mutations.
+* A Map-like class backed by a plain array so `createClassyStore()` can proxy mutations.
 *
 * Native `Map` uses internal slots that ES6 Proxy can't intercept, so mutations
 * like `.set()` would be invisible to the store. `ReactiveMap` solves this by
@@ -10,7 +10,7 @@ import { a as subscribe, i as store, o as PROXYABLE, r as getVersion, t as snaps
 *
 * Usage:
 * ```ts
-* const myStore = store({ users: reactiveMap<string, User>() });
+* const myStore = createClassyStore({ users: reactiveMap<string, User>() });
 * myStore.users.set('id1', { name: 'Alice' }); // reactive
 * ```
 */
@@ -79,7 +79,7 @@ var ReactiveMap = class {
 	}
 };
 /**
-* A Set-like class backed by a plain array so `store()` can proxy mutations.
+* A Set-like class backed by a plain array so `createClassyStore()` can proxy mutations.
 *
 * Native `Set` uses internal slots that ES6 Proxy can't intercept, so mutations
 * like `.add()` would be invisible to the store. `ReactiveSet` solves this by
@@ -87,7 +87,7 @@ var ReactiveMap = class {
 *
 * Usage:
 * ```ts
-* const myStore = store({ tags: reactiveSet<string>(['urgent']) });
+* const myStore = createClassyStore({ tags: reactiveSet<string>(['urgent']) });
 * myStore.tags.add('bug'); // reactive
 * ```
 */
@@ -148,7 +148,7 @@ var ReactiveSet = class {
 };
 /**
 * Creates a reactive Map-like collection backed by a plain array.
-* Wrap the parent object with `store()` for full reactivity.
+* Wrap the parent object with `createClassyStore()` for full reactivity.
 *
 * @param initial - Optional iterable of `[key, value]` pairs.
 */
@@ -157,7 +157,7 @@ function reactiveMap(initial) {
 }
 /**
 * Creates a reactive Set-like collection backed by a plain array.
-* Wrap the parent object with `store()` for full reactivity.
+* Wrap the parent object with `createClassyStore()` for full reactivity.
 *
 * @param initial - Optional iterable of values.
 */
@@ -191,5 +191,5 @@ function shallowEqual(a, b) {
 }
 
 //#endregion
-export { getVersion, reactiveMap, reactiveSet, shallowEqual, snapshot, store, subscribe };
+export { createClassyStore, getVersion, reactiveMap, reactiveSet, shallowEqual, snapshot, subscribe };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/collections/collections.ts","../src/utils/equality/equality.ts"],"sourcesContent":["import {PROXYABLE} from '../utils/internal/internal';\n\n// ── ReactiveMap ───────────────────────────────────────────────────────────────\n\n/**\n * A Map-like class backed by a plain array so `store()` can proxy mutations.\n *\n * Native `Map` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.set()` would be invisible to the store. `ReactiveMap` solves this by\n * storing entries in a plain array (`_entries`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = store({ users: reactiveMap<string, User>() });\n * myStore.users.set('id1', { name: 'Alice' }); // reactive\n * ```\n */\nexport class ReactiveMap<K, V> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _entries: [K, V][] = [];\n\n  /** Deduplicates initial entries by key (last value wins, matching native `Map`). */\n  constructor(initial?: Iterable<[K, V]>) {\n    if (initial) {\n      for (const [k, v] of initial) {\n        const index = this._entries.findIndex(([ek]) => Object.is(ek, k));\n        if (index !== -1) {\n          this._entries[index] = [k, v];\n        } else {\n          this._entries.push([k, v]);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of entries. */\n  get size(): number {\n    return this._entries.length;\n  }\n\n  /** Returns the value for `key`, or `undefined`. O(n) linear scan. */\n  get(key: K): V | undefined {\n    const entry = this._entries.find(([k]) => Object.is(k, key));\n    return entry ? entry[1] : undefined;\n  }\n\n  /** Returns `true` if `key` exists. O(n) linear scan. */\n  has(key: K): boolean {\n    return this._entries.some(([k]) => Object.is(k, key));\n  }\n\n  /** Sets `key` to `value`. Updates in-place if key exists, appends otherwise. */\n  set(key: K, value: V): this {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index !== -1) {\n      this._entries[index] = [key, value];\n    } else {\n      this._entries.push([key, value]);\n    }\n    return this;\n  }\n\n  /** Removes the entry for `key`. Returns `true` if found. */\n  delete(key: K): boolean {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index === -1) return false;\n    this._entries.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all entries. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._entries.splice(0, this._entries.length);\n  }\n\n  /** Returns an iterator over the keys. */\n  keys(): IterableIterator<K> {\n    return this._entries.map(([k]) => k)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<V> {\n    return this._entries.map(([, v]) => v)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [key, value] pairs. */\n  entries(): IterableIterator<[K, V]> {\n    return this._entries.map(([k, v]) => [k, v] as [K, V])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each entry, matching the native `Map.forEach` signature. */\n  forEach(callback: (value: V, key: K, map: ReactiveMap<K, V>) => void): void {\n    for (const [k, v] of this._entries) {\n      callback(v, k, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over [key, value] pairs. */\n  [Symbol.iterator](): IterableIterator<[K, V]> {\n    return this.entries();\n  }\n}\n\n// ── ReactiveSet ───────────────────────────────────────────────────────────────\n\n/**\n * A Set-like class backed by a plain array so `store()` can proxy mutations.\n *\n * Native `Set` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.add()` would be invisible to the store. `ReactiveSet` solves this by\n * storing items in a plain array (`_items`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = store({ tags: reactiveSet<string>(['urgent']) });\n * myStore.tags.add('bug'); // reactive\n * ```\n */\nexport class ReactiveSet<T> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _items: T[] = [];\n\n  /** Deduplicates initial values using `Object.is` comparison. */\n  constructor(initial?: Iterable<T>) {\n    if (initial) {\n      for (const v of initial) {\n        if (!this._items.some((item) => Object.is(item, v))) {\n          this._items.push(v);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of unique items. */\n  get size(): number {\n    return this._items.length;\n  }\n\n  /** Returns `true` if `value` exists. O(n) linear scan. */\n  has(value: T): boolean {\n    return this._items.some((item) => Object.is(item, value));\n  }\n\n  /** Adds `value` if not already present (no-op for duplicates). */\n  add(value: T): this {\n    if (!this.has(value)) {\n      this._items.push(value);\n    }\n    return this;\n  }\n\n  /** Removes `value`. Returns `true` if found. */\n  delete(value: T): boolean {\n    const index = this._items.findIndex((item) => Object.is(item, value));\n    if (index === -1) return false;\n    this._items.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all items. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._items.splice(0, this._items.length);\n  }\n\n  /** Returns an iterator over the values (same as `values()`, matching Set API). */\n  keys(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [value, value] pairs, matching the native Set API. */\n  entries(): IterableIterator<[T, T]> {\n    return this._items.map((v) => [v, v] as [T, T])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each item, matching the native `Set.forEach` signature. */\n  forEach(callback: (value: T, key: T, set: ReactiveSet<T>) => void): void {\n    for (const v of this._items) {\n      callback(v, v, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over values. */\n  [Symbol.iterator](): IterableIterator<T> {\n    return this.values();\n  }\n}\n\n// ── Factory functions ─────────────────────────────────────────────────────────\n\n/**\n * Creates a reactive Map-like collection backed by a plain array.\n * Wrap the parent object with `store()` for full reactivity.\n *\n * @param initial - Optional iterable of `[key, value]` pairs.\n */\nexport function reactiveMap<K, V>(\n  initial?: Iterable<[K, V]>,\n): ReactiveMap<K, V> {\n  return new ReactiveMap(initial);\n}\n\n/**\n * Creates a reactive Set-like collection backed by a plain array.\n * Wrap the parent object with `store()` for full reactivity.\n *\n * @param initial - Optional iterable of values.\n */\nexport function reactiveSet<T>(initial?: Iterable<T>): ReactiveSet<T> {\n  return new ReactiveSet(initial);\n}\n","/**\n * Shallow-equal comparison for objects and arrays.\n * Useful as a custom `isEqual` for `useStore` selectors that return objects/arrays.\n *\n * - Primitives compared with `Object.is`.\n * - Arrays: length + element-wise `Object.is`.\n * - Objects: key count + value-wise `Object.is`.\n */\nexport function shallowEqual<T>(a: T, b: T): boolean {\n  if (Object.is(a, b)) return true;\n  if (\n    typeof a !== 'object' ||\n    a === null ||\n    typeof b !== 'object' ||\n    b === null\n  ) {\n    return false;\n  }\n\n  if (Array.isArray(a) && Array.isArray(b)) {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!Object.is(a[i], b[i])) return false;\n    }\n    return true;\n  }\n\n  const keysA = Object.keys(a);\n  const keysB = Object.keys(b);\n  if (keysA.length !== keysB.length) return false;\n\n  for (const key of keysA) {\n    if (\n      !Object.hasOwn(b, key) ||\n      !Object.is(\n        (a as Record<string, unknown>)[key],\n        (b as Record<string, unknown>)[key],\n      )\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/collections/collections.ts","../src/utils/equality/equality.ts"],"sourcesContent":["import {PROXYABLE} from '../utils/internal/internal';\n\n// ── ReactiveMap ───────────────────────────────────────────────────────────────\n\n/**\n * A Map-like class backed by a plain array so `createClassyStore()` can proxy mutations.\n *\n * Native `Map` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.set()` would be invisible to the store. `ReactiveMap` solves this by\n * storing entries in a plain array (`_entries`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = createClassyStore({ users: reactiveMap<string, User>() });\n * myStore.users.set('id1', { name: 'Alice' }); // reactive\n * ```\n */\nexport class ReactiveMap<K, V> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _entries: [K, V][] = [];\n\n  /** Deduplicates initial entries by key (last value wins, matching native `Map`). */\n  constructor(initial?: Iterable<[K, V]>) {\n    if (initial) {\n      for (const [k, v] of initial) {\n        const index = this._entries.findIndex(([ek]) => Object.is(ek, k));\n        if (index !== -1) {\n          this._entries[index] = [k, v];\n        } else {\n          this._entries.push([k, v]);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of entries. */\n  get size(): number {\n    return this._entries.length;\n  }\n\n  /** Returns the value for `key`, or `undefined`. O(n) linear scan. */\n  get(key: K): V | undefined {\n    const entry = this._entries.find(([k]) => Object.is(k, key));\n    return entry ? entry[1] : undefined;\n  }\n\n  /** Returns `true` if `key` exists. O(n) linear scan. */\n  has(key: K): boolean {\n    return this._entries.some(([k]) => Object.is(k, key));\n  }\n\n  /** Sets `key` to `value`. Updates in-place if key exists, appends otherwise. */\n  set(key: K, value: V): this {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index !== -1) {\n      this._entries[index] = [key, value];\n    } else {\n      this._entries.push([key, value]);\n    }\n    return this;\n  }\n\n  /** Removes the entry for `key`. Returns `true` if found. */\n  delete(key: K): boolean {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index === -1) return false;\n    this._entries.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all entries. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._entries.splice(0, this._entries.length);\n  }\n\n  /** Returns an iterator over the keys. */\n  keys(): IterableIterator<K> {\n    return this._entries.map(([k]) => k)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<V> {\n    return this._entries.map(([, v]) => v)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [key, value] pairs. */\n  entries(): IterableIterator<[K, V]> {\n    return this._entries.map(([k, v]) => [k, v] as [K, V])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each entry, matching the native `Map.forEach` signature. */\n  forEach(callback: (value: V, key: K, map: ReactiveMap<K, V>) => void): void {\n    for (const [k, v] of this._entries) {\n      callback(v, k, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over [key, value] pairs. */\n  [Symbol.iterator](): IterableIterator<[K, V]> {\n    return this.entries();\n  }\n}\n\n// ── ReactiveSet ───────────────────────────────────────────────────────────────\n\n/**\n * A Set-like class backed by a plain array so `createClassyStore()` can proxy mutations.\n *\n * Native `Set` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.add()` would be invisible to the store. `ReactiveSet` solves this by\n * storing items in a plain array (`_items`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = createClassyStore({ tags: reactiveSet<string>(['urgent']) });\n * myStore.tags.add('bug'); // reactive\n * ```\n */\nexport class ReactiveSet<T> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _items: T[] = [];\n\n  /** Deduplicates initial values using `Object.is` comparison. */\n  constructor(initial?: Iterable<T>) {\n    if (initial) {\n      for (const v of initial) {\n        if (!this._items.some((item) => Object.is(item, v))) {\n          this._items.push(v);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of unique items. */\n  get size(): number {\n    return this._items.length;\n  }\n\n  /** Returns `true` if `value` exists. O(n) linear scan. */\n  has(value: T): boolean {\n    return this._items.some((item) => Object.is(item, value));\n  }\n\n  /** Adds `value` if not already present (no-op for duplicates). */\n  add(value: T): this {\n    if (!this.has(value)) {\n      this._items.push(value);\n    }\n    return this;\n  }\n\n  /** Removes `value`. Returns `true` if found. */\n  delete(value: T): boolean {\n    const index = this._items.findIndex((item) => Object.is(item, value));\n    if (index === -1) return false;\n    this._items.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all items. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._items.splice(0, this._items.length);\n  }\n\n  /** Returns an iterator over the values (same as `values()`, matching Set API). */\n  keys(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [value, value] pairs, matching the native Set API. */\n  entries(): IterableIterator<[T, T]> {\n    return this._items.map((v) => [v, v] as [T, T])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each item, matching the native `Set.forEach` signature. */\n  forEach(callback: (value: T, key: T, set: ReactiveSet<T>) => void): void {\n    for (const v of this._items) {\n      callback(v, v, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over values. */\n  [Symbol.iterator](): IterableIterator<T> {\n    return this.values();\n  }\n}\n\n// ── Factory functions ─────────────────────────────────────────────────────────\n\n/**\n * Creates a reactive Map-like collection backed by a plain array.\n * Wrap the parent object with `createClassyStore()` for full reactivity.\n *\n * @param initial - Optional iterable of `[key, value]` pairs.\n */\nexport function reactiveMap<K, V>(\n  initial?: Iterable<[K, V]>,\n): ReactiveMap<K, V> {\n  return new ReactiveMap(initial);\n}\n\n/**\n * Creates a reactive Set-like collection backed by a plain array.\n * Wrap the parent object with `createClassyStore()` for full reactivity.\n *\n * @param initial - Optional iterable of values.\n */\nexport function reactiveSet<T>(initial?: Iterable<T>): ReactiveSet<T> {\n  return new ReactiveSet(initial);\n}\n","/**\n * Shallow-equal comparison for objects and arrays.\n * Useful as a custom `isEqual` for `useStore` selectors that return objects/arrays.\n *\n * - Primitives compared with `Object.is`.\n * - Arrays: length + element-wise `Object.is`.\n * - Objects: key count + value-wise `Object.is`.\n */\nexport function shallowEqual<T>(a: T, b: T): boolean {\n  if (Object.is(a, b)) return true;\n  if (\n    typeof a !== 'object' ||\n    a === null ||\n    typeof b !== 'object' ||\n    b === null\n  ) {\n    return false;\n  }\n\n  if (Array.isArray(a) && Array.isArray(b)) {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!Object.is(a[i], b[i])) return false;\n    }\n    return true;\n  }\n\n  const keysA = Object.keys(a);\n  const keysB = Object.keys(b);\n  if (keysA.length !== keysB.length) return false;\n\n  for (const key of keysA) {\n    if (\n      !Object.hasOwn(b, key) ||\n      !Object.is(\n        (a as Record<string, unknown>)[key],\n        (b as Record<string, unknown>)[key],\n      )\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n"],"mappings":"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"}

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-BKVFJLuo.cjs');
 let proxy_compare = require("proxy-compare");
 let react = require("react");
 

package/dist/react/react.mjs

@@ -1,4 +1,4 @@
-import { a as subscribe, n as getInternal, t as snapshot } from "../snapshot-C8JDLu8L.mjs";
+import { a as subscribe, r as getInternal, t as snapshot } from "../snapshot-P0QPV1ER.mjs";
 import { createProxy, isChanged } from "proxy-compare";
 import { useCallback, useRef, useSyncExternalStore } from "react";
 

package/dist/{snapshot-CR8nA2Ob.cjs → snapshot-BKVFJLuo.cjs}

@@ -126,7 +126,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);
@@ -248,15 +248,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.
 */
@@ -284,7 +289,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.
@@ -303,7 +308,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.
 *
@@ -337,7 +342,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;
@@ -356,16 +361,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,
@@ -479,7 +484,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)) {
@@ -496,7 +501,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;
 }
 /**
@@ -512,7 +517,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) {
@@ -527,6 +532,12 @@ Object.defineProperty(exports, 'PROXYABLE', {
     return PROXYABLE;
   }
 });
+Object.defineProperty(exports, 'createClassyStore', {
+  enumerable: true,
+  get: function () {
+    return createClassyStore;
+  }
+});
 Object.defineProperty(exports, 'findGetterDescriptor', {
   enumerable: true,
   get: function () {
@@ -551,16 +562,10 @@ Object.defineProperty(exports, 'snapshot', {
     return snapshot;
   }
 });
-Object.defineProperty(exports, 'store', {
-  enumerable: true,
-  get: function () {
-    return store;
-  }
-});
 Object.defineProperty(exports, 'subscribe', {
   enumerable: true,
   get: function () {
     return subscribe;
   }
 });
-//# sourceMappingURL=snapshot-CR8nA2Ob.cjs.map
+//# sourceMappingURL=snapshot-BKVFJLuo.cjs.map