@demlik/tea 0.14.0 → 0.16.0

package/dist/jev/index.js

@@ -1,13 +1,14 @@
-import { createBatchWindow, subscribeBatchWindow } from '../chunk-F7FMAWLA.js';
+import { createBatchWindow } from '../chunk-MVZS5FDM.js';
 import '../chunk-LFZUK6J2.js';
-import { createFanOut } from '../chunk-MYXFNWAJ.js';
+import { describeError } from '../chunk-G5E74IJB.js';
+import { createFanOut } from '../chunk-QNGYQMZB.js';
 import '../chunk-TXN2KFHF.js';
-import { runCmdDef, createResilientCall, liftResilience, MsgType } from '../chunk-AQ6ZIMEA.js';
+import { runCmdDef, createResilientCall } from '../chunk-6NG4V5SB.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 { describeError } from '../chunk-G5E74IJB.js';
-import '../chunk-RQULHGYH.js';
+import '../chunk-4LPY67E4.js';
+import { initCache, has, set, evictExpired, cacheEvictionSub, cacheEvictionSubscribe, get } from '../chunk-IVJP3GKJ.js';
+import { liftSlice, readInOrder } from '../chunk-GOX2CYIM.js';
+import { Outcome } from '../chunk-CH5KTOEZ.js';
 
 // src/internal/jev/protocol/index.ts
 var jevQuestions = (questions) => questions;
@@ -30,114 +31,176 @@ 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
-    };
+var pass = (value) => ({ ok: true, value });
+var fail = (path) => ({
+  ok: false,
+  issue: { path }
+});
+var isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
+var object = (value, path, fields) => {
+  if (!isObj(value)) return fail(path);
+  const out = {};
+  for (const [key, check] of fields) {
+    const step = check(value[key], [...path, key]);
+    if (!step.ok) return step;
+    out[key] = step.value;
+  }
+  return pass(out);
+};
+var record = (isValue) => (value, path) => {
+  if (!isObj(value)) return fail(path);
+  for (const [key, v] of Object.entries(value)) {
+    if (!isValue(v)) return fail([...path, key]);
   }
-  if (question.type === "noul") {
-    return isNum(answer["noul"]) ? void 0 : { _tag: "malformed_answer", id, reason: "`noul` is not a number" };
+  return pass({ ...value });
+};
+var literal = (expected) => (value, path) => value === expected ? pass(expected) : fail(path);
+var finite = (value, path) => isFiniteNumber(value) ? pass(value) : fail(path);
+var string = (value, path) => typeof value === "string" ? pass(value) : fail(path);
+var exactProbabilities = (options) => (value, path) => {
+  const named = object(
+    value,
+    path,
+    options.map((k) => [k, finite])
+  );
+  if (!named.ok || !isObj(value)) return named;
+  return Object.keys(value).every((k) => options.includes(k)) ? named : fail(path);
+};
+var checkAnswer = (question, value, path) => {
+  switch (question.type) {
+    case "noul":
+      return object(value, path, [
+        ["type", literal("noul")],
+        ["noul", finite]
+      ]);
+    case "score":
+      return object(value, path, [
+        ["type", literal("score")],
+        ["confidence", finite],
+        ["score", finite],
+        ["legend", record((v) => typeof v === "string")],
+        ["probabilities", record(isFiniteNumber)]
+      ]);
+    case "choice": {
+      const options = Object.keys(question.criteria);
+      return object(value, path, [
+        ["type", literal("choice")],
+        [
+          "choice",
+          (v, p) => typeof v === "string" && options.includes(v) ? pass(v) : fail(p)
+        ],
+        ["confidence", finite],
+        ["probabilities", exactProbabilities(options)]
+      ]);
+    }
   }
-  if (!isNum(answer["confidence"])) {
-    return {
-      _tag: "malformed_answer",
-      id,
-      reason: "`confidence` is not a number"
-    };
+};
+var checkResponse = (questions, body) => {
+  const envelope = object(
+    body,
+    [],
+    [
+      ["model", string],
+      [
+        "usage",
+        (v, p) => object(v, p, [
+          ["input_tokens", finite],
+          ["output_tokens", finite]
+        ])
+      ],
+      [
+        "answers",
+        (v, p) => object(
+          v,
+          p,
+          Object.entries(questions).map(
+            ([id, question]) => [id, (a, ap) => checkAnswer(question, a, ap)]
+          )
+        )
+      ]
+    ]
+  );
+  if (!envelope.ok) return envelope;
+  const { model, usage, answers } = envelope.value;
+  return pass({ model, usage, answers });
+};
+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 ?? "answer is malformed"
   };
 };
