@coderook/cli 0.21.0 → 0.22.1

package/.claude-plugin/plugin.json

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

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

@@ -27,6 +27,7 @@ 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");
 /** Above this the API insists on a multipart session. */
 const DIRECT_LIMIT = 95 * 1024 * 1024;
 /*
@@ -105,6 +106,10 @@ 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;
     constructor(credentials) {
         this.credentials = credentials;
     }
@@ -345,8 +350,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;
@@ -394,6 +406,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 +574,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 +614,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 +623,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 +681,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 +701,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 {
@@ -718,7 +785,14 @@ class Uploader {
                             });
                         });
                         inFlight.delete(index);
-                        alreadyOnAccount += pieces.reused;
+                        /*
+                          A chunk is not a file. Counting every reused piece here made a
+                          one-file save report a negative number of sent files. The selected
+                          file counts as already stored only when every one of its pieces was
+                          reused and no payload crossed the wire.
+                        */
+                        if (pieces.sentBytes === 0)
+                            alreadyOnAccount += 1;
                         uploaded.push({
                             path: declaration.path,
                             sha256: declaration.sha256,
@@ -988,7 +1062,7 @@ class Uploader {
             ...(completed.repeated ? { repeated: true } : {}),
             sourceBytes: completed.version.sourceSize ?? sourceBytes,
             storedBytes: completed.version.storedSize ?? storedBytes,
-            sentBytes,
+            sentBytes: transferred,
             sentFiles: uploaded.length - alreadyOnAccount,
             reusedFiles: reused.length,
             /** Selected, but the service already held the content. */
@@ -1121,24 +1195,14 @@ 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);
         const answer = await this.call(`/v1/repositories/${repositoryId}/objects/pack`, {
             method: "POST",
             contentType: "application/octet-stream",
@@ -1167,6 +1231,216 @@ 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;
+            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;
+            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.
      *
@@ -1301,8 +1575,8 @@ class Uploader {
         */
         const CHUNK_LANES = 4;
         const active = new Set();
-        const dispatch = async (piece, at) => {
-            const task = this.sendChunk(repositoryId, declaration, piece, chunks, at, note).finally(() => {
+        const dispatch = async (piece, at, digest) => {
+            const task = this.sendChunk(repositoryId, declaration, piece, digest, chunks, at, note).finally(() => {
                 active.delete(task);
                 done += piece.length;
                 onOffset(done);
@@ -1311,6 +1585,51 @@ class Uploader {
             if (active.size >= CHUNK_LANES)
                 await Promise.race(active);
         };
+        /*
+          Ask about a bounded group of chunks before sending any of them.
+    
+          The old path asked once per chunk, with four GETs in flight. Besides
+          spending one network round trip per piece, an unavailable lookup was
+          deliberately treated as a miss, so a transient failure retransmitted
+          every otherwise reusable chunk. The website already uses the bulk
+          endpoint. Reusing it here gives Desktop and CLI the same wire behaviour
+          while retaining the safe "send it if unsure" fallback.
+    
+          A batch is no larger than the existing chunk lane count, so this does
+          not increase the memory ceiling: at most four bounded pieces are held.
+        */
+        const batch = [];
+        const flush = async () => {
+            if (!batch.length)
+                return;
+            const ready = batch.splice(0, batch.length);
+            const held = await this.storedInBulk(repositoryId, ready.map((item) => item.digest));
+            for (const item of ready) {
+                const stored = held.get(item.digest);
+                if (stored) {
+                    note("reused", 0);
+                    chunks[item.at] = {
+                        objectId: stored.objectId,
+                        sourceSize: item.piece.length,
+                        storedSize: stored.size,
+                    };
+                    done += item.piece.length;
+                    onOffset(done);
+                    continue;
+                }
+                await dispatch(item.piece, item.at, item.digest);
+            }
+            await Promise.all(active);
+        };
+        const queue = async (piece) => {
+            batch.push({
+                piece,
+                at: ordinal++,
+                digest: (0, node_crypto_1.createHash)("sha256").update(piece).digest("hex"),
+            });
+            if (batch.length >= CHUNK_LANES)
+                await flush();
+        };
         let ordinal = 0;
         let pending = Buffer.alloc(0);
         for await (const block of (0, node_fs_1.createReadStream)(declaration.full, {
@@ -1321,7 +1640,7 @@ class Uploader {
             pending = pending.length ? Buffer.concat([pending, incoming]) : incoming;
             let from = 0;
             for (const cut of (0, chunking_js_1.cutPoints)(pending, profile)) {
-                await dispatch(Buffer.from(pending.subarray(from, cut)), ordinal++);
+                await queue(Buffer.from(pending.subarray(from, cut)));
                 from = cut;
             }
             pending = Buffer.from(pending.subarray(from));
@@ -1333,8 +1652,8 @@ class Uploader {
           Dropping it truncates every chunked file by exactly its last piece.
         */
         if (pending.length)
-            await dispatch(pending, ordinal++);
-        await Promise.all(active);
+            await queue(pending);
+        await flush();
         /*
           Order is the file. Every position must be filled: a hole would mean a
           chunk that never landed, and publishing around it would produce a version
@@ -1351,7 +1670,7 @@ class Uploader {
         };
     }
     /** Send one chunk, reusing it if the account already holds those bytes. */
-    async sendChunk(repositoryId, declaration, piece, 
+    async sendChunk(repositoryId, declaration, piece, digest, 
     /*
       Written at a known position rather than appended. The chunks are sent
       several at a time and finish in whatever order the network decides, but
@@ -1362,48 +1681,27 @@ class Uploader {
     chunks, at, note) {
         {
             this.check();
-            const digest = (0, node_crypto_1.createHash)("sha256").update(piece).digest("hex");
-            /*
-              Asked per chunk rather than per file. This is the whole saving: the
-              parts of a large file that did not change answer "already held" and
-              never travel.
-            */
-            const held = await this.findStored(repositoryId, {
-                ...declaration,
-                sha256: digest,
-                size: piece.length,
+            const encoded = await (0, compress_js_1.encodeForUpload)(new Uint8Array(piece), declaration.path, await this.gzipAllowed());
+            const query = encoded.encoding === "gzip"
+                ? `?kind=chunk&role=chunk&encoding=gzip` +
+                    `&logicalSize=${piece.length}` +
+                    `&storedSha256=${encoded.storedSha256}`
+                : `?kind=chunk&role=chunk`;
+            const stored = await this.call(`/v1/repositories/${repositoryId}/objects/${digest}${query}`, {
+                method: "PUT",
+                contentType: "application/octet-stream",
+                body: encoded.body,
+            }).catch((error) => {
+                const reason = error instanceof Error ? error.message : String(error);
+                throw new Error(`${declaration.path}: ${reason}`);
             });
-            if (held) {
-                note("reused", 0);
-                chunks[at] = {
-                    objectId: held.objectId,
-                    sourceSize: piece.length,
-                    storedSize: held.size,
-                };
-            }
-            else {
-                const encoded = await (0, compress_js_1.encodeForUpload)(new Uint8Array(piece), declaration.path, await this.gzipAllowed());
-                const query = encoded.encoding === "gzip"
-                    ? `?kind=chunk&role=chunk&encoding=gzip` +
-                        `&logicalSize=${piece.length}` +
-                        `&storedSha256=${encoded.storedSha256}`
-                    : `?kind=chunk&role=chunk`;
-                const stored = await this.call(`/v1/repositories/${repositoryId}/objects/${digest}${query}`, {
-                    method: "PUT",
-                    contentType: "application/octet-stream",
-                    body: encoded.body,
-                }).catch((error) => {
-                    const reason = error instanceof Error ? error.message : String(error);
-                    throw new Error(`${declaration.path}: ${reason}`);
-                });
-                note("sent", encoded.body.byteLength);
-                chunks[at] = {
-                    objectId: stored.objectId,
-                    sourceSize: piece.length,
-                    /* What the service keeps, which is smaller when the piece gzipped. */
-                    storedSize: stored.storedSize ?? stored.size,
-                };
-            }
+            note("sent", encoded.body.byteLength);
+            chunks[at] = {
+                objectId: stored.objectId,
+                sourceSize: piece.length,
+                /* What the service keeps, which is smaller when the piece gzipped. */
+                storedSize: stored.storedSize ?? stored.size,
+            };
         }
     }
     async putDirect(repositoryId, declaration) {
@@ -1470,6 +1768,23 @@ class Uploader {
         this.packingSupported = (await this.serviceFeatures()).includes("solid-packs");
         return this.packingSupported;
     }
+    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;