@demlik/tea 0.15.0 → 0.17.0

package/dist/index.js

@@ -1,3 +1,4 @@
-export { Cmd, DispatchDiscardedError, DisposeTimeoutNotice, DriveFailedError, DriveStalledError, IdentityDropNotice, NO_ACK, NoCellError, PortNameCollisionError, ProvideFailedError, ProviderCycleError, QuiescenceTimeoutError, RuntimeDiscardNotice, RuntimeDiscardedError, StoreConflictError, SubIdCollisionError, UnknownProviderError, __resetPortRegistry, absurd, acceptedTypes, acceptsOf, ack, applyCell, applyCellChecked, asReducer, combineManagedResources, defineListener, defineMachine, defineManagedResource, definePort, dep, describeMachine, detectUpdateForm, driveToDone, foldMsgs, foldUpdates, formOf, fromBroadcastChannel, fromEventSource, fromEventTarget, fromInterval, fromPort, fromReconnectingWebSocket, fromTimeout, fromTransport, fromWebSocket, historyTracker, initAck, isFencedStore, isProvided, layer, liftSlice, msgKeysOf, nextSeq, noop, partitionByAck, provide, readInOrder, reconcile, replay, run, schemaMigrate, settle, structuralHash, subId, tagSeq, tryApplyCell, tryFoldMsgs, tryInterpret, value, wrapDetached } from './chunk-66PY5WYF.js';
+export { NO_ACK, ack, defineListener, defineManagedResource, fromBroadcastChannel, fromEventSource, fromEventTarget, fromInterval, fromPort, fromReconnectingWebSocket, fromTimeout, fromTransport, fromWebSocket, historyTracker, initAck, liftSlice, nextSeq, partitionByAck, readInOrder, reconcile, tagSeq } from './chunk-C4U5D5HP.js';
+export { AsyncSchemaError, Cmd, DispatchDiscardedError, DisposeTimeoutNotice, DriveFailedError, DriveStalledError, IdentityDropNotice, NoCellError, Outcome, OutcomeContractError, PortNameCollisionError, QuiescenceTimeoutError, RuntimeDiscardNotice, RuntimeDiscardedError, StoreConflictError, UndeclaredFailureError, __resetPortRegistry, absurd, acceptedTypes, acceptsOf, applyCell, applyCellChecked, asReducer, defineMachine, definePort, describeMachine, detectUpdateForm, foldMsgs, foldUpdates, formOf, isFencedStore, msgKeysOf, noop, replay, schemaMigrate, structuralHash, subId, subIdOf, tryApplyCell, tryFoldMsgs, tryInterpret, wrapDetached } from './chunk-K4ETBNKS.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/jev/index.d.ts

@@ -1,16 +1,13 @@
-import { b as CmdDef, C as Cmd } from '../core-DnzqWy6u.js';
+import { R as RunCmd, F as FailMsg, S as SucceedMsg, a as ResilientState, b as ResilientTimerMsg } from '../index-q1PoukOZ.js';
+import { l as Outcome, b as CmdDef, T as TimerDeps, C as Cmd, n as DepKeyedSub, p as TimerSub } from '../core-rDbOaJTN.js';
 import { RetryPolicy } from '../retry-backoff/index.js';
