memorio 4.9.8 → 4.9.30

package/index.js

@@ -642,24 +642,29 @@ var init_store = __esm({
             }, "value")
           },
           /**
-           * Calculates total size of all memorio items (characters).
+           * Calculates total size of all memorio items in kilobytes.
+           * Counts each prefixed key and its JSON-serialized value, summing their
+           * byte lengths and converting to whole kilobytes (Math.ceil). Replaces
+           * the previous character-only total which did not express real usage.
+           * @returns Total size in kilobytes (0 when empty / no memorio items).
            */
           size: {
             value: /* @__PURE__ */ __name(() => {
-              let totalSize = 0;
+              let totalBytes = 0;
               if (_hasStorage) {
-                Object.keys(_localStorage).forEach((key) => {
-                  if (key.startsWith(_getPrefix())) {
+                for (let i = 0; i < _localStorage.length; i++) {
+                  const key = _localStorage.key(i);
+                  if (key && key.startsWith(_getPrefix())) {
                     const item = _localStorage.getItem(key);
-                    if (item) totalSize += item.length;
+                    if (item) totalBytes += key.length + item.length;
                   }
-                });
+                }
               } else {
-                _getFallbackStorage().forEach((value) => {
-                  totalSize += value.length;
+                _getFallbackStorage().forEach((value, key) => {
+                  totalBytes += key.length + value.length;
                 });
               }
-              return totalSize;
+              return totalBytes === 0 ? 0 : Math.ceil(totalBytes / 1024);
             }, "value")
           },
           /**
@@ -1730,30 +1735,51 @@ var dispatch = {
   }, "set"),
   ///
   /**
-   * Listens for the specified event names and executes the callback when the event is triggered.
+   * Subscribes a callback to an event name. Maintains a *list* of handlers per
+   * name, so multiple subscribers on the same path (e.g. several
+   * `useObserver` calls observing `state.report`) each keep firing and each
+   * get an independent unsubscribe. The previous single-slot-per-name
+   * behaviour silently dropped the second subscriber and let any unsubscribe
+   * cancel every other subscriber on that path.
    * @param name The name of the event to listen for.
    * @param cb The callback function to execute when the event is triggered.
+   * @returns An unsubscribe function for this subscriber, or void if no callback.
    */
   listen: /* @__PURE__ */ __name((name, cb = null, _flag) => {
-    if (globalThis.events?.[name]) return;
-    const exec = cb ? (e) => {
+    if (!cb) return;
+    const wrapped = /* @__PURE__ */ __name((e) => {
       const target = e;
-      return globalThis.queueMicrotask ? globalThis.queueMicrotask(() => cb(target)) : Promise.resolve().then(() => cb(target));
-    } : void 0;
-    if (exec) globalThis.addEventListener(name, exec);
-    if (exec) globalThis.events[name] = exec;
+      if (globalThis.queueMicrotask) {
+        globalThis.queueMicrotask(() => cb(target));
+      } else {
+        Promise.resolve().then(() => cb(target));
+      }
+    }, "wrapped");
+    globalThis.addEventListener(name, wrapped);
+    const list = globalThis.events[name] = globalThis.events[name] ?? [];
+    list.push(wrapped);
+    return () => {
+      globalThis.removeEventListener(name, wrapped);
+      const idx = list.indexOf(wrapped);
+      if (idx > -1) list.splice(idx, 1);
+      if (!list.length) delete globalThis.events[name];
+    };
   }, "listen"),
   ///
   /**
-   * Removes the event listener for the specified event names.
-   * @param name The name of the event to remove the listener for.
+   * Removes ALL handlers for the specified event name (imperative bulk
+   * removal). For per-subscriber teardown, use the unsubscribe function
+   * returned by `listen`.
+   * @param name The name of the event to remove the listeners for.
    */
   remove: /* @__PURE__ */ __name((name) => {
-    const listener = globalThis.events?.[name];
-    if (listener) {
-      globalThis.removeEventListener(name, listener);
-      delete globalThis.events[name];
+    const entry = globalThis.events?.[name];
+    if (Array.isArray(entry)) {
+      entry.forEach((h) => globalThis.removeEventListener(name, h));
+    } else if (typeof entry === "function") {
+      globalThis.removeEventListener(name, entry);
     }
+    delete globalThis.events[name];
   }, "remove")
 };
 
@@ -1817,6 +1843,14 @@ var _validateValue = /* @__PURE__ */ __name((value, schema2, path2) => {
       }
     }
   }
+  if (schema2.type === "array" && Array.isArray(value) && schema2.items) {
+    for (let i = 0; i < value.length; i++) {
+      const itemResult = _validateValue(value[i], schema2.items, `${path2}[${i}]`);
+      if (!itemResult.valid) {
+        errors.push(...itemResult.errors || []);
+      }
+    }
+  }
   return errors.length === 0 ? { valid: true } : { valid: false, errors };
 }, "_validateValue");
 var validate = /* @__PURE__ */ __name((path2, value) => {
@@ -1877,7 +1911,8 @@ var buildProxy = /* @__PURE__ */ __name((obj, callback, tree = []) => {
   const event = /* @__PURE__ */ __name((name) => {
     try {
       dispatch.set(name, { detail: { name } });
-    } catch (_) {
+    } catch (err) {
+      if (DEV) console.warn("[memorio state] event dispatch failed:", err);
     }
     return;
   }, "event");
@@ -1896,7 +1931,7 @@ var buildProxy = /* @__PURE__ */ __name((obj, callback, tree = []) => {
         }
         if (prop === "list") {
           message_default('Some state could be hidden when you use "state.list". Use "state" to see the complete list ');
-          return JSON.parse(JSON.stringify(target));
+          return deepRaw(target, /* @__PURE__ */ new WeakSet());
         }
         if (typeof prop === "string") {
           const path2 = tree.length > 0 ? "state." + tree.concat(prop).join(".") : "state." + prop;
@@ -2032,7 +2067,8 @@ var buildProxy = /* @__PURE__ */ __name((obj, callback, tree = []) => {
                     message_default(`State '${key}' is now unlocked.`);
                   }, "value")
                 });
-              } catch (_) {
+              } catch (err) {
+                if (DEV) console.warn("[memorio state] lock/unlock defineProperty failed:", err);
               }
             }
           }
@@ -2272,27 +2308,28 @@ if (globalThis[SESSION_INSTANCE_KEY]) {
         }, "value")
       },
       /**
-       * Gets total size of all sessionStorage items.
-       * @returns Total size in characters.
+       * Calculates total size of all memorio session items in kilobytes.
+       * Counts each prefixed key and its JSON-serialized value, summing their
+       * byte lengths and converting to whole kilobytes (Math.ceil).
+       * @returns Total size in kilobytes (0 when empty / no memorio items).
        */
       size: {
         value: /* @__PURE__ */ __name(() => {
-          let totalSize = 0;
+          let totalBytes = 0;
           if (_hasStorage2) {
-            Object.keys(_sessionStorage).forEach(
-              (key) => {
-                if (key.startsWith(_getPrefix2())) {
-                  const item = _sessionStorage.getItem(key);
-                  if (item) totalSize += item.length;
-                }
+            for (let i = 0; i < _sessionStorage.length; i++) {
+              const key = _sessionStorage.key(i);
+              if (key && key.startsWith(_getPrefix2())) {
+                const item = _sessionStorage.getItem(key);
+                if (item) totalBytes += key.length + item.length;
               }
-            );
+            }
           } else {
-            _getFallbackStorage2().forEach((value) => {
-              totalSize += value.length;
+            _getFallbackStorage2().forEach((value, key) => {
+              totalBytes += key.length + value.length;
             });
           }
-          return totalSize;
+          return totalBytes === 0 ? 0 : Math.ceil(totalBytes / 1024);
         }, "value")
       },
       /**
@@ -2511,6 +2548,7 @@ var useObserver = /* @__PURE__ */ __name(((func, deps = []) => {
     };
   }
   const handlers = [];
+  const unsubs = [];
   const depList = Array.isArray(deps) && !deps.__path ? deps : [deps];
   try {
     depList.forEach((dep) => {
@@ -2524,8 +2562,11 @@ var useObserver = /* @__PURE__ */ __name(((func, deps = []) => {
       if (t) {
         t = t.replace(/^(\(\)\s*=>\s*)/, "").replace(/^globalThis\./, "").replace(/^state\./, "");
         const path2 = t.startsWith("store.") || t.startsWith("state.") ? t : "state." + t;
-        dispatch.listen(path2, () => func());
-        handlers.push(path2);
+        if (!handlers.includes(path2)) {
+          handlers.push(path2);
+          const off = dispatch.listen(path2, () => func());
+          if (typeof off === "function") unsubs.push({ path: path2, off });
+        }
       } else {
         internal_default.clearTrackedPaths();
         internal_default.tracking = true;
@@ -2537,8 +2578,9 @@ var useObserver = /* @__PURE__ */ __name(((func, deps = []) => {
         internal_default.trackedPaths.forEach((path2) => {
           if (!handlers.includes(path2)) {
             message_default(`useObserver: [Auto-Discovery] -> "${path2}"`);
-            dispatch.listen(path2, () => func());
             handlers.push(path2);
+            const off = dispatch.listen(path2, () => func());
+            if (typeof off === "function") unsubs.push({ path: path2, off });
           }
         });
       }
@@ -2549,11 +2591,9 @@ var useObserver = /* @__PURE__ */ __name(((func, deps = []) => {
       console.warn(`useObserver: No paths resolved for monitoring. Check your dependencies!`);
     }
     return () => {
-      handlers.forEach((path2) => {
-        if (typeof dispatch.remove === "function") {
-          dispatch.remove(path2);
-          message_default(`useObserver: Stopped monitoring "${path2}"`);
-        }
+      unsubs.forEach(({ path: path2, off }) => {
+        off();
+        message_default(`useObserver: Stopped monitoring "${path2}"`);
       });
     };
   } catch (err) {
@@ -3260,7 +3300,7 @@ init_internal();
 
 // package.json
 var package_default = {
-  version: "4.9.8"};
+  version: "4.9.30"};
 
 // core/global.ts
 init_env();
@@ -3279,20 +3319,20 @@ __name(typed, "typed");
 // functions/history/index.ts
 init_esm_shims();
 init_internal();
+init_env();
 init_message();
 function _clone(value) {
   if (value === null || typeof value !== "object") return value;
-  const ctor = value.constructor?.name;
-  if (ctor !== "Object" && ctor !== "Array") return value;
   try {
-    return JSON.parse(JSON.stringify(value));
-  } catch {
+    return deepRaw(value, /* @__PURE__ */ new WeakSet());
+  } catch (err) {
+    if (DEV) console.warn("[memorio history] deep clone failed:", err);
     return value;
   }
 }
 __name(_clone, "_clone");
 var snapshot = /* @__PURE__ */ __name(() => {
-  return _clone(deepRaw(state2));
+  return deepRaw(state2, /* @__PURE__ */ new WeakSet());
 }, "snapshot");
 var diff = /* @__PURE__ */ __name((snap) => {
   const changes = [];
@@ -3442,9 +3482,11 @@ var clearRedo = /* @__PURE__ */ __name(() => {
 init_esm_shims();
 init_store();
 init_idb();
+init_env();
 
 // functions/memory/journal.ts
 init_esm_shims();
+init_env();
 init_store();
 var g2 = globalThis;
 function namespace() {
@@ -3465,7 +3507,8 @@ function parseEntry(raw) {
   try {
     if (typeof raw === "string") return JSON.parse(raw);
     return raw;
-  } catch {
+  } catch (err) {
+    if (DEV) console.warn("[memorio memory] failed to parse journal entry:", err);
     return null;
   }
 }
@@ -3549,10 +3592,12 @@ var journal = {
    * local operations, then optionally pulls newer remote operations and applies
    * them. No-op (empty ack) when no provider is configured.
    *
-   * When pulling remote entries, HLC timestamps are used to order operations
-   * causally. Concurrent writes to the same key are resolved via the provider's
-   * `resolveConflict` method (if provided), falling back to HLC timestamp
-   * comparison.
+    * When pulling remote entries, HLC timestamps are used to order operations
+    * causally. Concurrent writes to the same key (HLC tie) are resolved via the
+    * provider's `resolveConflict` method (if provided), otherwise the REMOTE
+    * entry wins by default (logged at warn level in dev). Provide a resolver on
+    * the sync provider to override this behaviour and prevent silent local data
+    * loss.
    */
   async replay() {
     const ack = { synced: [], resolved: [] };
@@ -3588,7 +3633,11 @@ var journal = {
             if (ha && hb) {
               const cmp = hlc.compare(ha, hb);
               if (cmp === 0) {
-                const resolution = typeof provider.resolveConflict === "function" ? await provider.resolveConflict(localEntry, e) : "remote";
+                const hasResolver = typeof provider.resolveConflict === "function";
+                const resolution = hasResolver ? await provider.resolveConflict(localEntry, e) : "remote";
+                if (!hasResolver && DEV) {
+                  console.warn(`[memorio memory] replay() conflict for "${e.id}": no resolveConflict handler provided, defaulting to remote-wins`);
+                }
                 ack.resolved?.push({ id: e.id, resolution });
                 if (resolution === "local") continue;
               } else if (cmp > 0) {
@@ -3599,7 +3648,8 @@ var journal = {
           await this.append(e, e.operation || "confirm");
           await this.markSynced([e.id]);
         }
-      } catch (_) {
+      } catch (err) {
+        if (DEV) console.warn("[memorio memory] sync pull failed:", err);
       }
     }
     return ack;
@@ -3638,7 +3688,8 @@ async function recordJournal(entry, operation) {
   if (entry.scope === "hot") return;
   try {
     await journal_default.append(entry, operation);
-  } catch (_) {
+  } catch (err) {
+    if (DEV) console.warn("[memorio memory] journal append failed:", err);
   }
 }
 __name(recordJournal, "recordJournal");
@@ -3801,7 +3852,8 @@ async function loadFromScope(id, scope, isSuperseded = false) {
     const entry = JSON.parse(raw);
     entry.id = entry.id || id;
     return entry;
-  } catch {
+  } catch (err) {
+    if (DEV) console.warn("[memorio memory] failed to parse memory entry:", err);
     return null;
   }
 }
@@ -3847,7 +3899,8 @@ async function getAllIndexes() {
     const raw = store.get(MEMORY_INDEX_KEY);
     if (!raw) return {};
     return JSON.parse(raw);
-  } catch {
+  } catch (err) {
+    if (DEV) console.warn("[memorio memory] failed to parse memory index:", err);
     return {};
   }
 }
@@ -4118,6 +4171,7 @@ var memory = {
 
 // functions/inspect/index.ts
 init_esm_shims();
+init_env();
 var stateKeys = /* @__PURE__ */ __name(() => {
   const raw = deepRaw(state2);
   return Object.keys(raw).filter(
@@ -4184,11 +4238,10 @@ function _getValue(path2) {
 __name(_getValue, "_getValue");
 function _clone2(value) {
   if (value === null || typeof value !== "object") return value;
-  const ctor = value.constructor?.name;
-  if (ctor !== "Object" && ctor !== "Array") return value;
   try {
-    return JSON.parse(JSON.stringify(value));
-  } catch {
+    return deepRaw(value, /* @__PURE__ */ new WeakSet());
+  } catch (err) {
+    if (DEV) console.warn("[memorio inspect] deep clone failed:", err);
     return value;
   }
 }
@@ -4215,15 +4268,18 @@ if (!("memorio" in globalThis)) {
       enumerable: false
     }
   );
-  Object.defineProperty(
-    globalThis,
-    "events",
-    {
-      value: {},
-      writable: true,
-      enumerable: false
-    }
-  );
+  if (!("events" in globalThis)) {
+    Object.defineProperty(
+      globalThis,
+      "events",
+      {
+        value: {},
+        writable: true,
+        enumerable: false,
+        configurable: true
+      }
+    );
+  }
   if (typeof globalThis.addEventListener === "function") {
     dispatch.listen("memorio:memory:cleanup", async () => memory.forgetExpired?.());
   }

package/llms.txt

@@ -100,7 +100,7 @@ store.removeAll()
 store.clearAll()  // alias
 
 // Check size
-console.debug(store.size(), 'chars stored')
+console.debug(store.size(), 'kilobytes')
 
 // Check if persistent (real localStorage vs memory fallback)
 console.debug(store.isPersistent)  // true → real localStorage
@@ -134,7 +134,7 @@ session.removeAll()
 session.clearAll()  // alias
 
 // Check size
-console.debug(session.size(), 'chars stored')
+console.debug(session.size(), 'kilobytes')
 
 // Check if persistent
 console.debug(session.isPersistent)
@@ -466,15 +466,23 @@ MIT © Dario Passariello (BigLogic Inc Canada)
 
 Internal event system used by state changes; also usable directly for custom events.
 
+Listeners are stored as a *list* per event name, so multiple subscribers on the
+same name each keep firing. `dispatch.listen` returns an unsubscribe function
+for that specific subscriber — call it to remove only that one listener without
+affecting others registered under the same name.
+
 ```javascript
 // Dispatch a custom event
 memorio.dispatch.set('custom:event', { detail: { data: 'value' } })
 
-// Listen for an event
-memorio.dispatch.listen('custom:event', (e) => {
+// Listen for an event (returns an unsubscribe function)
+const off = memorio.dispatch.listen('custom:event', (e) => {
   console.debug('Event triggered:', e.detail)
 })
 
-// Remove listener
+// Remove only this listener via the returned unsubscribe
+off()
+
+// Remove *all* listeners for a name (imperative bulk removal)
 memorio.dispatch.remove('custom:event')
 ```