@coderook/cli 0.46.0 → 0.46.2

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, with cbx or plain git, from Claude Code.",
-  "version": "0.46.0",
+  "version": "0.46.2",
   "author": {
     "name": "ACCA Gaming Productions",
     "url": "https://coderook.com"

package/dist/cbx/src/core/upload.js

@@ -14,6 +14,7 @@ exports.Uploader = exports.UploadCancelled = void 0;
  */
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
+const node_zlib_1 = require("node:zlib");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const faults_js_1 = require("./faults.js");
@@ -133,6 +134,11 @@ const versionListings = new Map();
 const signatures = new Map();
 /** How many version listings a folder keeps in `.coderook/versions`. */
 const KEPT_LISTINGS = 3;
+/* The largest new file a one-request delta save carries as its own bytes. */
+const DELTA_SAVE_NEW_FILE_BYTES = 1024 * 1024;
+/** A delta save the service would not take; the save is sent the ordinary way. */
+class DeltaSaveRefused extends Error {
+}
 class Uploader {
     credentials;
     aborted = false;
@@ -147,6 +153,12 @@ class Uploader {
     deltaProtocol = null;
     /** Batch delta is separate so V2 single-file support remains compatible. */
     deltaBatchSupported = null;
+    /* Set once the service refuses a one-request delta save; later saves go the ordinary way. */
+    deltaSaveRefused = false;
+    /* Digests the plan asked about and heard were not held; see storedInBulk. */
+    plannedAbsent = new Set();
+    /** Batch signatures fetched while pricing a save, used once by the pass that sends it. */
+    plannedSignatures = new Map();
     versionDeltaSupported = null;
     microchunkSupported = null;
     /** One shared preflight, so parallel upload lanes cannot race /health. */
@@ -399,6 +411,8 @@ class Uploader {
         this.planningCreatedRepositoryId = null;
         this.plannedObjects.clear();
         this.plannedLayouts.clear();
+        this.plannedSignatures.clear();
+        this.plannedAbsent.clear();
         try {
             await this.runPass(request, report);
             const quote = this.plannedQuote;
@@ -547,7 +561,7 @@ class Uploader {
         if (!ticked.size)
             throw new Error("Nothing is selected to upload");
         const prior = request.repositoryId
-            ? await this.versionFiles(request.repositoryId, request.baseVersionId, request.localPath)
+            ? await this.versionFiles(request.repositoryId, request.baseVersionId, request.listingRoot ?? request.localPath)
             : new Map();
         // Ticked files are sent; everything else the project still has keeps the
         // copy already stored, and a file that is new but unticked is left out.
@@ -1119,6 +1133,22 @@ class Uploader {
                 },
             }
             : null;
+        /*
+          Names this attempt so a retry after a lost connection is answered with
+          the version already made, rather than making a second one. Named by what
+          each file is: a whole file is its object; a chunked one, or one sent as
+          a patch, is the digest of its contents — so retrying the same publish
+          produces the same key either way, which is the point of it.
+        */
+        const idempotencyKey = (0, publish_name_js_1.publishAttemptName)({
+            repositoryId,
+            expectedHeadVersionId: request.expectedHeadVersionId,
+            message: request.message,
+            files: contents.map((item) => ({
+                path: item.path,
+                objectId: item.objectId ?? item.sha256 ?? "",
+            })),
+        });
         const send = (asChanges) => {
             completing("confirming", "Files uploaded · waiting for CodeRook to confirm the save");
             return (0, profile_js_1.timed)("publish the version", () => this.call(`/v1/repositories/${repositoryId}/versions`, {
@@ -1150,20 +1180,7 @@ class Uploader {
                       Names this attempt so a retry after a lost connection is answered
                       with the version already made, rather than making a second one.
                     */
-                    idempotencyKey: (0, publish_name_js_1.publishAttemptName)({
-                        repositoryId,
-                        expectedHeadVersionId: request.expectedHeadVersionId,
-                        message: request.message,
-                        /*
-                          Named by what each file is. A whole file is its object; a chunked
-                          one is the digest of its contents — so retrying the same publish
-                          produces the same key either way, which is the point of it.
-                        */
-                        files: contents.map((item) => ({
-                            path: item.path,
-                            objectId: item.objectId ?? item.sha256 ?? "",
-                        })),
-                    }),
+                    idempotencyKey,
                     sourceSize: sourceBytes,
                     storedSize: storedBytes,
                     /*
@@ -1175,17 +1192,83 @@ class Uploader {
             }));
         };
         /*
-          A service that cannot build on the version named (it was taken down,
-          say) answers files_from_*; the whole list is then sent instead, which
-          every service accepts.
+          The whole save as one request (delta-save-v1): a small header saying
+          what POST /versions would be told, less the file list, then the exact
+          patches. Packed with gzip when that is smaller, which it is once a few
+          paths repeat their folders.
         */
-        const completed = await send(true).catch((error) => {
-            const code = error.code;
-            if (changesOnly && typeof code === "string" && code.startsWith("files_from_")) {
-                return send(false);
+        const sendDeltaSave = async (plan) => {
+            const sentHere = new Set(plan.entries.map((entry) => entry.declaration.path));
+            const removed = [...prior.keys()].filter((held) => !named.has(held));
+            const executable = contents
+                .filter((item) => item.executable === true && sentHere.has(item.path))
+                .map((item) => item.path);
+            /* Anything the service assumes by default is left out: the expected head is the base unless said otherwise. */
+            const header = new TextEncoder().encode(JSON.stringify({
+                message: request.message.trim() || "Saved from the CodeRook desktop app",
+                ...(request.expectedHeadVersionId === undefined || request.expectedHeadVersionId === request.baseVersionId
+                    ? {}
+                    : { expectedHeadVersionId: request.expectedHeadVersionId }),
+                ...(request.track && request.track !== "main" ? { track: request.track } : {}),
+                idempotencyKey,
+                ...(plan.entries.length ? {} : { baseVersionId: request.baseVersionId }),
+                ...(linesAdded === undefined ? {} : { linesAdded }),
+                ...(linesRemoved === undefined ? {} : { linesRemoved }),
+                ...(request.allowIgnored ? { allowIgnored: true } : {}),
+                ...(this.trackedByGit.length ? { trackedByGit: this.trackedByGit } : {}),
+                ...(removed.length ? { removed } : {}),
+                ...(executable.length ? { executable } : {}),
+            }));
+            const rest = new Uint8Array(4 + header.byteLength + plan.envelope.byteLength);
+            new DataView(rest.buffer).setUint32(0, header.byteLength, false);
+            rest.set(header, 4);
+            rest.set(plan.envelope, 4 + header.byteLength);
+            const packed = new Uint8Array((0, node_zlib_1.gzipSync)(rest, { level: 9 }));
+            const packing = packed.byteLength < rest.byteLength;
+            const body = new Uint8Array(4 + (packing ? packed.byteLength : rest.byteLength));
+            body.set(new TextEncoder().encode(packing ? "CDVZ" : "CDV1"), 0);
+            body.set(packing ? packed : rest, 4);
+            completing("confirming", "Sending the changes · waiting for CodeRook to confirm the save");
+            try {
+                const answer = await (0, profile_js_1.timed)("send the save as one request", () => this.call(`/v1/repositories/${repositoryId}/versions/delta`, {
+                    method: "POST",
+                    contentType: "application/vnd.coderook.delta-save; version=1",
+                    body,
+                }));
+                progress.finished(plan.entries.reduce((sum, entry) => sum + entry.declaration.size, 0), body.byteLength);
+                return answer;
             }
-            throw error;
-        });
+            catch (error) {
+                const code = error.code;
+                const status = error.status;
+                if ((typeof code === "string" && (code.startsWith("delta_") || code.startsWith("files_from_"))) ||
+                    status === 404 ||
+                    status === 405 ||
+                    status === 415) {
+                    throw new DeltaSaveRefused(error instanceof Error ? error.message : String(error));
+                }
+                throw error;
+            }
+        };
+        const completed = at.deltaSave
+            ? await sendDeltaSave(at.deltaSave)
+            : await send(true).catch((error) => {
+                const code = error.code;
+                if (changesOnly && typeof code === "string" && code.startsWith("files_from_")) {
+                    return send(false);
+                }
+                throw error;
+            });
+        if (at.deltaSave) {
+            const placed = new Map((completed.objects ?? []).map((one) => [one.path, one]));
+            for (const entry of [...wire, ...uploaded]) {
+                const one = placed.get(entry.path);
+                if (!one)
+                    continue;
+                entry.objectId = one.objectId;
+                entry.storedSize = one.storedSize;
+            }
+        }
         /*
           A clean stale-base save may contain a server-side merge. The candidate
           manifest built above is then not the Version that landed: it lacks the
@@ -1210,7 +1293,7 @@ class Uploader {
             (await this.versionDeltaAllowed());
         if (!completed.mergeTrack && !landedAsSent && !Object.keys(acceptedManifest).length) {
             completing("local", "CodeRook confirmed the save · reading the accepted file manifest");
-            acceptedManifest = Object.fromEntries([...(await this.versionFiles(repositoryId, completed.version.id, request.localPath))].map(([file, descriptor]) => [file, descriptor.sha256]));
+            acceptedManifest = Object.fromEntries([...(await this.versionFiles(repositoryId, completed.version.id, request.listingRoot ?? request.localPath))].map(([file, descriptor]) => [file, descriptor.sha256]));
         }
         const manifest = Object.keys(acceptedManifest).length
             ? acceptedManifest
@@ -1275,13 +1358,13 @@ class Uploader {
           folder now, from the list just sent — every entry with its digest — and
           that save does not have to download it.
         */
-        if (landedAsSent && request.localPath) {
+        if (landedAsSent && (request.listingRoot ?? request.localPath)) {
             const rows = wire.map((entry) => ({ ...entry, sha256: manifest[entry.path] }));
             if (rows.every((row) => typeof row.sha256 === "string" && row.sha256.length === 64)) {
                 const key = `${repositoryId}/${completed.version.id}`;
                 versionListings.set(key, Promise.resolve(rows));
                 completing("local", "CodeRook confirmed the save · caching the file listing for next time");
-                await writeListing(request.localPath, repositoryId, completed.version.id, rows);
+                await writeListing(request.listingRoot ?? request.localPath, repositoryId, completed.version.id, rows);
             }
         }
         report({
@@ -1497,7 +1580,7 @@ class Uploader {
             if (deltaDeclaration &&
                 smallOnes.some((one) => one.path === deltaDeclaration.path)) {
                 const held = prior.get(deltaDeclaration.path);
-                const placed = await (0, profile_js_1.timed)("send changed-file delta", () => this.putDelta(repositoryId, request.baseVersionId, held, deltaDeclaration));
+                const placed = await (0, profile_js_1.timed)("send changed-file delta", () => this.putDelta(repositoryId, request.baseVersionId, held, deltaDeclaration, request.localBase));
                 if (placed) {
                     batched.set(deltaDeclaration.sha256, {
                         objectId: placed.objectId,
@@ -1622,7 +1705,7 @@ class Uploader {
                                 : null;
                             const packedBytes = built ? this.frameSolidPack(built).byteLength : 0;
                             const delta = built
-                                ? await (0, profile_js_1.timed)("price changed-file batch", () => this.putDeltaBatch(repositoryId, request.baseVersionId, taking, prior, packedBytes))
+                                ? await (0, profile_js_1.timed)("price changed-file batch", () => this.putDeltaBatch(repositoryId, request.baseVersionId, taking, prior, packedBytes, request.localBase))
                                 : null;
                             if (delta) {
                                 (0, profile_js_1.counted)("files sent as delta batch", taking.length);
@@ -1790,6 +1873,7 @@ class Uploader {
                         if (chunkProfile &&
                             declaration.size >= CHUNK_THRESHOLD &&
                             (await this.chunkingAllowed())) {
+                            const priorFile = prior.get(declaration.path);
                             const pieces = await this.putChunked(repositoryId, declaration, chunkProfile, (offset) => {
                                 progress.lane(index, offset);
                                 report({
@@ -1803,7 +1887,11 @@ class Uploader {
                                         Math.round((progress.bytes() / Math.max(totalBytes, 1)) * 72),
                                     bytesPerSecond: progress.rate(),
                                 });
-                            });
+                            }, 
+                            /* The previous version's copy of this file, kept in pieces: what a changed piece is patched against. */
+                            request.baseVersionId && priorFile?.chunks?.length && priorFile.sha256
+                                ? { baseVersionId: request.baseVersionId, baseSha256: priorFile.sha256, baseSize: priorFile.sourceSize }
+                                : undefined);
                             progress.laneDone(index);
                             /*
                               A chunk is not a file. Counting every reused piece here made a
@@ -2124,6 +2212,97 @@ class Uploader {
           and eighteen in the other, which is not two pipelines. Judging by the
           share of bytes that will be batched splits the same game nine and twelve.
         */
+        /*
+          A save of edited files whose bases this client holds goes up as one
+          request (delta-save-v1): the exact patches and the version together, as
+          a Git push carries its objects and its commit in one pack. Nothing is
+          asked about first and nothing is priced object by object; the plan still
+          asks the service for the account's storage and allowance, with an empty
+          object list, so what a person is shown before saving stays true.
+        */
+        const oneRequest = this.deltaSaveRefused
+            ? null
+            : await this.deltaSavePlan(request, repositoryId, declarations, prior);
+        if (oneRequest && this.planning) {
+            report({
+                stage: "publish",
+                files: declarations.length,
+                totalFiles: declarations.length,
+                bytes: 0,
+                totalBytes,
+                path: "Checking storage and monthly allowance",
+                percent: 96,
+                bytesPerSecond: 0,
+            });
+            this.plannedQuote = await this.call(`/v1/repositories/${repositoryId}/uploads/preflight`, {
+                method: "POST",
+                contentType: "application/json",
+                body: JSON.stringify({
+                    sourceBytes: totalBytes,
+                    excludedBytes: 0,
+                    objects: [],
+                    track: request.track ?? "main",
+                }),
+            });
+            return {
+                repositoryId,
+                versionId: "",
+                sequence: 0,
+                sourceBytes: totalBytes,
+                storedBytes: this.plannedQuote.compactedBytes,
+                sentBytes: oneRequest.patchBytes,
+                sentFiles: oneRequest.entries.length,
+                reusedFiles: reused.length,
+                alreadyStoredFiles: 0,
+                manifest: {},
+                local: {},
+                telemetry: this.telemetry.snapshot(),
+            };
+        }
+        if (oneRequest) {
+            this.sendingBegan = true;
+            for (const entry of oneRequest.entries) {
+                uploaded.push({
+                    path: entry.declaration.path,
+                    sha256: entry.declaration.sha256,
+                    sourceSize: entry.declaration.size,
+                    storedSize: 0,
+                    mediaType: entry.declaration.mediaType,
+                });
+            }
+            try {
+                return await this.publishVersion({
+                    request,
+                    repositoryId,
+                    declarations,
+                    uploaded,
+                    reused,
+                    prior,
+                    everything,
+                    ticked,
+                    deletions,
+                    readFailures,
+                    vanished,
+                    totalBytes,
+                    progress,
+                    report,
+                    deltaSave: oneRequest,
+                });
+            }
+            catch (error) {
+                if (!(error instanceof DeltaSaveRefused))
+                    throw error;
+                /*
+                  Refused as a delta save (an old base, a patch that did not rebuild):
+                  sent the ordinary way instead. The plan's quote priced no objects,
+                  so the objects go up unquoted, as they did before quotes existed.
+                */
+                this.deltaSaveRefused = true;
+                this.activeQuoteId = null;
+                uploaded.length = 0;
+                (0, profile_js_1.counted)("delta saves sent the ordinary way", 1);
+            }
+        }
         await this.sendObjects({
             request,
             repositoryId,
@@ -2407,7 +2586,7 @@ class Uploader {
      * member has an immutable base and the complete two-way wire cost wins by
      * the same twenty-percent margin used by the single-file transport.
      */
-    async putDeltaBatch(repositoryId, baseVersionId, items, prior, solidPackBytes) {
+    async putDeltaBatch(repositoryId, baseVersionId, items, prior, solidPackBytes, localBase) {
         if (!baseVersionId ||
             solidPackBytes <= 0 ||
             items.length < 2 ||
@@ -2415,7 +2594,6 @@ class Uploader {
             !(await this.deltaBatchAllowed()))
             return null;
         let sourceBytes = 0;
-        let signatureEstimate = 6 + items.length * 4;
         const bases = [];
         for (const item of items) {
             const base = prior.get(item.declaration.path);
@@ -2430,46 +2608,46 @@ class Uploader {
             sourceBytes += item.declaration.size;
             if (sourceBytes > delta_js_1.DELTA_BATCH_MAX_SOURCE_BYTES)
                 return null;
-            signatureEstimate += (0, delta_js_1.estimateDeltaSignatureBytes)(base.sourceSize, 2);
             bases.push(base);
         }
+        /* The bases held here need no signature; only the rest are asked for. */
+        const held = await Promise.all(items.map((item, index) => this.localBaseBytes(localBase, item.declaration.path, bases[index])));
+        const asking = items.flatMap((_, index) => (held[index] ? [] : [index]));
+        let signatureEstimate = asking.length ? 6 + asking.length * 4 : 0;
+        for (const index of asking) {
+            signatureEstimate += (0, delta_js_1.estimateDeltaSignatureBytes)(bases[index].sourceSize, 2);
+        }
         if (signatureEstimate >= solidPackBytes * 0.8)
             return null;
         try {
-            const token = await this.credentials.token();
-            if (!token)
-                return null;
-            const response = await fetch(`${this.credentials.origin()}/v1/repositories/${repositoryId}/objects/delta/signatures`, {
-                method: "POST",
-                headers: {
-                    accept: "application/vnd.coderook.delta-signature-batch; version=2",
-                    authorization: `Bearer ${token}`,
-                    "content-type": "application/json",
-                    "user-agent": "CodeRook/0.1",
-                    ...(0, identify_js_1.clientHeaders)(),
-                },
-                body: JSON.stringify({
-                    baseVersionId,
-                    files: items.map((item, index) => ({
-                        path: item.declaration.path,
-                        baseSha256: bases[index].sha256,
-                    })),
-                }),
-                signal: this.controller.signal,
-            });
-            if (!response.ok)
+            /*
+              Signatures describe the base version's files, which never change, so
+              the ones fetched while pricing the save are the ones sending it needs.
+              Fetching them again in the sending pass doubled what a batch of edits
+              cost on the wire: 16 one-byte edits measured 12.1 KiB, against 8.8 KiB
+              with one fetch.
+            */
+            const signatureBytes = asking.length
+                ? await this.signatureBatch(repositoryId, baseVersionId, asking.map((index) => ({
+                    path: items[index].declaration.path,
+                    baseSha256: bases[index].sha256,
+                })))
+                : new Uint8Array(0);
+            if (!signatureBytes)
                 return null;
-            const signatureBytes = new Uint8Array(await response.arrayBuffer());
-            const signatures = (0, delta_js_1.decodeDeltaSignatureBatch)(signatureBytes);
-            if (signatures.length !== items.length)
+            const signatures = asking.length ? (0, delta_js_1.decodeDeltaSignatureBatch)(signatureBytes) : [];
+            if (signatures.length !== asking.length)
                 return null;
+            const signatureFor = new Map(asking.map((index, at) => [index, signatures[at]]));
             const framed = (0, delta_js_1.encodeDeltaBatchEnvelope)({
                 baseVersionId,
                 entries: items.map((item, index) => ({
                     path: item.declaration.path,
                     sha256: item.declaration.sha256,
                     mediaType: item.declaration.mediaType,
-                    patch: (0, delta_js_1.createDeltaPatch)(item.body, signatures[index]),
+                    patch: held[index]
+                        ? (0, delta_js_1.createExactDeltaPatch)(held[index], item.body)
+                        : (0, delta_js_1.createDeltaPatch)(item.body, signatureFor.get(index)),
                 })),
             });
             const wireBytes = signatureBytes.byteLength + framed.byteLength;
@@ -2520,10 +2698,13 @@ class Uploader {
      * is never a repository object: the service reconstructs and verifies the
      * complete target before returning the ordinary object id used below.
      */
-    async putDelta(repositoryId, baseVersionId, prior, declaration) {
+    async putDelta(repositoryId, baseVersionId, prior, declaration, localBase) {
         const deltaVersion = await this.deltaVersion();
         if (deltaVersion === 0)
             return null;
+        const held = deltaVersion === 2
+            ? await this.localBaseBytes(localBase, declaration.path, prior)
+            : null;
         let target;
         try {
             target = new Uint8Array(await (0, promises_1.readFile)(declaration.full));
@@ -2536,14 +2717,19 @@ class Uploader {
             return null;
         const ordinary = await (0, compress_js_1.encodeForUpload)(target, declaration.path, await this.gzipAllowed());
         const signatureEstimate = (0, delta_js_1.estimateDeltaSignatureBytes)(prior.sourceSize, deltaVersion);
-        if (signatureEstimate >= ordinary.body.byteLength * 0.8)
+        if (!held && signatureEstimate >= ordinary.body.byteLength * 0.8)
             return null;
         try {
-            const signatureBytes = await this.deltaSignature(repositoryId, baseVersionId, declaration.path, prior.sha256, deltaVersion);
-            const signature = (0, delta_js_1.parseDeltaSignature)(signatureBytes);
-            const patch = (0, delta_js_1.createDeltaPatch)(target, signature);
+            /* A base held here is patched against directly, with nothing fetched. */
+            const signatureBytes = held
+                ? new Uint8Array(0)
+                : await this.deltaSignature(repositoryId, baseVersionId, declaration.path, prior.sha256, deltaVersion);
+            const signature = held ? null : (0, delta_js_1.parseDeltaSignature)(signatureBytes);
+            const patch = held
+                ? (0, delta_js_1.createExactDeltaPatch)(held, target)
+                : (0, delta_js_1.createDeltaPatch)(target, signature);
             let framed;
-            if (signature.version === 2) {
+            if (held || signature.version === 2) {
                 framed = (0, delta_js_1.encodeDeltaEnvelope)({
                     baseVersionId,
                     path: declaration.path,
@@ -2595,6 +2781,168 @@ class Uploader {
             return null;
         }
     }
+    /**
+     * The one-request delta save for this selection, or null when it does not
+     * apply: every file being sent must be an edit of a file the base version
+     * holds at the same path, small enough for the delta transport, with its
+     * base held by the caller. A key published on purpose is stored as its
+     * covered copy, not as sent, so those saves keep the ordinary path.
+     */
+    async deltaSavePlan(request, repositoryId, declarations, prior) {
+        if (request.allowSecrets ||
+            typeof request.baseVersionId !== "string" ||
+            !prior.size ||
+            declarations.length > delta_js_1.DELTA_BATCH_MAX_FILES ||
+            !(await this.serviceFeatures()).includes("delta-save-v1"))
+            return null;
+        let sourceBytes = 0;
+        for (const declaration of declarations) {
+            const base = prior.get(declaration.path);
+            if ((base && !base.sha256) ||
+                declaration.size > delta_js_1.DELTA_MAX_FILE_BYTES ||
+                (base?.sourceSize ?? 0) > delta_js_1.DELTA_MAX_FILE_BYTES)
+                return null;
+            sourceBytes += declaration.size;
+            if (sourceBytes > delta_js_1.DELTA_BATCH_MAX_SOURCE_BYTES)
+                return null;
+        }
+        /*
+          Three ways a file goes in, cheapest first. An edit whose base is held
+          here is patched against it exactly. An edit whose base is not is patched
+          against the service's signatures of it, fetched in one request, when
+          those are worth fetching. Anything else small enough goes as its own
+          bytes, a literal patch any base rebuilds: a new file, or a rewrite that
+          shares nothing. Past a megabyte that is not taken, and the save goes the
+          ordinary way, where chunks and packs can find what is already held.
+        */
+        const targets = [];
+        const held = [];
+        const signed = [];
+        for (const [index, declaration] of declarations.entries()) {
+            let target;
+            try {
+                target = new Uint8Array(await (0, promises_1.readFile)(declaration.full));
+            }
+            catch {
+                return null;
+            }
+            if ((0, node_crypto_1.createHash)("sha256").update(target).digest("hex") !== declaration.sha256)
+                return null;
+            targets.push(target);
+            const was = prior.get(declaration.path);
+            const base = was ? await this.localBaseBytes(request.localBase, declaration.path, was) : null;
+            held.push(base);
+            if (base)
+                continue;
+            if (was && (0, delta_js_1.estimateDeltaSignatureBytes)(was.sourceSize, 2) < declaration.size * 0.8) {
+                signed.push(index);
+            }
+            else if (declaration.size > DELTA_SAVE_NEW_FILE_BYTES) {
+                return null;
+            }
+        }
+        let signatureFor = new Map();
+        let signatureBytes = 0;
+        if (signed.length) {
+            const fetched = await this.signatureBatch(repositoryId, request.baseVersionId, signed.map((index) => ({
+                path: declarations[index].path,
+                baseSha256: prior.get(declarations[index].path).sha256,
+            })));
+            if (!fetched)
+                return null;
+            try {
+                const signatures = (0, delta_js_1.decodeDeltaSignatureBatch)(fetched);
+                if (signatures.length !== signed.length)
+                    return null;
+                signatureFor = new Map(signed.map((index, at) => [index, signatures[at]]));
+            }
+            catch {
+                return null;
+            }
+            signatureBytes = fetched.byteLength;
+        }
+        const entries = declarations.map((declaration, index) => {
+            const target = targets[index];
+            const base = held[index];
+            const signature = signatureFor.get(index);
+            return {
+                declaration,
+                patch: base
+                    ? (0, delta_js_1.createExactDeltaPatch)(base, target)
+                    : signature
+                        ? (0, delta_js_1.createDeltaPatch)(target, signature)
+                        : (0, delta_js_1.createExactDeltaPatch)(new Uint8Array(0), target),
+            };
+        });
+        (0, profile_js_1.counted)("signature bytes for the delta save", signatureBytes);
+        /* A save that only deletes carries no envelope; its header names the base. */
+        const envelope = !entries.length ? new Uint8Array(0) : (0, delta_js_1.encodeDeltaBatchEnvelope)({
+            baseVersionId: request.baseVersionId,
+            entries: entries.map((entry) => ({
+                path: entry.declaration.path,
+                sha256: entry.declaration.sha256,
+                mediaType: entry.declaration.mediaType,
+                patch: entry.patch,
+            })),
+        });
+        return {
+            entries,
+            envelope,
+            patchBytes: entries.reduce((sum, entry) => sum + entry.patch.byteLength, 0),
+        };
+    }
+    /**
+     * Signatures of several base files in one request, or null when refused.
+     *
+     * Signatures describe the base version's files, which never change, so
+     * the ones fetched while pricing the save are the ones sending it needs.
+     * Fetching them again in the sending pass doubled what a batch of edits
+     * cost on the wire: 16 one-byte edits measured 12.1 KiB, against 8.8 KiB
+     * with one fetch.
+     */
+    async signatureBatch(repositoryId, baseVersionId, files) {
+        const key = JSON.stringify([repositoryId, baseVersionId, files.map((file) => [file.path, file.baseSha256])]);
+        const planned = this.planning ? undefined : this.plannedSignatures.get(key);
+        if (planned) {
+            this.plannedSignatures.delete(key);
+            return planned;
+        }
+        const token = await this.credentials.token();
+        if (!token)
+            return null;
+        const response = await fetch(`${this.credentials.origin()}/v1/repositories/${repositoryId}/objects/delta/signatures`, {
+            method: "POST",
+            headers: {
+                accept: "application/vnd.coderook.delta-signature-batch; version=2",
+                authorization: `Bearer ${token}`,
+                "content-type": "application/json",
+                "user-agent": "CodeRook/0.1",
+                ...(0, identify_js_1.clientHeaders)(),
+            },
+            body: JSON.stringify({ baseVersionId, files }),
+            signal: this.controller.signal,
+        });
+        if (!response.ok)
+            return null;
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        if (this.planning)
+            this.plannedSignatures.set(key, bytes);
+        return bytes;
+    }
+    /** A base's bytes from the caller, only when they are exactly the base. */
+    async localBaseBytes(localBase, filePath, base) {
+        if (!localBase || !base.sha256 || base.sourceSize > delta_js_1.DELTA_MAX_FILE_BYTES)
+            return null;
+        try {
+            const bytes = await localBase(filePath, base.sha256);
+            if (!bytes || bytes.byteLength > delta_js_1.DELTA_MAX_FILE_BYTES)
+                return null;
+            return (0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex") === base.sha256 ? bytes : null;
+        }
+        catch {
+            return null;
+        }
+    }
     deltaSignature(repositoryId, baseVersionId, filePath, baseSha256, version) {
         const key = [repositoryId, baseVersionId, filePath, baseSha256, version].join("\u0000");
         const known = signatures.get(key);
@@ -2695,7 +3043,18 @@ class Uploader {
      */
     async storedInBulk(repositoryId, digests) {
         const held = new Map();
-        if (!digests.length)
+        /*
+          The plan asked already; what it heard was not held is not asked twice.
+          Asking again cost a whole second request on every save, 34 KB of the
+          first save of 512 files. Only "not held" is reused: sending something
+          that arrived since costs bytes the service then recognises, while an
+          object reported held could have been collected in between, so those
+          are asked again.
+        */
+        const asking = this.planning
+            ? digests
+            : digests.filter((digest) => !this.plannedAbsent.has(digest));
+        if (!asking.length)
             return held;
         try {
             /*
@@ -2703,9 +3062,9 @@ class Uploader {
               thousand digests is roughly a third of a megabyte of JSON, which is
               nothing beside the transfer it is replacing.
             */
-            for (let at = 0; at < digests.length; at += 5000) {
+            for (let at = 0; at < asking.length; at += 5000) {
                 this.check();
-                const batch = [...new Set(digests.slice(at, at + 5000))];
+                const batch = [...new Set(asking.slice(at, at + 5000))];
                 const answer = await this.call(`/v1/repositories/${repositoryId}/stored`, {
                     method: "POST",
                     contentType: "application/json",
@@ -2714,6 +3073,11 @@ class Uploader {
                 for (const [digest, one] of Object.entries(answer.stored ?? {})) {
                     held.set(digest, { objectId: one.objectId, size: one.storedSize });
                 }
+                if (this.planning) {
+                    for (const digest of batch)
+                        if (!held.has(digest))
+                            this.plannedAbsent.add(digest);
+                }
             }
         }
         catch {
@@ -2734,7 +3098,7 @@ class Uploader {
      * content-addressed object, which is what makes "the service already has
      * this one" a question the existing protocol can already answer.
      */
-    async putChunked(repositoryId, declaration, profile, onOffset) {
+    async putChunked(repositoryId, declaration, profile, onOffset, deltaBase) {
         /*
           Three steps, and each file is read for as long as it has to be.
     
@@ -2794,6 +3158,9 @@ class Uploader {
           at most a maximum chunk each.
         */
         const CHUNK_LANES = 4;
+        const signatures = deltaBase
+            ? await this.chunkDeltaSignatures(repositoryId, declaration.path, deltaBase, layout, held)
+            : new Map();
         /*
           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
@@ -2843,7 +3210,16 @@ class Uploader {
                             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);
+                        const viaDelta = deltaBase
+                            ? await this.putChunkDelta(repositoryId, declaration, deltaBase, bytes, piece.digest, signatures.get(at))
+                            : null;
+                        if (viaDelta) {
+                            note("sent", viaDelta.sentBytes);
+                            chunks[at] = { objectId: viaDelta.objectId, sourceSize: piece.length, storedSize: viaDelta.storedSize };
+                        }
+                        else {
+                            await this.sendChunk(repositoryId, declaration, bytes, piece.digest, chunks, at, note, gzip);
+                        }
                     }
                     done += piece.length;
                     onOffset(Math.floor(already + done * share));
@@ -2923,6 +3299,119 @@ class Uploader {
         return layout;
     }
     /** Send one chunk, reusing it if the account already holds those bytes. */
+    /*
+      Chunk deltas (chunk-delta-v1): a changed piece of a large file, sent as a
+      patch against the old pieces covering the same place in the previous
+      version, rather than whole. A 64 KiB edit inside a 768 MiB file changes
+      one piece of about a megabyte, which used to travel complete. The service
+      rebuilds the piece, checks it against its digest and stores it as an
+      ordinary chunk, so nothing stored changes: only what crosses the wire.
+    */
+    chunkDeltaSupported = null;
+    async chunkDeltaAllowed() {
+        if (this.chunkDeltaSupported !== null)
+            return this.chunkDeltaSupported;
+        this.chunkDeltaSupported = (await this.serviceFeatures()).includes("chunk-delta-v1");
+        return this.chunkDeltaSupported;
+    }
+    /**
+     * Receiver signatures for the old bytes behind each changed piece, by the piece's position.
+     * The range is the piece's own place in the file widened by 64 KiB each way, in the base
+     * file's coordinates, so a piece moved a little by an insertion still finds its old bytes.
+     * Empty when the service does not offer chunk deltas or declines; the pieces then go whole.
+     */
+    async chunkDeltaSignatures(repositoryId, path, base, layout, held) {
+        const found = new Map();
+        if (this.planning || !(await this.chunkDeltaAllowed()))
+            return found;
+        const SLACK = 64 * 1024;
+        const wanted = [];
+        layout.forEach((piece, at) => {
+            if (held.has(piece.digest))
+                return;
+            const start = Math.max(0, piece.offset - SLACK);
+            const end = Math.min(base.baseSize, piece.offset + piece.length + SLACK);
+            if (end > start)
+                wanted.push({ at, start, end });
+        });
+        for (let from = 0; from < wanted.length; from += 64) {
+            const group = wanted.slice(from, from + 64);
+            try {
+                const token = await this.credentials.token();
+                if (!token)
+                    return found;
+                const response = await fetch(`${this.credentials.origin()}/v1/repositories/${repositoryId}/objects/chunk-delta/signatures`, {
+                    method: "POST",
+                    headers: {
+                        accept: "application/vnd.coderook.delta-signature-batch; version=2",
+                        authorization: `Bearer ${token}`,
+                        "content-type": "application/json",
+                        "user-agent": "CodeRook/0.1",
+                        ...(0, identify_js_1.clientHeaders)(),
+                    },
+                    body: JSON.stringify({
+                        baseVersionId: base.baseVersionId,
+                        path,
+                        baseSha256: base.baseSha256,
+                        ranges: group.map(({ start, end }) => ({ start, end })),
+                    }),
+                    signal: this.controller.signal,
+                });
+                if (!response.ok)
+                    continue;
+                const bytes = new Uint8Array(await response.arrayBuffer());
+                this.chunkDeltaSignatureBytes += bytes.byteLength;
+                const decoded = (0, delta_js_1.decodeDeltaSignatureBatch)(bytes);
+                if (decoded.length !== group.length)
+                    continue;
+                group.forEach((one, index) => found.set(one.at, { signature: decoded[index], start: one.start, end: one.end }));
+            }
+            catch {
+                /* Declined or unreachable: those pieces go whole, as they always did. */
+            }
+        }
+        return found;
+    }
+    /** Signature bytes fetched for chunk deltas during this run, counted in what travelled. */
+    chunkDeltaSignatureBytes = 0;
+    /** One changed piece as a patch; null when there is no signature, the patch would not pay, or the service refuses. */
+    async putChunkDelta(repositoryId, declaration, base, bytes, digest, signed) {
+        if (!signed || this.planning)
+            return null;
+        try {
+            const raw = (0, delta_js_1.createDeltaPatch)(bytes, signed.signature);
+            /* A patch that is mostly new bytes of one kind compresses well; sent packed only when it clearly saves. */
+            const packed = raw.byteLength > 1024 ? new Uint8Array((0, node_zlib_1.gzipSync)(raw, { level: 6 })) : null;
+            const usePacked = packed !== null && packed.byteLength < raw.byteLength * 0.9;
+            const patch = usePacked ? packed : raw;
+            const manifest = new TextEncoder().encode(JSON.stringify({
+                baseVersionId: base.baseVersionId,
+                path: declaration.path,
+                baseSha256: base.baseSha256,
+                start: signed.start,
+                end: signed.end,
+                sha256: digest,
+                size: bytes.byteLength,
+                mediaType: declaration.mediaType,
+                patchEncoding: usePacked ? "gzip" : "identity",
+            }));
+            const body = new Uint8Array(4 + manifest.byteLength + patch.byteLength);
+            new DataView(body.buffer).setUint32(0, manifest.byteLength, false);
+            body.set(manifest, 4);
+            body.set(patch, 4 + manifest.byteLength);
+            /* Worth it only when clearly smaller than the piece itself, the same margin the file deltas use. */
+            if (body.byteLength >= bytes.byteLength * 0.8)
+                return null;
+            const answer = await this.call(`/v1/repositories/${repositoryId}/objects/chunk-delta`, { method: "POST", contentType: "application/octet-stream", body });
+            if (!answer?.objectId)
+                return null;
+            (0, profile_js_1.counted)("chunks sent as deltas", 1);
+            return { objectId: answer.objectId, storedSize: answer.storedSize, sentBytes: body.byteLength };
+        }
+        catch {
+            return null;
+        }
+    }
     async sendChunk(repositoryId, declaration, piece, digest, 
     /*
       Written at a known position rather than appended. The chunks are sent

package/dist/cbx/src/local/remote.js

@@ -210,7 +210,22 @@ async function push(repository, options) {
                 }
                 await (0, promises_1.rm)(scratch, { recursive: true, force: true });
                 await (0, snapshot_js_1.writeEntriesInto)(repository, scratch, changed.map((file) => after.get(file)));
+                /*
+                  This history holds the base of every file it changes, as Git's sender
+                  does, so changed files go up as exact patches with no signatures
+                  fetched first.
+                */
+                const baseTree = before;
                 const request = {
+                    /* The listing of each version pushed is kept in the history, for the next push. */
+                    listingRoot: repository.directory,
+                    localBase: async (file, sha256) => {
+                        const entry = baseTree.get(file);
+                        if (!entry || entry.sha256 !== sha256)
+                            return null;
+                        const parts = await Promise.all(entry.chunks.map((name) => repository.objects.get(name)));
+                        return new Uint8Array(Buffer.concat(parts));
+                    },
                     localPath: scratch,
                     include: [...changed, ...changes.deleted],
                     deletions: changes.deleted,

package/dist/cbx/src/shared/delta.js

@@ -18,6 +18,7 @@ exports.deltaBlockSize = deltaBlockSize;
 exports.estimateDeltaSignatureBytes = estimateDeltaSignatureBytes;
 exports.createDeltaSignature = createDeltaSignature;
 exports.parseDeltaSignature = parseDeltaSignature;
+exports.createExactDeltaPatch = createExactDeltaPatch;
 exports.createDeltaPatch = createDeltaPatch;
 exports.deltaPatchTargetSize = deltaPatchTargetSize;
 exports.applyDeltaPatch = applyDeltaPatch;
@@ -313,6 +314,105 @@ function encodePatchV2(targetSize, operations) {
     }
     return out;
 }
+/* Bytes a run must share with the base before it is worth a COPY over a literal. */
+const EXACT_MIN_COPY = 12;
+const EXACT_WINDOW = 16;
+function windowKey(bytes, at) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < EXACT_WINDOW; index += 1) {
+        hash = Math.imul(hash ^ (bytes[at + index] ?? 0), 0x01000193);
+    }
+    return hash >>> 0;
+}
+/**
+ * Build a V2 patch from the base bytes themselves, for a client that still
+ * holds the version it is editing, the way Git's sender holds the objects the
+ * receiver has. No signature is fetched, and copies start and end on any
+ * byte, so a one-byte edit costs a few bytes instead of a whole block.
+ *
+ * The result is the same CRP2 format the receiver-signature path produces:
+ * any service that applies those applies this, and verifies the digest after.
+ */
+function createExactDeltaPatch(base, target) {
+    if (target.byteLength > exports.DELTA_MAX_FILE_BYTES || base.byteLength > exports.DELTA_MAX_FILE_BYTES) {
+        throw new Error("Delta target exceeds the bounded transport limit");
+    }
+    const operations = [];
+    /* The common case is one edited region: keep both ends whole. */
+    const limit = Math.min(base.byteLength, target.byteLength);
+    let prefix = 0;
+    while (prefix < limit && base[prefix] === target[prefix])
+        prefix += 1;
+    let suffix = 0;
+    while (suffix < limit - prefix &&
+        base[base.byteLength - 1 - suffix] === target[target.byteLength - 1 - suffix])
+        suffix += 1;
+    if (prefix >= EXACT_MIN_COPY)
+        appendOperation(operations, { kind: "copy", offset: 0, length: prefix });
+    else
+        prefix = 0;
+    if (suffix < EXACT_MIN_COPY)
+        suffix = 0;
+    const baseEnd = base.byteLength - suffix;
+    const targetEnd = target.byteLength - suffix;
+    /* Every window of the base's middle, by the offset it starts at. */
+    const index = new Map();
+    /*
+      Every offset for a small middle; every sixteenth past 256 KiB, as Git's
+      delta indexes, so an 8 MiB base is half a million entries, not eight
+      million. The target is still scanned at every byte, so moved text is found.
+    */
+    const stride = baseEnd - prefix > 256 * 1024 ? EXACT_WINDOW : 1;
+    for (let at = prefix; at + EXACT_WINDOW <= baseEnd; at += stride) {
+        const key = windowKey(base, at);
+        const list = index.get(key);
+        if (!list)
+            index.set(key, [at]);
+        else if (list.length < 16)
+            list.push(at);
+    }
+    let cursor = prefix;
+    let literalStart = prefix;
+    while (cursor + EXACT_WINDOW <= targetEnd) {
+        const candidates = index.get(windowKey(target, cursor));
+        let bestOffset = -1;
+        let bestLength = 0;
+        let bestBack = 0;
+        for (const offset of candidates ?? []) {
+            let length = 0;
+            while (cursor + length < targetEnd &&
+                offset + length < baseEnd &&
+                base[offset + length] === target[cursor + length])
+                length += 1;
+            let back = 0;
+            while (back < cursor - literalStart &&
+                back < offset - prefix &&
+                base[offset - back - 1] === target[cursor - back - 1])
+                back += 1;
+            if (length + back > bestLength + bestBack) {
+                bestOffset = offset;
+                bestLength = length;
+                bestBack = back;
+            }
+        }
+        if (bestOffset >= 0 && bestLength + bestBack >= EXACT_MIN_COPY) {
+            appendOperation(operations, { kind: "literal", bytes: target.slice(literalStart, cursor - bestBack) });
+            appendOperation(operations, {
+                kind: "copy",
+                offset: bestOffset - bestBack,
+                length: bestLength + bestBack,
+            });
+            cursor += bestLength;
+            literalStart = cursor;
+            continue;
+        }
+        cursor += 1;
+    }
+    appendOperation(operations, { kind: "literal", bytes: target.slice(literalStart, targetEnd) });
+    if (suffix)
+        appendOperation(operations, { kind: "copy", offset: baseEnd, length: suffix });
+    return encodePatchV2(target.byteLength, operations);
+}
 /** Build COPY/INSERT operations from receiver signatures, without base bytes. */
 function createDeltaPatch(target, signature) {
     if (target.byteLength > exports.DELTA_MAX_FILE_BYTES) {

package/dist/cbx/src/shared/native_engine.js

@@ -96,13 +96,35 @@ function engineProblem() {
         return broken;
     return enginePath() ? null : "no engine for this platform";
 }
-/** Whether a batch of this size is worth handing to the engine. */
+/*
+  Whether the engine should open and read files itself (store, measure), as
+  opposed to only walking folders (scan).
+
+  Not on Windows, for now. With real-time protection on, which is nearly
+  everyone, Windows Security scans each new file when the unsigned engine
+  opens it and barely slows Node, a signed and widely known program. On a
+  fresh copy of 8,525 files the engine took 13–16 s to store what Node read
+  and stored in 3 s; with protection off the engine took 0.5 s. Until the
+  engine is signed, Windows reads files here and the engine keeps the folder
+  walk, which only lists and stats and is not scanned. CBX_ENGINE_READS=on
+  turns engine reads back on.
+*/
+function engineMayRead() {
+    if (process.env.CBX_ENGINE_READS === "on")
+        return true;
+    if (process.env.CBX_ENGINE_READS === "off")
+        return false;
+    return process.platform !== "win32";
+}
+/** Whether a batch of this size is worth handing to the engine to read. */
 function worthTheEngine(files, bytes) {
     if (enginePath() === null || broken || files === 0)
         return false;
     /* CBX_ENGINE_ALWAYS=1 sends every batch, however small, so tests can run everything through it. */
     if (process.env.CBX_ENGINE_ALWAYS === "1")
         return true;
+    if (!engineMayRead())
+        return false;
     return files >= exports.ENGINE_MIN_FILES || bytes >= exports.ENGINE_MIN_BYTES;
 }
 function run(args, input, onLine, signal) {

package/dist/cli/src/cli.js

@@ -1267,14 +1267,27 @@ Pass ${accent("--allow-secrets")} if these are not real keys.`);
       command now does it itself, a few times, before giving up.
     */
     const resumeAfter = [10, 30, 60];
+    /*
+      The project an attempt created, for the attempts after it. A first save
+      creates its project while planning, and the project stays once anything
+      has been sent so a retry can reuse what arrived; but the retry used to ask
+      to create it again under the same name and was refused, so a dropped
+      connection during a first save could never be picked up.
+    */
+    let createdRepositoryId = null;
     for (let resumed = 0;; resumed += 1) {
         try {
+            if (createdRepositoryId && !uploadRequest.repositoryId) {
+                Object.assign(uploadRequest, { repositoryId: createdRepositoryId });
+            }
             const plan = await uploader.plan(uploadRequest, (progress) => {
                 line(`  ${track(progress.percent)} ${String(progress.percent).padStart(3)}%  ` +
                     `${"plan".padEnd(7)} ${progress.files}/${progress.totalFiles}  ` +
                     dim(progress.path.slice(-40)));
             });
             done(line);
+            if (plan.repositoryCreated)
+                createdRepositoryId = plan.repositoryId;
             console.log(`${accent("Upload plan")}  ${bytes(plan.sourceBytes)} selected → ` +
                 `${bytes(plan.compactedBytes)} compacted; ${bytes(plan.chargeableBytes)} new storage.`);
             console.log(plan.allowance.exempt

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coderook/cli",
-  "version": "0.46.0",
+  "version": "0.46.2",
   "description": "The command line for CodeRook (coderook.com): version control and project hosting for projects of any size. Every save is a compressed snapshot, private or public, never used to train AI.",
   "license": "Apache-2.0",
   "homepage": "https://coderook.com",