experimental-a2 0.20.0 → 0.22.0

package/dist/session-clear-C-QwTXV1.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"session-clear-C-QwTXV1.d.ts","names":[],"sources":["../src/session-clear.ts"],"mappings":";;;cAOa;;KAGD,iBAAiB;EAC3B,aAAa;EACb"}

package/dist/session-clear-DGI4jTQ5.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"session-clear-DGI4jTQ5.js","names":[],"sources":["../src/errors.ts","../src/session-clear.ts"],"sourcesContent":["export type A2ServerErrorCode =\n  | 'INVALID_PAYLOAD' // schema validation failed — thrown before anything is written\n  | 'FORBIDDEN' // external ingress was denied by server.fetch authorization\n  | 'UNKNOWN_EVENT_TYPE' // event type not in the machine's `events` map\n  | 'PARTIAL_DUPLICATE_BATCH' // batch mixed already-appended and fresh events\n  | 'SUPERSEDED_ATTEMPT' // handler append from an attempt a recovery claim or a clear replaced\n  | 'SESSION_CLEARED' // a read or call reached across the session's latest clear\n  | 'CLAIM_EXPIRED' // ctx.signal abort reason: the attempt's lease lapsed without renewal\n  | 'STORE_UNAVAILABLE' // store backend failure — retryable, nothing was written\n  | 'STORE_NOT_CONFIGURED' // no `store` in production, a missing peer dependency, or Postgres lacks A2's tables\n  | 'UNKNOWN_PRESENCE_FIELD' // presence field not in the contract's `presence` map\n  | 'PRESENCE_NOT_SUPPORTED' // contract declares presence but the store lacks the capability\n\nexport type A2ErrorCode =\n  A2ServerErrorCode | 'TIMEOUT' | 'HTTP_ERROR' | 'CONNECTION_FAILED' | 'UNKNOWN'\n\nexport class A2Error extends Error {\n  readonly code: A2ErrorCode\n  /** e.g. the Standard Schema issues for INVALID_PAYLOAD */\n  readonly details: unknown\n\n  constructor(\n    code: A2ErrorCode,\n    message: string,\n    options?: { details?: unknown; cause?: unknown },\n  ) {\n    super(\n      message,\n      options && 'cause' in options ? { cause: options.cause } : undefined,\n    )\n    this.name = 'A2Error'\n    this.code = code\n    this.details = options?.details\n  }\n}\n\n/** A handler write whose attempt no longer owns its triggering event. */\nexport function supersededAttemptError(\n  sessionId: string,\n  cause: { index: number; attempt: number },\n): A2Error {\n  return new A2Error(\n    'SUPERSEDED_ATTEMPT',\n    `attempt ${cause.attempt} no longer owns event ${cause.index} in session '${sessionId}'`,\n  )\n}\n\n/**\n * Wrap an arbitrary thrown value as STORE_UNAVAILABLE, preserving the\n * original as `cause`. A2Errors pass through untouched — they already\n * carry their own meaning.\n */\nexport function asStoreUnavailable(err: unknown): A2Error {\n  if (err instanceof A2Error) return err\n  return new A2Error('STORE_UNAVAILABLE', 'the store backend failed', {\n    cause: err,\n  })\n}\n\n/**\n * Throw from a handler to reject retrying: the failure is adjudicated\n * terminal immediately (dead-lettered on the first throw) instead of\n * consuming the ten-failure retry budget. For deterministic failures —\n * a guard that will refuse identically on every attempt — retrying is\n * waste and dead-lettering is the honest outcome. Matched by\n * `instanceof`, so subclasses carry domain meaning.\n */\nexport class NonRetriableError extends Error {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super(message, options)\n    this.name = 'NonRetriableError'\n  }\n}\n","import { A2Error } from './errors.ts'\nimport type { Event } from './store.ts'\n\n/** A2's own event types start with this; application contracts cannot. */\nexport const RESERVED_EVENT_PREFIX = 'a2.'\n\n/** Reserved type of the marker a clear appends. */\nexport const CLEAR_EVENT_TYPE = 'a2.cleared'\n\n/** The marker `session.stream()` yields where a clear ended a lifetime. */\nexport type SessionCleared = Event & {\n  type: typeof CLEAR_EVENT_TYPE\n  payload: null\n}\n\n/** Accepts any stream item, including presence patches and snapshots. */\nexport function isSessionCleared(item: object): item is SessionCleared {\n  return (item as { type?: unknown }).type === CLEAR_EVENT_TYPE\n}\n\nexport function sessionClearedError(message: string): A2Error {\n  return new A2Error('SESSION_CLEARED', message)\n}\n"],"mappings":";AAgBA,IAAa,UAAb,cAA6B,MAAM;CACjC;;CAEA;CAEA,YACE,MACA,SACA,SACA;EACA,MACE,SACA,WAAW,WAAW,UAAU,EAAE,OAAO,QAAQ,MAAM,IAAI,KAAA,CAC7D;EACA,KAAK,OAAO;EACZ,KAAK,OAAO;EACZ,KAAK,UAAU,SAAS;CAC1B;AACF;;AAGA,SAAgB,uBACd,WACA,OACS;CACT,OAAO,IAAI,QACT,sBACA,WAAW,MAAM,QAAQ,wBAAwB,MAAM,MAAM,eAAe,UAAU,EACxF;AACF;;;;;;AAOA,SAAgB,mBAAmB,KAAuB;CACxD,IAAI,eAAe,SAAS,OAAO;CACnC,OAAO,IAAI,QAAQ,qBAAqB,4BAA4B,EAClE,OAAO,IACT,CAAC;AACH;;;;;;;;;AAUA,IAAa,oBAAb,cAAuC,MAAM;CAC3C,YAAY,SAAiB,SAA+B;EAC1D,MAAM,SAAS,OAAO;EACtB,KAAK,OAAO;CACd;AACF;;;;ACjEA,MAAa,mBAAmB;;AAShC,SAAgB,iBAAiB,MAAsC;CACrE,OAAQ,KAA4B,SAAS;AAC/C;AAEA,SAAgB,oBAAoB,SAA0B;CAC5D,OAAO,IAAI,QAAQ,mBAAmB,OAAO;AAC/C"}

