@trazum/core 1.81.0 → 1.83.0

package/src/receipt.ts

@@ -0,0 +1,351 @@
+import { PROVIDER_REVIEWED, modelFrom } from './pricing.js';
+import type { PricingCatalogue } from './pricing.js';
+import { UNLABELLED } from './usage.js';
+import type { UsageBreakdown, UsageProfileReport } from './usage.js';
+
+/**
+ * The receipt: a bill's counts, with the provenance of every figure attached.
+ *
+ * ## What it is for
+ *
+ * A profile answers a question on the terminal where it ran. A receipt is the
+ * same figures shaped so they can still answer it somewhere else: aggregated by
+ * somebody's dashboard, filed against an invoice, or compared against last
+ * month's by a reader who was not there when the command ran.
+ *
+ * That is why every line carries the rate behind its money and the date that
+ * rate was last read. A dollar figure with no provenance cannot tell a
+ * repricing from a team whose spend moved, and the consumer that most needs
+ * that distinction is the one that cannot read a sentence explaining it.
+ *
+ * ## Why a line carries money per bucket and not only a rate
+ *
+ * The first version of this module published the catalogue's `inputPerMTok`
+ * and `outputPerMTok` beside a dollar figure computed by `profileUsage`. Those
+ * are not always the same rates. A model in a promotional window, or one whose
+ * long-context tier applied, is billed at `effectivePricing`'s figure, and a
+ * cached read is billed at a fraction of input that no published field named at
+ * all. **A consumer multiplying the stated rates by the stated tokens got a
+ * different number from the stated total, with nothing saying which was
+ * wrong.**
+ *
+ * That is a bad defect in a document whose entire purpose is that a figure can
+ * be recomputed by whoever receives it, and it is the exact failure the
+ * doctrine line at the foot of this comment is about.
+ *
+ * So a line now carries the **money as it was actually apportioned** -- input,
+ * cache reads, cache writes and output -- and `usd` is their sum. The rates stay
+ * as provenance, labelled as the catalogue's published figures rather than as
+ * the arithmetic. `receipt-arithmetic.test.js` fails if the four stop adding up,
+ * which is a property a reader can check on any receipt they are handed rather
+ * than a promise they have to take.
+ *
+ * ## What it carries, and what it has no field for
+ *
+ * Counts, model, provider, the money split by bucket, the published rates, the
+ * review date, the label the log carried, the period, and what could not be
+ * priced. There is **no field
+ * for prompt text, for an answer, for a file path, for a branch name or for a
+ * credential** — not redacted, not hashed, absent, because the input this takes
+ * has nowhere to hold them either.
+ *
+ * `receipt-redaction.test.js` holds that by planting all 4 in a log — in the
+ * session field among other places, which is the value this package has
+ * promised since it shipped never comes back out — and failing if any reaches
+ * the output. A property about what a document does not contain is exactly the
+ * kind this repository proves by breaking rather than by asserting.
+ *
+ * ## What it is not
+ *
+ * **Not a transport.** Nothing here opens a socket, reads an environment
+ * variable or takes an endpoint. `receiptFrom` returns a value; where it goes
+ * is the caller's decision. A module in this package that phoned home would
+ * break the roadmap's first rule, which is that no feature may make a network
+ * call a prerequisite for anything.
+ *
+ * **Not a new measurement.** Every figure is one `profileUsage` already
+ * produced. This adds provenance around them and takes nothing away.
+ *
+ * Doctrine: [A machine reader gets the provenance too](../../../docs/doctrine.md#a-machine-reader-gets-the-provenance-too)
+ */
+
+/**
+ * The catalogue's published rates for this model, and when a human last read
+ * them off the provider's own page.
+ *
+ * **Provenance, not the arithmetic.** These are list rates. The money that was
+ * actually apportioned is in `ReceiptLine.money`, and the two differ whenever a
+ * promotion or a long-context tier applied, or for any token billed at a
+ * fraction of input -- which is every cached read. A consumer wanting the rate
+ * that was really charged divides a bucket's money by its tokens; a consumer
+ * wanting to know whether a provider repriced compares these.
+ */
+export interface ReceiptPricing {
+  provider: string;
+  inputPerMTok: number;
+  outputPerMTok: number;
+  /**
+   * The date this provider's rates were last read off its own page, `null`
+   * when the catalogue carries no date for that provider.
+   *
+   * Per provider rather than per catalogue, because that is how the prices are
+   * actually reviewed: looking at one page and finding nothing changed is not
+   * the same event as not looking. A server comparing two receipts a month
+   * apart reads a repricing as a repricing instead of as a team missing a
+   * target.
+   */
+  reviewedOn: string | null;
+}
+
+/** Where a line's money went. The four add to `ReceiptLine.usd`. */
+export interface ReceiptMoney {
+  inputUsd: number;
+  cacheReadUsd: number;
+  cacheWriteUsd: number;
+  outputUsd: number;
+}
+
+/** One slice of a bill: a label's calls to one model. */
+export interface ReceiptLine {
+  /**
+   * The attribution the log carried, or `null` for the unlabelled bucket.
+   *
+   * `null` rather than the sentinel, which is an internal grouping key and is
+   * never serialised. A consumer that saw the raw sentinel would have to know
+   * this package's internals to render it.
+   */
+  label: string | null;
+  model: string;
+  calls: number;
+  inputTokens: number;
+  cacheReadTokens: number;
+  /** Every cache write, whatever its TTL. The sum of the two fields below. */
+  cacheWriteTokens: number;
+  /**
+   * The two write TTLs kept apart, because they are billed at different rates.
+   *
+   * They are here for the same reason `UsageBreakdown` keeps them: the ratio
+   * between them is not a constant across providers, so a total that has lost
+   * the split can be repriced only by guessing at it. A consumer repricing this
+   * traffic against another model's rates needs both.
+   */
+  cacheWrite5mTokens: number;
+  cacheWrite1hTokens: number;
+  outputTokens: number;
+  /**
+   * What it cost, which is exactly the sum of `money` below.
+   *
+   * Every line here is priced; what is not is in `gaps`.
+   */
+  usd: number;
+  /**
+   * Where the money went, as it was apportioned rather than as it might be
+   * recomputed.
+   *
+   * This is the field that makes a receipt checkable. `usd` alone can only be
+   * believed; these four can be added up, and each can be divided by its own
+   * token count to recover the rate that was really charged -- including the
+   * one for cached reads, which no published rate names.
+   */
+  money: ReceiptMoney;
+  /** The catalogue's published rates, as provenance. */
+  pricing: ReceiptPricing;
+}
+
+/** Everything a receipt refuses to answer, typed rather than left implicit. */
+export type ReceiptGap =
+  /**
+   * Models the catalogue does not price, with the size of what they used.
+   *
+   * The counts are here rather than in a line, and the first draft of this
+   * module got that wrong in a way its own guard caught. `byLabelAndModel`
+   * excludes unpriced calls on purpose — the profile keeps them apart so that
+   * a total is never tokens from one set of calls over dollars from another —
+   * so a receipt built from that list alone silently loses them.
+   *
+   * The obvious repair was worse than the bug: emit a line with `label: null`.
+   * That reads as *this call carried no label*, when in fact it carried one the
+   * profile could not attach to a priced slice. Conflating "unlabelled" with
+   * "unattributable" is the exact failure this project refuses elsewhere, so
+   * the gap carries the magnitude instead and nothing pretends to an
+   * attribution it does not have.
+   */
+  | { kind: 'unpriced'; models: string[]; calls: number; inputTokens: number; outputTokens: number }
+  | { kind: 'unread-lines'; count: number }
+  | { kind: 'no-clock' }
+  /**
+   * Calls whose cache-write TTL the log did not state, so the cheaper rate was
+   * assumed.
+   *
+   * Reported because it changes what kind of figure this is. A total that
+   * includes an assumed TTL is a **floor** on those calls, not a measurement,
+   * and a document that says `counting: 'counted'` while quietly resting on an
+   * assumption is claiming a precision it does not have.
+   */
+  | { kind: 'assumed-write-ttl'; calls: number };
+
+export interface ReceiptDocument {
+  /** The one thing a consumer must branch on. Set here, by the builder. */
+  schemaVersion: 1;
+  /**
+   * When this receipt was made, or `null`.
+   *
+   * Optional on purpose, and the reason is the same one `plan.json` gives: a
+   * document without a stamp is undated, which a reader can act on. A document
+   * with an invented stamp is wrong, which they cannot.
+   */
+  emittedAt: string | null;
+  /** The period the counts cover, from the log's own clock. */
+  span: { fromMs: number; toMs: number; calls: number } | null;
+  /**
+   * How the tokens were arrived at.
+   *
+   * `counted` for every receipt this function builds, because a usage log
+   * carries the provider's own counts. The field exists because a receipt built
+   * from an estimate would be a different kind of evidence, and a consumer must
+   * never have to guess which one it is holding.
+   */
+  counting: 'counted';
+  lines: ReceiptLine[];
+  total: { calls: number; usd: number };
+  /**
+   * What this receipt cannot say, and why.
+   *
+   * Present and empty rather than absent when there is nothing to report:
+   * "nothing was refused" and "this document does not record refusals" are
+   * different statements, and a server aggregating a thousand receipts has to
+   * be able to tell them apart.
+   */
+  gaps: ReceiptGap[];
+}
+
+/**
+ * The fields that leave this machine, listed once, in one place.
+ *
+ * The redaction guard reads this array rather than a copy of it, so a field
+ * added to `ReceiptLine` and not added here fails the guard. A whitelist
+ * maintained in two places is a whitelist with a hole in it.
+ */
+export const RECEIPT_LINE_FIELDS = Object.freeze([
+  'label',
+  'model',
+  'calls',
+  'inputTokens',
+  'cacheReadTokens',
+  'cacheWriteTokens',
+  'cacheWrite5mTokens',
+  'cacheWrite1hTokens',
+  'outputTokens',
+  'usd',
+  'money',
+  'pricing',
+] as const);
+
+const lineFrom = (
+  label: string,
+  model: string,
+  breakdown: UsageBreakdown,
+  catalogue: PricingCatalogue,
+): ReceiptLine => {
+  /*
+   * Every slice reaching here is priced: `byLabelAndModel` holds only what the
+   * catalogue knows. What it does not know is reported by the `unpriced` gap,
+   * with its size, so the receipt's total is never mistaken for the whole bill.
+   */
+  const priced = modelFrom(catalogue, model);
+  return {
+    label: label === UNLABELLED ? null : label,
+    model,
+    calls: breakdown.calls,
+    inputTokens: breakdown.inputTokens,
+    cacheReadTokens: breakdown.cacheReadTokens,
+    cacheWriteTokens: breakdown.cacheWriteTokens,
+    cacheWrite5mTokens: breakdown.cacheWrite5mTokens,
+    cacheWrite1hTokens: breakdown.cacheWrite1hTokens,
+    outputTokens: breakdown.outputTokens,
+    usd: breakdown.totalUsd,
+    /*
+     * Copied from the breakdown rather than recomputed from the rates below.
+     * Recomputing would reintroduce the defect this field exists to fix: the
+     * published rates are list rates, and a promotion, a long-context tier or
+     * any cached token is billed at something else.
+     */
+    money: {
+      inputUsd: breakdown.inputUsd,
+      cacheReadUsd: breakdown.cacheReadUsd,
+      cacheWriteUsd: breakdown.cacheWriteUsd,
+      outputUsd: breakdown.outputUsd,
+    },
+    pricing: {
+      provider: priced.provider ?? 'unknown',
+      inputPerMTok: priced.inputPerMTok,
+      outputPerMTok: priced.outputPerMTok,
+      reviewedOn: PROVIDER_REVIEWED[priced.provider ?? ''] ?? null,
+    },
+  };
+};
+
+export interface ReceiptOptions {
+  /** Stamp the document. Omit for an undated receipt, which is valid. */
+  emittedAt?: Date;
+}
+
+/**
+ * Build a receipt from a profile the caller already computed.
+ *
+ * Takes the report rather than the log text, and that is the guarantee rather
+ * than an ergonomic choice: `UsageProfileReport` has no field that can hold
+ * prompt content, so this function could not emit any even if it tried. The
+ * narrow input is what makes the promise checkable instead of merely stated.
+ */
+export function receiptFrom(
+  report: UsageProfileReport,
+  catalogue: PricingCatalogue,
+  options: ReceiptOptions = {},
+): ReceiptDocument {
+  const lines = report.byLabelAndModel.map((slice) =>
+    lineFrom(slice.label, slice.model, slice.breakdown, catalogue),
+  );
+
+  const gaps: ReceiptGap[] = [];
+  if (report.unpricedModels.length > 0) {
+    gaps.push({
+      kind: 'unpriced',
+      models: [...report.unpricedModels],
+      calls: report.unpriced.calls,
+      inputTokens: report.unpriced.inputTokens,
+      outputTokens: report.unpriced.outputTokens,
+    });
+  }
+  if (report.skippedLines.length > 0) {
+    gaps.push({ kind: 'unread-lines', count: report.skippedLines.length });
+  }
+  if (report.span === null) gaps.push({ kind: 'no-clock' });
+
+  /*
+   * Summed across the lines rather than read off a total, because the profile
+   * keeps this per slice and a receipt reports it once for the document.
+   */
+  const assumed = report.byLabelAndModel.reduce(
+    (sum, slice) => sum + slice.breakdown.assumedWriteTtlCalls,
+    0,
+  );
+  if (assumed > 0) gaps.push({ kind: 'assumed-write-ttl', calls: assumed });
+
+  return {
+    schemaVersion: 1,
+    emittedAt: options.emittedAt?.toISOString() ?? null,
+    span: report.span === null ? null : { ...report.span },
+    counting: 'counted',
+    lines,
+    /*
+     * `report.total` already excludes what could not be priced — the profile
+     * keeps those in `unpriced` precisely so a total is never tokens from one
+     * set of calls divided by dollars from another. The receipt inherits that
+     * separation rather than re-deriving it, and `gaps` carries the size of
+     * what is missing.
+     */
+    total: { calls: report.total.calls, usd: report.total.totalUsd },
+    gaps,
+  };
+}

