@fedify/netlify 2.4.0-pr.1020.43 → 2.4.0

package/README.md

@@ -1,7 +1,7 @@
 <!-- deno-fmt-ignore-file -->
 
-@fedify/netlify: Run Fedify queues with Netlify Async Workloads
-===============================================================
+@fedify/netlify: Run Fedify with Netlify blobs and async workloads
+==================================================================
 
 [![JSR][JSR badge]][JSR]
 [![npm][npm badge]][npm]
@@ -9,10 +9,11 @@
 
 *This package is available since Fedify 2.4.0.*
 
-This package connects [Fedify]'s [`MessageQueue`] API to
-[Netlify Async Workloads].  `NetlifyMessageQueue` publishes durable events,
-while `createNetlifyQueueHandler()` turns a Netlify Function into their
-consumer.
+This package connects [Fedify]'s [`KvStore`] and [`MessageQueue`] APIs to
+Netlify.  `NetlifyBlobsKvStore` stores federation state in [Netlify Blobs],
+`NetlifyMessageQueue` publishes durable events through
+[Netlify Async Workloads], and `createNetlifyQueueHandler()` turns a Netlify
+Function into their consumer.
 
 The initial release targets Netlify Functions, not Netlify Edge Functions.
 
@@ -23,13 +24,17 @@ The initial release targets Netlify Functions, not Netlify Edge Functions.
 [@fedify@hackers.pub badge]: https://fedi-badge.minhee.org/@fedify@hackers.pub/followers.svg
 [@fedify@hackers.pub]: https://hackers.pub/@fedify
 [Fedify]: https://fedify.dev/
+[`KvStore`]: https://jsr.io/@fedify/fedify/doc/federation/~/KvStore
 [`MessageQueue`]: https://jsr.io/@fedify/fedify/doc/federation/~/MessageQueue
+[Netlify Blobs]: https://docs.netlify.com/build/data-and-storage/netlify-blobs/
 [Netlify Async Workloads]: https://docs.netlify.com/build/async-workloads/get-started/
 
 
 Installation
 ------------
 
+For queue-only usage, install the package with Netlify Async Workloads:
+
 ~~~~ sh
 deno add jsr:@fedify/netlify npm:@netlify/async-workloads  # Deno
 npm  add     @fedify/netlify @netlify/async-workloads     # npm
@@ -38,8 +43,62 @@ yarn add     @fedify/netlify @netlify/async-workloads     # Yarn
 bun  add     @fedify/netlify @netlify/async-workloads     # Bun
 ~~~~
 
-The PostgreSQL-backed `orderingKv` example below also needs
-`@fedify/postgres`, `@netlify/database`, and `postgres`:
+
+Usage
+-----
+
+To use `NetlifyBlobsKvStore`, also install Netlify Blobs:
+
+~~~~ sh
+deno add npm:@netlify/blobs  # Deno
+npm  add     @netlify/blobs  # npm
+pnpm add     @netlify/blobs  # pnpm
+yarn add     @netlify/blobs  # Yarn
+bun  add     @netlify/blobs  # Bun
+~~~~
+
+Create one store and queue for both the web application and the workload
+function.  `NetlifyBlobsKvStore` provides the compare-and-set (CAS) support
+required when Fedify emits messages with an `orderingKey`, without requiring a
+separate database:
+
+~~~~ typescript
+import { AsyncWorkloadsClient } from "@netlify/async-workloads";
+import { getStore } from "@netlify/blobs";
+import {
+  NetlifyBlobsKvStore,
+  NetlifyMessageQueue,
+} from "@fedify/netlify";
+
+export const kv = new NetlifyBlobsKvStore(getStore({
+  name: "fedify",
+  consistency: "strong",
+}));
+export const queue = new NetlifyMessageQueue({
+  client: new AsyncWorkloadsClient(),
+  orderingKv: kv,
+});
+~~~~
+
+CAS operations always use strong reads and conditional writes.  The
+`consistency: "strong"` setting above also gives ordinary `get()` calls and
+listings strong consistency.  You can omit it when lower-latency, eventually
+consistent ordinary reads are acceptable.
+
+TTL expiration is logical: expired blobs remain in Netlify Blobs but are
+hidden by `get()` and `list()`.  CAS deletion similarly writes a tombstone so
+that a concurrent writer cannot recreate the key undetected.  Tombstones are
+also hidden and can be replaced by a later CAS operation, but they are not
+removed automatically.  Use a dedicated Netlify Blobs store and account for
+these retained blobs.  Only remove them during maintenance when concurrent CAS
+operations for those keys have stopped; physical deletion during a race would
+remove the version token that protects the key.
+
+### PostgreSQL alternative
+
+If the application already uses PostgreSQL, `PostgresKvStore` can provide the
+same CAS-capable ordering storage.  Install `@fedify/postgres`,
+`@netlify/database`, and `postgres` in addition to the base dependencies:
 
 ~~~~ sh
 deno add jsr:@fedify/postgres npm:@netlify/database npm:postgres  # Deno
