@vercel/board 0.16.0 → 0.18.0

package/dist/server-qgez0Xny-D5mLfqFQ.d.mts

@@ -0,0 +1,385 @@
+import { a as PresenceDefs, c as PresenceSnapshot, d as WithPresence, i as EventDefs, l as Reducer, n as Contract, o as PresenceMap, r as ContractEvent, s as PresencePatch, t as AppendInput, u as RegisteredReducer } from "./reducer-CYPHsSmd-BQIfozGi.mjs";
+import { r as Event } from "./store-D0MhBvg6-4Z2L0Kqd.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/session-clear-D1PFe7xl.d.ts
+//#region src/session-clear.d.ts
+/** Reserved type of the marker a clear appends. */
+declare const CLEAR_EVENT_TYPE = "a2.cleared";
+/** The marker `session.stream()` yields where a clear ended a lifetime. */
+type SessionCleared = Event & {
+  type: typeof CLEAR_EVENT_TYPE;
+  payload: null;
+};
+//#endregion
+//#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/server-qgez0Xny.d.ts
+//#region src/session-socket.d.ts
+/**
+ * The structural socket `sessionsSocket` speaks against — satisfied
+ * by `ws` and by `@vercel/functions`' upgraded socket alike, so the
+ * platform upgrade API stays out of the library. `message` data
+ * arrives as whatever the platform delivers (string, Buffer,
+ * ArrayBuffer, or fragments); the handler normalizes defensively.
+ */
+type A2Socket = {
+  send(data: string): void;
+  on(event: "message", listener: (data: unknown) => void): void;
+  on(event: "close", listener: () => void): void;
+  on(event: "error", listener: (error: unknown) => void): void;
+  close(code?: number, reason?: string): void;
+  /** Bytes queued but not yet transmitted — when exposed, the down
+   * pump uses it for backpressure (`SOCKET_TIMINGS`). */
+  bufferedAmount?: number;
+};
+//#endregion
+//#region src/server-fetch.d.ts
+type SuggestedEventType<D extends EventDefs> = (keyof D & string) | (string & Record<never, never>);
+type SuggestedPresenceValues<P extends PresenceDefs> = Readonly<{ [F in keyof P & string]?: unknown; } & Record<string, unknown>>;
+type A2PushEvent<D extends EventDefs = EventDefs> = {
+  readonly type: SuggestedEventType<D>;
+  readonly payload: unknown;
+  readonly id?: string;
+};
+type A2PushPresence<P extends PresenceDefs = PresenceDefs> = {
+  readonly participant: string;
+  readonly values: SuggestedPresenceValues<P>;
+  readonly seen?: number;
+  readonly at?: number;
+};
+type A2Operation<D extends EventDefs = EventDefs, P extends PresenceDefs = Record<never, never>> = {
+  readonly type: "stream";
+  readonly sessionId: string;
+  readonly startAfter: number;
+  readonly bootstrap?: true;
+  readonly transport: "http" | "websocket";
+} | {
+  readonly type: "history";
+  readonly sessionId: string;
+  readonly gte: number;
+  readonly lte: number;
+  readonly transport: "http";
+} | {
+  readonly type: "push";
+  readonly sessionId: string;
+  readonly events: readonly A2PushEvent<D>[];
+  readonly presence?: A2PushPresence<P>;
+  readonly transport: "http" | "websocket";
+};
+type UpgradeWebSocket = (attach: (socket: A2Socket) => void) => Response | Promise<Response>;
+type ServerFetchOptions<D extends EventDefs = EventDefs, P extends PresenceDefs = Record<never, never>> = {
+  authorize?: (operation: A2Operation<D, P>) => boolean | Promise<boolean>;
+  upgradeWebSocket?: UpgradeWebSocket;
+  /** Allow one upgraded connection to select more than one session. */
+  multiplexWebSocket?: boolean;
+};
+//#endregion
+//#region src/scheduler-task.d.ts
+/** One event carried by a delayed append task. */
+type ScheduledEvent = {
+  id: string;
+  type: string;
+  payload: unknown;
+};
+/** A durable wake-up for pending consumer work. */
+type SchedulerDrainTask = {
+  version: 1;
+  kind: "drain";
+  contract: string;
+  sessionId: string;
+  /** Earliest useful delivery as epoch milliseconds. */
+  dueAt: number;
+};
+/** A durable delayed append. */
+type SchedulerAppendTask = {
+  version: 1;
+  kind: "append";
+  /** Stable identity for provider-level deduplication. */
+  id: string;
+  contract: string;
+  sessionId: string;
+  /** Earliest useful delivery as epoch milliseconds. */
+  dueAt: number;
+  events: readonly ScheduledEvent[];
+  /** The scheduling consumer's event; delivery skips once it is cleared. */
+  originIndex?: number;
+};
+/** A durable conditional clear. */
+type SchedulerClearTask = {
+  version: 1;
+  kind: "clear";
+  /** Stable identity for provider-level deduplication. */
+  id: string;
+  contract: string;
+  sessionId: string;
+  /** Earliest useful delivery as epoch milliseconds. */
+  dueAt: number;
+  /** Clear only while this is still the head. */
+  ifLastIndex: number;
+};
+/** The versioned message protocol shared by scheduler adapters. */
+type SchedulerTask = SchedulerDrainTask | SchedulerAppendTask | SchedulerClearTask;
+//#endregion
+//#region src/server.d.ts
+type PublicState<R> = undefined extends R ? never : R extends {
+  initialState: infer S;
+} ? S : never;
+/** What every consumer's `run` receives. */
+type ConsumerContext<D extends EventDefs, K extends keyof D & string = keyof D & string, P extends PresenceDefs = Record<never, never>, S = never> = {
+  /** The triggering event. */
+  event: ContractEvent<D, K>;
+  /** Durable, 1-based dispatch ordinal for this event. */
+  attempt: number;
+  /** This session, with consumer-scoped idempotent append. */
+  session: Session<D, ConsumerAppend<D>, P, S>;
+  /** Fires on `abortOn` events (cancellation slice); dormant otherwise. */
+  signal: AbortSignal;
+};
+type LaneContext<D extends EventDefs, K extends keyof D & string = keyof D & string> = {
+  sessionId: string;
+  event: Pick<ContractEvent<D, K>, "type" | "payload"> & {
+    id?: string;
+  };
+};
+/**
+ * A consumer's lane: a string runs every event it takes in log order on one
+ * cursor; a function returns each event's lane, or null to run it
+ * concurrently.
+ */
+type ConsumerLane<D extends EventDefs, K extends keyof D & string = keyof D & string> = string | ((context: LaneContext<D, K>) => string | null);
+type SessionDispatch<D extends EventDefs> = (...events: AppendInput<D>[]) => Promise<ContractEvent<D>[]>;
+type SessionAppend<D extends EventDefs> = SessionDispatch<D> & {
+  /** Commit, then hand pending work directly to configured scheduler. */
+  dispatch: SessionDispatch<D>;
+};
+type ConsumerAppend<D extends EventDefs> = (name: string, ...events: AppendInput<D>[]) => Promise<ContractEvent<D>[]>;
+type ScheduleDelay = `${number}${"ms" | "s" | "m" | "h" | "d"}`;
+type ScheduleTiming = {
+  delay: ScheduleDelay;
+  at?: never;
+} | {
+  at: Date;
+  delay?: never;
+};
+type SessionSchedule<D extends EventDefs> = {
+  (name: string, timing: ScheduleTiming, ...events: AppendInput<D>[]): Promise<void>;
+  /**
+   * Publish a durable conditional clear. Delivery clears only while
+   * `ifLastIndex` is still the head, and finishes deleting before it
+   * acknowledges.
+   */
+  clear(name: string, options: ScheduleTiming & {
+    ifLastIndex: number;
+  }): Promise<void>;
+};
+type StateOptions = {
+  through?: number | "latest";
+};
+type SessionClearOptions = {
+  /** Clear only while this is the head; a mismatch changes nothing. */
+  ifLastIndex?: number;
+};
+type SessionClearResult = {
+  cleared: boolean;
+  index: number;
+};
+type SessionRedriveOptions = {
+  /** `retry` runs the consumer again with a fresh failure budget; `skip` settles the event without running it. */
+  action: "retry" | "skip";
+};
+type SessionRedriveResult = {
+  /** Whether the event was dead-lettered and is now resolved. */
+  redriven: boolean;
+};
+type SessionConsumeOptions = {
+  /**
+   * Run until the consumer has handled every event it takes through this
+   * index. Default: the session's head when the call starts. An index past
+   * the head counts as the head.
+   */
+  through?: number;
+  /** Stops waiting: the call throws the signal's reason. */
+  signal?: AbortSignal;
+};
+type SessionConsumeResult = {
+  /** The consumer has handled every event it takes through this index. */
+  index: number;
+};
+/** A dead-lettered event, with what an operator needs to resolve it. */
+type DeadLetter<D extends EventDefs> = ContractEvent<D> & {
+  /** The consumer this event is dead for; it may be done for others. */
+  consumer: string;
+  lane: string | null;
+  /** Durable dispatch claims, including claims abandoned by hard kills. */
+  attemptCount: number;
+  /**
+   * Failed attempts since the event was appended or last retried: caught
+   * consumer failures, and attempts that ended before they finished.
+   */
+  failureCount: number;
+  /**
+   * The last error the consumer threw, stringified; null when every failed
+   * attempt ended before it finished.
+   */
+  lastError: string | null;
+  failedAt: Date;
+};
+/** Dead-letter resolution; root sessions only. */
+type SessionDeadLetters<D extends EventDefs> = {
+  /** The session's dead-lettered events, oldest first. */
+  deadLetters(): Promise<DeadLetter<D>[]>;
+  /**
+   * Atomically resolve one dead-lettered event, then wake the session like
+   * an append. Any other event is left alone and reports `redriven: false`.
+   */
+  redrive(target: {
+    consumer: string;
+    index: number;
+  }, options: SessionRedriveOptions): Promise<SessionRedriveResult>;
+};
+/**
+ * The presence members of a session — intersected in via
+ * `WithPresence`, so they exist exactly when the contract declares
+ * presence fields. Intersected before the base members so the widened
+ * `stream` overload is tried first: the literal `presence: true`
+ * selects it, everything else falls through to the events-only base.
+ */
+type SessionPresence<D extends EventDefs, P extends PresenceDefs> = {
+  /**
+   * The two-plane feed: one snapshot of the current pruned map first
+   * (per-field stamps exact), then presence patches interleaved with
+   * events.
+   */
+  stream(opts: {
+    startAfter?: number;
+    presence: true;
+  }): AsyncIterable<ContractEvent<D> | SessionCleared | PresencePatch<P> | PresenceSnapshot<P>>;
+  /**
+   * Validate against the contract's presence schemas, then broadcast.
+   * Never an append: no log row, no dispatch, no scheduler arm. `at`
+   * is the sender's LWW stamp in epoch ms; omitted, receipt time
+   * stands in (single writer, so receipt order is sender order).
+   */
+  setPresence(patch: {
+    participant: string;
+    values: PresencePatch<P>["values"];
+    seen?: number;
+    at?: number;
+  }): Promise<void>;
+  /** The current map, expired values pruned — a point-in-time read. */
+  presence(): Promise<PresenceMap<P>>;
+};
+/** A handle on one instance of the machine. Creating it does no I/O. */
+type Session<D extends EventDefs, Append = SessionAppend<D>, P extends PresenceDefs = Record<never, never>, S = never> = WithPresence<P, SessionPresence<D, P>> & {
+  readonly id: string;
+  append: Append;
+  schedule: SessionSchedule<D>;
+  /**
+   * End the current lifetime: atomically append a clear marker, then
+   * delete the history below it. Indexes never restart.
+   */
+  clear(options?: SessionClearOptions): Promise<SessionClearResult>;
+  history(options?: {
+    gte?: number;
+    lte?: number;
+  }): Promise<ContractEvent<D>[]>;
+  /**
+   * Run a consumer with a string lane on this session, here, until it has
+   * handled every event it takes through `through`. The server's own
+   * consumer shares its cursor with background work, so this waits for
+   * whichever invocation holds it. A consumer the server doesn't run is
+   * pulled only by `consume`, and keeps its place between calls.
+   */
+  consume(consumer: Consumer<D>, options?: SessionConsumeOptions): Promise<SessionConsumeResult>;
+  state: {
+    <T>(reducer: Reducer<D, T, Record<never, never>>, options?: StateOptions): Promise<{
+      state: T;
+      index: number;
+      clearIndex?: number;
+    }>;
+  } & ([S] extends [never] ? unknown : {
+    (): Promise<{
+      state: S;
+      index: number;
+      clearIndex?: number;
+    }>;
+  });
+  /**
+   * A live feed of this session's events, starting after `startAfter`
+   * (exclusive). Server-side only. `server.fetch` exposes it over SSE.
+   * A clear arrives as a `SessionCleared` marker.
+   */
+  stream(opts?: {
+    startAfter?: number;
+  }): AsyncIterable<ContractEvent<D> | SessionCleared>;
+};
+/**
+ * The public server shape scheduler consumers accept. It stays structural so
+ * servers of any contract mix in one route; A2's private server internals add
+ * delayed-append delivery without exposing an untyped append method here.
+ */
+type DrainableServer = {
+  readonly contract: {
+    readonly name: string;
+  };
+  drain(sessionId: string): Promise<{
+    settled: boolean;
+  }>;
+};
+/**
+ * The scheduler seam (a2-implementation.md §7, §9). `schedule` puts a
+ * versioned drain or delayed append task on durable infrastructure;
+ * `handler` returns the route the transport delivers to. Claim holders
+ * move the watchdog alongside their renewable execution window.
+ * Implementations ship as
+ * entry points (`experimental-a2/scheduler-vercel`); core never imports a
+ * transport.
+ */
+type A2Scheduler = {
+  schedule(task: SchedulerTask): Promise<void>;
+  handler(...servers: DrainableServer[]): (req: Request) => Promise<Response>;
+};
+type A2Server<D extends EventDefs, P extends PresenceDefs = Record<never, never>, R extends RegisteredReducer<D, P> | undefined = RegisteredReducer<D, P> | undefined> = {
+  /** The contract this server implements. */
+  readonly contract: Contract<D, P, R>;
+  readonly fetch: {
+    (request: Request): Promise<Response>;
+    (request: Request, options: ServerFetchOptions<D, P>): Promise<Response>;
+  };
+  session(id: string): Session<D, SessionAppend<D>, P, PublicState<R>> & SessionDeadLetters<D>;
+  /**
+   * Process every currently eligible event. `settled` means nothing
+   * actionable remains, including work blocked behind a dead letter.
+   */
+  drain(sessionId: string): Promise<{
+    settled: boolean;
+  }>;
+};
+/**
+ * Which events fire `ctx.signal` while a consumer runs — the preemption
+ * channel for user cancellation. The array form matches by type; the
+ * object form takes per-type predicates for targeted cancellation
+ * (`(event, trigger) => event.payload.of === trigger.id`). Consumers
+ * without `abortOn` pay nothing. An aborted consumer should catch and
+ * return normally; throwing means "retry me".
+ */
+type AbortSpec<D extends EventDefs, K extends keyof D & string> = Array<keyof D & string> | { [T in keyof D & string]?: true | ((event: ContractEvent<D, T>, trigger: ContractEvent<D, K>, context: {
+  attempt: number;
+}) => boolean); };
+/** What a consumer's `run` returns: nothing, one event, or a batch. */
+type ConsumerResult<D extends EventDefs> = Promise<void | AppendInput<D> | readonly AppendInput<D>[]>;
+/** How `createServer` runs a consumer. Built by `consumer().run()`. */
+type ConsumerSpec<D extends EventDefs> = {
+  readonly types: readonly (keyof D & string)[] | null;
+  readonly lane: ConsumerLane<D> | null;
+  readonly backfill: boolean;
+  readonly abortOn: AbortSpec<D, keyof D & string> | null;
+  readonly run: (ctx: ConsumerContext<D>) => ConsumerResult<D>;
+};
+/** A named reader of a session's log with its own durable cursors. */
+type Consumer<D extends EventDefs> = {
+  readonly name: string;
+  readonly contract: {
+    readonly name: string;
+  };
+  readonly spec: ConsumerSpec<D>;
+};
+//#endregion
+export { SessionAppend as a, SessionConsumeOptions as c, SessionSchedule as d, StateOptions as f, SchedulerTask as i, SessionConsumeResult as l, A2Server as n, SessionClearOptions as o, SessionCleared as p, Consumer as r, SessionClearResult as s, A2Scheduler as t, SessionDeadLetters as u };

