experimental-a2 0.19.0 → 0.21.1

package/dist/{server-DYAATFuT.d.ts → server-BshFZ0eL.d.ts}

@@ -1,7 +1,7 @@
-import { c as ContractEvent, d as PresenceDefs, f as PresenceMap, g as WithPresence, m as PresenceSnapshot, o as AppendInput, p as PresencePatch, r as RegisteredReducer, s as Contract, t as Reducer, u as EventDefs } from "./reducer-CqA59Q6U.js";
-import { t as A2Store } from "./store-CyLUy86v.js";
-import { t as SessionCleared } from "./session-clear-C-QwTXV1.js";
-import { i as A2Telemetry } from "./telemetry-Cyfqo6Qt.js";
+import { c as ContractEvent, d as PresenceDefs, f as PresenceMap, g as WithPresence, m as PresenceSnapshot, o as AppendInput, p as PresencePatch, r as RegisteredReducer, s as Contract, t as Reducer, u as EventDefs } from "./reducer-CYPHsSmd.js";
+import { t as A2Store } from "./store-Z2qjw50n.js";
+import { t as SessionCleared } from "./session-clear-Bk_29eEw.js";
+import { i as A2Telemetry } from "./telemetry-CWwsh-Gx.js";
 //#region src/session-socket.d.ts
 /**
  * The structural socket `sessionsSocket` speaks against — satisfied
@@ -69,7 +69,7 @@ type ScheduledEvent = {
   type: string;
   payload: unknown;
 };
-/** A durable wake-up for pending handler work. */
+/** A durable wake-up for pending consumer work. */
 type SchedulerDrainTask = {
   version: 1;
   kind: "drain";
@@ -89,7 +89,7 @@ type SchedulerAppendTask = {
   /** Earliest useful delivery as epoch milliseconds. */
   dueAt: number;
   events: readonly ScheduledEvent[];
-  /** The scheduling handler's event; delivery skips once it is cleared. */
+  /** The scheduling consumer's event; delivery skips once it is cleared. */
   originIndex?: number;
 };
 /** A durable conditional clear. */
@@ -112,31 +112,35 @@ type SchedulerTask = SchedulerDrainTask | SchedulerAppendTask | SchedulerClearTa
 type PublicState<R> = undefined extends R ? never : R extends {
   initialState: infer S;
 } ? S : never;
-/** What every handler receives. */
-type HandlerContext<D extends EventDefs, K extends keyof D & string = keyof D & string, P extends PresenceDefs = Record<never, never>, 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 handler-scoped idempotent append. */
-  session: Session<D, HandlerAppend<D>, P, S>;
+  /** 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 Handler<D extends EventDefs, K extends keyof D & string = keyof D & string, P extends PresenceDefs = Record<never, never>, S = never> = (ctx: HandlerContext<D, K, P, S>) => Promise<void | AppendInput<D> | readonly AppendInput<D>[]>;
 type LaneContext<D extends EventDefs, K extends keyof D & string = keyof D & string> = {
   sessionId: string;
   event: Pick<ContractEvent<D, K>, "type" | "payload"> & {
     id?: string;
   };
 };
-type Lane<D extends EventDefs, K extends keyof D & string = keyof D & string> = string | ((context: LaneContext<D, K>) => 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 HandlerAppend<D extends EventDefs> = (name: string, ...events: AppendInput<D>[]) => Promise<ContractEvent<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;
@@ -168,25 +172,41 @@ type SessionClearResult = {
   index: number;
 };
 type SessionRedriveOptions = {
-  /** `retry` runs the handler again with a fresh failure budget; `skip` settles the event without running it. */
+  /** `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
-   * handler failures, and attempts that ended before they finished.
+   * consumer failures, and attempts that ended before they finished.
    */
   failureCount: number;
   /**
-   * The last error a handler threw, stringified; null when every failed
+   * The last error the consumer threw, stringified; null when every failed
    * attempt ended before it finished.
    */
   lastError: string | null;
@@ -200,7 +220,10 @@ type SessionDeadLetters<D extends EventDefs> = {
    * Atomically resolve one dead-lettered event, then wake the session like
    * an append. Any other event is left alone and reports `redriven: false`.
    */
-  redrive(index: number, options: SessionRedriveOptions): Promise<SessionRedriveResult>;
+  redrive(target: {
+    consumer: string;
+    index: number;
+  }, options: SessionRedriveOptions): Promise<SessionRedriveResult>;
 };
 /**
  * The presence members of a session — intersected in via
@@ -248,6 +271,14 @@ type Session<D extends EventDefs, Append = SessionAppend<D>, P extends PresenceD
     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;
@@ -271,7 +302,7 @@ type Session<D extends EventDefs, Append = SessionAppend<D>, P extends PresenceD
   }): AsyncIterable<ContractEvent<D> | SessionCleared>;
 };
 /**
- * The public server shape scheduler handlers accept. It stays structural so
+ * 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.
  */
@@ -327,29 +358,66 @@ declare function deliverSchedulerAppend(server: DrainableServer, task: Scheduler
  */
 declare function deliverSchedulerClear(server: DrainableServer, task: SchedulerClearTask): Promise<void>;
 /**
- * Which events fire `ctx.signal` while a handler runs — the preemption
+ * 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`). Handlers
- * without `abortOn` pay nothing. An aborted handler should catch and
+ * (`(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); };
-type HandlerEntry<D extends EventDefs, K extends keyof D & string = keyof D & string, P extends PresenceDefs = Record<never, never>, S = never> = Handler<D, K, P, S> | {
+/** 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>;
+};
+type ConsumerOptions<D extends EventDefs, P extends PresenceDefs, R extends RegisteredReducer<D, P> | undefined, K extends keyof D & string> = {
+  /** The contract whose events it reads. */
+  contract: Contract<D, P, R>;
+  /** Its identity, unique per server. A new name is a new consumer. */
+  name: string;
+  /** The event types it runs on; default every type. */
+  types?: readonly K[];
+  /** Omitted: concurrent. A string: one ordered lane. A function: per event. */
+  lane?: ConsumerLane<D, K>;
+  /** A new consumer starts at the beginning of the log. Needs a string lane. */
+  backfill?: boolean;
   abortOn?: AbortSpec<D, K>;
-  /** Session-scoped FIFO key, resolved and persisted when the event lands. */
-  lane?: Lane<D, K>;
-  handler: Handler<D, K, P, S>;
-};
-type HandlerFunction = (ctx: never) => Promise<unknown>;
-declare function handler<H extends HandlerFunction | {
-  handler: HandlerFunction;
-}>(entry: H): H extends HandlerFunction ? {
-  handler: H;
-} : H;
-type ServerOptions<D extends EventDefs, P extends PresenceDefs = Record<never, never>, R extends RegisteredReducer<D, P> | undefined = RegisteredReducer<D, P> | undefined> = {
+};
+/**
+ * A consumer written in `createServer({ consumers })`: `consumer()`'s
+ * options without the contract, which is the server's, and its `run`.
+ */
+type InlineConsumer<D extends EventDefs, P extends PresenceDefs, R extends RegisteredReducer<D, P> | undefined, K extends keyof D & string> = Omit<ConsumerOptions<D, P, R, K>, "contract"> & {
+  run: (ctx: ConsumerContext<D, K, P, PublicState<R>>) => ConsumerResult<D>;
+};
+/** The types an inline consumer takes: the ones it lists, or every type. */
+type InlineTypes<D extends EventDefs, X> = unknown extends X ? keyof D & string : Extract<X, keyof D & string>;
+/**
+ * `createServer`'s consumers: each a `consumer()` or written inline. `C` is
+ * inferred per entry, so an inline `run` sees only the types it lists.
+ */
+type ServerConsumers<D extends EventDefs, P extends PresenceDefs, R extends RegisteredReducer<D, P> | undefined, C extends readonly unknown[]> = { readonly [I in keyof C]: InlineConsumer<D, P, R, InlineTypes<D, C[I]>> | Extract<C[I], Consumer<D>>; };
+/** Define a consumer: a named reader of each session's log. */
+declare function consumer<D extends EventDefs, P extends PresenceDefs, R extends RegisteredReducer<D, P> | undefined, const K extends keyof D & string = keyof D & string>(options: ConsumerOptions<D, P, R, K>): {
+  run(fn: (ctx: ConsumerContext<D, K, P, PublicState<R>>) => ConsumerResult<D>): Consumer<D>;
+};
+type ServerOptions<D extends EventDefs, P extends PresenceDefs = Record<never, never>, R extends RegisteredReducer<D, P> | undefined = RegisteredReducer<D, P> | undefined, C extends readonly unknown[] = readonly Consumer<D>[]> = {
   /** The contract this server implements (see `a2.contract`). */
   contract: Contract<D, P, R>;
   /** Where events live. Defaults: sqlite in dev, memory in tests, required in prod. */
@@ -372,15 +440,14 @@ type ServerOptions<D extends EventDefs, P extends PresenceDefs = Record<never, n
     ttlMs?: number;
   };
   /**
-   * The reactions, keyed by event type — all present at construction,
-   * so a handler can never be silently missing because its module
-   * wasn't imported. Compose across files by spreading objects (note:
-   * a duplicate key under spread silently last-wins).
+   * The consumers, each a named reader of every session's log with its own
+   * cursors: a `consumer()`, or its options and `run` written inline, on this
+   * contract. Names are unique; a duplicate throws.
    */
-  handlers?: { [K in keyof D & string]?: HandlerEntry<D, K, P, PublicState<R>>; };
+  consumers?: ServerConsumers<D, P, R, C> | readonly Consumer<D>[];
 };
 /** Implement a contract: bind its vocabulary to storage and reactions. */