package/src/schemas.ts

@@ -151,6 +151,42 @@ export const CONTRACT_SCHEMAS: Record<ContractName, Record<string, unknown>> = {
     cannotSay: array,
     unpricedRecords: number,
   }),
+  'routing-measurement': doc('routing-measurement', {
+    slice: object,
+    evaluation: object,
+  }),
+  'example-pruning': doc('example-pruning', {
+    provider: string,
+    model: string,
+    selfAgreement: number,
+    recoverableTokens: number,
+    callsMade: number,
+    contributions: array,
+  }),
+  'store-inventory': doc('store-inventory', {
+    providers: array,
+    totalRecords: number,
+    span: objectOrNull,
+    possiblyDouble: number,
+    unknownVersion: number,
+    totalUsd: number,
+    unreadable: array,
+  }),
+  conformance: doc('conformance', {
+    contract: stringOrNull,
+    because: stringOrNull,
+    problems: array,
+    unavailable: array,
+    records: { type: ['number', 'null'] },
+    conforms: boolean,
+  }),
+  'watch-cycle': doc('watch-cycle', {
+    firedAtMs: number,
+    crossings: array,
+    suppressed: array,
+    abstentions: array,
+    gap: objectOrNull,
+  }),
 };
 
 /** The schema for one named contract — the object `trazum schema` prints. */