+var parseAnswers = (questions, body) => {
+  const parsed = checkResponse(questions, body);
+  if (!parsed.ok) return err(toJevErr(questions, body, parsed.issue));
+  const { answers, model, usage } = parsed.value;
+  return { ok: true, answers, model, usage };
+};
 var classifyStatus = (status) => {
   if (status >= 200 && status < 300) return "ok";
   if (status === 429 || status === 529) return "retry";
@@ -148,20 +211,53 @@ var classifyStatus = (status) => {
 function isTransientJevAskErr(error) {
   return error._tag === "http_retry" || error._tag === "port_threw";
 }
-var JevAskFailure = class extends Error {
-  constructor(jev) {
-    super(`jev ask: ${jev._tag}`);
-    this.jev = jev;
-    this.name = "JevAskFailure";
+function reject(jev) {
+  return Outcome.err({ _tag: "port_rejected", jev });
+}
+function jevAskErrOf(error) {
+  if (typeof error === "object" && error !== null) {
+    const jev = error.jev;
+    if (typeof jev === "object" && jev !== null && typeof jev._tag === "string") {
+      return jev;
+    }
   }
-  jev;
-};
-function toAskErr(error) {
-  if (error instanceof JevAskFailure) return error.jev;
   return { _tag: "port_threw", reason: describeError(error) };
 }
 var DEFAULT_JEV_MODEL = "jev-latest";
 var NO_USAGE = { input_tokens: 0, output_tokens: 0 };
+function isErrDecision(decided) {
+  return isJevErr(decided);
+}
+function decodeJevReply(request, reply) {
+  const kind = classifyStatus(reply.status);
+  if (kind === "retry")
+    return reject({ _tag: "http_retry", status: reply.status });
+  if (kind === "terminal") {
+    return reject({ _tag: "http_terminal", status: reply.status });
+  }
+  const parsed = parseAnswers(request.questions, reply.body);
+  if (!parsed.ok) return reject(parsed.error);
+  return Outcome.ok({
+    answers: parsed.answers,
+    model: parsed.model,
+    usage: parsed.usage,
+    source: "port"
+  });
+}
+function jevCallThrew(cause) {
+  return reject({ _tag: "port_threw", reason: describeError(cause) });
+}
+function offlineJevAnswer(request, fallback) {
+  if (fallback === void 0) return reject({ _tag: "no_answer_path" });
+  const decided = fallback(request);
+  if (isErrDecision(decided)) return reject(decided);
+  return Outcome.ok({
+    answers: decided,
+    model: request.model,
+    usage: NO_USAGE,
+    source: "fallback"
+  });
+}
 function jevAskCmdDef() {
   return runCmdDef();
 }
@@ -171,9 +267,6 @@ function createJevAsk(config, rng = Math.random) {
   };
   const rc = createResilientCall(resilientConfig, rng);
   const model = config.model ?? DEFAULT_JEV_MODEL;
-  function isErrDecision(decided) {
-    return isJevErr(decided);
-  }
   function liveRequest(s, key) {
     const call = s.calls[key];
     if (call?.phase === "running" || call?.phase === "waiting_retry") {
@@ -184,100 +277,71 @@ 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);
-  }
-  function succeed(s, key, msg) {
-    return rc.succeed(s, key, msg);
-  }
-  function settleFromFallback(s, key, request, fallback, at) {
-    const decided = fallback(request);
-    if (isErrDecision(decided)) return rc.settleFailed(s, key, decided);
-    return rc.succeed(s, key, {
-      type: MsgType.ResilientOk,
-      key,
-      result: {
-        answers: decided,
-        model: request.model,
-        usage: NO_USAGE,
-        source: "fallback"
-      },
-      at
+    return rc.attempt(s, key, request, at2);
+  }
+  function succeed(s, msg) {
+    const { call, cmds } = rc.settle(s, msg);
+    return [call, cmds];
+  }
+  function settleFromFallback(s, key, request, fallback, at2) {
+    const decided = offlineJevAnswer(request, fallback);
+    if (decided._tag === "Err") {
+      return rc.settleFailed(s, key, decided.error.jev, at2);
+    }
+    const { call, cmds } = rc.settle(s, {
+      cmd: { key },
+      value: decided.value,
+      at: at2
     });
+    return [call, cmds];
   }
-  function fail(s, key, msg) {
-    if (!isTransientJevAskErr(msg.error)) {
-      return rc.settleFailed(s, key, msg.error);
+  function fail2(s, msg) {
+    const { key } = msg.cmd;
+    const error = jevAskErrOf(msg.error);
+    if (!isTransientJevAskErr(error)) {
+      return rc.settleFailed(s, key, error, msg.at);
     }
     const request = liveRequest(s, key);
-    const settled = rc.fail(s, key, msg);
-    const backedOff = settled[0].calls[key]?.phase !== "failed";
-    if (backedOff || config.fallback === void 0 || request === void 0) {
-      return settled;
+    const { call, cmds, outcome } = rc.settle(s, { ...msg, error });
+    if (outcome.kind !== "failed" || config.fallback === void 0 || request === void 0) {
+      return [call, cmds];
     }
     return settleFromFallback(s, key, request, config.fallback, msg.at);
   }
   function onTimer(s, msg) {
     return rc.onTimer(s, msg);
   }
-  function subs(s) {
-    return rc.subs(s);
-  }
-  async function ask(request, signal) {
-    if (config.port === void 0) {
-      if (config.fallback === void 0) {
-        throw new JevAskFailure({ _tag: "no_answer_path" });
-      }
-      const decided = config.fallback(request);
-      if (isErrDecision(decided)) throw new JevAskFailure(decided);
-      return {
-        answers: decided,
-        model: request.model,
-        usage: NO_USAGE,
-        source: "fallback"
-      };
-    }
-    const { status, body } = await config.port(request, signal);
-    const kind = classifyStatus(status);
-    if (kind === "retry")
-      throw new JevAskFailure({ _tag: "http_retry", status });
-    if (kind === "terminal") {
-      throw new JevAskFailure({ _tag: "http_terminal", status });
-    }
-    const parsed = parseAnswers(config.questions, body);
-    if (!parsed.ok) throw new JevAskFailure(parsed.error);
-    return {
-      answers: parsed.answers,
-      model: parsed.model,
-      usage: parsed.usage,
-      source: "port"
-    };
-  }
-  const resilientRunHandler = rc.handlers({
-    run: (request) => ask(request)
-  }).resilient_run;
-  async function settleOf(cmd) {
-    const settle = await resilientRunHandler(cmd, {});
-    if (settle.type === MsgType.ResilientOk) return settle;
-    return {
-      type: MsgType.ResilientErr,
-      key: settle.key,
-      error: toAskErr(settle.error),
-      at: settle.at
-    };
+  function deadlines(s) {
+    return rc.deadlines(s);
   }
-  function handlers() {
-    return { resilient_run: (cmd) => settleOf(cmd) };
-  }
-  return { init, attempt, succeed, fail, onTimer, subs, handlers, ask };
+  return {
+    name: rc.name,
+    /** The `Cmd.define`d run Cmd — list it in the machine's `cmds`. */
+    run: rc.run,
+    init,
+    attempt,
+    succeed,
+    fail: fail2,
+    onTimer,
+    deadlines,
+    /** The built-in `timer` Sub's deps — resilient-call's `timer`. */
+    timer: rc.timer,
+    /** Your handler's outcome for an HTTP reply — {@link decodeJevReply}. */
+    decode: (request, reply) => decodeJevReply(request, reply),
+    /** Your handler's outcome when the call threw — {@link jevCallThrew}. */
+    rejected: jevCallThrew,
+    /** Your handler's outcome with no network — {@link offlineJevAnswer}. */
+    offline: (request) => offlineJevAnswer(request, config.fallback)
+  };
 }
 function liftJevAsk(state, result) {
-  return liftResilience(state, result);
+  return liftSlice("resilience", state, result);
 }
 
 // src/internal/jev/classify-batch/index.ts
@@ -346,75 +410,98 @@ 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;
-    for (const [key, answer] of Object.entries(msg.result.answers)) {
+    for (const [key, answer] of Object.entries(msg.value.answers)) {
       cache = set(cache, key, answer, msg.at, config.ttlMs);
     }
     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];
+    for (const key of Object.keys(msg.value.answers)) delete failed[key];
+    return liftSlice(
+      "fanOut",
+      { ...state, cache, failed },
+      fanOut.itemOk(state.fanOut, msg.cmd.key, msg.value)
+    );
   }
   function onBatchErr(state, msg) {
-    const batch = runningBatch(state, msg.key);
+    const batch = runningBatch(state, msg.cmd.key);
+    const error = jevAskErrOf(msg.error);
     const failed = { ...state.failed };
     if (batch !== void 0) {
-      for (const item of batch.items) failed[config.keyOf(item)] = msg.error;
+      for (const item of batch.items) failed[config.keyOf(item)] = 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.cmd.key, 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);
-    if (config.evictEveryMs === void 0) return windowSubs;
-    return [...windowSubs, cacheEvictionSub(id, config.evictEveryMs)];
-  }
-  function subscribers() {
-    return { deadline: subscribeBatchWindow, cache: cacheEvictionSubscribe };
+    return window.subs(state.window, id);
   }
-  function handlers() {
-    return {
-      resilient_run: (cmd) => {
-        const request = cmd.input;
-        const ask = createJevAsk({
-          questions: request.questions,
-          ...config.port === void 0 ? {} : { port: config.port },
-          ...config.fallback === void 0 ? {} : { fallback: config.fallback },
-          ...config.model === void 0 ? {} : { model: config.model }
-        });
-        return ask.handlers().resilient_run(cmd);
-      }
+  function subEntries(select, id = "jev-classify-batch") {
+    const flush = {
+      type: "timer",
+      deps: (model) => window.timer(select(model).window, id)
     };
+    if (config.evictEveryMs === void 0) return [flush];
+    return [flush, cacheEvictionSub(id, config.evictEveryMs)];
+  }
+  function subscribers() {
+    return { cache: cacheEvictionSubscribe };
   }
   return {
+    /** The ask Cmd def — list it in the machine's `cmds`. */
+    ask: askCmd,
     init,
     add,
     onWindow,
@@ -423,11 +510,20 @@ function createClassifyBatch(config) {
     onEvict,
     answerFor,
     subs,
+    subEntries,
     subscribers,
-    handlers
+    /**
+     * Your handler's outcome for Jev's reply to one batch — `../ask`'s
+     * `decodeJevReply`, parsing against the questions the batch carried.
+     */
+    decode: (request, reply) => decodeJevReply(request, reply),
+    /** Your handler's outcome when the call threw — `../ask`'s `jevCallThrew`. */
+    rejected: jevCallThrew,
+    /** Your handler's outcome with no network — the configured `fallback`. */
+    offline: (request) => offlineJevAnswer(request, config.fallback)
   };
 }
 
-export { DEFAULT_CLASSIFY_MAX_ITEMS, DEFAULT_JEV_MODEL, JEV_ENDPOINT, JevAskFailure, classifyStatus, createClassifyBatch, createJevAsk, isJevErr, isTransientJevAskErr, jevAskCmdDef, jevQuestions, liftJevAsk, parseAnswers };
+export { DEFAULT_CLASSIFY_MAX_ITEMS, DEFAULT_JEV_MODEL, JEV_ENDPOINT, classifyStatus, createClassifyBatch, createJevAsk, decodeJevReply, isJevErr, isTransientJevAskErr, jevAskCmdDef, jevAskErrOf, jevCallThrew, jevQuestions, liftJevAsk, offlineJevAnswer, parseAnswers };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map