@coderook/cli 0.29.4 → 0.30.0

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 transfer_progress_js_1 = require("./transfer_progress.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. */
@@ -339,18 +340,16 @@ class Uploader {
             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.
-        /*
-          An import filters nothing. The rules keep local mess out of a working
-          folder, but an imported tree is exactly what the source repository
-          tracked — there is no mess in it, and anything the source tracked in
-          spite of its own rules (which git does, for files committed before the
-          rule) would otherwise be dropped without being mentioned.
-        */
+    /**
+     * What this save is going to be about: which files, and what came before.
+     *
+     * Lifted out of `runPass` because it answers a question of its own and
+     * nothing after it changes the answer. The pass around it was one function
+     * of twelve hundred lines carrying five stages, which is how a progress
+     * report that reset the bar on every section header went unnoticed inside
+     * it for as long as it did.
+     */
+    async selectFiles(request, report) {
         const rules = request.allowIgnored
             ? { shared: "", local: "" }
             : await (0, worktree_js_1.readRules)(request.localPath);
@@ -458,6 +457,31 @@ class Uploader {
                 readFailures.set(chosen, error instanceof Error ? error.message : String(error));
             }
         }
+        return {
+            rules,
+            everything,
+            unticked,
+            ticked,
+            prior,
+            sending,
+            reused,
+            deletions,
+            readFailures,
+            vanished,
+        };
+    }
+    /**
+     * Every file's digest and size, which is what makes an unchanged file free.
+     *
+     * Its own method because it is the one stage that is purely waiting: each
+     * file here is an open, a read and a close, and on Windows every open is
+     * also an antivirus scan. Keeping it whole and separate is what makes the
+     * lane count and the throttled reporting legible rather than buried in the
+     * middle of a twelve-hundred-line pass.
+     */
+    async hashSelection(request, sending, deletions, readFailures, 
+    /** Ticked, not on disk, not a deletion — named in the refusal below. */
+    vanished, report) {
         // 1. Measure and hash. This is what makes an unchanged file free.
         const declarations = [];
         let totalBytes = 0;
@@ -594,294 +618,441 @@ class Uploader {
         if (!declarations.length && !deletions.size) {
             throw new Error("Nothing is selected to upload");
         }
-        // 2. The project needs somewhere on the account to live.
+        return { declarations, totalBytes };
+    }
+    /**
+     * The project this save goes into, made if it does not exist yet.
+     *
+     * Small enough to inline and worth naming anyway: it is the only step that
+     * can create something on the account, and the slug collision below is the
+     * reason it cannot simply be a create call.
+     */
+    async ensureRepository(request) {
         this.check();
-        let repositoryId = request.repositoryId;
-        if (!repositoryId) {
-            const slug = request.projectName
-                .trim()
-                .toLowerCase()
-                .replace(/[^a-z0-9]+/g, "-")
-                .replace(/^-|-$/g, "") || "project";
-            try {
-                const created = await this.call("/v1/repositories", {
-                    method: "POST",
-                    contentType: "application/json",
-                    body: JSON.stringify({
-                        slug,
-                        displayName: request.projectName.trim() || slug,
-                        description: "",
-                        visibility: "private",
-                    }),
-                });
-                repositoryId = created.id;
-                if (this.planning)
-                    this.planningCreatedRepositoryId = created.id;
-            }
-            catch (error) {
-                // The account already has a project of this name — which happens
-                // after a reinstall, or when the folder has moved. Saving into it is
-                // what was meant; failing would strand the folder.
-                const existing = await this.findBySlug(slug);
-                if (!existing)
-                    throw error;
-                repositoryId = existing;
-            }
+        if (request.repositoryId)
+            return request.repositoryId;
+        const slug = request.projectName
+            .trim()
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, "-")
+            .replace(/^-|-$/g, "") || "project";
+        try {
+            const created = await this.call("/v1/repositories", {
+                method: "POST",
+                contentType: "application/json",
+                body: JSON.stringify({
+                    slug,
+                    displayName: request.projectName.trim() || slug,
+                    description: "",
+                    visibility: "private",
+                }),
+            });
+            if (this.planning)
+                this.planningCreatedRepositoryId = created.id;
+            return created.id;
         }
-        // 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.
-    
-          A section is a bounded amount of work — a few hundred megabytes, or a few
-          thousand files, whichever comes first — and each one finishes before the
-          next begins. A small project is a single section and behaves exactly as
-          it did; a thirty gigabyte one is many, and holds no more at a time than
-          the small one does.
-    
-          The sections are planned from the survey rather than discovered as the
-          upload goes, so the size and shape of the work are known before a byte
-          moves, and a resumed upload plans the same sections in the same order.
-        */
-        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 = [];
-        let sentBytes = 0;
-        /*
-          Bytes that actually travelled, which is not the same as bytes accounted
-          for: a file the service already held advances the progress bar and costs
-          nothing. Reporting the rate from the second number makes a fast, mostly
-          reused save look like a stalled one.
-        */
-        let transferred = 0;
-        /*
-          Files whose content the service already had. Counted apart from what was
-          sent, because reporting them as sent would overstate the work and hide
-          the thing worth knowing: an interrupted save costs nothing to finish.
-        */
-        let alreadyOnAccount = 0;
-        /*
-          How far each lane is through the file it currently holds.
-    
-          With one worker, "everything finished plus how far I am" was simply
-          true. With six it is not: each lane added its own offset to the same
-          shared total, so the reported figure jumped between six different
-          answers and the progress bar ran backwards. Keeping the offsets apart
-          and summing them makes the total the sum of real work again.
-        */
-        const inFlight = new Map();
-        const progressBytes = () => {
-            let total = sentBytes;
-            for (const offset of inFlight.values())
-                total += offset;
-            return total;
-        };
-        /*
-          How fast the thing on screen is moving.
-    
-          Two faults, and they compounded. The rate was `transferred` over the
-          whole elapsed time, while the bar beside it showed `progressBytes()` —
-          different counters measuring different things. `transferred` only moves
-          when a file *finishes*, so a single large file reported a rate of
-          roughly nothing for its entire transfer and then jumped at the end: one
-          real upload sat at "152 MB of 1.1 GB · 10 B/s", which is not a slow
-          upload, it is a number describing something else.
-    
-          And dividing by the time since the start made it a lifetime average, so
-          a slow first minute went on dragging the figure down long after the
-          link had recovered — the opposite of what somebody watching it wants to
-          know, which is whether it is moving *now*.
-    
-          So: the same counter the bar uses, over a short trailing window.
-        */
-        const RATE_WINDOW_MS = 5000;
-        const samples = [];
-        const rate = () => {
-            const now = Date.now();
-            const bytes = progressBytes();
-            const last = samples[samples.length - 1];
-            // Sampled rather than recorded per call: this is asked once per report,
-            // and reports arrive per file, which for small files is thousands a
-            // second.
-            if (!last || now - last.at >= 250)
-                samples.push({ at: now, bytes });
-            while (samples.length > 2 && now - samples[0].at > RATE_WINDOW_MS) {
-                samples.shift();
-            }
-            const oldest = samples[0];
-            const seconds = (now - oldest.at) / 1000;
+        catch (error) {
             /*
-              Nothing until there is something to divide. Answering zero keeps the
-              window quiet rather than showing a figure computed from a fraction of
-              a second, which reads as a stall on an upload that has barely begun.
+              The account already has a project of this name — which happens after a
+              reinstall, or when the folder has moved. Saving into it is what was
+              meant; failing would strand the folder.
             */
-            if (seconds < 0.5)
-                return 0;
-            return Math.max(0, Math.round((bytes - oldest.bytes) / seconds));
-        };
-        /*
-          Two pipelines, not one queue.
-    
-          The sections were run one after another, and they do not compete for the
-          same thing: a section of small files spends about three seconds per batch
-          waiting on the service — measured, and independent of how many objects
-          the batch holds — while a section of large files is limited by the link.
-          One leaves bandwidth idle; the other cannot use any more.
-    
-          So they run together. Each pipeline takes the next section of its own
-          kind, and when one runs out it stops rather than stealing from the other,
-          because that would put two bandwidth-bound pipelines against a link that
-          is already saturated by one.
-        */
-        /*
-          Classified by where the bytes are, not by whether every file qualifies.
-    
-          Requiring every file to be small put one large file in charge of a whole
-          section: on a four gigabyte game it left three sections in one pipeline
-          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.
-        */
-        const smallShare = (one) => one.files
-            .filter((file) => file.size <= BATCH_FILE_LIMIT)
-            .reduce((sum, file) => sum + file.size, 0) / Math.max(one.bytes, 1);
-        const batchy = sections.filter((one) => smallShare(one) >= 0.5);
-        const heavy = sections.filter((one) => smallShare(one) < 0.5);
-        (0, profile_js_1.counted)("sections batched", batchy.length);
-        (0, profile_js_1.counted)("sections heavy", heavy.length);
-        /*
-          How many files the whole save has finished, across every section.
-    
-          The sections are an implementation detail of not holding thirty
-          gigabytes in memory at once, and they were leaking into what a person
-          reads: the count ran up to twenty-one thousand while reading, then reset
-          to "0 of 4,000" for each section and counted up again, over and over. It
-          looked like the save was starting over, repeatedly.
-    
-          One denominator for the whole save. Sections still say which one is in
-          flight, in words, where that belongs.
-        */
-        const sectionProgress = new Map();
-        /*
-          What has already been shown, so the number never goes backwards.
-    
-          Two pipelines run sections at once and each reports its own share, which
-          I have now twice failed to combine into a figure that only rises — the
-          count kept dropping to zero at section boundaries and reading as though
-          the save had restarted. Whatever the accounting does, the panel must not
-          be told a smaller number than it was told a moment ago: going backwards
-          is the specific thing a person notices, and it is never information.
-        */
-        let shown = 0;
-        const forward = (count) => {
-            if (count > shown)
-                shown = count;
-            return shown;
-        };
-        const runSection = async (section) => {
-            const declarations = section.files.map((file) => declarationByPath.get(file.path));
+            const existing = await this.findBySlug(slug);
+            if (!existing)
+                throw error;
+            return existing;
+        }
+    }
+    /**
+     * Name the version, which is what makes everything already stored visible.
+     *
+     * Its own method because the two halves of a save fail differently: up to
+     * here nothing on the account has changed and a retry costs only the bytes
+     * that did not arrive, while past here there is a version. Keeping the
+     * boundary a function call rather than a comment makes that legible.
+     */
+    async publishVersion(at) {
+        const { request, repositoryId, declarations, uploaded, reused, prior, everything, ticked, deletions, readFailures, vanished, totalBytes, progress, report, } = at;
+        // 4. Name the version, which is what makes the upload visible.
+        this.check();
+        report({
+            stage: "publish",
+            files: declarations.length,
+            totalFiles: declarations.length,
+            bytes: progress.sentBytes,
+            totalBytes,
             /*
-              This section's share of the one number the panel shows.
+              A save, not a version.
       
-              Two pipelines run at once, so no section can report on its own behalf
-              without the count lurching between them. Each records how far it has
-              got and the sum is what is shown, which is the only figure that is
-              true while both are moving.
+              Sending produces a commit; it becomes a version when somebody names
+              it, which happens later and on purpose. This line said "Recording the
+              version" while doing neither — it was the last wording left over from
+              before the two were separate, and it sat on the one screen a person
+              watches to the end.
             */
-            const advance = (done) => {
-                /*
-                  Only ever upward.
-        
-                  The workers share one iterator, so the indices arrive out of order —
-                  a worker holding file 5 reports after one holding file 200. Writing
-                  each straight in let a later, lower number undo a higher one, and
-                  the count sat still or fell back to zero at every section boundary,
-                  which is the exact stutter this was meant to remove.
-                */
-                const held = sectionProgress.get(section.index) ?? 0;
-                if (done > held)
-                    sectionProgress.set(section.index, done);
-                else if (!sectionProgress.has(section.index)) {
-                    sectionProgress.set(section.index, 0);
-                }
-                let sum = 0;
-                for (const each of sectionProgress.values())
-                    sum += each;
-                return forward(sum);
-            };
-            report({
-                stage: "upload",
+            path: "Writing down what was sent",
+            percent: 96,
+            bytesPerSecond: progress.rate(),
+        });
+        // The version names everything the project holds: what was just sent,
+        // plus every file that kept the object the last version pointed at.
+        const contents = [
+            ...uploaded,
+            ...reused.map((file) => {
+                const held = prior.get(file.path);
                 /*
-                  The count so far, not zero.
-        
-                  This line announces a new section, and it was reporting nought files
-                  done — so every section boundary threw the number back to the start
-                  and the bar with it. Four of the five reports in this stage were
-                  changed to carry the running total and this one, the only one a
-                  person is guaranteed to see, was missed.
+                  Republished in the shape it was already stored in. A file kept in
+                  pieces names the same pieces; flattening it to one object here would
+                  name an object that was never created.
                 */
-                files: advance(0),
-                totalFiles: allDeclarations.length,
-                bytes: progressBytes(),
-                totalBytes,
-                path: `Section ${section.index + 1} of ${sections.length}`,
-                percent: 20 + Math.round((progressBytes() / Math.max(totalBytes, 1)) * 72),
-                bytesPerSecond: rate(),
-            });
-            /*
-            Ask once what the account already holds.
-      
-            This used to be one request per file, immediately before deciding
-            whether to send it — nine thousand files meant nine thousand serial
-            round trips before a single byte moved, and on a folder of that size the
-            asking took longer than the transfer. The answer per digest is a boolean
-            and an identifier, so the whole question fits in one request.
-          */
-            const alreadyHeld = await (0, profile_js_1.timed)("ask what is already held", () => this.storedInBulk(repositoryId, declarations.map((one) => one.sha256)));
-            /*
-              The small files go first, packed together.
-        
-              They are the overwhelming majority by count and almost nothing by size,
-              so sending them one per request is where an upload spends its time. What
-              is left after this — the large files — is where bandwidth actually
-              matters, and those still go one per request through the lanes below.
-            */
-            const missing = declarations.filter((one) => !alreadyHeld.has(one.sha256));
-            const smallOnes = missing.filter((one) => one.size <= BATCH_FILE_LIMIT);
-            // 3. Send the objects.
-            /*
-              What was sent, in whichever shape it was sent. A small file is one
-              object; a large one is an ordered list of chunks and the digest of the
-              whole, which is what gives it an identity when no single object holds it.
-            */
-            const batched = new Map();
-            /*
-              Files that went up inside a solid pack. Kept apart from `batched` because
-              they are named differently in the version: a slice of a pack rather than
-              an object of their own.
-            */
-            const packedInto = new Map();
+                return {
+                    path: file.path,
+                    /*
+                      Republished in the shape it is stored in — all three of them. The
+                      packed case was missing, so an unchanged small file was declared
+                      with an empty object id instead of the slice it actually is.
+                    */
+                    ...(held.pack
+                        ? {
+                            /*
+                              The uploader's own shape for a pack slice, which is what
+                              the publish step converts to the wire. A file that came
+                              back from the service is described the same way as one this
+                              run packed, so the two paths converge before publishing
+                              rather than at it.
+                            */
+                            pack: {
+                                packObjectId: held.pack.objectId,
+                                offset: held.pack.offset,
+                                length: held.pack.length,
+                                storedSize: held.storedSize,
+                            },
+                            sha256: held.sha256,
+                        }
+                        : held.chunks?.length
+                            ? { chunks: held.chunks, sha256: held.sha256 }
+                            : { objectId: held.objectId }),
+                    sourceSize: held.sourceSize,
+                    storedSize: held.storedSize,
+                    mediaType: held.mediaType,
+                };
+            }),
+        ].sort((left, right) => left.path.localeCompare(right.path));
+        /*
+          Last check before the version is written: everything the person ticked
+          has to be in it. Reaching this with something missing would publish a
+          snapshot that silently lacked a file, which is the one failure a backup
+          tool must never have.
+        */
+        const named = new Set(contents.map((item) => item.path));
+        const dropped = [
+            ...new Set([
+                ...vanished,
+                ...[...ticked].filter((chosen) => !named.has(chosen) && !deletions.has(chosen)),
+            ]),
+        ];
+        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
+              — but the message stopped at the refusal, and the person is left with
+              a list of paths and no idea that the fix is either closing whatever
+              holds them or unticking them. Almost every case is a file another
+              program has open, so that is what it says.
+            */
+            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);
+        /*
+          Every object is uploaded and verified; nothing on the account points at
+          them yet. Stopping here has to leave no version and no partial one — the
+          objects are immutable and content-addressed, so a retry reuses them.
+        */
+        (0, faults_js_1.maybeFail)("submit:after-objects");
+        const completed = await (0, profile_js_1.timed)("publish the version", () => this.call(`/v1/repositories/${repositoryId}/versions`, {
+            method: "POST",
+            contentType: "application/json",
+            body: JSON.stringify({
+                message: request.message.trim() || "Saved from the CodeRook desktop app",
+                ...(request.baseVersionId === undefined
+                    ? {}
+                    : {
+                        ancestryMode: "required",
+                        baseVersionId: request.baseVersionId,
+                    }),
+                ...(request.expectedHeadVersionId === undefined
+                    ? {}
+                    : { expectedHeadVersionId: request.expectedHeadVersionId }),
+                ...(request.track ? { track: request.track } : {}),
+                ...(request.allowIgnored ? { allowIgnored: true } : {}),
+                ...(request.allowSecrets ? { allowSecrets: true } : {}),
+                ...(request.linesAdded === undefined ? {} : { linesAdded: request.linesAdded }),
+                ...(request.linesRemoved === undefined
+                    ? {}
+                    : { linesRemoved: request.linesRemoved }),
+                /*
+                  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 ?? "",
+                    })),
+                }),
+                sourceSize: sourceBytes,
+                storedSize: storedBytes,
+                /*
+                  One shape or the other, never both — the service refuses a file that
+                  names an object and a chunk list, and so does its database.
+                */
+                files: contents.map((item) => ({
+                    path: item.path,
+                    ...(item.pack
+                        ? {
+                            pack: {
+                                objectId: item.pack.packObjectId,
+                                offset: item.pack.offset,
+                                length: item.pack.length,
+                            },
+                            sha256: item.sha256,
+                        }
+                        : item.chunks
+                            ? { chunks: item.chunks, sha256: item.sha256 }
+                            : { objectId: item.objectId }),
+                    sourceSize: item.sourceSize,
+                    storedSize: item.storedSize,
+                    mediaType: item.mediaType,
+                    executable: false,
+                })),
+            }),
+        }));
+        /*
+          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
+          other publisher's safe changes. Persist the service's accepted snapshot
+          instead. A repeated attempt predates manifest echoing, so read that
+          Version once rather than guessing.
+        */
+        let acceptedManifest = (0, publication_js_1.acceptedManifestDigests)(completed.manifest?.files);
+        if (!completed.mergeTrack && !Object.keys(acceptedManifest).length) {
+            acceptedManifest = Object.fromEntries([...(await this.versionFiles(repositoryId, completed.version.id))].map(([file, descriptor]) => [file, descriptor.sha256]));
+        }
+        report({
+            stage: "done",
+            files: declarations.length,
+            totalFiles: declarations.length,
+            bytes: progress.sentBytes,
+            totalBytes,
+            path: `Version ${completed.version.sequence} saved`,
+            percent: 100,
+            bytesPerSecond: progress.rate(),
+        });
+        return {
+            repositoryId,
+            versionId: completed.version.id,
+            sequence: completed.version.sequence,
+            ...(completed.version.state === "held" ? { held: true } : {}),
+            ...(completed.mergeTrack ? { mergeTrack: completed.mergeTrack } : {}),
+            ...(completed.repeated ? { repeated: true } : {}),
+            sourceBytes: completed.version.sourceSize ?? sourceBytes,
+            storedBytes: completed.version.storedSize ?? storedBytes,
+            sentBytes: progress.transferred,
+            sentFiles: uploaded.length - progress.alreadyOnAccount,
+            reusedFiles: reused.length,
+            /** Selected, but the service already held the content. */
+            alreadyStoredFiles: progress.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.
+            /*
+              What this folder holds after the save. A file that was sent holds
+              the bytes that were sent. Anything else keeps whatever digest was
+              recorded before: an unticked edit therefore stays pending rather
+              than looking saved, and a copy left stale by somebody else's merge
+              stays recognisably stale rather than looking like a new edit.
+            */
+            local: Object.fromEntries(everything.flatMap((file) => {
+                const sent = declarations.find((one) => one.path === file.path);
+                if (sent)
+                    return [[file.path, sent.sha256]];
+                const before = request.known?.[file.path] ?? prior.get(file.path)?.sha256;
+                return before ? [[file.path, before]] : [];
+            })),
+            manifest: Object.keys(acceptedManifest).length
+                ? acceptedManifest
+                : {
+                    ...Object.fromEntries(reused.map((file) => [file.path, prior.get(file.path).sha256])),
+                    ...Object.fromEntries(declarations.map((declaration) => [declaration.path, declaration.sha256])),
+                },
+        };
+    }
+    /**
+     * Put every object on the account, and record how each one was stored.
+     *
+     * The longest stage, and where a save spends its time. Kept whole rather
+     * than split further because its parts are not independent: the delta path,
+     * the solid packs, the batches and the per-file lanes are four ways of
+     * answering one question, and which one a file takes is decided by the
+     * section it landed in.
+     *
+     * Nothing here changes anything visible on the account. Objects are
+     * immutable and content-addressed, so an interrupted send costs only the
+     * bytes that did not arrive — which is why the version is named afterwards
+     * rather than before.
+     */
+    async sendObjects(at) {
+        const { request, repositoryId, prior, 
+        /*
+          Bound under a distinct name on purpose. `runSection` declares its own
+          `declarations` for the section it is working on, and a progress report
+          reading the shadowed one says "file 3 of 40" when the save holds
+          twenty thousand.
+        */
+        declarations: everyDeclaration, declarationByPath, deltaDeclaration, sections, totalBytes, progress, uploaded, report, } = at;
+        const smallShare = (one) => one.files
+            .filter((file) => file.size <= BATCH_FILE_LIMIT)
+            .reduce((sum, file) => sum + file.size, 0) / Math.max(one.bytes, 1);
+        const batchy = sections.filter((one) => smallShare(one) >= 0.5);
+        const heavy = sections.filter((one) => smallShare(one) < 0.5);
+        (0, profile_js_1.counted)("sections batched", batchy.length);
+        (0, profile_js_1.counted)("sections heavy", heavy.length);
+        /*
+          How many files the whole save has finished, across every section.
+    
+          The sections are an implementation detail of not holding thirty
+          gigabytes in memory at once, and they were leaking into what a person
+          reads: the count ran up to twenty-one thousand while reading, then reset
+          to "0 of 4,000" for each section and counted up again, over and over. It
+          looked like the save was starting over, repeatedly.
+    
+          One denominator for the whole save. Sections still say which one is in
+          flight, in words, where that belongs.
+        */
+        const sectionProgress = new Map();
+        /*
+          What has already been shown, so the number never goes backwards.
+    
+          Two pipelines run sections at once and each reports its own share, which
+          I have now twice failed to combine into a figure that only rises — the
+          count kept dropping to zero at section boundaries and reading as though
+          the save had restarted. Whatever the accounting does, the panel must not
+          be told a smaller number than it was told a moment ago: going backwards
+          is the specific thing a person notices, and it is never information.
+        */
+        let shown = 0;
+        const forward = (count) => {
+            if (count > shown)
+                shown = count;
+            return shown;
+        };
+        const runSection = async (section) => {
+            const declarations = section.files.map((file) => declarationByPath.get(file.path));
+            /*
+              This section's share of the one number the panel shows.
+      
+              Two pipelines run at once, so no section can report on its own behalf
+              without the count lurching between them. Each records how far it has
+              got and the sum is what is shown, which is the only figure that is
+              true while both are moving.
+            */
+            const advance = (done) => {
+                /*
+                  Only ever upward.
+        
+                  The workers share one iterator, so the indices arrive out of order —
+                  a worker holding file 5 reports after one holding file 200. Writing
+                  each straight in let a later, lower number undo a higher one, and
+                  the count sat still or fell back to zero at every section boundary,
+                  which is the exact stutter this was meant to remove.
+                */
+                const held = sectionProgress.get(section.index) ?? 0;
+                if (done > held)
+                    sectionProgress.set(section.index, done);
+                else if (!sectionProgress.has(section.index)) {
+                    sectionProgress.set(section.index, 0);
+                }
+                let sum = 0;
+                for (const each of sectionProgress.values())
+                    sum += each;
+                return forward(sum);
+            };
+            report({
+                stage: "upload",
+                /*
+                  The count so far, not zero.
+        
+                  This line announces a new section, and it was reporting nought files
+                  done — so every section boundary threw the number back to the start
+                  and the bar with it. Four of the five reports in this stage were
+                  changed to carry the running total and this one, the only one a
+                  person is guaranteed to see, was missed.
+                */
+                files: advance(0),
+                totalFiles: everyDeclaration.length,
+                bytes: progress.bytes(),
+                totalBytes,
+                path: `Section ${section.index + 1} of ${sections.length}`,
+                percent: 20 + Math.round((progress.bytes() / Math.max(totalBytes, 1)) * 72),
+                bytesPerSecond: progress.rate(),
+            });
+            /*
+            Ask once what the account already holds.
+      
+            This used to be one request per file, immediately before deciding
+            whether to send it — nine thousand files meant nine thousand serial
+            round trips before a single byte moved, and on a folder of that size the
+            asking took longer than the transfer. The answer per digest is a boolean
+            and an identifier, so the whole question fits in one request.
+          */
+            const alreadyHeld = await (0, profile_js_1.timed)("ask what is already held", () => this.storedInBulk(repositoryId, declarations.map((one) => one.sha256)));
+            /*
+              The small files go first, packed together.
+        
+              They are the overwhelming majority by count and almost nothing by size,
+              so sending them one per request is where an upload spends its time. What
+              is left after this — the large files — is where bandwidth actually
+              matters, and those still go one per request through the lanes below.
+            */
+            const missing = declarations.filter((one) => !alreadyHeld.has(one.sha256));
+            const smallOnes = missing.filter((one) => one.size <= BATCH_FILE_LIMIT);
+            // 3. Send the objects.
+            /*
+              What was sent, in whichever shape it was sent. A small file is one
+              object; a large one is an ordered list of chunks and the digest of the
+              whole, which is what gives it an identity when no single object holds it.
+            */
+            const batched = new Map();
+            /*
+              Files that went up inside a solid pack. Kept apart from `batched` because
+              they are named differently in the version: a slice of a pack rather than
+              an object of their own.
+            */
+            const packedInto = new Map();
             if (deltaDeclaration &&
                 smallOnes.some((one) => one.path === deltaDeclaration.path)) {
                 const held = prior.get(deltaDeclaration.path);
@@ -891,8 +1062,7 @@ class Uploader {
                         objectId: placed.objectId,
                         size: placed.storedSize,
                     });
-                    sentBytes += deltaDeclaration.size;
-                    transferred += placed.sentBytes;
+                    progress.finished(deltaDeclaration.size, placed.sentBytes);
                     (0, profile_js_1.counted)("files sent as deltas", 1);
                 }
             }
@@ -999,21 +1169,19 @@ class Uploader {
                             const digest = item.declaration.sha256;
                             if (!batched.has(digest) && !packedInto.has(digest))
                                 continue;
-                            sentBytes += item.declaration.size;
-                            if (exactWireBytes === null)
-                                transferred += item.encoded.body.byteLength;
+                            progress.finished(item.declaration.size, exactWireBytes === null ? item.encoded.body.byteLength : 0);
                         }
                         if (exactWireBytes !== null)
-                            transferred += exactWireBytes;
+                            progress.finished(0, exactWireBytes);
                         report({
                             stage: "upload",
                             files: advance(0),
-                            totalFiles: allDeclarations.length,
-                            bytes: progressBytes(),
+                            totalFiles: everyDeclaration.length,
+                            bytes: progress.bytes(),
                             totalBytes,
                             path: taking[taking.length - 1].declaration.path,
-                            percent: 20 + Math.round((progressBytes() / Math.max(totalBytes, 1)) * 72),
-                            bytesPerSecond: rate(),
+                            percent: 20 + Math.round((progress.bytes() / Math.max(totalBytes, 1)) * 72),
+                            bytesPerSecond: progress.rate(),
                         });
                     })().finally(() => flying.delete(task));
                     flying.add(task);