-declare function createServer<D extends EventDefs, P extends PresenceDefs = Record<never, never>, R extends RegisteredReducer<D, P> | undefined = RegisteredReducer<D, P> | undefined>(options: ServerOptions<D, P, R>): A2Server<D, P, R>;
+declare function createServer<D extends EventDefs, P extends PresenceDefs = Record<never, never>, R extends RegisteredReducer<D, P> | undefined = RegisteredReducer<D, P> | undefined, const C extends readonly unknown[] = readonly Consumer<D>[]>(options: ServerOptions<D, P, R, C>): A2Server<D, P, R>;
 //#endregion
-export { ScheduledEvent as A, A2Socket as B, SessionRedriveResult as C, deliverSchedulerAppend as D, createServer as E, A2Operation as F, A2PushEvent as I, A2PushPresence as L, SchedulerClearTask as M, SchedulerDrainTask as N, deliverSchedulerClear as O, SchedulerTask as P, ServerFetchOptions as R, SessionRedriveOptions as S, StateOptions as T, SessionClearOptions as _, DrainableServer as a, SessionDispatch as b, HandlerContext as c, LaneContext as d, ScheduleDelay as f, SessionAppend as g, Session as h, DeadLetter as i, SchedulerAppendTask as j, handler as k, HandlerEntry as l, ServerOptions as m, A2Server as n, Handler as o, ScheduleTiming as p, AbortSpec as r, HandlerAppend as s, A2Scheduler as t, Lane as u, SessionClearResult as v, SessionSchedule as w, SessionPresence as x, SessionDeadLetters as y, UpgradeWebSocket as z };
-//# sourceMappingURL=server-DYAATFuT.d.ts.map
+export { SessionSchedule as A, SchedulerTask as B, SessionConsumeOptions as C, SessionPresence as D, SessionDispatch as E, deliverSchedulerClear as F, UpgradeWebSocket as G, A2PushEvent as H, ScheduledEvent as I, A2Socket as K, SchedulerAppendTask as L, consumer as M, createServer as N, SessionRedriveOptions as O, deliverSchedulerAppend as P, SchedulerClearTask as R, SessionClearResult as S, SessionDeadLetters as T, A2PushPresence as U, A2Operation as V, ServerFetchOptions as W, ServerConsumers as _, ConsumerAppend as a, SessionAppend as b, ConsumerOptions as c, DeadLetter as d, DrainableServer as f, ScheduleTiming as g, ScheduleDelay as h, Consumer as i, StateOptions as j, SessionRedriveResult as k, ConsumerResult as l, LaneContext as m, A2Server as n, ConsumerContext as o, InlineConsumer as p, AbortSpec as r, ConsumerLane as s, A2Scheduler as t, ConsumerSpec as u, ServerOptions as v, SessionConsumeResult as w, SessionClearOptions as x, Session as y, SchedulerDrainTask as z };
+//# sourceMappingURL=server-BshFZ0eL.d.ts.map

package/dist/server-BshFZ0eL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-BshFZ0eL.d.ts","names":[],"sources":["../src/session-socket.ts","../src/server-fetch.ts","../src/scheduler-task.ts","../src/server.ts"],"mappings":"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"}