waterplane 0.0.1 → 0.1.6

package/node_modules/@waterplane/shared/dist/sweep.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Clearing out old transport files — the rules, on both sides, once.
+ *
+ * ── Why this exists ─────────────────────────────────────────────────────────
+ *
+ * `.claude/outbox/` and `.claude/inbox/` are how work reaches a person and how
+ * a photo reaches an agent (CLAUDE.md, "The phone↔repo transport"). Nothing has
+ * ever removed anything from either. Measured on this desktop, across fourteen
+ * repos: **6.8 GB** sitting in transport directories, 4.0 GB of it in ONE repo's
+ * outbox across 31 files, another 2.4 GB in a second. The gallery's per-file
+ * delete has existed the whole time and is the wrong instrument at that size —
+ * 523 files in one inbox is not a list anybody taps through.
+ *
+ * ── The three rules everything here serves ──────────────────────────────────
+ *
+ *  1. **Nothing applies itself** (CLAUDE.md). This module PLANS and describes;
+ *     it deletes nothing, decides nothing, and schedules nothing. There is no
+ *     age past which a file goes away on its own, and adding one later would be
+ *     a change of kind, not of degree: these directories hold the only copy of
+ *     things nobody committed.
+ *  2. **A count on a control is a filter** (CLAUDE.md). `sweepCounts` and
+ *     `planSweep` are the SAME predicate (`olderThan`) — the chip that says
+ *     "27 · 3.9 GB" opens exactly those 27, because a second copy of the edge
+ *     is how a badge becomes a liar.
+ *  3. **A count is not a decision; bytes are.** Every number here travels with
+ *     its byte total. "27 files older than 30 days" does not tell you whether
+ *     to care. "27 files, 3.9 GB" does, and in the measured case those 27 files
+ *     were 97% of the repo's transport bytes.
+ *
+ * ── The one that is easy to get wrong ───────────────────────────────────────
+ *
+ * **The plan is the contract, not the age.** The caller sends back the exact
+ * paths it showed a person, and those are what get deleted — never an age for
+ * the host to re-cut. Re-deriving the cut at delete time is a race with every
+ * agent running in that repo: a file written between the preview and the tap
+ * would fall inside "older than 30 days" by the time the sweep ran only if the
+ * clock moved, but one written BEFORE the preview and missed by a listing race
+ * would be deleted without ever having been on screen. A person approved a
+ * LIST. That list is the authority.
+ *
+ * Pure: no fs, no clock of its own (`now` is passed in), so both ends and
+ * `packages/shared/test/sweep.test.mjs` run it identically.
+ */
+/**
+ * The age ladder, as a person thinks about it.
+ *
+ * Deliberately coarse and deliberately NOT user-typed. A free-text "older
+ * than N days" field is a more precise way to answer a question nobody asks
+ * precisely, and it puts an arbitrary number in the sentence that says what is
+ * about to be destroyed.
+ */
+export type SweepAge = "7d" | "30d" | "90d" | "365d";
+/** Widest cut first — the order the chips are drawn in, and the order that
+ *  makes the nesting visible (each one's set contains the next one's). */
+export declare const SWEEP_AGES: readonly SweepAge[];
+export declare const SWEEP_AGE_MS: Record<SweepAge, number>;
+/** Said in full wherever it is said — "30d" is a key, never a label. */
+export declare const SWEEP_AGE_LABEL: Record<SweepAge, string>;
+/** Which transport directories a sweep is looking at. Separate because they
+ *  are opposite directions and one of them is far more likely to hold the only
+ *  copy of something: the outbox is what an agent WROTE (re-derivable by
+ *  running the thing again), the inbox is what a phone UPLOADED (a photo that
+ *  may exist nowhere else). The UI keeps them apart for that reason alone. */
+export type SweepScope = "outbox" | "inbox";
+export declare const SWEEP_SCOPE_LABEL: Record<SweepScope, string>;
+/** The minimum of a file row these rules need. The host's `FileEntry` is
+ *  structurally this, so nothing converts. */
+export interface SweepRow {
+    name: string;
+    /** Worktree-relative, forward slashes — and the ONLY identifier a delete
+     *  takes. A name is not unique across the two transport directories. */
+    relPath: string;
+    size: number;
+    mtime: number;
+}
+/** A count and the bytes behind it. Never one without the other. */
+export interface SweepTally {
+    count: number;
+    bytes: number;
+}
+export interface SweepPlan extends SweepTally {
+    /** Exactly the rows the cut selected, newest first. This is what gets sent
+     *  back to delete — see the module note. */
+    rows: SweepRow[];
+    /** The whole directory, for the "n of N" the filter bar owes the reader. */
+    total: SweepTally;
+    /** The oldest selected row's mtime, or null when nothing was selected. Used
+     *  to say how far back the cut actually reaches rather than how far back it
+     *  was ALLOWED to reach — those differ whenever the oldest file is younger
+     *  than the chip. */
+    oldestMtime: number | null;
+}
+/**
+ * Is this file older than the cut?
+ *
+ * The one predicate. `sweepCounts` counts with it and `planSweep` cuts with it,
+ * so the chip and the list cannot disagree.
+ *
+ * **On `mtime` rather than birth time.** `FileEntry` carries both, and a
+ * rewritten artifact is a file somebody is still producing — a build that
+ * overwrites `report.html` every run has a fresh mtime and a months-old ctime,
+ * and deleting it as "old" would be deleting today's output. Last-written is
+ * the conservative direction for a destructive cut.
+ */
+export declare function olderThan(mtime: number, age: SweepAge, now: number): boolean;
+/** Sum a set of rows. Split out because "the whole directory" and "the cut"
+ *  are the same arithmetic and the filter bar shows them side by side. */
+export declare function tally(rows: readonly SweepRow[]): SweepTally;
+/**
+ * What each chip says — every age, counted over the same rows.
+ *
+ * **The buckets NEST and that is the point.** Anything older than a year is
+ * also older than 30 days, so the numbers descend across the ladder and a
+ * person can read the ladder as "how aggressive do I want to be". Disjoint bins
+ * ("between 30 and 90 days") answer a question nobody has when the goal is
+ * reclaiming space.
+ */
+export declare function sweepCounts(rows: readonly SweepRow[], now: number): Record<SweepAge, SweepTally>;
+/**
+ * The cut, as a plan a person can be shown and then approve verbatim.
+ *
+ * Newest first, matching every other file listing in this app — the reader is
+ * checking "is anything here I still want", and the things they still want are
+ * the recent ones, so those are the rows that must not need scrolling to.
+ */
+export declare function planSweep(rows: readonly SweepRow[], age: SweepAge, now: number): SweepPlan;
+/** Bytes as a person reads them. Own function rather than the web's `format.ts`
+ *  because the HOST says these sentences too (an op's ack), and a sweep that
+ *  reports "3906823168" has not reported anything. */
+export declare function fmtBytes(n: number): string;
+/**
+ * What the primary button says — **the whole decision, restated**
+ * (`SendSheet`'s rule, and this is a destructive one, so it matters more).
+ *
+ * Never "Delete" alone: the count and the bytes are the two facts that make it
+ * a decision, and the age is what the reader picked and may have forgotten
+ * picking by the time they reach the button.
+ */
+export declare function sweepButtonText(plan: SweepPlan): string;
+/** The sentence under it: what is being kept, said explicitly. A destructive
+ *  control that only describes what it destroys leaves the reader to work out
+ *  the complement, which is the half they actually care about. */
+export declare function sweepKeepText(plan: SweepPlan, age: SweepAge): string;
+/** What a sweep DID, as one sentence. */
+export interface SweepResult {
+    deleted: number;
+    bytes: number;
+    /** Paths that were not there any more — an agent or another device got there
+     *  first. Not a failure: the outcome asked for is the outcome reached. */
+    missing: string[];
+    /** Paths the host refused or could not remove. A failure, and named, because
+     *  a sweep that says "done" over files still on disk is the one lie this
+     *  feature could tell that costs real bytes. */
+    failed: string[];
+}
+export declare function sweepResultText(r: SweepResult): string;

