memorio 5.1.3 → 5.1.4

package/AGENTS.md

@@ -69,7 +69,7 @@ If the code you're generating is client-side (a single browser tab, one user), `
   outside a guaranteed browser context must guard: `if (idb.db.support())` or check
   `memorio.getCapabilities().hasIndexedDB` - don't rely on the no-op warning alone reaching a log
   anyone will see.
-- **`sqlite` persistence uses journal + checkpoint (incremental writes, periodic full snapshots).** Batch writes and persist once after the batch per the README's guidance — calling `persist()` inside a tight loop still forces expensive checkpoints.
+- **`sqlite` persistence uses journal + checkpoint (incremental writes, periodic full snapshots).** Batch writes and persist once after the batch per the README's guidance - calling `persist()` inside a tight loop still forces expensive checkpoints.
 - **`observer('state.some.path', cb)` paths are plain strings, unchecked against `state`'s actual
   shape.** A typo or a later rename fails *silently* - the observer just never fires again. Prefer
   `memorio.typed<T>()` + `registerSchema()` for anything you'd hate to have silently stop working,

package/CHANGELOG.md

@@ -5,12 +5,15 @@ All notable changes to this project will be documented in this file.
 ## [Unreleased]
 
 ### Added
-- **SQLite journal + checkpoint persistence**: When `persistence: true` is set on `sqlite.db.create()` (or via `sqlite.config({ persistence: true })`), writes are recorded in an append-only journal with HLC timestamps. Periodic checkpoints (every 50 ops or 250 ms of write-idle) snapshot the full database to `store`. On reopen, the checkpoint is loaded and pending journal entries are replayed — no writes lost between checkpoints. New methods: `sqlite.db.flush()`, `sqlite.db.persist()`, `sqlite.db.journal` namespace (`append`, `entries`, `count`, `clear`, `replay`, `checkpoint`), `sqlite.db.journal` for direct journal inspection.
+- **SQLite journal + checkpoint persistence**: When `persistence: true` is set on `sqlite.db.create()` (or via `sqlite.config({ persistence: true })`), writes are recorded in an append-only journal with HLC timestamps. Periodic checkpoints (every 50 ops or 250 ms of write-idle) snapshot the full database to `store`. On reopen, the checkpoint is loaded and pending journal entries are replayed - no writes lost between checkpoints. New methods: `sqlite.db.flush()`, `sqlite.db.persist()`, `sqlite.db.journal` namespace (`append`, `entries`, `count`, `clear`, `replay`, `checkpoint`), `sqlite.db.journal` for direct journal inspection.
+
+### Fixed
+- **`package.json` `sideEffects`**: Added `./core/global.ts` to the `sideEffects` array so that esbuild/tsup no longer tree-shakes the `import './core/global'` side-effect-only import in `index.ts`. Without this fix, the `core/global.ts` initialization block (which defines `globalThis.memorio`) was eliminated from production builds, causing `memorio.global()` to throw `Cannot read properties of undefined (reading 'global')`.
 
 ## [5.1.2] - 2026-09-14
 
 ### Fixed
-- **`types/encryption.d.ts`**: Fixed parse error (`TS1005: ',' expected`) in `deriveKey` signature — missing comma after `alg` parameter caused all consumers' type checkers to fail, even with `skipLibCheck: true`.
+- **`types/encryption.d.ts`**: Fixed parse error (`TS1005: ',' expected`) in `deriveKey` signature - missing comma after `alg` parameter caused all consumers' type checkers to fail, even with `skipLibCheck: true`.
 - **`core/platform.ts`**: `_isBun()` now checks `typeof globalAny.Bun.version === 'string'` instead of `typeof globalAny.Bun.sqlite === 'function'`, correctly detecting the Bun runtime so `hasBunSqlite()` returns `true` and the `bun:sqlite` backend loads.
 - **`functions/sqlite/tools/bun-sqlite-adapter.ts`**: Removed unused `_index` variable.
 - **`functions/security/index.ts`**: Removed redundant type re-export block that conflicted with inline `export type`/`export interface` declarations under `isolatedModules`.
@@ -18,7 +21,7 @@ All notable changes to this project will be documented in this file.
 - **`extension/vscode/esbuild.config.mjs`**: Replaced TypeScript type annotations with JSDoc `/** @type */` to fix parse errors in `.mjs` context.
 
 ### Packaging