-import { R as RunCmd, F as FailMsg, S as SucceedMsg, a as ResilientState } from '../index-CA_7I5g9.js';
-export { m as mountResilientCall } from '../index-CA_7I5g9.js';
-import { a as DeadlineSub, D as DeadlineExceeded, T as TtlCache, C as CacheEvictionSub, c as CacheEvictMsg } from '../index-HSYgG2Yt.js';
-export { b as deadlineSub, s as subscribeDeadline } from '../index-HSYgG2Yt.js';
-import { S as SubscribeHandler } from '../types-BseNPIhr.js';
-import { B as BatchWindow, a as BatchWindowSub, b as BatchWindowExpired } from '../index-C2DwkjlP.js';
-import { F as FanOutState } from '../index-CuNO9m8i.js';
-import 'zod';
-import '../index-CSyMYDAB.js';
-import '../runtime-types-CMF13BBh.js';
-import 'better-result';
+import { D as DeadlineExceeded, a as DeadlineSub, T as TtlCache, C as CacheEvictionSub, f as CacheEvictMsg } from '../index-DaX_P35Q.js';
+import { S as SubscribeHandler } from '../types-DPm5YCDQ.js';
+import { B as BatchWindow, a as BatchWindowSub, b as BatchWindowExpired } from '../index-Cberb5Rr.js';
+import { F as FanOutState } from '../index-Cx0F2M34.js';
+import '@standard-schema/spec';
+import '../index-CcrKLtse.js';
+import '../runtime-types-B62Ucnxr.js';
 
 /**
  * @packageDocumentation
@@ -60,19 +57,19 @@ import 'better-result';
  * network actually produced. Every `unknown` reaches a `JevErr`; nothing
  * reaches a `throw`.
  *
- * The check itself is a `zod` schema DERIVED from the questions map, so the
- * typed value is what `safeParse` returns rather than something asserted after
- * a hand-walk. Both halves of a choice question's claim are structural in that
- * schema: `choice` is a `z.enum` over the criteria keys, and `probabilities`
- * is a strict `z.object` whose shape IS those keys — so a distribution missing
- * one or carrying an extra fails the schema rather than a separate arm a later
- * reader has to remember. A partial distribution typed `Record<K, number>` is
+ * The check itself is a walk DERIVED from the questions map, one step per
+ * field, and the typed value is the fresh object it builds. Both halves of a
+ * choice question's claim are structural in that walk: `choice` must be one of
+ * the criteria keys, and `probabilities` must carry exactly those keys — so a
+ * distribution missing one or carrying an extra fails the check rather than a
+ * separate arm a later reader has to remember. A partial distribution typed `Record<K, number>` is
  * the representable-invalid state this module exists to refuse, and it arrives
  * through this gate or not at all. The envelope is checked by the same schema:
  * `model` is a string and `usage` carries two finite numbers.
  *
- * `safeParse`, never `parse`: a zod failure is turned into a `JevErr` value by
- * mapping its first issue's path onto the arm that names it.
+ * The walk stops at the first field that fails, and that field's path is
+ * mapped onto the `JevErr` arm that names it. It is hand-written rather than a
+ * schema library's so the published package depends on none (ADR 0021 §5).
  *
  * ## Why status classification lives here and not in `ask`
  *
@@ -316,39 +313,33 @@ type JevHttpStatus = "ok" | "retry" | "terminal";
 declare const classifyStatus: (status: number) => JevHttpStatus;
 
 /**
- * The injected HTTP caller — the one seam that touches the network.
+ * What an HTTP call to Jev came back with: the status and the undecoded body.
  *
- * It returns the status and the undecoded body rather than throwing on a
+ * Your handler returns this to {@link decodeJevReply} rather than throwing on a
  * non-2xx, because WHICH non-2xx it is decides whether the call backs off, and
- * a thrown adapter error has already lost that. `signal` is optional so a
- * `fetch` adapter can be cancelled; resilient-call issues no signal today, and
- * the slot exists so an adapter's own shape does not have to change when it
- * does.
- *
- * A `fetch` adapter and a scripted test fake satisfy this identically, which is
- * the whole reason the key lives in the adapter's closure and never in config.
+ * a thrown error has already lost that.
  */
