@pyreon/storage 0.11.3 → 0.11.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/storage",
-  "version": "0.11.3",
+  "version": "0.11.4",
   "description": "Reactive client-side storage for Pyreon — localStorage, sessionStorage, cookies, IndexedDB",
   "license": "MIT",
   "repository": {
@@ -41,11 +41,11 @@
     "lint": "biome check ."
   },
   "peerDependencies": {
-    "@pyreon/reactivity": "^0.11.3"
+    "@pyreon/reactivity": "^0.11.4"
   },
   "devDependencies": {
     "@happy-dom/global-registrator": "^20.8.3",
-    "@pyreon/reactivity": "^0.11.3",
+    "@pyreon/reactivity": "^0.11.4",
     "@vitus-labs/tools-lint": "^1.11.0"
   }
 }

package/src/tests/clear-remove.test.ts

@@ -0,0 +1,158 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest"
+import {
+  _resetRegistry,
+  clearStorage,
+  removeStorage,
+  useCookie,
+  useSessionStorage,
+  useStorage,
+} from "../index"
+
+describe("removeStorage — comprehensive", () => {
+  beforeEach(() => {
+    localStorage.clear()
+    sessionStorage.clear()
+    _resetRegistry()
+  })
+
+  afterEach(() => {
+    localStorage.clear()
+    sessionStorage.clear()
+    _resetRegistry()
+  })
+
+  it("removes localStorage entry and resets signal to default", () => {
+    const theme = useStorage("theme", "light")
+    theme.set("dark")
+    removeStorage("theme")
+    expect(theme()).toBe("light")
+    expect(localStorage.getItem("theme")).toBeNull()
+  })
+
+  it("removes sessionStorage entry", () => {
+    const step = useSessionStorage("step", 0)
+    step.set(5)
+    removeStorage("step", { type: "session" })
+    expect(step()).toBe(0)
+    expect(sessionStorage.getItem("step")).toBeNull()
+  })
+
+  it("removes cookie entry", () => {
+    const locale = useCookie("locale", "en")
+    locale.set("de")
+    removeStorage("locale", { type: "cookie" })
+    expect(locale()).toBe("en")
+  })
+
+  it("removes raw localStorage entry without a signal", () => {
+    localStorage.setItem("orphan", "value")
+    removeStorage("orphan")
+    expect(localStorage.getItem("orphan")).toBeNull()
+  })
+
+  it("removes raw sessionStorage entry without a signal", () => {
+    sessionStorage.setItem("orphan", "value")
+    removeStorage("orphan", { type: "session" })
+    expect(sessionStorage.getItem("orphan")).toBeNull()
+  })
+
+  it("removes cookie without a registered signal (no throw)", () => {
+    expect(() => removeStorage("nonexistent", { type: "cookie" })).not.toThrow()
+  })
+
+  it("defaults to localStorage when no type specified", () => {
+    localStorage.setItem("default-type", "val")
+    removeStorage("default-type")
+    expect(localStorage.getItem("default-type")).toBeNull()
+  })
+
+  it("after removeStorage, a new useStorage call creates fresh signal", () => {
+    const a = useStorage("resettable", "first")
+    a.set("modified")
+    removeStorage("resettable")
+
+    const b = useStorage("resettable", "second")
+    expect(b()).toBe("second")
+    expect(a).not.toBe(b)
+  })
+})
+
+describe("clearStorage — comprehensive", () => {
+  beforeEach(() => {
+    localStorage.clear()
+    sessionStorage.clear()
+    _resetRegistry()
+  })
+
+  afterEach(() => {
+    localStorage.clear()
+    sessionStorage.clear()
+    _resetRegistry()
+  })
+
+  it("clears all managed localStorage entries", () => {
+    const a = useStorage("a", 1)
+    const b = useStorage("b", 2)
+    const c = useStorage("c", 3)
+    a.set(10)
+    b.set(20)
+    c.set(30)
+
+    clearStorage()
+    expect(a()).toBe(1)
+    expect(b()).toBe(2)
+    expect(c()).toBe(3)
+  })
+
+  it("clears all managed sessionStorage entries", () => {
+    const a = useSessionStorage("a", "x")
+    const b = useSessionStorage("b", "y")
+    a.set("modified-a")
+    b.set("modified-b")
+
+    clearStorage("session")
+    expect(a()).toBe("x")
+    expect(b()).toBe("y")
+  })
+
+  it("clears managed cookie entries", () => {
+    const locale = useCookie("locale", "en")
+    locale.set("de")
+
+    clearStorage("cookie")
+    expect(locale()).toBe("en")
+  })
+
+  it('clears all backends with "all"', () => {
+    const local = useStorage("local-key", "default")
+    const session = useSessionStorage("session-key", "default")
+    const cookie = useCookie("cookie-key", "default")
+    local.set("changed")
+    session.set("changed")
+    cookie.set("changed")
+
+    clearStorage("all")
+    expect(local()).toBe("default")
+    expect(session()).toBe("default")
+    expect(cookie()).toBe("default")
+  })
+
+  it("clearStorage with no managed entries does not throw", () => {
+    expect(() => clearStorage()).not.toThrow()
+    expect(() => clearStorage("session")).not.toThrow()
+    expect(() => clearStorage("cookie")).not.toThrow()
+    expect(() => clearStorage("indexeddb")).not.toThrow()
+    expect(() => clearStorage("all")).not.toThrow()
+  })
+
+  it("clearStorage does not affect unmanaged entries", () => {
+    localStorage.setItem("unmanaged", "value")
+    const managed = useStorage("managed", "default")
+    managed.set("changed")
+
+    clearStorage()
+    expect(managed()).toBe("default")
+    // Unmanaged key should still exist (clearStorage only affects registered signals)
+    expect(localStorage.getItem("unmanaged")).toBe("value")
+  })
+})