-- **`package.json`**: Changed `"sideEffects": true` to `"sideEffects": ["./global.js", "./global.cjs"]` so tree-shaking works for consumers using only `state`/`store` — previously the entire engine (SQLite, memory, encryption) was bundled unconditionally.
+- **`package.json`**: Changed `"sideEffects": true` to `"sideEffects": ["./global.js", "./global.cjs"]` so tree-shaking works for consumers using only `state`/`store` - previously the entire engine (SQLite, memory, encryption) was bundled unconditionally.
 - Added `types/bun-sqlite.d.ts` module declaration so `import('bun:sqlite')` resolves under TypeScript.
 
 ### Migration guide: globals change (v5 breaking change)
@@ -26,16 +29,16 @@ All notable changes to this project will be documented in this file.
 **Upgrading from 4.x:** the globals (`state`, `store`, `session`, `cache`, `idb`, `observer`, `useObserver`) are no longer installed by `import "memorio"`. Applications that use them without importing them must change one line:
 
 ```ts
-// 4.x — globals installed on import
+// 4.x - globals installed on import
 import 'memorio'
 
-// 5.x — globals installed via the global entrypoint
+// 5.x - globals installed via the global entrypoint
 import 'memorio/global'
 ```
 
 Nothing else changes. The named imports (`import { state } from 'memorio'`) work identically.
 
-**Bundler cache:** after upgrading, restart the dev server and clear `node_modules/.vite` (Vite) or `.next/cache` (Next.js), because a stale pre-bundle can mask the breakage — the app may appear to work and then fail at the next dependency re-optimisation.
+**Bundler cache:** after upgrading, restart the dev server and clear `node_modules/.vite` (Vite) or `.next/cache` (Next.js), because a stale pre-bundle can mask the breakage - the app may appear to work and then fail at the next dependency re-optimisation.
 
 ## [5.1.0] - 2026-09-12
 

package/README.md