-type JevPort<Q extends JevQuestionMap = JevQuestionMap> = (request: JevRequest<Q>, signal?: AbortSignal) => Promise<{
+interface JevHttpReply {
     readonly status: number;
     readonly body: unknown;
-}>;
+}
 /**
  * The pure decider that answers when the network cannot.
  *
- * Called on exactly two paths: `port` is absent (the no-key case), and the
- * resilient retry budget is spent. It must be a pure function of the request —
- * the exhaustion path runs it inside the `fail` VERB, which replay re-runs, so
- * a clock read or an I/O call here would make the machine unreplayable.
- * Returning a {@link JevErr} is how a fallback says "I have no answer for
- * this one"; the call then settles as that error.
+ * Called on exactly two paths: a handler with no key returns
+ * {@link offlineJevAnswer}, and the resilient retry budget is spent. It must
+ * be a pure function of the request — the exhaustion path runs it inside the
+ * `fail` VERB, which replay re-runs, so a clock read or an I/O call here would
+ * make the machine unreplayable. Returning a {@link JevErr} is how a fallback
+ * says "I have no answer for this one"; the call then settles as that error.
  */
 type JevFallback<Q extends JevQuestionMap> = (request: JevRequest<Q>) => JevAnswers<Q> | JevErr;
 /**
  * Every way an ask can fail, as DATA.
  *
  * A superset of the protocol child's {@link JevErr}: a parse failure is
- * reported with the protocol's own tag untouched, and the three tags below are
- * the ones only a caller can observe. `{_tag}`-discriminated and
+ * reported with the protocol's own tag untouched, and the tags below are the
+ * ones only a caller can observe. `{_tag}`-discriminated and
  * JSON-round-trippable like the rest (ADR 0011), because it is carried on the
  * settle Msg and stored in the slice's `failed` phase.
  *
@@ -366,12 +357,12 @@ type JevAskErr = JevErr
     readonly _tag: "http_terminal";
     readonly status: number;
 }
-/** The port itself rejected (a socket error, a DNS failure) — transient. */
+/** The call itself threw (a socket error, a DNS failure) — transient. */
  | {
     readonly _tag: "port_threw";
     readonly reason: string;
 }
-/** No `port` and no `fallback`: the knob was configured with no way to answer. */
+/** No key and no `fallback`: the knob was configured with no way to answer. */
  | {
     readonly _tag: "no_answer_path";
 };
@@ -385,19 +376,23 @@ type JevAskErr = JevErr
  */
 declare function isTransientJevAskErr(error: JevAskErr): boolean;
 /**
- * The carrier that gets a {@link JevAskErr} out of the port and through
- * resilient-call's throw seam intact.
- *
- * resilient-call routes a rejected port to a failure Msg carrying the raw
- * thrown value, so throwing is the only way the handler can say "this attempt
- * failed" — and a bare `Error` would arrive with its classification already
- * lost. The typed payload rides on `jev`; the slice never stores this object
- * (the verbs store `jev` itself), so nothing un-serializable reaches Model.
+ * How a {@link JevAskErr} crosses the handler: the run Cmd's declared
+ * `port_rejected` tag, with the typed error on `jev`. The engine mints it into
+ * `resilient_run_err` untouched, and {@link jevAskErrOf} reads it back.
  */
-declare class JevAskFailure extends Error {
+type JevRejected = {
+    readonly _tag: "port_rejected";
     readonly jev: JevAskErr;
-    constructor(jev: JevAskErr);
-}
+};
+/**
+ * Read a settled failure back as a {@link JevAskErr}. PURE.
+ *
+ * A {@link JevRejected} yields its `jev`. Anything else a handler returned —
+ * a bare `port_rejected`, a `deadline_exceeded` — is a failure this door did
+ * not classify, and it reads as the transient `port_threw`, exactly as a
+ * foreign throw always has.
+ */
+declare function jevAskErrOf(error: unknown): JevAskErr;
 /** The model the door asks for when config names none. */
 declare const DEFAULT_JEV_MODEL = "jev-latest";
 /**
@@ -408,9 +403,7 @@ declare const DEFAULT_JEV_MODEL = "jev-latest";
 interface JevAskConfig<Q extends JevQuestionMap> {
     /** The question map every request carries; its keys type the answers. */
     readonly questions: Q;
-    /** DI port — the HTTP caller. Absent = the no-key case; `fallback` answers instead. */
-    readonly port?: JevPort<Q>;
-    /** The pure decider for the no-port and budget-spent paths. Absent → those settle as an error. */
+    /** The pure decider for the no-key and budget-spent paths. Absent → those settle as an error. */
     readonly fallback?: JevFallback<Q>;
     /** Backoff policy, composed into `../../resilience/resilient-call`. Omit → no backoff. */
     readonly retry?: RetryPolicy;
@@ -418,7 +411,7 @@ interface JevAskConfig<Q extends JevQuestionMap> {
     readonly model?: string;
 }
 /**
- * The settled answer carried on `resilient_ok`.
+ * The settled answer carried on `resilient_run_ok`.
  *
  * `source` is not decoration: a fallback answer and a model answer are both
  * valid answers with identical shape, and a host that routes on confidence — or
@@ -435,6 +428,27 @@ interface JevOk<Q extends JevQuestionMap> {
     /** Which path produced this answer. */
     readonly source: "port" | "fallback";
 }