package/node_modules/@waterplane/shared/dist/sweep.js

@@ -0,0 +1,193 @@
+/**
+ * Clearing out old transport files — the rules, on both sides, once.
+ *
+ * ── Why this exists ─────────────────────────────────────────────────────────
+ *
+ * `.claude/outbox/` and `.claude/inbox/` are how work reaches a person and how
+ * a photo reaches an agent (CLAUDE.md, "The phone↔repo transport"). Nothing has
+ * ever removed anything from either. Measured on this desktop, across fourteen
+ * repos: **6.8 GB** sitting in transport directories, 4.0 GB of it in ONE repo's
+ * outbox across 31 files, another 2.4 GB in a second. The gallery's per-file
+ * delete has existed the whole time and is the wrong instrument at that size —
+ * 523 files in one inbox is not a list anybody taps through.
+ *
+ * ── The three rules everything here serves ──────────────────────────────────
+ *
+ *  1. **Nothing applies itself** (CLAUDE.md). This module PLANS and describes;
+ *     it deletes nothing, decides nothing, and schedules nothing. There is no
+ *     age past which a file goes away on its own, and adding one later would be
+ *     a change of kind, not of degree: these directories hold the only copy of
+ *     things nobody committed.
+ *  2. **A count on a control is a filter** (CLAUDE.md). `sweepCounts` and
+ *     `planSweep` are the SAME predicate (`olderThan`) — the chip that says
+ *     "27 · 3.9 GB" opens exactly those 27, because a second copy of the edge
+ *     is how a badge becomes a liar.
+ *  3. **A count is not a decision; bytes are.** Every number here travels with
+ *     its byte total. "27 files older than 30 days" does not tell you whether
+ *     to care. "27 files, 3.9 GB" does, and in the measured case those 27 files
+ *     were 97% of the repo's transport bytes.
+ *
+ * ── The one that is easy to get wrong ───────────────────────────────────────
+ *
+ * **The plan is the contract, not the age.** The caller sends back the exact
+ * paths it showed a person, and those are what get deleted — never an age for
+ * the host to re-cut. Re-deriving the cut at delete time is a race with every
+ * agent running in that repo: a file written between the preview and the tap
+ * would fall inside "older than 30 days" by the time the sweep ran only if the
+ * clock moved, but one written BEFORE the preview and missed by a listing race
+ * would be deleted without ever having been on screen. A person approved a
+ * LIST. That list is the authority.
+ *
+ * Pure: no fs, no clock of its own (`now` is passed in), so both ends and
+ * `packages/shared/test/sweep.test.mjs` run it identically.
+ */
+/** Widest cut first — the order the chips are drawn in, and the order that
+ *  makes the nesting visible (each one's set contains the next one's). */
+export const SWEEP_AGES = ["7d", "30d", "90d", "365d"];
+export const SWEEP_AGE_MS = {
+    "7d": 7 * 86_400_000,
+    "30d": 30 * 86_400_000,
+    "90d": 90 * 86_400_000,
+    "365d": 365 * 86_400_000,
+};
+/** Said in full wherever it is said — "30d" is a key, never a label. */
+export const SWEEP_AGE_LABEL = {
+    "7d": "older than a week",
+    "30d": "older than 30 days",
+    "90d": "older than 90 days",
+    "365d": "older than a year",
+};
+export const SWEEP_SCOPE_LABEL = {
+    outbox: "outbox — what agents wrote for you",
+    inbox: "inbox — what this phone uploaded",
+};
+/**
+ * Is this file older than the cut?
+ *
+ * The one predicate. `sweepCounts` counts with it and `planSweep` cuts with it,
+ * so the chip and the list cannot disagree.
+ *
+ * **On `mtime` rather than birth time.** `FileEntry` carries both, and a
+ * rewritten artifact is a file somebody is still producing — a build that
+ * overwrites `report.html` every run has a fresh mtime and a months-old ctime,
+ * and deleting it as "old" would be deleting today's output. Last-written is
+ * the conservative direction for a destructive cut.
+ */
+export function olderThan(mtime, age, now) {
+    return now - mtime > SWEEP_AGE_MS[age];
+}
+/** Sum a set of rows. Split out because "the whole directory" and "the cut"
+ *  are the same arithmetic and the filter bar shows them side by side. */
+export function tally(rows) {
+    let bytes = 0;
+    for (const r of rows)
+        bytes += r.size;
+    return { count: rows.length, bytes };
+}
+/**
+ * What each chip says — every age, counted over the same rows.
+ *
+ * **The buckets NEST and that is the point.** Anything older than a year is
+ * also older than 30 days, so the numbers descend across the ladder and a
+ * person can read the ladder as "how aggressive do I want to be". Disjoint bins
+ * ("between 30 and 90 days") answer a question nobody has when the goal is
+ * reclaiming space.
+ */
+export function sweepCounts(rows, now) {
+    const out = {};
+    for (const age of SWEEP_AGES)
+        out[age] = { count: 0, bytes: 0 };
+    for (const r of rows) {
+        for (const age of SWEEP_AGES) {
+            if (olderThan(r.mtime, age, now)) {
+                out[age].count++;
+                out[age].bytes += r.size;
+            }
+        }
+    }
+    return out;
+}
+/**
+ * The cut, as a plan a person can be shown and then approve verbatim.
+ *
+ * Newest first, matching every other file listing in this app — the reader is
+ * checking "is anything here I still want", and the things they still want are
+ * the recent ones, so those are the rows that must not need scrolling to.
+ */
+export function planSweep(rows, age, now) {
+    const hit = rows.filter((r) => olderThan(r.mtime, age, now)).sort((a, b) => b.mtime - a.mtime);
+    const t = tally(hit);
+    return {
+        rows: hit,
+        count: t.count,
+        bytes: t.bytes,
+        total: tally(rows),
+        oldestMtime: hit.length ? Math.min(...hit.map((r) => r.mtime)) : null,
+    };
+}
+/** Bytes as a person reads them. Own function rather than the web's `format.ts`
+ *  because the HOST says these sentences too (an op's ack), and a sweep that
+ *  reports "3906823168" has not reported anything. */
+export function fmtBytes(n) {
+    if (!Number.isFinite(n) || n < 0)
+        return "?";
+    if (n < 1024)
+        return `${n} B`;
+    const units = ["KB", "MB", "GB", "TB"];
+    let v = n / 1024;
+    let i = 0;
+    while (v >= 1024 && i < units.length - 1) {
+        v /= 1024;
+        i++;
+    }
+    // Three significant figures under 10, one decimal under 100, none above —
+    // `tokens.ts`' `fmtCount` rule, for its reason: trailing precision on a
+    // number nobody will act on to that precision is noise in a sentence whose
+    // whole job is to be read at a glance.
+    const s = v < 10 ? v.toFixed(1) : Math.round(v).toString();
+    return `${s} ${units[i]}`;
+}
+/**
+ * What the primary button says — **the whole decision, restated**
+ * (`SendSheet`'s rule, and this is a destructive one, so it matters more).
+ *
+ * Never "Delete" alone: the count and the bytes are the two facts that make it
+ * a decision, and the age is what the reader picked and may have forgotten
+ * picking by the time they reach the button.
+ */
+export function sweepButtonText(plan) {
+    if (!plan.count)
+        return "Nothing to delete";
+    return `Delete ${plan.count} file${plan.count === 1 ? "" : "s"} · ${fmtBytes(plan.bytes)}`;
+}
+/** The sentence under it: what is being kept, said explicitly. A destructive
+ *  control that only describes what it destroys leaves the reader to work out
+ *  the complement, which is the half they actually care about. */
+export function sweepKeepText(plan, age) {
+    const keptCount = plan.total.count - plan.count;
+    const keptBytes = plan.total.bytes - plan.bytes;
+    if (!plan.total.count)
+        return "Nothing here.";
+    if (!plan.count) {
+        return `Nothing here is ${SWEEP_AGE_LABEL[age]} — all ${plan.total.count} files stay (${fmtBytes(plan.total.bytes)}).`;
+    }
+    if (!keptCount) {
+        return `Everything here is ${SWEEP_AGE_LABEL[age]}. Nothing would be kept.`;
+    }
+    return `${keptCount} newer file${keptCount === 1 ? "" : "s"} stay (${fmtBytes(keptBytes)}).`;
+}
+export function sweepResultText(r) {
+    const parts = [];
+    parts.push(r.deleted
+        ? `Deleted ${r.deleted} file${r.deleted === 1 ? "" : "s"} · ${fmtBytes(r.bytes)}.`
+        : "Deleted nothing.");
+    // Said apart from the failures on purpose: "already gone" is the sweep
+    // succeeding through a different route, and folding it into a failure count
+    // would teach the reader to distrust a clean run.
+    if (r.missing.length)
+        parts.push(`${r.missing.length} already gone.`);
+    if (r.failed.length)
+        parts.push(`${r.failed.length} could not be removed — still on disk.`);
+    return parts.join(" ");
+}
+//# sourceMappingURL=sweep.js.map