package/src/tests/cookie-options.test.ts

@@ -0,0 +1,186 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest"
+import { _resetRegistry, useCookie } from "../index"
+
+function clearAllCookies(): void {
+  for (const cookie of document.cookie.split(";")) {
+    const name = cookie.split("=")[0]?.trim()
+    if (name) {
+      // biome-ignore lint/suspicious/noDocumentCookie: test cleanup requires direct cookie access
+      document.cookie = `${name}=; max-age=0; path=/`
+    }
+  }
+}
+
+describe("useCookie — options", () => {
+  beforeEach(() => {
+    _resetRegistry()
+    clearAllCookies()
+  })
+
+  afterEach(() => {
+    _resetRegistry()
+    clearAllCookies()
+  })
+
+  describe("maxAge", () => {
+    it("sets cookie with maxAge in seconds", () => {
+      const sig = useCookie("session", "token-abc", { maxAge: 3600 })
+      sig.set("token-xyz")
+      // Cookie should be written — we can verify the signal value
+      expect(sig()).toBe("token-xyz")
+    })
+
+    it("maxAge=0 still writes cookie (browser handles expiry)", () => {
+      const sig = useCookie("ephemeral", "val", { maxAge: 0 })
+      sig.set("updated")
+      expect(sig()).toBe("updated")
+    })
+
+    it("large maxAge for long-lived cookies", () => {
+      const oneYear = 60 * 60 * 24 * 365
+      const sig = useCookie("locale", "en", { maxAge: oneYear })
+      sig.set("de")
+      expect(sig()).toBe("de")
+    })
+  })
+
+  describe("path", () => {
+    it("defaults to / when no path specified", () => {
+      const sig = useCookie("default-path", "val")
+      sig.set("updated")
+      expect(sig()).toBe("updated")
+    })
+
+    it("accepts custom path", () => {
+      const sig = useCookie("scoped", "val", { path: "/admin" })
+      sig.set("updated")
+      expect(sig()).toBe("updated")
+    })
+  })
+
+  describe("sameSite", () => {
+    it("defaults to lax when not specified", () => {
+      const sig = useCookie("lax-default", "val")
+      sig.set("updated")
+      expect(sig()).toBe("updated")
+    })
+
+    it("accepts strict sameSite", () => {
+      const sig = useCookie("strict-cookie", "val", { sameSite: "strict" })
+      sig.set("updated")
+      expect(sig()).toBe("updated")
+    })
+
+    it("accepts none sameSite", () => {
+      const sig = useCookie("none-cookie", "val", { sameSite: "none", secure: true })
+      sig.set("updated")
+      expect(sig()).toBe("updated")
+    })
+
+    it("accepts lax sameSite explicitly", () => {
+      const sig = useCookie("explicit-lax", "val", { sameSite: "lax" })
+      sig.set("updated")
+      expect(sig()).toBe("updated")
+    })
+  })
+
+  describe("combined options", () => {
+    it("maxAge + path + sameSite together", () => {
+      const sig = useCookie("combined", "default", {
+        maxAge: 86400,
+        path: "/app",
+        sameSite: "strict",
+      })
+      sig.set("updated")
+      expect(sig()).toBe("updated")
+      sig.remove()
+      expect(sig()).toBe("default")
+    })
+
+    it("expires + domain + secure together", () => {
+      const future = new Date(Date.now() + 86400000)
+      const sig = useCookie("full-options", "val", {
+        expires: future,
+        domain: "example.com",
+        secure: true,
+        sameSite: "none",
+      })
+      sig.set("updated")
+      expect(sig()).toBe("updated")
+    })
+
+    it("all options combined", () => {
+      const sig = useCookie("all-opts", "val", {
+        maxAge: 7200,
+        path: "/dashboard",
+        domain: "example.com",
+        secure: true,
+        sameSite: "strict",
+      })
+      sig.set("new-val")
+      expect(sig()).toBe("new-val")
+    })
+  })
+
+  describe("custom serializer/deserializer", () => {
+    it("uses custom serializer for cookie writes", () => {
+      const sig = useCookie("date-cookie", new Date("2025-01-01"), {
+        serializer: (d) => d.toISOString(),
+        deserializer: (s) => new Date(s),
+      })
+      const newDate = new Date("2025-06-15")
+      sig.set(newDate)
+      expect(sig().toISOString()).toBe("2025-06-15T00:00:00.000Z")
+    })
+  })
+
+  describe("remove with options", () => {
+    it("remove() resets signal regardless of cookie options", () => {
+      const sig = useCookie("removable", "default", {
+        maxAge: 86400,
+        path: "/app",
+        domain: "example.com",
+      })
+      sig.set("changed")
+      sig.remove()
+      expect(sig()).toBe("default")
+    })
+
+    it("after remove(), a new useCookie call creates a fresh signal", () => {
+      const a = useCookie("temp-cookie", "first")
+      a.set("modified")
+      a.remove()
+
+      const b = useCookie("temp-cookie", "second")
+      expect(b()).toBe("second")
+      expect(a).not.toBe(b)
+    })
+  })
+
+  describe("onError callback", () => {
+    it("calls onError when deserialization fails", () => {
+      // Pre-seed a corrupt cookie
+      // biome-ignore lint/suspicious/noDocumentCookie: test setup
+      document.cookie = `broken-cookie=${encodeURIComponent("{invalid json")}; path=/`
+
+      const errors: Error[] = []
+      const sig = useCookie("broken-cookie", "fallback", {
+        onError: (e) => {
+          errors.push(e)
+          return undefined
+        },
+      })
+      expect(sig()).toBe("fallback")
+      expect(errors).toHaveLength(1)
+    })
+
+    it("onError can provide custom fallback", () => {
+      // biome-ignore lint/suspicious/noDocumentCookie: test setup
+      document.cookie = `bad-cookie=${encodeURIComponent("not-json{")}`
+      const sig = useCookie("bad-cookie", "default", {
+        onError: () => "custom-fallback",
+      })
+      expect(sig()).toBe("custom-fallback")
+    })
+  })
+})