+/**
+ * Turn an HTTP reply into the run Cmd's outcome. PURE: classify the status,
+ * then parse the body against the questions the request carried.
+ *
+ * `ok` → the typed {@link JevOk}; a 429 / 529 → the transient `http_retry`;
+ * any other non-2xx → the terminal `http_terminal`; a body that disagrees with
+ * the questions → the protocol's own {@link JevErr}. Every failure is a
+ * {@link JevRejected}.
+ */
+declare function decodeJevReply<Q extends JevQuestionMap>(request: JevRequest<Q>, reply: JevHttpReply): Outcome<JevOk<Q>, JevRejected>;
+/**
+ * The outcome for a call that threw before Jev answered — a socket error, a
+ * DNS failure. PURE. It is the transient `port_threw`, so it backs off.
+ */
+declare function jevCallThrew(cause: unknown): Outcome<never, JevRejected>;
+/**
+ * The outcome with no network at all: the fallback's answer, or its refusal,
+ * or `no_answer_path` when there is no fallback. PURE — what a handler with
+ * no key returns.
+ */
+declare function offlineJevAnswer<Q extends JevQuestionMap>(request: JevRequest<Q>, fallback: JevFallback<Q> | undefined): Outcome<JevOk<Q>, JevRejected>;
 /**
  * The one effect this knob emits: run the ask for `key` with the plain-data
  * {@link JevRequest} (ADR 0014 — a Cmd is DECLARED, so its input, ok and err
@@ -452,15 +466,17 @@ declare function jevAskCmdDef<Q extends JevQuestionMap>(): CmdDef<"resilient_run
 } | {
     readonly [detail: string]: unknown;
     readonly _tag: "port_rejected";
-}, unknown>;
+}>;
 /** The Cmd the verbs emit — `resilient_run` carrying the request. */
-type JevAskCmd<Q extends JevQuestionMap> = RunCmd<JevRequest<Q>>;
-/** The success settle Msg — resilient-call's, with `result` narrowed to {@link JevOk}. */
+type JevAskCmd<Q extends JevQuestionMap> = RunCmd<JevRequest<Q>, "resilient", JevOk<Q>>;
+/** The success settle Msg — resilient-call's, with `value` narrowed to {@link JevOk}. */
 type JevSucceedMsg<Q extends JevQuestionMap> = SucceedMsg<JevOk<Q>>;
