@vercel/board 0.16.0 → 0.18.0

package/dist/store-memory-ZLiZbH3R.mjs

@@ -0,0 +1,2 @@
+import { t as memory } from "./store-memory-Bas9Uq5C.mjs";
+export { memory };

package/dist/store-polling-BZt2Rf3D-BiEM6_HB.mjs

@@ -0,0 +1,148 @@
+import { r as POLL_TIMINGS } from "./internal-CvsrprnU-CRY89I-b.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-polling-BZt2Rf3D.js
+const streamActivities = /* @__PURE__ */ new WeakMap();
+function createStreamActivity(wake) {
+	let idle = false;
+	const listeners = /* @__PURE__ */ new Set();
+	const setIdle = (next) => {
+		if (idle === next) return;
+		idle = next;
+		for (const listener of listeners) listener(idle);
+	};
+	return {
+		get idle() {
+			return idle;
+		},
+		setIdle,
+		activate() {
+			setIdle(false);
+			wake();
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		}
+	};
+}
+/**
+* The shared polling stream — how poll-based backends (sqlite,
+* postgres) implement `A2Store.stream`.
+*
+* The cadence is activity-adaptive: while events are flowing, polls
+* run at a tight floor (25ms) so streams feel pushed — a token
+* generation reads smoothly instead of clumping at the idle interval;
+* every empty poll doubles the gap until the idle ceiling. The cadence
+* is owned (POLL_TIMINGS in internal.ts), not a public option: the
+* floor already keeps active streams smooth, so tuning it is a cost
+* decision a2 makes, not one it delegates. Correctness never depends
+* on the cadence — each poll is a catch-up read (`index > last`, in
+* order), so nothing can be missed, only arrive a beat later.
+*/
+/** Unref'd cancellable timer — shared with the redis safety read. */
+const defaultSleep = (ms) => {
+	let timer;
+	let wake;
+	return {
+		promise: new Promise((resolve) => {
+			wake = resolve;
+			timer = setTimeout(resolve, ms);
+			timer.unref?.();
+		}),
+		cancel: () => {
+			clearTimeout(timer);
+			wake?.();
+		}
+	};
+};
+const ceiling = () => POLL_TIMINGS.idleCeilingMs;
+const floor = () => Math.min(POLL_TIMINGS.activeFloorMs, POLL_TIMINGS.idleCeilingMs);
+/**
+* Build the `stream()` iterable from a backend's catch-up read. The
+* iterable ends when the consumer calls `return()` (a disconnecting
+* SSE client), waking any pending sleep immediately.
+*/
+function pollingStream(readAfter, options) {
+	const startAfter = options.startAfter ?? 0;
+	const sleep = options.sleep ?? defaultSleep;
+	return { [Symbol.asyncIterator]() {
+		let last = startAfter;
+		let buffer = [];
+		let position = 0;
+		let closed = false;
+		let pending = null;
+		let interval = floor();
+		let activityVersion = 0;
+		const activity = createStreamActivity(() => {
+			if (closed) return;
+			activityVersion += 1;
+			interval = floor();
+			pending?.cancel();
+		});
+		const iterator = {
+			async next() {
+				for (;;) {
+					if (closed) return {
+						value: void 0,
+						done: true
+					};
+					try {
+						if (position === buffer.length) {
+							const rows = await readAfter(last);
+							if (closed) return {
+								value: void 0,
+								done: true
+							};
+							buffer = rows;
+							position = 0;
+						}
+					} catch (error) {
+						if (closed) return {
+							value: void 0,
+							done: true
+						};
+						throw error;
+					}
+					if (closed) return {
+						value: void 0,
+						done: true
+					};
+					const row = buffer[position];
+					if (row) {
+						activity.activate();
+						last = row.index;
+						buffer[position] = void 0;
+						position += 1;
+						if (position === buffer.length) {
+							buffer = [];
+							position = 0;
+						}
+						return {
+							value: row,
+							done: false
+						};
+					}
+					activity.setIdle(interval === ceiling());
+					const version = activityVersion;
+					pending = sleep(interval);
+					await pending.promise;
+					pending = null;
+					if (version === activityVersion) interval = Math.min(interval * 2, ceiling());
+				}
+			},
+			async return() {
+				closed = true;
+				buffer = [];
+				position = 0;
+				pending?.cancel();
+				return {
+					value: void 0,
+					done: true
+				};
+			}
+		};
+		streamActivities.set(iterator, activity);
+		return iterator;
+	} };
+}
+//#endregion
+export { streamActivities as i, defaultSleep as n, pollingStream as r, createStreamActivity as t };