@@ -49,29 +108,20 @@ yarn add     @fedify/postgres @netlify/database postgres          # Yarn
 bun  add     @fedify/postgres @netlify/database postgres          # Bun
 ~~~~
 
-
-Usage
------
-
-Create one queue for both the web application and the workload function.  A
-CAS-capable `KvStore`, such as `PostgresKvStore`, is required if Fedify emits
-messages with an `orderingKey`:
+Then replace the `kv` declaration from the main example:
 
 ~~~~ typescript
-import { AsyncWorkloadsClient } from "@netlify/async-workloads";
 import { getConnectionString } from "@netlify/database";
-import { NetlifyMessageQueue } from "@fedify/netlify";
 import { PostgresKvStore } from "@fedify/postgres";
 import postgres from "postgres";
 
 const sql = postgres(getConnectionString());
 export const kv = new PostgresKvStore(sql);
-export const queue = new NetlifyMessageQueue({
-  client: new AsyncWorkloadsClient(),
-  orderingKv: kv,
-});
 ~~~~
 
+Ordering state must use crash-safe storage.  `PostgresKvStore` creates a logged
+table by default; do not pass `unlogged: true` for `orderingKv`.
+
 Pass the queue to Fedify with `manuallyStartQueue: true`.  Async Workloads
 invokes the consumer, so `NetlifyMessageQueue.listen()` is intentionally not
 available:
@@ -142,9 +192,6 @@ because a lost response does not prove that the router rejected the event.
 Use the error's `orderingKey` and `orderingSequence` for manual recovery only
 after ruling out delivery.
 
-Ordering state must use crash-safe storage.  `PostgresKvStore` creates a logged
-table by default; do not pass `unlogged: true` for `orderingKv`.
-
 Netlify limits an event payload to 500 KB.  Fedify messages, including any
 embedded activity, must remain below that limit.
 
@@ -156,7 +203,7 @@ Fedify rejects a multi-message `enqueueTaskMany()` call with one
 batch enqueue so a failed partial send cannot produce duplicates on retry.
 
 See the [deployment manual] and the [Netlify Astro example] for a complete
-setup with Netlify Database.
+setup using the PostgreSQL alternative with Netlify Database.
 
 [deployment manual]: https://fedify.dev/manual/deploy#netlify-functions
 [Netlify Astro example]: https://github.com/fedify-dev/fedify/tree/main/examples/netlify-astro

package/dist/mod.cjs

@@ -1,6 +1,8 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let _netlify_async_workloads = require("@netlify/async-workloads");
+let byte_encodings_base64url = require("byte-encodings/base64url");
+let es_toolkit = require("es-toolkit");
 //#region ../../node_modules/.pnpm/temporal-polyfill@1.0.1/node_modules/temporal-polyfill/chunks/root.js
 const NativeTemporal = globalThis.Temporal;
 //#endregion
@@ -3546,7 +3548,7 @@ const Now = /*@__PURE__*/ Object.defineProperties({}, {
 		}
 	})
 });
