@demlik/tea 0.14.0 → 0.15.0

package/dist/index.d.ts

@@ -1,11 +1,71 @@
-import { B as BootingRuntime, a as ScopedCtxArg, S as Store, O as OnError, b as Supervision, R as Runtime } from './runtime-types-LWDoi943.js';
-export { c as Branded, C as CtxArg, D as DepToken, d as DepsOf, e as DispatchDiscardedError, f as DispatchSettle, g as DisposeTimeoutNotice, h as DriveFailedError, i as DriveStalledError, j as FencedRead, F as FencedStore, k as FoldRefusal, I as IdentityDropNotice, M as MachineTypes, l as OnReleaseError, P as PortNameCollisionError, m as ProvideFailedError, n as Provided, o as ProvidedCtx, p as Provider, q as ProviderCycleError, Q as QuiescenceTimeoutError, r as RuntimeDiscardNotice, s as RuntimeDiscardedError, t as RuntimeErrorContext, u as RuntimeErrorPhase, v as RuntimeRef, w as Schema, x as Scope, y as StoreConflictError, z as SubIdCollisionError, A as SupervisionStrategy, U as UnknownProviderError, _ as __resetPortRegistry, E as absurd, G as asReducer, H as defineMachine, J as definePort, K as dep, L as isFencedStore, N as isProvided, T as layer, V as noop, W as provide, X as replay, Y as schemaMigrate, Z as settle, $ as tryApplyCell, a0 as tryFoldMsgs, a1 as tryInterpret, a2 as value, a3 as wrapDetached } from './runtime-types-LWDoi943.js';
-import { C as Cmd, S as Sub, M as Machine, R as RequiredCtx, P as Port, D as Dispose, o as DepKeyedSub, c as SubId } from './core-CTzMJ82M.js';
-export { A as AnyCmdDef, b as CmdDef, p as CmdInput, a as CmdOf, i as CmdValue, E as ErrOf, q as ErrorsOf, r as ExhaustiveTransitions, s as Identity, I as Interpret, h as InterpretDetached, t as MachineShape, l as MalformedResult, N as NoCellError, k as NoCtx, O as OkOf, g as PortEmitter, d as Reducer, m as Requirements, f as RequirementsOf, e as Settled, u as SettledErr, v as SettledOk, w as Subscribe, x as SyncReturn, j as Tagged, n as TaggedError, T as Transitions, U as UpdateForm, y as acceptedTypes, z as acceptsOf, B as applyCell, F as applyCellChecked, G as describeMachine, H as detectUpdateForm, J as foldMsgs, K as foldUpdates, L as formOf, Q as msgKeysOf, V as structuralHash, W as subId } from './core-CTzMJ82M.js';
-import { S as SubscribeHandler } from './types-DP3f5NIl.js';
+import { B as BootingRuntime, a as ScopedCtxArg, S as Store, O as OnError, b as Supervision, R as Runtime } from './runtime-types-CMF13BBh.js';
+export { c as Branded, C as CtxArg, D as DepToken, d as DepsOf, e as DispatchDiscardedError, f as DispatchSettle, g as DisposeTimeoutNotice, h as DriveFailedError, i as DriveStalledError, j as FencedRead, F as FencedStore, k as FoldRefusal, I as IdentityDropNotice, M as MachineTypes, l as OnReleaseError, P as PortNameCollisionError, m as ProvideFailedError, n as Provided, o as ProvidedCtx, p as Provider, q as ProviderCycleError, Q as QuiescenceTimeoutError, r as RuntimeDiscardNotice, s as RuntimeDiscardedError, t as RuntimeErrorContext, u as RuntimeErrorPhase, v as RuntimeRef, w as Schema, x as Scope, y as StoreConflictError, z as SubIdCollisionError, A as SupervisionStrategy, U as UnknownProviderError, _ as __resetPortRegistry, E as absurd, G as asReducer, H as defineMachine, J as definePort, K as dep, L as isFencedStore, N as isProvided, T as layer, V as noop, W as provide, X as replay, Y as schemaMigrate, Z as settle, $ as tryApplyCell, a0 as tryFoldMsgs, a1 as tryInterpret, a2 as value, a3 as wrapDetached } from './runtime-types-CMF13BBh.js';
+import { C as Cmd, S as Sub, M as Machine, R as RequiredCtx, P as Port, D as Dispose, o as DepKeyedSub, c as SubId } from './core-DnzqWy6u.js';
+export { A as AnyCmdDef, b as CmdDef, p as CmdInput, a as CmdOf, l as CmdValue, E as ErrOf, q as ErrorsOf, r as ExhaustiveTransitions, s as Identity, I as Interpret, h as InterpretDetached, t as MachineShape, k as MalformedResult, N as NoCellError, i as NoCtx, O as OkOf, g as PortEmitter, d as Reducer, m as Requirements, f as RequirementsOf, e as Settled, u as SettledErr, v as SettledOk, w as Subscribe, x as SyncReturn, j as Tagged, n as TaggedError, T as Transitions, U as UpdateForm, y as acceptedTypes, z as acceptsOf, B as applyCell, F as applyCellChecked, G as describeMachine, H as detectUpdateForm, J as foldMsgs, K as foldUpdates, L as formOf, Q as msgKeysOf, V as structuralHash, W as subId } from './core-DnzqWy6u.js';
+import { S as SubscribeHandler } from './types-BseNPIhr.js';
 import 'better-result';
 import 'zod';
 