-/** The failure settle Msg — resilient-call's, with `error` narrowed to {@link JevAskErr}. */
-type JevFailMsg = Omit<FailMsg, "error"> & {
-    readonly error: JevAskErr;
-};
+/**
+ * The failure settle Msg the engine mints — resilient-call's. Its `error` is a
+ * {@link JevRejected} when your handler used this door's builders; `fail`
+ * reads it with {@link jevAskErrOf}.
+ */
+type JevFailMsg = FailMsg;
 /** The retry / deadline timer Msg — `DeadlineExceeded`, inherited. */
 type JevTimerMsg = DeadlineExceeded;
 /**
@@ -468,41 +484,46 @@ type JevTimerMsg = DeadlineExceeded;
  * jitter (pass a fixed `() => 0` in tests to pin backoff; defaults to
  * `Math.random`, read only at resilient-call's verb boundary).
  *
- * The slice and five of the six verbs are resilient-call's, forwarded. `fail` is
- * the one composed verb — it reads the {@link JevAskErr} the handler typed and
- * routes on it (see its docblock); it reimplements no backoff. `handlers` is the
- * new piece: the port call, the status classification, the parse, and the
- * enriched settle Msg.
+ * The slice and most verbs are resilient-call's, forwarded. `fail` is the one
+ * composed verb — it reads the {@link JevAskErr} back off the settled Msg and
+ * routes on it (see its docblock); it reimplements no backoff. `decode`,
+ * `rejected` and `offline` are the pure outcome builders your handler returns.
  */
 declare function createJevAsk<Q extends JevQuestionMap>(config: JevAskConfig<Q>, rng?: () => number): {
     name: "resilient";
+    /** The `Cmd.define`d run Cmd — list it in the machine's `cmds`. */
+    run: CmdDef<"resilient_run", {
+        readonly key: string;
+        readonly input: JevRequest<Q>;
+    }, JevOk<Q>, {
+        readonly [detail: string]: unknown;
+        readonly _tag: "deadline_exceeded";
+    } | {
+        readonly [detail: string]: unknown;
+        readonly _tag: "port_rejected";
+    }>;
     init: () => ResilientState<JevRequest<Q>, JevOk<Q>>;
     attempt: (s: ResilientState<JevRequest<Q>, JevOk<Q>>, key: string, content: JevState, at: number) => readonly [ResilientState<JevRequest<Q>, JevOk<Q>>, readonly JevAskCmd<Q>[]];
-    succeed: (s: ResilientState<JevRequest<Q>, JevOk<Q>>, key: string, msg: JevSucceedMsg<Q>) => readonly [ResilientState<JevRequest<Q>, JevOk<Q>>, readonly JevAskCmd<Q>[]];
-    fail: (s: ResilientState<JevRequest<Q>, JevOk<Q>>, key: string, msg: JevFailMsg) => readonly [ResilientState<JevRequest<Q>, JevOk<Q>>, readonly JevAskCmd<Q>[]];
+    succeed: (s: ResilientState<JevRequest<Q>, JevOk<Q>>, msg: JevSucceedMsg<Q>) => readonly [ResilientState<JevRequest<Q>, JevOk<Q>>, readonly JevAskCmd<Q>[]];
+    fail: (s: ResilientState<JevRequest<Q>, JevOk<Q>>, msg: JevFailMsg) => readonly [ResilientState<JevRequest<Q>, JevOk<Q>>, readonly JevAskCmd<Q>[]];
     onTimer: (s: ResilientState<JevRequest<Q>, JevOk<Q>>, msg: JevTimerMsg) => readonly [ResilientState<JevRequest<Q>, JevOk<Q>>, readonly JevAskCmd<Q>[]];
-    subs: (s: ResilientState<JevRequest<Q>, JevOk<Q>>) => readonly DeadlineSub[];
-    handlers: () => {
-        resilient_run: (cmd: JevAskCmd<Q>) => Promise<JevSucceedMsg<Q> | JevFailMsg>;
-    };
-    ask: (request: JevRequest<Q>, signal?: AbortSignal) => Promise<JevOk<Q>>;
+    deadlines: (s: ResilientState<JevRequest<Q>, JevOk<Q>>) => readonly DeadlineSub[];
+    /** The built-in `timer` Sub's deps — resilient-call's `timer`. */
+    timer: (s: ResilientState<JevRequest<Q>, JevOk<Q>>) => TimerDeps<ResilientTimerMsg<"resilient">> | null;
+    /** Your handler's outcome for an HTTP reply — {@link decodeJevReply}. */
+    decode: (request: JevRequest<Q>, reply: JevHttpReply) => Outcome<JevOk<Q>, JevRejected>;
+    /** Your handler's outcome when the call threw — {@link jevCallThrew}. */
+    rejected: typeof jevCallThrew;
+    /** Your handler's outcome with no network — {@link offlineJevAnswer}. */
+    offline: (request: JevRequest<Q>) => Outcome<JevOk<Q>, JevRejected>;
 };
 /**
  * The Cmd type a host machine declares in `types.cmd` when it splices a
  * {@link createJevAsk} knob in — {@link JevAskCmd} under the name a `types`
  * block reads well with. It is stated here so a host writes `cmd: {} as
- * JevCmd<Questions>` rather than deriving it from the knob's shape, which is
- * what `ReturnType<Ask["attempt"]>[1][number]` used to be doing at every call
- * site: a spelling of the same type that breaks the moment `attempt`'s tuple
- * changes, and that reads as machinery rather than as a name.
+ * JevCmd<Questions>` rather than deriving it from the knob's shape.
  */
 type JevCmd<Q extends JevQuestionMap> = JevAskCmd<Q>;
