@sdxc/spam 0.0.0-pre.1

package/dist/bayes/classify.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The arithmetic of the classifier: Robinson's smoothed per-token spam probability and Fisher's
+ * method for combining the most telling tokens into one probability. Kept free of storage so the
+ * numbers can be checked on their own.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import type { TokenStore } from "./store.js";
+/** The knobs of {@link classify}. */
+export interface ClassifyOptions {
+    /** How many documents of weight the prior carries against a token's own counts. */
+    strength: number;
+    /** The probability assumed for a token never seen. */
+    prior: number;
+    /** The most tokens that enter the combination. */
+    interestingTokens: number;
+    /** How far from 0.5 a token's probability must sit to enter the combination. */
+    minDeviation: number;
+}
+/** One token that entered the combination. */
+export interface Clue {
+    token: string;
+    probability: number;
+}
+/** The combined verdict and the tokens behind it, most telling first. */
+export interface Classification {
+    probability: number;
+    clues: Clue[];
+}
+/**
+ * Combines the most telling of `tokens` into a spam probability. A token's probability is the
+ * ratio of its spam and ham document frequencies, pulled toward `prior` in proportion to how
+ * rarely it was seen. With no telling token the answer is 0.5, which no cut acts on.
+ *
+ * @param tokens - The submission's distinct tokens
+ * @param counts - What the store holds for them
+ */
+export declare function classify(tokens: readonly string[], counts: TokenStore.Counts, options: ClassifyOptions): Classification;

package/dist/bayes/classify.js

@@ -0,0 +1,72 @@
+/**
+ * The distance from 0 and 1 a token probability is held at before taking logarithms, so a
+ * `strength` of 0 with a token seen only in one label yields a finite combination.
+ */
+const PROBABILITY_FLOOR = 1e-6;
+/**
+ * Combines the most telling of `tokens` into a spam probability. A token's probability is the
+ * ratio of its spam and ham document frequencies, pulled toward `prior` in proportion to how
+ * rarely it was seen. With no telling token the answer is 0.5, which no cut acts on.
+ *
+ * @param tokens - The submission's distinct tokens
+ * @param counts - What the store holds for them
+ */
+export function classify(tokens, counts, options) {
+    let clues = [];
+    for (let token of tokens) {
+        let probability = tokenProbability(counts.tokens.get(token), counts.documents, options);
+        if (Math.abs(probability - 0.5) >= options.minDeviation)
+            clues.push({ token, probability });
+    }
+    clues.sort((a, b) => Math.abs(b.probability - 0.5) - Math.abs(a.probability - 0.5));
+    clues = clues.slice(0, options.interestingTokens);
+    return { probability: fisher(clues.map((clue) => clue.probability)), clues };
+}
+/**
+ * Robinson's f(w) = (s·x + n·p(w)) / (s + n), where p(w) compares the token's frequency among
+ * spam documents with its frequency among ham documents and n is how many documents held it.
+ */
+function tokenProbability(tally, documents, options) {
+    let spam = tally?.spam ?? 0;
+    let ham = tally?.ham ?? 0;
+    let seen = spam + ham;
+    if (seen === 0)
+        return options.prior;
+    let spamFrequency = documents.spam > 0 ? Math.min(spam / documents.spam, 1) : 0;
+    let hamFrequency = documents.ham > 0 ? Math.min(ham / documents.ham, 1) : 0;
+    let ratio = spamFrequency / (spamFrequency + hamFrequency);
+    return (options.strength * options.prior + seen * ratio) / (options.strength + seen);
+}
+/**
+ * Fisher's method as SpamBayes applies it: one chi-squared test for "these tokens are spammy"
+ * and one for "these tokens are hammy", averaged so disagreement lands near 0.5.
+ */
+function fisher(probabilities) {
+    if (probabilities.length === 0)
+        return 0.5;
+    let spamLog = 0;
+    let hamLog = 0;
+    for (let raw of probabilities) {
+        let probability = Math.min(Math.max(raw, PROBABILITY_FLOOR), 1 - PROBABILITY_FLOOR);
+        spamLog += Math.log(1 - probability);
+        hamLog += Math.log(probability);
+    }
+    let freedom = 2 * probabilities.length;
+    let spamminess = 1 - chiSquaredSurvival(-2 * spamLog, freedom);
+    let hamminess = 1 - chiSquaredSurvival(-2 * hamLog, freedom);
+    return (1 + spamminess - hamminess) / 2;
+}
+/**
+ * The probability that a chi-squared variable with an even `freedom` exceeds `value`, by the
+ * closed-form series for even degrees of freedom, clamped to 1 against rounding.
+ */
+function chiSquaredSurvival(value, freedom) {
+    let half = value / 2;
+    let term = Math.exp(-half);
+    let sum = term;
+    for (let index = 1; index < freedom / 2; index++) {
+        term *= half / index;
+        sum += term;
+    }
+    return Math.min(sum, 1);
+}