+/**
+ * @packageDocumentation
+ * The composition seam — the layer between a battery and a door.
+ *
+ * A battery is pure state plus verbs over that state. A door holds several
+ * batteries side by side in one Model. Everything between those two facts was,
+ * until now, hand-written at every consumer: the one-key record rebuild that
+ * threads a verb's `[slice, cmds]` result back into the host state, and the
+ * statement order that decides which slice wins a derived read.
+ *
+ * Two helpers cover it, and neither is an optics kit. {@link liftSlice} is the
+ * record rebuild with the key checked by the type system; {@link readInOrder}
+ * turns a read's precedence from statement order into a value you can name,
+ * export and assert on. ADR 0001 (no off-the-shelf resilience) and ADR 0014
+ * (Effect's types, never its runtime values) between them settle why this is
+ * forty lines here rather than a dependency.
+ *
+ * Both are pure: no clock, no RNG, no storage, nothing captured. A `liftSlice`
+ * result is a fresh record and a Cmd array, so ADR 0014's journal/hash promise
+ * over a reducer's return value is untouched.
+ */
+/**
+ * Lift a battery verb's result into the host state that carries its slice.
+ *
+ * `liftSlice("resilience", state, knob.attempt(state.resilience, …))` is the
+ * `{ ...state, resilience: slice }` every consumer writes by hand, with the key
+ * checked: `key` must be a key of `S`, and the slice the verb returned must be
+ * assignable to the type that key carries — so naming the wrong field, or
+ * threading one battery's slice into another's key, is a compile error rather
+ * than a state shape nothing reads correctly.
+ *
+ * PURE — a fresh record and the verb's own Cmds, unchanged.
+ */
+declare function liftSlice<S, K extends keyof S, C>(key: K, state: S, [slice, cmds]: readonly [S[K], readonly C[]]): readonly [S, readonly C[]];
+/**
+ * One step of a composed read: the slice it consults, under the name that slice
+ * goes by. `read` returns `undefined` for "this slice has nothing to say",
+ * which is what hands the read on to the next step.
+ */
+interface ReadStep<In, Out> {
+    /** The slice this step consults — `"cache"`, `"failed"`, `"inFlight"`. */
+    readonly name: string;
+    /** What this slice says about `input`, or `undefined` to defer. */
+    readonly read: (input: In) => Out | undefined;
+}
+/**
+ * Run a composed read through `order` and return the first answer any step
+ * gives, or `absent` when every one defers.
+ *
+ * The point is that `order` is a VALUE. A derived read over three battery
+ * slices otherwise states its precedence as the order of three `if` statements,
+ * where it is invisible to the type system, unnameable in a test and one
+ * innocent-looking reshuffle away from being wrong — which is exactly the
+ * defect that escaped `classify-batch`'s per-battery test suites. Written as
+ * data, the precedence can be exported, printed and asserted on directly.
+ *
+ * PURE — it evaluates `read` in order and stores nothing.
+ */
+declare function readInOrder<In, Out>(input: In, order: readonly ReadStep<In, Out>[], absent: Out): Out;
+
 interface HistoryTracker<S, M extends {
     type: string;
 }> {
@@ -817,4 +877,4 @@ interface TransportBattery<TKey, Outbound, M, Ctx> {
  */
 declare function fromTransport<TKey, Inbound, Outbound, M, Ctx>(opts: FromTransportOpts<TKey, Inbound, Outbound, M, Ctx>): TransportBattery<TKey, Outbound, M, Ctx>;
 
-export { type Ack, type AckPartition, BootingRuntime, type CancelTimer, Cmd, type CombinedManagedResources, type DefineManagedResourceOpts, DepKeyedSub, Dispose, type DriveToDoneOptions, type EventSourceFactoryOpts, type FromTransportOpts, type GatedManagedResource, type HistoryTracker, type ListenerTarget, Machine, type ManagedResourceBattery, type ManagedResourceSub, NO_ACK, OnError, Port, type ReconnectingWebSocketFactoryOpts, RequiredCtx, Runtime, ScopedCtxArg, type Seq, type SeqTagged, Store, Sub, SubId, SubscribeHandler, Supervision, type Transport, type TransportBattery, type TransportFactory, type TransportSub, type WebSocketFactoryOpts, type WebSocketSubData, ack, combineManagedResources, defineListener, defineManagedResource, driveToDone, fromBroadcastChannel, fromEventSource, fromEventTarget, fromInterval, fromPort, fromReconnectingWebSocket, fromTimeout, fromTransport, fromWebSocket, historyTracker, initAck, nextSeq, partitionByAck, reconcile, run, tagSeq };
+export { type Ack, type AckPartition, BootingRuntime, type CancelTimer, Cmd, type CombinedManagedResources, type DefineManagedResourceOpts, DepKeyedSub, Dispose, type DriveToDoneOptions, type EventSourceFactoryOpts, type FromTransportOpts, type GatedManagedResource, type HistoryTracker, type ListenerTarget, Machine, type ManagedResourceBattery, type ManagedResourceSub, NO_ACK, OnError, Port, type ReadStep, type ReconnectingWebSocketFactoryOpts, RequiredCtx, Runtime, ScopedCtxArg, type Seq, type SeqTagged, Store, Sub, SubId, SubscribeHandler, Supervision, type Transport, type TransportBattery, type TransportFactory, type TransportSub, type WebSocketFactoryOpts, type WebSocketSubData, ack, combineManagedResources, defineListener, defineManagedResource, driveToDone, fromBroadcastChannel, fromEventSource, fromEventTarget, fromInterval, fromPort, fromReconnectingWebSocket, fromTimeout, fromTransport, fromWebSocket, historyTracker, initAck, liftSlice, nextSeq, partitionByAck, readInOrder, reconcile, run, tagSeq };

package/dist/index.js

@@ -1,3 +1,3 @@
-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, msgKeysOf, nextSeq, noop, partitionByAck, provide, reconcile, replay, run, schemaMigrate, settle, structuralHash, subId, tagSeq, tryApplyCell, tryFoldMsgs, tryInterpret, value, wrapDetached } from './chunk-RQULHGYH.js';
+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';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/jev/index.d.ts

@@ -1,14 +1,15 @@
-import { b as CmdDef, C as Cmd } from '../core-CTzMJ82M.js';
+import { b as CmdDef, C as Cmd } from '../core-DnzqWy6u.js';
 import { RetryPolicy } from '../retry-backoff/index.js';
-import { R as RunCmd, F as FailMsg, S as SucceedMsg, a as ResilientState } from '../index-B5BZ-_cT.js';
-import { a as DeadlineSub, D as DeadlineExceeded, T as TtlCache, C as CacheEvictionSub, c as CacheEvictMsg } from '../index-q0hXFeZ0.js';
-export { b as deadlineSub, s as subscribeDeadline } from '../index-q0hXFeZ0.js';
-import { S as SubscribeHandler } from '../types-DP3f5NIl.js';
-import { B as BatchWindow, a as BatchWindowSub } from '../index-4vZzljCD.js';
-import { F as FanOutState } from '../index-6A7dB8f6.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-DJWIER_3.js';
-import '../runtime-types-LWDoi943.js';
+import '../index-CSyMYDAB.js';
+import '../runtime-types-CMF13BBh.js';
 import 'better-result';
 
 /**
@@ -59,12 +60,19 @@ import 'better-result';
  * network actually produced. Every `unknown` reaches a `JevErr`; nothing
  * reaches a `throw`.
  *
- * Both halves of a choice question's claim are checked, because both are cast
- * away at the tail of `parseAnswers`: `choice` must be one of the criteria
- * keys, and `probabilities` must be keyed by EXACTLY those keys — none
- * missing, none extra. 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 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 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.
  *
  * ## Why status classification lives here and not in `ask`
  *
@@ -280,12 +288,11 @@ type JevParse<Q extends JevQuestionMap> = {
  * Turn an `unknown` response body into the typed answers for `questions`, or
  * into one `JevErr`. Pure, total, and never throwing on any input.
  *
- * The walk is question-driven, not body-driven: every id the request asked
- * about must be answered, and each answer is checked against ITS question's
- * type and — for a choice — against that question's own criteria keys, both as
- * the `choice` picked and as the exact key set of `probabilities`. An
- * answer under an id nobody asked about is ignored rather than refused; the
- * questions are the contract, and a wider response still satisfies it.
+ * The schema is question-driven: every id the request asked about must be
+ * answered, each answer is checked against ITS question's type and — for a
+ * choice — against that question's own criteria keys, both as the `choice`
+ * picked and as the exact key set of `probabilities`. An answer under an id
+ * nobody asked about is dropped rather than refused.
  */
 declare const parseAnswers: <Q extends JevQuestionMap>(questions: Q, body: unknown) => JevParse<Q>;
 /**
@@ -468,6 +475,7 @@ type JevTimerMsg = DeadlineExceeded;
  * enriched settle Msg.
  */
 declare function createJevAsk<Q extends JevQuestionMap>(config: JevAskConfig<Q>, rng?: () => number): {
+    name: "resilient";
     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>[]];
@@ -499,6 +507,10 @@ 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
  * door's slice so a consumer wires one import. Pure.
+ *
+ * The record rebuild is `liftSlice` from the root door (#231), the same helper
+ * `liftResilience` is expressed over — this stays as the named, pre-keyed
+ * convenience for this door, unchanged in name, signature and subpath.
  */
 declare function liftJevAsk<S extends {
     resilience: ResilientState<JevRequest<Q>, JevOk<Q>>;
@@ -621,7 +633,7 @@ declare function createClassifyBatch<I, C extends string>(config: ClassifyBatchC
     answerFor: (state: ClassifyBatchState<I, C>, key: string, at: number) => KeyAnswer<C>;
     subs: (state: ClassifyBatchState<I, C>, id?: string) => readonly (BatchWindowSub | CacheEvictionSub)[];
     subscribers: () => {
-        deadline: SubscribeHandler<DeadlineSub, DeadlineExceeded, unknown>;
+        deadline: SubscribeHandler<BatchWindowSub, BatchWindowExpired, unknown>;
         cache: SubscribeHandler<CacheEvictionSub, CacheEvictMsg, unknown>;
     };
     handlers: () => {

package/dist/jev/index.js

@@ -1,15 +1,16 @@
-import { createBatchWindow, subscribeBatchWindow } from '../chunk-F7FMAWLA.js';
+import { createBatchWindow, subscribeBatchWindow } from '../chunk-QPEVCJ5Q.js';
 import '../chunk-LFZUK6J2.js';
 import { createFanOut } from '../chunk-MYXFNWAJ.js';
 import '../chunk-TXN2KFHF.js';
-import { runCmdDef, createResilientCall, liftResilience, MsgType } from '../chunk-AQ6ZIMEA.js';
+import { runCmdDef, createResilientCall, MsgType } from '../chunk-AYS5N6WY.js';
+export { mountResilientCall } from '../chunk-AYS5N6WY.js';
 import '../chunk-VBDU4JL6.js';
-import { initCache, has, set, evictExpired, get, cacheEvictionSub, cacheEvictionSubscribe } from '../chunk-F2US5BW6.js';
-export { deadlineSub, subscribeDeadline } from '../chunk-F2US5BW6.js';
+import { initCache, has, set, evictExpired, cacheEvictionSub, cacheEvictionSubscribe, get } from '../chunk-22POWGFA.js';
+export { deadlineSub, subscribeDeadline } from '../chunk-22POWGFA.js';
 import { describeError } from '../chunk-G5E74IJB.js';
-import '../chunk-RQULHGYH.js';
+import { liftSlice, readInOrder } from '../chunk-66PY5WYF.js';
+import { z } from 'zod';
 
-// src/internal/jev/protocol/index.ts
 var jevQuestions = (questions) => questions;
 var JEV_ENDPOINT = "https://api.typesafe.ai/v1/systemone";
 var JEV_ERR_TAG_WITNESS = {
@@ -30,114 +31,127 @@ function isJevErr(value) {
   return typeof tag === "string" && tags.has(tag);
 }
 var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-var isNum = (v) => typeof v === "number" && Number.isFinite(v);
-var isNumMap = (v) => isObj(v) && Object.values(v).every(isNum);
-var isStrMap = (v) => isObj(v) && Object.values(v).every((x) => typeof x === "string");
+var at = (value, key) => isObj(value) ? value[key] : void 0;
 var err = (error) => ({
   ok: false,
   error
 });
-var checkAnswer = (id, question, answer) => {
-  if (!isObj(answer)) {
-    return { _tag: "malformed_answer", id, reason: "answer is not an object" };
-  }
-  const received = answer["type"];
-  if (typeof received !== "string") {
-    return { _tag: "malformed_answer", id, reason: "answer has no `type`" };
-  }
-  if (received !== question.type) {
-    return {
-      _tag: "answer_type_mismatch",
-      id,
-      expected: question.type,
-      received
-    };
-  }
-  if (question.type === "noul") {
-    return isNum(answer["noul"]) ? void 0 : { _tag: "malformed_answer", id, reason: "`noul` is not a number" };
+var finite = z.number().finite();
+var answerSchema = (question) => {
+  switch (question.type) {
+    case "noul":
+      return z.object({ type: z.literal("noul"), noul: finite });
+    case "score":
+      return z.object({
+        type: z.literal("score"),
+        confidence: finite,
+        score: finite,
+        legend: z.record(z.string(), z.string()),
+        probabilities: z.record(z.string(), finite)
+      });
+    case "choice": {
+      const options = Object.keys(question.criteria);
+      return z.object({
+        type: z.literal("choice"),
+        choice: z.enum(options),
+        confidence: finite,
+        // `JevChoiceAnswer<K>` types `probabilities` as TOTAL over the criteria
+        // keys. A strict object whose shape is those keys IS that claim: a
+        // missing key fails the shape, an extra one is unrecognized.
+        probabilities: z.strictObject(
+          Object.fromEntries(options.map((k) => [k, finite]))
+        )
+      });
+    }
   }
-  if (!isNum(answer["confidence"])) {
-    return {
-      _tag: "malformed_answer",
+};
+var jevAnswersSchema = (questions) => z.object(
+  Object.fromEntries(
+    Object.entries(questions).map(([id, question]) => [
       id,
-      reason: "`confidence` is not a number"
-    };
+      answerSchema(question)
+    ])
+  )
+);
+var responseSchema = (questions) => z.object({
+  model: z.string(),
+  usage: z.object({ input_tokens: finite, output_tokens: finite }),
+  answers: jevAnswersSchema(questions)
+});
+var ANSWER_FIELD_REASON = {
+  confidence: "`confidence` is not a number",
+  score: "`score` is not a number",
+  legend: "`legend` is not a map of strings",
+  probabilities: "`probabilities` is not a map of numbers",
+  choice: "`choice` is not a string",
+  noul: "`noul` is not a number"
+};
+var toJevErr = (questions, body, issue) => {
+  const [head, id, field] = issue?.path ?? [];
+  if (head === "model") {
+    return { _tag: "malformed_body", reason: "`model` is not a string" };
   }
-  const probabilities = answer["probabilities"];
-  if (!isNumMap(probabilities)) {
+  if (head === "usage") {
     return {
-      _tag: "malformed_answer",
-      id,
-      reason: "`probabilities` is not a map of numbers"
-    };
-  }
-  if (question.type === "score") {
-    if (!isNum(answer["score"])) {
-      return {
-        _tag: "malformed_answer",
-        id,
-        reason: "`score` is not a number"
-      };
-    }
-    return isStrMap(answer["legend"]) ? void 0 : {
-      _tag: "malformed_answer",
-      id,
-      reason: "`legend` is not a map of strings"
+      _tag: "malformed_body",
+      reason: "`usage` is not `{ input_tokens, output_tokens }`"
     };
   }
-  const choice = answer["choice"];
-  if (typeof choice !== "string") {
-    return { _tag: "malformed_answer", id, reason: "`choice` is not a string" };
+  if (head !== "answers") {
+    return { _tag: "malformed_body", reason: "body is not an object" };
   }
-  const options = Object.keys(question.criteria);
-  if (!options.includes(choice)) {
-    return { _tag: "off_criteria_choice", id, choice, options };
+  const answers = at(body, "answers");
+  if (!isObj(answers) || typeof id !== "string") {
+    return { _tag: "malformed_body", reason: "`answers` is not an object" };
   }
-  const missing = options.filter((k) => !Object.hasOwn(probabilities, k));
-  const extra = Object.keys(probabilities).filter((k) => !options.includes(k));
-  return missing.length === 0 && extra.length === 0 ? void 0 : { _tag: "off_criteria_probabilities", id, missing, extra, options };
-};
-var parseAnswers = (questions, body) => {
-  if (!isObj(body))
-    return err({ _tag: "malformed_body", reason: "body is not an object" });
-  const model = body["model"];
-  if (typeof model !== "string") {
-    return err({ _tag: "malformed_body", reason: "`model` is not a string" });
-  }
-  const usage = body["usage"];
-  if (!isObj(usage) || !isNum(usage["input_tokens"]) || !isNum(usage["output_tokens"])) {
-    return err({
-      _tag: "malformed_body",
-      reason: "`usage` is not `{ input_tokens, output_tokens }`"
-    });
+  if (!Object.hasOwn(answers, id)) return { _tag: "missing_answer", id };
+  const answer = answers[id];
+  const question = questions[id];
+  if (question === void 0 || field === void 0) {
+    return { _tag: "malformed_answer", id, reason: "answer is not an object" };
   }
-  const answers = body["answers"];
-  if (!isObj(answers)) {
-    return err({
-      _tag: "malformed_body",
-      reason: "`answers` is not an object"
-    });
+  if (field === "type") {
+    const received = at(answer, "type");
+    return typeof received === "string" ? { _tag: "answer_type_mismatch", id, expected: question.type, received } : { _tag: "malformed_answer", id, reason: "answer has no `type`" };
   }
-  for (const [id, question] of Object.entries(questions)) {
-    if (!Object.hasOwn(answers, id)) {
-      return err({ _tag: "missing_answer", id });
+  if (question.type === "choice") {
+    const options = Object.keys(question.criteria);
+    if (field === "choice") {
+      const choice = at(answer, "choice");
+      if (typeof choice === "string") {
+        return { _tag: "off_criteria_choice", id, choice, options };
+      }
+    }
+    if (field === "probabilities") {
+      const probabilities = at(answer, "probabilities");
+      const key = issue?.path[3];
+      const badValue = isObj(probabilities) && typeof key === "string" && Object.hasOwn(probabilities, key);
+      if (isObj(probabilities) && !badValue) {
+        return {
+          _tag: "off_criteria_probabilities",
+          id,
+          missing: options.filter((k) => !Object.hasOwn(probabilities, k)),
+          extra: Object.keys(probabilities).filter((k) => !options.includes(k)),
+          options
+        };
+      }
     }
-    const bad = checkAnswer(id, question, answers[id]);
-    if (bad !== void 0) return err(bad);
   }
+  const named = typeof field === "string" ? ANSWER_FIELD_REASON[field] : void 0;
   return {
-    ok: true,
-    // Every id of `questions` passed `checkAnswer`, which is exactly the set of
-    // obligations `JevAnswers<Q>` states. `unknown` is the bridge because the
-    // per-id narrowing happened in a loop, where the compiler cannot carry it.
-    answers,
-    model,
-    usage: {
-      input_tokens: usage["input_tokens"],
-      output_tokens: usage["output_tokens"]
-    }
+    _tag: "malformed_answer",
+    id,
+    reason: named ?? issue?.message ?? "answer is malformed"
   };
 };
+var parseAnswers = (questions, body) => {
+  const parsed = responseSchema(questions).safeParse(body);
+  if (!parsed.success) {
+    return err(toJevErr(questions, body, parsed.error.issues[0]));
+  }
+  const { answers, model, usage } = parsed.data;
+  return { ok: true, answers, model, usage };
+};
 var classifyStatus = (status) => {
   if (status >= 200 && status < 300) return "ok";
   if (status === 429 || status === 529) return "retry";
@@ -184,18 +198,18 @@ function createJevAsk(config, rng = Math.random) {
   function init() {
     return rc.init();
   }
-  function attempt(s, key, content, at) {
+  function attempt(s, key, content, at2) {
     const request = {
       state: content,
       model,
       questions: config.questions
     };
-    return rc.attempt(s, key, request, at);
+    return rc.attempt(s, key, request, at2);
   }
   function succeed(s, key, msg) {
     return rc.succeed(s, key, msg);
   }
-  function settleFromFallback(s, key, request, fallback, at) {
+  function settleFromFallback(s, key, request, fallback, at2) {
     const decided = fallback(request);
     if (isErrDecision(decided)) return rc.settleFailed(s, key, decided);
     return rc.succeed(s, key, {
@@ -207,7 +221,7 @@ function createJevAsk(config, rng = Math.random) {
         usage: NO_USAGE,
         source: "fallback"
       },
-      at
+      at: at2
     });
   }
   function fail(s, key, msg) {
@@ -274,10 +288,20 @@ function createJevAsk(config, rng = Math.random) {
   function handlers() {
     return { resilient_run: (cmd) => settleOf(cmd) };
   }
-  return { init, attempt, succeed, fail, onTimer, subs, handlers, ask };
+  return {
+    name: rc.name,
+    init,
+    attempt,
+    succeed,
+    fail,
+    onTimer,
+    subs,
+    handlers,
+    ask
+  };
 }
 function liftJevAsk(state, result) {
-  return liftResilience(state, result);
+  return liftSlice("resilience", state, result);
 }
 
 // src/internal/jev/classify-batch/index.ts
@@ -346,21 +370,28 @@ function createClassifyBatch(config) {
       id: cmd.items.map(config.keyOf).join("\0"),
       items: cmd.items
     }));
-    const [next, cmds] = fanOut.scatter(state.fanOut, batches);
-    return [{ ...state, fanOut: next }, cmds];
+    return liftSlice("fanOut", state, fanOut.scatter(state.fanOut, batches));
   }
-  function add(state, item, at) {
+  function add(state, item, at2) {
     const key = config.keyOf(item);
-    if (has(state.cache, key, at)) return [state, []];
+    if (has(state.cache, key, at2)) return [state, []];
     if (keysInFlight(state).has(key)) return [state, []];
     const failed = { ...state.failed };
     delete failed[key];
-    const [nextWindow, flushed] = window.add(state.window, item, at);
-    return scatter({ ...state, failed, window: nextWindow }, flushed);
-  }
-  function onWindow(state, at) {
-    const [nextWindow, flushed] = window.onWindow(state.window, at);
-    return scatter({ ...state, window: nextWindow }, flushed);
+    const [buffered, flushed] = liftSlice(
+      "window",
+      { ...state, failed },
+      window.add(state.window, item, at2)
+    );
+    return scatter(buffered, flushed);
+  }
+  function onWindow(state, at2) {
+    const [closed, flushed] = liftSlice(
+      "window",
+      state,
+      window.onWindow(state.window, at2)
+    );
+    return scatter(closed, flushed);
   }
   function onBatchOk(state, msg) {
     let cache = state.cache;
@@ -369,8 +400,11 @@ function createClassifyBatch(config) {
     }
     const failed = { ...state.failed };
     for (const key of Object.keys(msg.result.answers)) delete failed[key];
-    const [nextFanOut, cmds] = fanOut.itemOk(state.fanOut, msg.key, msg.result);
-    return [{ ...state, cache, failed, fanOut: nextFanOut }, cmds];
+    return liftSlice(
+      "fanOut",
+      { ...state, cache, failed },
+      fanOut.itemOk(state.fanOut, msg.key, msg.result)
+    );
   }
   function onBatchErr(state, msg) {
     const batch = runningBatch(state, msg.key);
@@ -378,19 +412,37 @@ function createClassifyBatch(config) {
     if (batch !== void 0) {
       for (const item of batch.items) failed[config.keyOf(item)] = msg.error;
     }
-    const [nextFanOut, cmds] = fanOut.itemErr(state.fanOut, msg.key, msg.error);
-    return [{ ...state, failed, fanOut: nextFanOut }, cmds];
-  }
-  function onEvict(state, at) {
-    return [{ ...state, cache: evictExpired(state.cache, at) }, []];
-  }
-  function answerFor(state, key, at) {
-    const answer = get(state.cache, key, at);
-    if (answer !== void 0) return { status: "answered", answer };
-    const error = state.failed[key];
-    if (error !== void 0) return { status: "failed", error };
-    if (keysInFlight(state).has(key)) return { status: "pending" };
-    return { status: "absent" };
+    return liftSlice(
+      "fanOut",
+      { ...state, failed },
+      fanOut.itemErr(state.fanOut, msg.key, msg.error)
+    );
+  }
+  function onEvict(state, at2) {
+    return liftSlice("cache", state, [evictExpired(state.cache, at2), []]);
+  }
+  const ANSWER_ORDER = [
+    {
+      name: "cache",
+      read: ({ state, key, at: at2 }) => {
+        const answer = get(state.cache, key, at2);
+        return answer === void 0 ? void 0 : { status: "answered", answer };
+      }
+    },
+    {
+      name: "failed",
+      read: ({ state, key }) => {
+        const error = state.failed[key];
+        return error === void 0 ? void 0 : { status: "failed", error };
+      }
+    },
+    {
+      name: "inFlight",
+      read: ({ state, key }) => keysInFlight(state).has(key) ? { status: "pending" } : void 0
+    }
+  ];
+  function answerFor(state, key, at2) {
+    return readInOrder({ state, key, at: at2 }, ANSWER_ORDER, { status: "absent" });
   }
   function subs(state, id = "jev-classify-batch") {
     const windowSubs = window.subs(state.window, id);