@needmoretruth/nmts-cli 0.17.2 → 0.34.2

package/dist/stdout.d.ts

@@ -0,0 +1,38 @@
+/** What `--out` is spelled as when the file goes to stdout. The spelling every tool shares. */
+export declare const STDOUT_TARGET = "-";
+/** Somewhere a whole file can be handed to, once. */
+export interface ByteDestination {
+    /** True when these bytes would land on a terminal rather than a pipe, a file or another program. */
+    isTerminal: boolean;
+    /** Resolves when the bytes have been handed over; rejects with the reason they were not. */
+    write(bytes: Uint8Array): Promise<void>;
+}
+/**
+ * Whether these bytes can go to a terminal without the terminal acting on them.
+ *
+ * ⛔ A TERMINAL EXECUTES WHAT IT IS SENT. An escape sequence stored in a file can retitle the
+ *    window, blank the screen, change what the reader's next keystrokes mean, and on terminals
+ *    that answer queries it can put text of its choosing into their next command line. So the
+ *    question is not "will this look like rubbish" — it is "does this contain instructions", and
+ *    the answer decides whether the bytes are refused or written. A pipe is a different question
+ *    and gets a different answer: a program reading this is expected to handle whatever it asked
+ *    for, and refusing binary there would make the whole option useless.
+ *
+ * ⚠ Tab, newline and carriage return are the three control characters that mean in a terminal
+ *   exactly what they mean in a text file, so they pass.
+ *
+ * ⚠ Bytes that are not well-formed UTF-8 fail too, and not for tidiness: what a terminal does with
+ *   a broken sequence is its own business, and this is somebody else's terminal.
+ */
+export declare function readableOnATerminal(bytes: Uint8Array): boolean;
+/** This program's own stdout, as a destination. */
+export declare function processStdout(): ByteDestination;
+/**
+ * Hand the whole file over, refusing rather than writing bytes a terminal would act on.
+ *
+ * Answers false when the program reading it closed the pipe before the file was done — `nmts get
+ * big.bin --out - | head -c 100` is an ordinary thing to do, and the reader that stopped listening
+ * is the one that decided it had enough. Every other failure throws: a caller must not be able to
+ * mistake "the disk filled up half way" for "handed over".
+ */
+export declare function handOver(bytes: Uint8Array, to: ByteDestination): Promise<boolean>;

package/dist/storage-control-chain.d.ts

@@ -0,0 +1,38 @@
+import { Transaction } from "@mysten/sui/transactions";
+import type { Network } from "./network.ts";
+import type { StorageRead } from "./commands/wallet-storage.ts";
+export type StorageOpShape = {
+    kind: "splitSize";
+    objectId: string;
+    keepBytes: number;
+} | {
+    kind: "splitEpoch";
+    objectId: string;
+    splitEpoch: number;
+} | {
+    kind: "fuse";
+    first: string;
+    second: string;
+    how: "amount" | "periods";
+} | {
+    kind: "transfer";
+    objectId: string;
+    to: string;
+};
+/** The transaction one shape is, for `sender`. */
+export declare function storageOpTransaction(shape: StorageOpShape, input: {
+    walrusPackageId: string;
+    sender: string;
+}): Transaction;
+/** What the dry run said: a fee, or the chain's own reason for refusing. */
+export interface DryRunVerdict {
+    feeMist: bigint | null;
+    refusal: string | null;
+}
+/** What the command reads before it prints a review, and the seam a test replaces. */
+export interface StorageOpsReads {
+    readStorage(address: string): Promise<StorageRead>;
+    walrusPackageId(): Promise<string>;
+    dryRun(shape: StorageOpShape, sender: string): Promise<DryRunVerdict>;
+}
+export declare function storageOpsReads(network: Network): StorageOpsReads;

package/dist/storage-control-chain.js