package/src/tokenizer.ts

@@ -2,20 +2,22 @@
  * Dependency-free token estimator.
  *
  * This is NOT a real tokenizer: it is a heuristic calibrated per character
- * class. It is built to keep the typical error on ordinary text
- * (English/Spanish, markdown, code) inside ±10%, which is plenty for comparing
- * two versions of the same prompt — but do NOT bill anyone from it.
+ * class, built for comparing two versions of the same prompt — but do NOT bill
+ * anyone from it.
  *
- * **That band is a design target that has not been measured.** It is printed on
- * every report and every dollar figure descends from it, and until
- * `scripts/measure-token-band.mjs` has been run against the official counting
- * endpoint, nothing in this repository establishes that it holds. It is stated
- * as one number for all text, which is a further assumption: the branches below
- * treat CJK, digits and punctuation quite differently from words, and there is
- * no reason those should land on the same accuracy.
+ * **Its accuracy is not one number, and the years it was written as one were
+ * the mistake.** The branches below treat CJK, digits and punctuation quite
+ * differently from words, and there was never a reason those should land on the
+ * same accuracy. Measured over 47 samples against the official counting
+ * endpoint they do not: the worst error is 3.2% on CJK, 5.6% on Latin prose,
+ * 25.1% on code and quoting, and 32.5% on a digit-dominant table. `band.ts`
+ * holds the bands those measurements earn and `bandFor(text)` is what a caller
+ * should print; the constant below is only the widest of them, for callers that
+ * have no text in hand.
  *