package/node_modules/@waterplane/shared/dist/sweep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sweep.js","sourceRoot":"","sources":["../src/sweep.ts"],"names":[],"mappings":"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"}

package/node_modules/@waterplane/shared/dist/sweepfamilies.d.ts

@@ -0,0 +1,56 @@
+import { type SweepPlan, type SweepRow, type SweepTally } from "./sweep.js";
+/**
+ * How many of each family stay.
+ *
+ * Deliberately a short ladder and deliberately NOT user-typed, for
+ * `SWEEP_AGES`' reason: a free-text N is a more precise way to answer a
+ * question nobody asks precisely, and it puts an arbitrary number into the
+ * sentence describing a delete. One, three, five: "only the current one", "the
+ * default the automatic prune uses", "a bit of headroom".
+ */
+export type FamilyKeep = 1 | 3 | 5;
+/** Widest cut first — the order the chips are drawn in, and the order that
+ *  makes the nesting visible (keep-1's victims contain keep-3's, which contain
+ *  keep-5's). */
+export declare const FAMILY_KEEPS: readonly FamilyKeep[];
+/** Said in full wherever it is said — "3" is a key, never a label. */
+export declare const FAMILY_KEEP_LABEL: Record<FamilyKeep, string>;
+/**
+ * How many distinct things this directory holds builds OF.
+ *
+ * Printed beside every count here, because "14 of 38 files" is unreadable on
+ * its own: it could be one family of 38 or 19 families of two, and those are
+ * completely different decisions. "14 of 38, across 13 build families" is the
+ * sentence that says what kind of directory you are looking at.
+ */
+export declare function familyCount(rows: readonly SweepRow[]): number;
+/**
+ * The cut, as a plan a person can be shown and then approve verbatim.
+ *
+ * `pruneVictims` takes `produced` (which families to consider) and `protect`
+ * (paths the run itself just wrote). Here every row is produced — a by-hand
+ * prune considers every family present — and NOTHING is protected, because
+ * there is no run whose output must survive its own cleanup. The newest `keep`
+ * of each family is already safe: that is `pruneVictims`' own rule, not
+ * something this function adds.
+ */
+export declare function planFamilySweep(rows: readonly SweepRow[], keep: FamilyKeep): SweepPlan;
+/**
+ * What each chip says — every keep-N, counted over the same rows.
+ *
+ * The same function the chip's tap uses (`planFamilySweep`), for
+ * `sweepCounts`' reason: a second copy of the edge is how a badge becomes a
+ * liar. The ladder nests, so the numbers descend left to right.
+ */
+export declare function familyCounts(rows: readonly SweepRow[]): Record<FamilyKeep, SweepTally>;
+/**
+ * The sentence under the button: what STAYS, and across how many families.
+ *
+ * `sweepKeepText`'s job, worded for this cut — a destructive control that only
+ * describes what it destroys leaves the reader to derive the complement, which
+ * is the half they care about.
+ */
+export declare function familyKeepText(plan: SweepPlan, keep: FamilyKeep, families: number): string;
+/** What the primary button says. `sweepButtonText`'s rule — the whole decision
+ *  restated — with the word that says WHY these and not others. */
+export declare function familyButtonText(plan: SweepPlan): string;

