@needmoretruth/nmts-cli 0.17.2

package/dist/commands/trash.js

@@ -0,0 +1,288 @@
+// `nmts rm` and `nmts restore` — the two halves of the trash.
+//
+// ⛔ NEITHER OF THESE DESTROYS ANYTHING. `rm` moves everything it is given to the trash, where it
+//    stays restorable for thirty days; the endpoint that erases a stored row for good is closed to
+//    an API key and stays closed, so no command here can reach it.
+//
+// ⛔ BOTH TAKE MANY PATHS AND WRITE THE LIST ONCE. Everything named is trashed together or
+//    nothing is: a run that wrote once per path would be one lost compare-and-swap away from a
+//    drive with half of the deletion in it, and the message would still say the whole run had
+//    happened. The server rows still go one at a time — there is no batch endpoint — which is
+//    why a run that stops half way names how far it got.
+//
+// ⚠ ONE VERB IN THIS TOOL DOES HAVE NO UNDO, AND IT IS DELIBERATELY NOT THESE TWO. `nmts sweep`
+//   drops list entries whose thirty days have already run out, which destroys this account's copy
+//   of the key for files the server has already destroyed its own copy of. It is a separate
+//   command, it stops for an answer on every run rather than once per machine, and it can never
+//   touch anything still inside the window these two work on. The sentence that used to sit here
+//   said no verb without an undo would ever live in this tool; that stopped being true the day
+//   the sweep arrived, and a header that goes on describing the world before a change is the way
+//   the next reader is misled.
+//
+// ⛔ THE SERVER ROW GOES FIRST, AND "ALREADY DONE" COUNTS AS DONE. The order is not arbitrary and
+//    neither is the forgiveness:
+//      · A trashed item's bytes cannot be fetched — `GET /v1/items/{id}/parts` requires
+//        `deleted_at IS NULL`. So the state to avoid above all others is a drive that shows a file
+//        as live when the server has already trashed it: the person sees it, asks for it, and is
+//        told it does not exist.
+//      · Writing the list only after the server agreed means a failed server call leaves the
+//        drive exactly as it was, which is the state a person can act on.
+//      · And a 404 from the server means the row is already in the state being asked for, which
+//        is what an interrupted run leaves behind. Treating it as a failure would make the retry
+//        of a half-finished command impossible — the one moment the retry is needed.
+import { setTrashed } from "../item-trash.js";
+import { buildIndex, fullPathOf, isLive, KIND_FILE } from "../drive-paths.js";
+import { NmtsError } from "../errors.js";
+import { readFileList } from "../manifest.js";
+import { applyManyToList, batchTargets } from "../manifest-write.js";
+import { openSession } from "../session.js";
+import { applyIntent } from "../shared/lib/drive/manifest-ops.js";
+export async function rm(paths, options = {}) {
+    return run("rm", paths, options);
+}
+export async function restore(paths, options = {}) {
+    return run("restore", paths, options);
+}
+async function run(verb, paths, options) {
+    const say = options.write ?? ((line) => process.stdout.write(`${line}\n`));
+    if (paths.length === 0) {
+        throw new NmtsError(`\`nmts ${verb}\` needs the path of at least one thing in the drive.`, {
+            exitCode: 2,
+            nextStep: `\`nmts ls${verb === "restore" ? " --all" : ""}\` prints the paths as this expects them.`,
+        });
+    }
+    const session = await openSession(options);
+    const list = await readFileList(session.server, session.apiKey, session.code, session.accountId);
+    const entries = list.manifest?.entries ?? [];
+    // ⛔ `rm` REFUSES what is already in the trash rather than quietly doing nothing, so the caller
+    //    learns nothing was needed; `restore` has to be able to SEE the trash to act on it. That is
+    //    why the two lookups differ. (The comment that used to sit here claimed a shared lookup would
+    //    make `rm` say "no such path" — it would not: the refusal below names the trash either way.
+    //    A reason that does not hold teaches the next reader to keep the wrong branch.)
+    //
+    // ⛔ AND ONE PATH THAT WILL NOT RESOLVE REFUSES THE WHOLE RUN, before a single server row is
+    //    touched. Trashing four of the five things somebody named and exiting 0 is worse than
+    //    trashing none: the run reads as done, and finding the odd one out means diffing the drive.
+    const index = buildIndex(entries);
+    const found = batchTargets(entries, paths, {
+        ...(verb === "restore" ? { includeTrashed: true } : {}),
+        nothingHappened: "Nothing changed.",
+    });
+    const acting = [];
+    const skipped = [];
+    for (const entry of found) {
+        const at = fullPathOf(index, entry);
+        if (verb === "restore" && isLive(index, entry)) {
+            // Already in the state being asked for. Not a refusal — named, and left alone.
+            skipped.push(at);
+            continue;
+        }
+        if (verb === "restore" && entry.deletedAt === undefined) {
+            // In the trash, but only because something above it is. Restoring this row would clear a
+            // `deletedAt` it does not have and leave the person exactly where they were.
+            throw new NmtsError(`"${at}" is in the trash because a folder above it is.`, {
+                exitCode: 4,
+                nextStep: `Nothing changed. Restore that folder instead — \`nmts ls --all\` shows which one carries the trash.`,
+            });
+        }
+        acting.push({ entry, path: at });
+    }
+    // ⛔ NAMING A FOLDER AND SOMETHING INSIDE IT IS NAMING ONE TRASHING TWICE, and only for `rm` is
+    //    that a problem worth solving here: stamping the child as well would give it a thirty-day
+    //    clock of its own, and then restoring the folder would leave it behind — the person would
+    //    have to remember they had also named it to ever find it again. Its bytes are covered
+    //    either way, because the rows are read from the folder. `restore` is the opposite case: a
+    //    child with its own instant needs its own clearing, so nothing is dropped there.
+    const named = new Set(acting.map((t) => t.entry.id));
+    const covered = verb === "rm" ? acting.filter((t) => hasNamedAncestor(entries, t.entry, named)) : [];
+    const targets = acting.filter((t) => !covered.includes(t));
+    for (const t of covered)
+        skipped.push(t.path);
+    if (targets.length === 0) {
+        // Everything named was already where it was asked to be. A no-op is a success: writing the
+        // list would cost every other device a download for nothing.
+        return nothingToDo(say, options, verb, skipped, list.seq ?? 0);
+    }
+    // Every FILE at or under the targets — a folder holds no bytes and has no server row, so the
+    // rows to move are its file descendants.
+    //
+    // ⛔ THE ROWS TO MOVE ARE THE ONES THE EDIT WILL MAKE REACHABLE, so the set is read off a
+    //    PREVIEW of the list rather than guessed (2026-08-23). `rm` is easy — everything
+    //    under the target loses its bytes. `restore` is not: a file the person deleted separately
+    //    last week keeps its own `deletedAt`, stays in the trash after the folder comes back, and
+    //    its row must stay deleted with it. Restoring that row would cancel its own thirty-day
+    //    sweep, go on costing storage, and leave the list saying "trashed" while the server says
+    //    "live" — after which `rm` refuses to put it back and the tool has no way out.
+    const at = Date.now();
+    const ids = targets.map((t) => t.entry.id);
+    const preview = buildIndex(applyIntent(entries, intentFor(verb, ids, at)));
+    const under = uniqueById(targets.flatMap((t) => filesUnder(entries, t.entry.id)));
+    // ⚠ Judged on the PREVIEW's own row, not on the one in hand: `applyIntent` returns new objects,
+    //   so asking the preview about the old object reads the old `deletedAt` and answers "still
+    //   trashed" for the very thing being restored.
+    const files = verb === "rm"
+        ? under
+        : under.filter((f) => {
+            const after = preview.byId.get(f.id);
+            return after !== undefined && isLive(preview, after);
+        });
+    let done = 0;
+    try {
+        for (const file of files) {
+            await tellServer(session.server, session.apiKey, verb, file.id);
+            done += 1;
+        }
+    }
+    catch (error) {
+        // ⛔ A HALF-FINISHED RUN MUST NAME ITSELF. Without this the agent sees six words of stderr and
+        //    the tool's own guidance ("a refusal is not a transient error, do not retry in a loop")
+        //    steers it away from the one thing that fixes this — running the same command again.
+        const because = error instanceof Error ? error.message : "the server refused";
+        throw new NmtsError(because, {
+            exitCode: 1,
+            nextStep: `${done} of ${files.length} file rows were moved before this stopped, and the file list was ` +
+                `not written. Running \`nmts ${verb}\` on the same paths again finishes the job — nothing is lost.`,
+        });
+    }
+    // ⛔ THE IDS ARE DECIDED AGAIN ON EVERY ATTEMPT, and this is not ceremony. Between the read
+    //    above and the write below another device can put one of these targets in the trash — by
+    //    trashing it, or by moving it under a folder that already is. Re-applying the intent we
+    //    built earlier would then stamp `deletedAt` on something that is ALREADY in the trash by
+    //    inheritance, giving it a clock of its own and quietly detaching it from the folder it came
+    //    with: restoring that folder afterwards would leave it behind. An id that has left the list
+    //    entirely is dropped for the reason `manifest-ops.ts` gives — the other device removing it
+    //    is newer information than our edit, and putting it back would undo a deletion somebody
+    //    made on purpose.
+    const result = await applyManyToList(session, (now) => {
+        const nowIndex = buildIndex(now);
+        const still = ids.filter((id) => {
+            const live = nowIndex.byId.get(id);
+            if (live === undefined)
+                return false;
+            return verb === "rm" ? isLive(nowIndex, live) : live.deletedAt !== undefined;
+        });
+        return still.length === 0 ? [] : [intentFor(verb, still, at)];
+    });
+    const shown = targets.map((t) => t.path);
+    if (options.json) {
+        say(JSON.stringify({
+            paths: shown,
+            ids,
+            files: files.length,
+            // Named, and nothing was written for them: already out of the trash, or already covered
+            // by a folder in the same run.
+            skipped,
+            changed: result.changed,
+            // ⚠ The one signal that another writer intervened. It was printed in prose and left out of
+            //   the JSON, which is the half an agent is told to read (2026-08-23).
+            reappliedAfterConflict: result.reappliedAfterConflict,
+            seq: result.seq,
+        }));
+        return 0;
+    }
+    const moved = files.length === 1 ? "1 file" : `${files.length} files`;
+    const names = shown.map((s) => `"${s}"`).join(", ");
+    say(verb === "rm"
+        ? `Moved ${names} to the trash (${moved}). ${shown.length === 1 ? "It" : "They"} can be restored for 30 days.`
+        : `Restored ${names} (${moved}).`);
+    if (skipped.length > 0)
+        say(`  ${skippedLine(verb, skipped)}`);
+    if (result.reappliedAfterConflict) {
+        say(`  Another device wrote the file list first, so this was applied to that version.`);
+    }
+    return 0;
+}
+/** The one intent either verb writes. Built in two places, so it is spelled in one. */
+function intentFor(verb, ids, at) {
+    return verb === "rm" ? { op: "trash", ids, at } : { op: "restore", ids, at };
+}
+/** What was named but not acted on, in the words that say why. */
+function skippedLine(verb, skipped) {
+    const names = skipped.map((s) => `"${s}"`).join(", ");
+    return verb === "rm"
+        ? `${names} is inside something else that was named, so it goes with it.`
+        : `${names} was not in the trash.`;
+}
+/**
+ * The run had nothing to do. Says so in whichever form the caller asked for.
+ *
+ * ⚠ In practice this is the `restore` case — everything named was already out of the trash.
+ *   `rm` reaches it only if every path it resolved was inside another path it resolved, which
+ *   cannot happen while the outermost one is always kept.
+ */
+function nothingToDo(say, options, verb, skipped, seq) {
+    if (options.json) {
+        say(JSON.stringify({ paths: [], ids: [], files: 0, skipped, changed: false, reappliedAfterConflict: false, seq }));
+        return 0;
+    }
+    const names = skipped.map((s) => `"${s}"`).join(", ");
+    say(verb === "restore"
+        ? `${names} ${skipped.length === 1 ? "is" : "are"} not in the trash. Nothing changed.`
+        : `Nothing was left to move to the trash. Nothing changed.`);
+    return 0;
+}
+/** Is any ancestor of this entry in the set? Used to drop a target a named folder already covers. */
+function hasNamedAncestor(entries, entry, named) {
+    const byId = buildIndex(entries).byId;
+    const seen = new Set([entry.id]);
+    let at = entry.parentId;
+    while (at !== null && !seen.has(at)) {
+        if (named.has(at))
+            return true;
+        seen.add(at);
+        at = byId.get(at)?.parentId ?? null;
+    }
+    return false;
+}
+/** One entry per id, keeping the first. Two named folders can hold the same file only once. */
+function uniqueById(files) {
+    const byId = new Map();
+    for (const file of files)
+        if (!byId.has(file.id))
+            byId.set(file.id, file);
+    return [...byId.values()];
+}
+/**
+ * Every file at or under one entry.
+ *
+ * ⚠ Trashed descendants are INCLUDED HERE, and the CALLER filters. Somebody who trashed one file
+ *   last week and then trashes its folder expects the folder to be gone from the server too — so
+ *   `rm` takes this set whole. `restore` cannot: see the note at the call site.
+ */
+function filesUnder(entries, rootId) {
+    const root = entries.find((e) => e.id === rootId);
+    if (root === undefined)
+        return [];
+    if (root.kind === KIND_FILE)
+        return [root];
+    const childrenOf = new Map();
+    for (const e of entries) {
+        const list = childrenOf.get(e.parentId);
+        if (list === undefined)
+            childrenOf.set(e.parentId, [e]);
+        else
+            list.push(e);
+    }
+    const out = [];
+    const seen = new Set([rootId]);
+    const queue = [rootId];
+    while (queue.length > 0) {
+        const id = queue.pop();
+        if (id === undefined)
+            break;
+        for (const child of childrenOf.get(id) ?? []) {
+            if (seen.has(child.id))
+                continue;
+            seen.add(child.id);
+            if (child.kind === KIND_FILE)
+                out.push(child);
+            else
+                queue.push(child.id);
+        }
+    }
+    return out;
+}
+/** ⛔ 404 is "already in the state you asked for", which is what a half-finished run leaves. */
+async function tellServer(base, apiKey, verb, id) {
+    await setTrashed(base, apiKey, id, verb === "rm");
+}