@@ -0,0 +1,78 @@
+// The chain behind `nmts wallet storage split|merge|transfer`: one builder per shape, the dry run
+// that prices it and says whether the contract would take it, and the package to call.
+//
+// ⛔ ONE BUILDER FOR THE FEE AND THE SIGNATURE — the rule `wallet-send-chain.ts` keeps. What the
+//    review priced is what `wallet-sign.ts` signs.
+//
+// ⛔ THE CALLS ARE WRITTEN BY HAND, as `shared/lib/storage-control/reuse.ts` writes `split_by_size`:
+//    the SDK exports the `Storage` struct and no function wrappers, and its generated bindings are
+//    not on an exported path. The signatures are the contract's (`storage_resource.move`):
+//      · `split_by_size(&mut Storage, u64)  → Storage`  self keeps `split_size`; the rest is returned
+//      · `split_by_epoch(&mut Storage, u32) → Storage`  self keeps [start, split); [split, end) is returned
+//      · `fuse_amount(&mut Storage, Storage)`            same period; the second's size joins the first
+//      · `fuse_periods(&mut Storage, Storage)`           same size, adjacent periods; the second is consumed
+//    ⛔ A returned resource must be transferred or the transaction is refused at assembly for an
+//       unused value; a consumed one needs nothing. The dry run is the final judge of every rule.
+import { Transaction } from "@mysten/sui/transactions";
+import { walrusClient, netGasFee } from "./extend-chain.js";
+import { splitStorageToFit } from "./shared/lib/storage-control/reuse.js";
+/** The transaction one shape is, for `sender`. */
+export function storageOpTransaction(shape, input) {
+    const tx = new Transaction();
+    tx.setSender(input.sender);
+    switch (shape.kind) {
+        case "splitSize":
+            return splitStorageToFit({ walrusPackageId: input.walrusPackageId, storageObjectId: shape.objectId, keepBytes: shape.keepBytes, owner: input.sender }, tx);
+        case "splitEpoch": {
+            const later = tx.moveCall({
+                package: input.walrusPackageId,
+                module: "storage_resource",
+                function: "split_by_epoch",
+                arguments: [tx.object(shape.objectId), tx.pure.u32(shape.splitEpoch)],
+            });
+            tx.transferObjects([later], input.sender);
+            return tx;
+        }
+        case "fuse":
+            tx.moveCall({
+                package: input.walrusPackageId,
+                module: "storage_resource",
+                function: shape.how === "amount" ? "fuse_amount" : "fuse_periods",
+                arguments: [tx.object(shape.first), tx.object(shape.second)],
+            });
+            return tx;
+        case "transfer":
+            tx.transferObjects([tx.object(shape.objectId)], shape.to);
+            return tx;
+    }
+}
+export function storageOpsReads(network) {
+    const client = walrusClient(network);
+    return {
+        async readStorage(address) {
+            return (await import("./wallet-storage-chain.js")).readWalletStorage(network, address);
+        },
+        async walrusPackageId() {
+            return (await client.walrus.systemObject()).package_id;
+        },
+        async dryRun(shape, sender) {
+            try {
+                const walrusPackageId = await this.walrusPackageId();
+                const bytes = await storageOpTransaction(shape, { walrusPackageId, sender }).build({ client });
+                const { effects } = await client.dryRunTransactionBlock({ transactionBlock: bytes });
+                if (effects.status.status !== "success") {
+                    return { feeMist: null, refusal: effects.status.error ?? "the chain gave no reason" };
+                }
+                return { feeMist: netGasFee(effects.gasUsed), refusal: null };
+            }
+            catch (error) {
+                // ⚠ A refusal at ASSEMBLY (a wrong argument, an object that is not this wallet's) is an
+                //   answer the person needs; a node that did not answer is not, and is said as unmeasured.
+                const message = error instanceof Error ? error.message : String(error);
+                return /abort|MoveAbort|InsufficientGas|ObjectNotFound|IncorrectUserSignature|not owned/i.test(message)
+                    ? { feeMist: null, refusal: message }
+                    : { feeMist: null, refusal: null };
+            }
+        },
+    };
+}

package/dist/sui-rpc.d.ts

@@ -0,0 +1,15 @@
+import { JsonRpcHTTPTransport } from "@mysten/sui/jsonRpc";
+/**
+ * A Sui transport that asks the network's hosts in order.
+ *
+ * ⭐ 2026-09-01. There used to be one host per network, and on that morning
+ * the testnet one was measured dead — `rpc-testnet.suiscan.xyz` completes the TCP handshake in
+ * 31 ms and then sends nothing for twelve seconds, three times running. It had been that way for
+ * eleven days, so every command that needed the shard count on testnet had simply stopped.
+ *
+ * ⚠ One transport per client on purpose: the host that answered becomes the one asked first, and
+ *   sharing that state across clients would let one command's bad luck redirect every other. The
+ *   flip side is that a recovered first host is not noticed until the process restarts — that is
+ *   the price of not probing a node nobody asked us to talk to.
+ */
+export declare function suiRpcTransport(network: string): JsonRpcHTTPTransport;