package/src/tests/cross-tab-sync.test.ts

@@ -0,0 +1,160 @@
+import { effect } from "@pyreon/reactivity"
+import { afterEach, beforeEach, describe, expect, it } from "vitest"
+import { _resetRegistry, useStorage } from "../index"
+
+/**
+ * Tests for cross-tab synchronization via the native `storage` event.
+ * These test the listener that useStorage attaches to `window.addEventListener('storage', ...)`.
+ */
+describe("useStorage — cross-tab sync", () => {
+  beforeEach(() => {
+    localStorage.clear()
+    _resetRegistry()
+  })
+
+  afterEach(() => {
+    localStorage.clear()
+    _resetRegistry()
+  })
+
+  it("updates signal when storage event fires with a new value", () => {
+    const theme = useStorage("theme", "light")
+    expect(theme()).toBe("light")
+
+    window.dispatchEvent(
+      Object.assign(new Event("storage"), {
+        key: "theme",
+        newValue: JSON.stringify("dark"),
+        storageArea: localStorage,
+      }),
+    )
+
+    expect(theme()).toBe("dark")
+  })
+
+  it("resets to default when storage event fires with null newValue (key deleted)", () => {
+    const theme = useStorage("theme", "light")
+    theme.set("dark")
+    expect(theme()).toBe("dark")
+
+    window.dispatchEvent(
+      Object.assign(new Event("storage"), {
+        key: "theme",
+        newValue: null,
+        storageArea: localStorage,
+      }),
+    )
+
+    expect(theme()).toBe("light")
+  })
+
+  it("ignores storage events for unregistered keys", () => {
+    const theme = useStorage("theme", "light")
+
+    window.dispatchEvent(
+      Object.assign(new Event("storage"), {
+        key: "unrelated-key",
+        newValue: JSON.stringify("value"),
+        storageArea: localStorage,
+      }),
+    )
+
+    expect(theme()).toBe("light")
+  })
+
+  it("ignores storage events with null key", () => {
+    const theme = useStorage("theme", "light")
+
+    window.dispatchEvent(
+      Object.assign(new Event("storage"), {
+        key: null,
+        newValue: null,
+        storageArea: localStorage,
+      }),
+    )
+
+    expect(theme()).toBe("light")
+  })
+
+  it("triggers reactive effect on cross-tab update", () => {
+    const theme = useStorage("theme", "light")
+    const values: string[] = []
+
+    effect(() => {
+      values.push(theme())
+    })
+
+    expect(values).toEqual(["light"])
+
+    window.dispatchEvent(
+      Object.assign(new Event("storage"), {
+        key: "theme",
+        newValue: JSON.stringify("dark"),
+        storageArea: localStorage,
+      }),
+    )
+
+    expect(values).toEqual(["light", "dark"])
+  })
+
+  it("handles corrupt JSON in storage event gracefully (falls back to default)", () => {
+    const count = useStorage("count", 0)
+
+    window.dispatchEvent(
+      Object.assign(new Event("storage"), {
+        key: "count",
+        newValue: "{invalid json",
+        storageArea: localStorage,
+      }),
+    )
+
+    // deserialize falls back to defaultValue on parse error
+    expect(count()).toBe(0)
+  })
+
+  it("syncs object values across tabs", () => {
+    const prefs = useStorage("prefs", { sidebar: true, density: "comfortable" })
+
+    window.dispatchEvent(
+      Object.assign(new Event("storage"), {
+        key: "prefs",
+        newValue: JSON.stringify({ sidebar: false, density: "compact" }),
+        storageArea: localStorage,
+      }),
+    )
+
+    expect(prefs()).toEqual({ sidebar: false, density: "compact" })
+  })
+
+  it("handles multiple rapid storage events", () => {
+    const count = useStorage("count", 0)
+
+    for (let i = 1; i <= 5; i++) {
+      window.dispatchEvent(
+        Object.assign(new Event("storage"), {
+          key: "count",
+          newValue: JSON.stringify(i),
+          storageArea: localStorage,
+        }),
+      )
+    }
+
+    expect(count()).toBe(5)
+  })
+
+  it("cross-tab sync works independently for different keys", () => {
+    const theme = useStorage("theme", "light")
+    const lang = useStorage("lang", "en")
+
+    window.dispatchEvent(
+      Object.assign(new Event("storage"), {
+        key: "theme",
+        newValue: JSON.stringify("dark"),
+        storageArea: localStorage,
+      }),
+    )
+
+    expect(theme()).toBe("dark")
+    expect(lang()).toBe("en") // unchanged
+  })
+})