package/node_modules/@waterplane/shared/dist/sweepfamilies.js

@@ -0,0 +1,140 @@
+/**
+ * The build prune, offered by hand — the cut that is not an age.
+ *
+ * ── Why an age chip is the wrong instrument for a pile of builds ────────────
+ *
+ * `sweep.ts` cuts on how OLD a file is, which is the right question for a
+ * transport directory in general and the wrong one for the thing that actually
+ * fills it. Measured on this desktop: `picture-app/.claude/outbox` held 4.5 GB,
+ * 33 of its 38 files APKs across 13 build families; `Tiptoi` held 2.5 GB, with
+ * `tiptoi-debug-dirty.apk` alone a family of **72**. What a person wants there
+ * is not "older than 30 days" — it is "I keep the newest few of each thing, and
+ * the rest are builds I have already replaced".
+ *
+ * The age chip catches those files too, and catches them BLINDLY: 30 days over
+ * picture-app selects 28 of 38 without knowing that some of those 28 are the
+ * newest copy of a variant nothing has rebuilt since. This cut knows.
+ *
+ * ── Why it is `pruneVictims`, and not a second rule ─────────────────────────
+ *
+ * `artifacts.ts` already answers "is this an older build of the same thing?" —
+ * `familyKey` is the phone's de-duplication rule AND the desktop's automatic
+ * prune, deliberately one function so the two cannot disagree. This is the
+ * third reader of that same question, so it is the same function again, called
+ * with every row as "produced" and nothing protected: a by-hand prune has no
+ * run to protect.
+ *
+ * ── What this does NOT do ───────────────────────────────────────────────────
+ *
+ *  - **It is never combined with an age.** Two predicates feeding one number is
+ *    two copies of the edge, which is what CLAUDE.md's "a count on a control is
+ *    a filter" forbids. The chip rows are mutually exclusive: picking a keep-N
+ *    clears the age, and picking an age clears the keep-N.
+ *  - **It is outbox-only.** An inbox holds photos, whose names are all-variable
+ *    (`1000074170.jpg`), so `familyKey` falls back to the exact path and
+ *    nothing ever supersedes anything — every photo would be its own family of
+ *    one, every cut empty. Offering a control that can only ever select nothing
+ *    is worse than not offering it.
+ *  - **It applies itself to nothing.** Like `sweep.ts`: it plans, the plan's
+ *    own rows are what get POSTed, and a person taps twice.
+ *
+ * Pure — no fs, no clock at all (unlike `sweep.ts`, this cut does not depend on
+ * "now", only on the order the files were written). `shared/test/sweepfamilies.test.mjs`.
+ */
+import { familyKey, pruneVictims } from "./artifacts.js";
+import { fmtBytes, tally } from "./sweep.js";
+/** Widest cut first — the order the chips are drawn in, and the order that
+ *  makes the nesting visible (keep-1's victims contain keep-3's, which contain
+ *  keep-5's). */
+export const FAMILY_KEEPS = [1, 3, 5];
+/** Said in full wherever it is said — "3" is a key, never a label. */
+export const FAMILY_KEEP_LABEL = {
+    1: "keep only the newest of each",
+    3: "keep the newest 3 of each",
+    5: "keep the newest 5 of each",
+};
+/**
+ * How many distinct things this directory holds builds OF.
+ *
+ * Printed beside every count here, because "14 of 38 files" is unreadable on
+ * its own: it could be one family of 38 or 19 families of two, and those are
+ * completely different decisions. "14 of 38, across 13 build families" is the
+ * sentence that says what kind of directory you are looking at.
+ */
+export function familyCount(rows) {
+    const keys = new Set();
+    for (const r of rows)
+        keys.add(familyKey(r.relPath));
+    return keys.size;
+}
+/**
+ * The cut, as a plan a person can be shown and then approve verbatim.
+ *
+ * `pruneVictims` takes `produced` (which families to consider) and `protect`
+ * (paths the run itself just wrote). Here every row is produced — a by-hand
+ * prune considers every family present — and NOTHING is protected, because
+ * there is no run whose output must survive its own cleanup. The newest `keep`
+ * of each family is already safe: that is `pruneVictims`' own rule, not
+ * something this function adds.
+ */
+export function planFamilySweep(rows, keep) {
+    const byPath = new Map();
+    for (const r of rows)
+        byPath.set(r.relPath, r);
+    const victims = pruneVictims(rows.map((r) => ({ relPath: r.relPath, mtime: r.mtime })), rows.map((r) => r.relPath), keep, []);
+    const hit = victims
+        .map((v) => byPath.get(v.relPath))
+        .filter((r) => !!r)
+        // Newest first, matching every other file listing in this app — the reader
+        // is checking "is anything here I still want".
+        .sort((a, b) => b.mtime - a.mtime);
+    const t = tally(hit);
+    return {
+        rows: hit,
+        count: t.count,
+        bytes: t.bytes,
+        total: tally(rows),
+        oldestMtime: hit.length ? Math.min(...hit.map((r) => r.mtime)) : null,
+    };
+}
+/**
+ * What each chip says — every keep-N, counted over the same rows.
+ *
+ * The same function the chip's tap uses (`planFamilySweep`), for
+ * `sweepCounts`' reason: a second copy of the edge is how a badge becomes a
+ * liar. The ladder nests, so the numbers descend left to right.
+ */
+export function familyCounts(rows) {
+    const out = {};
+    for (const keep of FAMILY_KEEPS) {
+        const plan = planFamilySweep(rows, keep);
+        out[keep] = { count: plan.count, bytes: plan.bytes };
+    }
+    return out;
+}
+/**
+ * The sentence under the button: what STAYS, and across how many families.
+ *
+ * `sweepKeepText`'s job, worded for this cut — a destructive control that only
+ * describes what it destroys leaves the reader to derive the complement, which
+ * is the half they care about.
+ */
+export function familyKeepText(plan, keep, families) {
+    const keptCount = plan.total.count - plan.count;
+    const keptBytes = plan.total.bytes - plan.bytes;
+    const fam = `${families} build ${families === 1 ? "family" : "families"}`;
+    if (!plan.total.count)
+        return "Nothing here.";
+    if (!plan.count) {
+        return `Nothing here is superseded — every one of the ${plan.total.count} files is among the newest ${keep} of its family (${fam}).`;
+    }
+    return `${keptCount} file${keptCount === 1 ? "" : "s"} stay (${fmtBytes(keptBytes)}) — the newest ${keep} of each of ${fam}.`;
+}
+/** What the primary button says. `sweepButtonText`'s rule — the whole decision
+ *  restated — with the word that says WHY these and not others. */
+export function familyButtonText(plan) {
+    if (!plan.count)
+        return "Nothing superseded";
+    return `Delete ${plan.count} superseded build${plan.count === 1 ? "" : "s"} · ${fmtBytes(plan.bytes)}`;
+}
+//# sourceMappingURL=sweepfamilies.js.map