-/**
- * The Sub type a host machine declares in `types.sub` — the deadline Sub
- * `subs` emits, inherited from resilient-call. Named here for the same reason
- * as {@link JevCmd}: a host names the type, it does not re-derive it.
- */
-type JevSub = DeadlineSub;
 /**
  * Lift a knob result `[slice, cmds]` into a host `[State, cmds]` where the slice
  * lives at `state.resilience` — resilient-call's convenience, re-typed for this
@@ -577,9 +598,7 @@ interface ClassifyBatchConfig<I, C extends string> {
     readonly evictEveryMs?: number;
     /** The model asked for. Forwarded to `../ask`'s default when omitted. */
     readonly model?: string;
-    /** DI port — the HTTP caller. Forwarded to `../ask`; absent is the no-key case. */
-    readonly port?: JevPort<ItemQuestions<C>>;
-    /** The pure decider for the no-port path. Forwarded to `../ask`. */
+    /** The pure decider `offline` answers with, for a handler with no key. */
     readonly fallback?: JevFallback<ItemQuestions<C>>;
 }
 /**
@@ -593,7 +612,7 @@ interface ClassifyBatchState<I, C extends string> {
     readonly fanOut: FanOutState<Batch<I>, JevOk<ItemQuestions<C>>>;
     /** The answers, keyed by `keyOf` — `../../resilience/cache`'s slice. */
     readonly cache: TtlCache<ItemAnswer<C>>;
-    /** Keys whose batch settled `resilient_err`, with the error that settled it. */
+    /** Keys whose batch settled `resilient_run_err`, with the error that settled it. */
     readonly failed: Readonly<Record<string, JevAskErr>>;
 }
 /** What {@link ClassifyBatchKnob.answerFor} reports about one key. */
@@ -603,7 +622,7 @@ type KeyAnswer<C extends string> =
     readonly status: "answered";
     readonly answer: ItemAnswer<C>;
 }
