@fluixi/storage 0.1.0-alpha.0

package/dist/serialization/json.cjs

@@ -0,0 +1,83 @@
+"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/serialization/json.ts
+var json_exports = {};
+__export(json_exports, {
+  jsonSerializer: () => jsonSerializer
+});
+module.exports = __toCommonJS(json_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 StorageSerializationError = class extends StorageError {
+  constructor(message, options = {}) {
+    super("serialization", message, options);
+  }
+};
+
+// src/serialization/json.ts
+function assertJson(value, path, seen) {
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+      return;
+    case "number":
+      if (!Number.isFinite(value)) throw new StorageSerializationError(`${path} is ${value}, which JSON cannot hold.`);
+      return;
+    case "object":
+      break;
+    default:
+      throw new StorageSerializationError(`${path} is a ${typeof value}, which JSON cannot hold.`);
+  }
+  if (value === null) return;
+  if (seen.has(value)) throw new StorageSerializationError(`${path} refers back to itself.`);
+  seen.add(value);
+  if (Array.isArray(value)) {
+    value.forEach((item, i) => assertJson(item, `${path}[${i}]`, seen));
+  } else {
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null) {
+      const name = value.constructor?.name ?? "an object with a prototype";
+      throw new StorageSerializationError(`${path} is ${name}, which does not survive JSON. Convert it to plain data first.`);
+    }
+    for (const [key, item] of Object.entries(value)) {
+      if (item === void 0) throw new StorageSerializationError(`${path}.${key} is undefined, which JSON drops. Omit the key or use null.`);
+      assertJson(item, `${path}.${key}`, seen);
+    }
+  }
+  seen.delete(value);
+}
+var jsonSerializer = {
+  serialize(value) {
+    assertJson(value, "value", /* @__PURE__ */ new Set());
+    return JSON.stringify(value);
+  },
+  deserialize(text) {
+    return JSON.parse(text);
+  }
+};

package/dist/serialization/json.d.ts

@@ -0,0 +1,3 @@
+import type { StorageSerializer } from '../core/types.js';
+export declare const jsonSerializer: StorageSerializer;
+//# sourceMappingURL=json.d.ts.map

package/dist/serialization/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/serialization/json.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAkC1D,eAAO,MAAM,cAAc,EAAE,iBAQ5B,CAAC"}

package/dist/serialization/json.js

@@ -0,0 +1,51 @@
+/**
+ * Strict JSON. JSON.stringify drops a function, turns NaN into null and a Date into a string
+ * that reads back as a string, all without a word. This refuses them instead, naming where:
+ * convert first (a Date to its ISO string), and the value reads back as it was written.
+ */
+import { StorageSerializationError } from '../core/errors.js';
+function assertJson(value, path, seen) {
+    switch (typeof value) {
+        case 'string':
+        case 'boolean':
+            return;
+        case 'number':
+            if (!Number.isFinite(value))
+                throw new StorageSerializationError(`${path} is ${value}, which JSON cannot hold.`);
+            return;
+        case 'object':
+            break;
+        default:
+            throw new StorageSerializationError(`${path} is a ${typeof value}, which JSON cannot hold.`);
+    }
+    if (value === null)
+        return;
+    if (seen.has(value))
+        throw new StorageSerializationError(`${path} refers back to itself.`);
+    seen.add(value);
+    if (Array.isArray(value)) {
+        value.forEach((item, i) => assertJson(item, `${path}[${i}]`, seen));
+    }
+    else {
+        const proto = Object.getPrototypeOf(value);
+        if (proto !== Object.prototype && proto !== null) {
+            const name = value.constructor?.name ?? 'an object with a prototype';
+            throw new StorageSerializationError(`${path} is ${name}, which does not survive JSON. Convert it to plain data first.`);
+        }
+        for (const [key, item] of Object.entries(value)) {
+            if (item === undefined)
+                throw new StorageSerializationError(`${path}.${key} is undefined, which JSON drops. Omit the key or use null.`);
+            assertJson(item, `${path}.${key}`, seen);
+        }
+    }
+    seen.delete(value);
+}
+export const jsonSerializer = {
+    serialize(value) {
+        assertJson(value, 'value', new Set());
+        return JSON.stringify(value);
+    },
+    deserialize(text) {
+        return JSON.parse(text);
+    },
+};

package/dist/serialization/json.mjs

