@contentrain/decide 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,587 @@
+//#region src/types.d.ts
+/** Where a decision came from. `cache` is a provider answer served again. */
+type DecisionSource = 'rule' | 'jev' | 'llm' | 'cache';
+/** Why a decision fell back to the rule instead of a provider answer. */
+type FallbackReason = 'no_provider' | 'budget' | 'circuit_open' | 'timeout' | 'error' | 'no_answer';
+/** One Jev question, as the systemone endpoint takes it. */
+type JevQuestion = {
+  type: 'choice';
+  instructions: string;
+  criteria: Record<string, string>;
+} | {
+  type: 'score';
+  instructions: string;
+  criteria: readonly string[];
+} | {
+  type: 'noul';
+  instructions: string;
+};
+/** One Jev answer, as the systemone endpoint returns it. */
+type JevAnswer = {
+  type: 'choice';
+  choice: string;
+  confidence: number;
+  probabilities?: Record<string, number>;
+} | {
+  type: 'score';
+  score: number;
+  confidence: number;
+  probabilities?: Record<string, number>;
+} | {
+  type: 'noul';
+  noul: number;
+};
+/** What a rule or a provider concluded about one input. */
+interface Outcome {
+  choice?: string;
+  score?: number;
+  /** 0–1. For a kind that asks more than one question, the lowest of them. */
+  confidence: number;
+  probabilities?: Record<string, number>;
+}
+/** A rule's answer. `final` means certain: no provider is asked. */
+interface RuleVerdict extends Outcome {
+  /**
+   * `true` — the rule decides and no provider is asked.
+   * `false` — tentative: the input is in the kind's undecided band. Providers
+   * are asked, and this is the answer when none of them answers.
+   */
+  final: boolean;
+}
+interface TokenCost {
+  input_tokens: number;
+  output_tokens: number;
+  /** Only when a price was configured; the vendor publishes none. */
+  usd?: number;
+}
+interface Decision {
+  kind: string;
+  /** The kind's schema version the decision was made under. */
+  version: string;
+  /** sha256 of kind, version, request shape and canonical shaped input — the cache key, and all the audit log keeps of the input. */
+  key: string;
+  /** Hash of the provider request shape the decision was keyed under (`requestShapeHash`); `none` for a kind with no provider prompt. */
+  shape: string;
+  choice?: string;
+  score?: number;
+  confidence: number;
+  probabilities?: Record<string, number>;
+  source: DecisionSource;
+  /** A provider's choice that fell below the kind's confidence floor; `choice` is then the kind's human-review choice. */
+  proposed?: string;
+  /** Set when the decision is the rule's tentative answer because no provider answered. */
+  unreviewed?: true;
+  fallback?: FallbackReason;
+  /** This decision's share of the batch's usage. Absent for rule and cache answers. */
+  cost?: TokenCost;
+  /** Wall time to reach this decision; for a batched answer, the batch's. */
+  ms: number;
+  /** The provider's model string, when it reported one. */
+  model?: string;
+}
+/**
+ * A kind's Jev request shape. It only ever sees the shaped input. The request a
+ * batch sends is `header(first item)` followed by one `Item <n>: <render>` line
+ * per item, with `questions('item<n>')` asked of every item.
+ *
+ * Everything here is part of what was calibrated. The request-shape hash
+ * (`requestShapeHash`) is taken over a request built from `probe`; it enters
+ * the cache key and the audit log, so a changed shape never reuses an answer.
+ */
+interface JevSpec<S> {
+  /** Text the request's state opens with, from the batch's first item. Absent: none. */
+  header?: (shaped: S) => string;
+  /** Items in different groups never share a request (PoC-1 sent one site per request). */
+  group?: (shaped: S) => string;
+  /** One item's line, after `Item <n>: `. */
+  render: (shaped: S) => string;
+  /** The questions asked of one item. Keys are suffixes: the request asks `<prefix>_<suffix>`. */
+  questions: (prefix: string) => Record<string, JevQuestion>;
+  /** The item's answers (keyed by suffix) as an outcome, or undefined when they do not make one. */
+  read: (answers: Record<string, JevAnswer>) => Outcome | undefined;
+  /** Batch limits of the calibrated shape. They take precedence over the decider's. */
+  batch?: {
+    maxItems?: number;
+    maxTokens?: number;
+  };
+  /** A representative shaped input, used to hash the request shape. */
+  probe: S;
+  /**
+   * The prompt an LLM provider sends for one batch, from the same state and
+   * questions Jev gets (`questions` are item 1's; the provider asks them of
+   * every item). Absent: the provider's generic prompt. Not part of the
+   * request-shape hash: bump the kind's version when it changes.
+   */
+  llmPrompt?: (request: {
+    state: string;
+    questions: Record<string, JevQuestion>;
+    count: number;
+  }) => string;
+}
+interface KindSpec<I = unknown, S = unknown> {
+  kind: string;
+  /** Bump on any change to the shaper, the choices or the prompt: it is part of the cache key. */
+  version: string;
+  /** The closed set a choice must come from. */
+  choices?: readonly string[];
+  /** Inclusive range a score must fall in. */
+  scoreRange?: readonly [number, number];
+  /**
+   * The input shaper. Its result is the only part of the input that leaves the
+   * process or reaches the cache key: plain JSON, nothing a decision does not
+   * need — no full content, no URLs, no identities.
+   */
+  shape: (input: I) => S;
+  /** The deterministic rule, asked first. Undefined: no opinion. */
+  rule?: (input: I) => RuleVerdict | undefined;
+  jev?: JevSpec<S>;
+  /**
+   * Below `threshold` a provider's choice is not trusted: the decision's
+   * `choice` becomes `choice` here and the provider's pick moves to `proposed`.
+   * This choice is never offered to a provider.
+   */
+  lowConfidence?: {
+    threshold: number;
+    choice: string;
+  };
+}
+/** What a provider returns for one batch: an outcome per item, in order. */
+interface ProviderAnswer {
+  outcomes: Array<Outcome | undefined>;
+  usage?: {
+    input_tokens: number;
+    output_tokens: number;
+  };
+  model?: string;
+}
+interface DecisionProvider {
+  readonly name: 'jev' | 'llm';
+  /** Whether the provider can be asked at all (a token is set, a model is wired). */
+  available: () => boolean;
+  /** The model the provider asks, when it names one; part of the request shape. */
+  readonly model?: string;
+  /** Answer one batch. Throws on transport failure; the decider turns that into a fallback. */
+  ask: (spec: KindSpec<any, any>, shaped: unknown[]) => Promise<ProviderAnswer>;
+}
+//#endregion
+//#region src/audit.d.ts
+interface AuditRecord {
+  /** ISO time the decision was made. */
+  at: string;
+  tenant: string;
+  kind: string;
+  version: string;
+  /** The input hash — the same value as the cache key. */
+  key: string;
+  /** The provider request shape the decision was keyed under. */
+  shape: string;
+  choice?: string;
+  score?: number;
+  confidence: number;
+  source: DecisionSource;
+  proposed?: string;
+  unreviewed?: true;
+  fallback?: FallbackReason;
+  ms: number;
+  model?: string;
+  input_tokens?: number;
+  output_tokens?: number;
+  usd?: number;
+}
+interface AuditSink {
+  write: (records: readonly AuditRecord[]) => Promise<void>;
+}
+declare function toAuditRecord(decision: Decision, at: string, tenant: string): AuditRecord;
+declare class MemoryAuditLog implements AuditSink {
+  readonly records: AuditRecord[];
+  write(records: readonly AuditRecord[]): Promise<void>;
+}
+/** Appends to a JSONL file (conventionally `decisions.jsonl`), one line per decision. */
+declare class JsonlAuditLog implements AuditSink {
+  readonly path: string;
+  constructor(path: string);
+  write(records: readonly AuditRecord[]): Promise<void>;
+}
+//#endregion
+//#region src/batch.d.ts
+interface BatchLimits {
+  maxItems?: number;
+  maxTokens?: number;
+}
+declare const DEFAULT_BATCH: Required<BatchLimits>;
+declare const estimateTokens: (text: string) => number;
+/**
+ * Split item costs into consecutive batches. `fixed` is what every request
+ * pays once (the preamble); `costs[i]` what item i adds (its line and its
+ * questions). An item too large for any batch goes alone.
+ */
+declare function planBatches(costs: readonly number[], fixed: number, limits?: BatchLimits): number[][];
+//#endregion
+//#region src/budget.d.ts
+/** How many provider decisions a tenant may spend. */
+interface DecisionBudget {
+  /** Reserve up to `count` decisions for `tenant` at `now`; returns how many were granted. */
+  take: (tenant: string, count: number, now: Date) => Promise<number>;
+}
+/** A per-tenant cap on provider decisions per UTC day, held in memory. */
+declare class MemoryDailyBudget implements DecisionBudget {
+  readonly perDay: number;
+  private readonly spent;
+  constructor(perDay: number);
+  take(tenant: string, count: number, now: Date): Promise<number>;
+  used(tenant: string, now: Date): number;
+}
+interface CircuitBreakerOptions {
+  /** Consecutive failed requests that open the circuit. Default 3. */
+  failures?: number;
+  /** How long it stays open before one request is let through. Default 60s. */
+  cooldownMs?: number;
+  now?: () => number;
+}
+/**
+ * Closed → open after `failures` consecutive failed requests; open → half-open
+ * after `cooldownMs`, where the next request decides: success closes it, a
+ * failure opens it for another cooldown.
+ */
+declare class CircuitBreaker {
+  private consecutive;
+  private openedAt;
+  private readonly limit;
+  private readonly cooldownMs;
+  private readonly now;
+  constructor(options?: CircuitBreakerOptions);
+  get state(): 'closed' | 'open' | 'half_open';
+  /** Whether a request may go out now. */
+  allows(): boolean;
+  success(): void;
+  failure(): void;
+}
+//#endregion
+//#region src/cache.d.ts
+/** What a cache keeps of a decision: the answer, never the input. */
+type CachedDecision = Pick<Decision, 'kind' | 'version' | 'shape' | 'choice' | 'score' | 'confidence' | 'probabilities' | 'proposed' | 'model'> & {
+  source: 'jev' | 'llm'; /** ISO time the provider answered. */
+  at: string;
+};
+interface DecisionCache {
+  get: (key: string) => Promise<CachedDecision | undefined>;
+  set: (key: string, value: CachedDecision) => Promise<void>;
+}
+declare function cacheKey(kind: string, version: string, shape: string, shaped: unknown): string;
+declare class MemoryDecisionCache implements DecisionCache {
+  private readonly entries;
+  get size(): number;
+  get(key: string): Promise<CachedDecision | undefined>;
+  set(key: string, value: CachedDecision): Promise<void>;
+}
+/**
+ * One `{"key","value"}` line per answer, appended. Read once, on first use;
+ * a later line for the same key wins. A torn last line (a crash mid-append) is
+ * skipped rather than failing the run — the answer is asked for again.
+ */
+declare class JsonlDecisionCache implements DecisionCache {
+  readonly path: string;
+  private loaded;
+  constructor(path: string);
+  private load;
+  get(key: string): Promise<CachedDecision | undefined>;
+  set(key: string, value: CachedDecision): Promise<void>;
+}
+//#endregion
+//#region src/decide.d.ts
+interface Pricing {
+  /** USD per million input tokens. */
+  inputPerMTok: number;
+  /** USD per million output tokens. */
+  outputPerMTok: number;
+}
+interface DeciderConfig {
+  /** Kinds this decider answers. Default: the built-in kinds. */
+  kinds?: ReadonlyArray<KindSpec<any, any>>;
+  /** Default: Jev over `process.env`; `false` turns it off. */
+  jev?: DecisionProvider | false;
+  /** Asked for what Jev does not answer. Default: `noopLlmProvider`; `createAnthropicProvider()` wires Claude Haiku. */
+  llm?: DecisionProvider;
+  /** Default: an in-memory cache for this decider's lifetime. */
+  cache?: DecisionCache;
+  audit?: AuditSink;
+  /** Absent: no cap. */
+  budget?: DecisionBudget;
+  /** One per provider. Default: 3 failures, 60s cooldown. */
+  breakers?: Partial<Record<'jev' | 'llm', CircuitBreaker>>;
+  batch?: BatchLimits;
+  /** Price per provider. Without one, that provider's `cost.usd` is left out; Jev's vendor publishes no price. */
+  pricing?: Partial<Record<'jev' | 'llm', Pricing>>;
+  now?: () => Date;
+}
+interface DecideOptions<I = unknown> {
+  /** Budget and audit tenant. Default `default`. */
+  tenant?: string;
+  /** Replace the kind's rule, e.g. with the host's own verdict function. `null` asks no rule. */
+  rule?: ((input: I) => RuleVerdict | undefined) | null;
+  /** Skip the cache lookup and do not store the answer. */
+  noCache?: boolean;
+  /**
+   * Ask a repeated input once (default). `false` asks every input as its own
+   * item, in the caller's order — what reproducing a calibrated request needs,
+   * since folding renumbers the items a request carries.
+   */
+  fold?: boolean;
+}
+interface Decider {
+  decide: <I>(kind: string, input: I, options?: DecideOptions<I>) => Promise<Decision>;
+  decideMany: <I>(kind: string, inputs: readonly I[], options?: DecideOptions<I>) => Promise<Decision[]>;
+  kinds: () => string[];
+}
+declare function createDecider(config?: DeciderConfig): Decider;
+/**
+ * Decide with the default decider: built-in kinds, Jev when
+ * `CONTENTRAIN_JEW_API_TOKEN` is set, an in-memory cache, no budget, no audit
+ * log. Build your own with `createDecider` for anything else.
+ */
+declare function decide<I>(kind: string, input: I, options?: DecideOptions<I>): Promise<Decision>;
+//#endregion
+//#region src/jev.d.ts
+declare const JEV_ENDPOINT = "https://api.typesafe.ai/v1/systemone";
+declare const JEV_TOKEN_ENV = "CONTENTRAIN_JEW_API_TOKEN";
+declare const DEFAULT_JEV_MODEL = "jev-latest";
+interface JevProviderOptions {
+  /** Where the token is read from. Default `process.env`. */
+  env?: Readonly<Record<string, string | undefined>>;
+  /** Injected for tests and recorded replays. The URL it is called with is always `JEV_ENDPOINT`. */
+  fetch?: typeof globalThis.fetch;
+  /** Per request. Default 15s. */
+  timeoutMs?: number;
+  /** Default `jev-latest`. Part of the request shape: a different model is a different cache. */
+  model?: string;
+}
+declare class JevError extends Error {
+  readonly status: number | undefined;
+  readonly timeout: boolean;
+  constructor(message: string, status: number | undefined, timeout?: boolean);
+}
+/**
+ * The request one batch sends: the kind's header from the first item, then one
+ * `Item <n>: ` line per item; every item's questions keyed `item<n>_<suffix>`.
+ */
+declare function buildJevRequest(spec: KindSpec<any, any>, shaped: readonly unknown[]): {
+  state: string;
+  questions: Record<string, JevQuestion>;
+};
+/**
+ * Hash of everything that shapes a kind's provider request: the model, the
+ * batch limits, whether items are grouped, and the request built from two
+ * copies of the kind's probe (header, line format, questions, criteria). A
+ * change to any of them changes the hash, and with it every cache key.
+ */
+declare function requestShapeHash(spec: KindSpec<any, any>, model?: string): string;
+declare function createJevProvider(options?: JevProviderOptions): DecisionProvider;
+/** Per-item outcomes from a systemone response. An item whose answers are missing or malformed gets `undefined`. */
+declare function readJevResponse(spec: KindSpec<any, any>, count: number, body: unknown): ProviderAnswer;
+//#endregion
+//#region src/llm.d.ts
+declare const noopLlmProvider: DecisionProvider;
+//#endregion
+//#region src/anthropic.d.ts
+declare const ANTHROPIC_ENDPOINT = "https://api.anthropic.com/v1/messages";
+declare const ANTHROPIC_KEY_ENV = "ANTHROPIC_API_KEY";
+declare const DEFAULT_ANTHROPIC_MODEL = "claude-haiku-4-5-20251001";
+interface AnthropicProviderOptions {
+  /** Where the key is read from. Default `process.env`. */
+  env?: Readonly<Record<string, string | undefined>>;
+  /** Injected for tests. The URL it is called with is always `ANTHROPIC_ENDPOINT`. */
+  fetch?: typeof globalThis.fetch;
+  /** Per request. Default 60s. */
+  timeoutMs?: number;
+  /** Default `claude-haiku-4-5-20251001`, asked at temperature 0. */
+  model?: string;
+}
+declare class AnthropicError extends Error {
+  readonly status: number | undefined;
+  readonly timeout: boolean;
+  constructor(message: string, status: number | undefined, timeout?: boolean);
+}
+type Questions = Record<string, JevQuestion>;
+/** The prompt for a kind without its own `llmPrompt`: the state, then every question with its options or rubric. */
+declare function genericLlmPrompt({
+  state,
+  questions,
+  count
+}: {
+  state: string;
+  questions: Questions;
+  count: number;
+}): string;
+/** The Messages API body one batch sends. */
+declare function buildAnthropicRequest(spec: KindSpec<any, any>, shaped: readonly unknown[], model?: string): {
+  model: string;
+  max_tokens: number;
+  temperature: number;
+  tools: {
+    name: string;
+    description: string;
+    input_schema: {
+      type: string;
+      properties: {
+        items: {
+          type: string;
+          items: {
+            type: string;
+            properties: Record<string, unknown>;
+            required: string[];
+          };
+        };
+      };
+      required: string[];
+    };
+  }[];
+  tool_choice: {
+    type: string;
+    name: string;
+  };
+  messages: {
+    role: string;
+    content: string;
+  }[];
+};
+/** Hash of the LLM request shape (model, prompt, tool), recorded by a calibration of this provider. */
+declare function anthropicRequestShapeHash(spec: KindSpec<any, any>, model?: string): string;
+declare function createAnthropicProvider(options?: AnthropicProviderOptions): DecisionProvider;
+/** Per-item outcomes from a Messages API response. An item whose record is missing or malformed gets `undefined`. */
+declare function readAnthropicResponse(spec: KindSpec<any, any>, count: number, body: unknown): ProviderAnswer;
+//#endregion
+//#region src/kinds/index.d.ts
+declare const BUILTIN_KINDS: ReadonlyArray<KindSpec<any, any>>;
+//#endregion
+//#region src/kinds/punch-item.d.ts
+declare const PUNCH_CLASSES: readonly ["product_defect", "source_limit", "cosmetic", "measurement"];
+type PunchClass = typeof PUNCH_CLASSES[number];
+declare const PUNCH_CLASS_CRITERIA: Record<PunchClass, string>;
+/** Severity rubric, levels 0–3 (Jev's score scale). Level n here is severity n+1 on a 1–4 scale. */
+declare const PUNCH_SEVERITY_CRITERIA: readonly ["Teslimi engellemez — göz ardı edilebilir.", "Küçük, düşük öncelik — teslim edilebilir, sonra bakılabilir.", "Teslimden önce ele alınmalı — müşteri fark edebilir ama kesin reddetmez.", "Müşteri fark eder ve reddeder — teslim öncesi mutlaka çözülmeli."];
+interface PunchItemInput {
+  /** The item's label in the run report, e.g. `(aile: post)` or a page slug. */
+  label: string;
+  /** Why it is on the list, as the run report words it. */
+  reason: string;
+  /** A link to the page. Never sent: the request says only whether there is one. */
+  link?: string;
+  /** The site the item belongs to. `name` and `url` only group items into one request and are never sent. */
+  site?: {
+    name?: string;
+    url?: string;
+    decision?: string;
+    median?: number;
+    mobile_median?: number;
+  };
+}
+interface PunchItemShaped {
+  label: string;
+  reason: string;
+  /** Whether the item has a link; the link itself is not kept. */
+  linked: boolean;
+  site: {
+    /** Opaque: a hash of the site's name or URL, so one site's items share a request. Never sent. */group: string;
+    decision: string | null;
+    median: number | null;
+    mobile_median: number | null;
+  };
+}
+declare function shapePunchItem(input: PunchItemInput): PunchItemShaped;
+declare function punchItemRule(input: PunchItemInput): RuleVerdict | undefined;
+/** Jev's 0–3 severity score as a 1–4 level (PoC-1's hand-label scale). */
+declare const severityLevel: (score: number) => number;
+declare const punchItem: KindSpec<PunchItemInput, PunchItemShaped>;
+//#endregion
+//#region src/kinds/eligibility-band.d.ts
+declare const ELIGIBILITY_CHOICES: readonly ["eligible", "access_blocked", "page_only", "custom_type"];
+type EligibilityChoice = typeof ELIGIBILITY_CHOICES[number];
+declare const NEEDS_HUMAN = "needs_human";
+/** Migrate's `EligibilityInput`, as discovery produces it. */
+interface EligibilityBandInput {
+  access: 'open' | 'bot_wall' | 'unreachable';
+  rest: {
+    reachable: boolean;
+    counts: {
+      posts: number | null;
+      pages: number | null;
+    };
+    postTypes: Array<{
+      slug: string;
+      count?: number | null;
+    }>; /** Sampled records. Only how many there are is used — their content never leaves. */
+    samples: {
+      posts: unknown[];
+      pages: unknown[];
+    };
+  };
+}
+interface EligibilityBandShaped {
+  access: EligibilityBandInput['access'];
+  rest_reachable: boolean;
+  posts: number | null;
+  pages: number | null;
+  post_samples: number;
+  page_samples: number;
+  custom_types: Array<{
+    slug: string;
+    count: number;
+  }>;
+}
+declare function shapeEligibility(input: EligibilityBandInput): EligibilityBandShaped;
+declare function eligibilityRule(input: EligibilityBandInput): RuleVerdict;
+declare const eligibilityBand: KindSpec<EligibilityBandInput, EligibilityBandShaped>;
+//#endregion
+//#region src/kinds/shape.d.ts
+declare function scrubText(text: string, max: number): string;
+/** A slug-like identifier (post-type name, family name): lower-case word characters and dashes only. */
+declare function scrubSlug(value: string, max?: number): string;
+//#endregion
+//#region src/calibration.d.ts
+interface RecordedCase<I> {
+  input: I;
+  /** The item's answers, keyed by the kind's question suffixes. */
+  answers: Record<string, JevAnswer>;
+}
+/**
+ * A `fetch` that answers systemone requests for `spec` from recorded answers,
+ * matching each item by its request header and its rendered line. An item
+ * with no recording gets no answers, which the decider treats as `no_answer`.
+ * `calls` counts requests.
+ *
+ * A replay re-reads the answers a model gave once. It checks the code path —
+ * shaping, grouping, batching, reading — and says nothing about how the model
+ * answers today; only a live run does.
+ */
+declare function createReplayFetch<I>(spec: KindSpec<I, any>, cases: ReadonlyArray<RecordedCase<I>>, model?: string): typeof globalThis.fetch & {
+  calls: number;
+};
+interface PunchLabel {
+  class: string;
+  /** 1–4. */
+  severity: number;
+}
+interface PunchCalibration {
+  total: number;
+  answered: number;
+  classMatch: number;
+  severityWithin1: number;
+  classRate: number;
+  severityRate: number;
+  misses: Array<{
+    index: number;
+    expected: PunchLabel;
+    choice?: string;
+    level?: number;
+  }>;
+}
+/** Exact class and severity within one level, over every label (an unanswered item counts as a miss). */
+declare function measurePunchCalibration(labels: readonly PunchLabel[], decisions: readonly Decision[]): PunchCalibration;
+/** Whether repeated runs over the same inputs chose the same class for every item. */
+declare function stableChoices(runs: ReadonlyArray<readonly Decision[]>): {
+  stable: number;
+  total: number;
+};
+//#endregion
+export { ANTHROPIC_ENDPOINT, ANTHROPIC_KEY_ENV, AnthropicError, type AnthropicProviderOptions, type AuditRecord, type AuditSink, BUILTIN_KINDS, type BatchLimits, type CachedDecision, CircuitBreaker, type CircuitBreakerOptions, DEFAULT_ANTHROPIC_MODEL, DEFAULT_BATCH, DEFAULT_JEV_MODEL, type DecideOptions, type Decider, type DeciderConfig, type Decision, type DecisionBudget, type DecisionCache, type DecisionProvider, type DecisionSource, ELIGIBILITY_CHOICES, type EligibilityBandInput, type EligibilityBandShaped, type EligibilityChoice, type FallbackReason, JEV_ENDPOINT, JEV_TOKEN_ENV, type JevAnswer, JevError, type JevProviderOptions, type JevQuestion, type JevSpec, JsonlAuditLog, JsonlDecisionCache, type KindSpec, MemoryAuditLog, MemoryDailyBudget, MemoryDecisionCache, NEEDS_HUMAN, type Outcome, PUNCH_CLASSES, PUNCH_CLASS_CRITERIA, PUNCH_SEVERITY_CRITERIA, type Pricing, type ProviderAnswer, type PunchCalibration, type PunchClass, type PunchItemInput, type PunchItemShaped, type PunchLabel, type RecordedCase, type RuleVerdict, type TokenCost, anthropicRequestShapeHash, buildAnthropicRequest, buildJevRequest, cacheKey, createAnthropicProvider, createDecider, createJevProvider, createReplayFetch, decide, eligibilityBand, eligibilityRule, estimateTokens, genericLlmPrompt, measurePunchCalibration, noopLlmProvider, planBatches, punchItem, punchItemRule, readAnthropicResponse, readJevResponse, requestShapeHash, scrubSlug, scrubText, severityLevel, shapeEligibility, shapePunchItem, stableChoices, toAuditRecord };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/audit.ts","../src/batch.ts","../src/budget.ts","../src/cache.ts","../src/decide.ts","../src/jev.ts","../src/llm.ts","../src/anthropic.ts","../src/kinds/index.ts","../src/kinds/punch-item.ts","../src/kinds/eligibility-band.ts","../src/kinds/shape.ts","../src/calibration.ts"],"mappings":";;KAQY,cAAA;;KAGA,cAAA;;KAGA,WAAA;EACN,IAAA;EAAgB,YAAA;EAAsB,QAAA,EAAU,MAAA;AAAA;EAChD,IAAA;EAAe,YAAA;EAAsB,QAAA;AAAA;EACrC,IAAA;EAAc,YAAA;AAAA;;KAGR,SAAA;EACN,IAAA;EAAgB,MAAA;EAAgB,UAAA;EAAoB,aAAA,GAAgB,MAAA;AAAA;EACpE,IAAA;EAAe,KAAA;EAAe,UAAA;EAAoB,aAAA,GAAgB,MAAA;AAAA;EAClE,IAAA;EAAc,IAAA;AAAA;;UAGH,OAAA;EACf,MAAA;EACA,KAAA;EANmB;EAQnB,UAAA;EACA,aAAA,GAAgB,MAAA;AAAA;;UAID,WAAA,SAAoB,OAAA;EAZb;;AAGxB;;;EAeE,KAAA;AAAA;AAAA,UAGe,SAAA;EACf,YAAA;EACA,aAAA;EAfgB;EAiBhB,GAAA;AAAA;AAAA,UAGe,QAAA;EACf,IAAA;;EAEA,OAAA;EAbK;EAeL,GAAA;EAZwB;EAcxB,KAAA;EACA,MAAA;EACA,KAAA;EACA,UAAA;EACA,aAAA,GAAgB,MAAA;EAChB,MAAA,EAAQ,cAAA;EAfL;EAiBH,QAAA;EAduB;EAgBvB,UAAA;EACA,QAAA,GAAW,cAAA;EALH;EAOR,IAAA,GAAO,SAAA;EAAA;EAEP,EAAA;EAFgB;EAIhB,KAAA;AAAA;;;;;;;;;;UAYe,OAAA;EAnBf;EAqBA,MAAA,IAAU,MAAA,EAAQ,CAAA;EApBP;EAsBX,KAAA,IAAS,MAAA,EAAQ,CAAA;EApBV;EAsBP,MAAA,GAAS,MAAA,EAAQ,CAAA;EAlBjB;EAoBA,SAAA,GAAY,MAAA,aAAmB,MAAA,SAAe,WAAA;EApBzC;EAsBL,IAAA,GAAO,OAAA,EAAS,MAAA,SAAe,SAAA,MAAe,OAAA;EAVxB;EAYtB,KAAA;IAAU,QAAA;IAAmB,SAAA;EAAA;EAJiB;EAM9C,KAAA,EAAO,CAAA;EAJwB;;;;;;EAW/B,SAAA,IAAa,OAAA;IAAW,KAAA;IAAe,SAAA,EAAW,MAAA,SAAe,WAAA;IAAc,KAAA;EAAA;AAAA;AAAA,UAGhE,QAAA;EACf,IAAA;EArBS;EAuBT,OAAA;EArBiB;EAuBjB,OAAA;EArBA;EAuBA,UAAA;EAvB+B;;;;;EA6B/B,KAAA,GAAQ,KAAA,EAAO,CAAA,KAAM,CAAA;EA3ByB;EA6B9C,IAAA,IAAQ,KAAA,EAAO,CAAA,KAAM,WAAA;EACrB,GAAA,GAAM,OAAA,CAAQ,CAAA;EA5Be;;;;;EAkC7B,aAAA;IAAkB,SAAA;IAAmB,MAAA;EAAA;AAAA;;UAItB,cAAA;EACf,QAAA,EAAU,KAAA,CAAM,OAAA;EAChB,KAAA;IAAU,YAAA;IAAsB,aAAA;EAAA;EAChC,KAAA;AAAA;AAAA,UAGe,gBAAA;EAAA,SACN,IAAA;EAjBI;EAmBb,SAAA;EAnCwB;EAAA,SAqCf,KAAA;EApCT;EAsCA,GAAA,GAAM,IAAA,EAAM,QAAA,YAAoB,MAAA,gBAAsB,OAAA,CAAQ,cAAA;AAAA;;;UC3I/C,WAAA;EDFS;ECIxB,EAAA;EACA,MAAA;EACA,IAAA;EACA,OAAA;EDJwB;ECMxB,GAAA;EDNwB;ECQxB,KAAA;EACA,MAAA;EACA,KAAA;EACA,UAAA;EACA,MAAA,EAAQ,cAAA;EACR,QAAA;EACA,UAAA;EACA,QAAA,GAAW,cAAA;EACX,EAAA;EACA,KAAA;EACA,YAAA;EACA,aAAA;EACA,GAAA;AAAA;AAAA,UAGe,SAAA;EACf,KAAA,GAAQ,OAAA,WAAkB,WAAA,OAAkB,OAAA;AAAA;AAAA,iBAG9B,aAAA,CAAc,QAAA,EAAU,QAAA,EAAU,EAAA,UAAY,MAAA,WAAiB,WAAA;AAAA,cA0BlE,cAAA,YAA0B,SAAA;EAAA,SAC5B,OAAA,EAAS,WAAA;EAEZ,KAAA,CAAM,OAAA,WAAkB,WAAA,KAAgB,OAAA;AAAA;;cAMnC,aAAA,YAAyB,SAAA;EAAA,SACf,IAAA;cAAA,IAAA;EAEf,KAAA,CAAM,OAAA,WAAkB,WAAA,KAAgB,OAAA;AAAA;;;UCpE/B,WAAA;EACf,QAAA;EACA,SAAA;AAAA;AAAA,cAGW,aAAA,EAAe,QAAA,CAAS,WAAA;AAAA,cAExB,cAAA,GAAkB,IAAA;AFJ/B;;;;;AAAA,iBEWgB,WAAA,CAAY,KAAA,qBAA0B,KAAA,UAAe,MAAA,GAAQ,WAAA;;;;UChB5D,cAAA;EHES;EGAxB,IAAA,GAAO,MAAA,UAAgB,KAAA,UAAe,GAAA,EAAK,IAAA,KAAS,OAAA;AAAA;;cAIzC,iBAAA,YAA6B,cAAA;EAAA,SAGnB,MAAA;EAAA,iBAFJ,KAAA;cAEI,MAAA;EAIf,IAAA,CAAK,MAAA,UAAgB,KAAA,UAAe,GAAA,EAAK,IAAA,GAAO,OAAA;EAQtD,IAAA,CAAK,MAAA,UAAgB,GAAA,EAAK,IAAA;AAAA;AAAA,UAKX,qBAAA;EHjB2C;EGmB1D,QAAA;EHnBoB;EGqBpB,UAAA;EACA,GAAA;AAAA;;;;;;cAQW,cAAA;EAAA,QACH,WAAA;EAAA,QACA,QAAA;EAAA,iBACS,KAAA;EAAA,iBACA,UAAA;EAAA,iBACA,GAAA;cAEL,OAAA,GAAS,qBAAA;EAAA,IAMjB,KAAA,CAAA;EHrCoD;EG2CxD,MAAA,CAAA;EAIA,OAAA,CAAA;EAKA,OAAA,CAAA;AAAA;;;AHjEF;AAAA,KIaY,cAAA,GAAiB,IAAA,CAAK,QAAA;EAChC,MAAA,iBJdwB;EIgBxB,EAAA;AAAA;AAAA,UAGe,aAAA;EACf,GAAA,GAAM,GAAA,aAAgB,OAAA,CAAQ,cAAA;EAC9B,GAAA,GAAM,GAAA,UAAa,KAAA,EAAO,cAAA,KAAmB,OAAA;AAAA;AAAA,iBAG/B,QAAA,CAAS,IAAA,UAAc,OAAA,UAAiB,KAAA,UAAe,MAAA;AAAA,cAI1D,mBAAA,YAA+B,aAAA;EAAA,iBACzB,OAAA;EAAA,IAEb,IAAA,CAAA;EAIE,GAAA,CAAI,GAAA,WAAc,OAAA,CAAQ,cAAA;EAI1B,GAAA,CAAI,GAAA,UAAa,KAAA,EAAO,cAAA,GAAiB,OAAA;AAAA;;;;;;cAUpC,kBAAA,YAA8B,aAAA;EAAA,SAGpB,IAAA;EAAA,QAFb,MAAA;cAEa,IAAA;EAAA,QAEb,IAAA;EAWF,GAAA,CAAI,GAAA,WAAc,OAAA,CAAQ,cAAA;EAI1B,GAAA,CAAI,GAAA,UAAa,KAAA,EAAO,cAAA,GAAiB,OAAA;AAAA;;;UCzDhC,OAAA;ELTS;EKWxB,YAAA;ELXwB;EKaxB,aAAA;AAAA;AAAA,UAGe,aAAA;;EAEf,KAAA,GAAQ,aAAA,CAAc,QAAA;ELdlB;EKgBJ,GAAA,GAAM,gBAAA;ELhBoC;EKkB1C,GAAA,GAAM,gBAAA;ELjBF;EKmBJ,KAAA,GAAQ,aAAA;EACR,KAAA,GAAQ,SAAA;ELnBJ;EKqBJ,MAAA,GAAS,cAAA;ELrBqB;EKuB9B,QAAA,GAAW,OAAA,CAAQ,MAAA,gBAAsB,cAAA;EACzC,KAAA,GAAQ,WAAA;ELrBW;EKuBnB,OAAA,GAAU,OAAA,CAAQ,MAAA,gBAAsB,OAAA;EACxC,GAAA,SAAY,IAAA;AAAA;AAAA,UAGG,aAAA;EL1BqB;EK4BpC,MAAA;EL5BwE;EK8BxE,IAAA,KAAS,KAAA,EAAO,CAAA,KAAM,WAAA;EL7BH;EK+BnB,OAAA;EL/BsD;;;;;EKqCtD,IAAA;AAAA;AAAA,UAGe,OAAA;EACf,MAAA,MAAY,IAAA,UAAc,KAAA,EAAO,CAAA,EAAG,OAAA,GAAU,aAAA,CAAc,CAAA,MAAO,OAAA,CAAQ,QAAA;EAC3E,UAAA,MAAgB,IAAA,UAAc,MAAA,WAAiB,CAAA,IAAK,OAAA,GAAU,aAAA,CAAc,CAAA,MAAO,OAAA,CAAQ,QAAA;EAC3F,KAAA;AAAA;AAAA,iBA6Dc,aAAA,CAAc,MAAA,GAAQ,aAAA,GAAqB,OAAA;;;;;AL3F3D;iBK2QgB,MAAA,GAAA,CAAU,IAAA,UAAc,KAAA,EAAO,CAAA,EAAG,OAAA,GAAU,aAAA,CAAc,CAAA,IAAK,OAAA,CAAQ,QAAA;;;cChS1E,YAAA;AAAA,cACA,aAAA;AAAA,cACA,iBAAA;AAAA,UAEI,kBAAA;ENVS;EMYxB,GAAA,GAAM,QAAA,CAAS,MAAA;ENTS;EMWxB,KAAA,UAAe,UAAA,CAAW,KAAA;ENXF;EMaxB,SAAA;ENVU;EMYV,KAAA;AAAA;AAAA,cAGW,QAAA,SAAiB,KAAA;EAAA,SACU,MAAA;EAAA,SAAqC,OAAA;cAA/D,OAAA,UAA0B,MAAA,sBAAqC,OAAA;AAAA;;;;;iBAU7D,eAAA,CAAgB,IAAA,EAAM,QAAA,YAAoB,MAAA;EAA+B,KAAA;EAAe,SAAA,EAAW,MAAA,SAAe,WAAA;AAAA;;;;;;;iBAmBlH,gBAAA,CAAiB,IAAA,EAAM,QAAA,YAAoB,KAAA;AAAA,iBAY3C,iBAAA,CAAkB,OAAA,GAAS,kBAAA,GAA0B,gBAAA;;iBA2CrD,eAAA,CAAgB,IAAA,EAAM,QAAA,YAAoB,KAAA,UAAe,IAAA,YAAgB,cAAA;;;cCzG5E,eAAA,EAAiB,gBAAA;;;cCYjB,kBAAA;AAAA,cACA,iBAAA;AAAA,cACA,uBAAA;AAAA,UAKI,wBAAA;ERpBS;EQsBxB,GAAA,GAAM,QAAA,CAAS,MAAA;ERnBS;EQqBxB,KAAA,UAAe,UAAA,CAAW,KAAA;ERrBF;EQuBxB,SAAA;ERpBU;EQsBV,KAAA;AAAA;AAAA,cAGW,cAAA,SAAuB,KAAA;EAAA,SACI,MAAA;EAAA,SAAqC,OAAA;cAA/D,OAAA,UAA0B,MAAA,sBAAqC,OAAA;AAAA;AAAA,KAMxE,SAAA,GAAY,MAAA,SAAe,WAAA;;iBAKhB,gBAAA,CAAA;EAAmB,KAAA;EAAO,SAAA;EAAW;AAAA;EAAW,KAAA;EAAe,SAAA,EAAW,SAAA;EAAW,KAAA;AAAA;AR/BrG;AAAA,iBQ0EgB,qBAAA,CAAsB,IAAA,EAAM,QAAA,YAAoB,MAAA,sBAA4B,KAAA;;;;;;;;;;;;;;wBAAhD,MAAA;;;;;;;;;;;;;;;;;;iBAiB5B,yBAAA,CAA0B,IAAA,EAAM,QAAA,YAAoB,KAAA;AAAA,iBAMpD,uBAAA,CAAwB,OAAA,GAAS,wBAAA,GAAgC,gBAAA;;iBA2CjE,qBAAA,CAAsB,IAAA,EAAM,QAAA,YAAoB,KAAA,UAAe,IAAA,YAAgB,cAAA;;;cC5JlF,aAAA,EAAe,aAAA,CAAc,QAAA;;;cCkB7B,aAAA;AAAA,KACD,UAAA,UAAoB,aAAA;AAAA,cAEnB,oBAAA,EAAsB,MAAA,CAAO,UAAA;;cAQ7B,uBAAA;AAAA,UAOI,cAAA;EV7BS;EU+BxB,KAAA;EV/BwB;EUiCxB,MAAA;EV9BU;EUgCV,IAAA;;EAEA,IAAA;IAAS,IAAA;IAAe,GAAA;IAAc,QAAA;IAAmB,MAAA;IAAiB,aAAA;EAAA;AAAA;AAAA,UAG3D,eAAA;EACf,KAAA;EACA,MAAA;EVpC8B;EUsC9B,MAAA;EACA,IAAA;IVnCwE,iGUqCtE,KAAA;IACA,QAAA;IACA,MAAA;IACA,aAAA;EAAA;AAAA;AAAA,iBAIY,cAAA,CAAe,KAAA,EAAO,cAAA,GAAiB,eAAA;AAAA,iBAwBvC,aAAA,CAAc,KAAA,EAAO,cAAA,GAAiB,WAAA;;cA8DzC,aAAA,GAAiB,KAAA;AAAA,cAEjB,SAAA,EAAW,QAAA,CAAS,cAAA,EAAgB,eAAA;;;cCtIpC,mBAAA;AAAA,KACD,iBAAA,UAA2B,mBAAA;AAAA,cAC1B,WAAA;;UAGI,oBAAA;EACf,MAAA;EACA,IAAA;IACE,SAAA;IACA,MAAA;MAAU,KAAA;MAAsB,KAAA;IAAA;IAChC,SAAA,EAAW,KAAA;MAAQ,IAAA;MAAc,KAAA;IAAA,IXdO;IWgBxC,OAAA;MAAW,KAAA;MAAkB,KAAA;IAAA;EAAA;AAAA;AAAA,UAIhB,qBAAA;EACf,MAAA,EAAQ,oBAAA;EACR,cAAA;EACA,KAAA;EACA,KAAA;EACA,YAAA;EACA,YAAA;EACA,YAAA,EAAc,KAAA;IAAQ,IAAA;IAAc,KAAA;EAAA;AAAA;AAAA,iBAOtB,gBAAA,CAAiB,KAAA,EAAO,oBAAA,GAAuB,qBAAA;AAAA,iBAwB/C,eAAA,CAAgB,KAAA,EAAO,oBAAA,GAAuB,WAAA;AAAA,cAgDjD,eAAA,EAAiB,QAAA,CAAS,oBAAA,EAAsB,qBAAA;;;iBC9G7C,SAAA,CAAU,IAAA,UAAc,GAAA;AZHxC;AAAA,iBYcgB,SAAA,CAAU,KAAA,UAAe,GAAA;;;UCPxB,YAAA;EACf,KAAA,EAAO,CAAA;;EAEP,OAAA,EAAS,MAAA,SAAe,SAAA;AAAA;AbP1B;;;;;AAGA;;;;;AAHA,iBa0BgB,iBAAA,GAAA,CAAqB,IAAA,EAAM,QAAA,CAAS,CAAA,QAAS,KAAA,EAAO,aAAA,CAAc,YAAA,CAAa,CAAA,IAAK,KAAA,mBAA0B,UAAA,CAAW,KAAA;EAAU,KAAA;AAAA;AAAA,UAuBlI,UAAA;EACf,KAAA;Eb7CyC;Ea+CzC,QAAA;AAAA;AAAA,UAGe,gBAAA;EACf,KAAA;EACA,QAAA;EACA,UAAA;EACA,eAAA;EACA,SAAA;EACA,YAAA;EACA,MAAA,EAAQ,KAAA;IAAQ,KAAA;IAAe,QAAA,EAAU,UAAA;IAAY,MAAA;IAAiB,KAAA;EAAA;AAAA;;iBAIxD,uBAAA,CAAwB,MAAA,WAAiB,UAAA,IAAc,SAAA,WAAoB,QAAA,KAAa,gBAAA;;iBAgCxF,aAAA,CAAc,IAAA,EAAM,aAAA,UAAuB,QAAA;EAAgB,MAAA;EAAgB,KAAA;AAAA"}