package/dist/bayes/data-table.d.ts

@@ -0,0 +1,58 @@
+/**
+ * A token store over `remix/data-table`, for D1 and Durable Object SQLite alike. Every write is
+ * an `insert … on conflict do update` adding to the stored counts, so concurrent reports never
+ * lose an increment without the transactions D1 lacks. The host app owns the table's migration.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import type { Result } from "@sdxc/result";
+import type { Database, TableRow } from "remix/data-table";
+import type { Label } from "../check.js";
+import { SpamCheckError } from "../check.js";
+import type { TokenStore } from "./store.js";
+/**
+ * One row per token with the number of spam and ham documents it appeared in. The row for
+ * {@link DOCUMENTS_TOKEN} holds the document totals. See {@link SPAM_TOKENS_SCHEMA_SQL}.
+ */
+export declare const spamTokens: import("remix/data-table").Table<"spam_tokens", {
+    token: import("remix/data-table").ColumnBuilder<string>;
+    spam: import("remix/data-table").ColumnBuilder<number>;
+    ham: import("remix/data-table").ColumnBuilder<number>;
+}, readonly "token"[]>;
+/** A token's counts, as loaded from {@link spamTokens}. */
+export type SpamTokenRow = TableRow<typeof spamTokens>;
+/**
+ * SQL creating the table {@link DataTableTokenStore} needs, for a host app to paste into its own
+ * migration. The primary key is the only index, since every read and write is by token.
+ */
+export declare const SPAM_TOKENS_SCHEMA_SQL = "create table spam_tokens (\n\ttoken text primary key,\n\tspam integer not null default 0,\n\tham integer not null default 0\n);";
+/**
+ * The row holding the document totals. Tokenized content never contains `@` outside a prefixed
+ * token, so this key never collides with a real token.
+ */
+export declare const DOCUMENTS_TOKEN = "@documents";
+/**
+ * Stores counts in {@link spamTokens}. A report writes its tokens in statements of at most
+ * {@link TOKENS_PER_STATEMENT}, with the document total in the last one, so a failure part way
+ * undercounts a document's tokens and never counts a document whose tokens were not written.
+ */
+export declare class DataTableTokenStore implements TokenStore {
+    #private;
+    /**
+     * @param db - A database whose schema includes {@link spamTokens}; one per tenant
+     */
+    constructor(db: Database);
+    /**
+     * Reads the requested tokens and the totals row in batches of {@link TOKENS_PER_STATEMENT}.
+     *
+     * @returns The counts, or an `unavailable` error when a query fails
+     */
+    read(tokens: readonly string[]): Promise<Result<TokenStore.Counts, SpamCheckError>>;
+    /**
+     * Adds one document with single-statement upserts; see {@link DataTableTokenStore}.
+     *
+     * @returns Success, or an `unavailable` error when a write fails
+     */
+    increment(tokens: readonly string[], label: Label): Promise<Result<void, SpamCheckError>>;
+}

package/dist/bayes/data-table.js