package/dist/sui-rpc.js

@@ -0,0 +1,59 @@
+// The chain transport: which Sui node a command talks to, and what happens when it does not answer.
+//
+// ⛔ WHY THIS IS ITS OWN FILE AND NOT PART OF walrus.ts. `walrus.ts` holds the host tables, and it
+//    is loaded by EVERY invocation including `nmts --help`. Importing the Sui SDK there pulled 150
+//    modules into a command that prints text and exits — `deploy/check-cli-startup.mjs` measured it
+//    and failed the build, which is exactly what that gate is for. The SDK is imported here, and
+//    only the commands that actually reach the chain import this.
+//
+// ⛔ NOT A RETRIER. Each host is asked once. Anything other than "no answer" — any 4xx that is not
+//    429 — is an answer, and asking a different node the same question gets the same one.
+import { JsonRpcHTTPTransport } from "@mysten/sui/jsonRpc";
+import { suiRpcHosts } from "./walrus.js";
+/** HTTP statuses that mean "no answer came", the only ones worth asking a second node about. */
+function worthAnotherHost(status) {
+    return status >= 500 || status === 429;
+}
+/**
+ * A Sui transport that asks the network's hosts in order.
+ *
+ * ⭐ 2026-09-01. There used to be one host per network, and on that morning
+ * the testnet one was measured dead — `rpc-testnet.suiscan.xyz` completes the TCP handshake in
+ * 31 ms and then sends nothing for twelve seconds, three times running. It had been that way for
+ * eleven days, so every command that needed the shard count on testnet had simply stopped.
+ *
+ * ⚠ One transport per client on purpose: the host that answered becomes the one asked first, and
+ *   sharing that state across clients would let one command's bad luck redirect every other. The
+ *   flip side is that a recovered first host is not noticed until the process restarts — that is
+ *   the price of not probing a node nobody asked us to talk to.
+ */
+export function suiRpcTransport(network) {
+    const hosts = suiRpcHosts(network);
+    let preferred = 0;
+    const fetchWithFailover = async (input, init) => {
+        const asked = new URL(typeof input === "string" ? input : input instanceof URL ? input.href : input.url);
+        let lastError = null;
+        for (let step = 0; step < hosts.length; step += 1) {
+            const index = (preferred + step) % hosts.length;
+            const host = hosts[index];
+            if (host === undefined)
+                continue;
+            try {
+                const res = await fetch(new URL(asked.pathname + asked.search, host), init);
+                if (worthAnotherHost(res.status) && step < hosts.length - 1) {
+                    lastError = new Error(`${host} answered ${res.status}`);
+                    continue;
+                }
+                preferred = index;
+                return res;
+            }
+            catch (err) {
+                lastError = err;
+            }
+        }
+        throw lastError instanceof Error
+            ? lastError
+            : new Error(`no Sui node answered (${hosts.length} tried)`);
+    };
+    return new JsonRpcHTTPTransport({ url: hosts[0] ?? "", fetch: fetchWithFailover });
+}

package/dist/support-attach.d.ts

@@ -0,0 +1,24 @@
+import type { RunRecord } from "./run-log.ts";
+/** What one attachment turned out to be. */
+export interface LogAttachment {
+    /** The text, oldest run first. Empty when there was nothing to attach. */
+    readonly text: string;
+    /** How many runs are in it. */
+    readonly runs: number;
+    /** How many were left out to fit the cap. */
+    readonly dropped: number;
+    /** What it weighs on the wire. */
+    readonly bytes: number;
+}
+/** The server's ceiling on the log field. `api/src/routes/support.rs` is the origin. */
+export declare const MAX_ATTACHMENT_BYTES: number;
+/** One run, as a person reads it. */
+export declare function formatRun(record: RunRecord): string;
+/**
+ * Build the attachment.
+ *
+ * `clean` is the caller's redaction — it runs over each run's own text rather than over the
+ * finished attachment, so that a value replaced by a longer label cannot push the result back over
+ * the cap after it has been measured.
+ */
+export declare function buildLogAttachment(records: readonly RunRecord[], clean: (text: string) => string, limit?: number): LogAttachment;

