@bli-cockpit/cli 0.2.237 → 0.2.238

package/dist/evidence-reconcile-client.js

@@ -55,70 +55,9 @@ export async function runEvidenceReconcile(options) {
         const batches = chunk(hashes, EVIDENCE_RECONCILE_MAX_BATCH);
         const bounded = options.maxBatches != null ? batches.slice(0, options.maxBatches) : batches;
         const cursor = await readReconcileCursor(paths);
-        let committed = 0;
-        let notCommitted = 0;
-        let unknownToServer = 0;
-        let failedBatches = 0;
-        let firstFailureReason = null;
-        let askedThisRun = 0;
-        for (const batch of bounded) {
-            const outcome = await sendReconcileBatch({
-                dashboardUrl: options.dashboardUrl,
-                deviceToken: session.device_token,
-                hashes: batch,
-                fetchImpl: doFetch,
-            });
-            if (!outcome.ok) {
-                failedBatches += 1;
-                firstFailureReason ??= outcome.reason;
-                continue;
-            }
-            askedThisRun += batch.length;
-            for (const item of outcome.results) {
-                recordReconcileResult(cursor, item.content_hash_sha256, {
-                    verdict: item.verdict,
-                    checked_at: now.toISOString(),
-                    server_committed_at: item.verdict === "committed" ? item.committed_at : null,
-                });
-                if (item.verdict === "committed")
-                    committed += 1;
-                else if (item.verdict === "not_committed")
-                    notCommitted += 1;
-                else
-                    unknownToServer += 1;
-            }
-        }
-        if (askedThisRun > 0) {
-            cursor.updated_at = now.toISOString();
-            await writeReconcileCursor(paths, cursor).catch((error) => {
-                // The prune's own forgetStagedObjects follows the same rule: the
-                // answer is not lost (the server has it), but a reader of THIS
-                // machine will ask again next run rather than silently drift.
-                console.error("[collector reconcile] reconcile cursor not written after answers landed", JSON.stringify({
-                    reason: "reconcile_cursor_write_failed",
-                    answered_count: askedThisRun,
-                    ...describeError(error),
-                }));
-            });
-        }
-        const result = {
-            status: askedThisRun > 0 ? "ok" : "fail",
-            reason: reconcileReason({
-                askedThisRun,
-                failedBatches,
-                firstFailureReason,
-                boundedShortOfAvailable: bounded.length < batches.length,
-            }),
-            asked: askedThisRun,
-            committed,
-            not_committed: notCommitted,
-            unknown_to_server: unknownToServer,
-            batches: bounded.length,
-            failed_batches: failedBatches,
-            total_batches: batches.length,
-        };
-        reportReconcile(result);
-        return result;
+        const counts = await askReconcileBatches(bounded, cursor, options.dashboardUrl, session.device_token, doFetch, now);
+        await writeAnsweredReconcileCursor(paths, cursor, now, counts.askedThisRun);
+        return finishReconcilePass(counts, bounded.length, batches.length);
     }
     catch (error) {
         const result = {
@@ -129,6 +68,78 @@ export async function runEvidenceReconcile(options) {
         return result;
     }
 }
+async function askReconcileBatches(bounded, cursor, dashboardUrl, deviceToken, doFetch, now) {
+    let committed = 0;
+    let notCommitted = 0;
+    let unknownToServer = 0;
+    let failedBatches = 0;
+    let firstFailureReason = null;
+    let askedThisRun = 0;
+    for (const batch of bounded) {
+        const outcome = await sendReconcileBatch({
+            dashboardUrl,
+            deviceToken,
+            hashes: batch,
+            fetchImpl: doFetch,
+        });
+        if (!outcome.ok) {
+            failedBatches += 1;
+            firstFailureReason ??= outcome.reason;
+            continue;
+        }
+        askedThisRun += batch.length;
+        for (const item of outcome.results) {
+            recordReconcileResult(cursor, item.content_hash_sha256, {
+                verdict: item.verdict,
+                checked_at: now.toISOString(),
+                server_committed_at: item.verdict === "committed" ? item.committed_at : null,
+            });
+            if (item.verdict === "committed")
+                committed += 1;
+            else if (item.verdict === "not_committed")
+                notCommitted += 1;
+            else
+                unknownToServer += 1;
+        }
+    }
+    return { committed, notCommitted, unknownToServer, failedBatches, firstFailureReason, askedThisRun };
+}
+async function writeAnsweredReconcileCursor(paths, cursor, now, askedThisRun) {
+    if (askedThisRun > 0) {
+        cursor.updated_at = now.toISOString();
+        await writeReconcileCursor(paths, cursor).catch((error) => {
+            // The prune's own forgetStagedObjects follows the same rule: the
+            // answer is not lost (the server has it), but a reader of THIS
+            // machine will ask again next run rather than silently drift.
+            console.error("[collector reconcile] reconcile cursor not written after answers landed", JSON.stringify({
+                reason: "reconcile_cursor_write_failed",
+                answered_count: askedThisRun,
+                ...describeError(error),
+            }));
+        });
+    }
+}
+function finishReconcilePass(counts, boundedCount, totalBatches) {
+    const { committed, notCommitted, unknownToServer, failedBatches, firstFailureReason, askedThisRun } = counts;
+    const result = {
+        status: askedThisRun > 0 ? "ok" : "fail",
+        reason: reconcileReason({
+            askedThisRun,
+            failedBatches,
+            firstFailureReason,
+            boundedShortOfAvailable: boundedCount < totalBatches,
+        }),
+        asked: askedThisRun,
+        committed,
+        not_committed: notCommitted,
+        unknown_to_server: unknownToServer,
+        batches: boundedCount,
+        failed_batches: failedBatches,
+        total_batches: totalBatches,
+    };
+    reportReconcile(result);
+    return result;
+}
 function reconcileReason(input) {
     if (input.askedThisRun === 0) {
         return `reconcile_unavailable: ${input.firstFailureReason ?? "unknown"}`;

package/dist/evidence-redelivery-plan.js

@@ -112,43 +112,46 @@ export async function planEvidenceRedelivery(options) {
             countUnplannable(plan, "no_manifest_row");
             continue;
         }
-        let packPlan = packPlans.get(object.pack_id);
-        if (!packPlan) {
-            packPlan = {
-                pack_id: object.pack_id,
-                provenance: manifest.provenance,
-                files: [],
-                bytes: 0,
-            };
-            packPlans.set(object.pack_id, packPlan);
-            plan.packs.push(packPlan);
-        }
-        packPlan.files.push({
-            pointer: {
-                raw_evidence_pointer_id: row.object_key,
-                privacy_classification: "remote_durable_raw_evidence",
-                retention_policy: {
-                    mode: RAW_EVIDENCE_RETENTION_MODE,
-                    privacy_classification: "remote_durable_raw_evidence",
-                },
-                storage_scope: "remote_object",
-                storage_bucket: RAW_EVIDENCE_BUCKET,
-                object_key: row.object_key,
-                content_hash_sha256: row.content_hash_sha256,
-                byte_size: row.byte_size,
-                media_type: row.media_type,
-                redacted_summary: row.redacted_summary,
-            },
-            local_path: path.join(root, object.pack_id, ...object.relative_path.split("/").filter(Boolean)),
-            kind: row.kind,
-            codex_session_id: null,
-        });
-        packPlan.bytes += object.byte_size;
-        plan.object_count += 1;
-        plan.bytes += object.byte_size;
+        addRedeliveryObject(plan, packPlans, manifest, row, object, root);
     }
     return plan;
 }
+function addRedeliveryObject(plan, packPlans, manifest, row, object, root) {
+    let packPlan = packPlans.get(object.pack_id);
+    if (!packPlan) {
+        packPlan = {
+            pack_id: object.pack_id,
+            provenance: manifest.provenance,
+            files: [],
+            bytes: 0,
+        };
+        packPlans.set(object.pack_id, packPlan);
+        plan.packs.push(packPlan);
+    }
+    packPlan.files.push({
+        pointer: {
+            raw_evidence_pointer_id: row.object_key,
+            privacy_classification: "remote_durable_raw_evidence",
+            retention_policy: {
+                mode: RAW_EVIDENCE_RETENTION_MODE,
+                privacy_classification: "remote_durable_raw_evidence",
+            },
+            storage_scope: "remote_object",
+            storage_bucket: RAW_EVIDENCE_BUCKET,
+            object_key: row.object_key,
+            content_hash_sha256: row.content_hash_sha256,
+            byte_size: row.byte_size,
+            media_type: row.media_type,
+            redacted_summary: row.redacted_summary,
+        },
+        local_path: path.join(root, object.pack_id, ...object.relative_path.split("/").filter(Boolean)),
+        kind: row.kind,
+        codex_session_id: null,
+    });
+    packPlan.bytes += object.byte_size;
+    plan.object_count += 1;
+    plan.bytes += object.byte_size;
+}
 /**
  * Every uncommitted object, oldest staged bytes first.
  *

package/dist/evidence-redelivery.js

@@ -78,41 +78,44 @@ export async function runEvidenceRedelivery(options) {
             reportRedelivery(result, plan);
             return result;
         }
-        const outcome = await deliverPlan({
-            plan,
-            dashboardUrl: options.dashboardUrl,
-            deviceToken: session.device_token,
-            fetchImpl: options.fetch ?? fetch,
-            now,
-        });
-        await recordOutcomes(paths, staging, outcome.outcomes, now);
-        const terminalOutcomes = outcome.outcomes.filter(entry => entry.upload_state === "upload_failed" && terminalDeliveryReason(entry.reason));
-        const result = {
-            status: outcome.failed > 0 && outcome.uploaded === 0 ? "fail" : "ok",
-            reason: "redelivered",
-            terminal: (inventory.terminal_count ?? 0) + terminalOutcomes.length,
-            terminal_bytes: (inventory.terminal_bytes ?? 0) + terminalOutcomes.reduce((bytes, entry) => bytes + (entry.pointer.byte_size ?? 0), 0),
-            offered: plan.object_count,
-            offered_bytes: plan.bytes,
-            uploaded: outcome.uploaded,
-            uploaded_bytes: outcome.uploadedBytes,
-            reused: outcome.reused,
-            reconciled_committed_by_409: outcome.outcomes.filter(entry => entry.reason === "reconciled_committed_by_409").length,
-            failed: outcome.failed,
-            held: plan.held_count,
-            deferred: plan.deferred_count,
-            deferred_bytes: plan.deferred_bytes,
-            packs: plan.packs.length,
-            failure_reasons: outcome.failureReasons,
-        };
-        reportRedelivery(result, plan);
-        return result;
+        return await deliverAndRecordPlan(options, paths, staging, now, inventory, plan, session.device_token);
     }
     catch (error) {
         console.error("[evidence-redelivery] the drain could not run; nothing was re-offered", JSON.stringify({ reason: "redelivery_threw", ...describeError(error) }));
         return { ...emptyResult("redelivery_threw", "fail") };
     }
 }
+async function deliverAndRecordPlan(options, paths, staging, now, inventory, plan, deviceToken) {
+    const outcome = await deliverPlan({
+        plan,
+        dashboardUrl: options.dashboardUrl,
+        deviceToken: deviceToken,
+        fetchImpl: options.fetch ?? fetch,
+        now,
+    });
+    await recordOutcomes(paths, staging, outcome.outcomes, now);
+    const terminalOutcomes = outcome.outcomes.filter(entry => entry.upload_state === "upload_failed" && terminalDeliveryReason(entry.reason));
+    const result = {
+        status: outcome.failed > 0 && outcome.uploaded === 0 ? "fail" : "ok",
+        reason: "redelivered",
+        terminal: (inventory.terminal_count ?? 0) + terminalOutcomes.length,
+        terminal_bytes: (inventory.terminal_bytes ?? 0) + terminalOutcomes.reduce((bytes, entry) => bytes + (entry.pointer.byte_size ?? 0), 0),
+        offered: plan.object_count,
+        offered_bytes: plan.bytes,
+        uploaded: outcome.uploaded,
+        uploaded_bytes: outcome.uploadedBytes,
+        reused: outcome.reused,
+        reconciled_committed_by_409: outcome.outcomes.filter(entry => entry.reason === "reconciled_committed_by_409").length,
+        failed: outcome.failed,
+        held: plan.held_count,
+        deferred: plan.deferred_count,
+        deferred_bytes: plan.deferred_bytes,
+        packs: plan.packs.length,
+        failure_reasons: outcome.failureReasons,
+    };
+    reportRedelivery(result, plan);
+    return result;
+}
 /**
  * One `uploadRawEvidenceFilesChunked` call per pack, because provenance is a
  * PACK fact: the repo, branch, operator, session and work context these bytes

package/dist/evidence-transcripts-client.js

@@ -23,7 +23,7 @@ export async function fetchTranscriptObjects(options) {
     const files = new Map();
     const seen = new Set();
     let returned = 0;
-    let unkeyed = 0;
+    const state = { unkeyed: 0 };
     let pages = 0;
     let after = null;
     for (;;) {
@@ -38,29 +38,13 @@ export async function fetchTranscriptObjects(options) {
             if (seen.has(object.ref_id))
                 continue;
             seen.add(object.ref_id);
-            addObject(object);
+            addTranscriptObject(object, files, state);
         }
         // Advance by what the server returned; a page that names no cursor is the last.
         if (!page.nextAfter)
             return finish("exhausted", "ok");
         after = page.nextAfter;
     }
-    function addObject(object) {
-        const identity = transcriptFileFromObjectKey(object.object_key);
-        if (!identity) {
-            unkeyed += 1;
-            return;
-        }
-        const key = transcriptFileKey(identity);
-        const list = files.get(key) ?? [];
-        list.push({
-            object_key: object.object_key,
-            byte_size: object.byte_size,
-            content_hash_sha256: object.content_hash_sha256,
-            stub: object.stub,
-        });
-        files.set(key, list);
-    }
     function finish(status, reason) {
         const result = {
             status,
@@ -69,7 +53,7 @@ export async function fetchTranscriptObjects(options) {
             requested: pages * pageSize,
             returned,
             unique: seen.size,
-            unkeyed,
+            unkeyed: state.unkeyed,
             files,
         };
         console.error("[collector sources] transcript objects listed", JSON.stringify({
@@ -78,13 +62,29 @@ export async function fetchTranscriptObjects(options) {
             requested: result.requested,
             returned,
             unique: seen.size,
-            unkeyed,
+            unkeyed: state.unkeyed,
             file_count: files.size,
             ...(status === "failed_partial" ? { failure: reason } : {}),
         }));
         return result;
     }
 }
+function addTranscriptObject(object, files, state) {
+    const identity = transcriptFileFromObjectKey(object.object_key);
+    if (!identity) {
+        state.unkeyed += 1;
+        return;
+    }
+    const key = transcriptFileKey(identity);
+    const list = files.get(key) ?? [];
+    list.push({
+        object_key: object.object_key,
+        byte_size: object.byte_size,
+        content_hash_sha256: object.content_hash_sha256,
+        stub: object.stub,
+    });
+    files.set(key, list);
+}
 async function requestPage(options) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), TRANSCRIPTS_PAGE_TIMEOUT_MS);

package/dist/evidence-upload-object.js

@@ -56,60 +56,68 @@ async function uploadObjectChunks(options, entry, disposition, chunkSizeBytes, o
             uploadedChunks += 1;
             continue;
         }
-        console.error("[evidence-upload] using chunk route", JSON.stringify({
-            reason: offer ? "signed_upload_refused_fallback" : "signed_upload_not_offered",
-            upload_id: disposition.upload_id, chunk_index: index,
-        }));
-        const encodedChunk = gzipSync(chunk);
-        console.error("[evidence-upload] chunk encoded", JSON.stringify({
-            upload_id: disposition.upload_id, chunk_index: index, chunk_encoding: "gzip",
-            bytes_before: chunk.length, bytes_after: encodedChunk.length,
-        }));
-        const chunkResponse = await requestJson(options, "/api/ambient/evidence/upload/chunk", {
-            schema_version: "ambient-raw-evidence-upload-chunk.v2",
-            encoding: "gzip",
-            generated_at: options.generatedAt,
-            provenance: options.provenance,
-            upload_id: disposition.upload_id,
-            object_key: objectKey,
-            chunk_index: index,
-            chunk_count: entry.chunkCount,
-            chunk_hash_sha256: sha256(chunk),
-            content_base64: encodedChunk.toString("base64"),
-        });
-        if (!chunkResponse.ok) {
-            // Same treatment the commit path has had since BLI-2528: the server's
-            // own reason rides on the label, so `chunk_3_failed_http_413` becomes
-            // `chunk_3_failed_http_413_object_too_large` and the ledger row names
-            // the cause instead of the transport (BLI-3483).
-            const chunkDetail = safeFailureDetail(chunkResponse.body);
-            if (chunkResponse.status === 409 && chunkDetail === "upload_not_pending:committed") {
-                console.error("[evidence-upload] committed receipt reconciled", JSON.stringify({
-                    reason: "reconciled_committed_by_409", upload_id: disposition.upload_id,
-                }));
-                return { ok: false, outcome: {
-                        ...failedOutcome(entry.file, "reconciled_committed_by_409", uploadedChunks),
-                        upload_state: "reused_existing",
-                    } };
-            }
-            console.error("[evidence-upload] chunk rejected", JSON.stringify({
-                reason: "chunk_rejected",
-                upload_id: disposition.upload_id,
-                http_status: chunkResponse.status,
-                server_reason: chunkDetail ?? "none",
-                chunk_index: index,
-                chunk_count: entry.chunkCount,
-                uploaded_chunk_count: uploadedChunks,
-            }));
-            return {
-                ok: false,
-                outcome: failedOutcome(entry.file, `chunk_${index}_failed_http_${chunkResponse.status}${chunkDetail ? `_${chunkDetail}` : ""}`, uploadedChunks),
-            };
-        }
+        const failure = await uploadChunkThroughEndpoint(options, entry, disposition, objectKey, index, chunk, uploadedChunks, Boolean(offer));
+        if (failure)
+            return failure;
         uploadedChunks += 1;
     }
     return { ok: true, uploadedChunks };
 }
+async function uploadChunkThroughEndpoint(options, entry, disposition, objectKey, index, chunk, uploadedChunks, hadSignedOffer) {
+    console.error("[evidence-upload] using chunk route", JSON.stringify({
+        reason: hadSignedOffer ? "signed_upload_refused_fallback" : "signed_upload_not_offered",
+        upload_id: disposition.upload_id, chunk_index: index,
+    }));
+    const encodedChunk = gzipSync(chunk);
+    console.error("[evidence-upload] chunk encoded", JSON.stringify({
+        upload_id: disposition.upload_id, chunk_index: index, chunk_encoding: "gzip",
+        bytes_before: chunk.length, bytes_after: encodedChunk.length,
+    }));
+    const chunkResponse = await requestJson(options, "/api/ambient/evidence/upload/chunk", {
+        schema_version: "ambient-raw-evidence-upload-chunk.v2",
+        encoding: "gzip",
+        generated_at: options.generatedAt,
+        provenance: options.provenance,
+        upload_id: disposition.upload_id,
+        object_key: objectKey,
+        chunk_index: index,
+        chunk_count: entry.chunkCount,
+        chunk_hash_sha256: sha256(chunk),
+        content_base64: encodedChunk.toString("base64"),
+    });
+    if (!chunkResponse.ok)
+        return rejectChunkResponse(chunkResponse, entry, disposition, index, uploadedChunks);
+    return null;
+}
+function rejectChunkResponse(chunkResponse, entry, disposition, index, uploadedChunks) {
+    // Same treatment the commit path has had since BLI-2528: the server's
+    // own reason rides on the label, so `chunk_3_failed_http_413` becomes
+    // `chunk_3_failed_http_413_object_too_large` and the ledger row names
+    // the cause instead of the transport (BLI-3483).
+    const chunkDetail = safeFailureDetail(chunkResponse.body);
+    if (chunkResponse.status === 409 && chunkDetail === "upload_not_pending:committed") {
+        console.error("[evidence-upload] committed receipt reconciled", JSON.stringify({
+            reason: "reconciled_committed_by_409", upload_id: disposition.upload_id,
+        }));
+        return { ok: false, outcome: {
+                ...failedOutcome(entry.file, "reconciled_committed_by_409", uploadedChunks),
+                upload_state: "reused_existing",
+            } };
+    }
+    console.error("[evidence-upload] chunk rejected", JSON.stringify({
+        reason: "chunk_rejected",
+        upload_id: disposition.upload_id,
+        http_status: chunkResponse.status,
+        server_reason: chunkDetail ?? "none",
+        chunk_index: index,
+        chunk_count: entry.chunkCount,
+        uploaded_chunk_count: uploadedChunks,
+    }));
+    return {
+        ok: false,
+        outcome: failedOutcome(entry.file, `chunk_${index}_failed_http_${chunkResponse.status}${chunkDetail ? `_${chunkDetail}` : ""}`, uploadedChunks),
+    };
+}
 async function commitUploadedObject(options, entry, disposition, objectKey, uploadedChunks, directChunks) {
     const commit = await requestJson(options, "/api/ambient/evidence/upload/commit", {
         schema_version: "ambient-raw-evidence-upload-commit.v1",
@@ -119,45 +127,9 @@ async function commitUploadedObject(options, entry, disposition, objectKey, uplo
         object_key: objectKey,
         ...(disposition.signed_uploads ? { direct_chunks: directChunks } : {}),
     });
-    if (!commit.ok) {
-        // The server can tell us this object will be refused again. Take its reason
-        // verbatim so the label names the cause ("storage rejected 116 MB") instead
-        // of the transport ("commit_failed_http_500"), which is all the fleet could
-        // say for the 57 days of BLI-2528.
-        const permanent = permanentCommitRejection(commit.body);
-        if (permanent) {
-            return failedOutcome(entry.file, permanent, uploadedChunks);
-        }
-        // A 5xx whose body is not JSON did not come from the route. The commit
-        // handler always answers `{ code, message, ... }`; an HTML error page means
-        // the serverless process was killed — an out-of-memory on a large
-        // assembly, or a hard timeout — so nothing server-side ran a catch, wrote a
-        // ledger reason, or logged a line. Naming it separately is the only way an
-        // operator reading upload reasons can tell "the server refused these bytes"
-        // from "the server never survived them".
-        //
-        // The stem comes from telemetry-core so the label the collector writes and
-        // the label `classifyUploadFailure` reads are the same string by
-        // construction; the status rides on the end so a 502 gateway timeout can
-        // still be told from a 500 process kill, and core strips it back off.
-        if (commit.status >= 500 && isNonJsonResponseBody(commit.body)) {
-            console.error("[evidence-commit] the server died before it could answer; the object is still pending", JSON.stringify({
-                upload_id: disposition.upload_id,
-                http_status: commit.status,
-                byte_size: entry.bytes.byteLength,
-                chunk_count: entry.chunkCount,
-                uploaded_chunk_count: uploadedChunks,
-                reason: COMMIT_CRASHED_PLATFORM,
-            }));
-            return failedOutcome(entry.file, `${COMMIT_CRASHED_PLATFORM}_http_${commit.status}`, uploadedChunks);
-        }
-        const detail = safeFailureDetail(commit.body);
-        return failedOutcome(entry.file, `commit_failed_http_${commit.status}${detail ? `_${detail}` : ""}`, uploadedChunks);
-    }
-    // "already_committed" means a concurrent or earlier sync made these bytes
-    // durable; this sync does not own them, so they must be reported as reuse —
-    // a later ingest failure here must not clean up an object another sync's
-    // indexed refs already point at.
+    if (!commit.ok)
+        return rejectCommit(commit, entry, disposition, uploadedChunks);
+    // Reused evidence belongs to another sync; later failures must not delete it.
     const parsedCommit = RawEvidenceUploadCommitResponseSchema.safeParse(commit.body);
     if (!parsedCommit.success) {
         return failedOutcome(entry.file, "commit_invalid_response", uploadedChunks);
@@ -189,6 +161,31 @@ async function commitUploadedObject(options, entry, disposition, objectKey, uplo
         uploaded_chunk_count: uploadedChunks,
     };
 }
+function rejectCommit(commit, entry, disposition, uploadedChunks) {
+    // The server can tell us this object will be refused again. Take its reason
+    // verbatim so the label names the cause ("storage rejected 116 MB") instead
+    // of the transport ("commit_failed_http_500"), which is all the fleet could
+    // say for the 57 days of BLI-2528.
+    const permanent = permanentCommitRejection(commit.body);
+    if (permanent) {
+        return failedOutcome(entry.file, permanent, uploadedChunks);
+    }
+    // The route always answers JSON. A non-JSON 5xx is a platform failure;
+    // keep the shared reason stem and HTTP status so retries stay classifiable.
+    if (commit.status >= 500 && isNonJsonResponseBody(commit.body)) {
+        console.error("[evidence-commit] the server died before it could answer; the object is still pending", JSON.stringify({
+            upload_id: disposition.upload_id,
+            http_status: commit.status,
+            byte_size: entry.bytes.byteLength,
+            chunk_count: entry.chunkCount,
+            uploaded_chunk_count: uploadedChunks,
+            reason: COMMIT_CRASHED_PLATFORM,
+        }));
+        return failedOutcome(entry.file, `${COMMIT_CRASHED_PLATFORM}_http_${commit.status}`, uploadedChunks);
+    }
+    const detail = safeFailureDetail(commit.body);
+    return failedOutcome(entry.file, `commit_failed_http_${commit.status}${detail ? `_${detail}` : ""}`, uploadedChunks);
+}
 /**
  * The server's verdict that repeating this commit is pointless, or null.
  *