@@ -0,0 +1,123 @@
+import { failure, success } from "@sdxc/result";
+import { column as c, inList, rawSql, table } from "remix/data-table";
+import { SpamCheckError } from "../check.js";
+/**
+ * One row per token with the number of spam and ham documents it appeared in. The row for
+ * {@link DOCUMENTS_TOKEN} holds the document totals. See {@link SPAM_TOKENS_SCHEMA_SQL}.
+ */
+export const spamTokens = table({
+    name: "spam_tokens",
+    primaryKey: ["token"],
+    columns: {
+        token: c.text(),
+        spam: c.integer(),
+        ham: c.integer(),
+    },
+});
+/**
+ * SQL creating the table {@link DataTableTokenStore} needs, for a host app to paste into its own
+ * migration. The primary key is the only index, since every read and write is by token.
+ */
+export const SPAM_TOKENS_SCHEMA_SQL = `create table spam_tokens (
+	token text primary key,
+	spam integer not null default 0,
+	ham integer not null default 0
+);`;
+/**
+ * The row holding the document totals. Tokenized content never contains `@` outside a prefixed
+ * token, so this key never collides with a real token.
+ */
+export const DOCUMENTS_TOKEN = "@documents";
+/** Tokens bound per statement, keeping each query under D1's limit of 100 bound parameters. */
+const TOKENS_PER_STATEMENT = 90;
+/**
+ * Stores counts in {@link spamTokens}. A report writes its tokens in statements of at most
+ * {@link TOKENS_PER_STATEMENT}, with the document total in the last one, so a failure part way
+ * undercounts a document's tokens and never counts a document whose tokens were not written.
+ */
+export class DataTableTokenStore {
+    #db;
+    /**
+     * @param db - A database whose schema includes {@link spamTokens}; one per tenant
+     */
+    constructor(db) {
+        this.#db = db;
+    }
+    /**
+     * Reads the requested tokens and the totals row in batches of {@link TOKENS_PER_STATEMENT}.
+     *
+     * @returns The counts, or an `unavailable` error when a query fails
+     */
+    async read(tokens) {
+        let keys = [DOCUMENTS_TOKEN, ...new Set(tokens)];
+        let rows = [];
+        try {
+            for (let batch of chunk(keys, TOKENS_PER_STATEMENT)) {
+                rows.push(...(await this.#db.findMany(spamTokens, { where: inList("token", batch) })));
+            }
+        }
+        catch (error) {
+            return failure(storeError("could not be read", error));
+        }
+        let documents = { spam: 0, ham: 0 };
+        let found = new Map();
+        for (let row of rows) {
+            let tally = { spam: storedCount(row.spam), ham: storedCount(row.ham) };
+            if (row.token === DOCUMENTS_TOKEN)
+                documents = tally;
+            else
+                found.set(row.token, tally);
+        }
+        return success({ documents, tokens: found });
+    }
+    /**
+     * Adds one document with single-statement upserts; see {@link DataTableTokenStore}.
+     *
+     * @returns Success, or an `unavailable` error when a write fails
+     */
+    async increment(tokens, label) {
+        let batches = chunk([...new Set(tokens)], TOKENS_PER_STATEMENT);
+        if (batches.length === 0)
+            batches.push([]);
+        let row = label === "spam" ? "(?, 1, 0)" : "(?, 0, 1)";
+        try {
+            for (let [index, batch] of batches.entries()) {
+                let keys = index === batches.length - 1 ? [...batch, DOCUMENTS_TOKEN] : batch;
+                await this.#db.exec(rawSql(`insert into spam_tokens (token, spam, ham) values ${keys.map(() => row).join(", ")}
+on conflict (token) do update set
+	spam = spam_tokens.spam + excluded.spam,
+	ham = spam_tokens.ham + excluded.ham`, keys));
+            }
+        }
+        catch (error) {
+            return failure(storeError("could not be written", error));
+        }
+        return success(undefined);
+    }
+}
+/**
+ * Splits `items` into consecutive batches of at most `size`.
+ *
+ * @template T - The item type
+ * @returns No batches for an empty list
+ */
+function chunk(items, size) {
+    let batches = [];
+    for (let start = 0; start < items.length; start += size) {
+        batches.push(items.slice(start, start + size));
+    }
+    return batches;
+}
+/**
+ * Coerces a stored count that a driver may hand back as text or a bigint, reading anything
+ * unusable as zero so one bad row leaves the rest of the classification intact.
+ */
+function storedCount(value) {
+    let count = Number(value);
+    return Number.isFinite(count) && count > 0 ? Math.trunc(count) : 0;
+}
+/** Wraps a driver error as the `unavailable` failure the filter records and moves past. */
+function storeError(what, cause) {
+    let reason = cause instanceof Error ? cause.message : String(cause);
+    return new SpamCheckError("unavailable", `the spam token table ${what}: ${reason}`);
+}

package/dist/bayes/memory.d.ts

@@ -0,0 +1,18 @@
+/**
+ * An in-process token store for tests and local development. It is the reference for the counts
+ * a persistent store keeps, with state that lives and dies with the instance.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import type { Result } from "@sdxc/result";
+import type { Label, SpamCheckError } from "../check.js";
+import type { TokenStore } from "./store.js";
+/** Keeps counts in a `Map` owned by the instance, so two instances never share training. */
+export declare class MemoryTokenStore implements TokenStore {
+    #private;
+    /** Answers copies, so a caller mutating the result leaves the stored counts intact. */
+    read(tokens: readonly string[]): Promise<Result<TokenStore.Counts, SpamCheckError>>;
+    /** Counts each distinct token once, however often `tokens` repeats it. */
+    increment(tokens: readonly string[], label: Label): Promise<Result<void, SpamCheckError>>;
+}

package/dist/bayes/memory.js

@@ -0,0 +1,26 @@
+import { success } from "@sdxc/result";
+/** Keeps counts in a `Map` owned by the instance, so two instances never share training. */
+export class MemoryTokenStore {
+    #documents = { spam: 0, ham: 0 };
+    #tokens = new Map();
+    /** Answers copies, so a caller mutating the result leaves the stored counts intact. */
+    async read(tokens) {
+        let found = new Map();
+        for (let token of tokens) {
+            let tally = this.#tokens.get(token);
+            if (tally !== undefined)
+                found.set(token, { ...tally });
+        }
+        return success({ documents: { ...this.#documents }, tokens: found });
+    }
+    /** Counts each distinct token once, however often `tokens` repeats it. */
+    async increment(tokens, label) {
+        for (let token of new Set(tokens)) {
+            let tally = this.#tokens.get(token) ?? { spam: 0, ham: 0 };
+            tally[label] += 1;
+            this.#tokens.set(token, tally);
+        }
+        this.#documents[label] += 1;
+        return success(undefined);
+    }
+}

package/dist/bayes/store.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The storage contract behind the classifier: per-token counts of the spam and ham documents a
+ * token appeared in, plus how many documents of each label were reported. Keeping it to one read
+ * and one increment lets any backend implement it with single statements.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import type { Result } from "@sdxc/result";
+import type { Label, SpamCheckError } from "../check.js";
+/**
+ * Where the classifier keeps what moderators taught it. A multi-tenant app builds one store per
+ * tenant database, so each tenant's reports shape only that tenant's verdicts.
+ */
+export interface TokenStore {
+    /**
+     * Loads the counts for `tokens` and the document totals. A token never reported is absent
+     * from the returned map, which the classifier reads as zero of each label.
+     */
+    read(tokens: readonly string[]): Promise<Result<TokenStore.Counts, SpamCheckError>>;
+    /**
+     * Adds one `label` document: every token's count for that label and the label's document
+     * total each rise by one. Callers pass distinct tokens.
+     */
+    increment(tokens: readonly string[], label: Label): Promise<Result<void, SpamCheckError>>;
+}
+/** The types a {@link TokenStore} returns. */
+export declare namespace TokenStore {
+    /** How many documents of each label an entry covers. */
+    interface Tally {
+        spam: number;
+        ham: number;
+    }
+    /** The answer to {@link TokenStore.read}. */
+    interface Counts {
+        /** Every document ever reported, by label. */
+        documents: Tally;
+        /** The requested tokens that have been reported at least once. */
+        tokens: Map<string, Tally>;
+    }
+}

package/dist/bayes/tokens.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Turns a submission into the tokens the classifier counts: content words, linked hosts and the
+ * author's email domain. Classifying and training share this one function, so a token learned
+ * from a report is spelled exactly as the check later looks it up.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import type { Submission } from "../check.js";
+/**
+ * The distinct tokens of `submission`, hosts first, then the email domain, then words in order of
+ * appearance, up to `maxTokens`. Hosts drop a leading `www.` and carry the `host:` prefix, the
+ * domain carries `email-domain:`, and words are lowercased and kept within the length window.
+ *
+ * @example tokenize({ content: "Buy at https://www.shop.example" }); // ["host:shop.example", "buy"]
+ */
+export declare function tokenize(submission: Submission, options?: tokenize.Options): string[];
+/** The types {@link tokenize} reads. */
+export declare namespace tokenize {
+    /** How content becomes tokens; the classifier and its training must share these values. */
+    interface Options {
+        /** Shorter words carry no meaning worth counting. @default 3 */
+        minLength?: number;
+        /** Longer words are hashes, encodings or keyboard mashing. @default 24 */
+        maxLength?: number;
+        /** Bounds the store reads and writes a single submission can cause. @default 200 */
+        maxTokens?: number;
+        /** Counts the author's email domain as an `email-domain:` token. @default true */
+        emailDomain?: boolean;
+    }
+}

package/dist/bayes/tokens.js

@@ -0,0 +1,42 @@
+import { extractLinks, extractWords } from "../lib/text.js";
+/** Apostrophes a word starts or ends with, which quote the word rather than belong to it. */
+const EDGE_APOSTROPHES = /^['’]+|['’]+$/g;
+/**
+ * The distinct tokens of `submission`, hosts first, then the email domain, then words in order of
+ * appearance, up to `maxTokens`. Hosts drop a leading `www.` and carry the `host:` prefix, the
+ * domain carries `email-domain:`, and words are lowercased and kept within the length window.
+ *
+ * @example tokenize({ content: "Buy at https://www.shop.example" }); // ["host:shop.example", "buy"]
+ */
+export function tokenize(submission, options = {}) {
+    let minLength = options.minLength ?? 3;
+    let maxLength = options.maxLength ?? 24;
+    let maxTokens = options.maxTokens ?? 200;
+    let emailDomain = options.emailDomain ?? true;
+    let tokens = new Set();
+    let urls = extractLinks(submission.content);
+    let authorUrl = submission.author?.url;
+    if (authorUrl !== undefined && URL.canParse(authorUrl))
+        urls.push(new URL(authorUrl));
+    for (let url of urls) {
+        let host = url.hostname.toLowerCase().replace(/^www\./, "");
+        if (host.length > 0)
+            tokens.add(`host:${host}`);
+    }
+    let email = submission.author?.email;
+    if (emailDomain && email !== undefined) {
+        let domain = email
+            .slice(email.lastIndexOf("@") + 1)
+            .trim()
+            .toLowerCase();
+        if (email.includes("@") && domain.length > 0)
+            tokens.add(`email-domain:${domain}`);
+    }
+    for (let raw of extractWords(submission.content)) {
+        let word = raw.replace(EDGE_APOSTROPHES, "").toLowerCase();
+        let length = Array.from(word).length;
+        if (length >= minLength && length <= maxLength)
+            tokens.add(word);
+    }
+    return [...tokens].slice(0, maxTokens);
+}

package/dist/bayes.d.ts

@@ -0,0 +1,43 @@
+import type { TokenStore } from "./bayes/store.js";
+import type { SpamCheck } from "./check.js";
+import { tokenize } from "./bayes/tokens.js";
+export type { SpamTokenRow } from "./bayes/data-table.js";
+export type { TokenStore } from "./bayes/store.js";
+export { DataTableTokenStore, SPAM_TOKENS_SCHEMA_SQL, spamTokens } from "./bayes/data-table.js";
+export { MemoryTokenStore } from "./bayes/memory.js";
+export { tokenize } from "./bayes/tokens.js";
+/**
+ * Scores a submission by what moderators reported before. It runs in the `local` stage because
+ * it reads the app's own storage, never a third party, and that read is its only await. Until the
+ * store holds `minDocuments` reports of each label it emits nothing, so a fresh install relies on
+ * the rules alone. `report` trains it; build it per tenant from that tenant's store.
+ *
+ * @example createSpamFilter({ checks: [...DEFAULT_RULES, bayes({ store: new DataTableTokenStore(ctx.db) })] })
+ */
+export declare function bayes(options: bayes.Options): SpamCheck;
+/** The types {@link bayes} reads. */
+export declare namespace bayes {
+    /** Where counts live, when the classifier speaks, and how much its verdicts weigh. */
+    interface Options extends tokenize.Options {
+        /** One per tenant in a multi-tenant app, so training never crosses tenants. */
+        store: TokenStore;
+        /** Reports of each label required before any signal. @default 20 */
+        minDocuments?: number;
+        /** The spam probability at or above which `bayes.spam` is emitted. @default 0.9 */
+        spamCut?: number;
+        /** The spam probability at or below which `bayes.ham` is emitted. @default 0.2 */
+        hamCut?: number;
+        /** @default 6 */
+        spamScore?: number;
+        /** Negative, so a submission the site's history calls ham is pulled down. @default -4 */
+        hamScore?: number;
+        /** How many documents of weight the prior carries against a rarely seen token. @default 1 */
+        strength?: number;
+        /** The probability assumed for a token never seen. @default 0.5 */
+        prior?: number;
+        /** The most telling tokens that enter the combination. @default 15 */
+        interestingTokens?: number;
+        /** How far from 0.5 a token must sit to enter the combination. @default 0.1 */
+        minDeviation?: number;
+    }
+}

package/dist/bayes.js

@@ -0,0 +1,67 @@
+import { isFailure, success } from "@sdxc/result";
+import { classify } from "./bayes/classify.js";
+import { tokenize } from "./bayes/tokens.js";
+export { DataTableTokenStore, SPAM_TOKENS_SCHEMA_SQL, spamTokens } from "./bayes/data-table.js";
+export { MemoryTokenStore } from "./bayes/memory.js";
+export { tokenize } from "./bayes/tokens.js";
+/** How many of the most telling tokens a signal's detail names. */
+const DETAIL_TOKENS = 5;
+/**
+ * Scores a submission by what moderators reported before. It runs in the `local` stage because
+ * it reads the app's own storage, never a third party, and that read is its only await. Until the
+ * store holds `minDocuments` reports of each label it emits nothing, so a fresh install relies on
+ * the rules alone. `report` trains it; build it per tenant from that tenant's store.
+ *
+ * @example createSpamFilter({ checks: [...DEFAULT_RULES, bayes({ store: new DataTableTokenStore(ctx.db) })] })
+ */
+export function bayes(options) {
+    let store = options.store;
+    let minDocuments = options.minDocuments ?? 20;
+    let spamCut = options.spamCut ?? 0.9;
+    let hamCut = options.hamCut ?? 0.2;
+    let spamScore = options.spamScore ?? 6;
+    let hamScore = options.hamScore ?? -4;
+    let classifyOptions = {
+        strength: options.strength ?? 1,
+        prior: options.prior ?? 0.5,
+        interestingTokens: options.interestingTokens ?? 15,
+        minDeviation: options.minDeviation ?? 0.1,
+    };
+    return {
+        name: "bayes",
+        stage: "local",
+        /**
+         * Emits `bayes.spam` above `spamCut`, `bayes.ham` below `hamCut`, and nothing between them
+         * or before the cold-start gate opens. A failed store read is a failure, never a verdict.
+         */
+        async check(submission) {
+            let tokens = tokenize(submission, options);
+            let read = await store.read(tokens);
+            if (isFailure(read))
+                return read;
+            let counts = read.data;
+            if (counts.documents.spam < minDocuments || counts.documents.ham < minDocuments) {
+                return success([]);
+            }
+            let { probability, clues } = classify(tokens, counts, classifyOptions);
+            let isSpam = probability >= spamCut;
+            if (!isSpam && probability > hamCut)
+                return success([]);
+            let named = clues
+                .filter((clue) => (isSpam ? clue.probability > 0.5 : clue.probability < 0.5))
+                .slice(0, DETAIL_TOKENS)
+                .map((clue) => clue.token);
+            return success([
+                {
+                    check: isSpam ? "bayes.spam" : "bayes.ham",
+                    score: isSpam ? spamScore : hamScore,
+                    detail: `spam probability ${probability.toFixed(3)}; tokens: ${named.join(", ")}`,
+                },
+            ]);
+        },
+        /** Counts the submission's tokens under `label`, tokenized exactly as `check` reads them. */
+        async report(submission, label) {
+            return await store.increment(tokenize(submission, options), label);
+        },
+    };
+}