@coderook/cli 0.30.2 → 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.30.2",
+  "version": "0.31.1",
   "author": {
     "name": "ACCA Gaming Productions",
     "url": "https://coderook.com"

package/dist/cli/src/cli.js

@@ -623,7 +623,21 @@ async function commandSubmit(parsed) {
       which is the wrong way round — so this is that capability, asked for
       plainly.
     */
-    const files = await (0, worktree_js_1.changedFiles)(folder, rules, baseline, hasFlag(parsed, "sync") ? "synchronize" : "add-and-update");
+    /*
+      Digests this machine has taken before, read before the scan rather than
+      before the upload.
+  
+      The uploader has always accepted these and the desktop has always passed
+      them, but on the command line the expensive part happens earlier: the
+      scan below reads and hashes the whole folder to decide what changed, and
+      that is where a 21,071-file project spent 169 of its 299 seconds. The
+      same map serves both — `changedFiles` fills it in place, so what the scan
+      learns is what the upload is handed.
+    */
+    const knownDigests = link?.repositoryId
+        ? await (0, config_js_1.readDigests)(link.repositoryId)
+        : new Map();
+    const files = await (0, worktree_js_1.changedFiles)(folder, rules, baseline, hasFlag(parsed, "sync") ? "synchronize" : "add-and-update", knownDigests);
     /*
       An upgraded folder with no materialisation record and something that
       differs from its recorded version is ambiguous in the one way that
@@ -788,6 +802,7 @@ Pass ${accent("--allow-secrets")} if these are not real keys.`);
     */
     const uploadRequest = (0, publish_js_1.uploadRequestFor)({
         localPath: folder,
+        ...(knownDigests.size ? { knownDigests } : {}),
         changed: files.filter((file) => !file.deleted).map((file) => file.path),
         deleted: files.filter((file) => file.deleted).map((file) => file.path),
         /*
@@ -994,6 +1009,15 @@ The connection failed: ${text}`));
         local: result.local,
         manifest: result.manifest,
     });
+    /*
+      What this save hashed, kept for the next one.
+  
+      Merged rather than replaced: `digestsTaken` holds only the files actually
+      read this time, and everything served from the existing record has to
+      survive or the next save reads it all again — which is precisely the cost
+      this exists to avoid.
+    */
+    await (0, config_js_1.writeDigests)(result.repositoryId, new Map([...knownDigests, ...uploader.digestsTaken()]));
     if (result.repeated) {
         console.log(`Already saved as ${accent(`v${result.sequence}`)} by an earlier attempt;` +
             ` nothing was sent again.`);

package/dist/cli/src/config.js

@@ -3,16 +3,19 @@ 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;
+exports.readDigests = readDigests;
+exports.writeDigests = writeDigests;
 /**
  * Where the command-line tool keeps its credential and its project links.
  *
@@ -21,6 +24,7 @@ exports.writeLink = writeLink;
  * 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");
@@ -42,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.
  *
@@ -134,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 {
@@ -160,25 +326,46 @@ 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) {
+    try {
+        const raw = await (0, promises_1.readFile)(digestsFile(projectId), "utf8");
+        return new Map(Object.entries(JSON.parse(raw)));
+    }
+    catch {
+        /* No record yet, or one this build cannot read: hash everything. */
+        return new Map();
+    }
+}
+async function writeDigests(projectId, digests) {
+    if (!digests.size)
+        return;
+    try {
+        await writePrivate(digestsFile(projectId), JSON.stringify(Object.fromEntries(digests)));
+    }
+    catch {
+        /* The next save hashes again, which is where this started. */
+    }
 }

package/dist/cli/src/git_remote.js

@@ -114,6 +114,7 @@ const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_process_1 = __importDefault(require("node:process"));
 const upload_js_1 = require("../../desktop-app/src/main/upload.js");
+const stored_zip_js_1 = require("./stored_zip.js");
 const tracks_js_1 = require("../../desktop-app/src/main/tracks.js");
 const identify_js_1 = require("../../desktop-app/src/main/identify.js");
 const config_js_1 = require("./config.js");
@@ -533,6 +534,17 @@ async function recordPushedCommits(marks) {
  * Contents are deduplicated by SHA-256 across the whole history, so a file
  * unchanged across a thousand versions is downloaded and sent to git once.
  */
+/*
+  How many blobs a clone fetches at once, and how much it will hold doing it.
+
+  Eight lanes for the same reason the folder walks use eight: these are
+  latency, not work, and the measured curve flattens there. The byte ceiling
+  is what stops a window of large files becoming a window of memory — one
+  oversized file still goes through on its own, because the count check comes
+  first and an empty window always accepts one more.
+*/
+const BLOB_LANES = 8;
+const BLOB_WINDOW_BYTES = 64 * 1024 * 1024;
 async function doImport(refs, url) {
     const { owner, slug } = (0, git_history_js_1.parseRemoteUrl)(url);
     const project = await (0, api_js_1.findProject)(owner ? `${owner}/${slug}` : slug);
@@ -639,22 +651,99 @@ async function doImport(refs, url) {
         let done = 0;
         for (const version of fresh) {
             const files = await downloader.files(repositoryId, version.id);
-            // Blobs first: fast-import requires a mark to exist before a commit
-            // names it.
-            for (const file of files) {
-                if (blobMark.has(file.sha256))
-                    continue;
-                const target = node_path_1.default.join(scratch, "blob.bin");
-                await (0, promises_1.rm)(target, { force: true });
-                await downloader.fileTo(repositoryId, version.id, file, target);
-                const bytes = await (0, promises_1.readFile)(target);
-                const mark = nextMark++;
-                blobMark.set(file.sha256, mark);
-                send("blob");
-                send(`mark :${mark}`);
-                send(`data ${bytes.length}`);
-                node_process_1.default.stdout.write(bytes);
-                node_process_1.default.stdout.write("\n");
+            /*
+              Blobs first: fast-import requires a mark to exist before a commit
+              names it. Fetched a window at a time and written out in order.
+      
+              This asked for one file, waited for it, wrote it to a scratch path,
+              read it back, and only then asked for the next — so a clone cost one
+              network round trip per file, in series. Against a 21,071-file project
+              that is 21,071 round trips at about seven tenths of a second each,
+              and a clone that never finished: measured over twenty seconds it was
+              using 0.17s of processor and moving two kilobytes.
+      
+              The stream fast-import reads has to stay ordered, so the fetching is
+              what overlaps, not the writing. The window is bounded by count and by
+              bytes together, because sixteen source files and sixteen video files
+              are not the same amount to be holding at once.
+            */
+            /*
+              The whole version in one request, where that works.
+      
+              Fetching per file is one round trip each: 21,071 of them on a real
+              Unity project, which is four hours in series and about half an hour
+              even eight at a time. The archive is the same bytes in one request.
+      
+              Anything unexpected about it — an entry this cannot read, a short
+              download, a service that does not offer the route — falls through to
+              the per-file path below, which is slow and known to work. A clone
+              that is slow is a nuisance; a clone that writes the wrong bytes is
+              not recoverable by trying again.
+            */
+            const fromArchive = new Map();
+            try {
+                const packed = await downloader.archive(repositoryId, version.id);
+                for (const entry of (0, stored_zip_js_1.readStoredZip)(packed)) {
+                    fromArchive.set(entry.path, entry.bytes);
+                }
+            }
+            catch (error) {
+                /*
+                  Said out loud, not swallowed.
+        
+                  This fell back silently, and the silence cost an hour: a deadline
+                  meant for ordinary requests was aborting the archive, the import
+                  dropped to fetching every file on its own, and from the outside it
+                  looked exactly like the slow clone the archive was added to fix.
+                  A fallback nobody can see is a fallback nobody can diagnose.
+                */
+                say(`  the archive for v${version.sequence} could not be used ` +
+                    `(${error instanceof Error ? error.message : String(error)}); ` +
+                    `fetching its files one by one`);
+                fromArchive.clear();
+            }
+            const seenBlob = new Set();
+            const wantedBlobs = files.filter((file) => {
+                if (blobMark.has(file.sha256) || seenBlob.has(file.sha256))
+                    return false;
+                seenBlob.add(file.sha256);
+                return true;
+            });
+            for (let at = 0; at < wantedBlobs.length;) {
+                const window = [];
+                let held = 0;
+                while (at < wantedBlobs.length && window.length < BLOB_LANES) {
+                    const size = Number(wantedBlobs[at].sourceSize ?? 0);
+                    if (window.length > 0 && held + size > BLOB_WINDOW_BYTES)
+                        break;
+                    held += size;
+                    window.push(wantedBlobs[at]);
+                    at += 1;
+                }
+                const fetched = await Promise.all(window.map(async (file, lane) => {
+                    /* Already in hand, if the archive carried it. */
+                    const packed = fromArchive.get(file.path);
+                    if (packed)
+                        return { file, bytes: packed };
+                    /*
+                      A scratch path per lane. They shared one name, which is fine
+                      while only one download is ever in flight and silently wrong
+                      the moment two are.
+                    */
+                    const target = node_path_1.default.join(scratch, `blob-${lane}.bin`);
+                    await (0, promises_1.rm)(target, { force: true });
+                    await downloader.fileTo(repositoryId, version.id, file, target);
+                    return { file, bytes: await (0, promises_1.readFile)(target) };
+                }));
+                for (const { file, bytes } of fetched) {
+                    const mark = nextMark++;
+                    blobMark.set(file.sha256, mark);
+                    send("blob");
+                    send(`mark :${mark}`);
+                    send(`data ${bytes.length}`);
+                    node_process_1.default.stdout.write(bytes);
+                    node_process_1.default.stdout.write("\n");
+                }
             }
             const mark = nextMark++;
             commitMark.set(version.id, mark);

package/dist/cli/src/publish.js

@@ -23,6 +23,11 @@ function uploadRequestFor(input) {
             ? { expectedHeadVersionId: input.baseVersionId }
             : {}),
         ...(input.known ? { known: input.known } : {}),
+        /*
+          Digests this machine has taken before, so an unchanged file is not read
+          again. The desktop has always passed these; the command line never did.
+        */
+        ...(input.knownDigests ? { knownDigests: input.knownDigests } : {}),
     };
 }
 function classifyPublishFailure(error) {

package/dist/cli/src/stored_zip.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Reading the archive CodeRook builds, without a compression library.
+ *
+ * A clone fetched every file individually: one HTTP round trip per blob, in
+ * series. Against a 21,071-file project that is 21,071 round trips, which at
+ * seven tenths of a second each is four hours — and the clone that exposed
+ * this simply never finished. Fetching eight at a time cut it to about half
+ * an hour; asking for the version as one archive cuts it to one request.
+ *
+ * Written by hand for the same reason `backend/src/archive.ts` writes it by
+ * hand: the entries are *stored*, never deflated, so the whole job is a
+ * header, a body, and skipping the directory at the end. Pulling in a zip
+ * library to not decompress anything would be a poor trade.
+ *
+ * Only the format that writer produces is accepted. Anything else — a
+ * deflated entry, a size deferred to a data descriptor, a Zip64 field — is
+ * refused rather than guessed at, and the caller falls back to fetching the
+ * files one by one. A reader that quietly mangles a project is worse than a
+ * slow one.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readStoredZip = readStoredZip;
+const LOCAL_HEADER = 0x04034b50;
+const CENTRAL_HEADER = 0x02014b50;
+/* An archive of nothing has no entries and no directory records — it opens
+   with this, and a reader that only knew the other two would refuse it. */
+const END_OF_DIRECTORY = 0x06054b50;
+/** Set in the general-purpose flags when sizes come after the body. */
+const SIZES_DEFERRED = 0x0008;
+const STORED = 0;
+/**
+ * Every entry in a stored archive, in the order it was written.
+ *
+ * Deliberately whole-buffer rather than streaming: the caller is holding one
+ * version's files to hand to fast-import, which needs them in order anyway,
+ * and a version large enough for this to matter is one the archive path
+ * should not be taking.
+ */
+function readStoredZip(archive) {
+    const view = new DataView(archive.buffer, archive.byteOffset, archive.byteLength);
+    const names = new TextDecoder("utf-8", { fatal: false });
+    const entries = [];
+    let at = 0;
+    while (at + 4 <= archive.length) {
+        const signature = view.getUint32(at, true);
+        /* Either record marks the end of the entries. */
+        if (signature === CENTRAL_HEADER || signature === END_OF_DIRECTORY)
+            break;
+        if (signature !== LOCAL_HEADER) {
+            throw new Error(`Not a stored archive: unexpected record at byte ${at}`);
+        }
+        if (at + 30 > archive.length)
+            throw new Error("Archive ends inside a header");
+        const flags = view.getUint16(at + 6, true);
+        const method = view.getUint16(at + 8, true);
+        const compressed = view.getUint32(at + 18, true);
+        const nameLength = view.getUint16(at + 26, true);
+        const extraLength = view.getUint16(at + 28, true);
+        if (method !== STORED) {
+            throw new Error(`Archive entry is compressed (method ${method})`);
+        }
+        if (flags & SIZES_DEFERRED) {
+            throw new Error("Archive entry defers its size to a data descriptor");
+        }
+        /*
+          0xffffffff is Zip64's marker for "the real size is in an extra field".
+          This writer never emits one, so seeing it means the archive did not come
+          from where it is assumed to have come from.
+        */
+        if (compressed === 0xffffffff)
+            throw new Error("Archive entry needs Zip64");
+        const nameAt = at + 30;
+        const bodyAt = nameAt + nameLength + extraLength;
+        const end = bodyAt + compressed;
+        if (end > archive.length)
+            throw new Error("Archive ends inside an entry");
+        entries.push({
+            path: names.decode(archive.subarray(nameAt, nameAt + nameLength)),
+            bytes: archive.subarray(bodyAt, end),
+        });
+        at = end;
+    }
+    return entries;
+}

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;