package/dist/store-CyLUy86v.d.ts

@@ -1,404 +0,0 @@
-import { p as PresencePatch } from "./reducer-CqA59Q6U.js";
-//#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 handler dispatch whose append first persisted a child event. */
-type EventCause = {
-  index: number;
-  attempt: number;
-  /** Size of one named handler append, used to reject truncated retries. */
-  batchSize?: number;
-};
-/**
- * What the store persists: immutable event history, including its causal edge,
- * plus derived dispatch and failure bookkeeping. The bookkeeping is disposable;
- * the event and its cause are not.
- */
-type StoredEvent = Event & {
-  /** Same-session handler dispatch that appended this event; null means root. */
-  cause: EventCause | null;
-  /** Session-scoped serial execution key resolved when the event is appended. */
-  lane: string | null;
-  /** Adapter clock time recorded by append settlement, completion, or manual skip; null while pending. */
-  processedAt: Date | null;
-  /** Dispatch attempt that completed this event; null without dispatch or while pending. */
-  processedByAttempt: number | null;
-  /** Exact ordered child ids atomically returned by the completing attempt. */
-  returnedEventIds: string[] | null;
-  /** Adapter clock time recorded by the first durable dispatch claim. */
-  firstClaimedAt: Date | null;
-  /** Adapter clock time recorded by the most recent durable dispatch claim. */
-  lastClaimedAt: Date | null;
-  /** Durable dispatch claims, including claims abandoned by hard kills. */
-  attemptCount: number;
-  /** Current dispatch holder; null when the event is not claimed. */
-  claimHolder: string | null;
-  /**
-   * Adapter clock expiry for the current dispatch claim, or, with no holder,
-   * the end of a failed attempt's retry hold.
-   */
-  claimExpiresAt: Date | null;
-  /**
-   * Failed attempts: caught handler 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 handler failure. */
-  lastFailedAt: Date | null;
-  /** Dispatch attempt that produced the most recent caught handler failure. */
-  lastFailedAttempt: number | null;
-  /** The last handler failure, stringified. */
-  lastError: string | null;
-  /** Adapter clock time recorded when dead-lettered; null otherwise. */
-  failedAt: Date | null;
-  /** Latest clear marker, on claimed events of a cleared session. */
-  clearIndex?: number;
-};
-/**
- * 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 trigger events that durably retain this exact checkpoint. */
-  pinEventIndexes?: readonly number[];
-};
-type StoreStateReadRequest = {
-  sessionId: string;
-  throughIndex?: number;
-  snapshotThroughIndex?: number;
-};
-/** The result of atomically claiming every currently eligible event. */
-type StoreClaimAvailableResult = {
-  outcome: "claimed";
-  events: StoredEvent[];
-} | {
-  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 append order. */
-type RenewClaimsResult = {
-  /** Listed claims that remain owned by the holder. */
-  renewed: number[];
-  /** Listed claims whose event a newer attempt has durably taken. */
-  superseded: number[];
-};
-/** The result of atomically recording a caught handler failure. */
-type FailAttemptResult = {
-  outcome: "failed" | "dead_lettered" | "superseded";
-  failureCount: number;
-};
-/** 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 handler `session.append`. */
-  cause?: EventCause;
-  /** Session-scoped serial execution key resolved before persistence. */
-  lane?: string;
-  /** Internal hint: settle this event in the append transaction; no handler is registered. */
-  settled?: true;
-};
-/** A handler-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 the session contains an event without a completion marker. */
-  hasPending: boolean;
-};
-type StoreClearOptions = {
-  sessionId: string;
-  ifLastIndex?: number;
-  /** The clearing handler's dispatch, fenced like a handler 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;
-  index: number;
-  /** `retry` clears the dead letter; `skip` settles it without a handler. */
-  action: "retry" | "skip";
-};
-type StoreRedriveResult = {
-  /** Whether the event was dead-lettered and this operation resolved it. */
-  redriven: boolean;
-  /** Whether the session contains an event without a completion marker. */
-  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;
-};
-/** An injectable id source for generated event ids. */
-type IdSource = () => string;
-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')`.
-   * Events carrying `settled: true` get `processedAt` in this same atomic
-   * operation, with no dispatch claim or `processedByAttempt`. The result's
-   * `hasPending` reflects the whole session in the same atomic operation,
-   * including older events and idempotent retries.
-   *
-   * An event carrying `cause` is a handler append, fenced by attempt
-   * currency: accept it only while `cause.attempt` is still the parent
-   * event's latest attempt and the parent 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 parent 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;
-  }): Promise<StoreAppendResult>;
-  /**
-   * Optional with `reclaim`. Serialized with `append`: checks
-   * `ifLastIndex` against the head and the latest marker, then appends a
-   * settled clear marker at the next index without touching existing
-   * rows. Afterwards every event at or below the marker is superseded.
-   */
-  clear?(options: StoreClearOptions): Promise<StoreClearResult>;
-  /**
-   * Deletes one bounded batch of rows below the latest clear marker, with
-   * their bookkeeping, 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 events above the
-   * latest clear marker, oldest first.
-   */
-  deadLetters?(sessionId: string): Promise<StoredEvent[]>;
-  /**
-   * Optional with `deadLetters`. Atomically resolves one dead-lettered event
-   * above the latest clear marker; any other event is untouched and reports
-   * `redriven: false`. `retry` clears `failedAt` and `failureCount`, so the
-   * event is claimable again with a fresh failure budget, keeping its claim
-   * history and last failure. `skip` records `processedAt` with no
-   * `processedByAttempt` or `returnedEventIds` and exposes the next event in
-   * its lane. Both serialize with `claimAvailable` and the handler-append
-   * parent fence; `skip` also serializes with lane promotion in `append` and
-   * `completeAttempt`. `hasPending` is read in the same step.
-   */
-  redrive?(options: StoreRedriveOptions): Promise<StoreRedriveResult>;
-  /** Events for one session, oldest first. Bounds form `(afterIndex, throughIndex]`. */
-  read(sessionId: string, opts?: {
-    afterIndex?: number;
-    throughIndex?: number;
-  }): Promise<StoredEvent[]>;
-  /** Public history without dispatch metadata; core falls back to read when absent. */
-  readHistory?(sessionId: string, opts?: {
-    afterIndex?: number;
-    throughIndex?: number;
-  }): Promise<Event[]>;
-  /**
-   * Atomically claims every eligible pending event. Unlaned events are all
-   * independently eligible. Within a lane, only the lowest-index unfinished
-   * event is eligible. A live claim produces `busy` only when it is the sole
-   * remaining obstacle to actionable work. Claimed events are returned in event-log
-   * order. Excluded rows remain lane barriers.
-   */
-  claimAvailable(options: {
-    sessionId: string;
-    holder: string;
-    ttlMs: number;
-    expiresAtMs?: number;
-    excludeIndexes?: readonly number[];
-    /**
-     * Taking over a lapsed claim (one whose holder is still recorded, never
-     * completed or failed) adds one to `failureCount`. When that reaches
-     * `maxFailures`, the event 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;
-  }): Promise<StoreClaimAvailableResult>;
-  /**
-   * Renews the listed live claims still owned by `holder`. Each listed claim
-   * carries the attempt ordinal the holder owns. `renewed` lists the claims
-   * that remain owned after the operation; `superseded` lists the claims
-   * whose event's `attemptCount` has durably passed the listed attempt. 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 {
-      index: number;
-      attempt: number;
-    }[];
-    ttlMs: number;
-    expiresAtMs?: number;
-  }): Promise<RenewClaimsResult>;
-  /**
-   * Atomically completes one current attempt and appends its returned events.
-   * 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;
-    index: number;
-    attempt: number;
-    events: ReturnedEvent[];
-  }): Promise<CompleteAttemptResult>;
-  /**
-   * Atomically records a caught failure for one claimed attempt. A stale
-   * attempt cannot poison a processed event or a newer dispatch. Accepted
-   * failures record the operation's clock time. A failure that does not
-   * dead-letter releases the claim and, with `retryAfterMs`, keeps the event
-   * unclaimable for that long: its claim expiry is set with no holder, so
-   * `claimAvailable` reports it `busy` until then.
-   */
-  failAttempt(options: {
-    sessionId: string;
-    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 when at least one
-   * listed trigger event is still unfinished; completion and dead-lettering
-   * release that event's pins and collect 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 existing row has a strictly newer `at` (the
-     * sender's stamp) is left untouched; `null` deletes the row. Every
-     * applied write refreshes that field's expiry to the storage's own
-     * clock plus `ttlMs` — the sender stamp orders writes but never
-     * anchors their lifetime.
-     */
-    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`. */
-    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 { EventCause as a, PresenceRow as c, StoreStateRead as d, StoredEvent as f, Event as i, StoreAppendResult as l, AppendEvent as n, FailAttemptResult as o, Clock as r, IdSource as s, A2Store as t, StoreClaimAvailableResult as u };
-//# sourceMappingURL=store-CyLUy86v.d.ts.map

package/dist/store-CyLUy86v.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"store-CyLUy86v.d.ts","names":[],"sources":["../src/store.ts"],"mappings":";;;KAaY;EACV;EACA;EACA;;EAEA;EACA;EACA,WAAW;;;KAID;EACV;EACA;;EAEA;;;;;;;KAQU,cAAc;;EAExB,OAAO;;EAEP;;EAEA,aAAa;;EAEb;;EAEA;;EAEA,gBAAgB;;EAEhB,eAAe;;EAEf;;EAEA;;;;;EAKA,gBAAgB;;;;;EAKhB;;EAEA,cAAc;;EAEd;;EAEA;;EAEA,UAAU;;EAEV;;;;;;;;;KAUU;EACV;EACA;EACA;EACA;EACA,IAAI;EACJ,WAAW;;;KAID;;EAEV;;EAEA;IAAY;IAAe;;;EAE3B,QAAQ;;EAER;;KAGU;EACV;EACA;;EAEA;;KAGU;EACV;EACA;EACA;;;KAGU;EACN;EAAoB,QAAQ;;EAC5B;EAAiB,SAAS;;EAC1B;;;KAGM;EACR;EAAsB,QAAQ;;EAAoB;;;KAG1C;;EAEV;;EAEA;;;KAIU;EACV;EACA;;;KAIU;EACV;EACA;;EAEA;;EAEA,QAAQ;;EAER;;EAEA;;;KAIU,gBAAgB;EAAgB;;;KAGhC;EACV,QAAQ;;EAER;;KAGU;EACV;EACA;;EAEA,QAAQ;;KAGE;EACV;;EAEA;;EAEA;;KAGU;EAAuB;EAAiB;;KAExC;EACV;EACA;;EAEA;;KAGU;;EAEV;;EAEA;;;;;;;KAQU;EACV,OAAO;;;KAIG;UAQK;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4Bf,OACE,mBACA,QAAQ,eACR;IAAY;MACX,QAAQ;;;;;;;EAQX,OAAO,SAAS,oBAAoB,QAAQ;;;;;;EAO5C,SAAS,oBAAoB,QAAQ;;;;;EAMrC,aAAa,oBAAoB,QAAQ;;;;;;;;;;;;EAazC,SAAS,SAAS,sBAAsB,QAAQ;;EAGhD,KACE,mBACA;IAAS;IAAqB;MAC7B,QAAQ;;EAGX,aACE,mBACA;IAAS;IAAqB;MAC7B,QAAQ;;;;;;;;EASX,eAAe;IACb;IACA;IACA;IACA;IACA;;;;;;;;;IASA;MACE,QAAQ;;;;;;;;;;EAWZ,YAAY;IACV;IACA;IACA;MAAmB;MAAe;;IAClC;IACA;MACE,QAAQ;;;;;;EAOZ,gBAAgB;IACd;IACA;IACA;IACA,QAAQ;MACN,QAAQ;;;;;;;;;EAUZ,YAAY;IACV;IACA;IACA;IACA;IACA;IACA;MACE,QAAQ;;;;;;;;EASZ,UACE,mBACA,qBACA;IAAY;IAAuB;MAClC,QAAQ;;;;;;;;EASX,YACE,mBAAmB,yBACnB,sBACC,QAAQ;;;;;;;EAQX,aACE,mBACA,qBACA,oBAAoB,uBACnB;;;;;;;EAQH;;;;;;;;;IASE,IACE,YACA,qBACA,QAAQ,gCACR;MAAQ;MAAc,IAAI;MAAM;QAC/B;;IAGH,KAAK,aAAa,QAAQ;;;;;;IAO1B,WAAW,YAAY,UAAU,OAAO;;;;;;;;;EAU1C,OACE,mBACA;IAAS;MACR,cAAc"}

package/dist/store-codec-DTG0Ftek.js

@@ -1,10 +0,0 @@
-//#region src/store-codec.ts
-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;
-};
-//#endregion
-export { decodeReturnedEventIds as t };
-
-//# sourceMappingURL=store-codec-DTG0Ftek.js.map

package/dist/store-codec-DTG0Ftek.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"store-codec-DTG0Ftek.js","names":[],"sources":["../src/store-codec.ts"],"sourcesContent":["export const decodeReturnedEventIds = (value: unknown): string[] => {\n  const decoded: unknown = typeof value === 'string' ? JSON.parse(value) : value\n  if (\n    !Array.isArray(decoded) ||\n    decoded.some((eventId) => typeof eventId !== 'string')\n  ) {\n    throw new TypeError('stored event has invalid returned event ids')\n  }\n  return decoded\n}\n"],"mappings":";AAAA,MAAa,0BAA0B,UAA6B;CAClE,MAAM,UAAmB,OAAO,UAAU,WAAW,KAAK,MAAM,KAAK,IAAI;CACzE,IACE,CAAC,MAAM,QAAQ,OAAO,KACtB,QAAQ,MAAM,YAAY,OAAO,YAAY,QAAQ,GAErD,MAAM,IAAI,UAAU,6CAA6C;CAEnE,OAAO;AACT"}

package/dist/store-presence-polling-B1ixeqIS.js

@@ -1,94 +0,0 @@
-import { i as POLL_TIMINGS } from "./internal-CscSY7K_.js";
-import { t as defaultSleep } from "./store-polling-7WJV0YWP.js";
-//#region src/store-presence-polling.ts
-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);
-	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;
-				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: /* @__PURE__ */ new Date()
-					});
-				}
-				if (changed) activate();
-				else if (version === before) interval = Math.min(interval * 2, POLL_TIMINGS.idleCeilingMs);
-			} catch {
-				interval = POLL_TIMINGS.idleCeilingMs;
-			}
-		}
-	};
-	run();
-	return {
-		ready,
-		wake: activate,
-		update(patch) {
-			for (const [field, value] of Object.entries(patch.values)) seen.set(key({
-				participant: patch.participant,
-				field
-			}), {
-				participant: patch.participant,
-				field,
-				value,
-				seen: patch.seen,
-				at: patch.at
-			});
-			activate();
-		},
-		stop() {
-			stopped = true;
-			pending?.cancel();
-			seen.clear();
-		}
-	};
-}
-//#endregion
-export { pollPresence as t };
-
-//# sourceMappingURL=store-presence-polling-B1ixeqIS.js.map

package/dist/store-presence-polling-B1ixeqIS.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"store-presence-polling-B1ixeqIS.js","names":[],"sources":["../src/store-presence-polling.ts"],"sourcesContent":["import type { PresencePatch } from './contract.ts'\nimport { POLL_TIMINGS } from './internal.ts'\nimport { defaultSleep, type Sleeper } from './store-polling.ts'\nimport type { PresenceRow } from './store.ts'\n\nconst key = ({\n  participant,\n  field,\n}: Pick<PresenceRow, 'participant' | 'field'>): string =>\n  JSON.stringify([participant, field])\n\nexport function pollPresence({\n  read,\n  deliver,\n  sleep = defaultSleep,\n}: {\n  read: () => Promise<PresenceRow[]>\n  deliver: (patch: PresencePatch) => void\n  sleep?: (ms: number) => Sleeper\n}): {\n  ready: Promise<void>\n  update(patch: PresencePatch): void\n  wake(): void\n  stop(): void\n} {\n  let stopped = false\n  let pending: Sleeper | undefined\n  let interval = Math.min(\n    POLL_TIMINGS.activeFloorMs,\n    POLL_TIMINGS.idleCeilingMs,\n  )\n  let version = 0\n  const seen = new Map<string, Omit<PresenceRow, 'expiresAt'>>()\n  const activate = (): void => {\n    version += 1\n    interval = Math.min(POLL_TIMINGS.activeFloorMs, POLL_TIMINGS.idleCeilingMs)\n    pending?.cancel()\n  }\n  const ready = read()\n    .then((rows) => {\n      if (stopped) return\n      for (const row of rows) seen.set(key(row), row)\n      return undefined\n    })\n    // Seeding is best effort; foreground snapshots still report read errors.\n    .catch(() => undefined)\n\n  const run = async (): Promise<void> => {\n    await ready\n    for (;;) {\n      if (stopped) return\n      const before = version\n      pending = sleep(interval)\n      // oxlint-disable-next-line no-await-in-loop -- adaptive presence polling\n      await pending.promise\n      if (stopped) return\n      try {\n        const reading = version\n        // oxlint-disable-next-line no-await-in-loop -- read each new presence snapshot\n        const rows = await read()\n        if (stopped) return\n        if (version !== reading) continue\n        const live = new Set<string>()\n        let changed = false\n        for (const row of rows) {\n          const id = key(row)\n          live.add(id)\n          const prior = seen.get(id)\n          seen.set(id, row)\n          if (\n            prior?.seen === row.seen &&\n            prior.at.getTime() === row.at.getTime() &&\n            JSON.stringify(prior.value) === JSON.stringify(row.value)\n          )\n            continue\n          changed = true\n          deliver({\n            participant: row.participant,\n            values: { [row.field]: row.value },\n            seen: row.seen,\n            at: row.at,\n          })\n        }\n        for (const [id, row] of seen) {\n          if (live.has(id)) continue\n          seen.delete(id)\n          changed = true\n          deliver({\n            participant: row.participant,\n            values: { [row.field]: null },\n            seen: row.seen,\n            at: new Date(),\n          })\n        }\n        if (changed) activate()\n        else if (version === before)\n          interval = Math.min(interval * 2, POLL_TIMINGS.idleCeilingMs)\n      } catch {\n        interval = POLL_TIMINGS.idleCeilingMs\n      }\n    }\n  }\n  void run()\n  return {\n    ready,\n    wake: activate,\n    update(patch) {\n      for (const [field, value] of Object.entries(patch.values)) {\n        seen.set(key({ participant: patch.participant, field }), {\n          participant: patch.participant,\n          field,\n          value,\n          seen: patch.seen,\n          at: patch.at,\n        })\n      }\n      activate()\n    },\n    stop() {\n      stopped = true\n      pending?.cancel()\n      seen.clear()\n    },\n  }\n}\n"],"mappings":";;;AAKA,MAAM,OAAO,EACX,aACA,YAEA,KAAK,UAAU,CAAC,aAAa,KAAK,CAAC;AAErC,SAAgB,aAAa,EAC3B,MACA,SACA,QAAQ,gBAUR;CACA,IAAI,UAAU;CACd,IAAI;CACJ,IAAI,WAAW,KAAK,IAClB,aAAa,eACb,aAAa,aACf;CACA,IAAI,UAAU;CACd,MAAM,uBAAO,IAAI,IAA4C;CAC7D,MAAM,iBAAuB;EAC3B,WAAW;EACX,WAAW,KAAK,IAAI,aAAa,eAAe,aAAa,aAAa;EAC1E,SAAS,OAAO;CAClB;CACA,MAAM,QAAQ,KAAK,CAAC,CACjB,MAAM,SAAS;EACd,IAAI,SAAS;EACb,KAAK,MAAM,OAAO,MAAM,KAAK,IAAI,IAAI,GAAG,GAAG,GAAG;CAEhD,CAAC,CAAC,CAED,YAAY,KAAA,CAAS;CAExB,MAAM,MAAM,YAA2B;EACrC,MAAM;EACN,SAAS;GACP,IAAI,SAAS;GACb,MAAM,SAAS;GACf,UAAU,MAAM,QAAQ;GAExB,MAAM,QAAQ;GACd,IAAI,SAAS;GACb,IAAI;IACF,MAAM,UAAU;IAEhB,MAAM,OAAO,MAAM,KAAK;IACxB,IAAI,SAAS;IACb,IAAI,YAAY,SAAS;IACzB,MAAM,uBAAO,IAAI,IAAY;IAC7B,IAAI,UAAU;IACd,KAAK,MAAM,OAAO,MAAM;KACtB,MAAM,KAAK,IAAI,GAAG;KAClB,KAAK,IAAI,EAAE;KACX,MAAM,QAAQ,KAAK,IAAI,EAAE;KACzB,KAAK,IAAI,IAAI,GAAG;KAChB,IACE,OAAO,SAAS,IAAI,QACpB,MAAM,GAAG,QAAQ,MAAM,IAAI,GAAG,QAAQ,KACtC,KAAK,UAAU,MAAM,KAAK,MAAM,KAAK,UAAU,IAAI,KAAK,GAExD;KACF,UAAU;KACV,QAAQ;MACN,aAAa,IAAI;MACjB,QAAQ,GAAG,IAAI,QAAQ,IAAI,MAAM;MACjC,MAAM,IAAI;MACV,IAAI,IAAI;KACV,CAAC;IACH;IACA,KAAK,MAAM,CAAC,IAAI,QAAQ,MAAM;KAC5B,IAAI,KAAK,IAAI,EAAE,GAAG;KAClB,KAAK,OAAO,EAAE;KACd,UAAU;KACV,QAAQ;MACN,aAAa,IAAI;MACjB,QAAQ,GAAG,IAAI,QAAQ,KAAK;MAC5B,MAAM,IAAI;MACV,oBAAI,IAAI,KAAK;KACf,CAAC;IACH;IACA,IAAI,SAAS,SAAS;SACjB,IAAI,YAAY,QACnB,WAAW,KAAK,IAAI,WAAW,GAAG,aAAa,aAAa;GAChE,QAAQ;IACN,WAAW,aAAa;GAC1B;EACF;CACF;CACA,IAAS;CACT,OAAO;EACL;EACA,MAAM;EACN,OAAO,OAAO;GACZ,KAAK,MAAM,CAAC,OAAO,UAAU,OAAO,QAAQ,MAAM,MAAM,GACtD,KAAK,IAAI,IAAI;IAAE,aAAa,MAAM;IAAa;GAAM,CAAC,GAAG;IACvD,aAAa,MAAM;IACnB;IACA;IACA,MAAM,MAAM;IACZ,IAAI,MAAM;GACZ,CAAC;GAEH,SAAS;EACX;EACA,OAAO;GACL,UAAU;GACV,SAAS,OAAO;GAChB,KAAK,MAAM;EACb;CACF;AACF"}