package/dist/support-attach.js

@@ -0,0 +1,72 @@
+// Turning the run log into the text that travels with a report.
+//
+// ⛔ IT IS FOR A PERSON TO READ, NOT FOR A MACHINE TO PARSE. The log on disk is JSON because it is
+//    appended to and trimmed; what goes into a report is a transcript, because the thing that
+//    makes a report useful is somebody being able to see the sequence at a glance.
+//
+// ⛔ THE CAP DROPS WHOLE RUNS, OLDEST FIRST. Cutting the text at a byte offset would end the
+//    attachment in the middle of the one run that matters — the newest one, which is the one the
+//    report is about — and a half line is worse than an honest count of what was left out.
+/** The server's ceiling on the log field. `api/src/routes/support.rs` is the origin. */
+export const MAX_ATTACHMENT_BYTES = 32 * 1024;
+/** Room held back for the "older runs left out" line and the blank line above it. */
+const NOTICE_RESERVE = 48;
+function bytes(text) {
+    return Buffer.byteLength(text, "utf8");
+}
+/** One run, as a person reads it. */
+export function formatRun(record) {
+    const lines = [
+        `${record.t} v${record.v} exit ${record.exit} in ${record.ms}ms`,
+        `$ nmts ${[record.cmd, ...record.args].join(" ")}`.trimEnd(),
+    ];
+    for (const event of record.events) {
+        if (event.kind === "http") {
+            const tail = event.error === undefined ? "" : ` ${event.error}`;
+            lines.push(`  ${event.method} ${event.path} → ${event.status}${tail}`);
+        }
+        else {
+            lines.push(`  ! ${event.message}`);
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Build the attachment.
+ *
+ * `clean` is the caller's redaction — it runs over each run's own text rather than over the
+ * finished attachment, so that a value replaced by a longer label cannot push the result back over
+ * the cap after it has been measured.
+ */
+export function buildLogAttachment(records, clean, limit = MAX_ATTACHMENT_BYTES) {
+    const blocks = records.map((record) => clean(formatRun(record)));
+    const kept = [];
+    let used = 0;
+    let dropped = 0;
+    // Newest first while packing, because the newest run is the one the report is about.
+    for (let i = blocks.length - 1; i >= 0; i -= 1) {
+        const block = blocks[i];
+        if (block === undefined)
+            continue;
+        // Every run but the first costs a blank line between it and the one before.
+        const cost = bytes(block) + (kept.length === 0 ? 0 : 2);
+        // ⛔ ROOM FOR THE NOTICE IS HELD BACK WHILE OLDER RUNS REMAIN, not added afterwards. An
+        //    attachment that filled the cap and then said "3 runs left out" would be over it, and the
+        //    server would refuse the whole message rather than the sentence.
+        const reserve = i === 0 ? 0 : NOTICE_RESERVE;
+        if (used + cost + reserve > limit) {
+            dropped = i + 1;
+            break;
+        }
+        used += cost;
+        kept.unshift(block);
+    }
+    const parts = kept.length === 0 ? [] : [kept.join("\n\n")];
+    if (dropped > 0)
+        parts.unshift(noticeLine(dropped));
+    const text = parts.join("\n\n");
+    return { text, runs: kept.length, dropped, bytes: bytes(text) };
+}
+function noticeLine(dropped) {
+    return `(${dropped} older ${dropped === 1 ? "run" : "runs"} left out to fit.)`;
+}

package/dist/support-copy.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The long text: what this is, who reads it, and what not to type.
+ *
+ * Printed by `nmts support --help` and `nmts support send --help`, and by the general help.
+ */
+export declare const SUPPORT_LONG: readonly string[];
+/**
+ * The short text, printed once above every preview.
+ *
+ * ⛔ TWO LINES AND NOT THE LONG ONE. The long text belongs where somebody is deciding whether to
+ *    write at all; on the send itself it would be four paragraphs between a person and the thing
+ *    they came to do, and text nobody reads protects nobody (owner, 2026-09-03).
+ */
+export declare const SUPPORT_SHORT: readonly string[];
+/** What `--attach-log` attaches, and what has already been taken out of it. */
+export declare const ATTACH_LOG_TEXT: readonly string[];
+/** One thing a report can be about, with the narrowings the server accepts for it. */
+export interface SupportCategory {
+    readonly code: string;
+    readonly subs: readonly string[];
+}
+/**
+ * What the command line offers.
+ *
+ * ⛔ A COPY OF THE SERVER'S TABLE (`api/src/domain/support.rs`, `CATEGORIES`) AND NOT ALL OF IT.
+ *    The two the server also knows are deliberately not here: `board` is the channel the terms
+ *    name for contesting a moderation decision and carries statutory clocks that belong on a
+ *    screen where a person reads what they are starting, and `other` is what the server files a
+ *    ticket as when none was named — offering it would make "I did not choose" a choice.
+ *
+ * ⚠ A category the server drops is a 400 naming the field, and the refusal names these. One the
+ *   server ADDS is simply not offered here until somebody adds it, which is the safe direction.
+ */
+export declare const SUPPORT_CATEGORIES: readonly SupportCategory[];
+/** The category codes, for a refusal that has to name them. */
+export declare function categoryCodes(): string[];
+/** The categories and their narrowings, one line each, for the help text. */
+export declare function categoryLines(): string[];
+/** The usage lines. Kept beside the copy because the two are read together. */
+export declare const SUPPORT_USAGE: readonly string[];
+/** What `nmts support --help` and `nmts support send --help` print. */
+export declare function supportHelpText(): string;

package/dist/support-copy.js

@@ -0,0 +1,109 @@
+// Every sentence `nmts support` shows a person, in one place.
+//
+// ⛔ WRITTEN ONCE AND IMPORTED, NEVER RETYPED. The same words are printed by the help text, by the
+//    preview above every send, and by the MCP tool descriptions. A second copy is how one of them
+//    starts saying something the others do not — and what these particular sentences promise is
+//    what is taken out of a message before it leaves the machine, which is not a promise to keep
+//    in two versions.
+//
+// ⛔ IT HAS NO IMPORTS AND MUST NOT GROW ANY. `help.ts` reads it, and `nmts --help` is measured
+//    (`check:cli-startup`): a module that pulled the command in behind it would make every run of
+//    the help text load the server client.
+//
+// ⛔ ENGLISH ONLY, LIKE THE WHOLE OF THIS PACKAGE (owner, 2026-09-03). Korean lives in
+//    `README.ko.md` and nowhere else in `cli/`.
+/**
+ * The long text: what this is, who reads it, and what not to type.
+ *
+ * Printed by `nmts support --help` and `nmts support send --help`, and by the general help.
+ */
+export const SUPPORT_LONG = [
+    "Send a message to the person who builds NMTS: a bug, an error, an idea, a question, or",
+    "anything else. It lands in the same inbox as the app's contact form, and replies come",
+    "back to this thread (`nmts support show <code>`).",
+    "",
+    "NMTS is built and run by one developer. I test it hard as a user myself, and on my own",
+    "that is nowhere near enough. The tiniest report counts, and so does anything you are not",
+    "sure is a bug. Every message is read, seriously.",
+    "",
+    "Write in English if you can. Korean is read too; if Korean is not your own language,",
+    "English is the better choice.",
+    "",
+    "Keep personal details out. Your NMTS key, API key, passphrase and file contents are",
+    "removed on this machine before anything is sent; file names and your public code may go.",
+    "Please do not type your name, address, health or anything else about yourself. The form",
+    "does not need it, and this inbox is the wrong place for it.",
+];
+/**
+ * The short text, printed once above every preview.
+ *
+ * ⛔ TWO LINES AND NOT THE LONG ONE. The long text belongs where somebody is deciding whether to
+ *    write at all; on the send itself it would be four paragraphs between a person and the thing
+ *    they came to do, and text nobody reads protects nobody (owner, 2026-09-03).
+ */
+export const SUPPORT_SHORT = [
+    "This goes to the developer of NMTS and is read. Leave personal details out: your NMTS key,",
+    "API key and file contents are stripped here before sending. English preferred; Korean is read too.",
+];
+/** What `--attach-log` attaches, and what has already been taken out of it. */
+export const ATTACH_LOG_TEXT = [
+    "--attach-log adds the CLI's own record of its last runs: the commands, the server's",
+    "answers and any error text. It is written already redacted (NMTS keys, API keys,",
+    "passphrases, tokens and key material become labels before they touch the disk) and is",
+    "redacted once more when attached. You do not need to read it before sending. If you know",
+    "a value that must not travel, add --omit <text> and it is replaced too.",
+];
+/**
+ * What the command line offers.
+ *
+ * ⛔ A COPY OF THE SERVER'S TABLE (`api/src/domain/support.rs`, `CATEGORIES`) AND NOT ALL OF IT.
+ *    The two the server also knows are deliberately not here: `board` is the channel the terms
+ *    name for contesting a moderation decision and carries statutory clocks that belong on a
+ *    screen where a person reads what they are starting, and `other` is what the server files a
+ *    ticket as when none was named — offering it would make "I did not choose" a choice.
+ *
+ * ⚠ A category the server drops is a 400 naming the field, and the refusal names these. One the
+ *   server ADDS is simply not offered here until somebody adds it, which is the safe direction.
+ */
+export const SUPPORT_CATEGORIES = [
+    { code: "bug", subs: ["upload", "download", "files", "wallet", "signin", "display", "other"] },
+    { code: "idea", subs: ["files", "sharing", "wallet", "app", "other"] },
+    { code: "account", subs: ["signin", "lostcode", "devices", "delete", "other"] },
+    { code: "storage", subs: ["extend", "expiry", "erase", "network", "other"] },
+    { code: "payment", subs: ["failed", "amount", "credits", "trial", "other"] },
+    { code: "privacy", subs: ["mydata", "removal", "legal", "security", "other"] },
+];
+/** The category codes, for a refusal that has to name them. */
+export function categoryCodes() {
+    return SUPPORT_CATEGORIES.map((c) => c.code);
+}
+/** The categories and their narrowings, one line each, for the help text. */
+export function categoryLines() {
+    return SUPPORT_CATEGORIES.map((c) => `  ${c.code.padEnd(10)}${c.subs.join(" · ")}`);
+}
+/** The usage lines. Kept beside the copy because the two are read together. */
+export const SUPPORT_USAGE = [
+    "  nmts support send --category <c> [--sub <s>] (--message <text> | --message-file <path>)",
+    "  nmts support send --category <c> --attach-log [n] [--omit <text>] [--yes] [--json]",
+    "  nmts support list",
+    "  nmts support show <code>",
+    "  nmts support reply <code> --message <text>",
+];
+/** What `nmts support --help` and `nmts support send --help` print. */
+export function supportHelpText() {
+    return [
+        "nmts support — write to the developer of NMTS.",
+        "",
+        "USAGE",
+        ...SUPPORT_USAGE,
+        "",
+        ...SUPPORT_LONG,
+        "",
+        "CATEGORIES",
+        ...categoryLines(),
+        "",
+        "THE LOG",
+        ...ATTACH_LOG_TEXT,
+        "",
+    ].join("\n");
+}

package/dist/support-wire.d.ts

@@ -0,0 +1,49 @@
+/** The server's own ceilings on what one message may carry. */
+export declare const MAX_MESSAGE_CHARS = 4000;
+export declare const MAX_REPLY_CHARS = 8000;
+export interface Wire {
+    server: string;
+    apiKey: string;
+}
+export declare function open(options: {
+    server?: string | undefined;
+}): Wire;
+export declare function call(wire: Wire, path: string, init: {
+    method?: "POST";
+    body?: unknown;
+}): Promise<unknown>;
+export interface Message {
+    fromOperator: boolean;
+    body: string;
+    createdAt: string;
+    deletedAt: string | null;
+}
+export interface Ticket {
+    id: string;
+    code: string;
+    category: string;
+    subcategory: string | null;
+    message: string;
+    status: string;
+    createdAt: string;
+    lastReadAt: string | null;
+    messages: Message[] | null;
+}
+export declare function asTicket(value: unknown): Ticket;
+export declare function asList(value: unknown): {
+    tickets: Ticket[];
+    unread: number;
+};
+/** The date part of an instant. The time of day is noise in a list of reports. */
+export declare function day(at: string): string;
+export declare function requireCategory(given: string | undefined): string;
+/**
+ * The narrowing, checked against the category it was given with.
+ *
+ * ⚠ It is optional everywhere, and stays optional here: somebody who does not know which one
+ *   applies must be able to send anyway.
+ */
+export declare function checkSub(category: string, given: string | undefined): string | null;
+/** Values too short to name one thing would blank half the report, so they are refused. */
+export declare function checkOmit(values: readonly string[]): string[];
+export declare function requireLength(message: string, most: number, what: string): void;