@@ -0,0 +1,60 @@
+// 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 StorageSerializationError = class extends StorageError {
+  constructor(message, options = {}) {
+    super("serialization", message, options);
+  }
+};
+
+// src/serialization/json.ts
+function assertJson(value, path, seen) {
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+      return;
+    case "number":
+      if (!Number.isFinite(value)) throw new StorageSerializationError(`${path} is ${value}, which JSON cannot hold.`);
+      return;
+    case "object":
+      break;
+    default:
+      throw new StorageSerializationError(`${path} is a ${typeof value}, which JSON cannot hold.`);
+  }
+  if (value === null) return;
+  if (seen.has(value)) throw new StorageSerializationError(`${path} refers back to itself.`);
+  seen.add(value);
+  if (Array.isArray(value)) {
+    value.forEach((item, i) => assertJson(item, `${path}[${i}]`, seen));
+  } else {
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null) {
+      const name = value.constructor?.name ?? "an object with a prototype";
+      throw new StorageSerializationError(`${path} is ${name}, which does not survive JSON. Convert it to plain data first.`);
+    }
+    for (const [key, item] of Object.entries(value)) {
+      if (item === void 0) throw new StorageSerializationError(`${path}.${key} is undefined, which JSON drops. Omit the key or use null.`);
+      assertJson(item, `${path}.${key}`, seen);
+    }
+  }
+  seen.delete(value);
+}
+var jsonSerializer = {
+  serialize(value) {
+    assertJson(value, "value", /* @__PURE__ */ new Set());
+    return JSON.stringify(value);
+  },
+  deserialize(text) {
+    return JSON.parse(text);
+  }
+};
+export {
+  jsonSerializer
+};

package/dist/serialization/serializer.cjs

@@ -0,0 +1,28 @@
+"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/serialization/serializer.ts
+var serializer_exports = {};
+__export(serializer_exports, {
+  createSerializer: () => createSerializer
+});
+module.exports = __toCommonJS(serializer_exports);
+function createSerializer(serialize, deserialize) {
+  return { serialize, deserialize };
+}

package/dist/serialization/serializer.d.ts

@@ -0,0 +1,4 @@
+import type { StorageSerializer } from '../core/types.js';
+/** A serializer from two functions. */
+export declare function createSerializer(serialize: (value: unknown) => string, deserialize: <T = unknown>(text: string) => T): StorageSerializer;
+//# sourceMappingURL=serializer.d.ts.map

package/dist/serialization/serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../src/serialization/serializer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1D,uCAAuC;AACvC,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,EACrC,WAAW,EAAE,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,KAAK,CAAC,GAC5C,iBAAiB,CAEnB"}

package/dist/serialization/serializer.js

@@ -0,0 +1,4 @@
+/** A serializer from two functions. */
+export function createSerializer(serialize, deserialize) {
+    return { serialize, deserialize };
+}

package/dist/serialization/serializer.mjs

@@ -0,0 +1,7 @@
+// src/serialization/serializer.ts
+function createSerializer(serialize, deserialize) {
+  return { serialize, deserialize };
+}
+export {
+  createSerializer
+};

package/dist/server/contracts.cjs

@@ -0,0 +1,36 @@
+"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/server/contracts.ts
+var contracts_exports = {};
+__export(contracts_exports, {
+  toStorageRequest: () => toStorageRequest,
+  toStorageResponse: () => toStorageResponse
+});
+module.exports = __toCommonJS(contracts_exports);
+function toStorageRequest(request) {
+  if ("getHeader" in request) return request;
+  const headers = "headers" in request ? request.headers : request;
+  return { getHeader: (name) => headers.get(name) };
+}
+function toStorageResponse(response) {
+  if ("appendHeader" in response) return response;
+  const headers = "headers" in response ? response.headers : response;
+  return { appendHeader: (name, value) => headers.append(name, value) };
+}

package/dist/server/contracts.d.ts

@@ -0,0 +1,27 @@
+/**
+ * What a server adapter needs from the request and the response. Any framework fits: a fetch
+ * `Request` and `Headers` are accepted as they are, anything else adapts in one line.
+ */
+export interface StorageRequest {
+    getHeader(name: string): string | null | undefined;
+}
+export interface StorageResponse {
+    /** Adds a header value without replacing earlier ones (one `Set-Cookie` per cookie). */
+    appendHeader(name: string, value: string): void;
+}
+interface HeadersLike {
+    get(name: string): string | null;
+}
+interface MutableHeadersLike {
+    append(name: string, value: string): void;
+}
+export type RequestLike = StorageRequest | HeadersLike | {
+    headers: HeadersLike;
+};
+export type ResponseLike = StorageResponse | MutableHeadersLike | {
+    headers: MutableHeadersLike;
+};
+export declare function toStorageRequest(request: RequestLike): StorageRequest;
+export declare function toStorageResponse(response: ResponseLike): StorageResponse;
+export {};
+//# sourceMappingURL=contracts.d.ts.map

