@coderook/cli 0.22.0 → 0.22.2

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

@@ -27,6 +27,8 @@ const profile_js_1 = require("./profile.js");
 const solid_js_1 = require("./solid.js");
 const retry_js_1 = require("./retry.js");
 const staging_js_1 = require("./staging.js");
+const delta_js_1 = require("../shared/delta.js");
+const telemetry_js_1 = require("../shared/telemetry.js");
 /** Above this the API insists on a multipart session. */
 const DIRECT_LIMIT = 95 * 1024 * 1024;
 /*
@@ -105,6 +107,21 @@ class Uploader {
     chunkingSupported = null;
     /** Null until the service has been asked; see packingAllowed. */
     packingSupported = null;
+    /** Null until the service has advertised its best changed-file transport. */
+    deltaProtocol = null;
+    /** Batch delta is separate so V2 single-file support remains compatible. */
+    deltaBatchSupported = null;
+    microchunkSupported = null;
+    /** 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 = false;
+    plannedObjects = new Map();
+    plannedQuote = null;
+    planningCreatedRepositoryId = null;
+    /** Attached to every object write after the server admits the exact plan. */
+    activeQuoteId = null;
     constructor(credentials) {
         this.credentials = credentials;
     }
@@ -138,8 +155,13 @@ class Uploader {
                 // Its own cancellation first: `worthRetrying` knows nothing of it.
                 if (error instanceof UploadCancelled)
                     throw error;
+                // Completing a multipart upload changes server state. Repeating it can
+                // replace the useful first failure with "upload is not active".
+                if (init.retryable === false)
+                    throw error;
                 if (attempt >= retry_js_1.RETRY_ATTEMPTS || !(0, retry_js_1.worthRetrying)(error))
                     throw error;
+                this.telemetry.retry();
                 await this.pause(wait);
                 wait *= 2;
             }
@@ -164,6 +186,7 @@ class Uploader {
     }
     /** A single attempt. Everything about repeating it lives in `call`. */
     async attempt(route, init) {
+        const started = performance.now();
         const token = await this.credentials.token();
         if (!token)
             throw new Error("Sign in again before uploading");
@@ -174,12 +197,17 @@ class Uploader {
                 authorization: `Bearer ${token}`,
                 "user-agent": "CodeRook/0.1",
                 ...(0, identify_js_1.clientHeaders)(),
+                ...(this.activeQuoteId
+                    ? { "x-coderook-upload-quote": this.activeQuoteId }
+                    : {}),
                 ...(init.contentType ? { "content-type": init.contentType } : {}),
             },
             body: init.body,
             signal: this.controller.signal,
         });
         const text = await response.text();
