@vercel/board 0.16.0 → 0.18.0

package/dist/backend-a2/store-redis-http.d.mts

@@ -1,4 +1,4 @@
-import { t as BoardStore } from "../types-BHCjTZdB.mjs";
+import { t as BoardStore } from "../types-8yq2VnKI.mjs";
 //#region src/store/redis-http.d.ts
 export type RedisHttpOptions = {
   /** The REST endpoint, e.g. `process.env.UPSTASH_REDIS_REST_URL`. */

package/dist/backend-a2/store-redis-http.mjs

@@ -1,5 +1,493 @@
-import { t as redisTables } from "../redis-tables-B35vv4CZ.mjs";
-import { redisHttp as redisHttp$1 } from "experimental-a2/store-redis-http";
+import { t as A2Error } from "../session-clear-wHd5GCpZ-BnKSxReK.mjs";
+import { n as NOTIFY_TIMINGS } from "../internal-CvsrprnU-CRY89I-b.mjs";
+import { n as defaultSleep } from "../store-polling-BZt2Rf3D-BiEM6_HB.mjs";
+import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "../store-N8PXxDAS-BWBgzBHp.mjs";
+import { n as createRedisNotifyStore, t as redisTables } from "../redis-tables-DN9PfIDi.mjs";
+//#region ../../node_modules/.pnpm/experimental-a2@0.22.0_@upstash+qstash@2.12.0_@vercel+queue@0.7.0_ai@7.0.130_zod@4.6.5__52060f00b21aecfab049c27fa3abd2f9/node_modules/experimental-a2/dist/store-redis-http.js
+function redisHttpSubscriptions({ url, token, onReconnect, fallback }) {
+	const subscriptions = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	let closed = false;
+	let supported = false;
+	const subscribe = (channel) => {
+		if (fallback.enabled()) return Promise.resolve();
+		const existing = subscriptions.get(channel);
+		if (existing) return existing.ready;
+		let resolve;
+		let reject;
+		const ready = new Promise((yes, no) => {
+			resolve = yes;
+			reject = no;
+		});
+		let stopped = false;
+		let connected = false;
+		let request;
+		let retry;
+		const subscription = {
+			ready,
+			stop() {
+				stopped = true;
+				request?.abort();
+				retry?.cancel();
+				resolve();
+			}
+		};
+		subscriptions.set(channel, subscription);
+		const run = async () => {
+			let delay = 100;
+			for (;;) {
+				if (stopped) return;
+				request = new AbortController();
+				const timeout = setTimeout(() => request?.abort(), NOTIFY_TIMINGS.safetyReadMs);
+				let reader;
+				let connectedAt;
+				try {
+					const response = await fetch(`${url.replace(/\/$/, "")}/subscribe/${encodeURIComponent(channel)}`, {
+						method: "POST",
+						headers: {
+							authorization: `Bearer ${token}`,
+							accept: "text/event-stream"
+						},
+						signal: request.signal
+					});
+					if (!supported && [
+						404,
+						405,
+						501
+					].includes(response.status)) {
+						await response.body?.cancel();
+						await fallback.checkCommands();
+						if (stopped) return;
+						if (!supported) {
+							fallback.enable();
+							for (const active of subscriptions.values()) active.stop();
+							subscriptions.clear();
+							return;
+						}
+					}
+					if (!response.ok || !response.headers.get("content-type")?.startsWith("text/event-stream") || !response.body) {
+						await response.body?.cancel();
+						throw new A2Error("STORE_UNAVAILABLE", `redis rest subscription failed: status ${response.status}`);
+					}
+					reader = response.body.getReader();
+					const decoder = new TextDecoder();
+					let buffer = "";
+					let data = [];
+					let acknowledged = false;
+					for (;;) {
+						if (stopped) break;
+						const chunk = await reader.read();
+						if (chunk.done) break;
+						buffer += decoder.decode(chunk.value, { stream: true });
+						let newline;
+						while ((newline = buffer.indexOf("\n")) !== -1) {
+							const line = buffer.slice(0, newline).replace(/\r$/, "");
+							buffer = buffer.slice(newline + 1);
+							if (line.startsWith("data:")) data.push(line.slice(5).replace(/^ /, ""));
+							else if (line === "" && data.length > 0) {
+								const message = data.join("\n");
+								data = [];
+								if (message.startsWith(`subscribe,${channel},`)) {
+									if (acknowledged) continue;
+									acknowledged = true;
+									supported = true;
+									clearTimeout(timeout);
+									connectedAt = Date.now();
+									resolve();
+									if (connected) onReconnect(channel);
+									connected = true;
+								} else if (message.startsWith(`message,${channel},`)) {
+									const payload = message.slice(`message,${channel},`.length);
+									for (const listener of listeners) listener(channel, payload);
+								}
+							}
+						}
+					}
+					if (!connected && !stopped) throw new A2Error("STORE_UNAVAILABLE", "redis rest subscription ended before acknowledgement");
+				} catch (error) {
+					if (!connected && !stopped) {
+						reject(error);
+						if (subscriptions.get(channel) === subscription) subscriptions.delete(channel);
+						return;
+					}
+				} finally {
+					clearTimeout(timeout);
+					request.abort();
+					await reader?.cancel().catch(() => {});
+					reader?.releaseLock();
+				}
+				if (stopped) return;
+				if (connectedAt !== void 0 && Date.now() - connectedAt >= NOTIFY_TIMINGS.safetyReadMs) delay = 100;
+				retry = defaultSleep(delay);
+				await retry.promise;
+				delay = Math.min(delay * 2, NOTIFY_TIMINGS.safetyReadMs);
+			}
+		};
+		run();
+		return ready;
+	};
+	const connection = {
+		call(command, ...args) {
+			if (closed) return Promise.reject(new A2Error("STORE_UNAVAILABLE", "the store was closed"));
+			const channel = String(args[0]);
+			if (command === "echo") return Promise.resolve(args[0]);
+			if (command === "subscribe") return subscribe(channel);
+			if (command === "unsubscribe") {
+				subscriptions.get(channel)?.stop();
+				subscriptions.delete(channel);
+				return Promise.resolve(null);
+			}
+			return Promise.reject(/* @__PURE__ */ new Error(`unsupported subscription command: ${command}`));
+		},
+		duplicate: () => connection,
+		on(_event, listener) {
+			listeners.add(listener);
+		},
+		disconnect() {
+			closed = true;
+			for (const subscription of subscriptions.values()) subscription.stop();
+			subscriptions.clear();
+			listeners.clear();
+		}
+	};
+	return connection;
+}
+/**
+* Index just past the array or string `scan` is inside, or -1 when `text`
+* ends first; `scan` then carries the state into the next chunk. Strings
+* are skipped with `indexOf`, so the per-character loop only walks
+* structure. A quote is escaped when an odd run of backslashes precedes
+* it; a run is counted back only to where the string scan resumed, and
+* `escaped` carries an odd trailing run across the chunk boundary.
+*/
+function scanValue(text, from, scan) {
+	let at = from;
+	while (at < text.length) {
+		if (scan.quoted) {
+			if (scan.escaped) {
+				scan.escaped = false;
+				at++;
+				continue;
+			}
+			const quote = text.indexOf("\"", at);
+			const end = quote < 0 ? text.length : quote;
+			let run = 0;
+			while (end - run - 1 >= at && text.charCodeAt(end - run - 1) === 92) run++;
+			if (quote < 0) {
+				scan.escaped = run % 2 === 1;
+				return -1;
+			}
+			at = quote + 1;
+			if (run % 2 === 1) continue;
+			scan.quoted = false;
+			if (scan.depth === 0) return at;
+			continue;
+		}
+		const code = text.charCodeAt(at++);
+		if (code === 34) scan.quoted = true;
+		else if (code === 91 || code === 123) scan.depth++;
+		else if ((code === 93 || code === 125) && --scan.depth === 0) return at;
+	}
+	return -1;
+}
+var JsonReply = class {
+	reader;
+	decoder = new TextDecoder("utf-8", { fatal: true });
+	signal;
+	text = "";
+	position = 0;
+	done = false;
+	abort;
+	array = "first";
+	scan = {
+		depth: 0,
+		quoted: false,
+		escaped: false
+	};
+	fragments = [];
+	failure;
+	constructor(options) {
+		const { body, signal } = options;
+		this.reader = body.getReader();
+		this.signal = signal;
+		this.abort = () => {
+			this.reader.cancel(signal.reason).catch(() => {});
+		};
+		signal.addEventListener("abort", this.abort, { once: true });
+		if (signal.aborted) this.abort();
+	}
+	async available() {
+		while (this.position === this.text.length && !this.done) {
+			this.signal.throwIfAborted();
+			const chunk = await this.reader.read();
+			this.signal.throwIfAborted();
+			this.done = Boolean(chunk.done);
+			this.text = chunk.done ? this.decoder.decode() : this.decoder.decode(chunk.value, { stream: true });
+			this.position = 0;
+		}
+		return this.position < this.text.length;
+	}
+	async peek() {
+		while (await this.available()) while (this.position < this.text.length) {
+			const value = this.text[this.position];
+			if (value !== " " && value !== "\n" && value !== "\r" && value !== "	") return value;
+			this.position++;
+		}
+	}
+	async expect(value) {
+		if (await this.peek() !== value) throw new Error("Invalid or truncated Redis HTTP reply");
+		this.position++;
+	}
+	async value() {
+		const first = await this.peek();
+		if (first !== "[" && first !== "\"") throw new Error("Invalid Redis HTTP reply value");
+		const scan = {
+			depth: 0,
+			quoted: false,
+			escaped: false
+		};
+		const fragments = [];
+		while (await this.available()) {
+			const start = this.position;
+			const end = scanValue(this.text, start, scan);
+			this.position = end < 0 ? this.text.length : end;
+			fragments.push(this.text.slice(start, this.position));
+			if (end >= 0) return JSON.parse(fragments.join(""));
+		}
+		throw new Error("Truncated Redis HTTP reply value");
+	}
+	/**
+	* The next entries of an open array, parsed together: every entry that
+	* completes in the current transport chunk, reading further chunks only
+	* until one has completed. Entries before a malformed one are returned
+	* first; the malformed one fails the next call. `undefined` once the
+	* array has closed.
+	*/
+	async entries() {
+		if (this.failure !== void 0) throw this.failure;
+		const texts = [];
+		const fail = (message) => {
+			const error = new Error(message);
+			if (texts.length === 0) throw error;
+			this.failure = error;
+		};
+		while (this.array !== "closed") {
+			if (this.position === this.text.length) {
+				if (texts.length > 0) break;
+				if (!await this.available()) throw new Error(this.array === "entry" ? "Truncated Redis HTTP reply value" : this.array === "separator" ? "Invalid or truncated Redis HTTP reply" : "Invalid Redis HTTP reply value");
+				continue;
+			}
+			if (this.array === "entry") {
+				const start = this.position;
+				const end = scanValue(this.text, start, this.scan);
+				this.position = end < 0 ? this.text.length : end;
+				this.fragments.push(this.text.slice(start, this.position));
+				if (end < 0) continue;
+				texts.push(this.fragments.length === 1 ? this.fragments[0] : this.fragments.join(""));
+				this.fragments = [];
+				this.array = "separator";
+				continue;
+			}
+			const value = this.text[this.position];
+			if (value === " " || value === "\n" || value === "\r" || value === "	") {
+				this.position++;
+				continue;
+			}
+			if (this.array === "separator" || this.array === "first" && value === "]") {
+				if (value === "]") this.array = "closed";
+				else if (value === ",") this.array = "value";
+				else {
+					fail("Invalid or truncated Redis HTTP reply");
+					break;
+				}
+				this.position++;
+				continue;
+			}
+			if (value !== "[" && value !== "\"") {
+				fail("Invalid Redis HTTP reply value");
+				break;
+			}
+			this.scan = {
+				depth: 0,
+				quoted: false,
+				escaped: false
+			};
+			this.array = "entry";
+		}
+		return texts.length > 0 ? this.parse(texts) : void 0;
+	}
+	parse(texts) {
+		try {
+			return JSON.parse(`[${texts.join(",")}]`);
+		} catch {
+			const parsed = [];
+			for (const text of texts) try {
+				parsed.push(JSON.parse(text));
+			} catch (error) {
+				this.failure = error;
+				break;
+			}
+			if (parsed.length === 0) throw this.failure;
+			return parsed;
+		}
+	}
+	async end() {
+		await this.expect("}");
+		if (await this.peek() !== void 0) throw new Error("Trailing data in Redis HTTP reply");
+	}
+	async close() {
+		this.signal.removeEventListener("abort", this.abort);
+		try {
+			await this.reader.cancel();
+		} finally {
+			this.reader.releaseLock();
+			this.text = "";
+		}
+	}
+};
+/**
+* The `result` array of an Upstash REST reply, in batches of the entries
+* that complete in each transport chunk.
+*/
+async function* redisHttpReply(options) {
+	const reply = new JsonReply(options);
+	try {
+		await reply.expect("{");
+		const key = await reply.value();
+		await reply.expect(":");
+		if (key === "error") {
+			const error = await reply.value();
+			if (typeof error !== "string") throw new Error("Invalid Redis HTTP error");
+			await reply.end();
+			throw new Error(`Redis HTTP command failed: ${String(error)}`);
+		}
+		if (key !== "result") throw new Error("Invalid Redis HTTP reply envelope");
+		await reply.expect("[");
+		for (;;) {
+			const entries = await reply.entries();
+			if (entries === void 0) break;
+			yield entries;
+		}
+		await reply.end();
+	} finally {
+		await reply.close();
+	}
+}
+const REDIS_HTTP_STREAM_READ_COUNT = 1e3;
+async function* readRedisStreamPage({ key, from, signal, url, token, count }) {
+	signal.throwIfAborted();
+	const response = await fetch(url, {
+		method: "POST",
+		headers: {
+			authorization: `Bearer ${token}`,
+			"content-type": "application/json"
+		},
+		body: JSON.stringify([
+			"XRANGE",
+			key,
+			from,
+			"+",
+			"COUNT",
+			String(count)
+		]),
+		signal
+	});
+	if (!response.ok || !response.body) {
+		const body = await response.json().catch(() => null);
+		throw new A2Error("STORE_UNAVAILABLE", `redis rest command failed: ${typeof body?.error === "string" ? body.error : `status ${response.status}`}`);
+	}
+	let last = Number(from.slice(0, -2)) - 1;
+	for await (const batch of redisHttpReply({
+		body: response.body,
+		signal
+	})) {
+		const entries = [];
+		try {
+			for (const entry of batch) {
+				if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string" || !Array.isArray(entry[1]) || entry[1].length % 2 !== 0 || !entry[1].every((field) => typeof field === "string")) throw new Error("Invalid Redis stream entry");
+				const index = /^\d+-0$/.test(entry[0]) ? Number(entry[0].slice(0, -2)) : NaN;
+				if (!Number.isSafeInteger(index) || index <= last) throw new Error("Redis stream entry did not advance");
+				last = index;
+				entries.push(entry);
+			}
+		} catch (error) {
+			if (entries.length > 0) yield entries;
+			throw error;
+		}
+		yield entries;
+	}
+}
+function redisHttp$1(options) {
+	if (!options.url || !options.token) throw new TypeError("redisHttp() needs a url and a token");
+	const { url, token } = options;
+	let polling = false;
+	let fallbackCheck;
+	const call = async (command, ...args) => {
+		let response;
+		try {
+			response = await fetch(url, {
+				method: "POST",
+				headers: {
+					authorization: `Bearer ${token}`,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify([command, ...args.map(String)]),
+				...command === "PING" ? { signal: AbortSignal.timeout(NOTIFY_TIMINGS.safetyReadMs) } : {}
+			});
+		} catch (err) {
+			throw new A2Error("STORE_UNAVAILABLE", "redis rest request failed", { cause: err });
+		}
+		const body = await response.json().catch(() => null);
+		if (body === null || !response.ok || body.error !== void 0) throw new A2Error("STORE_UNAVAILABLE", `redis rest command failed: ${body?.error ?? `status ${response.status}`}`);
+		return body.result;
+	};
+	const readStream = (read) => readRedisStreamPage({
+		...read,
+		url,
+		token,
+		count: REDIS_HTTP_STREAM_READ_COUNT
+	});
+	let subscriber;
+	let onReconnect;
+	const client = {
+		call,
+		duplicate: () => subscriber ??= redisHttpSubscriptions({
+			url,
+			token,
+			onReconnect: (channel) => onReconnect?.(channel),
+			fallback: {
+				enabled: () => polling,
+				checkCommands() {
+					fallbackCheck ??= call("PING").then((result) => {
+						if (result !== "PONG") throw new A2Error("STORE_UNAVAILABLE", "redis rest capability check failed");
+					}).catch((error) => {
+						fallbackCheck = void 0;
+						throw error;
+					});
+					return fallbackCheck;
+				},
+				enable() {
+					polling = true;
+				}
+			}
+		}),
+		on() {},
+		disconnect: () => subscriber?.disconnect()
+	};
+	return createRedisNotifyStore({
+		client: () => Promise.resolve(client),
+		closeClient: async () => client.disconnect(),
+		polling: () => polling,
+		onReconnect: (listener) => {
+			onReconnect = listener;
+		},
+		clock: options.clock ?? SYSTEM_CLOCK,
+		ids: options.ids ?? RANDOM_IDS,
+		keyPrefix: options.keyPrefix ?? "a2",
+		readStream
+	});
+}
+//#endregion
 //#region src/store/redis-http.ts
 /** A board on Redis over Upstash's REST API: no connection to keep, so it suits functions. */
 function redisHttp(options) {

package/dist/backend-a2/store-redis.d.mts

@@ -1,5 +1,13 @@
-import { t as BoardStore } from "../types-BHCjTZdB.mjs";
-import { RedisConnection } from "experimental-a2/store-redis";
+import { t as BoardStore } from "../types-8yq2VnKI.mjs";
+//#region ../../node_modules/.pnpm/experimental-a2@0.22.0_@upstash+qstash@2.12.0_@vercel+queue@0.7.0_ai@7.0.130_zod@4.6.5__52060f00b21aecfab049c27fa3abd2f9/node_modules/experimental-a2/dist/store-redis.d.ts
+//#region src/store-redis-notify.d.ts
+type RedisConnection = {
+  call(command: string, ...args: Array<string | number>): Promise<unknown>;
+  duplicate(): RedisConnection;
+  on(event: "message", listener: (channel: string, message: string) => void): unknown;
+  disconnect(): void;
+};
+//#endregion
 //#region src/store/redis.d.ts
 export type RedisOptions = {
   /**

package/dist/backend-a2/store-redis.mjs

@@ -1,5 +1,54 @@
-import { t as redisTables } from "../redis-tables-B35vv4CZ.mjs";
-import { redis as redis$1 } from "experimental-a2/store-redis";
+import { t as A2Error } from "../session-clear-wHd5GCpZ-BnKSxReK.mjs";
+import { t as retryableLazy } from "../retryable-lazy-DZWmHpii-Bye-W8q7.mjs";
+import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "../store-N8PXxDAS-BWBgzBHp.mjs";
+import { n as createRedisNotifyStore, t as redisTables } from "../redis-tables-DN9PfIDi.mjs";
+//#region ../../node_modules/.pnpm/experimental-a2@0.22.0_@upstash+qstash@2.12.0_@vercel+queue@0.7.0_ai@7.0.130_zod@4.6.5__52060f00b21aecfab049c27fa3abd2f9/node_modules/experimental-a2/dist/store-redis.js
+/**
+* experimental-a2/store-redis — the Redis-protocol store backend, on Redis
+* Streams. The storage semantics live in store-redis-core.ts (shared
+* with experimental-a2/store-redis-http); this module owns the connection and
+* the live feed.
+*
+* `stream()` is notify-driven: every write publishes a wake-up that
+* carries the appended events, one shared subscriber connection per backend
+* serves every local feed, and a caught-up feed applies carried events that
+* continue its sequence without reading. A gap, an oversized batch, a
+* reconnect, or the safety re-read (NOTIFY_TIMINGS) triggers an `XRANGE`
+* catch-up, so a lost wake-up costs latency, never delivery. Connections
+* scale with processes (one command client plus one subscriber), not with
+* concurrent viewers.
+*
+* Works with any Redis-protocol server on a single instance or a
+* non-cluster provider (Upstash — durable by default — Redis, Valkey).
+* `ioredis` is an optional peer dependency; pass `url`, or inject any client
+* exposing `call`/`duplicate`/`on`/`disconnect`.
+*/
+function redis$1(options = {}) {
+	const clock = options.clock ?? SYSTEM_CLOCK;
+	const ids = options.ids ?? RANDOM_IDS;
+	const prefix = options.keyPrefix ?? "a2";
+	if (!options.client && !options.url) throw new TypeError("redis() needs a url or an injected client");
+	const connection = retryableLazy(async () => {
+		if (options.client) return options.client;
+		return new (await (import("ioredis").catch(() => {
+			throw new A2Error("STORE_NOT_CONFIGURED", "experimental-a2/store-redis with a url needs the 'ioredis' package (optional peer dependency) — install it, or inject a client");
+		}))).default(options.url);
+	});
+	const client = connection.get;
+	return createRedisNotifyStore({
+		client,
+		...options.client ? {} : { callBytes: async (command, ...args) => (await client()).callBuffer(command, ...args) },
+		clock,
+		ids,
+		keyPrefix: prefix,
+		async closeClient() {
+			const current = connection.peek();
+			if (!current) return;
+			(await current.catch(() => null))?.disconnect();
+		}
+	});
+}
+//#endregion
 //#region src/store/redis.ts
 /** `ioredis` is an optional peer, installed by the apps that use Redis over TCP. */
 const IOREDIS = "ioredis";

package/dist/backend-a2/store-sqlite.d.mts

@@ -1,4 +1,4 @@
-import { t as BoardStore } from "../types-BHCjTZdB.mjs";
+import { t as BoardStore } from "../types-8yq2VnKI.mjs";
 //#region src/store/sqlite.d.ts
 /**
  * A board in one SQLite file, A2's log and board's tables side by side: `a2()`'s

package/dist/backend-a2/store-sqlite.mjs

@@ -1,6 +1,6 @@
-import { r as sqlTables } from "../sql-DbiEnqM0.mjs";
-import { t as sqliteDb } from "../sqlite-db-Cbj03vmp.mjs";
-import { sqlite as sqlite$1 } from "experimental-a2/store-sqlite";
+import { r as sqlTables } from "../sql-U9WTxrwJ.mjs";
+import { t as sqlite$1 } from "../store-sqlite-CxxPCcCT.mjs";
+import { t as sqliteDb } from "../sqlite-db-Ds4majtT.mjs";
 //#region src/store/sqlite.ts
 /**
 * A board in one SQLite file, A2's log and board's tables side by side: `a2()`'s