-/** The batch carrying this key settled `resilient_err`. Nothing was cached. */
+/** The batch carrying this key settled `resilient_run_err`. Nothing was cached. */
  | {
     readonly status: "failed";
     readonly error: JevAskErr;
@@ -624,6 +643,17 @@ type KeyAnswer<C extends string> =
  * that keeps one key out of two batches at once.
  */
 declare function createClassifyBatch<I, C extends string>(config: ClassifyBatchConfig<I, C>): {
+    /** The ask Cmd def — list it in the machine's `cmds`. */
+    ask: CmdDef<"resilient_run", {
+        readonly key: string;
+        readonly input: JevRequest<Readonly<Record<string, ItemQuestion<C>>>>;
+    }, JevOk<Readonly<Record<string, ItemQuestion<C>>>>, {
+        readonly [detail: string]: unknown;
+        readonly _tag: "deadline_exceeded";
+    } | {
+        readonly [detail: string]: unknown;
+        readonly _tag: "port_rejected";
+    }>;
     init: () => ClassifyBatchState<I, C>;
     add: (state: ClassifyBatchState<I, C>, item: I, at: number) => readonly [ClassifyBatchState<I, C>, readonly ClassifyBatchCmd<C>[]];
     onWindow: (state: ClassifyBatchState<I, C>, at: number) => readonly [ClassifyBatchState<I, C>, readonly ClassifyBatchCmd<C>[]];
@@ -631,16 +661,22 @@ declare function createClassifyBatch<I, C extends string>(config: ClassifyBatchC
     onBatchErr: (state: ClassifyBatchState<I, C>, msg: ClassifyBatchErrMsg) => readonly [ClassifyBatchState<I, C>, readonly ClassifyBatchCmd<C>[]];
     onEvict: (state: ClassifyBatchState<I, C>, at: number) => readonly [ClassifyBatchState<I, C>, readonly ClassifyBatchCmd<C>[]];
     answerFor: (state: ClassifyBatchState<I, C>, key: string, at: number) => KeyAnswer<C>;
-    subs: (state: ClassifyBatchState<I, C>, id?: string) => readonly (BatchWindowSub | CacheEvictionSub)[];
+    subs: (state: ClassifyBatchState<I, C>, id?: string) => readonly BatchWindowSub[];
+    subEntries: <Model>(select: (model: Model) => ClassifyBatchState<I, C>, id?: string) => readonly DepKeyedSub<Model, TimerSub<BatchWindowExpired> | CacheEvictionSub>[];
     subscribers: () => {
-        deadline: SubscribeHandler<BatchWindowSub, BatchWindowExpired, unknown>;
         cache: SubscribeHandler<CacheEvictionSub, CacheEvictMsg, unknown>;
     };
-    handlers: () => {
-        resilient_run: (cmd: ClassifyBatchCmd<C>) => Promise<ClassifyBatchOkMsg<C> | ClassifyBatchErrMsg>;
-    };
+    /**
+     * Your handler's outcome for Jev's reply to one batch — `../ask`'s
+     * `decodeJevReply`, parsing against the questions the batch carried.
+     */
+    decode: (request: JevRequest<ItemQuestions<C>>, reply: JevHttpReply) => Outcome<JevOk<Readonly<Record<string, ItemQuestion<C>>>>, JevRejected>;
+    /** Your handler's outcome when the call threw — `../ask`'s `jevCallThrew`. */
+    rejected: typeof jevCallThrew;
+    /** Your handler's outcome with no network — the configured `fallback`. */
+    offline: (request: JevRequest<ItemQuestions<C>>) => Outcome<JevOk<Readonly<Record<string, ItemQuestion<C>>>>, JevRejected>;
 };
 /** The bound knob {@link createClassifyBatch} returns. */
 type ClassifyBatchKnob<I, C extends string> = ReturnType<typeof createClassifyBatch<I, C>>;
 
-export { type Batch, type ClassifyBatchCmd, type ClassifyBatchConfig, type ClassifyBatchErrMsg, type ClassifyBatchKnob, type ClassifyBatchOkMsg, type ClassifyBatchState, type ClassifyCriteria, DEFAULT_CLASSIFY_MAX_ITEMS, DEFAULT_JEV_MODEL, DeadlineExceeded, DeadlineSub, type ItemAnswer, type ItemQuestion, type ItemQuestions, JEV_ENDPOINT, type JevAnswer, type JevAnswerFor, type JevAnswers, type JevAskCmd, type JevAskConfig, type JevAskErr, JevAskFailure, type JevChoiceAnswer, type JevChoiceCriteria, type JevChoiceQuestion, type JevCmd, type JevErr, type JevFailMsg, type JevFallback, type JevHttpStatus, type JevNoulAnswer, type JevNoulQuestion, type JevOk, type JevParse, type JevPort, type JevQuestion, type JevQuestionMap, type JevQuestionType, type JevRequest, type JevResponse, type JevScoreAnswer, type JevScoreCriteria, type JevScoreQuestion, type JevState, type JevSub, type JevSucceedMsg, type JevText, type JevTimerMsg, type JevUsage, type KeyAnswer, ResilientState, classifyStatus, createClassifyBatch, createJevAsk, isJevErr, isTransientJevAskErr, jevAskCmdDef, jevQuestions, liftJevAsk, parseAnswers };
+export { type Batch, type ClassifyBatchCmd, type ClassifyBatchConfig, type ClassifyBatchErrMsg, type ClassifyBatchKnob, type ClassifyBatchOkMsg, type ClassifyBatchState, type ClassifyCriteria, DEFAULT_CLASSIFY_MAX_ITEMS, DEFAULT_JEV_MODEL, type ItemAnswer, type ItemQuestion, type ItemQuestions, JEV_ENDPOINT, type JevAnswer, type JevAnswerFor, type JevAnswers, type JevAskCmd, type JevAskConfig, type JevAskErr, type JevChoiceAnswer, type JevChoiceCriteria, type JevChoiceQuestion, type JevCmd, type JevErr, type JevFailMsg, type JevFallback, type JevHttpReply, type JevHttpStatus, type JevNoulAnswer, type JevNoulQuestion, type JevOk, type JevParse, type JevQuestion, type JevQuestionMap, type JevQuestionType, type JevRejected, type JevRequest, type JevResponse, type JevScoreAnswer, type JevScoreCriteria, type JevScoreQuestion, type JevState, type JevSucceedMsg, type JevText, type JevTimerMsg, type JevUsage, type KeyAnswer, ResilientState, classifyStatus, createClassifyBatch, createJevAsk, decodeJevReply, isJevErr, isTransientJevAskErr, jevAskCmdDef, jevAskErrOf, jevCallThrew, jevQuestions, liftJevAsk, offlineJevAnswer, parseAnswers };