package/dist/server/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../src/server/contracts.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,cAAc;IAC7B,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACpD;AAED,MAAM,WAAW,eAAe;IAC9B,wFAAwF;IACxF,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACjD;AAED,UAAU,WAAW;IACnB,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;CAClC;AACD,UAAU,kBAAkB;IAC1B,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3C;AAED,MAAM,MAAM,WAAW,GAAG,cAAc,GAAG,WAAW,GAAG;IAAE,OAAO,EAAE,WAAW,CAAA;CAAE,CAAC;AAClF,MAAM,MAAM,YAAY,GAAG,eAAe,GAAG,kBAAkB,GAAG;IAAE,OAAO,EAAE,kBAAkB,CAAA;CAAE,CAAC;AAElG,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc,CAIrE;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,YAAY,GAAG,eAAe,CAIzE"}

package/dist/server/contracts.js

@@ -0,0 +1,16 @@
+/**
+ * What a server adapter needs from the request and the response. Any framework fits: a fetch
+ * `Request` and `Headers` are accepted as they are, anything else adapts in one line.
+ */
+export function toStorageRequest(request) {
+    if ('getHeader' in request)
+        return request;
+    const headers = 'headers' in request ? request.headers : request;
+    return { getHeader: (name) => headers.get(name) };
+}
+export function toStorageResponse(response) {
+    if ('appendHeader' in response)
+        return response;
+    const headers = 'headers' in response ? response.headers : response;
+    return { appendHeader: (name, value) => headers.append(name, value) };
+}

package/dist/server/contracts.mjs

@@ -0,0 +1,15 @@
+// src/server/contracts.ts
+function toStorageRequest(request) {
+  if ("getHeader" in request) return request;
+  const headers = "headers" in request ? request.headers : request;
+  return { getHeader: (name) => headers.get(name) };
+}
+function toStorageResponse(response) {
+  if ("appendHeader" in response) return response;
+  const headers = "headers" in response ? response.headers : response;
+  return { appendHeader: (name, value) => headers.append(name, value) };
+}
+export {
+  toStorageRequest,
+  toStorageResponse
+};

package/dist/server/cookie.cjs