-const Temporal$2 = /*@__PURE__*/ Object.defineProperties({}, {
+const Temporal$3 = /*@__PURE__*/ Object.defineProperties({}, {
 	...createStringTagDescriptors("Temporal"),
 	...createPropDescriptors({
 		PlainYearMonth,
@@ -3562,13 +3564,13 @@ const Temporal$2 = /*@__PURE__*/ Object.defineProperties({}, {
 });
 //#endregion
 //#region ../../node_modules/.pnpm/temporal-polyfill@1.0.1/node_modules/temporal-polyfill/index.js
-const Temporal$1 = NativeTemporal || Temporal$2;
+const Temporal$2 = NativeTemporal || Temporal$3;
 NativeTemporal && Date.prototype.toTemporalInstant;
 //#endregion
 //#region src/mq.ts
-const Temporal = Temporal$1;
+const Temporal$1 = Temporal$2;
 const defaultEventName = "fedify:queue";
-const defaultOrderingRetryDelay = Temporal.Duration.from({ seconds: 5 });
+const defaultOrderingRetryDelay = Temporal$1.Duration.from({ seconds: 5 });
 /**
 * An error raised when an event send is not acknowledged.
 *
@@ -3597,7 +3599,7 @@ var NetlifyMessageQueueSendError = class extends Error {
 };
 const orderingOptions = /* @__PURE__ */ new WeakMap();
 function duration(value, defaultValue, name) {
-	const result = value == null ? defaultValue : Temporal.Duration.from(value);
+	const result = value == null ? defaultValue : Temporal$1.Duration.from(value);
 	const milliseconds = result.total("milliseconds");
 	if (!Number.isFinite(milliseconds) || milliseconds <= 0) throw new RangeError(`${name} must be a positive finite duration.`);
 	return result;
@@ -3884,6 +3886,117 @@ function createNetlifyQueueHandler(options) {
 	return createNetlifyQueueHandlerWith(_netlify_async_workloads.asyncWorkloadFn, options);
 }
 //#endregion
+//#region src/kv.ts
+const Temporal = Temporal$2;
+const MAX_BLOB_KEY_BYTES = 600;
+const BLOB_KEY_PREFIX = "fedify1.";
+const BLOB_KEY_SEPARATOR = ".";
+const textDecoder = new TextDecoder();
+/**
+* A key-value store that uses Netlify Blobs.
+*
+* @since 2.4.0
+*/
+var NetlifyBlobsKvStore = class {
+	#store;
+	/**
+	* Creates a new Netlify Blobs-backed key-value store.
+	* @param store The Netlify Blobs store to use.
+	*/
+	constructor(store) {
+		this.#store = store;
+	}
+	serializeKey(key) {
+		const serialized = BLOB_KEY_PREFIX + key.map((part) => (0, byte_encodings_base64url.encodeBase64Url)(part)).join(BLOB_KEY_SEPARATOR) + BLOB_KEY_SEPARATOR;
+		if (new TextEncoder().encode(serialized).byteLength > MAX_BLOB_KEY_BYTES) throw new RangeError("The encoded key exceeds Netlify Blobs' 600-byte key limit.");
+		return serialized;
+	}
+	deserializeKey(key) {
+		return key.slice(8, -1).split(BLOB_KEY_SEPARATOR).map((part) => textDecoder.decode((0, byte_encodings_base64url.decodeBase64Url)(part)));
+	}
+	serializePrefix(prefix) {
+		return prefix == null ? BLOB_KEY_PREFIX : this.serializeKey(prefix);
+	}
+	isAbsent(metadata) {
+		if (metadata.tombstone === true) return true;
+		const expireIn = metadata.expireIn;
+		return typeof expireIn === "number" && expireIn <= Temporal.Now.instant().epochMilliseconds;
+	}
+	getEtag(entry) {
+		if (entry?.etag == null) throw new Error("Netlify Blobs did not return an ETag.");
+		return entry.etag;
+	}
+	/**
+	* {@inheritDoc KvStore.get}
+	*/
+	async get(key) {
+		const result = await this.#store.getWithMetadata(this.serializeKey(key), { type: "json" });
+		if (result === null || this.isAbsent(result.metadata)) return void 0;
+		return result.data;
+	}
+	/**
+	* {@inheritDoc KvStore.set}
+	*/
+	async set(key, value, options) {
+		const expireIn = options?.ttl == null ? null : Temporal.Now.instant().epochMilliseconds + options.ttl.total("millisecond");
+		await this.#store.setJSON(this.serializeKey(key), value, { metadata: { "expireIn": expireIn } });
+	}
+	/**
+	* {@inheritDoc KvStore.delete}
+	*/
+	delete(key) {
+		return this.#store.delete(this.serializeKey(key));
+	}
+	/**
+	* {@inheritDoc KvStore.list}
+	*/
+	async *list(prefix) {
+		const pages = this.#store.list({
+			paginate: true,
+			prefix: this.serializePrefix(prefix)
+		});
+		for await (const page of pages) for (const blob of page.blobs) {
+			const key = this.deserializeKey(blob.key);
+			const value = await this.get(key);
+			if (value === void 0) continue;
+			yield {
+				key,
+				value
+			};
+		}
+	}
+	/**
+	* {@inheritDoc KvStore.cas}
+	*/
+	async cas(key, expectedValue, newValue, options) {
+		while (true) {
+			const entry = await this.#store.getWithMetadata(this.serializeKey(key), {
+				consistency: "strong",
+				type: "json"
+			});
+			if (!(0, es_toolkit.isEqual)(entry === null || this.isAbsent(entry.metadata) ? void 0 : entry.data, expectedValue)) return false;
+			if (entry === null && newValue === void 0) return true;
+			const serializedKey = this.serializeKey(key);
+			if (newValue === void 0) {
+				if ((await this.#store.setJSON(serializedKey, null, {
+					onlyIfMatch: this.getEtag(entry),
+					metadata: { tombstone: true }
+				})).modified) return true;
+				continue;
+			}
+			const metadata = { "expireIn": options?.ttl == null ? null : Temporal.Now.instant().epochMilliseconds + options.ttl.total("millisecond") };
+			if ((entry === null ? await this.#store.setJSON(serializedKey, newValue, {
+				onlyIfNew: true,
+				metadata
+			}) : await this.#store.setJSON(serializedKey, newValue, {
+				onlyIfMatch: this.getEtag(entry),
+				metadata
+			})).modified) return true;
+		}
+	}
+};
+//#endregion
+exports.NetlifyBlobsKvStore = NetlifyBlobsKvStore;
 exports.NetlifyMessageQueue = NetlifyMessageQueue;
 exports.NetlifyMessageQueueSendError = NetlifyMessageQueueSendError;
 exports.createNetlifyQueueHandler = createNetlifyQueueHandler;