package/src/tests/indexed-db-debounce.test.ts

@@ -0,0 +1,95 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import { _resetDBCache, _resetRegistry, useIndexedDB } from "../index"
+
+describe("useIndexedDB — debounced writes", () => {
+  beforeEach(() => {
+    _resetRegistry()
+    _resetDBCache()
+    vi.useFakeTimers()
+  })
+
+  afterEach(() => {
+    _resetRegistry()
+    _resetDBCache()
+    vi.useRealTimers()
+  })
+
+  it("signal updates immediately, IDB write is debounced", () => {
+    const draft = useIndexedDB("debounce-test", "initial", { debounceMs: 50 })
+    draft.set("updated")
+    // Signal is synchronous
+    expect(draft()).toBe("updated")
+  })
+
+  it("multiple rapid sets coalesce into one write (only last value)", () => {
+    const draft = useIndexedDB("coalesce-test", "", { debounceMs: 100 })
+    draft.set("first")
+    draft.set("second")
+    draft.set("third")
+
+    // Signal reflects latest immediately
+    expect(draft()).toBe("third")
+  })
+
+  it("custom debounceMs is respected", () => {
+    const fast = useIndexedDB("fast", "", { debounceMs: 10 })
+    fast.set("value")
+    expect(fast()).toBe("value")
+
+    const slow = useIndexedDB("slow", "", { debounceMs: 5000 })
+    slow.set("value")
+    expect(slow()).toBe("value")
+  })
+
+  it("default debounceMs is 100", () => {
+    const sig = useIndexedDB("default-debounce", "initial")
+    sig.set("value")
+    expect(sig()).toBe("value")
+  })
+
+  it("update() also triggers debounced write", () => {
+    const count = useIndexedDB("update-debounce", 0, { debounceMs: 50 })
+    count.update((n) => n + 1)
+    count.update((n) => n + 1)
+    count.update((n) => n + 1)
+    expect(count()).toBe(3)
+  })
+
+  it("remove() cancels pending debounced write", () => {
+    const draft = useIndexedDB("remove-cancel", "default", { debounceMs: 200 })
+    draft.set("pending-value")
+    draft.remove()
+    expect(draft()).toBe("default")
+  })
+
+  it("custom dbName and storeName options", () => {
+    const sig = useIndexedDB("custom-db-key", "val", {
+      dbName: "my-app-db",
+      storeName: "my-store",
+    })
+    sig.set("updated")
+    expect(sig()).toBe("updated")
+  })
+
+  it("custom serializer/deserializer with IndexedDB", () => {
+    const sig = useIndexedDB("date-idb", new Date("2025-01-01"), {
+      serializer: (d) => d.toISOString(),
+      deserializer: (s) => new Date(s),
+      debounceMs: 50,
+    })
+    const newDate = new Date("2025-06-15")
+    sig.set(newDate)
+    expect(sig().toISOString()).toBe("2025-06-15T00:00:00.000Z")
+  })
+
+  it(".subscribe() works with debounced signals", () => {
+    const sig = useIndexedDB("sub-idb", "a", { debounceMs: 50 })
+    let called = false
+    const unsub = sig.subscribe(() => {
+      called = true
+    })
+    sig.set("b")
+    expect(called).toBe(true)
+    unsub()
+  })
+})

