@vercel/board 0.16.0 → 0.18.0

package/dist/store-D0MhBvg6-4Z2L0Kqd.d.mts

@@ -0,0 +1,530 @@
+import { s as PresencePatch } from "./reducer-CYPHsSmd-BQIfozGi.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-D0MhBvg6.d.ts
+//#region src/store.d.ts
+/** A stored event, as the public API exposes it. */
+type Event = {
+  id: string;
+  type: string;
+  payload: unknown;
+  /** Position in the session's event log, from 1. */
+  index: number;
+  sessionId: string;
+  createdAt: Date;
+};
+/** The consumer attempt whose append first persisted a child event. */
+type EventCause = {
+  consumer: string;
+  /** The cursor's lane; null for a concurrent consumer's cursor of one event. */
+  lane: string | null;
+  index: number;
+  attempt: number;
+  /** Size of one named consumer append, used to reject truncated retries. */
+  batchSize?: number;
+};
+/** What the store persists: immutable event history and its causal edge. */
+type StoredEvent = Event & {
+  /** Same-session consumer attempt that appended this event; null means root. */
+  cause: EventCause | null;
+};
+/**
+ * Where a consumer's cursor stands on its head event. A cursor is one record
+ * per (session, consumer, lane): a log cursor for a consumer with one string
+ * lane, a lane cursor per lane for a lane function, and a cursor per event
+ * (lane null) for a concurrent consumer. Its attempt and failure fields
+ * describe the current head and reset when the cursor moves past it.
+ */
+type HeadDispatch = {
+  consumer: string;
+  lane: string | null;
+  /** Adapter clock time recorded by the first durable claim of this head. */
+  firstClaimedAt: Date | null;
+  /** Adapter clock time recorded by the most recent durable claim of this head. */
+  lastClaimedAt: Date | null;
+  /** Durable claims of this head, including claims abandoned by hard kills. */
+  attemptCount: number;
+  /** Current holder; null when the head is not claimed. */
+  claimHolder: string | null;
+  /**
+   * Adapter clock expiry for the current claim, or, with no holder, the end
+   * of a failed attempt's retry hold.
+   */
+  claimExpiresAt: Date | null;
+  /**
+   * Failed attempts on this head: caught failures, and lapsed claims a later
+   * claim took over. This alone drives dead-lettering.
+   */
+  failureCount: number;
+  /** Adapter clock time recorded by the most recent caught failure. */
+  lastFailedAt: Date | null;
+  /** Attempt that produced the most recent caught failure. */
+  lastFailedAttempt: number | null;
+  /** The last failure, stringified. */
+  lastError: string | null;
+  /** Adapter clock time recorded when dead-lettered; null otherwise. */
+  failedAt: Date | null;
+};
+/** Where one cursor stands: its position, its head, and the head's dispatch state. */
+type StoredCursor = HeadDispatch & {
+  /** The last index this cursor finished; a log cursor counts from the latest clear marker. */
+  position: number;
+  /** The event it runs next; null when it has nothing to run. */
+  head: number | null;
+};
+/** A cursor's head event together with its dispatch state. */
+type HeadEvent = StoredEvent & HeadDispatch & {
+  /** Latest clear marker, on claimed heads of a cleared session. */
+  clearIndex?: number;
+};
+/** Names one cursor head: the consumer, its lane, and the head's index. */
+type HeadRef = {
+  consumer: string;
+  lane: string | null;
+  index: number;
+};
+/**
+ * A consumer the caller serves. Work for consumers it does not name is
+ * neither pending nor claimed, so a removed consumer's cursors wait for its
+ * name to return.
+ */
+type StoreConsumer = {
+  name: string;
+  /**
+   * Set for a consumer with one string lane. Its cursor keeps one position
+   * over the log and runs the next event whose type is in `types` (null:
+   * every type). A missing cursor is created by the first append that
+   * carries one of those types: at the start of the log with `backfill`,
+   * otherwise just before that append.
+   */
+  log?: {
+    lane: string;
+    types: readonly string[] | null;
+    backfill: boolean;
+  };
+};
+/**
+ * One live presence value, as `A2Store.presence.read` returns it. The
+ * row is the LWW unit — one participant's one field. `at` is the
+ * sender's stamp, the LWW comparator. `expiresAt` is the storage's
+ * own clock at the applied set plus its `ttlMs` — never derived from
+ * the sender stamp; a row is live strictly before it.
+ */
+type PresenceRow = {
+  participant: string;
+  field: string;
+  value: unknown;
+  seen: number;
+  at: Date;
+  expiresAt: Date;
+};
+/** One consistent cache-plus-tail read for a reducer fold. */
+type StoreStateRead = {
+  /** The current head checkpoint, even when an older historical snapshot is selected. */
+  headIndex: number | null;
+  /** The greatest cached fold at or before the requested snapshot frontier. */
+  snapshot: {
+    index: number;
+    state: unknown;
+  } | null;
+  /** Immutable events strictly after `snapshot.index`, or the full log on a miss. */
+  events: Event[];
+  /** Latest clear marker; omitted when the session was never cleared. */
+  clearIndex?: number;
+};
+type StoreSnapshotWrite = {
+  index: number;
+  state: unknown;
+  /** Unfinished cursor heads that durably retain this exact checkpoint. */
+  pins?: readonly HeadRef[];
+};
+type StoreStateReadRequest = {
+  sessionId: string;
+  throughIndex?: number;
+  snapshotThroughIndex?: number;
+};
+/** The result of atomically claiming every currently eligible head. */
+type StoreClaimAvailableResult = {
+  outcome: "claimed";
+  events: HeadEvent[];
+  /** The session's head when the claim was made: how far behind each event is. */
+  head?: number;
+} | {
+  outcome: "busy";
+  retryAt: Date;
+} | {
+  outcome: "settled";
+};
+/** A completion may lose to a newer claim or an earlier completion. */
+type CompleteAttemptResult = {
+  outcome: "completed";
+  events: StoredEvent[];
+} | {
+  outcome: "superseded";
+};
+/** The result of one claim-renewal heartbeat, both lists in head order. */
+type RenewClaimsResult = {
+  /** Listed claims that remain owned by the holder. */
+  renewed: HeadRef[];
+  /** Listed claims a newer attempt has durably taken, or whose cursor moved on. */
+  superseded: HeadRef[];
+};
+/** The result of atomically recording a caught failure. */
+type FailAttemptResult = {
+  outcome: "failed" | "dead_lettered" | "superseded";
+  failureCount: number;
+};
+/** A consumer an appended event starts work for, with its resolved lane. */
+type EventTarget = {
+  consumer: string;
+  /** The lane a lane function resolved; null runs the event concurrently. */
+  lane: string | null;
+};
+/** Input to `A2Store.append` — already validated by the machine. */
+type AppendEvent = {
+  type: string;
+  payload: unknown;
+  /** Caller-supplied idempotency key; generated when absent. */
+  id?: string;
+  /** Internal causal edge supplied atomically by consumer `session.append`. */
+  cause?: EventCause;
+  /**
+   * Lane-function and concurrent consumers this event starts work for,
+   * resolved before persistence. Log-cursor consumers are matched by type
+   * from `StoreConsumer.log` instead.
+   */
+  targets?: readonly EventTarget[];
+};
+/** A consumer-returned event with the deterministic id retries require. */
+type ReturnedEvent = AppendEvent & {
+  id: string;
+};
+/** The rows written by an append and the session's pending state. */
+type StoreAppendResult = {
+  events: StoredEvent[];
+  /**
+   * Whether a served consumer has a live head in this session: one that is
+   * not dead-lettered. An append whose own batch starts work for a served
+   * consumer may report true without checking that work is runnable.
+   */
+  hasPending: boolean;
+};
+type StoreClearOptions = {
+  sessionId: string;
+  ifLastIndex?: number;
+  /** The clearing consumer's attempt, fenced like a consumer append. */
+  cause?: EventCause;
+};
+type StoreClearResult = {
+  cleared: boolean;
+  /** The head after the operation. */
+  index: number;
+  /** The latest clear marker after the operation, or 0. */
+  clearIndex: number;
+};
+type StoreReclaimResult = {
+  deleted: number;
+  done: boolean;
+};
+type StoreRedriveOptions = {
+  sessionId: string;
+  consumer: string;
+  index: number;
+  /** `retry` clears the dead letter; `skip` moves the cursor past it. */
+  action: "retry" | "skip";
+  consumers?: readonly StoreConsumer[];
+};
+type StoreRedriveResult = {
+  /** Whether the head was dead-lettered and this operation resolved it. */
+  redriven: boolean;
+  /** Whether a served consumer has a live head in this session: one that is not dead-lettered. */
+  hasPending: boolean;
+};
+/**
+ * An injectable clock. Adapters take one so tests can drive claim
+ * expiry, failure timestamps, and (later) stuck-session detection
+ * deterministically — against real storage, no mocking.
+ */
+type Clock = {
+  now(): Date;
+};
+/**
+ * Cursor rules every operation shares:
+ *
+ * - `consumers` names the consumers the caller serves. Omitted, every cursor
+ *   counts and no log cursor is created or advanced by type.
+ * - A cursor's head is the next event it runs: the lowest unfinished event of
+ *   its lane, the event itself for a concurrent cursor, or for a log cursor
+ *   the next event after its position whose type it takes. The clear marker
+ *   is never a head.
+ * - A head is eligible when no live claim or retry hold owns it, it is not
+ *   dead-lettered, and it lies above the latest clear marker.
+ * - Moving a cursor past its head resets the head's attempt and failure
+ *   fields and releases snapshot pins on it.
+ */
+interface A2Store {
+  /**
+   * Accepts a batch; the batch is atomic — one transaction, consecutive
+   * `index`es, all-or-nothing. The idempotency key covers the whole
+   * operation, not each item: if *every* event's `id` already exists in
+   * this session, this is a retry of a committed batch whose ack was
+   * lost — return the existing rows as success. If only *some* ids
+   * exist, the caller mixed an already-sent batch with fresh events —
+   * always a caller bug — so throw `A2Error('PARTIAL_DUPLICATE_BATCH')`.
+   * Ids are unique per session: the same id in another session names a
+   * different event and plays no part in these checks.
+   *
+   * In the same atomic operation, each event's `targets` start cursor work:
+   * a lane target queues the event in that consumer's lane, a null lane
+   * creates a cursor for that event alone. Each log consumer in `consumers`
+   * whose types the batch carries gets its cursor created or, when idle, a
+   * head: the next event after its position that it takes, which may
+   * precede the batch when an appender that doesn't serve it wrote in
+   * between. `hasPending` reflects the whole session for the served consumers,
+   * including older work and idempotent retries.
+   *
+   * An event carrying `cause` is a consumer append, fenced by attempt
+   * currency: accept it only while the cause's cursor still has
+   * `cause.index` as its head, `cause.attempt` is that head's latest
+   * attempt, and the head is not dead-lettered; otherwise throw
+   * `A2Error('SUPERSEDED_ATTEMPT')` and write nothing. The check is part of
+   * this atomic operation and must serialize against a concurrent
+   * `claimAvailable` — an unlocked read of the cursor admits write skew. The
+   * idempotent-replay path runs first, so a batch whose ids all exist
+   * replays regardless of the current attempt.
+   *
+   * Clearing stores (a2-implementation.md §17.2) fence one level earlier:
+   * a `cause` at or below the latest clear marker throws
+   * `SUPERSEDED_ATTEMPT`, an `originIndex` there throws `SESSION_CLEARED`,
+   * and ids whose rows lie below the marker are free to reuse.
+   */
+  append(sessionId: string, events: AppendEvent[], options?: {
+    originIndex?: number;
+    consumers?: readonly StoreConsumer[];
+  }): Promise<StoreAppendResult>;
+  /**
+   * Optional with `reclaim`. Serialized with `append`: checks
+   * `ifLastIndex` against the head and the latest marker, then appends a
+   * clear marker at the next index without touching existing rows.
+   * Afterwards every event at or below the marker is superseded: no head
+   * lies there, and every log cursor's position counts from the marker.
+   */
+  clear?(options: StoreClearOptions): Promise<StoreClearResult>;
+  /**
+   * Deletes one bounded batch of rows below the latest clear marker, with
+   * their cursor records, id records, and cached folds. `done` once nothing
+   * remains below it. Never waits on a lock that other operations hold.
+   */
+  reclaim?(sessionId: string): Promise<StoreReclaimResult>;
+  /**
+   * Optional with `redrive`. The session's dead-lettered heads above the
+   * latest clear marker, in event order, then by consumer name.
+   */
+  deadLetters?(sessionId: string): Promise<HeadEvent[]>;
+  /**
+   * Optional with `deadLetters`. Atomically resolves the consumer's
+   * dead-lettered head at `index` above the latest clear marker; anything
+   * else is untouched and reports `redriven: false`. `retry` clears
+   * `failedAt` and `failureCount`, so the head is claimable again with a
+   * fresh failure budget, keeping its claim history and last failure. `skip`
+   * moves the cursor past the head with no completion. Both serialize with
+   * `claimAvailable` and the consumer-append fence. `hasPending` is read in
+   * the same step.
+   */
+  redrive?(options: StoreRedriveOptions): Promise<StoreRedriveResult>;
+  /**
+   * Brings one log consumer's cursor up to date without an append, for
+   * `session.consume()`. A missing cursor is created: with `backfill`, at
+   * the latest clear marker, taking the first event of its types after it;
+   * otherwise at the head, with nothing to run. When the session has nothing
+   * after its latest clear (or was never written), a missing cursor stays
+   * missing: nothing is written, and the cursor comes back idle at the
+   * marker, so a consume of an unknown session leaves no trace. That is
+   * exact with `backfill`; without it, the consumer starts at the first
+   * consume or serving append that finds events. An
+   * idle cursor takes the next event of its types after its position, so it
+   * finds events appended by deployments that don't serve it. A cursor with
+   * a head, claimed or not, is left as it is. Records the consumer's types,
+   * as an append would, and returns the cursor and the session's head.
+   */
+  wakeLog(options: {
+    sessionId: string;
+    consumer: StoreConsumer & {
+      log: NonNullable<StoreConsumer["log"]>;
+    };
+  }): Promise<{
+    cursor: StoredCursor;
+    head: number;
+  }>;
+  /**
+   * The session's cursors: every log and lane cursor, and every concurrent
+   * cursor that still has a head, by consumer, then lane (concurrent cursors
+   * last, by head). Lane and concurrent cursors whose work lies at or below
+   * the latest clear marker are not listed.
+   */
+  cursors(sessionId: string): Promise<StoredCursor[]>;
+  /** Events for one session, oldest first. Bounds form `(afterIndex, throughIndex]`. */
+  read(sessionId: string, opts?: {
+    afterIndex?: number;
+    throughIndex?: number;
+  }): Promise<StoredEvent[]>;
+  /** Public history without causal edges; core falls back to read when absent. */
+  readHistory?(sessionId: string, opts?: {
+    afterIndex?: number;
+    throughIndex?: number;
+  }): Promise<Event[]>;
+  /**
+   * Atomically claims every eligible head of the served consumers. A live
+   * claim or retry hold produces `busy` only when it is the sole remaining
+   * obstacle to actionable work. Claimed heads are returned in event order,
+   * then by consumer name. Excluded heads stay unclaimed and keep blocking
+   * their lane.
+   */
+  claimAvailable(options: {
+    sessionId: string;
+    holder: string;
+    ttlMs: number;
+    expiresAtMs?: number;
+    exclude?: readonly HeadRef[];
+    consumers?: readonly StoreConsumer[];
+    /**
+     * Taking over a lapsed claim (one whose holder is still recorded, never
+     * completed or failed) adds one to `failureCount`. When that reaches
+     * `maxFailures`, the head dead-letters instead of being claimed: it
+     * comes back in `events` with `failedAt` set and no claim. Its
+     * `attemptCount` still advances, fencing the lapsed attempt, and its
+     * `lastFailedAttempt` is unchanged.
+     */
+    maxFailures?: number;
+    /**
+     * Claims only heads at or below this index: a head past it is neither
+     * claimed nor reported `busy`, and stays claimable without it.
+     */
+    through?: number;
+  }): Promise<StoreClaimAvailableResult>;
+  /**
+   * Renews the listed live claims still owned by `holder`. Each listed claim
+   * carries the attempt the holder owns. `renewed` lists the claims that
+   * remain owned after the operation; `superseded` lists the claims whose
+   * head a newer attempt has durably taken, or whose cursor has moved past
+   * it. An expired claim no successor has taken appears in neither list — its
+   * attempt may still complete (`completeAttempt` is the fence), so it is
+   * not reported as lost. Renewal never revives an expired claim.
+   */
+  renewClaims(options: {
+    sessionId: string;
+    holder: string;
+    claims: readonly (HeadRef & {
+      attempt: number;
+    })[];
+    ttlMs: number;
+    expiresAtMs?: number;
+  }): Promise<RenewClaimsResult>;
+  /**
+   * Atomically completes one current attempt: appends its returned events
+   * (with their own targets, waking the served log consumers) and moves the
+   * cursor past its head. Retrying a committed completion with the same
+   * attempt and deterministic child ids returns the existing children. A
+   * stale attempt never appends.
+   */
+  completeAttempt(options: {
+    sessionId: string;
+    consumer: string;
+    lane: string | null;
+    index: number;
+    attempt: number;
+    events: ReturnedEvent[];
+    consumers?: readonly StoreConsumer[];
+  }): Promise<CompleteAttemptResult>;
+  /**
+   * Atomically records a caught failure for one claimed attempt. A stale
+   * attempt cannot poison a finished head or a newer attempt. Accepted
+   * failures record the operation's clock time. A failure that does not
+   * dead-letter releases the claim and, with `retryAfterMs`, keeps the head
+   * unclaimable for that long: its claim expiry is set with no holder, so
+   * `claimAvailable` reports it `busy` until then.
+   */
+  failAttempt(options: {
+    sessionId: string;
+    consumer: string;
+    lane: string | null;
+    index: number;
+    attempt: number;
+    error: string;
+    maxFailures: number;
+    retryAfterMs?: number;
+  }): Promise<FailAttemptResult>;
+  /**
+   * Reads a reducer snapshot and its event tail as one consistent adapter
+   * operation. On a cache miss, `snapshot` is null and `events` is the full
+   * log. The snapshot is untrusted; core may reject it and issue a full
+   * `read()` when its state schema no longer accepts the cached value.
+   * Operational failures propagate without falling back to a full-log read.
+   */
+  readState(sessionId: string, reducerName: string, options?: {
+    throughIndex?: number;
+    snapshotThroughIndex?: number;
+  }): Promise<StoreStateRead>;
+  /**
+   * Optional batched `readState` — one consistent snapshot-plus-tail read
+   * per session id, aligned positionally with the input (duplicates
+   * allowed). Each element has its own frontier; the batch makes no
+   * cross-session consistency claim. Core falls back to parallel
+   * `readState` calls when absent.
+   */
+  readStates?(requests: readonly StoreStateReadRequest[], reducerName: string): Promise<StoreStateRead[]>;
+  /**
+   * Atomically writes disposable reducer checkpoints. The greatest index
+   * advances the head cache. Older checkpoints survive only while at least
+   * one listed cursor head is still unfinished; moving that cursor past it
+   * or dead-lettering it releases the pin and collects unreferenced
+   * historical checkpoints.
+   */
+  putSnapshots(sessionId: string, reducerName: string, snapshots: readonly StoreSnapshotWrite[]): Promise<void>;
+  /**
+   * Optional ephemeral-plane capability (specs/a2-implementation.md
+   * §15.1) — optional like snapshots are. Values arrive already
+   * validated by core; adapters store them opaquely. Presence never
+   * touches the event log: no index, no history row, no recovery arm.
+   */
+  presence?: {
+    /**
+     * Field-wise last-writer-wins merge of one participant's values:
+     * a field whose unexpired entry has a strictly newer `at` (the
+     * sender's stamp) is left untouched. `null` deletes the value but
+     * keeps a tombstone with its `at`, which takes part in the merge
+     * like a value until it expires, so a set older than the delete
+     * still loses when it arrives later. Every applied write, value or
+     * tombstone, refreshes that field's expiry to the storage's own
+     * clock plus `ttlMs` — the sender stamp orders writes but never
+     * anchors their lifetime. `subscribe` delivers applied writes only,
+     * a delete as `null`.
+     */
+    set(ns: string, participant: string, values: Record<string, unknown | null>, meta: {
+      seen: number;
+      at: Date;
+      ttlMs: number;
+    }): Promise<void>;
+    /**
+     * The current map, pruned of rows at or past their `expiresAt`.
+     * Tombstones never appear.
+     */
+    read(ns: string): Promise<PresenceRow[]>;
+    /**
+     * Adapter-managed patch delivery. Without it, live feeds re-read
+     * presence on their poll cadence. HTTP Redis uses adaptive polling
+     * here when its endpoint does not support subscriptions.
+     */
+    subscribe?(ns: string, onPatch: (patch: PresencePatch) => void): () => void;
+  };
+  /**
+   * A live feed of one session's events, starting after `startAfter`
+   * (exclusive). Transport is the backend's choice — in-process pub/sub,
+   * polling, LISTEN/NOTIFY — callers never branch on which. The iterable
+   * ends when the consumer calls `return()` (e.g. a disconnecting SSE
+   * client) and must deliver events appended after subscription.
+   */
+  stream(sessionId: string, opts?: {
+    startAfter?: number;
+  }): AsyncIterable<Event>;
+}
+//#endregion
+export { Clock as n, Event as r, A2Store as t };