package/dist/commands/trial.js

@@ -0,0 +1,264 @@
+// `nmts trial` — this week's free trial: what is left of it, and asking for a place.
+//
+// ⛔ THE RULES ARE THE SERVER'S AND THIS COMMAND ONLY REPORTS THEM. One application per account
+//    per ISO week, first come first served against a budget the server decides weekly. There is
+//    no flag here that asks for more, no retry loop that waits for a place to open, and no way to
+//    name an amount — a place is what the week says it is. Every refusal below is passed on as
+//    the server's answer with the remedy named, never worked around.
+//
+// ⛔ ASKING IS A SEPARATE WORD FROM LOOKING. `nmts trial` reads and takes nothing; `nmts trial
+//    apply` spends this account's one chance for the week. A command that applied because it was
+//    run would spend that chance for somebody who wanted to know how many places were left.
+//
+// ⛔ IT NEEDS A PERSON'S CHECK, AND SAYS SO INSTEAD OF REPORTING A BARE REFUSAL. Both routes are
+//    open to an API key only while somebody has passed the account's human check inside the last
+//    four of the server's weeks. The server decides scope before it looks at that check, so a
+//    caller can be told "the key was not given permission" when what is actually missing is a
+//    person — which sends an agent to make another key, the one thing that cannot help. So the
+//    standing check is asked about first, and the answer names `nmts verify`.
+//
+// ⛔ AND APPLYING ASKS FOR SOMETHING THIS TOOL CANNOT PRODUCE. `POST /v1/trial/apply` runs a
+//    fresh browser check of its own on every application — it is the one request in this API that
+//    hands out credits, so the check is made per application rather than once per session. A
+//    command line has no browser and no token, so on any deployment configured with that check
+//    the application is refused however good the credentials are. That is reported as what it is,
+//    with the place a person can apply from, rather than as a credential problem. `nmts verify`
+//    is a DIFFERENT check and does not stand in for this one.
+import { request, ServerError } from "../api.js";
+import { readCredentialsFile } from "../credentials.js";
+import { NmtsError } from "../errors.js";
+import { isRecord } from "../guards.js";
+import { askAPersonToVerify, humanCheck } from "../human-check.js";
+import { BINARY_NAME, HOME_URL } from "../product.js";
+import { resolveServer } from "../server.js";
+import { requireApiKey } from "../session.js";
+import { humanSize } from "../units.js";
+import { CREDIT_BYTES } from "../upload-price.js";
+/** The one word this command takes, and what it costs. */
+const APPLY = "apply";
+export async function trial(action, options = {}) {
+    const say = options.write ?? ((line) => process.stdout.write(`${line}\n`));
+    if (action !== undefined && action !== "" && action !== APPLY) {
+        throw new NmtsError(`\`${BINARY_NAME} trial\` takes nothing, or \`${APPLY}\`.`, {
+            exitCode: 2,
+            nextStep: `\`${BINARY_NAME} trial\` says what is left of this week. \`${BINARY_NAME} trial ${APPLY}\` ` +
+                `asks for a place, which an account may do once a week.`,
+        });
+    }
+    const apiKey = requireApiKey();
+    const stored = readCredentialsFile();
+    const server = resolveServer(options.server ?? stored?.server);
+    const check = await humanCheck(server, apiKey);
+    if (!check.live)
+        throw askAPersonToVerify("The free trial cannot be read or applied for");
+    const week = readWeek(await request(server, "/v1/trial", { token: apiKey }));
+    if (action !== APPLY) {
+        if (options.json === true) {
+            say(JSON.stringify(asJson(week)));
+            return 0;
+        }
+        sayWeek(say, week);
+        sayRules(say);
+        if (week.live && !week.already && !week.held && week.slotsLeft > 0) {
+            say(``);
+            say(`  ${BINARY_NAME} trial ${APPLY}`);
+        }
+        return 0;
+    }
+    // ⛔ ALREADY IN IS NOT A FAILURE. The account holds the thing the command asks for, so the run
+    //    ends at 0 — and it does not send the application, because the answer is already known and
+    //    the server would spend a refusal saying so.
+    if (week.already) {
+        if (options.json === true) {
+            say(JSON.stringify({ event: "already", round: week.round }));
+            return 0;
+        }
+        say(`This account already took its place in week ${week.round}.`);
+        say(``);
+        say(`  One application per account per week, so there is nothing more to ask for until the`);
+        say(`  next one. \`${BINARY_NAME} balance\` says what the credits bought.`);
+        return 0;
+    }
+    const granted = await apply(server, apiKey, week);
+    if (options.json === true) {
+        say(JSON.stringify({ event: "granted", ...granted }));
+        return 0;
+    }
+    say(`Granted: ${granted.credits} credits, in week ${granted.round}.`);
+    say(``);
+    say(`  They lapse unused at ${granted.expires_at}. One credit is ${humanSize(CREDIT_BYTES)} held`);
+    say(`  for one lease period; \`${BINARY_NAME} balance\` says what is left of them.`);
+    return 0;
+}
+async function apply(server, apiKey, week) {
+    let answer;
+    try {
+        // ⚠ AN EMPTY BODY, AND NOT A MISSING ONE. The route reads one field — the browser check's
+        //   token — and treats absent and blank alike; sending `{}` is what a tool that always sends
+        //   JSON sends, and there is nothing else this end could put in it.
+        answer = await request(server, "/v1/trial/apply", { method: "POST", token: apiKey, body: {} });
+    }
+    catch (error) {
+        throw explain(error, week);
+    }
+    const credits = isRecord(answer) ? answer["credits"] : null;
+    const expires = isRecord(answer) ? answer["expires_at"] : null;
+    const round = isRecord(answer) ? answer["round"] : null;
+    if (typeof credits !== "number" ||
+        !Number.isFinite(credits) ||
+        typeof expires !== "string" ||
+        typeof round !== "string") {
+        throw new NmtsError("The server granted a place and described it in a shape this version cannot read.", {
+            exitCode: 1,
+            nextStep: `The credits are on the account whatever this printed — \`${BINARY_NAME} balance\` reads ` +
+                `the ledger. Update this tool.`,
+        });
+    }
+    return { credits, expires_at: expires, round };
+}
+/**
+ * Say what each refusal actually means, and what — if anything — changes it.
+ *
+ * ⛔ NONE OF THESE IS RETRIED HERE. Two of them (a full week, a lost race) are decided by other
+ *    people's applications and a loop would only take the next place from whoever asked next; the
+ *    rest are decided by a person or by the operator. An agent that reads "try again" retries;
+ *    every message below says what would have to change instead.
+ */
+function explain(error, week) {
+    if (!(error instanceof ServerError))
+        return error;
+    switch (error.code) {
+        // ⚠ ONLY THE REFUSAL, NOT THE OUTAGE. `TURNSTILE_UNAVAILABLE` means the check's verifier
+        //   could not be reached, which is a passing condition on the server's side and keeps
+        //   `api.ts`'s ordinary handling — telling somebody to go to a browser would send them to a
+        //   screen that is refusing for the same reason.
+        case "TURNSTILE_FAILED":
+            // ⛔ THE ADVICE `api.ts` CARRIES FOR THIS CODE IS THE WRONG ONE HERE, and that is why this
+            //    case exists. It says an API key is what waives the check — true for signing in, and
+            //    false for this route, which runs its own check on every application no matter what
+            //    credential arrived. A caller told to go and make a key would make one and be refused
+            //    again.
+            return new NmtsError("This server asks every application for a browser check, and a command line has none.", {
+                exitCode: 4,
+                nextStep: `Nothing was taken and this account's place for week ${week.round} is untouched. The ` +
+                    `check is a puzzle solved in a browser, and it is asked for on every application ` +
+                    `rather than once, because this is the one request that hands out credits. Apply on ` +
+                    `the account screen at ` +
+                    `${HOME_URL} instead. \`${BINARY_NAME} verify\` is a different check and does not stand ` +
+                    `in for this one.`,
+            });
+        case "TRIAL_FULL":
+            return new NmtsError("Every place in this week is taken.", {
+                exitCode: 4,
+                nextStep: `Places are first come, first served, and the week's budget is decided by the server. ` +
+                    `Nothing was taken. The next week's places appear when it turns.`,
+            });
+        case "TRIAL_ALREADY":
+            return new NmtsError(`This account already took its place in week ${week.round}.`, {
+                exitCode: 4,
+                nextStep: `One application per account per week. Nothing was taken.`,
+            });
+        case "TRIAL_CLOSED":
+            return new NmtsError("The free trial is not open on this server.", {
+                exitCode: 4,
+                nextStep: `Nothing was taken. Whether it runs at all is the operator's decision, not a setting here.`,
+            });
+        case "TRIAL_HELD":
+            return new NmtsError("Applications are paused.", {
+                exitCode: 4,
+                nextStep: `An unusually large wave of applications is being looked at, and they stay paused until ` +
+                    `that is done. Nothing was taken, and this account's place for the week is untouched.`,
+            });
+        case "TRIAL_LINE_CAPPED":
+            return new NmtsError("This internet connection has taken all the places it can today.", {
+                exitCode: 4,
+                nextStep: `Nothing was taken. A day's share per connection is what stops one line sweeping a ` +
+                    `week. Tomorrow it resets — though this week's places may be gone by then.`,
+            });
+        default:
+            return error;
+    }
+}
+function readWeek(answer) {
+    if (!isRecord(answer))
+        throw brokenAnswer();
+    const live = answer["live"];
+    const round = answer["round"];
+    if (typeof live !== "boolean" || typeof round !== "string")
+        throw brokenAnswer();
+    return {
+        live,
+        round,
+        computed: answer["computed"] === true,
+        winners: whole(answer["winners"]),
+        creditsPerWinner: whole(answer["credits_per_winner"]),
+        slotsLeft: whole(answer["slots_left"]),
+        already: answer["already"] === true,
+        held: answer["held"] === true,
+    };
+}
+/** A count the server sent, or 0. ⚠ 0 and "not decided" are told apart by `computed`, not by this. */
+function whole(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function brokenAnswer() {
+    return new NmtsError("The server did not describe this week's trial in a shape this version can read.", {
+        exitCode: 1,
+        nextStep: `Update this tool, or read the account screen at ${HOME_URL}.`,
+    });
+}
+function asJson(week) {
+    // The server's own spelling, so a reader that has seen one and then the other is not converting
+    // between two names for one number.
+    return {
+        live: week.live,
+        round: week.round,
+        computed: week.computed,
+        winners: week.winners,
+        credits_per_winner: week.creditsPerWinner,
+        slots_left: week.slotsLeft,
+        already: week.already,
+        held: week.held,
+    };
+}
+/**
+ * The week, one fact per line.
+ *
+ * ⛔ "NOT DECIDED YET" IS NOT "NO PLACES". A week with no computed budget row answers zero for
+ *    everything, and printing that as "0 places" would be this tool deciding something the server
+ *    has not.
+ */
+function sayWeek(say, week) {
+    say(`Free trial · week ${week.round}`);
+    say(``);
+    if (!week.live) {
+        say(`  The trial is not running on this server.`);
+        return;
+    }
+    if (!week.computed) {
+        say(`  This week's places have not been decided yet. That is not the same as none.`);
+        return;
+    }
+    say(`  places left        ${week.slotsLeft} of ${week.winners}`);
+    say(`  one place gives    ${week.creditsPerWinner} credits — ` +
+        `${humanSize(week.creditsPerWinner * CREDIT_BYTES)} for one lease period`);
+    say(`  this account       ${week.already ? `took its place this week` : `has not applied this week`}`);
+    if (week.held) {
+        say(``);
+        say(`  ⛔ Applications are paused while an unusually large wave of them is looked at.`);
+        say(`     A paused week is not a closed one: nothing here is decided against this account.`);
+    }
+    say(``);
+}
+/**
+ * The rules, printed every time and not only when one bites.
+ *
+ * ⛔ THEY ARE NOT THIS TOOL'S TO CHANGE, so they are stated where somebody reads them before
+ *    applying rather than quoted back as an error afterwards.
+ */
+function sayRules(say) {
+    say(`The rules, which this tool does not set and cannot bend:`);
+    say(`  · one application per account per week, on the server's own week boundaries`);
+    say(`  · first come, first served — a place goes to whoever asks while one is open`);
+    say(`  · the week's budget is decided by the server; there is no way to ask for more`);
+}