@rozenite/storage-plugin 1.12.0 → 2.0.0

package/dist/react-native/chunks/useRozeniteStoragePlugin.require.js

@@ -1,143 +1,624 @@
-import { useRozeniteDevToolsClient as v } from "@rozenite/plugin-bridge";
-import { useCallback as A, useMemo as T, useEffect as P } from "react";
-import { g as R, s as M } from "./types.js";
-import { useRozenitePluginAgentTool as p } from "@rozenite/agent-bridge";
-import { defineAgentToolContract as g } from "@rozenite/agent-shared";
-const x = async (t, e, r) => {
-  const o = t.find(
-    (n) => n.target.adapterId === e.target.adapterId && n.target.storageId === e.target.storageId
+import { useRozeniteDevToolsClient as V } from "@rozenite/plugin-bridge";
+import { useMemo as z, useEffect as G } from "react";
+import { s as $, D as N, g as B } from "./types.js";
+import { useRozenitePluginAgentTool as f } from "@rozenite/agent-bridge";
+import { defineAgentToolContract as b, definePaginatedAgentToolContract as Y, DEFAULT_PAGE_LIMIT as Q, MAX_PAGE_LIMIT as J } from "@rozenite/agent-shared";
+const W = "@rozenite/storage-plugin", T = 1;
+class p extends Error {
+  constructor(t, r) {
+    super(r), this.path = t;
+  }
+}
+const u = (e) => e === null ? "null" : Array.isArray(e) ? "array" : typeof e, X = (e) => typeof e == "object" && e !== null && !Array.isArray(e), S = (e, t) => {
+  if (!X(e))
+    throw new p(t, `Expected object, got ${u(e)}`);
+  return e;
+}, l = (e, t) => {
+  if (typeof e != "string")
+    throw new p(t, `Expected string, got ${u(e)}`);
+  return e;
+}, M = (e, t) => {
+  if (!Array.isArray(e))
+    throw new p(t, `Expected array, got ${u(e)}`);
+  return e;
+}, O = (e, t) => {
+  if (typeof e != "string" || !N.includes(e))
+    throw new p(
+      t,
+      `Expected one of ${N.join(", ")}, got ${u(e)}`
+    );
+  return e;
+}, H = (e, t) => {
+  const r = S(e, t);
+  return { supportedTypes: M(r.supportedTypes, `${t}.supportedTypes`).map(
+    (a, i) => O(a, `${t}.supportedTypes[${i}]`)
+  ) };
+}, Z = (e) => {
+  const t = S(e, "storage");
+  return {
+    adapterId: l(t.adapterId, "storage.adapterId"),
+    storageId: l(t.storageId, "storage.storageId"),
+    adapterName: l(t.adapterName, "storage.adapterName"),
+    storageName: l(t.storageName, "storage.storageName"),
+    capabilities: H(t.capabilities, "storage.capabilities")
+  };
+}, ee = (e, t) => {
+  const r = S(e, t), o = l(r.key, `${t}.key`), s = O(r.type, `${t}.type`), a = `${t}.value`;
+  switch (s) {
+    case "string": {
+      const i = r.value;
+      if (typeof i != "string")
+        throw new p(
+          a,
+          `Expected string for type "string", got ${u(i)}`
+        );
+      return { key: o, type: "string", value: i };
+    }
+    case "number": {
+      const i = r.value;
+      if (typeof i != "number" || !Number.isFinite(i))
+        throw new p(
+          a,
+          `Expected finite number for type "number", got ${u(i)}`
+        );
+      return { key: o, type: "number", value: i };
+    }
+    case "boolean": {
+      const i = r.value;
+      if (typeof i != "boolean")
+        throw new p(
+          a,
+          `Expected boolean for type "boolean", got ${u(i)}`
+        );
+      return { key: o, type: "boolean", value: i };
+    }
+    case "buffer": {
+      const i = r.value;
+      if (!Array.isArray(i))
+        throw new p(
+          a,
+          `Expected number[] for type "buffer", got ${u(i)}`
+        );
+      const n = i.map((c, d) => {
+        if (typeof c != "number" || !Number.isInteger(c) || c < 0 || c > 255)
+          throw new p(
+            `${a}[${d}]`,
+            `Expected uint8 (integer 0-255), got ${u(c)}`
+          );
+        return c;
+      });
+      return { key: o, type: "buffer", value: n };
+    }
+  }
+}, te = (e) => {
+  try {
+    const t = S(e, "$"), r = t.version;
+    if (r !== T)
+      throw new p(
+        "version",
+        `Unsupported snapshot version: ${u(r)} (this build supports version ${T})`
+      );
+    const o = l(t.plugin, "plugin"), s = l(t.createdAt, "createdAt"), a = Z(t.storage), n = M(t.entries, "entries").map(
+      (c, d) => ee(c, `entries[${d}]`)
+    );
+    return {
+      ok: !0,
+      snapshot: {
+        version: T,
+        plugin: o,
+        createdAt: s,
+        storage: a,
+        entries: n
+      }
+    };
+  } catch (t) {
+    if (t instanceof p)
+      return { ok: !1, error: { path: t.path, message: t.message } };
+    throw t;
+  }
+}, re = (e) => ({
+  version: 1,
+  plugin: W,
+  createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+  storage: {
+    adapterId: e.target.adapterId,
+    storageId: e.target.storageId,
+    adapterName: e.adapterName,
+    storageName: e.storageName,
+    capabilities: e.capabilities
+  },
+  entries: e.entries
+}), se = (e, t) => {
+  const r = [], o = [], s = [], a = [], i = [];
+  for (const [c, d] of e.entries.entries()) {
+    if (!$(t.capabilities, d.type)) {
+      a.push({ key: d.key, type: d.type });
+      continue;
+    }
+    if (t.isBlacklisted(d.key)) {
+      s.push({ key: d.key, reason: "blacklist" });
+      continue;
+    }
+    t.entryKeys.has(d.key) ? o.push(d.key) : r.push(d.key), i.push(c), t.entryKeys.add(d.key);
+  }
+  const n = e.storage.adapterId !== t.target.adapterId || e.storage.storageId !== t.target.storageId;
+  return {
+    newKeys: r,
+    overwriteKeys: o,
+    skippedKeys: s,
+    unsupportedTypes: a,
+    acceptedEntryIndexes: i,
+    metadataMismatch: n
+  };
+}, ne = (e, t) => e.adapterId === t.adapterId && e.storageId === t.storageId, R = (e) => typeof e == "object" && e != null && !Array.isArray(e) && typeof e.adapterId == "string" && e.adapterId.trim().length > 0 && typeof e.storageId == "string" && e.storageId.trim().length > 0, C = (e) => typeof e == "object" && e != null && !Array.isArray(e) && typeof e.requestId == "string" ? e.requestId : "", oe = (e) => {
+  if (typeof e != "object" || e == null || Array.isArray(e))
+    return !1;
+  const t = e;
+  return typeof t.key != "string" ? !1 : t.type === "string" ? typeof t.value == "string" : t.type === "number" ? typeof t.value == "number" : t.type === "boolean" ? typeof t.value == "boolean" : t.type === "buffer" && Array.isArray(t.value) && t.value.every(
+    (r) => typeof r == "number" && Number.isInteger(r) && r >= 0 && r <= 255
   );
-  if (!o) {
+}, K = (e, t) => e.blacklist ? (e.blacklist.lastIndex = 0, e.blacklist.test(t)) : !1, U = (e, t) => e.find((r) => ne(r.target, t)), ae = async (e, t) => {
+  const r = C(t), o = t, s = te(o.snapshot);
+  if (typeof o != "object" || o == null || o.type !== "preview-import" || typeof o.requestId != "string" || o.requestId.trim().length === 0 || !R(o.target) || !s.ok)
+    return {
+      type: "storage-request-error",
+      requestId: r,
+      code: "INVALID_REQUEST",
+      message: "Import preview requests require a valid target, request ID, and snapshot."
+    };
+  const a = U(e, o.target);
+  if (!a)
+    return {
+      type: "storage-request-error",
+      requestId: r,
+      code: "TARGET_NOT_FOUND",
+      message: "The requested storage target was not found."
+    };
+  try {
+    const i = new Set(await a.getAllKeys());
+    return {
+      type: "import-preview",
+      requestId: r,
+      target: a.target,
+      preview: se(s.snapshot, {
+        target: a.target,
+        capabilities: a.capabilities,
+        entryKeys: i,
+        isBlacklisted: (n) => K(a, n)
+      })
+    };
+  } catch {
+    return {
+      type: "storage-request-error",
+      requestId: r,
+      code: "READ_FAILED",
+      message: "Failed to inspect the requested storage for import."
+    };
+  }
+}, ie = async (e, t, r) => {
+  const o = C(t), s = t;
+  if (typeof s != "object" || s == null || s.type !== "import-entries" || typeof s.requestId != "string" || s.requestId.trim().length === 0 || !R(s.target) || !Array.isArray(s.entries) || !s.entries.every(oe)) {
     r({
       type: "import-result",
-      target: e.target,
+      requestId: o,
+      target: R(s.target) ? s.target : { adapterId: "", storageId: "" },
       ok: !1,
       written: 0,
-      total: e.entries.length,
+      total: 0,
+      error: "Import requests require a valid target, request ID, and entries."
+    });
+    return;
+  }
+  const a = U(e, s.target);
+  if (!a) {
+    r({
+      type: "import-result",
+      requestId: s.requestId,
+      target: s.target,
+      ok: !1,
+      written: 0,
+      total: s.entries.length,
       error: "Target storage not found"
     });
     return;
   }
-  for (let n = 0; n < e.entries.length; n++) {
-    const s = e.entries[n];
+  const i = s.entries.filter(
+    (n) => $(a.capabilities, n.type) && !K(a, n.key)
+  );
+  for (let n = 0; n < i.length; n++) {
+    const c = i[n];
     try {
-      await o.set(s);
-    } catch (i) {
-      r({
+      await a.set(c);
+    } catch (d) {
+      n > 0 && r({
+        type: "storage-invalidated",
+        target: s.target,
+        operation: "import"
+      }), r({
         type: "import-result",
-        target: e.target,
+        requestId: s.requestId,
+        target: s.target,
         ok: !1,
         written: n,
-        total: e.entries.length,
-        failedKey: s.key,
-        error: i instanceof Error ? i.message : String(i)
+        total: i.length,
+        failedKey: c.key,
+        error: d instanceof Error ? d.message : String(d)
       });
       return;
     }
     r({
-      type: "set-entry",
-      target: e.target,
-      entry: s
+      type: "import-progress",
+      requestId: s.requestId,
+      target: s.target,
+      written: n + 1,
+      total: i.length
     });
   }
-  r({
+  i.length > 0 && r({
+    type: "storage-invalidated",
+    target: s.target,
+    operation: "import"
+  }), r({
     type: "import-result",
-    target: e.target,
+    requestId: s.requestId,
+    target: s.target,
     ok: !0,
-    written: e.entries.length,
-    total: e.entries.length
+    written: i.length,
+    total: i.length
   });
-}, N = 1500, m = (t) => t.kind === "async", w = (t) => t.type === "buffer" ? `${t.type}:${t.value.join(",")}` : `${t.type}:${String(t.value)}`, K = (t) => new Map(t.map((e) => [e.key, e])), I = (t, e) => t.shouldFilterKey?.(e) ? !0 : t.blacklist ? (t.blacklist.lastIndex = 0, t.blacklist.test(e)) : !1, z = (t, e, r) => {
-  if (!M(t, e))
+}, ce = (e) => typeof e == "object" && e != null && !Array.isArray(e) && typeof e.requestId == "string" ? e.requestId : "", de = (e) => typeof e == "object" && e != null && !Array.isArray(e) && e.type === "discover-storages" && typeof e.requestId == "string" && e.requestId.trim().length > 0, ge = async (e) => ({
+  target: e.target,
+  adapterName: e.adapterName,
+  storageName: e.storageName,
+  entryCount: (await e.getAllKeys()).length,
+  capabilities: e.capabilities,
+  supportsSubscriptions: e.supportsSubscriptions
+}), pe = (e) => {
+  const t = /* @__PURE__ */ new Set();
+  return e.some(({ target: r }) => {
+    const o = `${r.adapterId}:${r.storageId}`;
+    return t.has(o) ? !0 : (t.add(o), !1);
+  });
+}, ue = async (e, t) => {
+  const r = ce(t);
+  if (!de(t))
+    return {
+      type: "storage-request-error",
+      requestId: r,
+      code: "INVALID_REQUEST",
+      message: "Storage discovery requires a non-empty request ID."
+    };
+  try {
+    if (pe(e))
+      return {
+        type: "storage-request-error",
+        requestId: r,
+        code: "INVALID_REQUEST",
+        message: "Configured storages must have unique targets."
+      };
+    const o = await Promise.all(e.map(ge));
+    return { type: "storage-descriptors", requestId: r, storages: o };
+  } catch {
+    return {
+      type: "storage-request-error",
+      requestId: r,
+      code: "READ_FAILED",
+      message: "Failed to discover configured storages."
+    };
+  }
+}, ye = 256, k = 16, le = (e) => e.toString(16).toUpperCase().padStart(2, "0"), fe = (e) => {
+  let t = "", r = 0;
+  for (const o of e) {
+    if (r === ye)
+      return { preview: t, isTruncated: !0 };
+    t += o, r += 1;
+  }
+  return { preview: t, isTruncated: !1 };
+}, Ie = (e) => {
+  if (e.type === "string")
+    return {
+      key: e.key,
+      type: e.type,
+      ...fe(e.value),
+      // JavaScript strings expose their length in UTF-16 code units.
+      valueSize: e.value.length
+    };
+  if (e.type === "buffer") {
+    const r = e.value.slice(0, k);
+    return {
+      key: e.key,
+      type: e.type,
+      preview: r.map(le).join(" "),
+      valueSize: e.value.length,
+      isTruncated: e.value.length > k
+    };
+  }
+  const t = String(e.value);
+  return {
+    key: e.key,
+    type: e.type,
+    preview: t,
+    valueSize: t.length,
+    isTruncated: !1
+  };
+}, me = 100, he = 4, we = (e) => typeof e == "object" && e != null && !Array.isArray(e) && typeof e.requestId == "string" ? e.requestId : "", L = (e) => typeof e == "object" && e != null && !Array.isArray(e) && typeof e.adapterId == "string" && e.adapterId.trim().length > 0 && typeof e.storageId == "string" && e.storageId.trim().length > 0, be = (e) => (e ?? "").trim().toLowerCase(), Ee = (e) => {
+  if (typeof e != "object" || e == null || Array.isArray(e) || e.type !== "list-entry-previews" || typeof e.requestId != "string" || e.requestId.trim().length === 0 || !L(e.target) || e.search !== void 0 && typeof e.search != "string" || e.cursor !== void 0 && typeof e.cursor != "string" || !Number.isFinite(e.limit) || !Number.isInteger(e.limit) || e.limit < 1)
+    return;
+  const t = e.keySortDirection;
+  if (t !== void 0 && t !== "ascending" && t !== "descending")
+    return;
+  const r = e;
+  return {
+    ...r,
+    search: be(r.search),
+    keySortDirection: t ?? "ascending",
+    limit: Math.min(r.limit, me)
+  };
+}, D = (e) => btoa(encodeURIComponent(JSON.stringify(e))), qe = (e) => {
+  try {
+    const t = JSON.parse(decodeURIComponent(atob(e)));
+    return typeof t != "object" || t == null || Array.isArray(t) || t.version !== 1 || !L(t.target) || typeof t.search != "string" || t.keySortDirection !== "ascending" && t.keySortDirection !== "descending" || typeof t.boundaryKey != "string" || t.direction !== "next" && t.direction !== "previous" ? void 0 : t;
+  } catch {
+    return;
+  }
+}, x = (e, t) => e.adapterId === t.adapterId && e.storageId === t.storageId, Ae = (e, t) => e < t ? -1 : e > t ? 1 : 0, Se = async (e, t) => {
+  const r = new Array(t.length);
+  let o = 0;
+  const s = async () => {
+    for (; o < t.length; ) {
+      const a = o;
+      o += 1;
+      const i = await e.get(t[a]);
+      i && (r[a] = Ie(i));
+    }
+  };
+  return await Promise.all(
+    Array.from(
+      { length: Math.min(he, t.length) },
+      s
+    )
+  ), r.filter(
+    (a) => a != null
+  );
+}, ve = async (e, t) => {
+  const r = we(t), o = Ee(t);
+  if (!o)
+    return {
+      type: "storage-request-error",
+      requestId: r,
+      code: "INVALID_REQUEST",
+      message: "Entry preview requests require a valid target, request ID, and positive integer limit."
+    };
+  const s = e.find(
+    (i) => x(i.target, o.target)
+  );
+  if (!s)
+    return {
+      type: "storage-request-error",
+      requestId: r,
+      code: "TARGET_NOT_FOUND",
+      message: "The requested storage target was not found."
+    };
+  let a;
+  if (o.cursor !== void 0 && (a = qe(o.cursor), !a || !x(a.target, o.target) || a.search !== o.search || a.keySortDirection !== o.keySortDirection))
+    return {
+      type: "storage-request-error",
+      requestId: r,
+      code: "INVALID_CURSOR",
+      message: "The entry preview cursor is invalid or belongs to a different query.",
+      resetPagination: !0
+    };
+  try {
+    const i = (await s.getAllKeys()).filter((w) => w.toLowerCase().includes(o.search)).sort(Ae);
+    o.keySortDirection === "descending" && i.reverse();
+    let n = 0;
+    if (a) {
+      const w = i.indexOf(a.boundaryKey);
+      if (w === -1)
+        return {
+          type: "storage-request-error",
+          requestId: r,
+          code: "INVALID_CURSOR",
+          message: "The entry preview cursor is stale after storage changes.",
+          resetPagination: !0
+        };
+      n = a.direction === "next" ? w + 1 : Math.max(0, w - o.limit);
+    }
+    const c = i.slice(n, n + o.limit), d = await Se(s, c), g = n + c.length, y = {
+      version: 1,
+      target: o.target,
+      search: o.search,
+      keySortDirection: o.keySortDirection
+    };
+    return {
+      type: "entry-previews",
+      requestId: r,
+      target: o.target,
+      items: d,
+      ...g < i.length && c.length > 0 ? {
+        nextCursor: D({
+          ...y,
+          boundaryKey: c.at(-1),
+          direction: "next"
+        })
+      } : {},
+      ...n > 0 && c.length > 0 ? {
+        previousCursor: D({
+          ...y,
+          boundaryKey: c[0],
+          direction: "previous"
+        })
+      } : {}
+    };
+  } catch {
+    return {
+      type: "storage-request-error",
+      requestId: r,
+      code: "READ_FAILED",
+      message: "Failed to read entry previews from the requested storage."
+    };
+  }
+}, Te = (e) => typeof e == "object" && e != null && !Array.isArray(e) && typeof e.requestId == "string" ? e.requestId : "", Re = (e) => typeof e == "object" && e != null && !Array.isArray(e) && typeof e.adapterId == "string" && e.adapterId.trim().length > 0 && typeof e.storageId == "string" && e.storageId.trim().length > 0, $e = (e, t) => e.adapterId === t.adapterId && e.storageId === t.storageId, Ne = (e) => typeof e == "object" && e != null && !Array.isArray(e) && e.type === "get-entry" && typeof e.requestId == "string" && e.requestId.trim().length > 0 && Re(e.target) && typeof e.key == "string", ke = async (e, t) => {
+  const r = Te(t);
+  if (!Ne(t))
+    return {
+      type: "storage-request-error",
+      requestId: r,
+      code: "INVALID_REQUEST",
+      message: "Full entry requests require a valid target, request ID, and string key."
+    };
+  const o = e.find(
+    (s) => $e(s.target, t.target)
+  );
+  if (!o)
+    return {
+      type: "storage-request-error",
+      requestId: r,
+      code: "TARGET_NOT_FOUND",
+      message: "The requested storage target was not found."
+    };
+  try {
+    const s = await o.get(t.key);
+    return s ? {
+      type: "entry",
+      requestId: r,
+      target: o.target,
+      entry: s
+    } : {
+      type: "storage-request-error",
+      requestId: r,
+      code: "ENTRY_NOT_FOUND",
+      message: "The requested storage entry was not found."
+    };
+  } catch {
+    return {
+      type: "storage-request-error",
+      requestId: r,
+      code: "READ_FAILED",
+      message: "Failed to read the requested storage entry."
+    };
+  }
+}, De = (e) => typeof e == "object" && e != null && !Array.isArray(e) && typeof e.requestId == "string" ? e.requestId : "", xe = (e) => typeof e == "object" && e != null && !Array.isArray(e) && typeof e.adapterId == "string" && e.adapterId.trim().length > 0 && typeof e.storageId == "string" && e.storageId.trim().length > 0, _e = (e, t) => e.adapterId === t.adapterId && e.storageId === t.storageId, Pe = (e) => typeof e == "object" && e != null && !Array.isArray(e) && e.type === "export-snapshot" && typeof e.requestId == "string" && e.requestId.trim().length > 0 && xe(e.target), je = async (e, t) => {
+  const r = De(t);
+  if (!Pe(t))
+    return {
+      type: "storage-request-error",
+      requestId: r,
+      code: "INVALID_REQUEST",
+      message: "Export requests require a valid target and request ID."
+    };
+  const o = e.find(
+    (s) => _e(s.target, t.target)
+  );
+  if (!o)
+    return {
+      type: "storage-request-error",
+      requestId: r,
+      code: "TARGET_NOT_FOUND",
+      message: "The requested storage target was not found."
+    };
+  try {
+    const s = await o.getAllEntries();
+    return {
+      type: "export-snapshot-result",
+      requestId: r,
+      target: o.target,
+      snapshot: re({
+        target: o.target,
+        adapterName: o.adapterName,
+        storageName: o.storageName,
+        capabilities: o.capabilities,
+        entries: s
+      })
+    };
+  } catch {
+    return {
+      type: "storage-request-error",
+      requestId: r,
+      code: "READ_FAILED",
+      message: "Failed to export the requested storage."
+    };
+  }
+}, v = (e) => e.kind === "async", A = (e, t) => e.shouldFilterKey?.(t) ? !0 : e.blacklist ? (e.blacklist.lastIndex = 0, e.blacklist.test(t)) : !1, Fe = (e, t, r) => {
+  if (!$(e, t))
     throw new Error(
-      `Type "${e}" is not supported by storage "${r.storageId}" in adapter "${r.adapterId}".`
+      `Type "${t}" is not supported by storage "${r.storageId}" in adapter "${r.adapterId}".`
     );
-}, b = async (t) => (m(t), t.getAllKeys()), E = async (t, e) => (m(t), t.get(e)), j = async (t, e) => {
-  if (m(t)) {
-    await t.set(e);
+}, _ = async (e) => (v(e), e.getAllKeys()), P = async (e, t) => (v(e), e.get(t)), Me = async (e, t) => {
+  if (v(e)) {
+    await e.set(t);
     return;
   }
-  t.set(e);
-}, F = async (t, e) => {
-  if (m(t)) {
-    await t.delete(e);
+  e.set(t);
+}, Oe = async (e, t) => {
+  if (v(e)) {
+    await e.delete(t);
     return;
   }
-  t.delete(e);
-}, S = async (t) => {
-  const e = await t();
-  return K(e);
-}, V = (t, e, r) => {
-  e.forEach((o, n) => {
-    const s = t.get(n);
-    if (!s) {
-      r.onSet(o);
-      return;
-    }
-    w(s) !== w(o) && r.onSet(o);
-  }), t.forEach((o, n) => {
-    e.has(n) || r.onDelete(n);
-  });
-}, _ = async (t, e) => {
-  let r = await S(t);
-  const o = setInterval(async () => {
-    try {
-      const n = await S(t);
-      V(r, n, e), r = n;
-    } catch {
-    }
-  }, N);
-  return {
-    remove: () => {
-      clearInterval(o);
-    }
-  };
-}, D = (t, e) => {
-  const r = e.storage, o = {
-    adapterId: t.id,
-    storageId: e.id
-  }, n = async (i) => {
-    if (!I(e, i))
-      return E(r, i);
-  }, s = async () => {
-    const i = await b(r);
+  e.delete(t);
+}, Ce = async (e) => {
+  await e.clear();
+}, Ke = (e, t) => {
+  const r = t.storage, o = r.subscribe, s = /* @__PURE__ */ new Set();
+  let a = !1;
+  const i = {
+    adapterId: e.id,
+    storageId: t.id
+  }, n = async (d) => {
+    if (!A(t, d))
+      return P(r, d);
+  }, c = async () => {
+    const d = await _(r);
     return (await Promise.all(
-      i.filter((l) => !I(e, l)).map((l) => E(r, l))
-    )).filter((l) => !!l);
+      d.filter((y) => !A(t, y)).map((y) => P(r, y))
+    )).filter((y) => !!y);
   };
   return {
-    id: R(o),
-    target: o,
-    adapterName: t.name,
-    storageName: e.name,
-    capabilities: e.capabilities,
-    blacklist: e.blacklist,
+    id: B(i),
+    target: i,
+    adapterName: e.name,
+    storageName: t.name,
+    capabilities: t.capabilities,
+    supportsSubscriptions: o != null,
+    blacklist: t.blacklist,
     get: n,
-    set: async (i) => {
-      z(e.capabilities, i.type, o), await j(r, i);
+    set: async (d) => {
+      Fe(t.capabilities, d.type, i), s.add(d.key);
+      try {
+        await Me(r, d);
+      } finally {
+        s.delete(d.key);
+      }
     },
-    delete: async (i) => {
-      await F(r, i);
+    delete: async (d) => {
+      s.add(d);
+      try {
+        await Oe(r, d);
+      } finally {
+        s.delete(d);
+      }
     },
-    getAllKeys: async () => (await b(r)).filter((a) => !I(e, a)),
-    getAllEntries: s,
-    watch: async ({ onSet: i, onDelete: a }) => r.subscribe ? r.subscribe(async (l) => {
+    purge: async () => {
+      a = !0;
       try {
-        const d = await n(l);
-        if (!d) {
-          a(l);
-          return;
-        }
-        i(d);
-      } catch {
+        await Ce(r);
+      } finally {
+        a = !1;
       }
-    }) : _(s, { onSet: i, onDelete: a })
+    },
+    getAllKeys: async () => (await _(r)).filter((g) => !A(t, g)),
+    getAllEntries: c,
+    ...o ? {
+      watch: async (d) => o((g) => {
+        !a && !s.has(g) && !A(t, g) && d(g);
+      })
+    } : {}
   };
-}, q = (t) => t.flatMap(
-  (e) => e.storages.map(
-    (r) => D(e, r)
+}, Ue = (e) => e.flatMap(
+  (t) => t.storages.map(
+    (r) => Ke(t, r)
   )
-), f = {
+), E = {
   adapterId: {
     type: "string",
     description: "Storage adapter ID. Required when multiple adapters are configured."
@@ -146,58 +627,67 @@ const x = async (t, e, r) => {
     type: "string",
     description: "Storage node ID within the adapter. Required when multiple storages are configured."
   }
-}, u = "@rozenite/storage-plugin", $ = [
+}, I = "@rozenite/storage-plugin", j = [
   "string",
   "number",
   "boolean",
   "buffer"
-], y = {
-  listStorages: g({
+], m = {
+  listStorages: b({
     name: "list-storages",
-    description: "List all storage adapters and their storage nodes currently available on the device, including supported entry types and entry counts.",
+    description: "List all storage adapters and their storage nodes currently available on the device, including supported entry types. Entry counts are omitted to avoid enumerating every storage.",
     inputSchema: { type: "object", properties: {} }
   }),
-  listEntries: g({
+  listEntries: Y({
     name: "list-entries",
     description: "List keys in a storage. This call intentionally does not return entry values to keep responses token-efficient.",
     inputSchema: {
       type: "object",
       properties: {
-        ...f,
-        offset: {
+        ...E,
+        limit: {
           type: "number",
-          description: "Pagination offset. Defaults to 0."
+          description: "Pagination size. Defaults to 20 and is capped at 100."
         },
-        limit: {
+        cursor: {
+          type: "string",
+          description: "Opaque pagination cursor from a previous list-entries call."
+        },
+        offset: {
           type: "number",
-          description: "Pagination size. Defaults to 100."
+          description: "Deprecated initial pagination offset. Must be a non-negative integer and cannot be combined with cursor."
         }
       }
+    },
+    pagination: {
+      kind: "cursor",
+      fields: ["key"],
+      defaultFields: ["key"]
     }
   }),
-  readEntry: g({
+  readEntry: b({
     name: "read-entry",
     description: "Read a single storage entry value by key.",
     inputSchema: {
       type: "object",
       properties: {
-        ...f,
+        ...E,
         key: { type: "string", description: "Entry key." }
       },
       required: ["key"]
     }
   }),
-  createEntry: g({
+  createEntry: b({
     name: "create-entry",
     description: "Create a new storage entry. Fails if the key already exists.",
     inputSchema: {
       type: "object",
       properties: {
-        ...f,
+        ...E,
         key: { type: "string", description: "Entry key." },
         type: {
           type: "string",
-          enum: [...$],
+          enum: [...j],
           description: "Entry value type. Must be one of the supported types for the target storage (see list-storages)."
         },
         value: {
@@ -207,17 +697,17 @@ const x = async (t, e, r) => {
       required: ["key", "type", "value"]
     }
   }),
-  editEntry: g({
+  editEntry: b({
     name: "edit-entry",
     description: "Edit an existing storage entry. Fails if the key does not exist.",
     inputSchema: {
       type: "object",
       properties: {
-        ...f,
+        ...E,
         key: { type: "string", description: "Entry key." },
         type: {
           type: "string",
-          enum: [...$],
+          enum: [...j],
           description: "Entry value type. Must be one of the supported types for the target storage (see list-storages)."
         },
         value: {
@@ -227,219 +717,230 @@ const x = async (t, e, r) => {
       required: ["key", "type", "value"]
     }
   }),
-  removeEntry: g({
+  removeEntry: b({
     name: "remove-entry",
     description: "Remove a storage entry by key.",
     inputSchema: {
       type: "object",
       properties: {
-        ...f,
+        ...E,
         key: { type: "string", description: "Entry key." }
       },
       required: ["key"]
     }
   })
-}, k = (t, e) => {
-  if (t === "string") {
-    if (typeof e != "string")
+}, F = (e, t) => {
+  if (e === "string") {
+    if (typeof t != "string")
       throw new Error("Expected string value for type=string");
-    return e;
+    return t;
   }
-  if (t === "number") {
-    if (typeof e != "number" || Number.isNaN(e))
+  if (e === "number") {
+    if (typeof t != "number" || Number.isNaN(t))
       throw new Error("Expected number value for type=number");
-    return e;
+    return t;
   }
-  if (t === "boolean") {
-    if (typeof e != "boolean")
+  if (e === "boolean") {
+    if (typeof t != "boolean")
       throw new Error("Expected boolean value for type=boolean");
-    return e;
+    return t;
   }
-  if (!Array.isArray(e) || !e.every((r) => Number.isInteger(r)))
+  if (!Array.isArray(t) || !t.every((r) => Number.isInteger(r)))
     throw new Error("Expected number[] value for type=buffer");
-  return e;
-}, h = (t) => `${t.target.adapterId}/${t.target.storageId}`, L = (t) => {
-  const e = A(
-    (r, o) => {
-      if (t.length === 0)
-        throw new Error("No storages are registered.");
-      if (r !== void 0 || o !== void 0) {
-        const n = t.find(
-          (s) => (r === void 0 || s.target.adapterId === r) && (o === void 0 || s.target.storageId === o)
-        );
-        if (!n) {
-          const s = [
-            r && `adapterId="${r}"`,
-            o && `storageId="${o}"`
-          ].filter(Boolean).join(", ");
-          throw new Error(
-            `No storage matched ${s}. Available: ${t.map(h).join(", ")}`
-          );
-        }
-        return n;
-      }
-      if (t.length > 1)
-        throw new Error(
-          `Multiple storages detected. Provide adapterId and/or storageId. Available: ${t.map(h).join(", ")}`
-        );
-      return t[0];
-    },
-    [t]
-  );
-  p({
-    pluginId: u,
-    tool: y.listStorages,
-    handler: async () => ({
-      storages: await Promise.all(
-        t.map(async (r) => ({
-          adapterId: r.target.adapterId,
-          storageId: r.target.storageId,
-          adapterName: r.adapterName,
-          storageName: r.storageName,
-          supportedTypes: r.capabilities.supportedTypes,
-          entryCount: (await r.getAllKeys()).length
-        }))
-      )
-    })
-  }), p({
-    pluginId: u,
-    tool: y.listEntries,
-    handler: async ({ adapterId: r, storageId: o, offset: n = 0, limit: s = 100 }) => {
-      const i = e(r, o), a = await i.getAllKeys(), l = Math.max(0, Math.floor(n)), d = Math.max(1, Math.floor(s)), c = a.slice(l, l + d);
-      return {
-        adapterId: i.target.adapterId,
-        storageId: i.target.storageId,
-        total: a.length,
-        offset: l,
-        limit: d,
-        keys: c
-      };
-    }
-  }), p({
-    pluginId: u,
-    tool: y.readEntry,
-    handler: async ({ adapterId: r, storageId: o, key: n }) => {
-      const s = e(r, o), i = await s.get(n);
-      if (!i)
-        throw new Error(
-          `Key "${n}" not found in storage "${h(s)}".`
-        );
-      return {
-        adapterId: s.target.adapterId,
-        storageId: s.target.storageId,
-        entry: i
-      };
+  return t;
+}, h = (e) => `${e.target.adapterId}/${e.target.storageId}`, Le = (e, t) => e.adapterId === t.adapterId && e.storageId === t.storageId, Ve = (e) => btoa(encodeURIComponent(JSON.stringify(e))), ze = (e) => {
+  try {
+    const t = JSON.parse(decodeURIComponent(atob(e)));
+    if (typeof t != "object" || t == null || Array.isArray(t) || t.version !== 1 || typeof t.target?.adapterId != "string" || typeof t.target?.storageId != "string" || !Number.isSafeInteger(t.offset) || t.offset < 0)
+      throw new Error("Invalid cursor");
+    return t;
+  } catch {
+    throw new Error(
+      "Invalid cursor. Run list-entries again without a cursor to restart pagination."
+    );
+  }
+}, Ge = (e) => typeof e != "number" || !Number.isFinite(e) || !Number.isInteger(e) || e < 1 ? Q : Math.min(e, J), Be = (e) => typeof e != "number" || !Number.isFinite(e) || !Number.isSafeInteger(e) || e < 0 ? 0 : e, q = (e, t, r) => {
+  if (e.length === 0)
+    throw new Error("No storages are registered.");
+  if (t !== void 0 || r !== void 0) {
+    const o = e.filter(
+      (a) => (t === void 0 || a.target.adapterId === t) && (r === void 0 || a.target.storageId === r)
+    ), s = [
+      t !== void 0 && `adapterId="${t}"`,
+      r !== void 0 && `storageId="${r}"`
+    ].filter(Boolean).join(", ");
+    if (o.length === 0)
+      throw new Error(
+        `No storage matched ${s}. Available: ${e.map(h).join(", ")}`
+      );
+    if (o.length > 1)
+      throw new Error(
+        `Multiple storages matched ${s}. Provide both adapterId and storageId. Available: ${o.map(h).join(", ")}`
+      );
+    return o[0];
+  }
+  if (e.length > 1)
+    throw new Error(
+      `Multiple storages detected. Provide adapterId and/or storageId. Available: ${e.map(h).join(", ")}`
+    );
+  return e[0];
+}, Ye = async (e, t) => {
+  const r = Ge(t.limit);
+  if (t.cursor !== void 0 && t.offset !== void 0)
+    throw new Error("Provide either cursor or offset, not both.");
+  const o = t.cursor === void 0 ? void 0 : ze(t.cursor);
+  if (o && !Le(o.target, e.target))
+    throw new Error(
+      "Cursor does not match the requested storage. Run list-entries again without a cursor to restart pagination."
+    );
+  const s = await e.getAllKeys(), a = o?.offset ?? Be(t.offset), i = Math.min(a + r, s.length);
+  return {
+    adapterId: e.target.adapterId,
+    storageId: e.target.storageId,
+    total: s.length,
+    items: s.slice(a, i).map((n) => ({ key: n })),
+    page: {
+      limit: r,
+      hasMore: i < s.length,
+      ...i < s.length ? {
+        nextCursor: Ve({
+          version: 1,
+          target: e.target,
+          offset: i
+        })
+      } : {}
     }
-  }), p({
-    pluginId: u,
-    tool: y.createEntry,
-    handler: async ({ adapterId: r, storageId: o, key: n, type: s, value: i }) => {
-      const a = e(r, o);
-      if (await a.get(n))
+  };
+}, Qe = (e) => ({
+  listStorages: async () => ({
+    storages: e.map((t) => ({
+      adapterId: t.target.adapterId,
+      storageId: t.target.storageId,
+      adapterName: t.adapterName,
+      storageName: t.storageName,
+      supportedTypes: t.capabilities.supportedTypes
+    }))
+  }),
+  listEntries: async (t) => {
+    const r = q(e, t.adapterId, t.storageId);
+    return Ye(r, t);
+  },
+  readEntry: async ({
+    adapterId: t,
+    storageId: r,
+    key: o
+  }) => {
+    const s = q(e, t, r), a = await s.get(o);
+    if (!a)
+      throw new Error(
+        `Key "${o}" not found in storage "${h(s)}".`
+      );
+    return {
+      adapterId: s.target.adapterId,
+      storageId: s.target.storageId,
+      entry: a
+    };
+  }
+}), Je = (e) => {
+  const t = Qe(e);
+  f({
+    pluginId: I,
+    tool: m.listStorages,
+    handler: t.listStorages
+  }), f({
+    pluginId: I,
+    tool: m.listEntries,
+    handler: t.listEntries
+  }), f({
+    pluginId: I,
+    tool: m.readEntry,
+    handler: t.readEntry
+  }), f({
+    pluginId: I,
+    tool: m.createEntry,
+    handler: async ({ adapterId: r, storageId: o, key: s, type: a, value: i }) => {
+      const n = q(e, r, o);
+      if (await n.get(s))
         throw new Error(
-          `Key "${n}" already exists in storage "${h(a)}". Use edit-entry instead.`
+          `Key "${s}" already exists in storage "${h(n)}". Use edit-entry instead.`
         );
-      const d = k(s, i);
-      return await a.set({ key: n, type: s, value: d }), {
-        adapterId: a.target.adapterId,
-        storageId: a.target.storageId,
+      const d = F(a, i);
+      return await n.set({ key: s, type: a, value: d }), {
+        adapterId: n.target.adapterId,
+        storageId: n.target.storageId,
         created: !0,
-        key: n
+        key: s
       };
     }
-  }), p({
-    pluginId: u,
-    tool: y.editEntry,
-    handler: async ({ adapterId: r, storageId: o, key: n, type: s, value: i }) => {
-      const a = e(r, o);
-      if (!await a.get(n))
+  }), f({
+    pluginId: I,
+    tool: m.editEntry,
+    handler: async ({ adapterId: r, storageId: o, key: s, type: a, value: i }) => {
+      const n = q(e, r, o);
+      if (!await n.get(s))
         throw new Error(
-          `Key "${n}" not found in storage "${h(a)}". Use create-entry instead.`
+          `Key "${s}" not found in storage "${h(n)}". Use create-entry instead.`
         );
-      const d = k(s, i);
-      return await a.set({ key: n, type: s, value: d }), {
-        adapterId: a.target.adapterId,
-        storageId: a.target.storageId,
+      const d = F(a, i);
+      return await n.set({ key: s, type: a, value: d }), {
+        adapterId: n.target.adapterId,
+        storageId: n.target.storageId,
         edited: !0,
-        key: n
+        key: s
       };
     }
-  }), p({
-    pluginId: u,
-    tool: y.removeEntry,
-    handler: async ({ adapterId: r, storageId: o, key: n }) => {
-      const s = e(r, o), i = !!await s.get(n);
-      return await s.delete(n), {
-        adapterId: s.target.adapterId,
-        storageId: s.target.storageId,
+  }), f({
+    pluginId: I,
+    tool: m.removeEntry,
+    handler: async ({ adapterId: r, storageId: o, key: s }) => {
+      const a = q(e, r, o), i = !!await a.get(s);
+      return await a.delete(s), {
+        adapterId: a.target.adapterId,
+        storageId: a.target.storageId,
         removed: i,
-        key: n
+        key: s
       };
     }
   });
-}, B = ({
-  storages: t
+}, tt = ({
+  storages: e
 }) => {
-  const e = T(() => q(t), [t]);
-  L(e);
-  const r = v({
+  const t = z(() => Ue(e), [e]);
+  Je(t);
+  const r = V({
     pluginId: "@rozenite/storage-plugin"
   });
-  return P(() => {
+  return G(() => {
     if (!r)
       return;
-    const o = async (a) => {
-      const l = a ? e.filter((d) => d.id === a) : e;
-      for (const d of l)
-        try {
-          const c = await d.getAllEntries();
-          r.send("snapshot", {
-            type: "snapshot",
-            target: d.target,
-            adapterName: d.adapterName,
-            storageName: d.storageName,
-            capabilities: d.capabilities,
-            blacklist: d.blacklist ? { source: d.blacklist.source, flags: d.blacklist.flags } : void 0,
-            entries: c
-          });
-        } catch (c) {
-          console.warn(
-            `[Rozenite] Storage Plugin: Failed to snapshot ${d.target.adapterId}/${d.target.storageId}.`,
-            c
-          );
-        }
-    };
-    o();
-    const n = [];
+    const o = [];
     let s = !1;
+    const a = (n, c, d) => {
+      r.send("storage-invalidated", {
+        type: "storage-invalidated",
+        target: n,
+        key: c,
+        operation: d
+      });
+    };
     Promise.all(
-      e.map(async (a) => {
+      t.filter((n) => n.supportsSubscriptions && n.watch).map(async (n) => {
         try {
-          const l = await a.watch({
-            onSet: (d) => {
-              r.send("set-entry", {
-                type: "set-entry",
-                target: a.target,
-                entry: d
-              });
-            },
-            onDelete: (d) => {
-              r.send("delete-entry", {
-                type: "delete-entry",
-                target: a.target,
-                key: d
-              });
-            }
+          const c = n.watch;
+          if (!c)
+            return;
+          const d = await c((g) => {
+            a(n.target, g);
           });
           if (s) {
-            l.remove();
+            d.remove();
             return;
           }
-          n.push(l);
-        } catch (l) {
+          o.push(d);
+        } catch (c) {
           console.warn(
-            `[Rozenite] Storage Plugin: Failed to attach watcher for ${a.target.adapterId}/${a.target.storageId}.`,
-            l
+            `[Rozenite] Storage Plugin: Failed to attach watcher for ${n.target.adapterId}/${n.target.storageId}.`,
+            c
           );
         }
       })
@@ -447,72 +948,119 @@ const x = async (t, e, r) => {
     const i = [
       r.onMessage(
         "set-entry",
-        async ({ target: a, entry: l }) => {
-          const d = e.find(
-            (c) => c.target.adapterId === a.adapterId && c.target.storageId === a.storageId
+        async ({ target: n, entry: c }) => {
+          const d = t.find(
+            (g) => g.target.adapterId === n.adapterId && g.target.storageId === n.storageId
           );
           if (!d) {
             console.warn(
-              `[Rozenite] Storage Plugin: Storage target not found for ${a.adapterId}/${a.storageId}`
+              `[Rozenite] Storage Plugin: Storage target not found for ${n.adapterId}/${n.storageId}`
             );
             return;
           }
           try {
-            await d.set(l);
-          } catch (c) {
+            await d.set(c), a(d.target, c.key, "set");
+          } catch (g) {
             console.warn(
-              `[Rozenite] Storage Plugin: Failed to set entry in ${a.adapterId}/${a.storageId}.`,
-              c
+              `[Rozenite] Storage Plugin: Failed to set entry in ${n.adapterId}/${n.storageId}.`,
+              g
             );
           }
         }
       ),
       r.onMessage(
         "delete-entry",
-        async ({ target: a, key: l }) => {
-          const d = e.find(
-            (c) => c.target.adapterId === a.adapterId && c.target.storageId === a.storageId
+        async ({ target: n, key: c }) => {
+          const d = t.find(
+            (g) => g.target.adapterId === n.adapterId && g.target.storageId === n.storageId
           );
           if (!d) {
             console.warn(
-              `[Rozenite] Storage Plugin: Storage target not found for ${a.adapterId}/${a.storageId}`
+              `[Rozenite] Storage Plugin: Storage target not found for ${n.adapterId}/${n.storageId}`
             );
             return;
           }
           try {
-            await d.delete(l);
-          } catch (c) {
+            await d.delete(c), a(d.target, c, "delete");
+          } catch (g) {
             console.warn(
-              `[Rozenite] Storage Plugin: Failed to delete entry in ${a.adapterId}/${a.storageId}.`,
-              c
+              `[Rozenite] Storage Plugin: Failed to delete entry in ${n.adapterId}/${n.storageId}.`,
+              g
             );
           }
         }
       ),
       r.onMessage(
-        "get-snapshot",
-        async ({ target: a }) => {
-          if (a === "all") {
-            await o();
+        "purge-storage",
+        async ({ target: n }) => {
+          const c = t.find(
+            (d) => d.target.adapterId === n.adapterId && d.target.storageId === n.storageId
+          );
+          if (!c) {
+            console.warn(
+              `[Rozenite] Storage Plugin: Storage target not found for ${n.adapterId}/${n.storageId}`
+            );
             return;
           }
-          await o(`${a.adapterId}:${a.storageId}`);
+          try {
+            await c.purge(), a(c.target, void 0, "purge");
+          } catch (d) {
+            console.warn(
+              `[Rozenite] Storage Plugin: Failed to purge storage in ${n.adapterId}/${n.storageId}.`,
+              d
+            );
+          }
+        }
+      ),
+      r.onMessage(
+        "discover-storages",
+        async (n) => {
+          const c = await ue(t, n);
+          r.send(c.type, c);
+        }
+      ),
+      r.onMessage(
+        "list-entry-previews",
+        async (n) => {
+          const c = await ve(t, n);
+          r.send(c.type, c);
+        }
+      ),
+      r.onMessage(
+        "get-entry",
+        async (n) => {
+          const c = await ke(t, n);
+          r.send(c.type, c);
+        }
+      ),
+      r.onMessage(
+        "export-snapshot",
+        async (n) => {
+          const c = await je(t, n);
+          r.send(c.type, c);
+        }
+      ),
+      r.onMessage(
+        "preview-import",
+        async (n) => {
+          const c = await ae(t, n);
+          r.send(c.type, c);
         }
       ),
       r.onMessage(
         "import-entries",
-        async (a) => {
-          await x(e, a, (l) => {
-            l.type === "set-entry" ? r.send("set-entry", l) : r.send("import-result", l);
+        async (n) => {
+          await ie(t, n, (c) => {
+            r.send(c.type, c);
           });
         }
       )
     ];
     return () => {
-      s = !0, n.forEach((a) => a.remove()), i.forEach((a) => a.remove());
+      s = !0, o.forEach((n) => n.remove()), i.forEach((n) => n.remove());
     };
-  }, [r, e]), r;
+  }, [r, t]), r;
 };
 export {
-  B as useRozeniteStoragePlugin
+  tt as useRozeniteStoragePlugin
 };