@vercel/board 0.15.0 → 0.17.0

package/dist/backend-a2/scheduler-vercel.mjs

@@ -1,2 +1,204 @@
-import { vercelQueues } from "experimental-a2/scheduler-vercel";
+import { i as deliverSchedulerClear, r as deliverSchedulerAppend } from "../server-DtFrWxi3-Boa6gdWO.mjs";
+import { _ as serverInternals, l as assertSchedulerTargets, t as DRAIN_TIMINGS, u as classifySchedulerSendFailure } from "../internal-CvsrprnU-CRY89I-b.mjs";
+import { t as retryableLazy } from "../retryable-lazy-DZWmHpii-Bye-W8q7.mjs";
+import { n as SYSTEM_CLOCK } from "../store-N8PXxDAS-BWBgzBHp.mjs";
+import { t as normalizeSchedulerTask } from "../scheduler-task-X1SToDjP-BVoWuInI.mjs";
+import { createHash } from "node:crypto";
+//#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/scheduler-vercel.js
+/**
+* experimental-a2/scheduler-vercel — queue-backed scheduler over Vercel Queues.
+*
+* `vercelQueues()` returns an `A2Scheduler` (a2-implementation.md §9):
+*
+* - drain tasks round the requested watchdog time up to a one-second slot.
+*   One message per `(topic, contract, session, dueAt)` coalesces appends,
+*   claim renewals and racing callbacks. `DuplicateMessageError` is
+*   success because that due-time slot is already durable.
+* - append tasks hash their stable task id with the topic for provider
+*   deduplication. Their six-day maximum delay leaves a full day for
+*   delivery and retries inside the provider's seven-day retention.
+*   Clear tasks follow the same identity and delay rules. All tasks use
+*   the configured deployment scope for sending and receiving.
+* - `handler(...servers)` is the delivery route: look up the server for
+*   the contract named in the message and drain it. Settled drains ack;
+*   contention, consumer failure, and a drain that throws after arming its
+*   successor all ack once a later watchdog is durable.
+*
+* `@vercel/queue` is an optional peer dependency, imported lazily. The
+* `transport` option is the injection seam — tests run a real little
+* in-memory queue through the same interface.
+*/
+/**
+* The "not settled yet" signal for a drain whose outcome is unknown — an
+* expected state, not a transport failure. The default transport classifies
+* it in `@vercel/queue`'s `retry` option and reschedules the delivery quietly
+* (`{ afterSeconds }` → visibility change → 200 response, no error log)
+* instead of letting it surface as a thrown 500. Busy and stalled deliveries
+* use a fresh watchdog instead. Custom transports should treat this class the
+* same way when their protocol has a polite reschedule.
+*/
+var DrainUnsettled = class extends Error {};
+/** Vercel Queues rejects shorter visibility changes. */
+const MIN_VISIBILITY_SECONDS = 30;
+/** Vercel Queues' maximum message retention; its default is a day. */
+const MAX_RETENTION_SECONDS = 604800;
+const TOPIC_PATTERN = /^[A-Za-z0-9_-]+$/;
+const RETRYABLE_HTTP_CLIENT_STATUSES = /* @__PURE__ */ new Set([
+	408,
+	409,
+	425,
+	429
+]);
+/** The SDK's send path maps these statuses to name-only error instances. */
+const TERMINAL_VERCEL_SEND_ERROR_NAMES = /* @__PURE__ */ new Set([
+	"BadRequestError",
+	"UnauthorizedError",
+	"ForbiddenError"
+]);
+const recordOf = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+const httpStatusOf = (error) => {
+	try {
+		const record = recordOf(error);
+		if (!record) return void 0;
+		const response = recordOf(record["response"]);
+		const statuses = [
+			record["status"],
+			record["statusCode"],
+			response?.["status"]
+		].filter((value) => typeof value === "number" && Number.isInteger(value) && value >= 100 && value <= 599);
+		const [status] = statuses;
+		if (status === void 0) return void 0;
+		return statuses.every((candidate) => candidate === status) ? status : void 0;
+	} catch {
+		return;
+	}
+};
+const errorNameOf = (error) => {
+	try {
+		const name = recordOf(error)?.["name"];
+		return typeof name === "string" ? name : void 0;
+	} catch {
+		return;
+	}
+};
+const classifyVercelSendFailure = (error) => {
+	const status = httpStatusOf(error);
+	const terminal = status === void 0 ? TERMINAL_VERCEL_SEND_ERROR_NAMES.has(errorNameOf(error) ?? "") : status >= 400 && status < 500 && !RETRYABLE_HTTP_CLIENT_STATUSES.has(status);
+	return classifySchedulerSendFailure(error, terminal ? "terminal" : "retryable");
+};
+const digestId = (parts) => `a2_${createHash("sha256").update(JSON.stringify(parts)).digest("hex")}`;
+/** Base of the unsettled redelivery backoff, doubled per delivery. */
+const UNSETTLED_BACKOFF_BASE_SECONDS = 5;
+/** Redelivery backoff for retry states: base, 2×, 4×… bounded. */
+const unsettledBackoffSeconds = (deliveryCount) => Math.min(Math.max(UNSETTLED_BACKOFF_BASE_SECONDS * 2 ** Math.max(deliveryCount - 1, 0), MIN_VISIBILITY_SECONDS), 60);
+const vercelQueueTransport = async (clientOptions) => {
+	const queue = await import("@vercel/queue").catch(() => {
+		throw classifySchedulerSendFailure(/* @__PURE__ */ new Error("experimental-a2/scheduler-vercel needs the '@vercel/queue' package (optional peer dependency) — install it, or inject a transport"), "terminal");
+	});
+	const client = new queue.QueueClient(clientOptions);
+	return {
+		send: (topic, message, options) => client.send(topic, message, options),
+		handleCallback: (handler) => client.handleCallback(handler, {
+			visibilityTimeoutSeconds: MIN_VISIBILITY_SECONDS,
+			retry: (error, metadata) => error instanceof DrainUnsettled ? { afterSeconds: unsettledBackoffSeconds(metadata.deliveryCount) } : void 0
+		}),
+		isDuplicate: (error) => error instanceof queue.DuplicateMessageError
+	};
+};
+function vercelQueues(options = {}) {
+	const topic = options.topic ?? "a2";
+	if (typeof topic !== "string" || !TOPIC_PATTERN.test(topic)) throw new TypeError("vercelQueues() topic must match [A-Za-z0-9_-]+");
+	const clock = options.clock ?? SYSTEM_CLOCK;
+	const clientOptions = options.deploymentId === void 0 ? {} : { deploymentId: options.deploymentId };
+	const transport = retryableLazy(() => options.transport ? Promise.resolve(options.transport) : vercelQueueTransport(clientOptions)).get;
+	const sendTask = async (task) => {
+		const nowMs = clock.now().getTime();
+		const requestedDueAt = task.dueAt;
+		if (!Number.isFinite(requestedDueAt)) throw classifySchedulerSendFailure(/* @__PURE__ */ new TypeError("vercel scheduler dueAt must be a finite number"), "terminal");
+		const dueAt = requestedDueAt <= nowMs ? Math.floor(nowMs / 1e3) * 1e3 : Math.ceil(requestedDueAt / 1e3) * 1e3;
+		const deliveryTargetAt = task.kind === "drain" ? dueAt : requestedDueAt;
+		const deliveryDelaySeconds = Math.max(0, Math.ceil((deliveryTargetAt - nowMs) / 1e3));
+		const message = {
+			...task,
+			dueAt
+		};
+		const idempotencyKey = task.kind === "drain" ? digestId([
+			"a2:scheduler-vercel:drain:v1",
+			topic,
+			task.contract,
+			task.sessionId,
+			String(dueAt)
+		]) : task.kind === "append" ? digestId([
+			"a2:scheduler-vercel:append:v1",
+			topic,
+			task.id
+		]) : digestId([
+			"a2:scheduler-vercel:clear:v1",
+			topic,
+			task.id
+		]);
+		const t = await transport();
+		try {
+			await t.send(topic, message, {
+				delaySeconds: deliveryDelaySeconds,
+				idempotencyKey,
+				retentionSeconds: MAX_RETENTION_SECONDS
+			});
+		} catch (err) {
+			if (t.isDuplicate(err)) return;
+			throw classifyVercelSendFailure(err);
+		}
+	};
+	const successorDueAt = (message) => {
+		const minimumDueAt = clock.now().getTime() + DRAIN_TIMINGS.claimTtlMs + DRAIN_TIMINGS.watchdogGraceMs;
+		const beats = Math.max(1, Math.ceil((minimumDueAt - message.dueAt) / DRAIN_TIMINGS.claimHeartbeatMs));
+		return message.dueAt + beats * DRAIN_TIMINGS.claimHeartbeatMs;
+	};
+	return {
+		async schedule(task) {
+			await sendTask(task);
+		},
+		handler(...servers) {
+			assertSchedulerTargets(servers);
+			const byContract = /* @__PURE__ */ new Map();
+			for (const server of servers) byContract.set(server.contract.name, server);
+			return async (req) => {
+				return (await transport()).handleCallback(async (delivered) => {
+					const task = normalizeSchedulerTask(delivered);
+					if (!task) throw new TypeError("a2 scheduler received an invalid task");
+					const server = byContract.get(task.contract);
+					if (!server) throw new Error(`a2 scheduler: no server for contract '${task.contract}' — pass it to scheduler.handler(...)`);
+					const internals = serverInternals.get(server);
+					if (task.kind === "append") {
+						await deliverSchedulerAppend(server, task);
+						return;
+					}
+					if (task.kind === "clear") {
+						await deliverSchedulerClear(server, task);
+						return;
+					}
+					const nextDueAt = successorDueAt(task);
+					const result = internals ? await internals.schedulerDrain(task.sessionId, { watchdogDueAt: nextDueAt }) : {
+						...await server.drain(task.sessionId),
+						outcome: "unknown"
+					};
+					if (result.settled) return;
+					if (result.outcome === "busy" || result.outcome === "stalled" || result.outcome === "failed") {
+						if (result.schedulerArm) await result.schedulerArm;
+						else await sendTask({
+							version: 1,
+							kind: "drain",
+							contract: task.contract,
+							sessionId: task.sessionId,
+							dueAt: nextDueAt
+						});
+						return;
+					}
+					throw new DrainUnsettled(`a2 scheduler: session '${task.sessionId}' of '${task.contract}' not settled yet (${result.outcome}) — rescheduled for redelivery`);
+				})(req);
+			};
+		}
+	};
+}
+//#endregion
 export { vercelQueues };

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

@@ -1,5 +1,5 @@
-import { t as BoardStore } from "../types-BHCjTZdB.mjs";
-import { Clock } from "experimental-a2/server";
+import { n as Clock } from "../store-D0MhBvg6-4Z2L0Kqd.mjs";
+import { t as BoardStore } from "../types-8yq2VnKI.mjs";
 //#region src/store/memory.d.ts
 /**
  * A board that lives in memory, for tests: its log in A2's memory store, its

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

@@ -1,6 +1,6 @@
-import { r as sqlTables } from "../sql-DbiEnqM0.mjs";
-import { t as sqliteDb } from "../sqlite-db-Cbj03vmp.mjs";
-import { memory as memory$1 } from "experimental-a2/store-memory";
+import { r as sqlTables } from "../sql-U9WTxrwJ.mjs";
+import { t as sqliteDb } from "../sqlite-db-Ds4majtT.mjs";
+import { t as memory$1 } from "../store-memory-Bas9Uq5C.mjs";
 //#region src/store/memory.ts
 /**
 * A board that lives in memory, for tests: its log in A2's memory store, its

package/dist/backend-a2/store-postgres.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/postgres-db.d.ts
 /** What the tables need of a `pg` Pool, or of anything shaped like one. */
 type PgQueryable = {