+        this.telemetry.request(route.split("?")[0] ?? route, init.body, new TextEncoder().encode(text).byteLength, performance.now() - started);
+        this.telemetry.memory(process.memoryUsage().rss);
         if (!response.ok) {
             /*
               Parsed only when it looks like JSON. An edge failure serves an HTML
@@ -224,7 +252,78 @@ class Uploader {
             throw new Error(`${route} returned a malformed reply`);
         }
     }
+    /**
+     * Perform the complete local compaction pass and ask the service whether its
+     * exact physical result fits. No object body is sent by this method.
+     */
+    async plan(request, report) {
+        this.planning = true;
+        this.activeQuoteId = null;
+        this.plannedQuote = null;
+        this.planningCreatedRepositoryId = null;
+        this.plannedObjects.clear();
+        try {
+            await this.runPass(request, report);
+            const quote = this.plannedQuote;
+            if (!quote)
+                throw new Error("Upload planning did not finish");
+            return {
+                ...quote,
+                repositoryCreated: this.planningCreatedRepositoryId === quote.repositoryId,
+            };
+        }
+        catch (error) {
+            if (this.planningCreatedRepositoryId) {
+                await this.call(`/v1/repositories/${this.planningCreatedRepositoryId}`, { method: "DELETE" }).catch(() => undefined);
+            }
+            throw error;
+        }
+        finally {
+            this.planning = false;
+        }
+    }
+    /** Release a review quote, and optionally its newly-created empty project. */
+    async cancelPlan(plan, removeCreatedRepository = false) {
+        await this.call(`/v1/repositories/${plan.repositoryId}/uploads/preflight/${plan.quoteId}`, { method: "DELETE" });
+        if (removeCreatedRepository && plan.repositoryCreated) {
+            await this.call(`/v1/repositories/${plan.repositoryId}`, { method: "DELETE" });
+        }
+    }
+    /** Plan first, then execute only the admitted immutable object set. */
     async run(request, report) {
+        const plan = await this.plan(request, report);
+        return this.execute(request, plan, report);
+    }
+    /** Execute a still-active quote produced by {@link plan}. */
+    async execute(request, plan, report) {
+        this.activeQuoteId = plan.quoteId;
+        try {
+            return await this.runPass({ ...request, repositoryId: plan.repositoryId }, report);
+        }
+        finally {
+            this.activeQuoteId = null;
+        }
+    }
+    rememberObject(definition) {
+        this.plannedObjects.set(definition.sha256, definition);
+        // Only used to let the planning pass build an in-memory candidate. It is
+        // never published or sent to the service.
+        return `00000000-0000-4000-8000-${definition.sha256.slice(0, 12)}`;
+    }
+    definition(sha256, size, mediaType, encoded, kind = "chunk", repositoryRole = "chunk") {
+        return {
+            sha256,
+            size,
+            storedSize: encoded.body.byteLength,
+            storedSha256: encoded.encoding === "gzip" ? encoded.storedSha256 : sha256,
+            mediaType,
+            kind,
+            repositoryRole,
+            encoding: encoded.encoding,
+        };
+    }
+    async runPass(request, report) {
+        this.telemetry = new telemetry_js_1.RepositoryTelemetry();
         // A version is a snapshot, not a delta, so it has to name every file in
         // the project — not merely the ones being sent this time. Anything
         // unchanged keeps the object the previous version already pointed at.
@@ -288,7 +387,23 @@ class Uploader {
         */
         const onDisk = new Set(everything.map((file) => file.path));
         const deletions = new Set(request.deletions ?? []);
+        const readFailures = new Map();
         const vanished = [...ticked].filter((chosen) => !onDisk.has(chosen) && !deletions.has(chosen));
+        /*
+          A caller may still hold a selection drawn before the rules changed. If
+          the file is on disk but absent from the filtered survey, it is excluded,
+          not unreadable. Naming that distinction matters: closing applications
+          cannot fix an ignore rule, while changing or removing the rule can.
+        */
+        for (const chosen of vanished) {
+            try {
+                await (0, promises_1.stat)(node_path_1.default.join(request.localPath, chosen));
+                readFailures.set(chosen, "excluded by the project's ignore rules");
+            }
+            catch (error) {
+                readFailures.set(chosen, error instanceof Error ? error.message : String(error));
+            }
+        }
         // 1. Measure and hash. This is what makes an unchanged file free.
         const declarations = [];
         let totalBytes = 0;
@@ -299,10 +414,11 @@ class Uploader {
             try {
                 size = (await (0, promises_1.stat)(full)).size;
             }
-            catch {
+            catch (error) {
                 // Unreadable now, though it was listed a moment ago. Skipping it
                 // would publish a version quietly missing a file the person chose.
                 vanished.push(file.path);
+                readFailures.set(file.path, error instanceof Error ? error.message : String(error));
                 continue;
             }
             report({
@@ -332,8 +448,9 @@ class Uploader {
             try {
                 digest = await (0, profile_js_1.timed)("hash files", () => digestOf(full));
             }
-            catch {
+            catch (error) {
                 vanished.push(file.path);
+                readFailures.set(file.path, error instanceof Error ? error.message : String(error));
                 continue;
             }
             declarations.push({
@@ -345,8 +462,15 @@ class Uploader {
             });
             totalBytes += size;
         }
-        if (!declarations.length)
+        /*
+          A deletion-only save has no file to hash or upload, but it is still a
+          real new Version: the retained base minus the explicitly selected path.
+          Refusing it here made the object phase look healthy while preventing the
+          manifest-only operation that deletion is supposed to be.
+        */
+        if (!declarations.length && !deletions.size) {
             throw new Error("Nothing is selected to upload");
+        }
         // 2. The project needs somewhere on the account to live.
         this.check();
         let repositoryId = request.repositoryId;
@@ -368,6 +492,8 @@ class Uploader {
                     }),
                 });
                 repositoryId = created.id;
+                if (this.planning)
+                    this.planningCreatedRepositoryId = created.id;
             }
             catch (error) {
                 // The account already has a project of this name — which happens
@@ -379,6 +505,10 @@ class Uploader {
                 repositoryId = existing;
             }
         }
+        // Learn the wire contract once, before the two section pipelines begin.
+        // Otherwise their first feature questions race each other and a busy
+        // service can make one lane cache a false "unsupported" answer.
+        await this.serviceCapabilities();
         /*
           Sent in sections, not in one attempt.
     
@@ -394,6 +524,24 @@ class Uploader {
         */
         const allDeclarations = declarations;
         const declarationByPath = new Map(allDeclarations.map((one) => [one.path, one]));
+        /*
+          The narrow first use of the delta transport.
+    
+          One changed small file used to miss solid packing (which correctly
+          requires a group) and upload its complete compressed bytes. When more
+          than one small file changes, the existing pack remains the better
+          answer and is deliberately untouched. New files have no receiver base
+          and also stay on the existing path.
+        */
+        const logicallyChanged = allDeclarations.filter((one) => prior.get(one.path)?.sha256 !== one.sha256);
+        const deltaDeclaration = logicallyChanged.length === 1 &&
+            request.baseVersionId &&
+            prior.has(logicallyChanged[0].path) &&
+            logicallyChanged[0].size <= BATCH_FILE_LIMIT &&
+            logicallyChanged[0].size <= delta_js_1.DELTA_MAX_FILE_BYTES &&
+            prior.get(logicallyChanged[0].path).sourceSize <= delta_js_1.DELTA_MAX_FILE_BYTES
+            ? logicallyChanged[0]
+            : null;
         const sections = (0, staging_js_1.planSections)(allDeclarations.map((one) => ({ path: one.path, size: one.size })));
         (0, profile_js_1.counted)("sections planned", sections.length);
         const uploaded = [];
@@ -544,7 +692,22 @@ class Uploader {
               an object of their own.
             */
             const packedInto = new Map();
-            if (smallOnes.length > 1) {
+            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));
+                if (placed) {
+                    batched.set(deltaDeclaration.sha256, {
+                        objectId: placed.objectId,
+                        size: placed.storedSize,
+                    });
+                    sentBytes += deltaDeclaration.size;
+                    transferred += placed.sentBytes;
+                    (0, profile_js_1.counted)("files sent as deltas", 1);
+                }
+            }
+            const smallForPacking = smallOnes.filter((one) => !batched.has(one.sha256));
+            if (smallForPacking.length > 1) {
                 let pack = [];
                 let packBytes = 0;
                 /*
@@ -569,6 +732,7 @@ class Uploader {
                     pack = [];
                     packBytes = 0;
                     const task = (async () => {
+                        let exactWireBytes = null;
                         try {
                             /*
                               Compressed together first. This is what the .cbx format is for and
@@ -577,18 +741,36 @@ class Uploader {
                               and 30.2% compressed together, because a two-kilobyte file gives a
                               compressor no dictionary worth having.
                             */
-                            const placed = (await this.packingAllowed())
-                                ? await (0, profile_js_1.timed)("send packs", () => this.putPack(repositoryId, taking.map((item) => ({
-                                    declaration: item.declaration,
+                            const packItems = taking.map((item) => ({
+                                declaration: item.declaration,
+                                body: item.body,
+                            }));
+                            const built = (await this.packingAllowed())
+                                ? await (0, solid_js_1.buildSolidPack)(packItems.map((item) => ({
+                                    sha256: item.declaration.sha256,
                                     body: item.body,
-                                }))))
+                                })))
+                                : 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))
+                                : null;
+                            if (delta) {
+                                (0, profile_js_1.counted)("files sent as delta batch", taking.length);
+                                exactWireBytes = delta.sentBytes;
+                                for (const [digest, one] of delta.objects)
+                                    batched.set(digest, one);
+                            }
+                            const placed = !delta && built
+                                ? await (0, profile_js_1.timed)("send packs", () => this.putPack(repositoryId, packItems, built))
                                 : null;
                             if (placed) {
                                 (0, profile_js_1.counted)("files sent in packs", taking.length);
+                                exactWireBytes = packedBytes;
                                 for (const [digest, one] of placed)
                                     packedInto.set(digest, one);
                             }
-                            else {
+                            else if (!delta) {
                                 /*
                                   Not worth packing — already-compressed content, or too few files.
                                   They still travel together, just as separate objects.
@@ -617,8 +799,11 @@ class Uploader {
                             if (!batched.has(digest) && !packedInto.has(digest))
                                 continue;
                             sentBytes += item.declaration.size;
-                            transferred += item.encoded.body.byteLength;
+                            if (exactWireBytes === null)
+                                transferred += item.encoded.body.byteLength;
                         }
+                        if (exactWireBytes !== null)
+                            transferred += exactWireBytes;
                         report({
                             stage: "upload",
                             files: 0,
@@ -634,7 +819,7 @@ class Uploader {
                     if (flying.size >= BATCH_LANES)
                         await Promise.race(flying);
                 };
-                for (const declaration of smallOnes) {
+                for (const declaration of smallForPacking) {
                     this.check();
                     let body;
                     try {
@@ -699,7 +884,9 @@ class Uploader {
                       whole: cutting it up would trade one request for several and save
                       nothing.
                     */
-                    const chunkProfile = (0, chunking_js_1.profileForFileSize)(declaration.size);
+                    const chunkProfile = (await this.microchunkAllowed())
+                        ? (0, chunking_js_1.microchunkProfileForFileSize)(declaration.size)
+                        : (0, chunking_js_1.profileForFileSize)(declaration.size);
                     if (chunkProfile &&
                         declaration.size >= CHUNK_THRESHOLD &&
                         (await this.chunkingAllowed())) {
@@ -813,6 +1000,41 @@ class Uploader {
             }
         };
         await Promise.all([pipeline(batchy), pipeline(heavy)]);
+        if (this.planning) {
+            report({
+                stage: "publish",
+                files: declarations.length,
+                totalFiles: declarations.length,
+                bytes: sentBytes,
+                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: [...this.plannedObjects.values()],
+                }),
+            });
+            return {
+                repositoryId,
+                versionId: "",
+                sequence: 0,
+                sourceBytes: totalBytes,
+                storedBytes: this.plannedQuote.compactedBytes,
+                sentBytes: this.plannedQuote.chargeableBytes,
+                sentFiles: Object.values(this.plannedQuote.objects).filter((object) => object.needsUpload).length,
+                reusedFiles: reused.length,
+                alreadyStoredFiles: 0,
+                manifest: {},
+                local: {},
+                telemetry: this.telemetry.snapshot(),
+            };
+        }
         // 4. Name the version, which is what makes the upload visible.
         this.check();
         report({
@@ -885,6 +1107,11 @@ class Uploader {
         if (dropped.length) {
             const shown = dropped.slice(0, 5).join(", ");
             const rest = dropped.length > 5 ? ` and ${dropped.length - 5} more` : "";
+            const details = dropped
+                .map((name) => readFailures.get(name) ? `${name}: ${readFailures.get(name)}` : "")
+                .filter(Boolean)
+                .slice(0, 3)
+                .join("; ");
             /*
               Say what to do about it. Refusing is right — a version quietly missing
               a file somebody chose is the one failure a backup tool must never have
@@ -893,10 +1120,14 @@ class Uploader {
               holds them or unticking them. Almost every case is a file another
               program has open, so that is what it says.
             */
-            throw new Error(`${dropped.length} selected file${dropped.length === 1 ? "" : "s"} could not be read, ` +
-                `so nothing was saved: ${shown}${rest}. This usually means another program ` +
-                `has them open. Close it and try again, or untick them in the file list. ` +
-                `Nothing was changed on your account.`);
+            const excluded = dropped.some((name) => readFailures.get(name)?.includes("ignore rules"));
+            throw new Error(`${dropped.length} selected file${dropped.length === 1 ? "" : "s"} could not be included, ` +
+                `so nothing was saved: ${shown}${rest}. ` +
+                (excluded
+                    ? `At least one is excluded by the project's ignore rules. Change the rules or untick it and try again. `
+                    : `Another program may have a file open. Close it or untick the file and try again. `) +
+                `Nothing was changed on your account.` +
+                (details ? ` Details: ${details}` : ""));
         }
         const sourceBytes = contents.reduce((total, item) => total + item.sourceSize, 0);
         const storedBytes = contents.reduce((total, item) => total + item.storedSize, 0);
@@ -1000,6 +1231,7 @@ class Uploader {
             reusedFiles: reused.length,
             /** Selected, but the service already held the content. */
             alreadyStoredFiles: alreadyOnAccount,
+            telemetry: this.telemetry.snapshot(),
             // A file that kept its old object records the digest of *that* copy,
             // not of the file on disk, so an unticked edit is still pending next
             // time rather than looking as though it had been saved.
@@ -1128,24 +1360,38 @@ class Uploader {
      * service would not take it — in which case the caller falls back to sending
      * them separately, which is slower and larger but always works.
      */
-    async putPack(repositoryId, items) {
-        const built = await (0, solid_js_1.buildSolidPack)(items.map((item) => ({
+    async putPack(repositoryId, items, alreadyBuilt) {
+        const built = alreadyBuilt ?? await (0, solid_js_1.buildSolidPack)(items.map((item) => ({
             sha256: item.declaration.sha256,
             body: item.body,
         })));
         if (!built)
             return null;
-        const manifest = JSON.stringify({
-            sha256: built.sha256,
-            storedSha256: built.storedSha256,
-            size: built.size,
-            members: built.members,
-        });
-        const manifestBytes = new TextEncoder().encode(manifest);
-        const packed = new Uint8Array(4 + manifestBytes.byteLength + built.body.byteLength);
-        new DataView(packed.buffer).setUint32(0, manifestBytes.byteLength, false);
-        packed.set(manifestBytes, 4);
-        packed.set(built.body, 4 + manifestBytes.byteLength);
+        const packed = this.frameSolidPack(built);
+        if (this.planning) {
+            const objectId = this.rememberObject({
+                sha256: built.sha256,
+                size: built.size,
+                storedSize: built.body.byteLength,
+                storedSha256: built.storedSha256,
+                mediaType: "application/octet-stream",
+                kind: "solid_pack",
+                repositoryRole: "bundle",
+                encoding: "gzip",
+            });
+            const placed = new Map();
+            for (const member of built.members) {
+                placed.set(member.sha256, {
+                    packObjectId: objectId,
+                    offset: member.offset,
+                    length: member.length,
+                    storedSize: built.size
+                        ? Math.round((member.length / built.size) * built.body.byteLength)
+                        : 0,
+                });
+            }
+            return placed;
+        }
         const answer = await this.call(`/v1/repositories/${repositoryId}/objects/pack`, {
             method: "POST",
             contentType: "application/octet-stream",
@@ -1174,6 +1420,235 @@ class Uploader {
         }
         return placed;
     }
+    /** The exact HTTP body used for the solid-pack alternative. */
+    frameSolidPack(built) {
+        const manifestBytes = new TextEncoder().encode(JSON.stringify({
+            sha256: built.sha256,
+            storedSha256: built.storedSha256,
+            size: built.size,
+            members: built.members,
+        }));
+        const packed = new Uint8Array(4 + manifestBytes.byteLength + built.body.byteLength);
+        new DataView(packed.buffer).setUint32(0, manifestBytes.byteLength, false);
+        packed.set(manifestBytes, 4);
+        packed.set(built.body, 4 + manifestBytes.byteLength);
+        return packed;
+    }
+    /**
+     * Price several independent file deltas against the already-built solid
+     * pack. The batch is optional and may only replace the pack when every
+     * 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) {
+        if (!baseVersionId ||
+            solidPackBytes <= 0 ||
+            items.length < 2 ||
+            items.length > delta_js_1.DELTA_BATCH_MAX_FILES ||
+            !(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);
+            if (!base ||
+                !base.sha256 ||
+                item.declaration.size > delta_js_1.DELTA_MAX_FILE_BYTES ||
+                base.sourceSize > delta_js_1.DELTA_MAX_FILE_BYTES)
+                return null;
+            if ((0, node_crypto_1.createHash)("sha256").update(item.body).digest("hex") !==
+                item.declaration.sha256)
+                return null;
+            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);
+        }
+        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)
+                return null;
+            const signatureBytes = new Uint8Array(await response.arrayBuffer());
+            const signatures = (0, delta_js_1.decodeDeltaSignatureBatch)(signatureBytes);
+            if (signatures.length !== items.length)
+                return null;
+            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]),
+                })),
+            });
+            const wireBytes = signatureBytes.byteLength + framed.byteLength;
+            if (wireBytes >= solidPackBytes * 0.8)
+                return null;
+            if (this.planning) {
+                const objects = new Map();
+                for (const item of items) {
+                    const definition = this.definition(item.declaration.sha256, item.body.byteLength, item.declaration.mediaType, item.encoded);
+                    objects.set(item.declaration.sha256, {
+                        objectId: this.rememberObject(definition),
+                        size: definition.storedSize,
+                    });
+                }
+                return { objects, sentBytes: wireBytes };
+            }
+            const answer = await this.call(`/v1/repositories/${repositoryId}/objects/delta/batch`, {
+                method: "POST",
+                contentType: "application/octet-stream",
+                body: framed,
+            });
+            if (answer.objects.length !== items.length)
+                return null;
+            const objects = new Map();
+            for (const object of answer.objects) {
+                if (!items.some((item) => item.declaration.sha256 === object.sha256)) {
+                    return null;
+                }
+                objects.set(object.sha256, {
+                    objectId: object.objectId,
+                    size: object.storedSize,
+                });
+            }
+            const expectedDigests = new Set(items.map((item) => item.declaration.sha256)).size;
+            return objects.size === expectedDigests
+                ? { objects, sentBytes: wireBytes }
+                : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Try the negotiated receiver-signature transport for one changed file.
+     *
+     * Any refusal, old deployment, stale base, or poor result returns null and
+     * the caller sends the complete object exactly as it did before. The patch
+     * 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) {
+        const deltaVersion = await this.deltaVersion();
+        if (deltaVersion === 0)
+            return null;
+        let target;
+        try {
+            target = new Uint8Array(await (0, promises_1.readFile)(declaration.full));
+        }
+        catch {
+            return null;
+        }
+        const digest = (0, node_crypto_1.createHash)("sha256").update(target).digest("hex");
+        if (digest !== declaration.sha256)
+            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)
+            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);
+            let framed;
+            if (signature.version === 2) {
+                framed = (0, delta_js_1.encodeDeltaEnvelope)({
+                    baseVersionId,
+                    path: declaration.path,
+                    sha256: declaration.sha256,
+                    mediaType: declaration.mediaType,
+                    patch,
+                });
+            }
+            else {
+                const manifest = new TextEncoder().encode(JSON.stringify({
+                    baseVersionId,
+                    path: declaration.path,
+                    baseSha256: prior.sha256,
+                    sha256: declaration.sha256,
+                    size: target.byteLength,
+                    mediaType: declaration.mediaType,
+                }));
+                framed = new Uint8Array(4 + manifest.byteLength + patch.byteLength);
+                new DataView(framed.buffer).setUint32(0, manifest.byteLength, false);
+                framed.set(manifest, 4);
+                framed.set(patch, 4 + manifest.byteLength);
+            }
+            // Count both directions. A patch that only looks small because its
+            // receiver signature was ignored is not an improvement.
+            const wireBytes = signatureBytes.byteLength + framed.byteLength;
+            if (wireBytes >= ordinary.body.byteLength * 0.8)
+                return null;
+            if (this.planning) {
+                const definition = this.definition(declaration.sha256, target.byteLength, declaration.mediaType, ordinary);
+                return {
+                    objectId: this.rememberObject(definition),
+                    storedSize: definition.storedSize,
+                    sentBytes: wireBytes,
+                };
+            }
+            const answer = await this.call(`/v1/repositories/${repositoryId}/objects/delta`, {
+                method: "POST",
+                contentType: "application/octet-stream",
+                body: framed,
+            });
+            return {
+                objectId: answer.objectId,
+                storedSize: answer.storedSize,
+                sentBytes: wireBytes,
+            };
+        }
+        catch {
+            // This is an optional transport. The complete-object path is authority.
+            return null;
+        }
+    }
+    async deltaSignature(repositoryId, baseVersionId, filePath, baseSha256, version) {
+        const token = await this.credentials.token();
+        if (!token)
+            throw new Error("Sign in again before uploading");
+        const response = await fetch(`${this.credentials.origin()}/v1/repositories/${repositoryId}/objects/delta/signature`, {
+            method: "POST",
+            headers: {
+                accept: `application/vnd.coderook.delta-signature; version=${version}`,
+                authorization: `Bearer ${token}`,
+                "content-type": "application/json",
+                "user-agent": "CodeRook/0.1",
+                ...(0, identify_js_1.clientHeaders)(),
+            },
+            body: JSON.stringify({ baseVersionId, path: filePath, baseSha256 }),
+            signal: this.controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`Delta signature failed with HTTP ${response.status}`);
+        }
+        return new Uint8Array(await response.arrayBuffer());
+    }
     /**
      * Send many small objects in one request.
      *
@@ -1210,6 +1685,16 @@ class Uploader {
             packed.set(item.encoded.body, at);
             at += item.encoded.body.byteLength;
         }
+        if (this.planning) {
+            for (const item of items) {
+                const definition = this.definition(item.declaration.sha256, item.body.byteLength, item.declaration.mediaType, item.encoded);
+                landed.set(item.declaration.sha256, {
+                    objectId: this.rememberObject(definition),
+                    size: definition.storedSize,
+                });
+            }
+            return landed;
+        }
         const answer = await this.call(`/v1/repositories/${repositoryId}/objects/batch`, {
             method: "POST",
             contentType: "application/octet-stream",
@@ -1420,6 +1905,16 @@ class Uploader {
                     `&logicalSize=${piece.length}` +
                     `&storedSha256=${encoded.storedSha256}`
                 : `?kind=chunk&role=chunk`;
+            if (this.planning) {
+                const definition = this.definition(digest, piece.length, declaration.mediaType, encoded);
+                note("sent", encoded.body.byteLength);
+                chunks[at] = {
+                    objectId: this.rememberObject(definition),
+                    sourceSize: piece.length,
+                    storedSize: definition.storedSize,
+                };
+                return;
+            }
             const stored = await this.call(`/v1/repositories/${repositoryId}/objects/${digest}${query}`, {
                 method: "PUT",
                 contentType: "application/octet-stream",
@@ -1461,6 +1956,13 @@ class Uploader {
                 `&logicalSize=${body.length}` +
                 `&storedSha256=${encoded.storedSha256}`
             : `?kind=chunk&role=chunk`;
+        if (this.planning) {
+            const definition = this.definition(digest, body.length, declaration.mediaType, encoded);
+            return {
+                objectId: this.rememberObject(definition),
+                size: definition.storedSize,
+            };
+        }
         /*
           The answer carries both sizes and they are not the same thing: `size` is
           the file's own length, `storedSize` is what the service actually keeps.
@@ -1501,46 +2003,86 @@ class Uploader {
         this.packingSupported = (await this.serviceFeatures()).includes("solid-packs");
         return this.packingSupported;
     }
+    async microchunkAllowed() {
+        if (this.microchunkSupported !== null)
+            return this.microchunkSupported;
+        this.microchunkSupported = (await this.serviceFeatures()).includes("microchunk-map-v1");
+        return this.microchunkSupported;
+    }
+    async deltaVersion() {
+        if (this.deltaProtocol !== null)
+            return this.deltaProtocol;
+        const features = await this.serviceFeatures();
+        this.deltaProtocol = features.includes("delta-transport-v2")
+            ? 2
+            : features.includes("delta-transport")
+                ? 1
+                : 0;
+        return this.deltaProtocol;
+    }
+    async deltaBatchAllowed() {
+        if (this.deltaBatchSupported !== null)
+            return this.deltaBatchSupported;
+        this.deltaBatchSupported = (await this.serviceFeatures()).includes("delta-batch-v2");
+        return this.deltaBatchSupported;
+    }
     async chunkingAllowed() {
         if (this.chunkingSupported !== null)
             return this.chunkingSupported;
         this.chunkingSupported = (await this.serviceFeatures()).includes("chunked-files");
         return this.chunkingSupported;
     }
-    /** What /health says this deployment accepts. Fetched once. */
+    /** What /health says this deployment accepts. One request per uploader. */
+    async serviceCapabilities() {
+        if (this.capabilityRequest)
+            return this.capabilityRequest;
+        this.capabilityRequest = (async () => {
+            try {
+                const response = await fetch(`${this.credentials.origin()}/health`, {
+                    headers: { accept: "application/json", ...(0, identify_js_1.clientHeaders)() },
+                    signal: AbortSignal.timeout(8000),
+                });
+                if (!response.ok)
+                    throw new Error(`health failed (${response.status})`);
+                const body = (await response.json());
+                return {
+                    features: body.features ?? [],
+                    contentEncodings: body.contentEncodings ?? ["identity"],
+                };
+            }
+            catch {
+                /* Unknown is treated as unsupported: never risk a refused upload. */
+                return { features: [], contentEncodings: ["identity"] };
+            }
+        })();
+        return this.capabilityRequest;
+    }
     async serviceFeatures() {
-        try {
-            const response = await fetch(`${this.credentials.origin()}/health`, {
-                headers: { accept: "application/json", ...(0, identify_js_1.clientHeaders)() },
-                signal: AbortSignal.timeout(8000),
-            });
-            const body = (await response.json());
-            return body.features ?? [];
-        }
-        catch {
-            /* Unknown is treated as unsupported: never risk a refused upload. */
-            return [];
-        }
+        return (await this.serviceCapabilities()).features;
     }
     async gzipAllowed() {
         if (this.gzipSupported !== null)
             return this.gzipSupported;
-        try {
-            const response = await fetch(`${this.credentials.origin()}/health`, {
-                headers: { accept: "application/json", ...(0, identify_js_1.clientHeaders)() },
-                signal: AbortSignal.timeout(8000),
-            });
-            const body = (await response.json());
-            this.gzipSupported = Boolean(body.contentEncodings?.includes("gzip"));
-        }
-        catch {
-            /* Unknown is treated as unsupported: never risk a refused upload. */
-            this.gzipSupported = false;
-        }
+        const body = await this.serviceCapabilities();
+        this.gzipSupported = body.contentEncodings.includes("gzip");
         return this.gzipSupported;
     }
     /** Files past the direct limit go up in parts under an upload session. */
     async putMultipart(repositoryId, declaration, onOffset) {
+        if (this.planning) {
+            const objectId = this.rememberObject({
+                sha256: declaration.sha256,
+                size: declaration.size,
+                storedSize: declaration.size,
+                storedSha256: declaration.sha256,
+                mediaType: declaration.mediaType,
+                kind: "chunk",
+                repositoryRole: "chunk",
+                encoding: "identity",
+            });
+            onOffset(declaration.size);
+            return { objectId, size: declaration.size };
+        }
         const session = await this.call(`/v1/repositories/${repositoryId}/uploads`, {
             method: "POST",
             contentType: "application/json",
@@ -1568,7 +2110,12 @@ class Uploader {
                 partNumber += 1;
                 onOffset(offset);
             }
-            return await this.call(`/v1/uploads/${session.uploadSessionId}/complete`, { method: "POST", contentType: "application/json", body: "{}" });
+            return await this.call(`/v1/uploads/${session.uploadSessionId}/complete`, {
+                method: "POST",
+                contentType: "application/json",
+                body: "{}",
+                retryable: false,
+            });
         }
         catch (error) {
             // A half-finished session would hold storage forever.