@@ -4,7 +4,6 @@
 
 [![npm version](https://img.shields.io/npm/v/memorio)](https://www.npmjs.com/package/memorio)
 [![license](https://img.shields.io/npm/l/memorio)](./LICENSE)
-[![bundle size](https://img.shields.io/bundlephobia/minzip/memorio)](https://bundlephobia.com/package/memorio)
 [![Socket Badge](https://socket.dev/api/badge/npm/package/memorio)](https://socket.dev/npm/package/memorio)
 [![Known Vulnerabilities](https://snyk.io/test/npm/memorio/badge.svg)](https://snyk.io/test/npm/memorio)
 [![zero deps](https://img.shields.io/badge/dependencies-0-brightgreen)](#security)
@@ -13,14 +12,10 @@
 ![Edge Workers](https://img.shields.io/badge/Edge%20Workers-compatible-gray)
 ![TypeScript](https://img.shields.io/badge/TypeScript-native-gray?logo=typescript)
 ![React](https://img.shields.io/badge/React-compatible-gray?logo=react)
-![Tests](https://img.shields.io/badge/tests-500+%20passed-green)
 [![license](https://img.shields.io/npm/l/memorio.svg)](#license)
 
-<!--
-[![CI](https://img.shields.io/github/actions/workflow/status/GITHUB_ORG/GITHUB_REPO/ci.yml?branch=main)](https://github.com/GITHUB_ORG/GITHUB_REPO/actions)
--->
 
-**The memory layer for AI agents and apps — owned by the user, not the vendor.**
+**The memory layer for AI agents and apps - owned by the user, not the vendor.**
 
 ```ts
 import 'memorio/global'
@@ -41,13 +36,13 @@ Just data, available where your application needs it.
 
 That's the whole API for the simple case. No provider tree, no boilerplate.
 
-But real apps grow. Most AI-powered apps (and most apps in general) eventually need more than "just state" — persistence, session data, caches, structured browser storage, local SQL, application memory, history, optional sync. Usually that means pulling in a different library — and a different mental model — for each. Memorio gives them one consistent runtime, without making the simple case complicated:
+But real apps grow. Most AI-powered apps (and most apps in general) eventually need more than "just state" - persistence, session data, caches, structured browser storage, local SQL, application memory, history, optional sync. Usually that means pulling in a different library - and a different mental model - for each. Memorio gives them one consistent runtime, without making the simple case complicated:
 
 ```ts
 state.value = 42
 ```
 
-But the reason memorio exists isn't just "fewer dependencies." It's this: **the memory an AI agent builds about a user shouldn't be locked inside a vendor's server, opaque, and impossible to inspect or move.** Memorio's memory layer is structured, inspectable, editable, and — when you turn on encryption — readable only with a key the vendor doesn't hold. It runs client-side, in the browser, on the edge, or in Node.
+But the reason memorio exists isn't just "fewer dependencies." It's this: **the memory an AI agent builds about a user shouldn't be locked inside a vendor's server, opaque, and impossible to inspect or move.** Memorio's memory layer is structured, inspectable, editable, and - when you turn on encryption - readable only with a key the vendor doesn't hold. It runs client-side, in the browser, on the edge, or in Node.
 
 That said, this covers *structured* memory - preferences, decisions, facts with confidence and provenance - not semantic similarity search. If your agent needs "find things like this conversation," pair memorio with a dedicated vector store; see [`markdown/MEMORY.md`](./markdown/MEMORY.md).
 
@@ -84,17 +79,27 @@ Named imports (`import { state } from 'memorio'`) are unaffected. After upgradin
 Three things cover most apps - reactive state, persistence, and observation:
 
 ```ts
-import { state, persist, observer } from 'memorio'
+import { state, observer } from 'memorio'
 
 state.user = { name: 'Sara' }
 
-persist('state.user')
+const stopPersisting = state.persist('state.user')
 
 observer('state.user', user => {
   console.log(user)
 })
 ```
 
+`state.persist()` creates a bidirectional mirror between `state` (live in-memory)
+and `store` (durable copy). It seeds the initial value from `store` if present,
+then every write to that path flows to `store` automatically. The return value is
+an unsubscribe function - call it to stop the mirroring (the value already in
+`store` is preserved):
+
+```ts
+stopPersisting() // from here, state.user is in-memory only; store no longer updated
+```
+
 And this is what makes memorio a *memory* layer, not just a state manager - structured, inspectable facts about a user or agent, not just ephemeral UI state:
 
 ```ts
@@ -172,9 +177,9 @@ For most apps, that's enough. Everything below is an optional capability you can
 Memorio is upfront about what it doesn't do, so you don't find out the hard way:
 
 - **No encryption by default.** Data is stored in plain text unless you explicitly turn on `memorio.encryption` or pass an `encryptionKey`. See [`SECURITY.md`](./SECURITY.md).
-- **Namespaces/contexts aren't a security boundary.** `memorio.isolate()` gives you logical separation between tenants or sessions, not authorization or access control — enforce that at your application layer.
-- **SQLite persistence uses a journal + checkpoint strategy.** Individual writes are recorded in an append-only journal (incremental); periodic checkpoints snapshot the full database. This avoids serializing the entire database on every write. The `bun:sqlite` backend doesn't support `export()` but handles persistence natively — see [`markdown/SQLITE.md`](./markdown/SQLITE.md).
-- **`memory.context()` is rule-based, not embedding-based.** It ranks structured entries by recency, confidence, and type — it does not do semantic similarity search. Pair it with a vector store if your agent needs "find things like this."
+- **Namespaces/contexts aren't a security boundary.** `memorio.isolate()` gives you logical separation between tenants or sessions, not authorization or access control - enforce that at your application layer.
+- **SQLite persistence uses a journal + checkpoint strategy.** Individual writes are recorded in an append-only journal (incremental); periodic checkpoints snapshot the full database. This avoids serializing the entire database on every write. The `bun:sqlite` backend doesn't support `export()` but handles persistence natively - see [`markdown/SQLITE.md`](./markdown/SQLITE.md).
+- **`memory.context()` is rule-based, not embedding-based.** It ranks structured entries by recency, confidence, and type - it does not do semantic similarity search. Pair it with a vector store if your agent needs "find things like this."
 - **Key management is your responsibility.** Memorio's encryption is client-side; it doesn't manage, rotate, or store keys for you.
 
 ---

package/examples/sqlite-batched-writes.ts

@@ -1,60 +1,60 @@
-/**
- * sqlite-batched-writes.ts
- *
- * Scenario: importing or writing many rows into memorio's sqlite layer.
- *
- * With persistence enabled, each write is recorded in an append-only journal
- * (incremental). Periodic checkpoints — every 50 operations or 250 ms of
- * write-idle — take a full database snapshot. Calling `flush()` inside a
- * per-row loop triggers a checkpoint on every iteration, which is expensive.
- */
-import { memorio } from 'memorio'
-
-interface UserRow {
-  id: number
-  name: string
-  role: string
-}
-
-export async function importUsers(users: UserRow[]) {
-  await memorio.sqlite.ready
-  await memorio.sqlite.db.create('app', { persistence: true })
-
-  await memorio.sqlite.query.run(
-    'app',
-    `CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT NOT NULL, role TEXT)`
-  )
-
-  // Bad: this would trigger a full checkpoint after every single insert.
-  //
-  // for (const user of users) {
-  //   await memorio.sqlite.query.run('app', 'INSERT INTO users ...', [...])
-  //   await memorio.sqlite.db.flush('app') // <- don't do this per row
-  // }
-
-  // Good: run every insert first, flush once after the batch. Writes are
-  // journaled incrementally (cheap); the checkpoint (full snapshot) happens
-  // once at the end.
-  for (const user of users) {
-    await memorio.sqlite.query.run(
-      'app',
-      `INSERT INTO users (id, name, role) VALUES (?, ?, ?)`,
-      [user.id, user.name, user.role]
-    )
-  }
-
-  // Flush explicitly, once, after the whole batch — check the installed
-  // version's API for the exact flush/persist call name if it differs from
-  // automatic persistence-on-close.
-  const admins = await memorio.sqlite.query.select(
-    'app',
-    `SELECT * FROM users WHERE role = ?`,
-    ['admin']
-  )
-
-  return admins
-}
-
-// For read-heavy or scratch-space use where durability doesn't matter,
-// skip { persistence: true } entirely - sqlite runs in memory by default,
-// which avoids journal and checkpoint overhead altogether.
+/**
+ * sqlite-batched-writes.ts
+ *
+ * Scenario: importing or writing many rows into memorio's sqlite layer.
+ *
+ * With persistence enabled, each write is recorded in an append-only journal
+ * (incremental). Periodic checkpoints - every 50 operations or 250 ms of
+ * write-idle - take a full database snapshot. Calling `flush()` inside a
+ * per-row loop triggers a checkpoint on every iteration, which is expensive.
+ */
+import { memorio } from 'memorio'
+
+interface UserRow {
+  id: number
+  name: string
+  role: string
+}
+
+export async function importUsers(users: UserRow[]) {
+  await memorio.sqlite.ready
+  await memorio.sqlite.db.create('app', { persistence: true })
+
+  await memorio.sqlite.query.run(
+    'app',
+    `CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT NOT NULL, role TEXT)`
+  )
+
+  // Bad: this would trigger a full checkpoint after every single insert.
+  //
+  // for (const user of users) {
+  //   await memorio.sqlite.query.run('app', 'INSERT INTO users ...', [...])
+  //   await memorio.sqlite.db.flush('app') // <- don't do this per row
+  // }
+
+  // Good: run every insert first, flush once after the batch. Writes are
+  // journaled incrementally (cheap); the checkpoint (full snapshot) happens
+  // once at the end.
+  for (const user of users) {
+    await memorio.sqlite.query.run(
+      'app',
+      `INSERT INTO users (id, name, role) VALUES (?, ?, ?)`,
+      [user.id, user.name, user.role]
+    )
+  }
+
+  // Flush explicitly, once, after the whole batch - check the installed
+  // version's API for the exact flush/persist call name if it differs from
+  // automatic persistence-on-close.
+  const admins = await memorio.sqlite.query.select(
+    'app',
+    `SELECT * FROM users WHERE role = ?`,
+    ['admin']
+  )
+
+  return admins
+}
+
+// For read-heavy or scratch-space use where durability doesn't matter,
+// skip { persistence: true } entirely - sqlite runs in memory by default,
+// which avoids journal and checkpoint overhead altogether.

package/global.cjs

@@ -3327,19 +3327,39 @@ if (globalThis[STATE_INSTANCE_KEY]) {
         const initial = exports.store.get(key);
         if (initial !== void 0 && initial !== null) {
           let acc = exports.state;
+          let seedOk = true;
           for (let i = 0; i < segments.length - 1; i++) {
             const seg = segments[i];
-            if (acc[seg] === void 0 || acc[seg] === null) acc[seg] = {};
-            acc = acc[seg];
+            const existing = acc[seg];
+            if (existing === void 0 || existing === null) {
+              acc[seg] = {};
+              acc = acc[seg];
+            } else if (typeof existing === "object") {
+              acc = existing;
+            } else {
+              if (exports.DEV) {
+                console.warn(
+                  `[memorio state] state.persist('${normalized}') aborted seeding: '${seg}' already holds a primitive value (${typeof existing}), cannot nest '${segments.slice(i + 1).join(".")}' under it.`
+                );
+              }
+              seedOk = false;
+              break;
+            }
+          }
+          if (seedOk && acc) {
+            acc[segments[segments.length - 1]] = deepRaw(initial);
           }
-          if (acc) acc[segments[segments.length - 1]] = deepRaw(initial);
         }
         const handler = /* @__PURE__ */ __name(() => {
           let current = exports.state;
           for (const seg of segments) {
             current = current === void 0 || current === null ? void 0 : current[seg];
           }
-          exports.store.set(key, deepRaw(current));
+          if (current === void 0) {
+            exports.store.remove(key);
+          } else {
+            exports.store.set(key, deepRaw(current));
+          }
         }, "handler");
         const off = dispatch.listen(normalized, handler);
         return typeof off === "function" ? off : () => {
@@ -3759,8 +3779,7 @@ var observerFunction = /* @__PURE__ */ __name((s, cb = null, option = true) => {
   }
   if (s && cb) {
     const resolvedPath = resolvePath(s);
-    if (!resolvedPath) return;
-    if (typeof s !== "string" && !(s && typeof s === "object")) {
+    if (!resolvedPath) {
       console.error(`Observer Error: name of state need to be a 'string' like 'state.test' or a direct state value`);
       return;
     }
@@ -3810,7 +3829,7 @@ Object.defineProperties(
      * @returns void
      */
     removeAll: {
-      get: /* @__PURE__ */ __name(() => {
+      value: /* @__PURE__ */ __name(() => {
         const obs = globalThis.observer;
         const list = obs?.list;
         if (list) {
@@ -3819,7 +3838,7 @@ Object.defineProperties(
           });
         }
         return true;
-      }, "get")
+      }, "value")
     },
     ///
     /**
@@ -3849,40 +3868,58 @@ var useObserver = /* @__PURE__ */ __name(((func, deps = []) => {
   const unsubs = [];
   const depList = Array.isArray(deps) && !deps.__path ? deps : [deps];
   try {
-    depList.forEach((dep) => {
-      let t = "";
-      if (typeof dep === "function") {
-        const result = exports.propertyName(dep);
-        if (result) t = result;
-      } else if (typeof dep === "object" && dep !== null) {
-        t = dep.__path || (typeof dep.toString === "function" && dep.toString() !== "[object Object]" ? dep.toString() : "");
+    if (depList.length === 0) {
+      exports.internal.clearTrackedPaths();
+      exports.internal.tracking = true;
+      try {
+        func();
+      } catch (_) {
       }
-      if (t) {
-        t = t.replace(/^(\(\)\s*=>\s*)/, "").replace(/^globalThis\./, "").replace(/^state\./, "");
-        const path = t.startsWith("store.") || t.startsWith("state.") ? t : "state." + t;
+      exports.internal.tracking = false;
+      exports.internal.trackedPaths.forEach((path) => {
         if (!handlers.includes(path)) {
+          message_default(`useObserver: [Auto-Discovery] -> "${path}"`);
           handlers.push(path);
           const off = dispatch.listen(path, () => func());
           if (typeof off === "function") unsubs.push({ path, off });
         }
-      } else {
-        exports.internal.clearTrackedPaths();
-        exports.internal.tracking = true;
-        try {
-          func();
-        } catch (_) {
+      });
+    } else {
+      depList.forEach((dep) => {
+        let t = "";
+        if (typeof dep === "function") {
+          const result = exports.propertyName(dep);
+          if (result) t = result;
+        } else if (typeof dep === "object" && dep !== null) {
+          t = dep.__path || (typeof dep.toString === "function" && dep.toString() !== "[object Object]" ? dep.toString() : "");
         }
-        exports.internal.tracking = false;
-        exports.internal.trackedPaths.forEach((path) => {
+        if (t) {
+          t = t.replace(/^(\(\)\s*=>\s*)/, "").replace(/^globalThis\./, "").replace(/^state\./, "");
+          const path = t.startsWith("store.") || t.startsWith("state.") ? t : "state." + t;
           if (!handlers.includes(path)) {
-            message_default(`useObserver: [Auto-Discovery] -> "${path}"`);
             handlers.push(path);
             const off = dispatch.listen(path, () => func());
             if (typeof off === "function") unsubs.push({ path, off });
           }
-        });
-      }
-    });
+        } else {
+          exports.internal.clearTrackedPaths();
+          exports.internal.tracking = true;
+          try {
+            func();
+          } catch (_) {
+          }
+          exports.internal.tracking = false;
+          exports.internal.trackedPaths.forEach((path) => {
+            if (!handlers.includes(path)) {
+              message_default(`useObserver: [Auto-Discovery] -> "${path}"`);
+              handlers.push(path);
+              const off = dispatch.listen(path, () => func());
+              if (typeof off === "function") unsubs.push({ path, off });
+            }
+          });
+        }
+      });
+    }
     if (handlers.length > 0) {
       message_default(`useObserver: Monitoring ${handlers.length} paths.`);
     } else {
@@ -4808,7 +4845,7 @@ init_internal();
 
 // package.json
 var package_default = {
-  version: "5.1.3"};
+  version: "5.1.4"};
 
 // core/global.ts
 init_env();
@@ -5484,19 +5521,22 @@ var memory = {
   async patch(key, patches) {
     const entry = await this._getEntry(key);
     if (!entry) return;
+    const patchedValue = JSON.parse(JSON.stringify(entry.value ?? {}));
     let patched = false;
     for (const p of patches) {
+      const relativePath = p.path.replace(/^[^.]+\./, "");
       if (p.op === "set") {
-        setNestedPath({ [entry.key]: entry.value }, p.path.replace(/^[^.]+\./, ""), p.value);
+        setNestedPath(patchedValue, relativePath, p.value);
         patched = true;
       } else if (p.op === "delete") {
-        deleteNestedPath({ [entry.key]: entry.value }, p.path.replace(/^[^.]+\./, ""));
+        deleteNestedPath(patchedValue, relativePath);
         patched = true;
       }
     }
     if (!patched) return;
     const updated = {
       ...entry,
+      value: patchedValue,
       updatedAt: now(),
       lastConfirmedAt: now(),
       version: (entry.version ? entry.version : 0) + 1,

package/global.js

@@ -3324,19 +3324,39 @@ if (globalThis[STATE_INSTANCE_KEY]) {
         const initial = store.get(key);
         if (initial !== void 0 && initial !== null) {
           let acc = state2;
+          let seedOk = true;
           for (let i = 0; i < segments.length - 1; i++) {
             const seg = segments[i];
-            if (acc[seg] === void 0 || acc[seg] === null) acc[seg] = {};
-            acc = acc[seg];
+            const existing = acc[seg];
+            if (existing === void 0 || existing === null) {
+              acc[seg] = {};
+              acc = acc[seg];
+            } else if (typeof existing === "object") {
+              acc = existing;
+            } else {
+              if (DEV) {
+                console.warn(
+                  `[memorio state] state.persist('${normalized}') aborted seeding: '${seg}' already holds a primitive value (${typeof existing}), cannot nest '${segments.slice(i + 1).join(".")}' under it.`
+                );
+              }
+              seedOk = false;
+              break;
+            }
+          }
+          if (seedOk && acc) {
+            acc[segments[segments.length - 1]] = deepRaw(initial);
           }
-          if (acc) acc[segments[segments.length - 1]] = deepRaw(initial);
         }
         const handler = /* @__PURE__ */ __name(() => {
           let current = state2;
           for (const seg of segments) {
             current = current === void 0 || current === null ? void 0 : current[seg];
           }
-          store.set(key, deepRaw(current));
+          if (current === void 0) {
+            store.remove(key);
+          } else {
+            store.set(key, deepRaw(current));
+          }
         }, "handler");
         const off = dispatch.listen(normalized, handler);
         return typeof off === "function" ? off : () => {
@@ -3756,8 +3776,7 @@ var observerFunction = /* @__PURE__ */ __name((s, cb = null, option = true) => {
   }
   if (s && cb) {
     const resolvedPath = resolvePath(s);
-    if (!resolvedPath) return;
-    if (typeof s !== "string" && !(s && typeof s === "object")) {
+    if (!resolvedPath) {
       console.error(`Observer Error: name of state need to be a 'string' like 'state.test' or a direct state value`);
       return;
     }
@@ -3807,7 +3826,7 @@ Object.defineProperties(
      * @returns void
      */
     removeAll: {
-      get: /* @__PURE__ */ __name(() => {
+      value: /* @__PURE__ */ __name(() => {
         const obs = globalThis.observer;
         const list = obs?.list;
         if (list) {
@@ -3816,7 +3835,7 @@ Object.defineProperties(
           });
         }
         return true;
-      }, "get")
+      }, "value")
     },
     ///
     /**
@@ -3846,40 +3865,58 @@ var useObserver = /* @__PURE__ */ __name(((func, deps = []) => {
   const unsubs = [];
   const depList = Array.isArray(deps) && !deps.__path ? deps : [deps];
   try {
-    depList.forEach((dep) => {
-      let t = "";
-      if (typeof dep === "function") {
-        const result = propertyName(dep);
-        if (result) t = result;
-      } else if (typeof dep === "object" && dep !== null) {
-        t = dep.__path || (typeof dep.toString === "function" && dep.toString() !== "[object Object]" ? dep.toString() : "");
+    if (depList.length === 0) {
+      internal_default.clearTrackedPaths();
+      internal_default.tracking = true;
+      try {
+        func();
+      } catch (_) {
       }
-      if (t) {
-        t = t.replace(/^(\(\)\s*=>\s*)/, "").replace(/^globalThis\./, "").replace(/^state\./, "");
-        const path2 = t.startsWith("store.") || t.startsWith("state.") ? t : "state." + t;
+      internal_default.tracking = false;
+      internal_default.trackedPaths.forEach((path2) => {
         if (!handlers.includes(path2)) {
+          message_default(`useObserver: [Auto-Discovery] -> "${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;
-        try {
-          func();
-        } catch (_) {
+      });
+    } else {
+      depList.forEach((dep) => {
+        let t = "";
+        if (typeof dep === "function") {
+          const result = propertyName(dep);
+          if (result) t = result;
+        } else if (typeof dep === "object" && dep !== null) {
+          t = dep.__path || (typeof dep.toString === "function" && dep.toString() !== "[object Object]" ? dep.toString() : "");
         }
-        internal_default.tracking = false;
-        internal_default.trackedPaths.forEach((path2) => {
+        if (t) {
+          t = t.replace(/^(\(\)\s*=>\s*)/, "").replace(/^globalThis\./, "").replace(/^state\./, "");
+          const path2 = t.startsWith("store.") || t.startsWith("state.") ? t : "state." + t;
           if (!handlers.includes(path2)) {
-            message_default(`useObserver: [Auto-Discovery] -> "${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;
+          try {
+            func();
+          } catch (_) {
+          }
+          internal_default.tracking = false;
+          internal_default.trackedPaths.forEach((path2) => {
+            if (!handlers.includes(path2)) {
+              message_default(`useObserver: [Auto-Discovery] -> "${path2}"`);
+              handlers.push(path2);
+              const off = dispatch.listen(path2, () => func());
+              if (typeof off === "function") unsubs.push({ path: path2, off });
+            }
+          });
+        }
+      });
+    }
     if (handlers.length > 0) {
       message_default(`useObserver: Monitoring ${handlers.length} paths.`);
     } else {
@@ -4805,7 +4842,7 @@ init_internal();
 
 // package.json
 var package_default = {
-  version: "5.1.3"};
+  version: "5.1.4"};
 
 // core/global.ts
 init_env();
@@ -5481,19 +5518,22 @@ var memory = {
   async patch(key, patches) {
     const entry = await this._getEntry(key);
     if (!entry) return;
+    const patchedValue = JSON.parse(JSON.stringify(entry.value ?? {}));
     let patched = false;
     for (const p of patches) {
+      const relativePath = p.path.replace(/^[^.]+\./, "");
       if (p.op === "set") {
-        setNestedPath({ [entry.key]: entry.value }, p.path.replace(/^[^.]+\./, ""), p.value);
+        setNestedPath(patchedValue, relativePath, p.value);
         patched = true;
       } else if (p.op === "delete") {
-        deleteNestedPath({ [entry.key]: entry.value }, p.path.replace(/^[^.]+\./, ""));
+        deleteNestedPath(patchedValue, relativePath);
         patched = true;
       }
     }
     if (!patched) return;
     const updated = {
       ...entry,
+      value: patchedValue,
       updatedAt: now(),
       lastConfirmedAt: now(),
       version: (entry.version ? entry.version : 0) + 1,