@@ -0,0 +1,126 @@
+"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/server/cookie.ts
+var cookie_exports = {};
+__export(cookie_exports, {
+  cookieStorage: () => cookieStorage
+});
+module.exports = __toCommonJS(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/server/contracts.ts
+function toStorageRequest(request) {
+  if ("getHeader" in request) return request;
+  const headers = "headers" in request ? request.headers : request;
+  return { getHeader: (name) => headers.get(name) };
+}
+function toStorageResponse(response) {
+  if ("appendHeader" in response) return response;
+  const headers = "headers" in response ? response.headers : response;
+  return { appendHeader: (name, value) => headers.append(name, value) };
+}
+
+// src/server/cookie.ts
+function cookieStorage(options = {}) {
+  const { request, response, maxSize = 4096, ...cookie } = options;
+  const reader = request ? toStorageRequest(request) : null;
+  const writer = response ? toStorageResponse(response) : null;
+  let incoming = null;
+  const written = /* @__PURE__ */ new Map();
+  const read = () => {
+    if (!incoming) {
+      incoming = /* @__PURE__ */ new Map();
+      for (const [name, value] of Object.entries((0, import_cookie.parseCookies)(reader?.getHeader("cookie")))) incoming.set(decodeCookieName(name), value);
+    }
+    return incoming;
+  };
+  const emit = (key, header) => {
+    if (!writer) throw new StorageUnavailableError("This cookie storage has no response to write to.", { key });
+    writer.appendHeader("set-cookie", header);
+  };
+  const get = (key) => written.has(key) ? written.get(key) : read().get(key) ?? null;
+  const keys = () => {
+    const all = new Set(read().keys());
+    for (const [key, value] of written) value === null ? all.delete(key) : all.add(key);
+    return [...all];
+  };
+  const remove = (key) => {
+    if (get(key) === null) return;
+    emit(key, (0, import_cookie.serializeCookie)(encodeCookieName(key), "", { ...cookie, maxAge: 0, expires: /* @__PURE__ */ new Date(0) }));
+    written.set(key, null);
+  };
+  return {
+    name: "cookie",
+    scope: "cookie",
+    capabilities: {
+      synchronous: true,
+      persistent: true,
+      reactive: false,
+      crossContext: true,
+      expiration: false,
+      transactions: false
+    },
+    get,
+    set(key, value, writeOptions) {
+      const header = (0, import_cookie.serializeCookie)(encodeCookieName(key), value, withEntryExpiry(cookie, writeOptions?.expiresAt));
+      const size = cookiePairSize(header);
+      if (size > maxSize) throw new StorageQuotaError(`Cookie ${key} is ${size} bytes, over the ${maxSize} limit.`, { key });
+      emit(key, header);
+      written.set(key, value);
+    },
+    remove,
+    has: (key) => get(key) !== null,
+    keys,
+    clear: () => keys().forEach(remove)
+  };
+}

package/dist/server/cookie.d.ts

@@ -0,0 +1,21 @@
+import { type CookieOptions } from '@fluixi/utils/cookie';
+import type { StorageAdapter } from '../core/types.js';
+import { type RequestLike, type ResponseLike } from './contracts.js';
+export interface CookieStorageOptions extends CookieOptions {
+    /** Where the cookies are read from. Without it the adapter starts empty. */
+    request?: RequestLike;
+    /** Where `Set-Cookie` headers go. Without it the adapter is read-only. */
+    response?: ResponseLike;
+    /** Largest `name=value` in bytes. Browsers keep about 4096. */
+    maxSize?: number;
+}
+/**
+ * Cookies of one request. Reads come from the request's `Cookie` header plus this adapter's own
+ * writes; each write appends a `Set-Cookie` to the response. Make one per request.
+ *
+ * Every cookie the request carries is visible, so give the storage a namespace: `clear()` on a
+ * storage without one deletes the session cookie too. Expiry set through the storage lives in the
+ * value and also sets the cookie's Expires; without one the cookie lasts as `maxAge`/`expires` say.
+ */
+export declare function cookieStorage(options?: CookieStorageOptions): StorageAdapter;
+//# sourceMappingURL=cookie.d.ts.map

package/dist/server/cookie.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cookie.d.ts","sourceRoot":"","sources":["../../src/server/cookie.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiC,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAEzF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,EAAuC,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE1G,MAAM,WAAW,oBAAqB,SAAQ,aAAa;IACzD,4EAA4E;IAC5E,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,oBAAyB,GAAG,cAAc,CAuDhF"}

package/dist/server/cookie.js

@@ -0,0 +1,71 @@
+import { parseCookies, serializeCookie } from '@fluixi/utils/cookie';
+import { StorageQuotaError, StorageUnavailableError } from '../core/errors.js';
+import { cookiePairSize, decodeCookieName as decodeName, encodeCookieName as encodeName, withEntryExpiry } from '../utils/cookie-names.js';
+import { toStorageRequest, toStorageResponse } from './contracts.js';
+/**
+ * Cookies of one request. Reads come from the request's `Cookie` header plus this adapter's own
+ * writes; each write appends a `Set-Cookie` to the response. Make one per request.
+ *
+ * Every cookie the request carries is visible, so give the storage a namespace: `clear()` on a
+ * storage without one deletes the session cookie too. Expiry set through the storage lives in the
+ * value and also sets the cookie's Expires; without one the cookie lasts as `maxAge`/`expires` say.
+ */
+export function cookieStorage(options = {}) {
+    const { request, response, maxSize = 4096, ...cookie } = options;
+    const reader = request ? toStorageRequest(request) : null;
+    const writer = response ? toStorageResponse(response) : null;
+    let incoming = null;
+    // This request's writes: a value, or null once removed.
+    const written = new Map();
+    const read = () => {
+        if (!incoming) {
+            incoming = new Map();
+            for (const [name, value] of Object.entries(parseCookies(reader?.getHeader('cookie'))))
+                incoming.set(decodeName(name), value);
+        }
+        return incoming;
+    };
+    const emit = (key, header) => {
+        if (!writer)
+            throw new StorageUnavailableError('This cookie storage has no response to write to.', { key });
+        writer.appendHeader('set-cookie', header);
+    };
+    const get = (key) => (written.has(key) ? written.get(key) : read().get(key) ?? null);
+    const keys = () => {
+        const all = new Set(read().keys());
+        for (const [key, value] of written)
+            value === null ? all.delete(key) : all.add(key);
+        return [...all];
+    };
+    const remove = (key) => {
+        if (get(key) === null)
+            return;
+        emit(key, serializeCookie(encodeName(key), '', { ...cookie, maxAge: 0, expires: new Date(0) }));
+        written.set(key, null);
+    };
+    return {
+        name: 'cookie',
+        scope: 'cookie',
+        capabilities: {
+            synchronous: true,
+            persistent: true,
+            reactive: false,
+            crossContext: true,
+            expiration: false,
+            transactions: false,
+        },
+        get,
+        set(key, value, writeOptions) {
+            const header = serializeCookie(encodeName(key), value, withEntryExpiry(cookie, writeOptions?.expiresAt));
+            const size = cookiePairSize(header);
+            if (size > maxSize)
+                throw new StorageQuotaError(`Cookie ${key} is ${size} bytes, over the ${maxSize} limit.`, { key });
+            emit(key, header);
+            written.set(key, value);
+        },
+        remove,
+        has: (key) => get(key) !== null,
+        keys,
+        clear: () => keys().forEach(remove),
+    };
+}