@@ -1061,12 +1229,12 @@ class Uploader {
                     report({
                         stage: "upload",
                         files: advance(index),
-                        totalFiles: allDeclarations.length,
-                        bytes: sentBytes,
+                        totalFiles: everyDeclaration.length,
+                        bytes: progress.bytes(),
                         totalBytes,
                         path: declaration.path,
-                        percent: 20 + Math.round((sentBytes / Math.max(totalBytes, 1)) * 72),
-                        bytesPerSecond: rate(),
+                        percent: 20 + Math.round((progress.bytes() / Math.max(totalBytes, 1)) * 72),
+                        bytesPerSecond: progress.rate(),
                     });
                     /*
                       Content the service already holds does not need sending. Asking costs
@@ -1092,20 +1260,20 @@ class Uploader {
                         declaration.size >= CHUNK_THRESHOLD &&
                         (await this.chunkingAllowed())) {
                         const pieces = await this.putChunked(repositoryId, declaration, chunkProfile, (offset) => {
-                            inFlight.set(index, offset);
+                            progress.lane(index, offset);
                             report({
                                 stage: "upload",
                                 files: advance(index),
-                                totalFiles: allDeclarations.length,
-                                bytes: progressBytes(),
+                                totalFiles: everyDeclaration.length,
+                                bytes: progress.bytes(),
                                 totalBytes,
                                 path: declaration.path,
                                 percent: 20 +
-                                    Math.round(((sentBytes + offset) / Math.max(totalBytes, 1)) * 72),
-                                bytesPerSecond: rate(),
+                                    Math.round((progress.bytes() / Math.max(totalBytes, 1)) * 72),
+                                bytesPerSecond: progress.rate(),
                             });
                         });
-                        inFlight.delete(index);
+                        progress.laneDone(index);
                         /*
                           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
@@ -1113,7 +1281,7 @@ class Uploader {
                           reused and no payload crossed the wire.
                         */
                         if (pieces.sentBytes === 0)
-                            alreadyOnAccount += 1;
+                            progress.alreadyHeld();
                         uploaded.push({
                             path: declaration.path,
                             sha256: declaration.sha256,
@@ -1122,8 +1290,7 @@ class Uploader {
                             storedSize: pieces.chunks.reduce((sum, one) => sum + one.storedSize, 0),
                             mediaType: declaration.mediaType,
                         });
-                        sentBytes += declaration.size;
-                        transferred += pieces.sentBytes;
+                        progress.finished(declaration.size, pieces.sentBytes);
                         continue;
                     }
                     const fromPack = packedInto.get(declaration.sha256);
@@ -1158,7 +1325,7 @@ class Uploader {
                         */
                         (await this.findStored(repositoryId, declaration));
                     if (alreadyStored)
-                        alreadyOnAccount += 1;
+                        progress.alreadyHeld();
                     const result = alreadyStored ??
                         (declaration.size <= DIRECT_LIMIT
                             ? await (0, profile_js_1.timed)("send files one at a time", () => this.putDirect(repositoryId, declaration)).catch((error) => {
@@ -1167,19 +1334,26 @@ class Uploader {
                                 throw new Error(`${declaration.path}: ${reason}`);
                             })
                             : await this.putMultipart(repositoryId, declaration, (offset) => {
+                                /*
+                                  Recorded before the report reads it. Without this the bar does
+                                  not move at all during a multipart file: `bytes()` sums the
+                                  settled total and the open lanes, and this lane's offset is
+                                  only in the second of those once it has been set.
+                                */
+                                progress.lane(index, offset);
                                 report({
                                     stage: "upload",
                                     files: advance(index),
-                                    totalFiles: allDeclarations.length,
-                                    bytes: progressBytes(),
+                                    totalFiles: everyDeclaration.length,
+                                    bytes: progress.bytes(),
                                     totalBytes,
                                     path: declaration.path,
                                     percent: 20 +
-                                        Math.round(((sentBytes + offset) / Math.max(totalBytes, 1)) * 72),
-                                    bytesPerSecond: rate(),
+                                        Math.round((progress.bytes() / Math.max(totalBytes, 1)) * 72),
+                                    bytesPerSecond: progress.rate(),
                                 });
                             }));
-                    inFlight.delete(index);
+                    progress.laneDone(index);
                     uploaded.push({
                         path: declaration.path,
                         objectId: result.objectId,
@@ -1187,9 +1361,7 @@ class Uploader {
                         storedSize: result.size,
                         mediaType: declaration.mediaType,
                     });
-                    sentBytes += declaration.size;
-                    if (!alreadyStored)
-                        transferred += declaration.size;
+                    progress.finished(declaration.size, alreadyStored ? 0 : declaration.size);
                 }
             };
             await Promise.all(Array.from({ length: Math.min(UPLOAD_LANES, declarations.length) }, () => runWorker()));
@@ -1203,12 +1375,119 @@ class Uploader {
             }
         };
         await Promise.all([pipeline(batchy), pipeline(heavy)]);
+    }
+    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.
+        /*
+          An import filters nothing. The rules keep local mess out of a working
+          folder, but an imported tree is exactly what the source repository
+          tracked — there is no mess in it, and anything the source tracked in
+          spite of its own rules (which git does, for files committed before the
+          rule) would otherwise be dropped without being mentioned.
+        */
+        /*
+          Chosen first, and separately: which files this save is about, what the
+          project held before it, and what a ticked path that is no longer on disk
+          means. Nothing below changes any of it.
+        */
+        const { everything, ticked, prior, sending, reused, deletions, readFailures, vanished, } = await this.selectFiles(request, report);
+        /*
+          Read once, here. Everything below works from the declarations rather
+          than from the disk.
+        */
+        const { declarations, totalBytes } = await this.hashSelection(request, sending, deletions, readFailures, vanished, report);
+        // 2. The project needs somewhere on the account to live.
+        const repositoryId = await this.ensureRepository(request);
+        // 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.
+    
+          A section is a bounded amount of work — a few hundred megabytes, or a few
+          thousand files, whichever comes first — and each one finishes before the
+          next begins. A small project is a single section and behaves exactly as
+          it did; a thirty gigabyte one is many, and holds no more at a time than
+          the small one does.
+    
+          The sections are planned from the survey rather than discovered as the
+          upload goes, so the size and shape of the work are known before a byte
+          moves, and a resumed upload plans the same sections in the same order.
+        */
+        const declarationByPath = new Map(declarations.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 = declarations.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)(declarations.map((one) => ({ path: one.path, size: one.size })));
+        (0, profile_js_1.counted)("sections planned", sections.length);
+        const uploaded = [];
+        /*
+          Every number a person watches during a save comes from here. It used to
+          be four loose counters and two closures in the middle of this function,
+          which is where the backwards bar and the "10 B/s" reading both came from
+          — see the note on TransferProgress.
+        */
+        const progress = new transfer_progress_js_1.TransferProgress();
+        /*
+          Two pipelines, not one queue.
+    
+          The sections were run one after another, and they do not compete for the
+          same thing: a section of small files spends about three seconds per batch
+          waiting on the service — measured, and independent of how many objects
+          the batch holds — while a section of large files is limited by the link.
+          One leaves bandwidth idle; the other cannot use any more.
+    
+          So they run together. Each pipeline takes the next section of its own
+          kind, and when one runs out it stops rather than stealing from the other,
+          because that would put two bandwidth-bound pipelines against a link that
+          is already saturated by one.
+        */
+        /*
+          Classified by where the bytes are, not by whether every file qualifies.
+    
+          Requiring every file to be small put one large file in charge of a whole
+          section: on a four gigabyte game it left three sections in one pipeline
+          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.
+        */
+        await this.sendObjects({
+            request,
+            repositoryId,
+            prior,
+            declarations,
+            declarationByPath,
+            deltaDeclaration,
+            sections,
+            totalBytes,
+            progress,
+            uploaded,
+            report,
+        });
         if (this.planning) {
             report({
                 stage: "publish",
                 files: declarations.length,
                 totalFiles: declarations.length,
-                bytes: sentBytes,
+                bytes: progress.sentBytes,
                 totalBytes,
                 path: "Checking storage and monthly allowance",
                 percent: 96,
@@ -1238,243 +1517,22 @@ class Uploader {
                 telemetry: this.telemetry.snapshot(),
             };
         }
-        // 4. Name the version, which is what makes the upload visible.
-        this.check();
-        report({
-            stage: "publish",
-            files: declarations.length,
-            totalFiles: declarations.length,
-            bytes: sentBytes,
-            totalBytes,
-            /*
-              A save, not a version.
-      
-              Sending produces a commit; it becomes a version when somebody names
-              it, which happens later and on purpose. This line said "Recording the
-              version" while doing neither — it was the last wording left over from
-              before the two were separate, and it sat on the one screen a person
-              watches to the end.
-            */
-            path: "Writing down what was sent",
-            percent: 96,
-            bytesPerSecond: rate(),
-        });
-        // The version names everything the project holds: what was just sent,
-        // plus every file that kept the object the last version pointed at.
-        const contents = [
-            ...uploaded,
-            ...reused.map((file) => {
-                const held = prior.get(file.path);
-                /*
-                  Republished in the shape it was already stored in. A file kept in
-                  pieces names the same pieces; flattening it to one object here would
-                  name an object that was never created.
-                */
-                return {
-                    path: file.path,
-                    /*
-                      Republished in the shape it is stored in — all three of them. The
-                      packed case was missing, so an unchanged small file was declared
-                      with an empty object id instead of the slice it actually is.
-                    */
-                    ...(held.pack
-                        ? {
-                            /*
-                              The uploader's own shape for a pack slice, which is what
-                              the publish step converts to the wire. A file that came
-                              back from the service is described the same way as one this
-                              run packed, so the two paths converge before publishing
-                              rather than at it.
-                            */
-                            pack: {
-                                packObjectId: held.pack.objectId,
-                                offset: held.pack.offset,
-                                length: held.pack.length,
-                                storedSize: held.storedSize,
-                            },
-                            sha256: held.sha256,
-                        }
-                        : held.chunks?.length
-                            ? { chunks: held.chunks, sha256: held.sha256 }
-                            : { objectId: held.objectId }),
-                    sourceSize: held.sourceSize,
-                    storedSize: held.storedSize,
-                    mediaType: held.mediaType,
-                };
-            }),
-        ].sort((left, right) => left.path.localeCompare(right.path));
-        /*
-          Last check before the version is written: everything the person ticked
-          has to be in it. Reaching this with something missing would publish a
-          snapshot that silently lacked a file, which is the one failure a backup
-          tool must never have.
-        */
-        const named = new Set(contents.map((item) => item.path));
-        const dropped = [
-            ...new Set([
-                ...vanished,
-                ...[...ticked].filter((chosen) => !named.has(chosen) && !deletions.has(chosen)),
-            ]),
-        ];
-        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
-              — but the message stopped at the refusal, and the person is left with
-              a list of paths and no idea that the fix is either closing whatever
-              holds them or unticking them. Almost every case is a file another
-              program has open, so that is what it says.
-            */
-            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);
-        /*
-          Every object is uploaded and verified; nothing on the account points at
-          them yet. Stopping here has to leave no version and no partial one — the
-          objects are immutable and content-addressed, so a retry reuses them.
-        */
-        (0, faults_js_1.maybeFail)("submit:after-objects");
-        const completed = await (0, profile_js_1.timed)("publish the version", () => this.call(`/v1/repositories/${repositoryId}/versions`, {
-            method: "POST",
-            contentType: "application/json",
-            body: JSON.stringify({
-                message: request.message.trim() || "Saved from the CodeRook desktop app",
-                ...(request.baseVersionId === undefined
-                    ? {}
-                    : {
-                        ancestryMode: "required",
-                        baseVersionId: request.baseVersionId,
-                    }),
-                ...(request.expectedHeadVersionId === undefined
-                    ? {}
-                    : { expectedHeadVersionId: request.expectedHeadVersionId }),
-                ...(request.track ? { track: request.track } : {}),
-                ...(request.allowIgnored ? { allowIgnored: true } : {}),
-                ...(request.allowSecrets ? { allowSecrets: true } : {}),
-                ...(request.linesAdded === undefined ? {} : { linesAdded: request.linesAdded }),
-                ...(request.linesRemoved === undefined
-                    ? {}
-                    : { linesRemoved: request.linesRemoved }),
-                /*
-                  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 ?? "",
-                    })),
-                }),
-                sourceSize: sourceBytes,
-                storedSize: storedBytes,
-                /*
-                  One shape or the other, never both — the service refuses a file that
-                  names an object and a chunk list, and so does its database.
-                */
-                files: contents.map((item) => ({
-                    path: item.path,
-                    ...(item.pack
-                        ? {
-                            pack: {
-                                objectId: item.pack.packObjectId,
-                                offset: item.pack.offset,
-                                length: item.pack.length,
-                            },
-                            sha256: item.sha256,
-                        }
-                        : item.chunks
-                            ? { chunks: item.chunks, sha256: item.sha256 }
-                            : { objectId: item.objectId }),
-                    sourceSize: item.sourceSize,
-                    storedSize: item.storedSize,
-                    mediaType: item.mediaType,
-                    executable: false,
-                })),
-            }),
-        }));
-        /*
-          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
-          other publisher's safe changes. Persist the service's accepted snapshot
-          instead. A repeated attempt predates manifest echoing, so read that
-          Version once rather than guessing.
-        */
-        let acceptedManifest = (0, publication_js_1.acceptedManifestDigests)(completed.manifest?.files);
-        if (!completed.mergeTrack && !Object.keys(acceptedManifest).length) {
-            acceptedManifest = Object.fromEntries([...(await this.versionFiles(repositoryId, completed.version.id))].map(([file, descriptor]) => [file, descriptor.sha256]));
-        }
-        report({
-            stage: "done",
-            files: declarations.length,
-            totalFiles: declarations.length,
-            bytes: sentBytes,
+        return this.publishVersion({
+            request,
+            repositoryId,
+            declarations,
+            uploaded,
+            reused,
+            prior,
+            everything,
+            ticked,
+            deletions,
+            readFailures,
+            vanished,
             totalBytes,
-            path: `Version ${completed.version.sequence} saved`,
-            percent: 100,
-            bytesPerSecond: rate(),
+            progress,
+            report,
         });
-        return {
-            repositoryId,
-            versionId: completed.version.id,
-            sequence: completed.version.sequence,
-            ...(completed.version.state === "held" ? { held: true } : {}),
-            ...(completed.mergeTrack ? { mergeTrack: completed.mergeTrack } : {}),
-            ...(completed.repeated ? { repeated: true } : {}),
-            sourceBytes: completed.version.sourceSize ?? sourceBytes,
-            storedBytes: completed.version.storedSize ?? storedBytes,
-            sentBytes: transferred,
-            sentFiles: uploaded.length - alreadyOnAccount,
-            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.
-            /*
-              What this folder holds after the save. A file that was sent holds
-              the bytes that were sent. Anything else keeps whatever digest was
-              recorded before: an unticked edit therefore stays pending rather
-              than looking saved, and a copy left stale by somebody else's merge
-              stays recognisably stale rather than looking like a new edit.
-            */
-            local: Object.fromEntries(everything.flatMap((file) => {
-                const sent = declarations.find((one) => one.path === file.path);
-                if (sent)
-                    return [[file.path, sent.sha256]];
-                const before = request.known?.[file.path] ?? prior.get(file.path)?.sha256;
-                return before ? [[file.path, before]] : [];
-            })),
-            manifest: Object.keys(acceptedManifest).length
-                ? acceptedManifest
-                : {
-                    ...Object.fromEntries(reused.map((file) => [file.path, prior.get(file.path).sha256])),
-                    ...Object.fromEntries(declarations.map((declaration) => [declaration.path, declaration.sha256])),
-                },
-        };
     }
     /** What the newest version holds, so unchanged files can point at it. */
     async versionFiles(repositoryId, versionId) {