@avasapp/agent-bridge 0.5.0 → 0.6.1

package/dist/adapters/device.d.cts

@@ -0,0 +1,49 @@
+import { T as Tools } from '../types-qlwdcGjt.cjs';
+import { NavigationLike } from './expo-router.cjs';
+
+type Fn = (...args: any[]) => any;
+/** The parts of `react-native` the device tools use. Defaults to `require('react-native')`. */
+type ReactNativeLike = {
+    Linking: {
+        getInitialURL: Fn;
+    };
+    AppState: {
+        currentState: string;
+    };
+    DeviceEventEmitter: {
+        emit: Fn;
+        listenerCount?: Fn;
+    };
+    Platform?: {
+        OS: string;
+    };
+};
+/** `@react-native-community/netinfo`'s default export. */
+type NetInfoLike = {
+    refresh?: Fn;
+};
+/** `expo-notifications`. Only its default action id is read. */
+type NotificationsLike = {
+    DEFAULT_ACTION_IDENTIFIER?: string;
+};
+type DeviceToolsOptions = {
+    /** NetInfo, so `device.offline` also flips it. Leave out if the app has none. */
+    NetInfo?: NetInfoLike;
+    /** `import * as Notifications from 'expo-notifications'`. Adds `device.notification`. */
+    Notifications?: NotificationsLike;
+    /** `useNavigationContainerRef()` from expo-router. Makes `device.openUrl` return the route it ended on. */
+    navigation?: NavigationLike;
+    /** Adds `device.setTime`, which fakes `Date.now()` and `new Date()` app-wide. Off by default. */
+    time?: boolean;
+    /** Override where Linking, AppState and the emitter come from. For tests. */
+    reactNative?: ReactNativeLike;
+};
+
+/**
+ * Fake what comes from outside the JS: an incoming deep link, the app going
+ * to the background, going offline, a push notification and (opt in) the clock.
+ * `device.restore` undoes all of it.
+ */
+declare function deviceTools(options?: DeviceToolsOptions): Tools;
+
+export { type DeviceToolsOptions, type NetInfoLike, type NotificationsLike, type ReactNativeLike, deviceTools };

package/dist/adapters/expo-router.cjs

@@ -23,6 +23,8 @@ __export(expo_router_exports, {
   routerTools: () => routerTools
 });
 module.exports = __toCommonJS(expo_router_exports);
+
+// src/adapters/expo-router-route.ts
 var ROOT = "__root";
 var NOT_FOUND = "+not-found";
 var SETTLE_MS = 1e3;
@@ -104,6 +106,86 @@ function settle(navigation, go) {
     }
   });
 }