package/dist/store-presence-polling-JuAy2Ck2-CYpuK75X.mjs

@@ -0,0 +1,109 @@
+import { r as POLL_TIMINGS } from "./internal-CvsrprnU-CRY89I-b.mjs";
+import { n as defaultSleep } from "./store-polling-BZt2Rf3D-BiEM6_HB.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-presence-polling-JuAy2Ck2.js
+const key = ({ participant, field }) => JSON.stringify([participant, field]);
+function pollPresence({ read, deliver, sleep = defaultSleep }) {
+	let stopped = false;
+	let pending;
+	let interval = Math.min(POLL_TIMINGS.activeFloorMs, POLL_TIMINGS.idleCeilingMs);
+	let version = 0;
+	const seen = /* @__PURE__ */ new Map();
+	const activate = () => {
+		version += 1;
+		interval = Math.min(POLL_TIMINGS.activeFloorMs, POLL_TIMINGS.idleCeilingMs);
+		pending?.cancel();
+	};
+	const ready = read().then((rows) => {
+		if (stopped) return;
+		for (const row of rows) seen.set(key(row), row);
+	}).catch(() => void 0);
+	/** Delivers how `rows` differ from what was seen; true when they do. */
+	const reconcile = (rows) => {
+		const live = /* @__PURE__ */ new Set();
+		let changed = false;
+		for (const row of rows) {
+			const id = key(row);
+			live.add(id);
+			const prior = seen.get(id);
+			seen.set(id, row);
+			if (prior?.seen === row.seen && prior.at.getTime() === row.at.getTime() && JSON.stringify(prior.value) === JSON.stringify(row.value)) continue;
+			changed = true;
+			deliver({
+				participant: row.participant,
+				values: { [row.field]: row.value },
+				seen: row.seen,
+				at: row.at
+			});
+		}
+		for (const [id, row] of seen) {
+			if (live.has(id)) continue;
+			seen.delete(id);
+			changed = true;
+			deliver({
+				participant: row.participant,
+				values: { [row.field]: null },
+				seen: row.seen,
+				at: row.at
+			});
+		}
+		return changed;
+	};
+	const run = async () => {
+		await ready;
+		for (;;) {
+			if (stopped) return;
+			const before = version;
+			pending = sleep(interval);
+			await pending.promise;
+			if (stopped) return;
+			try {
+				const reading = version;
+				const rows = await read();
+				if (stopped) return;
+				if (version !== reading) continue;
+				if (reconcile(rows)) activate();
+				else if (version === before) interval = Math.min(interval * 2, POLL_TIMINGS.idleCeilingMs);
+			} catch {
+				interval = POLL_TIMINGS.idleCeilingMs;
+			}
+		}
+	};
+	run();
+	return {
+		ready,
+		async snapshot(readSnapshot) {
+			const reading = version;
+			const rows = await readSnapshot();
+			if (!stopped && version === reading && reconcile(rows)) activate();
+			return rows;
+		},
+		wake: activate,
+		update(patch) {
+			for (const [field, value] of Object.entries(patch.values)) {
+				const id = key({
+					participant: patch.participant,
+					field
+				});
+				if (value === null) {
+					seen.delete(id);
+					continue;
+				}
+				seen.set(id, {
+					participant: patch.participant,
+					field,
+					value,
+					seen: patch.seen,
+					at: patch.at
+				});
+			}
+			activate();
+		},
+		stop() {
+			stopped = true;
+			pending?.cancel();
+			seen.clear();
+		}
+	};
+}
+//#endregion
+export { pollPresence as t };

package/dist/store-sqlite-BmwL3pUR.mjs

@@ -0,0 +1,2 @@
+import { t as sqlite } from "./store-sqlite-CxxPCcCT.mjs";
+export { sqlite };