package/dist/mod.d.cts

@@ -1,9 +1,49 @@
 /// <reference lib="esnext.temporal" />
-import { Federation, KvStore, Message, MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions } from "@fedify/fedify/federation";
+import { Federation, KvKey, KvStore, KvStoreListEntry, KvStoreSetOptions, Message, MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions } from "@fedify/fedify/federation";
 import { AsyncWorkloadEvent, CustomAsyncWorkloadEvent, asyncWorkloadFn } from "@netlify/async-workloads";
 
 //#region src/types.d.ts
 /**
+* The subset of Netlify's Blobs `Store` used by this package.
+*
+* The real Netlify Blobs `Store` satisfies this interface.  The narrower
+* interface also keeps Netlify Blobs optional and makes it possible to supply
+* a test double.
+*
+* @since 2.4.0
+*/
+interface NetlifyBlobsStore {
+  getWithMetadata(key: string, options: {
+    readonly consistency?: "eventual" | "strong";
+    readonly type: "json";
+  }): Promise<{
+    readonly data: unknown;
+    readonly etag?: string;
+    readonly metadata: Record<string, unknown>;
+  } | null>;
+  setJSON(key: string, data: unknown, options?: {
+    readonly metadata?: Record<string, unknown>;
+  } & ({
+    readonly onlyIfNew?: boolean;
+    readonly onlyIfMatch?: never;
+  } | {
+    readonly onlyIfMatch?: string;
+    readonly onlyIfNew?: never;
+  })): Promise<{
+    readonly etag?: string;
+    readonly modified: boolean;
+  }>;
+  delete(key: string): Promise<void>;
+  list(options: {
+    readonly paginate: true;
+    readonly prefix?: string;
+  }): AsyncIterable<{
+    readonly blobs: readonly {
+      readonly key: string;
+    }[];
+  }>;
+}
+/**
 * The subset of Netlify's `AsyncWorkloadsClient` used by this package.
 *
 * The real `AsyncWorkloadsClient` satisfies this interface.  The narrower
@@ -176,4 +216,44 @@ type WorkloadFunction = ReturnType<typeof asyncWorkloadFn<NetlifyQueueEvent>>;
 */
 declare function createNetlifyQueueHandler<TContextData>(options: NetlifyQueueHandlerOptions<TContextData>): WorkloadFunction;
 //#endregion