- * `test/token-band.test.js` asserts the band per text type as soon as the ground
- * truth exists. Until then it says so rather than passing quietly.
+ * `test/token-band.test.js` holds every sample against the band `bandFor` gives
+ * it, and a sample edited since it was measured fails rather than passing
+ * quietly.
  *
  * For exact numbers use `countTokensAnthropic` (the official token-counting
  * endpoint, which is free) or pass your own `TokenCounter`.
@@ -25,53 +27,47 @@ import { detectTextLanguage } from './language.js';
 import { SAFE_FETCH_INIT, checkedEndpoint } from './net.js';
 
 /**
- * The error band this estimator is published under, as a percentage.
+ * The widest band this estimator is published under, as a percentage.
  *
- * **Measured, not chosen, and it has moved three times.** It was `15` for eight
- * releases as a design target nobody had checked; the first measurement found two
- * of eight samples outside it and it went to `25`; fixing the digit divisor and
- * calibrating per language brought it back to `15`. This is the fourth value and
- * the first one that is comfortably above what the corpus actually shows.
+ * **A history worth keeping, because each value was believed at the time.** It
+ * was `15` for eight releases as a design target nobody had checked; the first
+ * measurement found two of eight samples outside it and it went to `25`; fixing
+ * the digit divisor and calibrating per language brought it back to `15`, and
+ * splitting kana from han — Japanese had been +11.2% and Chinese −3.2% under one
+ * rule — brought it to `10`. Four values, each an improvement, and all four
+ * wrong in the same way.
  *
- * ```
- * worst measured error   6.4%   (code-heavy, which nothing is fitted to)
- * published band        10%
- * ```
+ * **The corpus they were measured on was the corpus they were fitted to.**
+ * Twenty-one samples held thirteen files of Latin prose and exactly one each of
+ * code, numeric and punctuation, and those single files were where the constants
+ * came from. The worst error it could show was 6.4%, and 10 looked like a
+ * comfortable margin over it. Neither figure was about the estimator.
  *
- * **The margin is deliberate and it is not slack.** 6.4 rounded up is 7, and
- * publishing 7 would be a tighter claim than twenty-one samples across six text
- * types can support: the corpus has no Korean, no Arabic, no Cyrillic prose, no
- * mixed-script document, and a seventh text type could easily land at eight. A
- * band that becomes false the first time somebody measures something new is the
- * exact fault this whole exercise was fixing. Overstating the uncertainty is the
- * safe direction for a tool that reports money.
+ * **It is no longer one number, and this one is the widest.** A corpus of
+ * thirteen prose files and one each of code, numeric and punctuation put the
+ * band at 10, and those single files were the set the constants had been fitted
+ * to. Measured on forty-seven, the same estimator is 6% out on prose and 33%
+ * out on a CSV ledger. `bandFor` in `band.ts` is what a caller that has the
+ * text should use.
  *
- * What earned the drop from 15 was **splitting kana from han**. Every CJK
- * character was charged one token, which put Japanese at +11.2% — the worst error
- * anywhere in the corpus — while Chinese sat at −3.2% under the same rule. Kana
- * measure 0.75 tokens per character and han 1.05, and that pair takes the two
- * samples to −1.5% and +1.3%. See `KANA_TOKENS_PER_CHAR`.
- *
- * **Which samples the band rests on matters more than the number.** Eight of the
- * twenty-one had a constant fitted to them — seven Latin divisors and the digit
- * divisor — so their residuals are optimistic by construction. The two worst
- * errors in the corpus, `code-heavy` at 6.4% and `punctuation-heavy` at 5.7%, are
- * fitted to nothing at all, and they are what sets this figure.
- *
- * Exported so every report, README and tool description reads the same number. It
- * was a literal in twenty-four files before this, with the only machine-readable
- * copy in a test, and `token-band.test.js` now fails any file that states a
- * different one.
+ * This stays for the callers that do not have it — a figure covering the whole
+ * catalogue of text, which can only be the worst of them. Widening it from 10
+ * to 33 makes every claim that reads it true where it had been false, at the
+ * cost of understating the estimator on prose. That trade is deliberate: a
+ * caller with no text cannot know which it is holding, and there is only one
+ * safe direction to guess in.
  */