package/dist/{serving-BNbzc96L.mjs → serving-CNkgUPW1.mjs}

@@ -1,2 +1,2 @@
-import { i as ownTeamId, n as discoveryIdentity, r as ownProjectId, t as oidcTokens } from "./tokens-DKLn5P9B.mjs";
+import { i as ownTeamId, n as discoveryIdentity, r as ownProjectId, t as oidcTokens } from "./tokens-DhuzKzAl.mjs";
 export { discoveryIdentity, oidcTokens, ownProjectId, ownTeamId };

package/dist/session-clear-wHd5GCpZ-BnKSxReK.mjs

@@ -0,0 +1,51 @@
+//#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/session-clear-wHd5GCpZ.js
+var A2Error = class extends Error {
+	code;
+	/** e.g. the Standard Schema issues for INVALID_PAYLOAD */
+	details;
+	constructor(code, message, options) {
+		super(message, options && "cause" in options ? { cause: options.cause } : void 0);
+		this.name = "A2Error";
+		this.code = code;
+		this.details = options?.details;
+	}
+};
+/** A consumer write whose attempt no longer owns its triggering event. */
+function supersededAttemptError(sessionId, cause) {
+	const of = cause.consumer === void 0 ? "" : ` for consumer '${cause.consumer}'`;
+	return new A2Error("SUPERSEDED_ATTEMPT", `attempt ${cause.attempt} no longer owns event ${cause.index}${of} in session '${sessionId}'`);
+}
+/**
+* Wrap an arbitrary thrown value as STORE_UNAVAILABLE, preserving the
+* original as `cause`. A2Errors pass through untouched — they already
+* carry their own meaning.
+*/
+function asStoreUnavailable(err) {
+	if (err instanceof A2Error) return err;
+	return new A2Error("STORE_UNAVAILABLE", "the store backend failed", { cause: err });
+}
+/**
+* Throw from a consumer to reject retrying: the failure is adjudicated
+* terminal immediately (dead-lettered on the first throw) instead of
+* consuming the ten-failure retry budget. For deterministic failures —
+* a guard that will refuse identically on every attempt — retrying is
+* waste and dead-lettering is the honest outcome. Matched by
+* `instanceof`, so subclasses carry domain meaning.
+*/
+var NonRetriableError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "NonRetriableError";
+	}
+};
+/** Reserved type of the marker a clear appends. */
+const CLEAR_EVENT_TYPE = "a2.cleared";
+/** Accepts any stream item, including presence patches and snapshots. */
+function isSessionCleared(item) {
+	return item.type === CLEAR_EVENT_TYPE;
+}
+function sessionClearedError(message) {
+	return new A2Error("SESSION_CLEARED", message);
+}
+//#endregion
+export { isSessionCleared as a, asStoreUnavailable as i, CLEAR_EVENT_TYPE as n, sessionClearedError as o, NonRetriableError as r, supersededAttemptError as s, A2Error as t };

package/dist/{sql-DbiEnqM0.mjs → sql-U9WTxrwJ.mjs}

@@ -1,6 +1,6 @@
+import { c as externalMessageKey } from "./external-BV_cUncs.mjs";
 import { n as setOwn } from "./own-OwgPWdmh.mjs";
-import { r as externalMessageKey } from "./reducers-mUPFuFJV.mjs";
-import { i as syncReads, n as project, r as projectSync, t as concernedMessageId } from "./project-CFiArraX.mjs";
+import { i as syncReads, n as project, r as projectSync, t as concernedMessageId } from "./project-DMDST9kl.mjs";
 //#region src/store/sql.ts
 /** The projection's name in `board_positions`, and the A2 consumer that runs it. */
 const TABLES_CONSUMER = "board-tables";

package/dist/{sqlite-db-Cbj03vmp.mjs → sqlite-db-Ds4majtT.mjs}

@@ -1,4 +1,4 @@
-import { n as ddl } from "./sql-DbiEnqM0.mjs";
+import { n as ddl } from "./sql-U9WTxrwJ.mjs";
 import { mkdirSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 //#region src/store/sqlite-db.ts