-export { type NetlifyAsyncWorkloadsClient, NetlifyMessageQueue, type NetlifyMessageQueueOptions, NetlifyMessageQueueSendError, type NetlifyQueueEvent, type NetlifyQueueEventData, type NetlifyQueueHandlerOptions, createNetlifyQueueHandler };
+//#region src/kv.d.ts
+/**
+* A key-value store that uses Netlify Blobs.
+*
+* @since 2.4.0
+*/
+declare class NetlifyBlobsKvStore implements KvStore {
+  #private;
+  /**
+  * Creates a new Netlify Blobs-backed key-value store.
+  * @param store The Netlify Blobs store to use.
+  */
+  constructor(store: NetlifyBlobsStore);
+  private serializeKey;
+  private deserializeKey;
+  private serializePrefix;
+  private isAbsent;
+  private getEtag;
+  /**
+  * {@inheritDoc KvStore.get}
+  */
+  get<T = unknown>(key: KvKey): Promise<T | undefined>;
+  /**
+  * {@inheritDoc KvStore.set}
+  */
+  set(key: KvKey, value: unknown, options?: KvStoreSetOptions | undefined): Promise<void>;
+  /**
+  * {@inheritDoc KvStore.delete}
+  */
+  delete(key: KvKey): Promise<void>;
+  /**
+  * {@inheritDoc KvStore.list}
+  */
+  list(prefix?: KvKey): AsyncIterable<KvStoreListEntry>;
+  /**
+  * {@inheritDoc KvStore.cas}
+  */
+  cas(key: KvKey, expectedValue: unknown, newValue: unknown, options?: KvStoreSetOptions): Promise<boolean>;
+}
+//#endregion
+export { type NetlifyAsyncWorkloadsClient, NetlifyBlobsKvStore, type NetlifyBlobsStore, NetlifyMessageQueue, type NetlifyMessageQueueOptions, NetlifyMessageQueueSendError, type NetlifyQueueEvent, type NetlifyQueueEventData, type NetlifyQueueHandlerOptions, createNetlifyQueueHandler };

package/dist/mod.d.ts

@@ -1,9 +1,49 @@
 /// <reference lib="esnext.temporal" />
 import { AsyncWorkloadEvent, CustomAsyncWorkloadEvent, asyncWorkloadFn } from "@netlify/async-workloads";
-import { Federation, KvStore, Message, MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions } from "@fedify/fedify/federation";
+import { Federation, KvKey, KvStore, KvStoreListEntry, KvStoreSetOptions, Message, MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions } from "@fedify/fedify/federation";
 
 //#region src/types.d.ts
 /**
+* The subset of Netlify's Blobs `Store` used by this package.
+*
+* The real Netlify Blobs `Store` satisfies this interface.  The narrower
+* interface also keeps Netlify Blobs optional and makes it possible to supply
+* a test double.
+*
+* @since 2.4.0
+*/
+interface NetlifyBlobsStore {
+  getWithMetadata(key: string, options: {
+    readonly consistency?: "eventual" | "strong";
+    readonly type: "json";
+  }): Promise<{
+    readonly data: unknown;
+    readonly etag?: string;
+    readonly metadata: Record<string, unknown>;
+  } | null>;
+  setJSON(key: string, data: unknown, options?: {
+    readonly metadata?: Record<string, unknown>;
+  } & ({
+    readonly onlyIfNew?: boolean;
+    readonly onlyIfMatch?: never;
+  } | {
+    readonly onlyIfMatch?: string;
+    readonly onlyIfNew?: never;
+  })): Promise<{
+    readonly etag?: string;
+    readonly modified: boolean;
+  }>;
+  delete(key: string): Promise<void>;
+  list(options: {
+    readonly paginate: true;
+    readonly prefix?: string;
+  }): AsyncIterable<{
+    readonly blobs: readonly {
+      readonly key: string;
+    }[];
+  }>;
+}
+/**
 * The subset of Netlify's `AsyncWorkloadsClient` used by this package.
 *
 * The real `AsyncWorkloadsClient` satisfies this interface.  The narrower
@@ -176,4 +216,44 @@ type WorkloadFunction = ReturnType<typeof asyncWorkloadFn<NetlifyQueueEvent>>;
 */
 declare function createNetlifyQueueHandler<TContextData>(options: NetlifyQueueHandlerOptions<TContextData>): WorkloadFunction;
 //#endregion