-export const ESTIMATE_ERROR_BAND_PCT = 10;
+export const ESTIMATE_ERROR_BAND_PCT = 33;
 
 /**
  * Whose tokenizer that band was measured against.
  *
  * The number above is not a property of the estimator; it is a property of the
- * estimator **against Claude**. Twenty-one samples, one counting endpoint, one
- * family. Trazum prices seven, and until somebody runs the harness against the
- * others nobody knows what the error is on a GPT or a Gemini prompt.
+ * estimator **against Claude**. Forty-seven samples, one counting endpoint, one
+ * family. Trazum prices seven, and the two that have since been run are far
+ * outside anything published here: DeepSeek 94.5% at worst, Mistral 103.1%. On
+ * a GPT or a Gemini prompt nobody has measured it at all, and
+ * `measuredForeignError` answers null rather than the nearest number.
  *
  * Exported as a name rather than left implicit in a comment because the band
  * had already leaked out of its domain in three places: an advisory that told a
@@ -173,6 +169,34 @@ const DIVISOR_BY_LANGUAGE: Readonly<Record<string, number>> = {
 const KANA_TOKENS_PER_CHAR = 0.75;
 const HAN_TOKENS_PER_CHAR = 1.05;
 
+/**
+ * Hangul, measured at last.
+ *
+ * The comment above used to end *"Hangul keeps the old cost of 1, because
+ * nothing here measures Korean. Guessing it from Japanese would be inventing a
+ * figure."* That was right, and it stayed right for exactly as long as nobody
+ * measured Korean. `cjk-korean.txt` now does: at 1 token per character the
+ * estimate came out **20.0% under** — 232 against 290 — and 1.20 takes it to
+ * -10.0%.
+ *
+ * **1.20 was the one-sample answer and it was wrong by ten points.** A second
+ * Korean sample in a different register — a deployment review against support
+ * copy — put both at -10.6% and -10.0% under it, and solving the constant on
+ * the two together lands on 1.35, where both come out at 0.0%.
+ *
+ * Two independent texts agreeing to within four tenths of a point across the
+ * whole search is what makes this a property of Hangul rather than a fit to a
+ * file. Their residuals move in lockstep at every candidate value: -10.6/-10.0
+ * at 1.20, -3.5/-3.1 at 1.30, 3.2/3.4 at 1.40. One sample cannot show that and
+ * two can, which is the entire argument for measuring more of the thin classes
+ * rather than tuning harder on the thin ones.
+ *
+ * Still in-sample: the honest test is a third Korean prompt, and the corpus
+ * grows one at a time.
+ */
+const HANGUL_TOKENS_PER_CHAR = 1.35;
+const HANGUL = /[가-힯]/;
+
 /**
  * What a prompt gets when the language could not be told.
  *
@@ -248,7 +272,11 @@ export function estimateTokens(text: string): number {
        * where the loop happens to break, not of what the text costs.
        */
       while (i < chars.length && CJK.test(chars[i]!)) {
-        cjkTokens += KANA.test(chars[i]!) ? KANA_TOKENS_PER_CHAR : HAN_TOKENS_PER_CHAR;
+        cjkTokens += KANA.test(chars[i]!)
+          ? KANA_TOKENS_PER_CHAR
+          : HANGUL.test(chars[i]!)
+            ? HANGUL_TOKENS_PER_CHAR
+            : HAN_TOKENS_PER_CHAR;
         i++;
       }
       continue;