package/src/tests/memory-storage.test.ts

@@ -0,0 +1,256 @@
+import { effect } from "@pyreon/reactivity"
+import { afterEach, beforeEach, describe, expect, it } from "vitest"
+import { _resetRegistry, createStorage, useMemoryStorage } from "../index"
+
+describe("useMemoryStorage", () => {
+  beforeEach(() => {
+    _resetRegistry()
+  })
+
+  afterEach(() => {
+    _resetRegistry()
+  })
+
+  it("works without any browser storage APIs (SSR-safe)", () => {
+    const sig = useMemoryStorage("ssr-key", "default")
+    expect(sig()).toBe("default")
+    sig.set("updated")
+    expect(sig()).toBe("updated")
+  })
+
+  it("persists values within the same session", () => {
+    const sig = useMemoryStorage("persist-key", "initial")
+    sig.set("saved")
+    expect(sig()).toBe("saved")
+  })
+
+  it("deduplicates signals for same key", () => {
+    const a = useMemoryStorage("dedup", "val")
+    const b = useMemoryStorage("dedup", "val")
+    expect(a).toBe(b)
+  })
+
+  it("returns different signals for different keys", () => {
+    const a = useMemoryStorage("key-a", "val")
+    const b = useMemoryStorage("key-b", "val")
+    expect(a).not.toBe(b)
+  })
+
+  it(".remove() resets to default", () => {
+    const sig = useMemoryStorage("removable", "default")
+    sig.set("changed")
+    sig.remove()
+    expect(sig()).toBe("default")
+  })
+
+  it("after remove, a new call creates a fresh signal", () => {
+    const a = useMemoryStorage("fresh", "first")
+    a.set("modified")
+    a.remove()
+
+    const b = useMemoryStorage("fresh", "second")
+    expect(b()).toBe("second")
+    expect(a).not.toBe(b)
+  })
+
+  it(".update() works", () => {
+    const count = useMemoryStorage("count", 0)
+    count.update((n) => n + 1)
+    count.update((n) => n + 1)
+    expect(count()).toBe(2)
+  })
+
+  it(".peek() reads without subscribing", () => {
+    const sig = useMemoryStorage("peek-key", "val")
+    expect(sig.peek()).toBe("val")
+  })
+
+  it("is reactive in effects", () => {
+    const sig = useMemoryStorage("reactive", "a")
+    const values: string[] = []
+
+    effect(() => {
+      values.push(sig())
+    })
+
+    sig.set("b")
+    sig.set("c")
+
+    expect(values).toEqual(["a", "b", "c"])
+  })
+
+  it("works with complex objects", () => {
+    const sig = useMemoryStorage("obj", { name: "", items: [] as string[] })
+    sig.set({ name: "test", items: ["a", "b"] })
+    expect(sig()).toEqual({ name: "test", items: ["a", "b"] })
+  })
+
+  it("works with arrays", () => {
+    const sig = useMemoryStorage("arr", [1, 2, 3])
+    sig.set([4, 5, 6])
+    expect(sig()).toEqual([4, 5, 6])
+  })
+
+  it("works with booleans", () => {
+    const sig = useMemoryStorage("bool", false)
+    sig.set(true)
+    expect(sig()).toBe(true)
+  })
+
+  it("works with null default", () => {
+    const sig = useMemoryStorage<string | null>("nullable", null)
+    expect(sig()).toBeNull()
+    sig.set("value")
+    expect(sig()).toBe("value")
+    sig.remove()
+    expect(sig()).toBeNull()
+  })
+
+  it(".debug() returns debug info", () => {
+    const sig = useMemoryStorage("debug", "test")
+    expect(sig.debug().value).toBe("test")
+  })
+
+  it(".label can be set and read", () => {
+    const sig = useMemoryStorage("label", "val")
+    sig.label = "my-memory-signal"
+    expect(sig.label).toBe("my-memory-signal")
+  })
+
+  it(".subscribe() works", () => {
+    const sig = useMemoryStorage("sub", "a")
+    let called = false
+    const unsub = sig.subscribe(() => {
+      called = true
+    })
+    sig.set("b")
+    expect(called).toBe(true)
+    unsub()
+  })
+
+  it(".direct() works", () => {
+    const sig = useMemoryStorage("dir", "a")
+    let called = false
+    const unsub = sig.direct(() => {
+      called = true
+    })
+    sig.set("b")
+    expect(called).toBe(true)
+    unsub()
+  })
+})
+
+describe("createStorage — custom backends", () => {
+  beforeEach(() => {
+    _resetRegistry()
+  })
+
+  afterEach(() => {
+    _resetRegistry()
+  })
+
+  it("creates storage with a simple Map backend", () => {
+    const store = new Map<string, string>()
+    const useCustom = createStorage({
+      get: (k) => store.get(k) ?? null,
+      set: (k, v) => store.set(k, v),
+      remove: (k) => store.delete(k),
+    })
+
+    const sig = useCustom("key", "default")
+    expect(sig()).toBe("default")
+
+    sig.set("value")
+    expect(sig()).toBe("value")
+    expect(store.get("key")).toBe(JSON.stringify("value"))
+  })
+
+  it("creates a named backend for separate deduplication", () => {
+    const storeA = new Map<string, string>()
+    const storeB = new Map<string, string>()
+
+    const useBackendA = createStorage(
+      {
+        get: (k) => storeA.get(k) ?? null,
+        set: (k, v) => storeA.set(k, v),
+        remove: (k) => storeA.delete(k),
+      },
+      "backend-a",
+    )
+
+    const useBackendB = createStorage(
+      {
+        get: (k) => storeB.get(k) ?? null,
+        set: (k, v) => storeB.set(k, v),
+        remove: (k) => storeB.delete(k),
+      },
+      "backend-b",
+    )
+
+    const sigA = useBackendA("key", "a-default")
+    const sigB = useBackendB("key", "b-default")
+
+    // Different backends, same key — should be different signals
+    expect(sigA).not.toBe(sigB)
+    expect(sigA()).toBe("a-default")
+    expect(sigB()).toBe("b-default")
+  })
+
+  it("backend that transforms values (encryption-like)", () => {
+    // Simple "encryption" — just base64 encode/decode
+    const store = new Map<string, string>()
+    const useEncrypted = createStorage({
+      get: (k) => {
+        const v = store.get(k)
+        return v ? atob(v) : null
+      },
+      set: (k, v) => store.set(k, btoa(v)),
+      remove: (k) => store.delete(k),
+    })
+
+    const sig = useEncrypted("secret", "default")
+    sig.set("my-secret-value")
+
+    expect(sig()).toBe("my-secret-value")
+    // Raw stored value should be base64 encoded
+    const raw = store.get("secret")
+    expect(raw).toBe(btoa(JSON.stringify("my-secret-value")))
+  })
+
+  it("handles backend.remove() errors gracefully", () => {
+    const useCustom = createStorage({
+      get: () => null,
+      set: () => {
+        // no-op
+      },
+      remove: () => {
+        throw new Error("remove failed")
+      },
+    })
+
+    const sig = useCustom("key", "default")
+    sig.set("value")
+    // remove() should not throw
+    sig.remove()
+    expect(sig()).toBe("default")
+  })
+
+  it("multiple hooks on same custom backend share deduplication", () => {
+    const store = new Map<string, string>()
+    const useCustom = createStorage(
+      {
+        get: (k) => store.get(k) ?? null,
+        set: (k, v) => store.set(k, v),
+        remove: (k) => store.delete(k),
+      },
+      "shared",
+    )
+
+    const sig1 = useCustom("shared-key", "default")
+    sig1.set("updated")
+
+    const sig2 = useCustom("shared-key", "default")
+    expect(sig1).toBe(sig2) // Same instance
+    expect(sig2()).toBe("updated")
+  })
+})