@coderook/cli 0.31.0 → 0.31.1

package/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "coderook",
   "displayName": "CodeRook",
   "description": "Save, browse and restore whole-snapshot versions of a project on CodeRook, from Claude Code.",
-  "version": "0.31.0",
+  "version": "0.31.1",
   "author": {
     "name": "ACCA Gaming Productions",
     "url": "https://coderook.com"

package/dist/cli/src/config.js

@@ -3,13 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.credentials = exports.DEFAULT_API = void 0;
+exports.DamagedLinkError = exports.credentials = exports.DEFAULT_API = void 0;
 exports.apiOrigin = apiOrigin;
 exports.configDirectory = configDirectory;
 exports.storeToken = storeToken;
 exports.loadToken = loadToken;
 exports.clearToken = clearToken;
 exports.keyFor = keyFor;
+exports.linkFileFor = linkFileFor;
 exports.readLink = readLink;
 exports.forgetLink = forgetLink;
 exports.writeLink = writeLink;
@@ -23,6 +24,7 @@ exports.writeDigests = writeDigests;
  * location follows each platform's convention rather than scattering dot
  * directories about.
  */
+const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_os_1 = require("node:os");
@@ -44,7 +46,21 @@ function configDirectory() {
     return node_path_1.default.join(process.env.XDG_CONFIG_HOME ?? node_path_1.default.join((0, node_os_1.homedir)(), ".config"), "coderook");
 }
 const tokenFile = () => node_path_1.default.join(configDirectory(), "token");
-const linksFile = () => node_path_1.default.join(configDirectory(), "links.json");
+/*
+  One small file per folder, under `links/`.
+
+  It was one file for every folder this machine had ever linked, read whole and
+  rewritten whole — pretty-printed — by every command. On a real machine that
+  file reached 419 MB across 549 folders, 536 of which no longer existed, and
+  every `cbx` paid about three seconds to read it before doing anything and
+  another two and a half to write it back after a save. It also lost updates:
+  two commands in two folders each rewrote the lot, and the later one erased
+  the earlier one's change.
+
+  The old file is read once, split into these, and renamed out of the way.
+*/
+const linksDirectory = () => node_path_1.default.join(configDirectory(), "links");
+const legacyLinksFile = () => node_path_1.default.join(configDirectory(), "links.json");
 /**
  * Write a file only its owner can read, and atomically.
  *
@@ -136,17 +152,165 @@ function keyFor(localPath) {
 }
 /** How the key used to be worked out, so existing links keep working. */
 const legacyKeyFor = (localPath) => node_path_1.default.resolve(localPath).toLowerCase();
-async function readLinks() {
+/**
+ * A link record that exists and cannot be read.
+ *
+ * Deliberately not the same as "no link". Reading a damaged record as absent
+ * makes a linked folder look new, and the next save creates a second project
+ * beside the real one — so this stops and names the file instead.
+ */
+class DamagedLinkError extends Error {
+    file;
+    constructor(file, cause) {
+        super(`CodeRook's record of which project a folder belongs to is damaged: ${file}\n` +
+            "Nothing was changed. Restore that file from a backup, or move it aside " +
+            "to treat the folder as not yet linked.");
+        this.file = file;
+        this.name = "DamagedLinkError";
+        this.cause = cause;
+    }
+}
+exports.DamagedLinkError = DamagedLinkError;
+/** The file one folder's link lives in. Hashed, because a key is a path. */
+function linkFileFor(localPath) {
+    return storedFileFor(keyFor(localPath));
+}
+const storedFileFor = (key) => node_path_1.default.join(linksDirectory(), `${(0, node_crypto_1.createHash)("sha256").update(key).digest("hex").slice(0, 32)}.json`);
+function sameMap(left, right) {
+    const keys = Object.keys(left);
+    if (keys.length !== Object.keys(right).length)
+        return false;
+    for (const key of keys)
+        if (left[key] !== right[key])
+            return false;
+    return true;
+}
+function pack(key, link) {
+    const { local, ...rest } = link;
+    if (local && sameMap(local, link.manifest)) {
+        return { key, link: { ...rest, localIsManifest: true } };
+    }
+    return { key, link: local ? { ...rest, local } : rest };
+}
+function unpack(stored) {
+    const { localIsManifest, ...link } = stored.link;
+    /* A copy, so a caller changing one cannot quietly change the other. */
+    return localIsManifest ? { ...link, local: { ...link.manifest } } : link;
+}
+async function exists(file) {
+    return (0, promises_1.access)(file).then(() => true, () => false);
+}
+/** One folder's record: undefined when there is none, and loud when damaged. */
+async function readStored(key) {
+    const file = storedFileFor(key);
+    let text;
     try {
-        return JSON.parse(await (0, promises_1.readFile)(linksFile(), "utf8"));
+        text = await (0, promises_1.readFile)(file, "utf8");
     }
-    catch {
-        return {};
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+    try {
+        const stored = JSON.parse(text);
+        if (stored?.key !== key)
+            throw new Error("the record is for another folder");
+        return stored;
+    }
+    catch (error) {
+        throw new DamagedLinkError(file, error);
     }
 }
+/**
+ * Write a record only if there is not one already.
+ *
+ * The migration's writer. A link written by a command running at the same
+ * moment is newer than anything in the old file, and must win. A hard link
+ * makes "create only if absent" one atomic step, and a reader never sees a
+ * half-written file; where the disk cannot do hard links the check and the
+ * move are two steps, which is only a race against a command in that same
+ * folder in the same instant.
+ */
+async function writeStoredIfAbsent(stored) {
+    const target = storedFileFor(stored.key);
+    if (await exists(target))
+        return;
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(target), { recursive: true });
+    const temporary = `${target}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.tmp`;
+    await (0, promises_1.writeFile)(temporary, JSON.stringify(stored), "utf8");
+    await (0, promises_1.chmod)(temporary, 0o600).catch(() => undefined);
+    try {
+        await (0, promises_1.link)(temporary, target);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "EEXIST" && !(await exists(target))) {
+            await (0, promises_1.rename)(temporary, target);
+            return;
+        }
+    }
+    finally {
+        await (0, promises_1.rm)(temporary, { force: true }).catch(() => undefined);
+    }
+}
+/**
+ * Split the old single file into one per folder, once.
+ *
+ * Whoever renames it to `.migrating` first does the work, and anyone arriving
+ * while that is going on — or after a run that was interrupted — works from
+ * the `.migrating` copy too. Every write here is "only if absent", so running
+ * it twice is harmless and a newer link written meanwhile is never overwritten.
+ *
+ * A damaged old file is put back and reported rather than migrated as empty:
+ * that would silently unlink every folder on the machine.
+ */
+async function migrateLegacyLinks() {
+    const legacy = legacyLinksFile();
+    const claimed = `${legacy}.migrating`;
+    await (0, promises_1.rename)(legacy, claimed).catch(() => undefined);
+    let text;
+    try {
+        text = await (0, promises_1.readFile)(claimed, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    let links;
+    try {
+        links = JSON.parse(text);
+    }
+    catch (error) {
+        await (0, promises_1.rename)(claimed, legacy).catch(() => undefined);
+        throw new DamagedLinkError(legacy, error);
+    }
+    for (const [key, link] of Object.entries(links)) {
+        await writeStoredIfAbsent(pack(key, link));
+    }
+    /* Kept rather than deleted: it is somebody's data, and moving it is enough. */
+    await (0, promises_1.rename)(claimed, `${legacy}.migrated`).catch(() => undefined);
+}
+async function lookUp(localPath) {
+    for (const key of new Set([keyFor(localPath), legacyKeyFor(localPath)])) {
+        const stored = await readStored(key);
+        if (!stored)
+            continue;
+        if ("forgotten" in stored)
+            return null;
+        return unpack(stored);
+    }
+    return null;
+}
 async function readLink(localPath) {
-    const links = await readLinks();
-    const link = links[keyFor(localPath)] ?? links[legacyKeyFor(localPath)] ?? null;
+    let link = await lookUp(localPath);
+    if (!link &&
+        ((await exists(legacyLinksFile())) ||
+            (await exists(`${legacyLinksFile()}.migrating`)))) {
+        await migrateLegacyLinks();
+        link = await lookUp(localPath);
+    }
     if (!link)
         return null;
     return {
@@ -162,27 +326,27 @@ async function readLink(localPath) {
  * afterwards — which is the one thing this is for.
  */
 async function forgetLink(localPath) {
-    const links = await readLinks();
-    const had = links[keyFor(localPath)] !== undefined ||
-        links[legacyKeyFor(localPath)] !== undefined;
-    if (!had)
+    if (!(await readLink(localPath)))
         return false;
-    delete links[keyFor(localPath)];
-    delete links[legacyKeyFor(localPath)];
-    await writePrivate(linksFile(), JSON.stringify(links, null, 2));
+    for (const key of new Set([keyFor(localPath), legacyKeyFor(localPath)])) {
+        const forgotten = { key, forgotten: true };
+        await writePrivate(storedFileFor(key), JSON.stringify(forgotten));
+    }
     return true;
 }
 async function writeLink(localPath, link) {
-    const links = await readLinks();
-    // A folder recorded under the old key moves to the new one rather than
-    // being left behind as a second connection to the same place.
-    delete links[legacyKeyFor(localPath)];
+    const key = keyFor(localPath);
     const baseVersionId = link.baseVersionId ?? link.versionId;
-    links[keyFor(localPath)] = {
+    const stored = pack(key, {
         ...link,
         ...(baseVersionId ? { baseVersionId, versionId: baseVersionId } : {}),
-    };
-    await writePrivate(linksFile(), JSON.stringify(links, null, 2));
+    });
+    await writePrivate(storedFileFor(key), JSON.stringify(stored));
+    // A folder recorded under the old key moves to the new one rather than
+    // being left behind as a second connection to the same place.
+    const legacy = legacyKeyFor(localPath);
+    if (legacy !== key)
+        await (0, promises_1.rm)(storedFileFor(legacy), { force: true });
 }
 const digestsFile = (projectId) => node_path_1.default.join(configDirectory(), "digests", `${projectId}.json`);
 async function readDigests(projectId) {

package/dist/desktop-app/src/main/compress.js

@@ -55,6 +55,27 @@ async function encodeForUpload(original, relativePath, allowGzip) {
     if (!(0, compression_policy_1.shouldTryGzip)(relativePath, original.byteLength, allowGzip))
         return plain;
     try {
+        /*
+          Ask a little of it before asking all of it.
+    
+          The extension list is a guess and the cost of a miss used to be the whole
+          file. Two sampled windows make it an eighth of that, which is what lets
+          the decision stay measured — the principle above — for a format nothing
+          here has heard of, instead of measured-at-any-price.
+        */
+        if ((0, compression_policy_1.worthSampling)(original.byteLength)) {
+            let anyWindowArguesFor = false;
+            for (const window of (0, compression_policy_1.sampleWindows)(original.byteLength)) {
+                const sample = original.subarray(window.at, window.at + window.size);
+                const tried = await deflate(sample, { level: 6 });
+                if (!(0, compression_policy_1.sampleSaysDoNotBother)(sample.byteLength, tried.byteLength)) {
+                    anyWindowArguesFor = true;
+                    break;
+                }
+            }
+            if (!anyWindowArguesFor)
+                return plain;
+        }
         const packed = await deflate(original, { level: 6 });
         if (!(0, compression_policy_1.gzipIsWorthKeeping)(original.byteLength, packed.byteLength))
             return plain;

package/dist/desktop-app/src/main/detect.js

@@ -25,6 +25,7 @@ exports.rulesFromSuggestions = rulesFromSuggestions;
  * exactly as long as nothing is applied without somebody saying so.
  */
 const node_path_1 = __importDefault(require("node:path"));
+const format_js_1 = require("../shared/format.js");
 /*
   Everything here is recoverable from something else in the project, or is
   another program's working state. Nothing that could be somebody's only copy
@@ -302,6 +303,46 @@ const BULK_FILES = 2_000;
 const BULK_SHARE = 0.7;
 /** Above this share of hand-written files it is source, not output. */
 const BULK_SOURCE_SHARE = 0.1;
+/**
+ * And the same question asked in bytes, for a folder that is huge but not many.
+ *
+ * Counting files misses the shape that actually stops a save finishing. A real
+ * project — 253 files — kept thirteen `.gguf` model weights in `output/`: 73
+ * files, 10.67 GB, 99% of everything it would have sent and 29% of its file
+ * count. Every threshold above is about counts, so nothing was suggested, and
+ * the app set out to upload 10.7 GB of rebuildable model output without a word.
+ * It never finished, and the project still has no version.
+ *
+ * A gigabyte is the floor because below it the upload is not the problem and
+ * the question is not worth asking. The share is the same 0.7: a folder that is
+ * most of the bytes, whatever its file count.
+ */
+const BULK_BYTES = 1024 * 1024 * 1024;
+/*
+  Media somebody made, as opposed to bytes a machine emitted.
+
+  Needed only by the size test, and needed badly there. `SOURCE_EXTENSIONS`
+  above asks "did a person type this", which is the right question for a folder
+  judged on its file count — a cache holds no `.ts` files. It is the wrong
+  question for a folder judged on its size, because a game's art holds no `.ts`
+  files either, and by bytes the art is almost always most of the project. The
+  count rule has a calibration case for exactly that folder; a size rule without
+  this list would walk straight back into it and offer to leave the game out.
+*/
+const AUTHORED_EXTENSIONS = new Set([
+    ".aseprite", ".blend", ".bmp", ".dds", ".exr", ".fbx", ".flac", ".gif",
+    ".glb", ".gltf", ".hdr", ".jpeg", ".jpg", ".m4a", ".mov", ".mp3", ".mp4",
+    ".obj", ".ogg", ".otf", ".pdf", ".png", ".psd", ".svg", ".tga", ".tif",
+    ".tiff", ".ttf", ".wav", ".webm", ".webp", ".woff", ".woff2",
+]);
+/**
+ * Above this share of a folder's *bytes* it is a library of made things.
+ *
+ * By bytes rather than by file count, because that is the currency the test it
+ * guards is arguing in: one 4 GB video beside a thousand generated logs is a
+ * folder of video, and counting files would call it a folder of logs.
+ */
+const AUTHORED_BYTE_SHARE = 0.5;
 /**
  * One enormous folder that no list of names could have known about.
  *
@@ -309,42 +350,70 @@ const BULK_SOURCE_SHARE = 0.1;
  * things every project has and not at all for the one a person invented. This
  * repository's own `work/` is 63,210 of the 64,554 files it would otherwise
  * send — scratch output from a test harness, named nothing in particular, and
- * invisible to every rule in this file.
+ * invisible to every rule in this file. Another project's `output/` is 10.67 GB
+ * of model weights in 73 files, which no count-based threshold can see at all.
  *
- * So this asks about shape instead of name: one folder that is most of the
- * upload and holds no source in it. Never recommended, because the same shape
- * is also what a genuine dataset looks like, and a project whose work really
- * is fifty thousand data files should be asked once and then believed.
+ * So this asks about shape instead of name, in both currencies: one folder that
+ * is most of what would be sent — by file count or by size — and holds no
+ * source in it. Never recommended, because the same shape is also what a
+ * genuine dataset looks like, and a project whose work really is fifty thousand
+ * data files should be asked once and then believed.
  */
 function suggestBulkDirectories(files) {
-    if (files.length < BULK_FILES)
-        return [];
     const tally = new Map();
+    let totalBytes = 0;
     for (const entry of files) {
         const normalised = entry.path.split("\\").join("/");
+        totalBytes += entry.size;
         const top = normalised.includes("/") ? normalised.slice(0, normalised.indexOf("/")) : "";
         /* A file at the root belongs to no folder, so it cannot be one of these. */
         if (!top)
             continue;
-        const held = tally.get(top) ?? { bytes: 0, files: 0, source: 0 };
+        const held = tally.get(top) ?? { bytes: 0, files: 0, source: 0, authored: 0 };
+        const extension = node_path_1.default.extname(normalised).toLowerCase();
         held.bytes += entry.size;
         held.files += 1;
-        if (SOURCE_EXTENSIONS.has(node_path_1.default.extname(normalised).toLowerCase()))
+        if (SOURCE_EXTENSIONS.has(extension))
             held.source += 1;
+        if (AUTHORED_EXTENSIONS.has(extension))
+            held.authored += entry.size;
         tally.set(top, held);
     }
     const found = [];
     for (const [top, held] of tally) {
-        if (held.files < BULK_FILES)
-            continue;
-        if (held.files / files.length < BULK_SHARE)
-            continue;
+        /*
+          Whatever else is true of it, a folder with source in it is somebody's
+          work. This is the one test both shapes below have to pass.
+        */
         if (held.source / held.files >= BULK_SOURCE_SHARE)
             continue;
+        const byCount = files.length >= BULK_FILES &&
+            held.files >= BULK_FILES &&
+            held.files / files.length >= BULK_SHARE;
+        const byBytes = held.bytes >= BULK_BYTES &&
+            held.bytes / Math.max(totalBytes, 1) >= BULK_SHARE &&
+            /*
+              And it is not a library of made things. A game's art is most of a game
+              by size and is the last thing anybody wants left out of the save.
+            */
+            held.authored / Math.max(held.bytes, 1) < AUTHORED_BYTE_SHARE;
+        if (!byCount && !byBytes)
+            continue;
+        /*
+          Described in whichever currency makes the case. "73 of 253 files" is not
+          an argument for leaving anything out; "10.7 GB of 10.8 GB" is the entire
+          argument, and the person reading it is deciding whether to spend an
+          evening uploading. Where both are true, size is still the thing that
+          hurts, so size is what gets said.
+        */
+        const reason = byBytes
+            ? `${(0, format_js_1.formatBytes)(held.bytes)} of ${(0, format_js_1.formatBytes)(totalBytes)}, ` +
+                `and no source in it — generated?`
+            : `${held.files.toLocaleString()} of ${files.length.toLocaleString()} files, ` +
+                `and no source in it — generated?`;
         found.push({
             pattern: `${top}/`,
-            reason: `${held.files.toLocaleString()} of ${files.length.toLocaleString()} files, ` +
-                `and no source in it — generated?`,
+            reason,
             bytes: held.bytes,
             files: held.files,
             recommended: false,

package/dist/desktop-app/src/main/upload.js

@@ -21,6 +21,7 @@ const identify_js_1 = require("./identify.js");
 const worktree_js_1 = require("./worktree.js");
 const publish_name_js_1 = require("./publish_name.js");
 const compress_js_1 = require("./compress.js");
+const compression_policy_js_1 = require("../shared/compression_policy.js");
 const chunking_js_1 = require("../shared/chunking.js");
 const publication_js_1 = require("../shared/publication.js");
 const profile_js_1 = require("./profile.js");
@@ -125,9 +126,21 @@ class Uploader {
     /** One shared preflight, so parallel upload lanes cannot race /health. */
     capabilityRequest = null;
     telemetry = new telemetry_js_1.RepositoryTelemetry();
-    /** Planning runs the real partition/compression choices without body I/O. */
+    /*
+      Planning makes the real partition and compression choices, and for a
+      chunked file that means reading it: a chunk's identity is the digest of its
+      bytes, and the quote has to name every one. This comment used to say the
+      plan did no body I/O, which was never true, and the belief that it was is
+      how the send came to do all of that reading a second time.
+    */
     planning = false;
     plannedObjects = new Map();
+    /**
+     * Where each chunked file was cut, as the plan found it, so the send does not
+     * cut it again. Keyed by path and whole-file digest: a file that changed in
+     * between has a different digest, finds nothing here, and is walked afresh.
+     */
+    plannedLayouts = new Map();
     plannedQuote = null;
     /*
       Digests worked out while planning, so sending does not work them out again.
@@ -320,6 +333,7 @@ class Uploader {
         this.plannedQuote = null;
         this.planningCreatedRepositoryId = null;
         this.plannedObjects.clear();
+        this.plannedLayouts.clear();
         try {
             await this.runPass(request, report);
             const quote = this.plannedQuote;
@@ -2075,18 +2089,36 @@ class Uploader {
      */
     async putChunked(repositoryId, declaration, profile, onOffset) {
         /*
-          Read in windows, not all at once.
+          Three steps, and each file is read for as long as it has to be.
     
-          This used to load the whole file to chunk it, which for the files that
-          reach this path — everything past sixteen megabytes — meant an allocation
-          the size of the file. A three gigabyte video was a three gigabyte buffer
-          and an out-of-memory crash partway through an upload, which is the one
-          failure worse than a slow one: it happens after the work.
+          This used to walk the file once, asking the service about every four
+          chunks as it went and waiting for each answer before reading on — then
+          the send walked it again and asked all over again. A 10.6 GB project is
+          8,395 chunks: 2,099 lookups per pass, one after another, at about a
+          third of a second each. Twelve minutes of waiting per pass, on a stage
+          the window labels "Working out what to send", before a byte had moved.
     
-          The window holds at most one read plus one maximum chunk, whatever the
-          file is. Exactly how cbx.ts packs a bundle, and for the same reason.
+          Now: find where the file is cut and what each piece's digest is (the plan
+          does this; the send is handed the plan's answer), ask about every digest
+          at once — one request per five thousand — and then read only the pieces
+          that are not already held, by position, several at a time.
         */
-        const chunks = [];
+        const key = `${declaration.path}\n${declaration.sha256}`;
+        let layout = this.planning ? undefined : this.plannedLayouts.get(key);
+        /*
+          Walking the file is half this file's progress when it happens here and
+          none of it when the plan already did it, so the bar neither jumps back
+          between the two halves nor sits still through the first.
+        */
+        const walking = !layout;
+        if (!layout) {
+            layout = await this.layoutOf(declaration, profile, (offset) => onOffset(Math.floor(offset / 2)));
+            if (this.planning)
+                this.plannedLayouts.set(key, layout);
+        }
+        const already = walking ? declaration.size / 2 : 0;
+        const share = walking ? 0.5 : 1;
+        const chunks = new Array(layout.length);
         let reused = 0;
         let sent = 0;
         let done = 0;
@@ -2096,6 +2128,12 @@ class Uploader {
             else
                 sent += bytes;
         };
+        /*
+          Asked all at once, because nothing about the question needs the bytes.
+          The old batch was capped at four because each entry held a piece in
+          memory; the digests alone are sixty-four characters each.
+        */
+        const held = await this.storedInBulk(repositoryId, layout.map((piece) => piece.digest));
         /*
           A file's chunks go up several at a time.
     
@@ -2105,68 +2143,108 @@ class Uploader {
           out and only the big one was left — five lanes idle while one crawled.
           For a folder that is *one* large file, that was the whole upload.
     
-          Bounded tighter than the file lanes because each one holds a piece in
-          memory: four in flight of at most a maximum chunk each, rather than six.
+          Bounded because each lane holds one piece in memory: four in flight of
+          at most a maximum chunk each.
         */
         const CHUNK_LANES = 4;
-        const active = new Set();
-        const dispatch = async (piece, at, digest) => {
-            const task = this.sendChunk(repositoryId, declaration, piece, digest, chunks, at, note).finally(() => {
-                active.delete(task);
-                done += piece.length;
-                onOffset(done);
-            });
-            active.add(task);
-            if (active.size >= CHUNK_LANES)
-                await Promise.race(active);
-        };
         /*
-          Ask about a bounded group of chunks before sending any of them.
-    
-          The old path asked once per chunk, with four GETs in flight. Besides
-          spending one network round trip per piece, an unavailable lookup was
-          deliberately treated as a miss, so a transient failure retransmitted
-          every otherwise reusable chunk. The website already uses the bulk
-          endpoint. Reusing it here gives Desktop and CLI the same wire behaviour
-          while retaining the safe "send it if unsure" fallback.
-    
-          A batch is no larger than the existing chunk lane count, so this does
-          not increase the memory ceiling: at most four bounded pieces are held.
+          One verdict for this file, shared by its lanes, and consulted only where
+          the plan has not already decided. The send takes each chunk's encoding
+          from the plan instead, because the service holds every object to exactly
+          what was quoted and rejects anything else — and this verdict depends on
+          which of four lanes finishes compressing first, so two passes asking it
+          separately could disagree about a chunk right where it gives up.
         */
-        const batch = [];
-        const flush = async () => {
-            if (!batch.length)
-                return;
-            const ready = batch.splice(0, batch.length);
-            const held = await this.storedInBulk(repositoryId, ready.map((item) => item.digest));
-            for (const item of ready) {
-                const stored = held.get(item.digest);
-                if (stored) {
-                    note("reused", 0);
-                    chunks[item.at] = {
-                        objectId: stored.objectId,
-                        sourceSize: item.piece.length,
-                        storedSize: stored.size,
-                    };
-                    done += item.piece.length;
-                    onOffset(done);
-                    continue;
+        const gzip = (0, compression_policy_js_1.freshGzipVerdict)();
+        const pieces = layout;
+        const file = await (0, promises_1.open)(declaration.full, "r");
+        try {
+            let cursor = 0;
+            const lane = async () => {
+                for (;;) {
+                    const at = cursor;
+                    cursor += 1;
+                    if (at >= pieces.length)
+                        return;
+                    this.check();
+                    const piece = pieces[at];
+                    const stored = held.get(piece.digest);
+                    if (stored) {
+                        note("reused", 0);
+                        chunks[at] = {
+                            objectId: stored.objectId,
+                            sourceSize: piece.length,
+                            storedSize: stored.size,
+                        };
+                    }
+                    else {
+                        const bytes = Buffer.allocUnsafe(piece.length);
+                        let got = 0;
+                        while (got < piece.length) {
+                            const { bytesRead } = await file.read(bytes, got, piece.length - got, piece.offset + got);
+                            if (!bytesRead)
+                                break;
+                            got += bytesRead;
+                        }
+                        /*
+                          Checked, because the layout may be the plan's and the file may
+                          have been written to since without its size or time moving. The
+                          service would refuse the piece anyway; this says why, in words.
+                        */
+                        if (got !== piece.length ||
+                            (0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex") !== piece.digest) {
+                            throw new Error(`${declaration.path} changed while it was being saved. ` +
+                                "Save again to send what it holds now.");
+                        }
+                        await this.sendChunk(repositoryId, declaration, bytes, piece.digest, chunks, at, note, gzip);
+                    }
+                    done += piece.length;
+                    onOffset(Math.floor(already + done * share));
                 }
-                await dispatch(item.piece, item.at, item.digest);
+            };
+            await Promise.all(Array.from({ length: Math.min(CHUNK_LANES, pieces.length) }, () => lane()));
+        }
+        finally {
+            await file.close();
+        }
+        /*
+          Order is the file. Every position must be filled: a hole would mean a
+          chunk that never landed, and publishing around it would produce a version
+          whose bytes are individually verified and collectively wrong.
+    
+          Counted by index rather than with `some`, which skips the holes of a
+          sparse array — the one thing this check exists to find — and so could
+          never have fired.
+        */
+        for (let at = 0; at < pieces.length; at += 1) {
+            if (!chunks[at]) {
+                throw new Error(`${declaration.path}: a chunk did not finish uploading`);
             }
-            await Promise.all(active);
-        };
-        const queue = async (piece) => {
-            batch.push({
-                piece,
-                at: ordinal++,
-                digest: (0, node_crypto_1.createHash)("sha256").update(piece).digest("hex"),
-            });
-            if (batch.length >= CHUNK_LANES)
-                await flush();
+        }
+        return {
+            chunks: chunks,
+            reused,
+            sentBytes: sent,
         };
-        let ordinal = 0;
+    }
+    /**
+     * Where a file is cut into chunks, and the digest of each piece.
+     *
+     * Read in windows, not all at once. This used to load the whole file to
+     * chunk it, which for the files that reach this path meant an allocation the
+     * size of the file: a three gigabyte video was a three gigabyte buffer and an
+     * out-of-memory crash partway through an upload. The window holds at most
+     * one read plus one maximum chunk, whatever the file is — exactly how cbx.ts
+     * packs a bundle, and for the same reason.
+     *
+     * Nothing is kept but offsets and digests, so a ten gigabyte file costs a few
+     * hundred kilobytes to remember between the plan and the send.
+     */
+    async layoutOf(declaration, profile, onScanned) {
+        const layout = [];
+        const digestOf = (bytes) => (0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex");
         let pending = Buffer.alloc(0);
+        let pendingAt = 0;
         for await (const block of (0, node_fs_1.createReadStream)(declaration.full, {
             highWaterMark: 8 * 1024 * 1024,
         })) {
@@ -2175,10 +2253,16 @@ class Uploader {
             pending = pending.length ? Buffer.concat([pending, incoming]) : incoming;
             let from = 0;
             for (const cut of (0, chunking_js_1.cutPoints)(pending, profile)) {
-                await queue(Buffer.from(pending.subarray(from, cut)));
+                layout.push({
+                    offset: pendingAt + from,
+                    length: cut - from,
+                    digest: digestOf(pending.subarray(from, cut)),
+                });
                 from = cut;
             }
+            pendingAt += from;
             pending = Buffer.from(pending.subarray(from));
+            onScanned(pendingAt);
         }
         /*
           cutPoints returns the boundaries *inside* what it was given and never the
@@ -2186,23 +2270,10 @@ class Uploader {
           mention — the packer in cbx.ts emits that tail itself, after its loop.
           Dropping it truncates every chunked file by exactly its last piece.
         */
-        if (pending.length)
-            await queue(pending);
-        await flush();
-        /*
-          Order is the file. Every position must be filled: a hole would mean a
-          chunk that never landed, and publishing around it would produce a version
-          whose bytes are individually verified and collectively wrong.
-        */
-        const ordered = chunks.slice(0, ordinal);
-        if (ordered.some((one) => !one)) {
-            throw new Error(`${declaration.path}: a chunk did not finish uploading`);
+        if (pending.length) {
+            layout.push({ offset: pendingAt, length: pending.length, digest: digestOf(pending) });
         }
-        return {
-            chunks: ordered,
-            reused,
-            sentBytes: sent,
-        };
+        return layout;
     }
     /** Send one chunk, reusing it if the account already holds those bytes. */
     async sendChunk(repositoryId, declaration, piece, digest, 
@@ -2213,10 +2284,29 @@ class Uploader {
       large file out of sequence, which produces bytes that are all present,
       all verified individually, and wrong.
     */
-    chunks, at, note) {
+    chunks, at, note, 
+    /** This file's running verdict on compression; see {@link noteChunkOutcome}. */
+    gzip) {
         {
             this.check();
-            const encoded = await (0, compress_js_1.encodeForUpload)(new Uint8Array(piece), declaration.path, await this.gzipAllowed());
+            /*
+              What the plan decided, where it decided. The quote names each object's
+              encoding and the service rejects a piece that arrives any other way,
+              so the send repeats the plan's answer rather than working one out. The
+              same bytes with the same answer compress to the same bytes, which is
+              what makes repeating it exact.
+            */
+            const planned = this.planning ? undefined : this.plannedObjects.get(digest);
+            const encoded = await (0, compress_js_1.encodeForUpload)(new Uint8Array(piece), declaration.path, planned
+                ? planned.encoding === "gzip"
+                : gzip.allowed && (await this.gzipAllowed()));
+            /*
+              Read the outcome back rather than the guess. A chunk that kept gzip
+              proves the file is worth compressing; a run of chunks that did not
+              proves it is not, and there is no reason to ask the rest of a gigabyte.
+            */
+            if (!planned)
+                (0, compression_policy_js_1.noteChunkOutcome)(gzip, encoded.encoding === "gzip");
             const query = encoded.encoding === "gzip"
                 ? `?kind=chunk&role=chunk&encoding=gzip` +
                     `&logicalSize=${piece.length}` +

package/dist/desktop-app/src/main/worktree.js

@@ -4,6 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IGNORE_HEADING = exports.KEEP_HEADING = exports.LOCAL_EXCLUDE_FILE = exports.IGNORE_FILE = exports.STARTER_IGNORE = exports.CODEROOK_TAIL = exports.CODEROOK_TAIL_HEADING = exports.KEPT_ANYWAY = exports.KEPT_ANYWAY_HEADING = exports.ALSO_LEFT_OUT = exports.ALSO_LEFT_OUT_HEADING = exports.STARTER_MARKER = exports.EVALUATION_FILE_LIMIT = void 0;
+exports.ruleTarget = ruleTarget;
+exports.keptTargets = keptTargets;
+exports.withoutOpposites = withoutOpposites;
 exports.starterAuthored = starterAuthored;
 exports.missingStarterRules = missingStarterRules;
 exports.missingEngineRules = missingEngineRules;
@@ -11,6 +14,7 @@ exports.isRepository = isRepository;
 exports.migrateRetiredRules = migrateRetiredRules;
 exports.starterFor = starterFor;
 exports.moveRule = moveRule;
+exports.acceptSuggestions = acceptSuggestions;
 exports.readRules = readRules;
 exports.writeRules = writeRules;
 exports.collectLayers = collectLayers;
@@ -224,6 +228,93 @@ function ruleLines(text) {
         .map((line) => line.trim())
         .filter((line) => line.length > 0 && !line.startsWith("#"));
 }
+/**
+ * What a rule line is about, with the parts that do not change the answer
+ * taken off: the `!`, and a slash at either end.
+ *
+ * `output/`, `/output/` and `!output/` all name the same folder, and deciding
+ * whether two lines disagree has to compare what they name rather than how they
+ * were spelt — the detector writes one spelling, the filter screen another, and
+ * a person a third.
+ */
+function ruleTarget(line) {
+    return line.trim().replace(/^!/, "").replace(/^\/+|\/+$/g, "");
+}
+/** Every thing this file explicitly keeps, by {@link ruleTarget}. */
+function keptTargets(text) {
+    return new Set(ruleLines(text)
+        .filter((line) => line.startsWith("!"))
+        .map(ruleTarget));
+}
+/**
+ * The file without any line that says the opposite of `line` about the same
+ * thing, and without a heading that is left with nothing under it.
+ *
+ * Needed because every writer here appends. A keep has to come after whatever
+ * would take the file, and a new ignore after a keep beats it, so the last
+ * word always wins — but the earlier word stayed in the file. A real project
+ * ended up with `# Always include` / `!output/` directly above
+ * `# Suggested for this folder, and accepted.` / `output/`: correct to a
+ * matcher, and to anybody reading it, a file that says both things.
+ *
+ * Only the exact opposite goes. A broader rule — `*.log` above a kept
+ * `!important.log` — is not about the same thing and is what makes the keep
+ * mean anything, so it is left alone. Everything the removal did not touch is
+ * returned byte for byte, line endings included.
+ */
+function withoutOpposites(body, line) {
+    const target = ruleTarget(line);
+    const keeping = line.trim().startsWith("!");
+    const lines = body.split(NEWLINE);
+    const plain = (at) => (lines[at] ?? "").trim();
+    const isRule = (at) => plain(at).length > 0 && !plain(at).startsWith("#");
+    const drop = new Set();
+    /* Paragraphs are runs of non-blank lines; a heading belongs to its own. */
+    let start = 0;
+    while (start < lines.length) {
+        if (!plain(start)) {
+            start += 1;
+            continue;
+        }
+        let end = start;
+        while (end + 1 < lines.length && plain(end + 1))
+            end += 1;
+        let touched = false;
+        for (let at = start; at <= end; at += 1) {
+            if (!isRule(at))
+                continue;
+            const other = plain(at);
+            if (ruleTarget(other) === target && other.startsWith("!") !== keeping) {
+                drop.add(at);
+                touched = true;
+            }
+        }
+        /*
+          A heading over nothing is a claim about nothing. Dropped with its
+          paragraph, and one blank line beside it, so the file does not gather
+          empty gaps where decisions used to be.
+        */
+        if (touched) {
+            let left = false;
+            for (let at = start; at <= end; at += 1) {
+                if (isRule(at) && !drop.has(at))
+                    left = true;
+            }
+            if (!left) {
+                for (let at = start; at <= end; at += 1)
+                    drop.add(at);
+                if (end + 1 < lines.length && !plain(end + 1))
+                    drop.add(end + 1);
+                else if (start > 0 && !plain(start - 1))
+                    drop.add(start - 1);
+            }
+        }
+        start = end + 1;
+    }
+    if (!drop.size)
+        return body;
+    return lines.filter((_line, at) => !drop.has(at)).join(NEWLINE);
+}
 /**
  * Whether this .gitignore was written by CodeRook rather than by a person.
  *
@@ -255,7 +346,14 @@ function starterAuthored(text) {
  */
 function missingStarterRules(text, reference = exports.STARTER_IGNORE) {
     const present = new Set(ruleLines(text));
-    return ruleLines(reference).filter((line) => !present.has(line));
+    /*
+      Not a line the person has already answered. A starter rule for something
+      this file explicitly keeps is not missing, it was overruled — and offering
+      it back would append it after the keep, where it wins, and take out the
+      very thing somebody said to always include.
+    */
+    const kept = keptTargets(text);
+    return ruleLines(reference).filter((line) => !present.has(line) && (line.startsWith("!") || !kept.has(ruleTarget(line))));
 }
 /**
  * The rules this folder's own file is missing for the kind of project it is.
@@ -423,12 +521,23 @@ async function moveRule(root, file, keep) {
         .catch(() => file.endsWith("/"));
     const target = directory ? `${bare}/` : bare;
     const line = keep ? `!${target}` : target;
+    /*
+      The opposite answer goes first. Moving a folder that was kept onto the
+      ignore list used to add `output/` after `!output/` and leave both, so the
+      file said both things and only the order decided which it meant.
+    */
+    const settled = withoutOpposites(rules.shared, line);
     /* Saying it twice changes nothing and makes the file harder to read. */
-    const already = ruleLines(rules.shared).some((one) => one === line);
-    if (already)
-        return rules;
+    const already = ruleLines(settled).some((one) => one === line);
+    if (already) {
+        if (settled === rules.shared)
+            return rules;
+        const next = { ...rules, shared: settled };
+        await writeRules(root, next);
+        return next;
+    }
     const heading = keep ? exports.KEEP_HEADING : exports.IGNORE_HEADING;
-    let body = rules.shared.replace(/\s*$/, "");
+    let body = settled.replace(/\s*$/, "");
     /*
       A keep inside an excluded folder needs the folder opened first.
   
@@ -484,6 +593,85 @@ async function moveRule(root, file, keep) {
     await writeRules(root, next);
     return next;
 }
+/**
+ * Take the suggestions somebody accepted, and write them.
+ *
+ * The accepted patterns and the missing starter lines are written as two
+ * labelled blocks rather than one, because they answer different questions:
+ * one is "this folder holds a cache", the other is "the rules this folder
+ * was set up with have moved on". A person reading the file later should be
+ * able to tell which was which.
+ *
+ * Lifted out of the window's event handler for the same reason `moveRule` was:
+ * inside it nothing could test it, and the defect it had — leaving the keep it
+ * had just overruled in the file — was found by a person reading their own
+ * .gitignore rather than by anything here.
+ */
+async function acceptSuggestions(root, patterns, starter) {
+    const rules = await readRules(root);
+    /*
+      A suggestion somebody accepts is their answer about that folder, and it
+      replaces any earlier one. A real project kept `# Always include` /
+      `!output/` directly above the `output/` the size prompt had just
+      written: right to a matcher, because the later line wins, and to
+      anybody reading the file a flat contradiction.
+  
+      Starter lines are the other way round. Nobody chose those one by one,
+      so they never overrule a keep — `missingStarterRules` already leaves
+      out anything kept, and this skips it again in case the file changed
+      between the prompt being drawn and the button being pressed.
+    */
+    let settled = rules.shared;
+    for (const pattern of patterns)
+        settled = withoutOpposites(settled, pattern);
+    const keptNow = keptTargets(settled);
+    starter = starter.filter((line) => line.startsWith("!") || !keptNow.has(ruleTarget(line)));
+    /*
+      Added to, never stacked.
+  
+      The first version of this appended a fresh block every time, so a
+      folder that grew a second cache later ended up with two identical
+      headings and the same rule written twice — the same fault the template
+      appender had already been fixed for. Lines that are already in the file
+      are skipped, and a heading that is already there is extended under
+      itself rather than repeated.
+    */
+    const has = new Set(settled
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean));
+    const add = (heading, lines) => {
+        const wanted = lines.filter((line) => !has.has(line.trim()));
+        if (!wanted.length)
+            return "";
+        for (const line of wanted)
+            has.add(line.trim());
+        return [heading, ...wanted].join("\n");
+    };
+    let shared = settled.replace(/\s*$/, "");
+    for (const [heading, lines] of [
+        [detect_js_1.SUGGESTED_HEADING, patterns],
+        [detect_js_1.STARTER_TOPUP_HEADING, starter],
+    ]) {
+        const block = add(heading, lines);
+        if (!block)
+            continue;
+        const at = shared.indexOf(heading);
+        if (at === -1) {
+            shared = shared ? `${shared}\n\n${block}` : block;
+            continue;
+        }
+        /* Extend the block that is already there, directly under its heading. */
+        const after = at + heading.length;
+        shared =
+            shared.slice(0, after) +
+                block.slice(heading.length) +
+                shared.slice(after);
+    }
+    const next = { ...rules, shared: `${shared}\n` };
+    await writeRules(root, next);
+    return next;
+}
 /** The two headings a move writes under, so a person can find their own edits. */
 exports.KEEP_HEADING = "# Always include";
 exports.IGNORE_HEADING = "# Left out from the filter screen";

package/dist/desktop-app/src/shared/compression_policy.js

@@ -6,16 +6,21 @@
  * make the same decision for the same object.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WORTHWHILE_COMPRESSION_RATIO = exports.SMALLEST_WORTH_COMPRESSING = void 0;
+exports.GZIP_KEEP_RATE = exports.GZIP_REVIEW_EVERY = exports.SAMPLE_BYTES = exports.WORTHWHILE_COMPRESSION_RATIO = exports.SMALLEST_WORTH_COMPRESSING = void 0;
 exports.looksCompressed = looksCompressed;
 exports.shouldTryGzip = shouldTryGzip;
+exports.worthSampling = worthSampling;
+exports.sampleWindows = sampleWindows;
+exports.sampleSaysDoNotBother = sampleSaysDoNotBother;
 exports.gzipIsWorthKeeping = gzipIsWorthKeeping;
+exports.freshGzipVerdict = freshGzipVerdict;
+exports.noteChunkOutcome = noteChunkOutcome;
 const ALREADY_COMPRESSED = new Set([
     ".7z", ".aac", ".avi", ".br", ".bz2", ".cbx", ".docx", ".flac", ".gif",
-    ".gz", ".heic", ".jpeg", ".jpg", ".jxl", ".m4a", ".m4v", ".mkv", ".mov",
-    ".mp3", ".mp4", ".odp", ".ods", ".odt", ".ogg", ".opus", ".pdf", ".png",
-    ".pptx", ".rar", ".safetensors", ".webm", ".webp", ".xlsx", ".xz", ".zip",
-    ".zst",
+    ".gguf", ".gz", ".heic", ".jpeg", ".jpg", ".jxl", ".m4a", ".m4v", ".mkv",
+    ".mov", ".mp3", ".mp4", ".odp", ".ods", ".odt", ".ogg", ".onnx", ".opus",
+    ".pdf", ".png", ".pptx", ".rar", ".safetensors", ".webm", ".webp", ".xlsx",
+    ".xz", ".zip", ".zst",
 ]);
 exports.SMALLEST_WORTH_COMPRESSING = 4 * 1024;
 exports.WORTHWHILE_COMPRESSION_RATIO = 0.95;
@@ -30,6 +35,118 @@ function shouldTryGzip(relativePath, sourceBytes, allowGzip) {
         sourceBytes >= exports.SMALLEST_WORTH_COMPRESSING &&
         !looksCompressed(relativePath));
 }
+/**
+ * Above this, find out by trying a little before trying all of it.
+ *
+ * The extension list above is a guess, and the cost of a miss is unbounded.
+ * A project of thirteen `.gguf` model weights — 10.6 GB, an extension nothing
+ * here had heard of — was deflated at level 6, in full, to discover that it
+ * compressed by 3.3% and the result had to be thrown away. That was 87% of the
+ * time the save spent before it sent a single byte, and the save runs the whole
+ * pipeline twice, so it was paid twice. The project never finished saving.
+ *
+ * A quarter of a megabyte is eight times deflate's window, which is enough for
+ * the answer to mean something, and 6% of a maximum chunk, which is what makes
+ * a wrong guess in the list above cheap instead of ruinous.
+ */
+exports.SAMPLE_BYTES = 256 * 1024;
+/** Whether a piece is big enough that guessing wrong on it is worth avoiding. */
+function worthSampling(sourceBytes) {
+    /*
+      Only where the sample is a real saving over the whole thing. Sampling a
+      300 KB file costs most of what compressing it would and answers a question
+      that was about to be answered properly anyway.
+    */
+    return sourceBytes >= exports.SAMPLE_BYTES * 8;
+}
+/**
+ * Where to look, for a piece of this size.
+ *
+ * Two windows, not one, because a single window at the front judges the whole
+ * file by its header. A container with a text manifest and an incompressible
+ * payload would be compressed in full on the strength of its first block —
+ * which is the waste this exists to avoid — and one shaped the other way round
+ * would be abandoned despite compressing. The middle disagrees with the front
+ * in both cases, and either window arguing for compression is enough.
+ *
+ * Shared rather than chosen per caller so Desktop and the browser make the same
+ * decision about the same bytes, which is the point of this module.
+ */
+function sampleWindows(sourceBytes) {
+    return [
+        { at: 0, size: exports.SAMPLE_BYTES },
+        { at: Math.floor(sourceBytes / 2), size: exports.SAMPLE_BYTES },
+    ];
+}
+/**
+ * Whether a window that compressed this little argues against the whole piece.
+ *
+ * Deliberately the same test {@link gzipIsWorthKeeping} applies at the end: the
+ * sample is an estimate of that answer, so estimating it against a softer
+ * threshold was the bug in the first attempt at this. A window that saved 3%
+ * would have passed a "did it compress at all" test, committed the file to a
+ * full deflate, and then had the result discarded for saving 3% — which is
+ * exactly the several minutes this was meant to stop spending.
+ *
+ * Getting it wrong costs a little space and never a wrong result: an object's
+ * identity is the digest of its original bytes, whatever travels.
+ */
+function sampleSaysDoNotBother(sampleBytes, compressedSampleBytes) {
+    return !gzipIsWorthKeeping(sampleBytes, compressedSampleBytes);
+}
 function gzipIsWorthKeeping(sourceBytes, compressedBytes) {
     return compressedBytes < sourceBytes * exports.WORTHWHILE_COMPRESSION_RATIO;
 }
+/** How often a chunked file's compression is reviewed. */
+exports.GZIP_REVIEW_EVERY = 16;
+/** The fraction of reviewed chunks that must have kept gzip, as its divisor. */
+exports.GZIP_KEEP_RATE = 4;
+/** A file nothing is known about yet. */
+function freshGzipVerdict() {
+    return { allowed: true, tried: 0, kept: 0, chunks: 0 };
+}
+/**
+ * Record how one chunk turned out, and decide whether to keep trying.
+ *
+ * A large file is not one object, it is hundreds: a 1 GB file at a 1 MB target
+ * is a thousand chunks, each compressed and judged on its own. So the guard
+ * that stops wasted work on a whole *file* cannot live in the piece — sampling
+ * inside a 1 MB chunk saves a fraction of a job that was already small.
+ *
+ * Thirteen `.gguf` model weights, 10.6 GB, went chunk by chunk through deflate
+ * at level 6. That was 87% of the time the save spent before it sent a byte,
+ * and a save runs the whole pipeline twice, so it was spent twice. The project
+ * never finished saving.
+ *
+ * Measured on one of those files, 24 of 208 chunks did clear the 5% threshold
+ * and keep their compression — so "give up once nothing has compressed" never
+ * fired, which was the first attempt at this. What those 24 chunks saved was
+ * 0.7% of the file. The question is a rate, not an existence.
+ *
+ * Each window is judged on itself, and the count starts again after every
+ * review. Judging the file cumulatively instead lets a compressible opening buy
+ * an arbitrarily long incompressible tail: a run of 256 chunks that compressed
+ * would carry the next thousand that did not, which is the cost this exists to
+ * bound. Starting again means the work wasted after a file changes character is
+ * never more than one window, whereever in the file that happens.
+ *
+ * Being wrong costs a little storage and never a wrong result: an object's
+ * identity is the digest of its original bytes, whatever those bytes travelled
+ * as, so chunks already sent compressed stay exactly as valid as before.
+ */
+function noteChunkOutcome(verdict, keptGzip) {
+    if (!verdict.allowed)
+        return;
+    verdict.chunks += 1;
+    verdict.tried += 1;
+    if (keptGzip)
+        verdict.kept += 1;
+    if (verdict.tried < exports.GZIP_REVIEW_EVERY)
+        return;
+    if (verdict.kept * exports.GZIP_KEEP_RATE < verdict.tried) {
+        verdict.allowed = false;
+        return;
+    }
+    verdict.tried = 0;
+    verdict.kept = 0;
+}

package/dist/desktop-app/src/shared/format.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Number formatting in the design's phrasing, where both sides can reach it.
+ *
+ * Byte sizes started out in the renderer, because only the renderer showed
+ * them. Then the detector began writing a person-facing sentence of its own —
+ * "10.7 GB of 10.8 GB, and no source in it" — and a second formatter in the
+ * main process would have meant the same folder described two ways in two
+ * places. The renderer re-exports these, so nothing that already imports from
+ * `renderer/format` had to change.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBytes = formatBytes;
+exports.formatCount = formatCount;
+/** Short byte text: "812 MB", "3.6 GB", "24 GB". A fraction only when there is one. */
+function formatBytes(value) {
+    let size = value;
+    for (const unit of ["B", "KB", "MB", "GB", "TB"]) {
+        if (size < 1024 || unit === "TB") {
+            if (unit === "B")
+                return `${Math.round(size)} B`;
+            const text = size >= 100 ? size.toFixed(0) : size.toFixed(1);
+            return `${text.endsWith(".0") ? text.slice(0, -2) : text} ${unit}`;
+        }
+        size /= 1024;
+    }
+    return `${value} B`;
+}
+function formatCount(value) {
+    return value.toLocaleString("en-US");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coderook/cli",
-  "version": "0.31.0",
+  "version": "0.31.1",
   "description": "CodeRook from the command line, on any operating system",
   "license": "SEE LICENSE IN LICENSE.txt",
   "homepage": "https://coderook.com",