@@ -315,7 +343,29 @@ export function estimateTokens(text: string): number {
       total += 1;
       i++;
     } else {
-      total += Math.ceil(n / 2);
+      /**
+       * One token per symbol, not one per two.
+       *
+       * Two was the shipped value and every symbol-dense sample in the corpus
+       * undercounted under it, in the same direction, by amounts that grow with
+       * density: punctuation-heavy -5.7%, code-heavy -6.4%,
+       * punctuation-markup -11.4%, code-sql -25.6%, code-shell -29.8%. Five
+       * samples agreeing on a direction is a shape, not a fit — a merge table
+       * covers `, ` and `. ` and covers `${`, `"$`, `--` and `&#8209;` far less
+       * well, and shell and SQL are made of the second kind.
+       *
+       * Searched over the whole corpus rather than the class it helps, so a
+       * value that fixed code by wrecking prose could not look like a win: at
+       * 1.0 the samples outside the published band drop from five to three and
+       * the mean error from 6.6% to 5.1%, with no sample moved more than a
+       * point in the wrong direction.
+       *
+       * The search wanted to go below 1.0 and was not allowed to. Below one is
+       * more than a token per symbol, which may well be true of SQL — code-sql
+       * is still 24.9% under — but it is a claim about a class this corpus has
+       * two samples of, and two samples do not earn a constant.
+       */
+      total += Math.ceil(n / 1);
     }
   }