@fluixi/storage 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fluixi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# @fluixi/storage
+
+One typed key/value API over any backend: memory, localStorage, sessionStorage, cookies, a
+request, or your own. No dependency on the rest of Fluixi.
+
+```ts
+import { createStorage } from '@fluixi/storage';
+import { localStorageAdapter } from '@fluixi/storage/browser';
+
+const prefs = createStorage<{ theme: 'light' | 'dark' }>({ adapter: localStorageAdapter(), namespace: 'app' });
+
+prefs.set('theme', 'dark', { ttl: 30 * 24 * 3600_000 });
+prefs.get('theme'); // 'dark' | null
+```
+
+- **Adapters**: `memoryStorage` (`.`), `localStorageAdapter`, `sessionStorageAdapter` and
+  `documentCookieAdapter` (`./browser`), `cookieStorage` and `requestStorage` (`./server`), or
+  your own.
+- **Values**: namespaces, expiry, versions and migrations, a strict JSON serializer that refuses
+  what JSON would silently change.
+- **Management**: `search`, `entries`, `prune`, `usage`, `update`, `getOrSet`, `snapshot`,
+  `restore`, `copyStorage`.
+- **Changes**: `subscribe`, across every storage over the same adapter and across tabs.
+- **Encryption**: per item and opt in, AES-256-GCM through Web Crypto, with a key provider.
+- **Errors**: one `StorageError` family with stable codes.
+
+In a Fluixi app, `useStorage`, `persisted` and the theme helpers in `@fluixi/core` build on it.
+
+Documentation: [Storage](https://docs.fluixi.com/v1/en/storage) and
+[Storage in an app](https://docs.fluixi.com/v1/en/app-storage).

package/dist/adapters/memory.cjs

@@ -0,0 +1,46 @@
+"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/memory.ts
+var memory_exports = {};
+__export(memory_exports, {
+  memoryStorage: () => memoryStorage
+});
+module.exports = __toCommonJS(memory_exports);
+function memoryStorage() {
+  const values = /* @__PURE__ */ new Map();
+  return {
+    name: "memory",
+    scope: "memory",
+    capabilities: {
+      synchronous: true,
+      persistent: false,
+      reactive: false,
+      crossContext: false,
+      expiration: false,
+      transactions: false
+    },
+    get: (key) => values.get(key) ?? null,
+    set: (key, value) => void values.set(key, value),
+    remove: (key) => void values.delete(key),
+    has: (key) => values.has(key),
+    keys: () => [...values.keys()],
+    clear: () => values.clear()
+  };
+}

package/dist/adapters/memory.d.ts

@@ -0,0 +1,8 @@
+import type { StorageAdapter } from '../core/types.js';
+/**
+ * Values in a Map, for as long as this adapter lives. Works anywhere: browser, server, tests,
+ * workers. Each call makes its own Map: on a server, keep one per request, never one per
+ * process for request data.
+ */
+export declare function memoryStorage(): StorageAdapter;
+//# sourceMappingURL=memory.d.ts.map

package/dist/adapters/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/adapters/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,cAAc,CAoB9C"}

package/dist/adapters/memory.js

@@ -0,0 +1,26 @@
+/**
+ * Values in a Map, for as long as this adapter lives. Works anywhere: browser, server, tests,
+ * workers. Each call makes its own Map: on a server, keep one per request, never one per
+ * process for request data.
+ */
+export function memoryStorage() {
+    const values = new Map();
+    return {
+        name: 'memory',
+        scope: 'memory',
+        capabilities: {
+            synchronous: true,
+            persistent: false,
+            reactive: false,
+            crossContext: false,
+            expiration: false,
+            transactions: false,
+        },
+        get: (key) => values.get(key) ?? null,
+        set: (key, value) => void values.set(key, value),
+        remove: (key) => void values.delete(key),
+        has: (key) => values.has(key),
+        keys: () => [...values.keys()],
+        clear: () => values.clear(),
+    };
+}

package/dist/adapters/memory.mjs

@@ -0,0 +1,25 @@
+// src/adapters/memory.ts
+function memoryStorage() {
+  const values = /* @__PURE__ */ new Map();
+  return {
+    name: "memory",
+    scope: "memory",
+    capabilities: {
+      synchronous: true,
+      persistent: false,
+      reactive: false,
+      crossContext: false,
+      expiration: false,
+      transactions: false
+    },
+    get: (key) => values.get(key) ?? null,
+    set: (key, value) => void values.set(key, value),
+    remove: (key) => void values.delete(key),
+    has: (key) => values.has(key),
+    keys: () => [...values.keys()],
+    clear: () => values.clear()
+  };
+}
+export {
+  memoryStorage
+};

package/dist/browser/document-cookie.cjs

@@ -0,0 +1,101 @@
+"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/browser/document-cookie.ts
+var document_cookie_exports = {};
+__export(document_cookie_exports, {
+  documentCookieAdapter: () => documentCookieAdapter
+});
+module.exports = __toCommonJS(document_cookie_exports);
+var import_cookie = require("@fluixi/utils/cookie");
+
+// src/core/errors.ts
+var StorageError = class extends Error {
+  constructor(code, message, options = {}) {
+    super(message);
+    this.name = new.target.name;
+    this.code = code;
+    this.key = options.key;
+    if (options.cause !== void 0) this.cause = options.cause;
+  }
+};
+var StorageUnavailableError = class extends StorageError {
+  constructor(message, options = {}) {
+    super("unavailable", message, options);
+  }
+};
+var StorageQuotaError = class extends StorageError {
+  constructor(message, options = {}) {
+    super("quota", message, options);
+  }
+};
+
+// src/utils/cookie-names.ts
+var encodeCookieName = (key) => encodeURIComponent(key).replace(/[()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+var decodeCookieName = (name) => {
+  try {
+    return decodeURIComponent(name);
+  } catch {
+    return name;
+  }
+};
+var cookiePairSize = (header) => new TextEncoder().encode(header.slice(0, header.indexOf(";"))).length;
+var withEntryExpiry = (cookie, expiresAt) => expiresAt === void 0 ? cookie : { ...cookie, maxAge: void 0, expires: new Date(expiresAt) };
+
+// src/browser/document-cookie.ts
+function documentCookieAdapter(options = {}) {
+  const { maxSize = 4096, ...cookie } = options;
+  const doc = (key) => {
+    if (typeof document === "undefined") throw new StorageUnavailableError("document.cookie is not available here; on a server use cookieStorage.", { key });
+    return document;
+  };
+  const all = () => {
+    const out = /* @__PURE__ */ new Map();
+    for (const [name, value] of Object.entries((0, import_cookie.parseCookies)(doc().cookie))) out.set(decodeCookieName(name), value);
+    return out;
+  };
+  const write = (key, header) => {
+    doc(key).cookie = header;
+  };
+  return {
+    name: "documentCookie",
+    scope: "cookie",
+    capabilities: {
+      synchronous: true,
+      persistent: true,
+      reactive: false,
+      crossContext: true,
+      expiration: false,
+      transactions: false
+    },
+    get: (key) => all().get(key) ?? null,
+    set(key, value, writeOptions) {
+      const header = (0, import_cookie.serializeCookie)(encodeCookieName(key), value, { ...withEntryExpiry(cookie, writeOptions?.expiresAt), httpOnly: false });
+      const size = cookiePairSize(header);
+      if (size > maxSize) throw new StorageQuotaError(`Cookie ${key} is ${size} bytes, over the ${maxSize} limit.`, { key });
+      write(key, header);
+    },
+    remove: (key) => write(key, (0, import_cookie.serializeCookie)(encodeCookieName(key), "", { ...cookie, httpOnly: false, maxAge: 0, expires: /* @__PURE__ */ new Date(0) })),
+    has: (key) => all().has(key),
+    keys: () => [...all().keys()],
+    clear() {
+      for (const key of all().keys()) this.remove(key);
+    }
+  };
+}

package/dist/browser/document-cookie.d.ts

@@ -0,0 +1,14 @@
+import { type CookieOptions } from '@fluixi/utils/cookie';
+import type { StorageAdapter } from '../core/types.js';
+export interface DocumentCookieOptions extends Omit<CookieOptions, 'httpOnly'> {
+    /** Largest `name=value` in bytes. Browsers keep about 4096. */
+    maxSize?: number;
+}
+/**
+ * The page's cookies through `document.cookie`: the browser half of a value the server also
+ * reads from the request, so both render the same thing. Script cannot set or see HttpOnly
+ * cookies, so these never are. `secure` defaults to true, which a browser honours on https and
+ * on localhost only.
+ */
+export declare function documentCookieAdapter(options?: DocumentCookieOptions): StorageAdapter;
+//# sourceMappingURL=document-cookie.d.ts.map

package/dist/browser/document-cookie.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-cookie.d.ts","sourceRoot":"","sources":["../../src/browser/document-cookie.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiC,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAEzF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGvD,MAAM,WAAW,qBAAsB,SAAQ,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC;IAC5E,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,qBAA0B,GAAG,cAAc,CAuCzF"}

package/dist/browser/document-cookie.js

@@ -0,0 +1,53 @@
+import { parseCookies, serializeCookie } from '@fluixi/utils/cookie';
+import { StorageQuotaError, StorageUnavailableError } from '../core/errors.js';
+import { cookiePairSize, decodeCookieName, encodeCookieName, withEntryExpiry } from '../utils/cookie-names.js';
+/**
+ * The page's cookies through `document.cookie`: the browser half of a value the server also
+ * reads from the request, so both render the same thing. Script cannot set or see HttpOnly
+ * cookies, so these never are. `secure` defaults to true, which a browser honours on https and
+ * on localhost only.
+ */
+export function documentCookieAdapter(options = {}) {
+    const { maxSize = 4096, ...cookie } = options;
+    const doc = (key) => {
+        if (typeof document === 'undefined')
+            throw new StorageUnavailableError('document.cookie is not available here; on a server use cookieStorage.', { key });
+        return document;
+    };
+    const all = () => {
+        const out = new Map();
+        for (const [name, value] of Object.entries(parseCookies(doc().cookie)))
+            out.set(decodeCookieName(name), value);
+        return out;
+    };
+    const write = (key, header) => {
+        doc(key).cookie = header;
+    };
+    return {
+        name: 'documentCookie',
+        scope: 'cookie',
+        capabilities: {
+            synchronous: true,
+            persistent: true,
+            reactive: false,
+            crossContext: true,
+            expiration: false,
+            transactions: false,
+        },
+        get: (key) => all().get(key) ?? null,
+        set(key, value, writeOptions) {
+            const header = serializeCookie(encodeCookieName(key), value, { ...withEntryExpiry(cookie, writeOptions?.expiresAt), httpOnly: false });
+            const size = cookiePairSize(header);
+            if (size > maxSize)
+                throw new StorageQuotaError(`Cookie ${key} is ${size} bytes, over the ${maxSize} limit.`, { key });
+            write(key, header);
+        },
+        remove: (key) => write(key, serializeCookie(encodeCookieName(key), '', { ...cookie, httpOnly: false, maxAge: 0, expires: new Date(0) })),
+        has: (key) => all().has(key),
+        keys: () => [...all().keys()],
+        clear() {
+            for (const key of all().keys())
+                this.remove(key);
+        },
+    };
+}

package/dist/browser/document-cookie.mjs

@@ -0,0 +1,80 @@
+// src/browser/document-cookie.ts
+import { parseCookies, serializeCookie } from "@fluixi/utils/cookie";
+
+// src/core/errors.ts
+var StorageError = class extends Error {
+  constructor(code, message, options = {}) {
+    super(message);
+    this.name = new.target.name;
+    this.code = code;
+    this.key = options.key;
+    if (options.cause !== void 0) this.cause = options.cause;
+  }
+};
+var StorageUnavailableError = class extends StorageError {
+  constructor(message, options = {}) {
+    super("unavailable", message, options);
+  }
+};
+var StorageQuotaError = class extends StorageError {
+  constructor(message, options = {}) {
+    super("quota", message, options);
+  }
+};
+
+// src/utils/cookie-names.ts
+var encodeCookieName = (key) => encodeURIComponent(key).replace(/[()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+var decodeCookieName = (name) => {
+  try {
+    return decodeURIComponent(name);
+  } catch {
+    return name;
+  }
+};
+var cookiePairSize = (header) => new TextEncoder().encode(header.slice(0, header.indexOf(";"))).length;
+var withEntryExpiry = (cookie, expiresAt) => expiresAt === void 0 ? cookie : { ...cookie, maxAge: void 0, expires: new Date(expiresAt) };
+
+// src/browser/document-cookie.ts
+function documentCookieAdapter(options = {}) {
+  const { maxSize = 4096, ...cookie } = options;
+  const doc = (key) => {
+    if (typeof document === "undefined") throw new StorageUnavailableError("document.cookie is not available here; on a server use cookieStorage.", { key });
+    return document;
+  };
+  const all = () => {
+    const out = /* @__PURE__ */ new Map();
+    for (const [name, value] of Object.entries(parseCookies(doc().cookie))) out.set(decodeCookieName(name), value);
+    return out;
+  };
+  const write = (key, header) => {
+    doc(key).cookie = header;
+  };
+  return {
+    name: "documentCookie",
+    scope: "cookie",
+    capabilities: {
+      synchronous: true,
+      persistent: true,
+      reactive: false,
+      crossContext: true,
+      expiration: false,
+      transactions: false
+    },
+    get: (key) => all().get(key) ?? null,
+    set(key, value, writeOptions) {
+      const header = serializeCookie(encodeCookieName(key), value, { ...withEntryExpiry(cookie, writeOptions?.expiresAt), httpOnly: false });
+      const size = cookiePairSize(header);
+      if (size > maxSize) throw new StorageQuotaError(`Cookie ${key} is ${size} bytes, over the ${maxSize} limit.`, { key });
+      write(key, header);
+    },
+    remove: (key) => write(key, serializeCookie(encodeCookieName(key), "", { ...cookie, httpOnly: false, maxAge: 0, expires: /* @__PURE__ */ new Date(0) })),
+    has: (key) => all().has(key),
+    keys: () => [...all().keys()],
+    clear() {
+      for (const key of all().keys()) this.remove(key);
+    }
+  };
+}
+export {
+  documentCookieAdapter
+};

package/dist/browser/index.cjs

@@ -0,0 +1,209 @@
+/*! @fluixi/storage v0.1.0-alpha.0 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+"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/browser/index.ts
+var index_exports = {};
+__export(index_exports, {
+  documentCookieAdapter: () => documentCookieAdapter,
+  localStorageAdapter: () => localStorageAdapter,
+  sessionStorageAdapter: () => sessionStorageAdapter
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/errors.ts
+var StorageError = class extends Error {
+  constructor(code, message, options = {}) {
+    super(message);
+    this.name = new.target.name;
+    this.code = code;
+    this.key = options.key;
+    if (options.cause !== void 0) this.cause = options.cause;
+  }
+};
+var StorageUnavailableError = class extends StorageError {
+  constructor(message, options = {}) {
+    super("unavailable", message, options);
+  }
+};
+var StorageQuotaError = class extends StorageError {
+  constructor(message, options = {}) {
+    super("quota", message, options);
+  }
+};
+var StorageSecurityError = class extends StorageError {
+  constructor(message, options = {}) {
+    super("security", message, options);
+  }
+};
+var StorageAdapterError = class extends StorageError {
+  constructor(message, options = {}) {
+    super("adapter", message, options);
+  }
+};
+
+// src/utils/environment.ts
+function hasWindow() {
+  return typeof window !== "undefined";
+}
+
+// src/browser/web-storage.ts
+function mapError(error, area, key) {
+  if (error instanceof StorageError) return error;
+  const name = error?.name;
+  const code = error?.code;
+  if (name === "QuotaExceededError" || name === "NS_ERROR_DOM_QUOTA_REACHED" || code === 22 || code === 1014) {
+    return new StorageQuotaError(`${area} is full${key ? ` writing ${key}` : ""}.`, { key, cause: error });
+  }
+  if (name === "SecurityError") {
+    return new StorageSecurityError(`${area} is blocked by the browser (privacy settings or a sandboxed frame).`, { key, cause: error });
+  }
+  return new StorageAdapterError(`${area} failed${key ? ` on ${key}` : ""}.`, { key, cause: error });
+}
+function webStorage(area, capabilities) {
+  const resolve = (key) => {
+    let storage;
+    try {
+      storage = globalThis[area];
+    } catch (error) {
+      throw mapError(error, area, key);
+    }
+    if (!storage) throw new StorageUnavailableError(`${area} is not available here (a server, a worker, or a browser without it).`, { key });
+    return storage;
+  };
+  const run = (key, fn) => {
+    const storage = resolve(key);
+    try {
+      return fn(storage);
+    } catch (error) {
+      throw mapError(error, area, key);
+    }
+  };
+  return {
+    name: area,
+    scope: area === "localStorage" ? "local" : "session",
+    capabilities,
+    get: (key) => run(key, (s) => s.getItem(key)),
+    set: (key, value) => run(key, (s) => s.setItem(key, value)),
+    remove: (key) => run(key, (s) => s.removeItem(key)),
+    has: (key) => run(key, (s) => s.getItem(key) !== null),
+    keys: () => run(void 0, (s) => {
+      const keys = [];
+      for (let i = 0; i < s.length; i++) {
+        const key = s.key(i);
+        if (key !== null) keys.push(key);
+      }
+      return keys;
+    }),
+    clear: () => run(void 0, (s) => s.clear()),
+    subscribe(listener) {
+      if (!hasWindow()) return () => {
+      };
+      const onStorage = (event) => {
+        let storage;
+        try {
+          storage = resolve();
+        } catch {
+          return;
+        }
+        if (event.storageArea !== storage) return;
+        listener({ key: event.key, value: event.newValue });
+      };
+      window.addEventListener("storage", onStorage);
+      return () => window.removeEventListener("storage", onStorage);
+    }
+  };
+}
+function localStorageAdapter() {
+  return webStorage("localStorage", {
+    synchronous: true,
+    persistent: true,
+    reactive: true,
+    crossContext: true,
+    expiration: false,
+    transactions: false
+  });
+}
+function sessionStorageAdapter() {
+  return webStorage("sessionStorage", {
+    synchronous: true,
+    persistent: false,
+    reactive: false,
+    crossContext: false,
+    expiration: false,
+    transactions: false
+  });
+}
+
+// src/browser/document-cookie.ts
+var import_cookie = require("@fluixi/utils/cookie");
+
+// src/utils/cookie-names.ts
+var encodeCookieName = (key) => encodeURIComponent(key).replace(/[()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+var decodeCookieName = (name) => {
+  try {
+    return decodeURIComponent(name);
+  } catch {
+    return name;
+  }
+};
+var cookiePairSize = (header) => new TextEncoder().encode(header.slice(0, header.indexOf(";"))).length;
+var withEntryExpiry = (cookie, expiresAt) => expiresAt === void 0 ? cookie : { ...cookie, maxAge: void 0, expires: new Date(expiresAt) };
+
+// src/browser/document-cookie.ts
+function documentCookieAdapter(options = {}) {
+  const { maxSize = 4096, ...cookie } = options;
+  const doc = (key) => {
+    if (typeof document === "undefined") throw new StorageUnavailableError("document.cookie is not available here; on a server use cookieStorage.", { key });
+    return document;
+  };
+  const all = () => {
+    const out = /* @__PURE__ */ new Map();
+    for (const [name, value] of Object.entries((0, import_cookie.parseCookies)(doc().cookie))) out.set(decodeCookieName(name), value);
+    return out;
+  };
+  const write = (key, header) => {
+    doc(key).cookie = header;
+  };
+  return {
+    name: "documentCookie",
+    scope: "cookie",
+    capabilities: {
+      synchronous: true,
+      persistent: true,
+      reactive: false,
+      crossContext: true,
+      expiration: false,
+      transactions: false
+    },
+    get: (key) => all().get(key) ?? null,
+    set(key, value, writeOptions) {
+      const header = (0, import_cookie.serializeCookie)(encodeCookieName(key), value, { ...withEntryExpiry(cookie, writeOptions?.expiresAt), httpOnly: false });
+      const size = cookiePairSize(header);
+      if (size > maxSize) throw new StorageQuotaError(`Cookie ${key} is ${size} bytes, over the ${maxSize} limit.`, { key });
+      write(key, header);
+    },
+    remove: (key) => write(key, (0, import_cookie.serializeCookie)(encodeCookieName(key), "", { ...cookie, httpOnly: false, maxAge: 0, expires: /* @__PURE__ */ new Date(0) })),
+    has: (key) => all().has(key),
+    keys: () => [...all().keys()],
+    clear() {
+      for (const key of all().keys()) this.remove(key);
+    }
+  };
+}

package/dist/browser/index.d.ts

@@ -0,0 +1,4 @@
+/** Browser adapters. A separate entry, so a server bundle never loads them. */
+export { localStorageAdapter, sessionStorageAdapter } from './web-storage.js';
+export { documentCookieAdapter, type DocumentCookieOptions } from './document-cookie.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/browser/index.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAC9E,OAAO,EAAE,qBAAqB,EAAE,KAAK,qBAAqB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/browser/index.js

@@ -0,0 +1,3 @@
+/** Browser adapters. A separate entry, so a server bundle never loads them. */
+export { localStorageAdapter, sessionStorageAdapter } from './web-storage.js';
+export { documentCookieAdapter } from './document-cookie.js';