package/node_modules/@waterplane/shared/dist/sweepfamilies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sweepfamilies.js","sourceRoot":"","sources":["../src/sweepfamilies.ts"],"names":[],"mappings":"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"}

package/node_modules/@waterplane/shared/dist/termpalette.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The terminal's background and foreground, per theme — the one statement of
+ * them both ends read.
+ *
+ * The phone paints its xterm.js grid with these (`web/termTheme.ts`, which adds
+ * the light theme's sixteen ANSI colours on top). The host answers the tmux
+ * client's OSC 10/11 colour queries with them (`host/termqueries.ts`), and
+ * tmux hands the same answer to the CLI when IT asks for the background — so
+ * the colour the CLI picks its own contrast against is the colour the phone
+ * actually draws behind it, whether or not a phone is attached.
+ */
+export type TermThemeName = "dark" | "light";
+export interface TermColors {
+    background: string;
+    foreground: string;
+}
+export declare const TERM_COLORS: Readonly<Record<TermThemeName, Readonly<TermColors>>>;

package/node_modules/@waterplane/shared/dist/termpalette.js

@@ -0,0 +1,5 @@
+export const TERM_COLORS = {
+    dark: { background: "#0b0d10", foreground: "#d6dce5" },
+    light: { background: "#fcfcfd", foreground: "#1c2430" },
+};
+//# sourceMappingURL=termpalette.js.map

package/node_modules/@waterplane/shared/dist/termpalette.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"termpalette.js","sourceRoot":"","sources":["../src/termpalette.ts"],"names":[],"mappings":"AAeA,MAAM,CAAC,MAAM,WAAW,GAA0D;IAChF,IAAI,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE;IACtD,KAAK,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE;CACxD,CAAC"}