-export { type NetlifyAsyncWorkloadsClient, NetlifyMessageQueue, type NetlifyMessageQueueOptions, NetlifyMessageQueueSendError, type NetlifyQueueEvent, type NetlifyQueueEventData, type NetlifyQueueHandlerOptions, createNetlifyQueueHandler };
+//#region src/kv.d.ts
+/**
+* A key-value store that uses Netlify Blobs.
+*
+* @since 2.4.0
+*/
+declare class NetlifyBlobsKvStore implements KvStore {
+  #private;
+  /**
+  * Creates a new Netlify Blobs-backed key-value store.
+  * @param store The Netlify Blobs store to use.
+  */
+  constructor(store: NetlifyBlobsStore);
+  private serializeKey;
+  private deserializeKey;
+  private serializePrefix;
+  private isAbsent;
+  private getEtag;
+  /**
+  * {@inheritDoc KvStore.get}
+  */
+  get<T = unknown>(key: KvKey): Promise<T | undefined>;
+  /**
+  * {@inheritDoc KvStore.set}
+  */
+  set(key: KvKey, value: unknown, options?: KvStoreSetOptions | undefined): Promise<void>;
+  /**
+  * {@inheritDoc KvStore.delete}
+  */
+  delete(key: KvKey): Promise<void>;
+  /**
+  * {@inheritDoc KvStore.list}
+  */
+  list(prefix?: KvKey): AsyncIterable<KvStoreListEntry>;
+  /**
+  * {@inheritDoc KvStore.cas}
+  */
+  cas(key: KvKey, expectedValue: unknown, newValue: unknown, options?: KvStoreSetOptions): Promise<boolean>;
+}
+//#endregion
+export { type NetlifyAsyncWorkloadsClient, NetlifyBlobsKvStore, type NetlifyBlobsStore, NetlifyMessageQueue, type NetlifyMessageQueueOptions, NetlifyMessageQueueSendError, type NetlifyQueueEvent, type NetlifyQueueEventData, type NetlifyQueueHandlerOptions, createNetlifyQueueHandler };

package/dist/mod.js

@@ -1,5 +1,7 @@
 import { Temporal } from "temporal-polyfill";
 import { ErrorDoNotRetry, asyncWorkloadFn } from "@netlify/async-workloads";
+import { decodeBase64Url, encodeBase64Url } from "byte-encodings/base64url";
+import { isEqual } from "es-toolkit";
 //#region src/mq.ts
 const defaultEventName = "fedify:queue";
 const defaultOrderingRetryDelay = Temporal.Duration.from({ seconds: 5 });
@@ -318,4 +320,113 @@ function createNetlifyQueueHandler(options) {
 	return createNetlifyQueueHandlerWith(asyncWorkloadFn, options);
 }
 //#endregion