+
+// src/runtime/screen/settle.ts
+var STATE = /* @__PURE__ */ Symbol.for("@avasapp/agent-bridge/commits");
+var UPDATE_LANES = (1 << 22) - 1;
+var hook = () => globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+var now = () => performance.now();
+function install() {
+  const h = hook();
+  if (!h) return null;
+  const current = h.onCommitFiberRoot;
+  const existing = current?.[STATE];
+  if (existing) return existing;
+  const state = { commits: 0, listeners: /* @__PURE__ */ new Set() };
+  const wrapped = function(...args) {
+    state.commits += 1;
+    for (const listener of state.listeners) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+    return current?.apply(this, args);
+  };
+  Object.defineProperty(wrapped, STATE, { value: state });
+  h.onCommitFiberRoot = wrapped;
+  return state;
+}
+function busy() {
+  const h = hook();
+  if (!h?.renderers || !h.getFiberRoots) return false;
+  for (const id of h.renderers.keys()) {
+    for (const root of h.getFiberRoots(id)) {
+      const pending = root.pendingLanes;
+      if (typeof pending !== "number") continue;
+      if (pending & ~(root.suspendedLanes ?? 0) & UPDATE_LANES) return true;
+    }
+  }
+  return false;
+}
+var frame = () => new Promise((resolve) => {
+  const raf = globalThis.requestAnimationFrame;
+  if (raf) raf(() => resolve());
+  else setTimeout(resolve, 16);
+});
+async function settle2(options = {}) {
+  const maxMs = options.maxMs ?? 500;
+  const t0 = now();
+  const state = install();
+  const start = state?.commits ?? 0;
+  const result = () => ({
+    commits: (state?.commits ?? 0) - start,
+    ms: Math.round((now() - t0) * 100) / 100
+  });
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  if (!state) return result();
+  let seen = state.commits;
+  if (seen === start && !busy()) return result();
+  while (now() - t0 < maxMs) {
+    await frame();
+    if (state.commits === seen && !busy()) break;
+    seen = state.commits;
+  }
+  return result();
+}
+
+// src/adapters/expo-router.ts
+function targetPath(href) {
+  if (!href.startsWith("/")) return null;
+  const path = href.split(/[?#]/)[0];
+  const segments = path.split("/").filter((s) => s && !isGroup(s));
+  if (segments.at(-1) === "index") segments.pop();
+  return `/${segments.map(decode).join("/")}`;
+}
+function carriesQuery(href, params) {
+  const query = href.split("#")[0]?.split("?")[1];
+  if (!query) return true;
+  for (const [key, value] of new URLSearchParams(query))
+    if (![params[key]].flat().some((v) => String(v) === value)) return false;
+  return true;
+}
 function needDismiss(fn) {
   if (!fn)
     throw new Error(
@@ -114,18 +196,43 @@ function needDismiss(fn) {
 function routerTools(router, options = {}) {
   const { navigation } = options;
   const go = (fn, value) => navigation ? settle(navigation, fn).then(() => value) : (fn(), value);
+  const read = (nav) => ({
+    ...routeFromState(nav.getRootState()),
+    canGoBack: router.canGoBack()
+  });
+  const goTo = (fn, href) => navigation ? settle(navigation, fn).then(() => settle2()).then(() => landed(navigation, href)) : (fn(), href);
+  const landed = (navigation2, href) => {
+    if (navigation2.isReady && !navigation2.isReady())
+      return {
+        href,
+        warning: "The navigation container has not mounted yet, so the route the app ended on could not be read."
+      };
+    const route = read(navigation2);
+    const onNotFound = route.segments.includes(NOT_FOUND);
+    if (onNotFound && !href.includes(NOT_FOUND))
+      throw new Error(
+        `${href} matched no route: the app is on +not-found (${route.pathname}). Check the href against the app's routes.`
+      );
+    const want = targetPath(href);
+    if (want !== null && (want !== route.pathname || !carriesQuery(href, route.params)))
+      return {
+        ...route,
+        warning: `asked for ${href} but the app is on ${route.href}; it may have redirected, or the navigation did not run`
+      };
+    return route;
+  };
   return {
     "router.navigate": {
-      description: "Go to a route, reusing it if it is already in the stack.",
-      run: (href) => go(() => router.navigate(href), href)
+      description: "Go to a route, reusing it if it is already in the stack. With the navigation container it returns the route it ended on as an object (with a `warning` if that is not the href, path or query) and throws on +not-found.",
+      run: (href) => goTo(() => router.navigate(href), href)
     },
     "router.push": {
       description: "Push a route.",
-      run: (href) => go(() => router.push(href), href)
+      run: (href) => goTo(() => router.push(href), href)
     },
     "router.replace": {
       description: "Replace the current route.",
-      run: (href) => go(() => router.replace(href), href)
+      run: (href) => goTo(() => router.replace(href), href)
     },
     "router.back": {
       description: "Pop the navigator once if it can. Returns whether it could. Ignores modals and sheets the app renders itself, so it can pop the screen under one: close those with the app's own tool, e.g. modal.close.",
@@ -157,8 +264,7 @@ function routerTools(router, options = {}) {
           );
         if (navigation.isReady && !navigation.isReady())
           throw new Error("The navigation container has not mounted yet.");
-        const state = navigation.getRootState();
-        return { ...routeFromState(state), canGoBack: router.canGoBack() };
+        return read(navigation);
       }
     }
   };

package/dist/adapters/expo-router.d.cts

@@ -1,4 +1,4 @@
-import { T as Tools } from '../types-BmpykP1P.cjs';
+import { T as Tools } from '../types-qlwdcGjt.cjs';
 
 /** The imperative `router` from expo-router. Passed in, so this adds no dependency. */
 type RouterLike = {

package/dist/adapters/jotai.cjs

@@ -0,0 +1,266 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/jotai.ts
+var jotai_exports = {};
+__export(jotai_exports, {
+  jotaiTools: () => jotaiTools
+});
+module.exports = __toCommonJS(jotai_exports);
+
+// src/runtime/to-json.ts
+function toJson(value) {
+  if (value === void 0) return null;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const text = JSON.stringify(value, (_key, v) => {
+    if (typeof v === "bigint") return v.toString();
+    if (typeof v === "function" || typeof v === "symbol") return void 0;
+    if (v instanceof Error) return { name: v.name, message: v.message };
+    if (v instanceof Map) return Object.fromEntries(v);
+    if (v instanceof Set) return [...v];
+    if (v && typeof v === "object") {
+      if (seen.has(v)) return "[Circular]";
+      seen.add(v);
+    }
+    return v;
+  });
+  return text === void 0 ? null : JSON.parse(text);
+}
+
+// src/adapters/store-common.ts
+var isObject = (value) => typeof value === "object" && value !== null;
+function toPath(part) {
+  if (typeof part === "string") return part === "" ? [] : part.split(".");
+  if (typeof part === "number") return [part];
+  if (Array.isArray(part) && part.every((p) => typeof p === "string" || typeof p === "number"))
+    return part;
+  throw new Error(
+    `A path is a dotted string or an array of segments, got ${JSON.stringify(part)}`
+  );
+}
+function at(value, path) {
+  return path.reduce(
+    (v, k) => v?.[k],
+    value
+  );
+}
+var kindOf = (v) => v === null ? "null" : Array.isArray(v) ? "array" : typeof v;
+function readState(state, given, tool = "store.get") {
+  const args = given.filter((a) => a != null);
+  const last = args.at(-1);
+  const isOptions = isObject(last) && !Array.isArray(last);
+  const options = isOptions ? last : {};
+  const unknown = Object.keys(options).filter((k) => k !== "pick" && k !== "keys");
+  if (unknown.length)
+    throw new Error(
+      `Unknown ${tool} option ${unknown.map((k) => `"${k}"`).join(", ")}. Options: pick, keys`
+    );
+  const value = at(state, (isOptions ? args.slice(0, -1) : args).flatMap(toPath));
+  if (options.pick !== void 0) {
+    if (!Array.isArray(options.pick))
+      throw new Error(`${tool} pick is an array of paths`);
+    return Object.fromEntries(
+      options.pick.map((p) => [
+        Array.isArray(p) ? p.join(".") : String(p),
+        at(value, toPath(p))
+      ])
+    );
+  }
+  if (options.keys)
+    return isObject(value) ? Object.fromEntries(Object.entries(value).map(([k, v]) => [k, kindOf(v)])) : kindOf(value);
+  return value;
+}
+var PREVIEW = 200;
+function preview(value) {
+  try {
+    const safe = toJson(value);
+    const text = JSON.stringify(safe);
+    if (text.length <= PREVIEW) return safe;
+    return `${text.slice(0, PREVIEW)}\u2026 (${text.length} chars)`;
+  } catch {
+    return "[unserializable]";
+  }
+}
+var REDACTED = "[redacted]";
+function redactValue(redact, name, value, path, seen = []) {
+  if (!redact || typeof value === "function") return value;
+  if (typeof redact === "function") {
+    if (path) value = redact(name, path, value);
+  } else if (path && redact[name]?.some((p) => path === p || path.startsWith(`${p}.`))) {
+    return REDACTED;
+  }
+  if (!isObject(value) || seen.includes(value)) return value;
+  const next = [...seen, value];
+  const entries = Object.entries(value).map(([k, v]) => [
+    k,
+    redactValue(redact, name, v, path ? `${path}.${k}` : k, next)
+  ]);
+  return Array.isArray(value) ? entries.map(([, v]) => v) : Object.fromEntries(entries);
+}
+function redactNamed(redact, name, value) {
+  if (!redact) return value;
+  if (typeof redact === "function") {
+    return redactValue(redact, name, redact(name, "", value), "");
+  }
+  const rule = redact[name];
+  if (rule === true) return REDACTED;
+  return rule ? redactValue({ [name]: rule }, name, value, "") : value;
+}
+var warned = /* @__PURE__ */ new Set();
+function warnUnknownRedact(redact, known, adapter) {
+  if (!redact || typeof redact === "function") return;
+  for (const key of Object.keys(redact)) {
+    if (known.includes(key) || warned.has(`${adapter}:${key}`)) continue;
+    warned.add(`${adapter}:${key}`);
+    console.warn(`[agent-bridge] ${adapter} redact key "${key}" matches no ${adapter === "redux" ? "slice" : "atom"}, so it hides nothing. Known: ${known.join(", ")}`);
+  }
+}
+
+// src/adapters/jotai.ts
+var snapshots = /* @__PURE__ */ new WeakMap();
+var isWritable = (atom) => typeof atom.write === "function";
+var same = (a, b) => {
+  if (Object.is(a, b)) return true;
+  try {
+    return JSON.stringify(a) === JSON.stringify(b);
+  } catch {
+    return false;
+  }
+};
+function jotaiTools(store, atoms, options = {}) {
+  let saved = snapshots.get(store);
+  if (!saved) snapshots.set(store, saved = /* @__PURE__ */ new Map());
+  const entries = saved;
+  warnUnknownRedact(options.redact, Object.keys(atoms), "jotai");
+  const find = (name) => {
+    const atom = atoms[name];
+    if (!atom) throw new Error(`Unknown atom "${name}". Known: ${Object.keys(atoms).join(", ")}`);
+    return atom;
+  };
+  const show = (name, value) => redactNamed(options.redact, name, value);
+  const read = async (atom) => {
+    const store2 = store;
+    const unsub = store2.sub?.(atom, () => {
+    });
+    try {
+      return await store.get(atom);
+    } finally {
+      unsub?.();
+    }
+  };
+  return {
+    "jotai.list": {
+      description: 'Atom names, each "read-write" or "read-only" (derived atoms with no write cannot be set). Action atoms (write-only, like atom(null, write)) show as read-write but jotai.set refuses them.',
+      maxArgs: 0,
+      run: () => Object.fromEntries(
+        Object.entries(atoms).map(([name, a]) => [name, isWritable(a) ? "read-write" : "read-only"])
+      )
+    },
+    "jotai.get": {
+      description: 'Value of an atom, or a path inside it: ("user"), ("user", "address.city"), ("user", "address", "city") or ("user", ["address", "city"]). Async atoms are awaited. A last { pick: ["a.b", "c"] } returns just those fields; { keys: true } lists keys and their types without values. Atoms and paths configured with redact print as "[redacted]". Only atoms in the store you passed are visible: a <Provider> without a store prop has its own store.',
+      run: async (name, ...rest) => readState(show(name, await store.get(find(name))), rest, "jotai.get")
+    },
+    "jotai.set": {
+      maxArgs: 2,
+      description: `Set a writable atom to a value: ("count", 5). Returns the atom's new value. An atom is snapshotted on its first jotai.set since the last restore (or jotai.commit); bridge.restore sets it back to that value, and leaves alone an atom the app changed after you (returned in {skipped}). Changes made before that, e.g. by tapping the UI, are not in it: set an atom to its current value first to snapshot early, and see bridge.pending. Read-only atoms are refused, and so is any atom whose value is not the one you sent afterwards (an action atom or atomWithReducer: its write already ran and cannot be undone). A writable derived atom is set through its own write, and restored the same way.`,
+      run: async (name, value) => {
+        const atom = find(name);
+        if (!isWritable(atom))
+          throw new Error(`Atom "${name}" is read-only: it has no write, so it cannot be set`);
+        const first = !entries.has(name);
+        if (first) {
+          const original = await read(atom);
+          entries.set(name, { original, after: original });
+        }
+        try {
+          await store.set(atom, value);
+        } catch (e) {
+          if (first) entries.delete(name);
+          throw e;
+        }
+        const now = await store.get(atom);
+        if (!same(now, value)) {
+          if (first) entries.delete(name);
+          throw new Error(
+            `Atom "${name}" did not take the value: it reads ${JSON.stringify(preview(show(name, now)))} after the set. Its write is probably an action or a reducer, which already ran and cannot be undone, so it is not snapshotted.`
+          );
+        }
+        entries.get(name).after = now;
+        return show(name, now);
+      }
+    },
+    "jotai.commit": {
+      maxArgs: 1,
+      description: "Keep an atom as it is now: drops its pending snapshot, so bridge.restore leaves it alone and the next jotai.set snapshots again from this value. Returns { atom, committed } (committed: false when nothing was pending).",
+      run: (name) => ({ atom: name, committed: entries.delete(name) })
+    },
+    "jotai.restore": {
+      maxArgs: 0,
+      pending: ({ detail } = {}) => {
+        if (!entries.size) return false;
+        if (!detail) return true;
+        const out = {};
+        for (const [name, e] of entries) {
+          const atom = atoms[name];
+          const raw = atom ? store.get(atom) : void 0;
+          if (atom && same(e.original, raw)) continue;
+          out[name] = {
+            snapshot: preview(show(name, e.original)),
+            current: !atom ? "(no atom has this name now)" : raw instanceof Promise ? "(async)" : preview(show(name, raw))
+          };
+        }
+        return out;
+      },
+      description: "Undo the agent: set each atom changed with jotai.set back to its value at the first set (jotai.commit drops a snapshot), newest first. Returns their names; an atom the app changed after the agent is left alone and returned as { restored, skipped }. If an atom cannot be set back (or the write does not take), the rest are still restored and the error names it; its snapshot stays.",
+      run: async () => {
+        const done = [];
+        const skipped = [];
+        const failed = [];
+        for (const [name, e] of [...entries].reverse()) {
+          const atom = atoms[name];
+          if (!atom) {
+            failed.push(`${name} (no atom has this name now)`);
+            continue;
+          }
+          try {
+            if (!same(await store.get(atom), e.after)) {
+              entries.delete(name);
+              skipped.push(name);
+              continue;
+            }
+            await store.set(atom, e.original);
+            if (!same(await store.get(atom), e.original)) {
+              failed.push(`${name} (the write did not change it back)`);
+              continue;
+            }
+            entries.delete(name);
+            done.push(name);
+          } catch (err) {
+            failed.push(`${name} (${err instanceof Error ? err.message : String(err)})`);
+          }
+        }
+        if (failed.length)
+          throw new Error(
+            `Could not restore ${failed.join(", ")}. Restored: ${done.join(", ") || "none"}. The snapshots of the failed atoms are kept.`
+          );
+        return skipped.length ? { restored: done, skipped } : done;
+      }
+    }
+  };
+}

package/dist/adapters/jotai.d.cts

@@ -0,0 +1,19 @@
+import { T as Tools } from '../types-qlwdcGjt.cjs';
+import { N as NamedRedact } from '../store-common-j0cHHvBr.cjs';
+
+/** Anything with a Jotai store's shape: getDefaultStore(), createStore(), or the Provider's store. */
+type JotaiStoreLike = {
+    get(atom: any): unknown;
+    set(atom: any, ...args: any[]): unknown;
+};
+/** A Jotai atom; the adapter only checks whether it has a `write`. */
+type JotaiAtomLike = object;
+
+type JotaiToolsOptions = {
+    /** By atom name, as `{ token: true }` or `{ user: ['phone'] }`, or a hook `(atom, path, value)`. */
+    redact?: NamedRedact;
+};
+/** Read, set and restore named Jotai atoms. */
+declare function jotaiTools(store: JotaiStoreLike, atoms: Record<string, JotaiAtomLike>, options?: JotaiToolsOptions): Tools;
+
+export { type JotaiAtomLike, NamedRedact as JotaiRedact, type JotaiStoreLike, type JotaiToolsOptions, jotaiTools };

package/dist/adapters/react-native-mmkv.cjs

@@ -24,6 +24,10 @@ __export(react_native_mmkv_exports, {
 });
 module.exports = __toCommonJS(react_native_mmkv_exports);
 var originals = /* @__PURE__ */ new WeakMap();
+var written = /* @__PURE__ */ new WeakMap();
+var rev = 0;
+var idOf = (mmkv) => typeof mmkv.id === "string" ? mmkv.id : void 0;
+var isPlain = (v) => !!v && typeof v === "object" && !Array.isArray(v);
 function remove(mmkv, name, key) {
   if (mmkv.remove) mmkv.remove(key);
   else if (mmkv.delete) mmkv.delete(key);
@@ -45,6 +49,12 @@ function mmkvTools(instances) {
     const exists = mmkv.contains?.(key) ?? mmkv.getAllKeys().includes(key);
     saved.set(key, exists ? mmkv.getString(key) ?? null : void 0);
   };
+  const note = (mmkv, key, value) => {
+    let map = written.get(mmkv);
+    if (!map) written.set(mmkv, map = /* @__PURE__ */ new Map());
+    map.set(key, value);
+    rev += 1;
+  };
   return {
     "mmkv.list": {
       description: "Instance names.",
@@ -68,6 +78,7 @@ function mmkvTools(instances) {
         const mmkv = get(name);
         beforeChange(mmkv, key);
         mmkv.set(key, stored);
+        note(mmkv, key, typeof stored === "string" ? stored : "native");
         return true;
       }
     },
@@ -77,11 +88,78 @@ function mmkvTools(instances) {
         const mmkv = get(name);
         beforeChange(mmkv, key);
         remove(mmkv, name, key);
+        note(mmkv, key, null);
         return true;
       }
     },
     "mmkv.restore": {
       pending: () => Object.values(instances).some((m) => originals.has(m)),
+      journalRev: () => rev,
+      // Only string values: an original or written number can't be read back as one.
+      journal: () => {
+        const out = {};
+        for (const [name, mmkv] of Object.entries(instances)) {
+          const saved = originals.get(mmkv);
+          for (const [key, original] of saved ?? []) {
+            const now = written.get(mmkv)?.get(key);
+            if (original === null || now === void 0 || now === "native") continue;
+            const id = idOf(mmkv);
+            (out[name] ?? (out[name] = {}))[key] = { original: original ?? null, written: now, ...id !== void 0 && { id } };
+          }
+        }
+        return Object.keys(out).length ? out : void 0;
+      },
+      adopt: (raw) => {
+        const data = isPlain(raw) ? raw : {};
+        const result = { adopted: [], already: [], changed: [] };
+        const retry = {};
+        for (const [name, keys] of Object.entries(data)) {
+          if (!isPlain(keys)) {
+            (result.invalid ?? (result.invalid = [])).push(name);
+            continue;
+          }
+          const mmkv = instances[name];
+          if (!mmkv) {
+            retry[name] = keys;
+            continue;
+          }
+          for (const [key, entry] of Object.entries(keys)) {
+            const label = `${name}:${key}`;
+            const e = entry;
+            const text = (v) => v === null || typeof v === "string";
+            if (!isPlain(e) || !text(e.original) || !text(e.written) || e.id !== void 0 && typeof e.id !== "string") {
+              (result.invalid ?? (result.invalid = [])).push(label);
+              continue;
+            }
+            const now = idOf(mmkv);
+            if (e.id !== void 0 && now !== void 0 && e.id !== now) {
+              (result.skipped ?? (result.skipped = [])).push(label);
+              continue;
+            }
+            const exists = mmkv.contains?.(key) ?? mmkv.getAllKeys().includes(key);
+            if (!exists && e.written === null && !(e.id !== void 0 && e.id === now)) {
+              result.already.push(label);
+              continue;
+            }
+            const current = exists ? mmkv.getString(key) ?? void 0 : null;
+            const saved = originals.get(mmkv);
+            const savedNow = saved?.get(key);
+            const savedFake = saved?.has(key) && savedNow !== null && (savedNow ?? null) === entry.written && (entry.written !== null || e.id !== void 0 && e.id === now);
+            if (current === entry.original && !savedFake) {
+              result.already.push(label);
+            } else if (savedFake || current === entry.written) {
+              let map = originals.get(mmkv);
+              if (!map) originals.set(mmkv, map = /* @__PURE__ */ new Map());
+              map.set(key, entry.original ?? void 0);
+              if (!savedFake) note(mmkv, key, entry.written);
+              else rev += 1;
+              result.adopted.push(label);
+            } else result.changed.push(label);
+          }
+        }
+        if (Object.keys(retry).length) result.retry = retry;
+        return result;
+      },
       description: "Undo the agent: put back keys changed with mmkv.set or mmkv.delete, deleting ones that did not exist. Returns how many.",
       run: () => {
         let restored = 0;
@@ -95,7 +173,9 @@ function mmkvTools(instances) {
             restored += 1;
           }
           originals.delete(mmkv);
+          written.delete(mmkv);
         }
+        rev += 1;
         return restored;
       }
     }

package/dist/adapters/react-native-mmkv.d.cts

@@ -1,7 +1,9 @@
-import { T as Tools } from '../types-BmpykP1P.cjs';
+import { T as Tools } from '../types-qlwdcGjt.cjs';
 
 /** The MMKV surface this adapter uses. v3 has `delete`, v4 has `remove`. */
 type MMKVLike = {
+    /** MMKV v2 and v3 instances carry their `id`; v4 does not. Used only to tell instances apart. */
+    id?: string;
     getAllKeys: () => string[];
     getString: (key: string) => string | undefined;
     set: (key: string, value: string | number | boolean) => void;

package/dist/adapters/react-native-webview.d.cts

@@ -1,4 +1,4 @@
-import { T as Tools } from '../types-BmpykP1P.cjs';
+import { T as Tools } from '../types-qlwdcGjt.cjs';
 
 /** What the adapter needs from a react-native-webview instance. */
 type WebViewLike = {