package/dist/store-N8PXxDAS-BWBgzBHp.mjs

@@ -0,0 +1,5 @@
+//#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-N8PXxDAS.js
+const SYSTEM_CLOCK = { now: () => /* @__PURE__ */ new Date() };
+const RANDOM_IDS = () => crypto.randomUUID();
+//#endregion
+export { SYSTEM_CLOCK as n, RANDOM_IDS as t };

package/dist/store-codec-DwrWlgQx-CYxGW0aD.mjs

@@ -0,0 +1,61 @@
+import { t as A2Error } from "./session-clear-wHd5GCpZ-BnKSxReK.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-codec-DwrWlgQx.js
+const canonicalJson = (value) => JSON.stringify(value, (_key, candidate) => {
+	if (candidate === null || typeof candidate !== "object" || Array.isArray(candidate)) return candidate;
+	return Object.fromEntries(Object.entries(candidate).toSorted(([left], [right]) => left < right ? -1 : left > right ? 1 : 0));
+}) ?? "null";
+const idempotentReplay = (events, existing) => {
+	const byId = new Map(existing.map((event) => [event.id, event]));
+	const ordered = events.map((event) => event.id === void 0 ? void 0 : byId.get(event.id));
+	const firstIndex = ordered[0]?.index;
+	const batchSize = events[0]?.cause?.batchSize;
+	if (firstIndex === void 0 || batchSize !== void 0 && batchSize !== events.length || ordered.some((stored, index) => {
+		const event = events[index];
+		return stored === void 0 || stored.index !== firstIndex + index || stored.type !== event.type || stored.cause?.batchSize !== event.cause?.batchSize || canonicalJson(stored.payload) !== canonicalJson(event.payload);
+	})) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "already-appended events do not match the retried batch");
+	return ordered;
+};
+const decodeReturnedEventIds = (value) => {
+	const decoded = typeof value === "string" ? JSON.parse(value) : value;
+	if (!Array.isArray(decoded) || decoded.some((eventId) => typeof eventId !== "string")) throw new TypeError("stored event has invalid returned event ids");
+	return decoded;
+};
+const positive = (value) => Number.isInteger(value) && Number(value) >= 1;
+/** A stored causal edge, from its JSON text or parsed value. */
+const decodeCause = (value) => {
+	if (value === null || value === void 0) return null;
+	const decoded = typeof value === "string" ? JSON.parse(value) : value;
+	if (typeof decoded.consumer !== "string" || decoded.consumer.length === 0 || decoded.lane !== null && typeof decoded.lane !== "string" || !positive(decoded.index) || !positive(decoded.attempt) || decoded.batchSize !== void 0 && !positive(decoded.batchSize)) throw new TypeError("stored event has an invalid cause");
+	return {
+		consumer: decoded.consumer,
+		lane: decoded.lane,
+		index: Number(decoded.index),
+		attempt: Number(decoded.attempt),
+		...decoded.batchSize === void 0 ? {} : { batchSize: Number(decoded.batchSize) }
+	};
+};
+/** The key of a cursor within its consumer: its lane, or its one event. */
+const cursorKeyOf = (lane, index) => lane === null ? `#${index}` : `L${lane}`;
+/**
+* A log cursor a store doesn't hold, at `position` with nothing to run:
+* what `wakeLog` returns for a session with nothing after its latest clear,
+* where it writes nothing.
+*/
+const idleLogCursor = (consumer, lane, position) => ({
+	consumer,
+	lane,
+	position,
+	head: null,
+	firstClaimedAt: null,
+	lastClaimedAt: null,
+	attemptCount: 0,
+	claimHolder: null,
+	claimExpiresAt: null,
+	failureCount: 0,
+	lastFailedAt: null,
+	lastFailedAttempt: null,
+	lastError: null,
+	failedAt: null
+});
+//#endregion
+export { idleLogCursor as a, idempotentReplay as i, decodeCause as n, decodeReturnedEventIds as r, cursorKeyOf as t };