-export { NetlifyMessageQueue, NetlifyMessageQueueSendError, createNetlifyQueueHandler };
+//#region src/kv.ts
+const MAX_BLOB_KEY_BYTES = 600;
+const BLOB_KEY_PREFIX = "fedify1.";
+const BLOB_KEY_SEPARATOR = ".";
+const textDecoder = new TextDecoder();
+/**
+* A key-value store that uses Netlify Blobs.
+*
+* @since 2.4.0
+*/
+var NetlifyBlobsKvStore = class {
+	#store;
+	/**
+	* Creates a new Netlify Blobs-backed key-value store.
+	* @param store The Netlify Blobs store to use.
+	*/
+	constructor(store) {
+		this.#store = store;
+	}
+	serializeKey(key) {
+		const serialized = BLOB_KEY_PREFIX + key.map((part) => encodeBase64Url(part)).join(BLOB_KEY_SEPARATOR) + BLOB_KEY_SEPARATOR;
+		if (new TextEncoder().encode(serialized).byteLength > MAX_BLOB_KEY_BYTES) throw new RangeError("The encoded key exceeds Netlify Blobs' 600-byte key limit.");
+		return serialized;
+	}
+	deserializeKey(key) {
+		return key.slice(8, -1).split(BLOB_KEY_SEPARATOR).map((part) => textDecoder.decode(decodeBase64Url(part)));
+	}
+	serializePrefix(prefix) {
+		return prefix == null ? BLOB_KEY_PREFIX : this.serializeKey(prefix);
+	}
+	isAbsent(metadata) {
+		if (metadata.tombstone === true) return true;
+		const expireIn = metadata.expireIn;
+		return typeof expireIn === "number" && expireIn <= Temporal.Now.instant().epochMilliseconds;
+	}
+	getEtag(entry) {
+		if (entry?.etag == null) throw new Error("Netlify Blobs did not return an ETag.");
+		return entry.etag;
+	}
+	/**
+	* {@inheritDoc KvStore.get}
+	*/
+	async get(key) {
+		const result = await this.#store.getWithMetadata(this.serializeKey(key), { type: "json" });
+		if (result === null || this.isAbsent(result.metadata)) return void 0;
+		return result.data;
+	}
+	/**
+	* {@inheritDoc KvStore.set}
+	*/
+	async set(key, value, options) {
+		const expireIn = options?.ttl == null ? null : Temporal.Now.instant().epochMilliseconds + options.ttl.total("millisecond");
+		await this.#store.setJSON(this.serializeKey(key), value, { metadata: { "expireIn": expireIn } });
+	}
+	/**
+	* {@inheritDoc KvStore.delete}
+	*/
+	delete(key) {
+		return this.#store.delete(this.serializeKey(key));
+	}
+	/**
+	* {@inheritDoc KvStore.list}
+	*/
+	async *list(prefix) {
+		const pages = this.#store.list({
+			paginate: true,
+			prefix: this.serializePrefix(prefix)
+		});
+		for await (const page of pages) for (const blob of page.blobs) {
+			const key = this.deserializeKey(blob.key);
+			const value = await this.get(key);
+			if (value === void 0) continue;
+			yield {
+				key,
+				value
+			};
+		}
+	}
+	/**
+	* {@inheritDoc KvStore.cas}
+	*/
+	async cas(key, expectedValue, newValue, options) {
+		while (true) {
+			const entry = await this.#store.getWithMetadata(this.serializeKey(key), {
+				consistency: "strong",
+				type: "json"
+			});
+			if (!isEqual(entry === null || this.isAbsent(entry.metadata) ? void 0 : entry.data, expectedValue)) return false;
+			if (entry === null && newValue === void 0) return true;
+			const serializedKey = this.serializeKey(key);
+			if (newValue === void 0) {
+				if ((await this.#store.setJSON(serializedKey, null, {
+					onlyIfMatch: this.getEtag(entry),
+					metadata: { tombstone: true }
+				})).modified) return true;
+				continue;
+			}
+			const metadata = { "expireIn": options?.ttl == null ? null : Temporal.Now.instant().epochMilliseconds + options.ttl.total("millisecond") };
+			if ((entry === null ? await this.#store.setJSON(serializedKey, newValue, {
+				onlyIfNew: true,
+				metadata
+			}) : await this.#store.setJSON(serializedKey, newValue, {
+				onlyIfMatch: this.getEtag(entry),
+				metadata
+			})).modified) return true;
+		}
+	}
+};
+//#endregion
+export { NetlifyBlobsKvStore, NetlifyMessageQueue, NetlifyMessageQueueSendError, createNetlifyQueueHandler };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/netlify",
-  "version": "2.4.0-pr.1020.43+41cebe9c",
+  "version": "2.4.0",
   "description": "Integrate Fedify with Netlify Async Workloads",
   "keywords": [
     "Fedify",
@@ -47,22 +47,22 @@
     "package.json"
   ],
   "dependencies": {
+    "byte-encodings": "^1.0.11",
+    "es-toolkit": "1.46.1",
     "temporal-polyfill": "^1.0.1"
   },
   "peerDependencies": {
     "@netlify/async-workloads": "^0.0.106",
-    "@fedify/fedify": "^2.4.0-pr.1020.43+41cebe9c"
+    "@fedify/fedify": "^2.4.0"
   },
   "devDependencies": {
     "@js-temporal/polyfill": "^0.5.1",
-    "@netlify/database": "^1.1.0",
     "@standard-schema/spec": "^1.1.0",
-    "@types/node": "^22.17.0",
-    "netlify-cli": "^26.2.0",
-    "postgres": "^3.4.7",
+    "@netlify/blobs": "11.0.3",
+    "@types/node": "^24.12.2",
+    "netlify-cli": "^27.4.2",
     "tsdown": "^0.22.0",
-    "typescript": "^6.0.0",
-    "@fedify/postgres": "^2.4.0-pr.1020.43+41cebe9c"
+    "typescript": "^6.0.0"
   },
   "scripts": {
     "build:self": "tsdown",