@demlik/tea 0.13.0 → 0.14.0

package/dist/jev/index.js

@@ -0,0 +1,433 @@
+import { createBatchWindow, subscribeBatchWindow } from '../chunk-F7FMAWLA.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 '../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';
+
+// src/internal/jev/protocol/index.ts
+var jevQuestions = (questions) => questions;
+var JEV_ENDPOINT = "https://api.typesafe.ai/v1/systemone";
+var JEV_ERR_TAG_WITNESS = {
+  malformed_body: true,
+  missing_answer: true,
+  answer_type_mismatch: true,
+  off_criteria_choice: true,
+  off_criteria_probabilities: true,
+  malformed_answer: true
+};
+var JEV_ERR_TAGS = new Set(
+  Object.keys(JEV_ERR_TAG_WITNESS)
+);
+function isJevErr(value) {
+  if (!("_tag" in value)) return false;
+  const tag = value._tag;
+  const tags = JEV_ERR_TAGS;
+  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 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" };
+  }
+  if (!isNum(answer["confidence"])) {
+    return {
+      _tag: "malformed_answer",
+      id,
+      reason: "`confidence` is not a number"
+    };
+  }
+  const probabilities = answer["probabilities"];
+  if (!isNumMap(probabilities)) {
+    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"
+    };
+  }
+  const choice = answer["choice"];
+  if (typeof choice !== "string") {
+    return { _tag: "malformed_answer", id, reason: "`choice` is not a string" };
+  }
+  const options = Object.keys(question.criteria);
+  if (!options.includes(choice)) {
+    return { _tag: "off_criteria_choice", id, choice, options };
+  }
+  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 }`"
+    });
+  }
+  const answers = body["answers"];
+  if (!isObj(answers)) {
+    return err({
+      _tag: "malformed_body",
+      reason: "`answers` is not an object"
+    });
+  }
+  for (const [id, question] of Object.entries(questions)) {
+    if (!Object.hasOwn(answers, id)) {
+      return err({ _tag: "missing_answer", id });
+    }
+    const bad = checkAnswer(id, question, answers[id]);
+    if (bad !== void 0) return err(bad);
+  }
+  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"]
+    }
+  };
+};
+var classifyStatus = (status) => {
+  if (status >= 200 && status < 300) return "ok";
+  if (status === 429 || status === 529) return "retry";
+  return "terminal";
+};
+
+// src/internal/jev/ask/index.ts
+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";
+  }
+  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 jevAskCmdDef() {
+  return runCmdDef();
+}
+function createJevAsk(config, rng = Math.random) {
+  const resilientConfig = {
+    ...config.retry === void 0 ? {} : { retry: config.retry }
+  };
+  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") {
+      return call.input;
+    }
+    return void 0;
+  }
+  function init() {
+    return rc.init();
+  }
+  function attempt(s, key, content, at) {
+    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
+    });
+  }
+  function fail(s, key, msg) {
+    if (!isTransientJevAskErr(msg.error)) {
+      return rc.settleFailed(s, key, msg.error);
+    }
+    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;
+    }
+    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 handlers() {
+    return { resilient_run: (cmd) => settleOf(cmd) };
+  }
+  return { init, attempt, succeed, fail, onTimer, subs, handlers, ask };
+}
+function liftJevAsk(state, result) {
+  return liftResilience(state, result);
+}
+
+// src/internal/jev/classify-batch/index.ts
+var DEFAULT_CLASSIFY_MAX_ITEMS = 25;
+function createClassifyBatch(config) {
+  const maxItems = config.maxItems ?? DEFAULT_CLASSIFY_MAX_ITEMS;
+  const askCmd = jevAskCmdDef();
+  const instructionsFor = config.instructions ?? ((key) => `Classify the element of \`state\` whose key is "${key}".`);
+  function idOfBatch(batch) {
+    return batch.id;
+  }
+  function questionsFor(items) {
+    const questions = {};
+    for (const item of items) {
+      const key = config.keyOf(item);
+      questions[key] = {
+        type: "choice",
+        instructions: instructionsFor(key, item),
+        criteria: config.criteria
+      };
+    }
+    return questions;
+  }
+  function requestFor(batch) {
+    return {
+      state: batch.items,
+      model: config.model ?? DEFAULT_JEV_MODEL,
+      questions: questionsFor(batch.items)
+    };
+  }
+  const fanOut = createFanOut({
+    concurrency: config.concurrency,
+    idOf: idOfBatch,
+    of: (batch) => askCmd({ key: batch.id, input: requestFor(batch) })
+  });
+  const window = createBatchWindow({
+    maxItems,
+    maxMs: config.maxMs,
+    flush: (items) => ({ type: "classify_batch_flush", items })
+  });
+  function init() {
+    return {
+      window: window.init(),
+      fanOut: fanOut.init(),
+      cache: initCache(),
+      failed: {}
+    };
+  }
+  function keysInFlight(state) {
+    const keys = /* @__PURE__ */ new Set();
+    for (const item of state.window.buffer) keys.add(config.keyOf(item));
+    for (const batch of state.fanOut.pending) {
+      for (const item of batch.items) keys.add(config.keyOf(item));
+    }
+    for (const batch of state.fanOut.running) {
+      for (const item of batch.items) keys.add(config.keyOf(item));
+    }
+    return keys;
+  }
+  function runningBatch(state, id) {
+    return state.fanOut.running.find((batch) => batch.id === id);
+  }
+  function scatter(state, flushed) {
+    if (flushed.length === 0) return [state, []];
+    const batches = flushed.map((cmd) => ({
+      id: cmd.items.map(config.keyOf).join("\0"),
+      items: cmd.items
+    }));
+    const [next, cmds] = fanOut.scatter(state.fanOut, batches);
+    return [{ ...state, fanOut: next }, cmds];
+  }
+  function add(state, item, at) {
+    const key = config.keyOf(item);
+    if (has(state.cache, key, at)) 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);
+  }
+  function onBatchOk(state, msg) {
+    let cache = state.cache;
+    for (const [key, answer] of Object.entries(msg.result.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];
+  }
+  function onBatchErr(state, msg) {
+    const batch = runningBatch(state, msg.key);
+    const failed = { ...state.failed };
+    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" };
+  }
+  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 };
+  }
+  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);
+      }
+    };
+  }
+  return {
+    init,
+    add,
+    onWindow,
+    onBatchOk,
+    onBatchErr,
+    onEvict,
+    answerFor,
+    subs,
+    subscribers,
+    handlers
+  };
+}
+
+export { DEFAULT_CLASSIFY_MAX_ITEMS, DEFAULT_JEV_MODEL, JEV_ENDPOINT, JevAskFailure, classifyStatus, createClassifyBatch, createJevAsk, isJevErr, isTransientJevAskErr, jevAskCmdDef, jevQuestions, liftJevAsk, parseAnswers };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/jev/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internal/jev/protocol/index.ts","../../src/internal/jev/ask/index.ts","../../src/internal/jev/classify-batch/index.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/**\n * @packageDocumentation\n * internal/jev/protocol — the wire contract of TypeSafe **Jev** (System One)\n * as types plus two pure functions, and nothing that performs I/O. Internal\n * since #216 — not published on any subpath; the `ask` child that opens the\n * socket imports it from here.\n *\n * The contract is transcribed from `https://docs.typesafe.ai/api`, re-verified\n * 2026-09-21: `POST https://api.typesafe.ai/v1/systemone`, `Authorization:\n * Bearer <API_KEY>`, request `{ state, model, questions }`, response\n * `{ model, answers, usage }`. Where this module and that page disagree, the\n * page is right and this module is a bug.\n *\n * ## What this module is for\n *\n * A Jev call is a map of questions you name, and an answer comes back under\n * each name. That is a shape TypeScript can hold onto, and the whole point of\n * typing it here is that a **choice** question's `criteria` keys ARE its\n * answer's `choice` domain — write the rubric once and the narrowing is free\n * at the call site:\n *\n * ```ts\n * const qs = jevQuestions({\n *   category: {\n *     type: \"choice\",\n *     instructions: \"Which budget line is this?\",\n *     criteria: { groceries: \"Supermarkets\", dining: \"Restaurants\" },\n *   },\n * });\n * // parsed.answers.category.choice : \"groceries\" | \"dining\"\n * ```\n *\n * `jevQuestions` is an identity function with a `const` type parameter; it\n * exists so the literal keys survive inference without every call site\n * spelling `as const`. `JevAnswers<Q>` is the mapped type that turns such a\n * questions map into its answers map.\n *\n * ## Why parsing is a pure function returning data\n *\n * `parseAnswers` never throws — a response that disagrees with the questions\n * that produced it is a recoverable failure with an obvious next move (retry,\n * re-prompt, give up on this one item), so it is DATA: a closed `JevErr`\n * union of `{ _tag }` values that survives a JSON round-trip into Model\n * (ADR 0011). The type-level guarantee above is a *claim about the wire*, and\n * `parseAnswers` is the one place that claim is checked against a body the\n * network actually produced. Every `unknown` reaches a `JevErr`; nothing\n * reaches a `throw`.\n *\n * Both halves of a choice question's claim are checked, because both are cast\n * away at the tail of `parseAnswers`: `choice` must be one of the criteria\n * keys, and `probabilities` must be keyed by EXACTLY those keys — none\n * missing, none extra. A partial distribution typed `Record<K, number>` is the\n * representable-invalid state this module exists to refuse, and it arrives\n * through this gate or not at all.\n *\n * ## Why status classification lives here and not in `ask`\n *\n * \"429 and 529 back off, everything else non-2xx is terminal\" is a fact about\n * the protocol, published in the same reference page as the body shapes, and\n * `ask` re-deriving it is how the retry policy and the wire contract drift\n * apart. `classifyStatus` is the single reading.\n *\n * ## Bounds the API enforces and this module does not\n *\n * A Choice takes at most 255 options and a Score takes at most 10 levels.\n * `JevScoreQuestion` encodes the *lower* bound — a Score with fewer than two\n * levels does not compile — because a two-element minimum is a tuple, which\n * costs nothing. The upper bounds are not encoded: spelling them as a union\n * of nine tuple arities (or 255 of them) buys a compile error in place of a\n * `422`, at the price of unreadable diagnostics on every ordinary Score. They\n * are the API's `422`, which `classifyStatus` already calls terminal.\n */\n\n// ── the shared instruction / description slot ──────────────────────────────\n\n/**\n * What every `instructions` and every criterion description accepts.\n *\n * The reference page allows a string, an object, or an array in all three\n * slots: a long question carrying data it refers to is written as an object\n * with the question in one field and the data in the others. Typing it as\n * `string` alone would reject the documented structured form.\n */\nexport type JevText =\n  | string\n  | Readonly<Record<string, unknown>>\n  | readonly unknown[];\n\n// ── questions ──────────────────────────────────────────────────────────────\n\n/** The three question types, as the `type` discriminant spells them. */\nexport type JevQuestionType = \"choice\" | \"score\" | \"noul\";\n\n/**\n * A choice question's rubric: option key → description, or `null` where an\n * option needs no extra detail. The keys are the answer's `choice` domain.\n */\nexport type JevChoiceCriteria = Readonly<Record<string, JevText | null>>;\n\n/** Pick one option from a set you define. */\nexport interface JevChoiceQuestion<\n  C extends JevChoiceCriteria = JevChoiceCriteria,\n> {\n  readonly type: \"choice\";\n  readonly instructions: JevText;\n  readonly criteria: C;\n}\n\n/**\n * A score question's rubric: an ORDERED list of level descriptions, at least\n * two of them. The API accepts up to ten.\n */\nexport type JevScoreCriteria = readonly [JevText, JevText, ...JevText[]];\n\n/** Rate the state along an ordered rubric. */\nexport interface JevScoreQuestion {\n  readonly type: \"score\";\n  readonly instructions: JevText;\n  readonly criteria: JevScoreCriteria;\n}\n\n/** A yes/no question. `criteria` is optional; both arms are required when it is present. */\nexport interface JevNoulQuestion {\n  readonly type: \"noul\";\n  readonly instructions: JevText;\n  readonly criteria?: {\n    readonly true: JevText;\n    readonly false: JevText;\n  };\n}\n\n/** One typed question. */\nexport type JevQuestion =\n  | JevChoiceQuestion\n  | JevScoreQuestion\n  | JevNoulQuestion;\n\n/** The `questions` map: an id you choose → the question asked under it. */\nexport type JevQuestionMap = Readonly<Record<string, JevQuestion>>;\n\n/**\n * Identity, with the literal keys kept.\n *\n * The `const` type parameter is the whole function: it preserves each choice\n * question's `criteria` keys as literals, so `JevAnswers<typeof qs>` can name\n * them. Without it the inferred type is `Record<string, string>` and the\n * narrowing this module exists for is gone before `parseAnswers` is reached.\n */\nexport const jevQuestions = <const Q extends JevQuestionMap>(questions: Q): Q =>\n  questions;\n\n// ── the request ────────────────────────────────────────────────────────────\n\n/** The evaluation endpoint. */\nexport const JEV_ENDPOINT = \"https://api.typesafe.ai/v1/systemone\" as const;\n\n/** The content to evaluate: text, or structured data. */\nexport type JevState =\n  | string\n  | Readonly<Record<string, unknown>>\n  | readonly unknown[];\n\n/** The request body of `POST /v1/systemone`. */\nexport interface JevRequest<Q extends JevQuestionMap = JevQuestionMap> {\n  readonly state: JevState;\n  readonly model: string;\n  readonly questions: Q;\n}\n\n// ── answers ────────────────────────────────────────────────────────────────\n\n/** The yes/no answer, on a scale from 0 (no) to 1 (yes). */\nexport interface JevNoulAnswer {\n  readonly type: \"noul\";\n  readonly noul: number;\n}\n\n/**\n * The chosen option and the full distribution over the options.\n *\n * `K` is the choice question's own criteria keys, which is why `choice` is a\n * union rather than a `string` and `probabilities` is total over the options.\n */\nexport interface JevChoiceAnswer<K extends string = string> {\n  readonly type: \"choice\";\n  readonly choice: K;\n  readonly probabilities: Readonly<Record<K, number>>;\n  readonly confidence: number;\n}\n\n/**\n * The probability-weighted value across the levels — it can land BETWEEN\n * levels, which is why `score` is a `number` and not an index. `legend` and\n * `probabilities` are keyed by the level index as a string.\n */\nexport interface JevScoreAnswer {\n  readonly type: \"score\";\n  readonly score: number;\n  readonly legend: Readonly<Record<string, string>>;\n  readonly probabilities: Readonly<Record<string, number>>;\n  readonly confidence: number;\n}\n\n/** One typed answer. */\nexport type JevAnswer = JevChoiceAnswer | JevScoreAnswer | JevNoulAnswer;\n\n/** The answer a given question type yields, with the choice union carried through. */\nexport type JevAnswerFor<Q> = Q extends {\n  readonly type: \"choice\";\n  readonly criteria: infer C;\n}\n  ? JevChoiceAnswer<Extract<keyof C, string>>\n  : Q extends { readonly type: \"score\" }\n    ? JevScoreAnswer\n    : Q extends { readonly type: \"noul\" }\n      ? JevNoulAnswer\n      : never;\n\n/** A questions map turned into its answers map, id for id. */\nexport type JevAnswers<Q extends JevQuestionMap> = {\n  readonly [K in keyof Q]: JevAnswerFor<Q[K]>;\n};\n\n/** Token usage for the request. */\nexport interface JevUsage {\n  readonly input_tokens: number;\n  readonly output_tokens: number;\n}\n\n/** The response body of `POST /v1/systemone`. */\nexport interface JevResponse<Q extends JevQuestionMap = JevQuestionMap> {\n  readonly model: string;\n  readonly answers: JevAnswers<Q>;\n  readonly usage: JevUsage;\n}\n\n// ── failures are data ──────────────────────────────────────────────────────\n\n/**\n * Every way a response can fail to be the answers to the questions asked.\n *\n * Closed, `{ _tag }`-discriminated, JSON-round-trippable: a consumer folds one\n * of these into Model and routes on `_tag` (ADR 0011). `path` and `id` say\n * WHERE, so a failure names the question it is about rather than the whole\n * call.\n */\nexport type JevErr =\n  /** The envelope is not a Jev response at all — not an object, or `model` /\n   *  `answers` / `usage` missing or of the wrong shape. */\n  | { readonly _tag: \"malformed_body\"; readonly reason: string }\n  /** A question id in the request has no answer under it in the response. */\n  | { readonly _tag: \"missing_answer\"; readonly id: string }\n  /** An answer arrived, but its `type` is not its question's. */\n  | {\n      readonly _tag: \"answer_type_mismatch\";\n      readonly id: string;\n      readonly expected: JevQuestionType;\n      readonly received: string;\n    }\n  /** A choice answer picked something that is not one of its criteria keys. */\n  | {\n      readonly _tag: \"off_criteria_choice\";\n      readonly id: string;\n      readonly choice: string;\n      readonly options: readonly string[];\n    }\n  /** A choice answer's `probabilities` keys are not exactly its question's\n   *  criteria keys. `JevChoiceAnswer<K>` types that map as TOTAL over `K`, so\n   *  a partial or off-criteria one is the representable-invalid state this\n   *  module exists to refuse. `missing` and `extra` say which way it failed. */\n  | {\n      readonly _tag: \"off_criteria_probabilities\";\n      readonly id: string;\n      readonly missing: readonly string[];\n      readonly extra: readonly string[];\n      readonly options: readonly string[];\n    }\n  /** The answer's `type` is right and its payload is not — a missing\n   *  `confidence`, a `probabilities` that is not a number map, and so on. */\n  | {\n      readonly _tag: \"malformed_answer\";\n      readonly id: string;\n      readonly reason: string;\n    };\n\n/**\n * The tags {@link JevErr} is closed over, witnessed against the union.\n *\n * The `satisfies` is the point: it is the compiler checking this record's keys\n * against `JevErr[\"_tag\"]` in BOTH directions — a union arm with no entry here\n * fails totality, and an entry naming no arm fails the excess-property check\n * on the literal. Before it, the set was `ReadonlySet<string>` and a new arm\n * was tied to its runtime guard by reviewer attention alone: omit the entry\n * and {@link isJevErr} silently answers `false` for that arm forever.\n */\nconst JEV_ERR_TAG_WITNESS = {\n  malformed_body: true,\n  missing_answer: true,\n  answer_type_mismatch: true,\n  off_criteria_choice: true,\n  off_criteria_probabilities: true,\n  malformed_answer: true,\n} as const satisfies Record<JevErr[\"_tag\"], true>;\n\n/**\n * The membership set {@link isJevErr} tests against — the single reading of\n * the union's tags, so nothing downstream re-derives it from a `\"_tag\" in x`\n * test.\n */\nconst JEV_ERR_TAGS: ReadonlySet<JevErr[\"_tag\"]> = new Set(\n  Object.keys(JEV_ERR_TAG_WITNESS) as readonly JevErr[\"_tag\"][],\n);\n\n/**\n * Is `value` a {@link JevErr}?\n *\n * The discriminant is the `_tag` VALUE against the closed set above, never the\n * bare presence of the key. A `JevAnswers` map is keyed by the caller's own\n * question ids, so a caller may legally name a question `_tag` — and then\n * `\"_tag\" in answers` is `true`. The value under it is an ANSWER, which is\n * always an object and never one of these string literals, so reading the\n * value is the one test a caller's id space cannot reach.\n */\nexport function isJevErr(value: object): value is JevErr {\n  if (!(\"_tag\" in value)) return false;\n  const tag: unknown = (value as { readonly _tag: unknown })._tag;\n  // The set is keyed over the union's tags, and the question being asked is\n  // whether an arbitrary string is one of them — a read-only widening, sound\n  // because `has` only ever reads.\n  const tags: ReadonlySet<string> = JEV_ERR_TAGS;\n  return typeof tag === \"string\" && tags.has(tag);\n}\n\n/** What `parseAnswers` returns: typed answers, or one `JevErr`. Never a throw. */\nexport type JevParse<Q extends JevQuestionMap> =\n  | {\n      readonly ok: true;\n      readonly answers: JevAnswers<Q>;\n      readonly model: string;\n      readonly usage: JevUsage;\n    }\n  | { readonly ok: false; readonly error: JevErr };\n\n// ── parsing ────────────────────────────────────────────────────────────────\n\ntype Obj = Readonly<Record<string, unknown>>;\n\nconst isObj = (v: unknown): v is Obj =>\n  typeof v === \"object\" && v !== null && !Array.isArray(v);\n\nconst isNum = (v: unknown): v is number =>\n  typeof v === \"number\" && Number.isFinite(v);\n\n/** Every value of `v` is a finite number. `v` itself must already be an object. */\nconst isNumMap = (v: unknown): v is Readonly<Record<string, number>> =>\n  isObj(v) && Object.values(v).every(isNum);\n\nconst isStrMap = (v: unknown): v is Readonly<Record<string, string>> =>\n  isObj(v) && Object.values(v).every((x) => typeof x === \"string\");\n\nconst err = (\n  error: JevErr,\n): { readonly ok: false; readonly error: JevErr } => ({\n  ok: false,\n  error,\n});\n\n/**\n * Check one answer against the question that asked for it.\n *\n * Returns `undefined` on a match — the answer is then structurally the shape\n * `JevAnswerFor<Q>` names, and the cast at the end of `parseAnswers` is that\n * fact rather than a hope. Returning the error instead of throwing keeps the\n * whole walk branch-free of `try`.\n */\nconst checkAnswer = (\n  id: string,\n  question: JevQuestion,\n  answer: unknown,\n): JevErr | undefined => {\n  if (!isObj(answer)) {\n    return { _tag: \"malformed_answer\", id, reason: \"answer is not an object\" };\n  }\n  const received = answer[\"type\"];\n  if (typeof received !== \"string\") {\n    return { _tag: \"malformed_answer\", id, reason: \"answer has no `type`\" };\n  }\n  if (received !== question.type) {\n    return {\n      _tag: \"answer_type_mismatch\",\n      id,\n      expected: question.type,\n      received,\n    };\n  }\n\n  if (question.type === \"noul\") {\n    return isNum(answer[\"noul\"])\n      ? undefined\n      : { _tag: \"malformed_answer\", id, reason: \"`noul` is not a number\" };\n  }\n\n  if (!isNum(answer[\"confidence\"])) {\n    return {\n      _tag: \"malformed_answer\",\n      id,\n      reason: \"`confidence` is not a number\",\n    };\n  }\n  const probabilities = answer[\"probabilities\"];\n  if (!isNumMap(probabilities)) {\n    return {\n      _tag: \"malformed_answer\",\n      id,\n      reason: \"`probabilities` is not a map of numbers\",\n    };\n  }\n\n  if (question.type === \"score\") {\n    if (!isNum(answer[\"score\"])) {\n      return {\n        _tag: \"malformed_answer\",\n        id,\n        reason: \"`score` is not a number\",\n      };\n    }\n    return isStrMap(answer[\"legend\"])\n      ? undefined\n      : {\n          _tag: \"malformed_answer\",\n          id,\n          reason: \"`legend` is not a map of strings\",\n        };\n  }\n\n  // choice — the two checks the type-level contract rests on.\n  const choice = answer[\"choice\"];\n  if (typeof choice !== \"string\") {\n    return { _tag: \"malformed_answer\", id, reason: \"`choice` is not a string\" };\n  }\n  const options = Object.keys(question.criteria);\n  if (!options.includes(choice)) {\n    return { _tag: \"off_criteria_choice\", id, choice, options };\n  }\n\n  // `JevChoiceAnswer<K>` says `probabilities` is TOTAL over the criteria keys\n  // and carries nothing else. A `Record<K, number>` the bytes under-fill is\n  // exactly the value the cast at the tail of `parseAnswers` would otherwise\n  // launder into the caller's hands.\n  const missing = options.filter((k) => !Object.hasOwn(probabilities, k));\n  const extra = Object.keys(probabilities).filter((k) => !options.includes(k));\n  return missing.length === 0 && extra.length === 0\n    ? undefined\n    : { _tag: \"off_criteria_probabilities\", id, missing, extra, options };\n};\n\n/**\n * Turn an `unknown` response body into the typed answers for `questions`, or\n * into one `JevErr`. Pure, total, and never throwing on any input.\n *\n * The walk is question-driven, not body-driven: every id the request asked\n * about must be answered, and each answer is checked against ITS question's\n * type and — for a choice — against that question's own criteria keys, both as\n * the `choice` picked and as the exact key set of `probabilities`. An\n * answer under an id nobody asked about is ignored rather than refused; the\n * questions are the contract, and a wider response still satisfies it.\n */\nexport const parseAnswers = <Q extends JevQuestionMap>(\n  questions: Q,\n  body: unknown,\n): JevParse<Q> => {\n  if (!isObj(body))\n    return err({ _tag: \"malformed_body\", reason: \"body is not an object\" });\n\n  const model = body[\"model\"];\n  if (typeof model !== \"string\") {\n    return err({ _tag: \"malformed_body\", reason: \"`model` is not a string\" });\n  }\n\n  const usage = body[\"usage\"];\n  if (\n    !isObj(usage) ||\n    !isNum(usage[\"input_tokens\"]) ||\n    !isNum(usage[\"output_tokens\"])\n  ) {\n    return err({\n      _tag: \"malformed_body\",\n      reason: \"`usage` is not `{ input_tokens, output_tokens }`\",\n    });\n  }\n\n  const answers = body[\"answers\"];\n  if (!isObj(answers)) {\n    return err({\n      _tag: \"malformed_body\",\n      reason: \"`answers` is not an object\",\n    });\n  }\n\n  for (const [id, question] of Object.entries(questions)) {\n    if (!Object.hasOwn(answers, id)) {\n      return err({ _tag: \"missing_answer\", id });\n    }\n    const bad = checkAnswer(id, question, answers[id]);\n    if (bad !== undefined) return err(bad);\n  }\n\n  return {\n    ok: true,\n    // Every id of `questions` passed `checkAnswer`, which is exactly the set of\n    // obligations `JevAnswers<Q>` states. `unknown` is the bridge because the\n    // per-id narrowing happened in a loop, where the compiler cannot carry it.\n    answers: answers as unknown as JevAnswers<Q>,\n    model,\n    usage: {\n      input_tokens: usage[\"input_tokens\"],\n      output_tokens: usage[\"output_tokens\"],\n    },\n  };\n};\n\n// ── status classification ──────────────────────────────────────────────────\n\n/**\n * What a caller does next with an HTTP status.\n *\n * `retry` means back off and send it again; `terminal` means this request will\n * never succeed as written. `ok` is the 2xx arm — naming it keeps the function\n * total, so `ask` switches on three cases instead of testing 2xx itself and\n * then asking here.\n */\nexport type JevHttpStatus = \"ok\" | \"retry\" | \"terminal\";\n\n/**\n * Classify one HTTP status, per the reference page's error table.\n *\n * 429 (rate limited) and 529 (overloaded) are the two the page tells you to\n * back off on. 401 (bad key) and 422 (the body failed validation) will fail\n * identically forever. Every other non-2xx is terminal by default: an\n * unrecognized failure is not evidence that retrying helps, and a retry loop\n * over one is the expensive way to find that out.\n */\nexport const classifyStatus = (status: number): JevHttpStatus => {\n  if (status >= 200 && status < 300) return \"ok\";\n  if (status === 429 || status === 529) return \"retry\";\n  return \"terminal\";\n};\n","/**\n * @packageDocumentation\n * internal/jev/ask — one Cmd that asks Jev a question map, over\n * `../../resilience/resilient-call`, with the HTTP caller injected as a port\n * and a pure fallback behind it. Internal since #217 — not published on any\n * subpath; `../protocol` is the wire contract it speaks.\n *\n * This is `../../llm-call` for Jev: a config object, the resilient-call slice\n * it INHERITS, and one interpret handler that calls the port, classifies the\n * status, parses the body against the questions that produced it, and returns\n * the enriched resilient settle Msg so it re-enters the host reducer.\n * `init`, `attempt`, `succeed`, `onTimer` and `subs` are resilient-call's verbs\n * forwarded; there is no retry loop, no timer and no `Date.now()` in any verb\n * here.\n *\n * ## The two ports and the one policy\n *\n *   - `port: JevPort<Q>` — the injected HTTP caller,\n *     `(request, signal?) => Promise<{ status, body }>`. A `fetch`-backed\n *     adapter and a scripted test fake satisfy it identically, and the door\n *     never reads an env var or holds a key: whoever builds the adapter owns\n *     the `Authorization` header. `undefined` is the no-key case, and it is a\n *     legal configuration — see the fallback.\n *   - `fallback?: (request) => JevAnswers<Q> | JevErr` — a PURE deterministic\n *     decider. It answers on the two paths where the network cannot: `port` is\n *     absent, or the resilient retry budget is spent. Pure is the requirement,\n *     not a preference — the exhaustion path calls it inside the `fail` verb,\n *     so a fallback that read a clock or a socket would break replay.\n *   - `retry: RetryPolicy` — handed straight to resilient-call. Omit it and the\n *     first transient failure is terminal, exactly as resilient-call documents.\n *\n * ## Which failures back off and which do not\n *\n * `classifyStatus` (the protocol child, the single reading of the error table)\n * splits the answer three ways, and that split IS the retry decision:\n *\n *   - `ok` → parse. A body that disagrees with the questions asked settles\n *     `resilient_err` carrying the protocol's own {@link JevErr} — terminal,\n *     because the same request will produce the same body.\n *   - `retry` (429 / 529) → a TRANSIENT {@link JevAskErr}. `fail` feeds it to\n *     resilient-call's backoff, so the call waits and re-issues.\n *   - `terminal` (401 / 422 / anything else non-2xx) → a terminal\n *     {@link JevAskErr}. `fail` settles it through `settleFailed`: the call\n *     ends now, the breaker is not tripped and the port is NOT called again.\n *\n * ## Typical wiring\n *\n *   const ask = createJevAsk({\n *     questions,                        // the map; its keys type the answers\n *     port: fetchJevPort(apiKey),       // or omit it and configure `fallback`\n *     fallback: (req) => offlineGuess(req),\n *     retry: defaultRetryPolicy,\n *   });\n *\n *   // in the machine:\n *   init: () => [{ resilience: ask.init() }, []],\n *   update: {\n *     ask_jev: (s, m) => liftJevAsk(s, ask.attempt(s.resilience, m.key, m.state, m.at)),\n *     // `resilient_ok` / `resilient_err` RE-ENTER from `handlers` (the settle\n *     // Msg the interpret handler returns). Run the inherited verb FIRST so the\n *     // backoff loop advances, THEN fold `m.result` / `m.error` into the host's\n *     // own state — the enrichment belongs in the reducer arm, not the handler.\n *     resilient_ok: (s, m) => {\n *       const [slice, cmds] = ask.succeed(s.resilience, m.key, m);\n *       return [{ ...s, resilience: slice, answers: m.result.answers }, cmds];\n *     },\n *     resilient_err: (s, m) => {\n *       const [slice, cmds] = ask.fail(s.resilience, m.key, m);\n *       return [{ ...s, resilience: slice, failure: m.error }, cmds];\n *     },\n *     deadline_exceeded: (s, m) => liftJevAsk(s, ask.onTimer(s.resilience, m)),\n *   },\n *   subscriptions: (s) => ask.subs(s.resilience),\n *   subscribe: { deadline: subscribeDeadline },\n *   interpret: ask.handlers(),\n */\n\nimport { describeError } from \"../../../describe-error\";\nimport type { Cmd } from \"../../../index\";\nimport { MsgType } from \"../../../protocol\";\nimport type { RetryPolicy } from \"../../../retry-backoff\";\nimport {\n  createResilientCall,\n  type DeadlineExceeded,\n  type DeadlineSub,\n  deadlineSub,\n  type FailMsg,\n  liftResilience,\n  type ResilientConfig,\n  type ResilientState,\n  type RunCmd,\n  runCmdDef,\n  type SucceedMsg,\n  subscribeDeadline,\n} from \"../../resilience/resilient-call\";\nimport {\n  classifyStatus,\n  isJevErr,\n  type JevAnswers,\n  type JevErr,\n  type JevQuestionMap,\n  type JevRequest,\n  type JevState,\n  type JevUsage,\n  parseAnswers,\n} from \"../protocol\";\n\n// ===========================================================================\n// The DI ports.\n// ===========================================================================\n\n/**\n * The injected HTTP caller — the one seam that touches the network.\n *\n * It returns the status and the undecoded body rather than throwing on a\n * non-2xx, because WHICH non-2xx it is decides whether the call backs off, and\n * a thrown adapter error has already lost that. `signal` is optional so a\n * `fetch` adapter can be cancelled; resilient-call issues no signal today, and\n * the slot exists so an adapter's own shape does not have to change when it\n * does.\n *\n * A `fetch` adapter and a scripted test fake satisfy this identically, which is\n * the whole reason the key lives in the adapter's closure and never in config.\n */\nexport type JevPort<Q extends JevQuestionMap = JevQuestionMap> = (\n  request: JevRequest<Q>,\n  signal?: AbortSignal,\n) => Promise<{ readonly status: number; readonly body: unknown }>;\n\n/**\n * The pure decider that answers when the network cannot.\n *\n * Called on exactly two paths: `port` is absent (the no-key case), and the\n * resilient retry budget is spent. It must be a pure function of the request —\n * the exhaustion path runs it inside the `fail` VERB, which replay re-runs, so\n * a clock read or an I/O call here would make the machine unreplayable.\n * Returning a {@link JevErr} is how a fallback says \"I have no answer for\n * this one\"; the call then settles as that error.\n */\nexport type JevFallback<Q extends JevQuestionMap> = (\n  request: JevRequest<Q>,\n) => JevAnswers<Q> | JevErr;\n\n// ===========================================================================\n// Failures — the protocol's, plus the three this door adds.\n// ===========================================================================\n\n/**\n * Every way an ask can fail, as DATA.\n *\n * A superset of the protocol child's {@link JevErr}: a parse failure is\n * reported with the protocol's own tag untouched, and the three tags below are\n * the ones only a caller can observe. `{_tag}`-discriminated and\n * JSON-round-trippable like the rest (ADR 0011), because it is carried on the\n * settle Msg and stored in the slice's `failed` phase.\n *\n * `http_retry` and `port_threw` are the TRANSIENT pair — {@link isTransientJevAskErr}\n * is the single reading, and `fail` backs off on exactly those two.\n */\nexport type JevAskErr =\n  | JevErr\n  /** 429 / 529 — the statuses `classifyStatus` says to back off on. */\n  | { readonly _tag: \"http_retry\"; readonly status: number }\n  /** 401 / 422 / any other non-2xx — this request fails identically forever. */\n  | { readonly _tag: \"http_terminal\"; readonly status: number }\n  /** The port itself rejected (a socket error, a DNS failure) — transient. */\n  | { readonly _tag: \"port_threw\"; readonly reason: string }\n  /** No `port` and no `fallback`: the knob was configured with no way to answer. */\n  | { readonly _tag: \"no_answer_path\" };\n\n/**\n * Does this failure deserve another attempt?\n *\n * The one place the transient/terminal split is read. A rate limit and a dropped\n * socket are the two failures a second attempt can clear; a 401, a 422 and every\n * parse failure will reproduce exactly, so retrying one spends a real HTTP call\n * to learn nothing.\n */\nexport function isTransientJevAskErr(error: JevAskErr): boolean {\n  return error._tag === \"http_retry\" || error._tag === \"port_threw\";\n}\n\n/**\n * The carrier that gets a {@link JevAskErr} out of the port and through\n * resilient-call's throw seam intact.\n *\n * resilient-call routes a rejected port to a failure Msg carrying the raw\n * thrown value, so throwing is the only way the handler can say \"this attempt\n * failed\" — and a bare `Error` would arrive with its classification already\n * lost. The typed payload rides on `jev`; the slice never stores this object\n * (the verbs store `jev` itself), so nothing un-serializable reaches Model.\n */\nexport class JevAskFailure extends Error {\n  constructor(readonly jev: JevAskErr) {\n    super(`jev ask: ${jev._tag}`);\n    this.name = \"JevAskFailure\";\n  }\n}\n\n/** Read any thrown value back as a {@link JevAskErr}. A foreign throw is transient. */\nfunction toAskErr(error: unknown): JevAskErr {\n  if (error instanceof JevAskFailure) return error.jev;\n  return { _tag: \"port_threw\", reason: describeError(error) };\n}\n\n// ===========================================================================\n// Config, request and result.\n// ===========================================================================\n\n/** The model the door asks for when config names none. */\nexport const DEFAULT_JEV_MODEL = \"jev-latest\";\n\n/** No tokens were spent — what a fallback answer's usage is. */\nconst NO_USAGE: JevUsage = { input_tokens: 0, output_tokens: 0 };\n\n/**\n * The jev-ask knob. `questions` is the load-bearing one: it is both the map\n * sent on every request and the type that makes the answers narrow at the call\n * site, so it belongs to the knob rather than to a call.\n */\nexport interface JevAskConfig<Q extends JevQuestionMap> {\n  /** The question map every request carries; its keys type the answers. */\n  readonly questions: Q;\n  /** DI port — the HTTP caller. Absent = the no-key case; `fallback` answers instead. */\n  readonly port?: JevPort<Q>;\n  /** The pure decider for the no-port and budget-spent paths. Absent → those settle as an error. */\n  readonly fallback?: JevFallback<Q>;\n  /** Backoff policy, composed into `../../resilience/resilient-call`. Omit → no backoff. */\n  readonly retry?: RetryPolicy;\n  /** The model id asked for. Defaults to {@link DEFAULT_JEV_MODEL}. */\n  readonly model?: string;\n}\n\n/**\n * The settled answer carried on `resilient_ok`.\n *\n * `source` is not decoration: a fallback answer and a model answer are both\n * valid answers with identical shape, and a host that routes on confidence — or\n * bills on usage — has to be able to tell them apart. A fallback's `usage` is\n * zero because nothing was spent.\n */\nexport interface JevOk<Q extends JevQuestionMap> {\n  /** The typed answers, one per question id. */\n  readonly answers: JevAnswers<Q>;\n  /** The model that answered, as the response reported it (or the requested one, for a fallback). */\n  readonly model: string;\n  /** Tokens spent. Zero on the fallback path. */\n  readonly usage: JevUsage;\n  /** Which path produced this answer. */\n  readonly source: \"port\" | \"fallback\";\n}\n\n// ===========================================================================\n// The Cmd + Msgs the knob speaks.\n// ===========================================================================\n\n/**\n * The one effect this knob emits: run the ask for `key` with the plain-data\n * {@link JevRequest} (ADR 0014 — a Cmd is DECLARED, so its input, ok and err\n * channels are types on the constructor rather than a convention). It is\n * resilient-call's `runCmdDef` specialized to this door's input and result, the\n * same way `../../idempotency/idempotent-intake` mints its defs per knob: `Q` is\n * a type parameter, so the def is a factory and not a module constant.\n */\nexport function jevAskCmdDef<Q extends JevQuestionMap>() {\n  return runCmdDef<JevRequest<Q>, JevOk<Q>>();\n}\n\n/** The Cmd the verbs emit — `resilient_run` carrying the request. */\nexport type JevAskCmd<Q extends JevQuestionMap> = RunCmd<JevRequest<Q>>;\n\n/** The success settle Msg — resilient-call's, with `result` narrowed to {@link JevOk}. */\nexport type JevSucceedMsg<Q extends JevQuestionMap> = SucceedMsg<JevOk<Q>>;\n\n/** The failure settle Msg — resilient-call's, with `error` narrowed to {@link JevAskErr}. */\nexport type JevFailMsg = Omit<FailMsg, \"error\"> & {\n  readonly error: JevAskErr;\n};\n\n/** The retry / deadline timer Msg — `DeadlineExceeded`, inherited. */\nexport type JevTimerMsg = DeadlineExceeded;\n\n// ===========================================================================\n// The knob factory.\n// ===========================================================================\n\n/**\n * Build a jev-ask knob from `config`. `rng` is injected for the inherited retry\n * jitter (pass a fixed `() => 0` in tests to pin backoff; defaults to\n * `Math.random`, read only at resilient-call's verb boundary).\n *\n * The slice and five of the six verbs are resilient-call's, forwarded. `fail` is\n * the one composed verb — it reads the {@link JevAskErr} the handler typed and\n * routes on it (see its docblock); it reimplements no backoff. `handlers` is the\n * new piece: the port call, the status classification, the parse, and the\n * enriched settle Msg.\n */\nexport function createJevAsk<Q extends JevQuestionMap>(\n  config: JevAskConfig<Q>,\n  rng: () => number = Math.random,\n) {\n  const resilientConfig: ResilientConfig = {\n    ...(config.retry === undefined ? {} : { retry: config.retry }),\n  };\n  const rc = createResilientCall<JevRequest<Q>, JevOk<Q>>(resilientConfig, rng);\n  const model = config.model ?? DEFAULT_JEV_MODEL;\n\n  /** The slice this knob owns — resilient-call's slice verbatim. */\n  type State = ResilientState<JevRequest<Q>, JevOk<Q>>;\n\n  /**\n   * A fallback's answer or its refusal.\n   *\n   * The discriminant is the protocol child's own {@link isJevErr} — the `_tag`\n   * VALUE read against the closed `JevErr` tag set. Testing for the KEY instead\n   * reads a caller's question ids as a discriminant they never agreed to: a\n   * question legally named `_tag` makes `\"_tag\" in decided` true on a perfectly\n   * good answers map, and the successful fallback then settles as a refusal\n   * carrying the answers map as its error. An answer is always an object and\n   * never one of those five tag literals, so the value test cannot collide.\n   */\n  function isErrDecision(decided: JevAnswers<Q> | JevErr): decided is JevErr {\n    return isJevErr(decided);\n  }\n\n  /** The request a call under `key` is live with, or `undefined` if it is not live. */\n  function liveRequest(s: State, key: string): JevRequest<Q> | undefined {\n    const call = s.calls[key];\n    if (call?.phase === \"running\" || call?.phase === \"waiting_retry\") {\n      return call.input;\n    }\n    return undefined;\n  }\n\n  /** The starting slice — resilient-call's. */\n  function init(): State {\n    return rc.init();\n  }\n\n  /**\n   * Ask the configured questions about `content` under `key`. PURE — it builds\n   * the plain-data request (no closures: `state`, `model` and `questions` are\n   * all values) and delegates straight to resilient-call's gate.\n   */\n  function attempt(\n    s: State,\n    key: string,\n    content: JevState,\n    at: number,\n  ): readonly [State, readonly JevAskCmd<Q>[]] {\n    const request: JevRequest<Q> = {\n      state: content,\n      model,\n      questions: config.questions,\n    };\n    return rc.attempt(s, key, request, at);\n  }\n\n  /** Record a settled answer for `key`. PURE — resilient-call's `succeed`. */\n  function succeed(\n    s: State,\n    key: string,\n    msg: JevSucceedMsg<Q>,\n  ): readonly [State, readonly JevAskCmd<Q>[]] {\n    return rc.succeed(s, key, msg);\n  }\n\n  /**\n   * Settle `key` from the fallback, as if the fallback's answer were the\n   * response. PURE — the fallback is a pure decider, and `succeed` / `settleFailed`\n   * are resilient-call's own settle verbs. `s` is the state BEFORE the failing\n   * attempt was recorded, so the call is still live and `succeed` closes it\n   * normally.\n   */\n  function settleFromFallback(\n    s: State,\n    key: string,\n    request: JevRequest<Q>,\n    fallback: JevFallback<Q>,\n    at: number,\n  ): readonly [State, readonly JevAskCmd<Q>[]] {\n    const decided = fallback(request);\n    if (isErrDecision(decided)) return rc.settleFailed(s, key, decided);\n    return rc.succeed(s, key, {\n      type: MsgType.ResilientOk,\n      key,\n      result: {\n        answers: decided,\n        model: request.model,\n        usage: NO_USAGE,\n        source: \"fallback\",\n      },\n      at,\n    });\n  }\n\n  /**\n   * Record a failure for `key`. PURE. The backoff itself is resilient-call's —\n   * nothing here recomputes a delay, counts an attempt or reads a clock. What\n   * this verb adds is the routing the typed error makes possible, and it is two\n   * decisions:\n   *\n   *   1. A TERMINAL error settles through `settleFailed`, which ends the call\n   *      without touching the breaker or the retry counter. Handing a 401 or a\n   *      parse failure to `fail` instead would re-issue the identical request\n   *      and trip a breaker over a backend that is perfectly healthy.\n   *   2. When the transient path EXHAUSTS the retry budget and a `fallback` is\n   *      configured, the fallback answers instead of the call settling failed.\n   *      This is the one place that can be observed — exhaustion is a fact of\n   *      the slice, not of the handler, so the handler cannot know it is on the\n   *      last attempt.\n   */\n  function fail(\n    s: State,\n    key: string,\n    msg: JevFailMsg,\n  ): readonly [State, readonly JevAskCmd<Q>[]] {\n    if (!isTransientJevAskErr(msg.error)) {\n      return rc.settleFailed(s, key, msg.error);\n    }\n    const request = liveRequest(s, key);\n    const settled = rc.fail(s, key, msg);\n    const backedOff = settled[0].calls[key]?.phase !== \"failed\";\n    if (backedOff || config.fallback === undefined || request === undefined) {\n      return settled;\n    }\n    return settleFromFallback(s, key, request, config.fallback, msg.at);\n  }\n\n  /** A retry / deadline timer fired. PURE — resilient-call's `onTimer`. */\n  function onTimer(\n    s: State,\n    msg: JevTimerMsg,\n  ): readonly [State, readonly JevAskCmd<Q>[]] {\n    return rc.onTimer(s, msg);\n  }\n\n  /** Pre-wired subs — resilient-call's retry-timer subscriptions. */\n  function subs(s: State): readonly DeadlineSub[] {\n    return rc.subs(s);\n  }\n\n  // ---- The port the resilient handler drives -----------------------------\n\n  /**\n   * Run ONE ask: call the port, classify the status, parse the body against the\n   * questions that produced it. Resolves to the typed {@link JevOk}; throws a\n   * {@link JevAskFailure} on every failure, because throwing is how\n   * resilient-call is told an attempt failed. `fail` reads the carried\n   * {@link JevAskErr} back and decides whether the throw was worth retrying.\n   *\n   * With no `port` this is the fallback's whole story: no HTTP call is made, and\n   * with no fallback either the knob says so as `no_answer_path` rather than\n   * pretending a network failure.\n   */\n  async function ask(\n    request: JevRequest<Q>,\n    signal?: AbortSignal,\n  ): Promise<JevOk<Q>> {\n    if (config.port === undefined) {\n      if (config.fallback === undefined) {\n        throw new JevAskFailure({ _tag: \"no_answer_path\" });\n      }\n      const decided = config.fallback(request);\n      if (isErrDecision(decided)) throw new JevAskFailure(decided);\n      return {\n        answers: decided,\n        model: request.model,\n        usage: NO_USAGE,\n        source: \"fallback\",\n      };\n    }\n\n    const { status, body } = await config.port(request, signal);\n    const kind = classifyStatus(status);\n    if (kind === \"retry\")\n      throw new JevAskFailure({ _tag: \"http_retry\", status });\n    if (kind === \"terminal\") {\n      throw new JevAskFailure({ _tag: \"http_terminal\", status });\n    }\n\n    const parsed = parseAnswers(config.questions, body);\n    if (!parsed.ok) throw new JevAskFailure(parsed.error);\n    return {\n      answers: parsed.answers,\n      model: parsed.model,\n      usage: parsed.usage,\n      source: \"port\",\n    };\n  }\n\n  // ---- Handlers ----------------------------------------------------------\n\n  // resilient-call's `resilient_run` handler over `ask` — the shared\n  // Railway-routed invoke (Ok → `resilient_ok`, Err → `resilient_err`), stamped\n  // with the one `Date.now()` this module makes, at the effect boundary.\n  const resilientRunHandler = rc.handlers({\n    run: (request) => ask(request),\n  }).resilient_run;\n\n  /**\n   * Await one invoke and resolve to the ENRICHED settle Msg. The success Msg is\n   * resilient-call's as-is (`ask` already returns the typed {@link JevOk}); the\n   * failure Msg is its `error: unknown` read back as the typed\n   * {@link JevAskErr}, so the host reducer — and `fail` — route on a tag rather\n   * than on a stringified throw.\n   */\n  async function settleOf(\n    cmd: JevAskCmd<Q>,\n  ): Promise<JevSucceedMsg<Q> | JevFailMsg> {\n    const settle = await resilientRunHandler(cmd, {});\n    if (settle.type === MsgType.ResilientOk) return settle;\n    return {\n      type: MsgType.ResilientErr,\n      key: settle.key,\n      error: toAskErr(settle.error),\n      at: settle.at,\n    };\n  }\n\n  /**\n   * Pre-wired interpret handler for `resilient_run`. It RETURNS the settle Msg\n   * rather than dispatching one: the substrate enqueues an interpret handler's\n   * returned Msg as a follow-up onto the dispatch tail, so the host's\n   * `resilient_ok` / `resilient_err` arms run `succeed` / `fail` and the\n   * inherited backoff loop advances. A handler that dispatched instead would\n   * settle one invoke and leave the slice wedged at `running`.\n   */\n  function handlers(): {\n    resilient_run: (\n      cmd: JevAskCmd<Q>,\n    ) => Promise<JevSucceedMsg<Q> | JevFailMsg>;\n  } {\n    return { resilient_run: (cmd: JevAskCmd<Q>) => settleOf(cmd) };\n  }\n\n  return { init, attempt, succeed, fail, onTimer, subs, handlers, ask };\n}\n\n/**\n * The Cmd type a host machine declares in `types.cmd` when it splices a\n * {@link createJevAsk} knob in — {@link JevAskCmd} under the name a `types`\n * block reads well with. It is stated here so a host writes `cmd: {} as\n * JevCmd<Questions>` rather than deriving it from the knob's shape, which is\n * what `ReturnType<Ask[\"attempt\"]>[1][number]` used to be doing at every call\n * site: a spelling of the same type that breaks the moment `attempt`'s tuple\n * changes, and that reads as machinery rather than as a name.\n */\nexport type JevCmd<Q extends JevQuestionMap> = JevAskCmd<Q>;\n\n/**\n * The Sub type a host machine declares in `types.sub` — the deadline Sub\n * `subs` emits, inherited from resilient-call. Named here for the same reason\n * as {@link JevCmd}: a host names the type, it does not re-derive it.\n */\nexport type JevSub = DeadlineSub;\n\n/**\n * Lift a knob result `[slice, cmds]` into a host `[State, cmds]` where the slice\n * lives at `state.resilience` — resilient-call's convenience, re-typed for this\n * door's slice so a consumer wires one import. Pure.\n */\nexport function liftJevAsk<\n  S extends { resilience: ResilientState<JevRequest<Q>, JevOk<Q>> },\n  Q extends JevQuestionMap,\n  C extends Cmd,\n>(\n  state: S,\n  result: readonly [ResilientState<JevRequest<Q>, JevOk<Q>>, readonly C[]],\n): readonly [S, readonly C[]] {\n  return liftResilience(state, result);\n}\n\n/**\n * Re-export the deadline Sub primitives (inherited from resilient-call) so a\n * consumer wires one import: `subscribeDeadline` is the `subscribe` cell,\n * `deadlineSub` builds the Sub literal `subs` emits.\n */\nexport { subscribeDeadline, deadlineSub };\nexport type { DeadlineSub, DeadlineExceeded, ResilientState };\n","/**\n * @packageDocumentation\n * internal/jev/classify-batch — the composition that turns a stream of items\n * into Jev calls. Internal since #218 — not published on any subpath.\n *\n * It writes NO chunker, NO cache, NO concurrency limiter and NO retry. Every\n * one of those already exists as a battery, and this module is the wiring:\n *\n *   - `../../flow/batch-window` coalesces `add(item, at)` calls into size- or\n *     time-bounded batches (`maxItems`, `maxMs`).\n *   - `../../flow/fan-out` bounds how many batches are in flight\n *     (`concurrency`), keyed by a batch id that is a pure function of the\n *     batch's item keys.\n *   - `../../resilience/cache` is the TTL cache keyed by `keyOf(item)`. An item\n *     whose key is cached never enters a batch; every settled answer is written\n *     back with `ttlMs`.\n *   - `../ask` is the one effect: each flushed batch becomes one `resilient_run`\n *     Cmd carrying Jev's NATIVE batch form (grill #215, R1.2) — the item array\n *     IS the request `state`, and `questions` holds one `choice` question per\n *     item, keyed by `keyOf(item)`. There is no `{ transactions }` envelope of\n *     any kind.\n *\n * ## The slice is plain data, and time arrives as `at`\n *\n * {@link ClassifyBatchState} is the three batteries' own slices plus a failure\n * map, so it survives a `Store` rehydrate unchanged. Every transition is a Msg\n * through the verbs (`add`, `onWindow`, `onBatchOk`, `onBatchErr`, `onEvict`);\n * no verb reads a clock, and the one `Date.now()` on the path is the one\n * `../ask`'s interpret handler already stamps at the effect boundary.\n *\n * ## What this module deliberately does not decide\n *\n * `answerFor` is a derived READ. It reports `answered` / `failed` / `pending` /\n * `absent` and hands back the choice answer with its own `confidence`; whether\n * a given confidence auto-assigns or goes to triage is the HOST reducer's rule,\n * and putting a threshold here would make one caller's policy everybody's.\n *\n * ## Typical wiring\n *\n *   const classify = createClassifyBatch({\n *     keyOf: (t) => sanitizedMerchant(t),\n *     criteria: { groceries: \"Supermarkets\", dining: \"Restaurants\" },\n *     maxItems: 25,\n *     maxMs: 2_000,\n *     concurrency: 4,\n *     ttlMs: 86_400_000,\n *     port: fetchJevPort(apiKey),\n *   });\n *\n *   update: {\n *     classify_add: (s, m) => lift(s, classify.add(s.classify, m.item, m.at)),\n *     deadline_exceeded: (s, m) => lift(s, classify.onWindow(s.classify, m.atMs)),\n *     resilient_ok: (s, m) => lift(s, classify.onBatchOk(s.classify, m)),\n *     resilient_err: (s, m) => lift(s, classify.onBatchErr(s.classify, m)),\n *     cache_evict: (s, m) => lift(s, classify.onEvict(s.classify, nowFromMsg)),\n *   },\n *   subscriptions: (s) => classify.subs(s.classify),\n *   subscribe: classify.subscribers(),\n *   interpret: classify.handlers(),\n */\n\nimport type { Cmd } from \"../../../index\";\nimport {\n  type BatchWindow,\n  type BatchWindowSub,\n  createBatchWindow,\n  subscribeBatchWindow,\n} from \"../../flow/batch-window\";\nimport { createFanOut, type FanOutState } from \"../../flow/fan-out\";\nimport {\n  type CacheEvictionSub,\n  cacheEvictionSub,\n  cacheEvictionSubscribe,\n  get as cacheGet,\n  has as cacheHas,\n  set as cacheSet,\n  evictExpired,\n  initCache,\n  type TtlCache,\n} from \"../../resilience/cache\";\nimport {\n  createJevAsk,\n  DEFAULT_JEV_MODEL,\n  type JevAskCmd,\n  type JevAskErr,\n  type JevFailMsg,\n  type JevFallback,\n  type JevOk,\n  type JevPort,\n  type JevSucceedMsg,\n  jevAskCmdDef,\n} from \"../ask\";\nimport type {\n  JevAnswerFor,\n  JevChoiceQuestion,\n  JevRequest,\n  JevText,\n} from \"../protocol\";\n\n// ===========================================================================\n// The question shape one item gets.\n// ===========================================================================\n\n/**\n * The rubric every item is classified against: option key → description, or\n * `null` where an option needs no extra detail. `C` is the option union, and it\n * is what makes an answer's `choice` narrow at the call site.\n */\nexport type ClassifyCriteria<C extends string> = Readonly<\n  Record<C, JevText | null>\n>;\n\n/** The one `choice` question an item is asked. */\nexport type ItemQuestion<C extends string> = JevChoiceQuestion<\n  ClassifyCriteria<C>\n>;\n\n/**\n * The `questions` map of one batch: one {@link ItemQuestion} per item, keyed by\n * `keyOf(item)`. This IS Jev's native batch form — the questions map is the\n * fan-out over items, so nothing here wraps the items in an envelope of its own.\n */\nexport type ItemQuestions<C extends string> = Readonly<\n  Record<string, ItemQuestion<C>>\n>;\n\n/** The answer one item's question yields. */\nexport type ItemAnswer<C extends string> = JevAnswerFor<ItemQuestion<C>>;\n\n// ===========================================================================\n// Batches, Cmds and Msgs.\n// ===========================================================================\n\n/**\n * One flushed batch, as plain data: the items and the id fan-out addresses it\n * by. `id` is a pure function of the batch's item keys (they are joined with a\n * separator no sanitized key contains), which is what lets a settle Msg — whose\n * `key` is that id — find its batch again after a rehydrate.\n */\nexport interface Batch<I> {\n  readonly id: string;\n  readonly items: readonly I[];\n}\n\n/** The Cmd a flushed batch becomes — `../ask`'s, carrying the native request. */\nexport type ClassifyBatchCmd<C extends string> = JevAskCmd<ItemQuestions<C>>;\n\n/** The success settle Msg — `../ask`'s, with the batch's answers. */\nexport type ClassifyBatchOkMsg<C extends string> = JevSucceedMsg<\n  ItemQuestions<C>\n>;\n\n/** The failure settle Msg — `../ask`'s, with the typed {@link JevAskErr}. */\nexport type ClassifyBatchErrMsg = JevFailMsg;\n\n/**\n * The internal Cmd the batch window flushes into. It never leaves this module:\n * `add` and `onWindow` intercept it and hand the items to fan-out, which is\n * what bounds how many batches are in flight. Letting the window emit the ask\n * Cmd directly would flush straight past `concurrency`.\n */\ntype FlushCmd<I> = Cmd<\"classify_batch_flush\"> & {\n  readonly items: readonly I[];\n};\n\n// ===========================================================================\n// Config and slice.\n// ===========================================================================\n\n/** The default page size — the one the grill settled on for Jev. */\nexport const DEFAULT_CLASSIFY_MAX_ITEMS = 25;\n\n/** The knob. Every field is a policy this module refuses to invent. */\nexport interface ClassifyBatchConfig<I, C extends string> {\n  /**\n   * The cache key and the question id of an item — e.g. a sanitized merchant\n   * string, so two transactions at the same shop share one answer. PURE.\n   */\n  readonly keyOf: (item: I) => string;\n  /** The rubric every item is classified against. Its keys are the answer domain. */\n  readonly criteria: ClassifyCriteria<C>;\n  /**\n   * The `instructions` for one item's question. Defaults to a template naming\n   * the item's key, which is what tells the model WHICH element of the request\n   * `state` the question is about.\n   */\n  readonly instructions?: (key: string, item: I) => JevText;\n  /** Size trigger, forwarded to the batch window. Defaults to {@link DEFAULT_CLASSIFY_MAX_ITEMS}. */\n  readonly maxItems?: number;\n  /** Latency ceiling in ms, forwarded to the batch window. */\n  readonly maxMs: number;\n  /** Max batches in flight, forwarded to fan-out. */\n  readonly concurrency: number;\n  /** How long a settled answer stays cached, forwarded to the TTL cache. */\n  readonly ttlMs: number;\n  /** Eviction tick for the TTL cache. Omit and no eviction Sub is declared. */\n  readonly evictEveryMs?: number;\n  /** The model asked for. Forwarded to `../ask`'s default when omitted. */\n  readonly model?: string;\n  /** DI port — the HTTP caller. Forwarded to `../ask`; absent is the no-key case. */\n  readonly port?: JevPort<ItemQuestions<C>>;\n  /** The pure decider for the no-port path. Forwarded to `../ask`. */\n  readonly fallback?: JevFallback<ItemQuestions<C>>;\n}\n\n/**\n * The slice: the three batteries' own slices, plus the one fact none of them\n * holds — which keys a failed batch left unanswered. All plain data.\n */\nexport interface ClassifyBatchState<I, C extends string> {\n  /** The open batch window — `../../flow/batch-window`'s slice. */\n  readonly window: BatchWindow<I>;\n  /** The in-flight batches — `../../flow/fan-out`'s slice. */\n  readonly fanOut: FanOutState<Batch<I>, JevOk<ItemQuestions<C>>>;\n  /** The answers, keyed by `keyOf` — `../../resilience/cache`'s slice. */\n  readonly cache: TtlCache<ItemAnswer<C>>;\n  /** Keys whose batch settled `resilient_err`, with the error that settled it. */\n  readonly failed: Readonly<Record<string, JevAskErr>>;\n}\n\n/** What {@link ClassifyBatchKnob.answerFor} reports about one key. */\nexport type KeyAnswer<C extends string> =\n  /** Answered and unexpired: the host applies its own confidence rule to this. */\n  | { readonly status: \"answered\"; readonly answer: ItemAnswer<C> }\n  /** The batch carrying this key settled `resilient_err`. Nothing was cached. */\n  | { readonly status: \"failed\"; readonly error: JevAskErr }\n  /** Buffered in the open window, or in a batch that has not settled. */\n  | { readonly status: \"pending\" }\n  /** Never seen, or cached and now expired. */\n  | { readonly status: \"absent\" };\n\n// ===========================================================================\n// The knob factory.\n// ===========================================================================\n\n/**\n * Build a classify-batch knob from `config`.\n *\n * The verbs are pure and the whole composition is the four batteries'; the only\n * thing this factory adds is the native-batch request shape and the bookkeeping\n * that keeps one key out of two batches at once.\n */\nexport function createClassifyBatch<I, C extends string>(\n  config: ClassifyBatchConfig<I, C>,\n) {\n  type State = ClassifyBatchState<I, C>;\n  type AskOk = JevOk<ItemQuestions<C>>;\n  type Cmds = readonly ClassifyBatchCmd<C>[];\n\n  const maxItems = config.maxItems ?? DEFAULT_CLASSIFY_MAX_ITEMS;\n  const askCmd = jevAskCmdDef<ItemQuestions<C>>();\n  const instructionsFor =\n    config.instructions ??\n    ((key: string): JevText =>\n      `Classify the element of \\`state\\` whose key is \"${key}\".`);\n\n  /** The batch's identity: its item keys, in arrival order. PURE. */\n  function idOfBatch(batch: Batch<I>): string {\n    return batch.id;\n  }\n\n  /** One batch's `questions` map — one choice question per item, keyed by `keyOf`. */\n  function questionsFor(items: readonly I[]): ItemQuestions<C> {\n    const questions: Record<string, ItemQuestion<C>> = {};\n    for (const item of items) {\n      const key = config.keyOf(item);\n      questions[key] = {\n        type: \"choice\",\n        instructions: instructionsFor(key, item),\n        criteria: config.criteria,\n      };\n    }\n    return questions;\n  }\n\n  /**\n   * The native Jev request for a batch: the item array IS the `state`, and the\n   * questions map is the per-item fan-out. No envelope.\n   */\n  function requestFor(batch: Batch<I>): JevRequest<ItemQuestions<C>> {\n    return {\n      state: batch.items,\n      model: config.model ?? DEFAULT_JEV_MODEL,\n      questions: questionsFor(batch.items),\n    };\n  }\n\n  const fanOut = createFanOut<\n    Batch<I>,\n    AskOk,\n    ClassifyBatchCmd<C>,\n    ClassifyBatchCmd<C>\n  >({\n    concurrency: config.concurrency,\n    idOf: idOfBatch,\n    of: (batch) => askCmd({ key: batch.id, input: requestFor(batch) }),\n  });\n\n  const window = createBatchWindow<I, FlushCmd<I>>({\n    maxItems,\n    maxMs: config.maxMs,\n    flush: (items) => ({ type: \"classify_batch_flush\", items }),\n  });\n\n  /** The starting slice — each battery's own `init`, side by side. */\n  function init(): State {\n    return {\n      window: window.init(),\n      fanOut: fanOut.init(),\n      cache: initCache<ItemAnswer<C>>(),\n      failed: {},\n    };\n  }\n\n  /** Every key currently buffered or in flight. PURE. */\n  function keysInFlight(state: State): ReadonlySet<string> {\n    const keys = new Set<string>();\n    for (const item of state.window.buffer) keys.add(config.keyOf(item));\n    for (const batch of state.fanOut.pending) {\n      for (const item of batch.items) keys.add(config.keyOf(item));\n    }\n    for (const batch of state.fanOut.running) {\n      for (const item of batch.items) keys.add(config.keyOf(item));\n    }\n    return keys;\n  }\n\n  /** The running batch a settle Msg's `key` addresses, or `undefined`. PURE. */\n  function runningBatch(state: State, id: string): Batch<I> | undefined {\n    return state.fanOut.running.find((batch) => batch.id === id);\n  }\n\n  /**\n   * Hand a flushed window's items to fan-out. Fan-out returns the launch Cmds —\n   * at most `concurrency` of them — so a window that flushes while the budget is\n   * spent parks its batch in `pending` and launches nothing.\n   */\n  function scatter(\n    state: State,\n    flushed: readonly FlushCmd<I>[],\n  ): readonly [State, Cmds] {\n    if (flushed.length === 0) return [state, []];\n    const batches = flushed.map((cmd) => ({\n      id: cmd.items.map(config.keyOf).join(\"\\u0000\"),\n      items: cmd.items,\n    }));\n    const [next, cmds] = fanOut.scatter(state.fanOut, batches);\n    return [{ ...state, fanOut: next }, cmds];\n  }\n\n  /**\n   * Offer `item` to the pipeline at `at`. PURE.\n   *\n   * An item whose key is cached, buffered, or already in a batch is DROPPED:\n   * the cache hit is the whole point of the cache, and the other two are what\n   * keeps one key out of two batches at once — which is the property that makes\n   * a batch's id a usable identity and an answer's key unambiguous.\n   *\n   * An item that is NOT dropped loses its standing failure mark, exactly as\n   * {@link onBatchOk} clears one: from the instant the key is buffered it is in\n   * flight again, and a `failed` entry left standing would make `answerFor`\n   * report the PREVIOUS attempt's error for the whole of the new one — telling a\n   * host that polls it to stop waiting for work that is running.\n   */\n  function add(state: State, item: I, at: number): readonly [State, Cmds] {\n    const key = config.keyOf(item);\n    if (cacheHas(state.cache, key, at)) return [state, []];\n    if (keysInFlight(state).has(key)) return [state, []];\n\n    const failed: Record<string, JevAskErr> = { ...state.failed };\n    delete failed[key];\n    const [nextWindow, flushed] = window.add(state.window, item, at);\n    return scatter({ ...state, failed, window: nextWindow }, flushed);\n  }\n\n  /** The time window closed: flush whatever is buffered. PURE. */\n  function onWindow(state: State, at: number): readonly [State, Cmds] {\n    const [nextWindow, flushed] = window.onWindow(state.window, at);\n    return scatter({ ...state, window: nextWindow }, flushed);\n  }\n\n  /**\n   * A batch settled OK. PURE.\n   *\n   * Every answer is written back to the cache with `ttlMs` at `msg.at`, the\n   * batch's keys lose any standing failure mark, and fan-out backfills the freed\n   * concurrency slot — so the returned Cmds are the next batches' asks.\n   *\n   * An answer arrives under the question id it was asked under, which is the\n   * item's own key, so the write-back needs no positional matching between the\n   * request `state` array and the answers map.\n   */\n  function onBatchOk(\n    state: State,\n    msg: ClassifyBatchOkMsg<C>,\n  ): readonly [State, Cmds] {\n    let cache = state.cache;\n    for (const [key, answer] of Object.entries(msg.result.answers)) {\n      cache = cacheSet(cache, key, answer, msg.at, config.ttlMs);\n    }\n    const failed: Record<string, JevAskErr> = { ...state.failed };\n    for (const key of Object.keys(msg.result.answers)) delete failed[key];\n\n    const [nextFanOut, cmds] = fanOut.itemOk(state.fanOut, msg.key, msg.result);\n    return [{ ...state, cache, failed, fanOut: nextFanOut }, cmds];\n  }\n\n  /**\n   * A batch settled `resilient_err`. PURE.\n   *\n   * Each of its keys is marked failed with the error that settled it and the\n   * cache is NOT touched: a failure is not an answer, and writing one back under\n   * `ttlMs` would poison every later `add` for that key for the whole TTL. The\n   * key stays re-addable, because it is neither cached nor in flight once\n   * fan-out has moved the batch to `failed`.\n   */\n  function onBatchErr(\n    state: State,\n    msg: ClassifyBatchErrMsg,\n  ): readonly [State, Cmds] {\n    const batch = runningBatch(state, msg.key);\n    const failed: Record<string, JevAskErr> = { ...state.failed };\n    if (batch !== undefined) {\n      for (const item of batch.items) failed[config.keyOf(item)] = msg.error;\n    }\n    const [nextFanOut, cmds] = fanOut.itemErr(state.fanOut, msg.key, msg.error);\n    return [{ ...state, failed, fanOut: nextFanOut }, cmds];\n  }\n\n  /** The eviction tick fired: drop every entry expired at `at`. PURE. */\n  function onEvict(state: State, at: number): readonly [State, Cmds] {\n    return [{ ...state, cache: evictExpired(state.cache, at) }, []];\n  }\n\n  /**\n   * What is known about `key` at `at`. PURE, derived — it stores nothing.\n   *\n   * `at` is a parameter rather than a clock read because a TTL answer is only\n   * an answer relative to an instant, and this module reads no clock anywhere.\n   * The host passes the `at` of the Msg it is handling.\n   */\n  function answerFor(state: State, key: string, at: number): KeyAnswer<C> {\n    const answer = cacheGet(state.cache, key, at);\n    if (answer !== undefined) return { status: \"answered\", answer };\n    const error = state.failed[key];\n    if (error !== undefined) return { status: \"failed\", error };\n    if (keysInFlight(state).has(key)) return { status: \"pending\" };\n    return { status: \"absent\" };\n  }\n\n  /**\n   * The Subs — the window's flush timer, plus the cache's eviction tick when\n   * `evictEveryMs` is configured. Fan-out declares none (it runs no timers).\n   */\n  function subs(\n    state: State,\n    id = \"jev-classify-batch\",\n  ): readonly (BatchWindowSub | CacheEvictionSub)[] {\n    const windowSubs = window.subs(state.window, id);\n    if (config.evictEveryMs === undefined) return windowSubs;\n    return [...windowSubs, cacheEvictionSub(id, config.evictEveryMs)];\n  }\n\n  /** The `subscribe` cells the Subs above need. */\n  function subscribers() {\n    return { deadline: subscribeBatchWindow, cache: cacheEvictionSubscribe };\n  }\n\n  /**\n   * The interpret handler for the ask Cmd. The port call, the status\n   * classification and the parse are ALL `../ask`'s — this seam only builds the\n   * ask knob around the questions the Cmd is carrying, because a batch's\n   * question map is minted per batch while `createJevAsk` takes one map per\n   * knob. The knob is built at the effect boundary, so nothing impure and\n   * nothing closure-shaped ever reaches the slice.\n   */\n  function handlers(): {\n    resilient_run: (\n      cmd: ClassifyBatchCmd<C>,\n    ) => Promise<ClassifyBatchOkMsg<C> | ClassifyBatchErrMsg>;\n  } {\n    return {\n      resilient_run: (cmd) => {\n        const request = cmd.input as JevRequest<ItemQuestions<C>>;\n        const ask = createJevAsk<ItemQuestions<C>>({\n          questions: request.questions,\n          ...(config.port === undefined ? {} : { port: config.port }),\n          ...(config.fallback === undefined\n            ? {}\n            : { fallback: config.fallback }),\n          ...(config.model === undefined ? {} : { model: config.model }),\n        });\n        return ask.handlers().resilient_run(cmd);\n      },\n    };\n  }\n\n  return {\n    init,\n    add,\n    onWindow,\n    onBatchOk,\n    onBatchErr,\n    onEvict,\n    answerFor,\n    subs,\n    subscribers,\n    handlers,\n  };\n}\n\n/** The bound knob {@link createClassifyBatch} returns. */\nexport type ClassifyBatchKnob<I, C extends string> = ReturnType<\n  typeof createClassifyBatch<I, C>\n>;\n"]}