@bli-cockpit/cli 0.2.4 → 0.2.7

package/dist/cursors/backfill-cursor.js

@@ -3,6 +3,8 @@ import fs from "node:fs/promises";
 import path from "node:path";
 export const BACKFILL_CURSOR_FILENAME = "backfill.json";
 export const BACKFILL_COMPLETION_MARKER_FILENAME = "backfill-complete.json";
+export const BACKFILL_COVERAGE_VERSION = "redacted-session-backfill.v3";
+export const BACKFILL_COMPLETION_RECHECK_MS = 24 * 60 * 60 * 1_000;
 export function emptyBackfillCursorState() {
     return {
         schema_version: "cockpit-backfill-cursor.v1",
@@ -29,14 +31,98 @@ export async function writeBackfillCursor(paths, state) {
 export async function writeBackfillCompletionMarker(paths, marker) {
     await writePrivateJson(backfillCompletionMarkerPath(paths), marker);
 }
+export async function readBackfillCompletionMarker(paths) {
+    try {
+        const raw = JSON.parse(await fs.readFile(backfillCompletionMarkerPath(paths), "utf8"));
+        return parseBackfillCompletionMarker(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The cursor is only reusable inside the exact approved-root scope that
+ * produced it. Without this binding, adding a root after an earlier completed
+ * backfill can make the global oldest-mtime cursor skip every session in the
+ * new root.
+ */
+export function prepareBackfillCursorForScope(cursor, collectionRoots, sources) {
+    const collectionScopeId = backfillCollectionScopeId(collectionRoots);
+    let reset = false;
+    for (const source of sources) {
+        if (cursor.sources[source].collection_scope_id === collectionScopeId) {
+            continue;
+        }
+        cursor.sources[source] = emptySourceCursor(collectionScopeId);
+        reset = true;
+    }
+    return {
+        cursor,
+        collection_scope_id: collectionScopeId,
+        reset,
+    };
+}
+export function backfillCompletionCovers(marker, collectionRoots, requiredSources, now = new Date()) {
+    if (!marker)
+        return false;
+    if (marker.coverage_version !== BACKFILL_COVERAGE_VERSION)
+        return false;
+    if (marker.collection_scope_id !== backfillCollectionScopeId(collectionRoots)) {
+        return false;
+    }
+    const revalidateAfter = Date.parse(marker.revalidate_after);
+    if (!Number.isFinite(revalidateAfter) || now.getTime() >= revalidateAfter) {
+        return false;
+    }
+    const completedSources = new Set(marker.sources);
+    return requiredSources.every((source) => completedSources.has(source));
+}
+export function backfillCollectionScopeId(collectionRoots) {
+    const normalized = [...new Set(collectionRoots.map(normalizeScopeRoot))].sort();
+    return `scope-${crypto
+        .createHash("sha256")
+        .update(JSON.stringify(normalized))
+        .digest("hex")
+        .slice(0, 24)}`;
+}
 export function recordBackfillCursorObservations(cursor, observations, now) {
     for (const observation of observations) {
         const source = cursor.sources[observation.source] ?? emptySourceCursor();
+        const newest = source.newest_mtime_ms_covered;
+        if (newest === null ||
+            observation.session_file_mtime_ms > newest) {
+            source.newest_mtime_ms_covered = observation.session_file_mtime_ms;
+            source.newest_mtime_covered = observation.session_file_mtime;
+            source.processed_keys_at_newest_mtime = observation.cursor_key
+                ? [observation.cursor_key]
+                : [];
+        }
+        else if (observation.session_file_mtime_ms === newest &&
+            observation.cursor_key) {
+            source.processed_keys_at_newest_mtime = [
+                ...new Set([
+                    ...source.processed_keys_at_newest_mtime,
+                    observation.cursor_key,
+                ]),
+            ].sort();
+        }
         const oldest = source.oldest_mtime_ms_processed;
         if (oldest === null ||
             observation.session_file_mtime_ms < oldest) {
             source.oldest_mtime_ms_processed = observation.session_file_mtime_ms;
             source.oldest_mtime_processed = observation.session_file_mtime;
+            source.processed_keys_at_oldest_mtime = observation.cursor_key
+                ? [observation.cursor_key]
+                : [];
+        }
+        else if (observation.session_file_mtime_ms === oldest &&
+            observation.cursor_key) {
+            source.processed_keys_at_oldest_mtime = [
+                ...new Set([
+                    ...source.processed_keys_at_oldest_mtime,
+                    observation.cursor_key,
+                ]),
+            ].sort();
         }
         source.state_counts[observation.state] =
             (source.state_counts[observation.state] ?? 0) + 1;
@@ -46,16 +132,43 @@ export function recordBackfillCursorObservations(cursor, observations, now) {
     }
     cursor.updated_at = now.toISOString();
 }
+/**
+ * Marks the upper edge of an exhaustive, issue-free scan. This is deliberately
+ * separate from candidate observations: an empty session store is still a
+ * valid completed scan, and a future run must only revisit files newer than
+ * this edge plus any unfinished historical tail.
+ */
+export function recordBackfillScanCoverage(cursor, sources, coveredThrough, now) {
+    const coveredThroughMs = coveredThrough.getTime();
+    for (const sourceKey of sources) {
+        const source = cursor.sources[sourceKey] ?? emptySourceCursor();
+        if (source.newest_mtime_ms_covered === null ||
+            coveredThroughMs > source.newest_mtime_ms_covered) {
+            source.newest_mtime_ms_covered = coveredThroughMs;
+            source.newest_mtime_covered = coveredThrough.toISOString();
+            // No file identity is implied by a wall-clock scan boundary. A file
+            // later observed at this exact timestamp remains eligible.
+            source.processed_keys_at_newest_mtime = [];
+        }
+        cursor.sources[sourceKey] = source;
+    }
+    cursor.updated_at = now.toISOString();
+}
 export function backfillCursorPath(paths) {
     return path.join(paths.cursors_dir, BACKFILL_CURSOR_FILENAME);
 }
 export function backfillCompletionMarkerPath(paths) {
     return path.join(paths.cursors_dir, BACKFILL_COMPLETION_MARKER_FILENAME);
 }
-function emptySourceCursor() {
+function emptySourceCursor(collectionScopeId = null) {
     return {
+        collection_scope_id: collectionScopeId,
+        newest_mtime_ms_covered: null,
+        newest_mtime_covered: null,
+        processed_keys_at_newest_mtime: [],
         oldest_mtime_ms_processed: null,
         oldest_mtime_processed: null,
+        processed_keys_at_oldest_mtime: [],
         state_counts: {},
         reason_counts: {},
     };
@@ -78,15 +191,63 @@ function parseSourceCursor(value) {
     if (!value || typeof value !== "object")
         return emptySourceCursor();
     const record = value;
+    const newest = optionalNumber(record["newest_mtime_ms_covered"]);
     const oldest = optionalNumber(record["oldest_mtime_ms_processed"]);
     return {
+        collection_scope_id: optionalString(record["collection_scope_id"]),
+        newest_mtime_ms_covered: newest,
+        newest_mtime_covered: optionalString(record["newest_mtime_covered"]) ??
+            (newest === null ? null : new Date(newest).toISOString()),
+        processed_keys_at_newest_mtime: parseStringArray(record["processed_keys_at_newest_mtime"]),
         oldest_mtime_ms_processed: oldest,
         oldest_mtime_processed: optionalString(record["oldest_mtime_processed"]) ??
             (oldest === null ? null : new Date(oldest).toISOString()),
+        processed_keys_at_oldest_mtime: parseStringArray(record["processed_keys_at_oldest_mtime"]),
         state_counts: parseNumberRecord(record["state_counts"]),
         reason_counts: parseNumberRecord(record["reason_counts"]),
     };
 }
+function parseBackfillCompletionMarker(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (record["schema_version"] !== "cockpit-backfill-complete.v2" ||
+        record["coverage_version"] !== BACKFILL_COVERAGE_VERSION) {
+        return null;
+    }
+    const collectionScopeId = optionalString(record["collection_scope_id"]);
+    const completedAt = optionalString(record["completed_at"]);
+    const revalidateAfter = optionalString(record["revalidate_after"]);
+    const rawSources = record["sources"];
+    if (!collectionScopeId ||
+        !completedAt ||
+        !revalidateAfter ||
+        !Number.isFinite(Date.parse(revalidateAfter)) ||
+        !Array.isArray(rawSources)) {
+        return null;
+    }
+    const sources = [
+        ...new Set(rawSources.filter((source) => source === "codex" || source === "claude_code")),
+    ];
+    if (sources.length === 0)
+        return null;
+    return {
+        schema_version: "cockpit-backfill-complete.v2",
+        coverage_version: BACKFILL_COVERAGE_VERSION,
+        collection_scope_id: collectionScopeId,
+        sources,
+        completed_at: completedAt,
+        revalidate_after: revalidateAfter,
+        cursor: parseBackfillCursor(record["cursor"]),
+    };
+}
+function normalizeScopeRoot(value) {
+    const windowsStyle = path.win32.isAbsolute(value) && !path.posix.isAbsolute(value);
+    if (windowsStyle)
+        return path.win32.normalize(value).toLowerCase();
+    const resolved = path.resolve(value);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
 function parseNumberRecord(value) {
     if (!value || typeof value !== "object")
         return {};
@@ -98,6 +259,13 @@ function parseNumberRecord(value) {
     }
     return out;
 }
+function parseStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return [
+        ...new Set(value.filter((entry) => typeof entry === "string" && entry.trim().length > 0)),
+    ].sort();
+}
 async function writePrivateJson(filePath, value) {
     await fs.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
     const tempPath = `${filePath}.tmp-${process.pid}-${crypto.randomUUID()}`;

package/dist/cursors/raw-evidence-cursor.js

@@ -24,7 +24,8 @@ export const PRIMARY_CURSOR_FILENAME = "raw-evidence.json";
 export const CLAUDE_CURSOR_FILENAME = "claude-raw-evidence.json";
 // Sidecars can push a single sync past 500 objects; pruning at 500 would force
 // re-read + re-begin of durable objects every sync thereafter. Entries are
-// ~150 B, so 5,000 is ~750 KB on disk (D4).
+// ~150 B, so 5,000 is ~750 KB on disk (D4). Undurable sessions are exempt from
+// the session cap below because dropping retry state can strand evidence.
 const MAX_TRACKED_OBJECTS = 5_000;
 const MAX_TRACKED_SESSIONS = 5_000;
 export function emptyRawEvidenceCursorState() {
@@ -98,9 +99,22 @@ function pruneCursorState(state) {
     return {
         ...state,
         objects: pruneNewest(state.objects, MAX_TRACKED_OBJECTS, (entry) => entry.committed_at),
-        sessions: pruneNewest(state.sessions, MAX_TRACKED_SESSIONS, (entry) => entry.last_seen_at),
+        sessions: pruneSessionEntries(state.sessions),
     };
 }
+function pruneSessionEntries(sessions) {
+    const entries = Object.entries(sessions);
+    if (entries.length <= MAX_TRACKED_SESSIONS)
+        return sessions;
+    const undurable = entries.filter(([, entry]) => !entry.uploaded_object_key);
+    const durable = entries.filter(([, entry]) => entry.uploaded_object_key);
+    durable.sort((a, b) => b[1].last_seen_at.localeCompare(a[1].last_seen_at));
+    const durableSlots = Math.max(0, MAX_TRACKED_SESSIONS - undurable.length);
+    return Object.fromEntries([
+        ...undurable,
+        ...durable.slice(0, durableSlots),
+    ]);
+}
 function pruneNewest(record, max, sortKey) {
     const entries = Object.entries(record);
     if (entries.length <= max)

package/dist/evidence-upload-client.js

@@ -1,4 +1,4 @@
-import { RAW_EVIDENCE_UPLOAD_DEFAULT_CHUNK_BYTES, RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES, RAW_EVIDENCE_UPLOAD_MAX_OBJECTS_PER_BEGIN, RawEvidenceRedactionMetadataSchema, RawEvidenceUploadCommitResponseSchema, } from "@bli-cockpit/telemetry-core";
+import { RAW_EVIDENCE_UPLOAD_DEFAULT_CHUNK_BYTES, RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES, RAW_EVIDENCE_UPLOAD_MAX_OBJECTS_PER_BEGIN, RawEvidenceLegacyUploadResponseSchema, RawEvidenceRedactionMetadataSchema, RawEvidenceUploadBeginResponseSchema, RawEvidenceUploadCommitResponseSchema, } from "@bli-cockpit/telemetry-core";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 const DEFAULT_MAX_ATTEMPTS = 3;
@@ -97,7 +97,28 @@ export async function uploadRawEvidenceFilesChunked(options) {
             }
             continue;
         }
-        const dispositions = readBeginDispositions(begin.body);
+        const parsedBegin = RawEvidenceUploadBeginResponseSchema.safeParse(begin.body);
+        if (!parsedBegin.success) {
+            for (const entry of batch) {
+                outcomes.push(failedOutcome(entry.file, "begin_invalid_response"));
+                for (const duplicate of entry.duplicates) {
+                    outcomes.push(failedOutcome(duplicate, "begin_invalid_response"));
+                }
+                resolvedEntries.add(entry);
+            }
+            continue;
+        }
+        const dispositions = readBeginDispositions(parsedBegin.data);
+        if (!dispositions) {
+            for (const entry of batch) {
+                outcomes.push(failedOutcome(entry.file, "begin_invalid_response"));
+                for (const duplicate of entry.duplicates) {
+                    outcomes.push(failedOutcome(duplicate, "begin_invalid_response"));
+                }
+                resolvedEntries.add(entry);
+            }
+            continue;
+        }
         for (const entry of batch) {
             const objectKey = entry.file.pointer.object_key ?? "";
             const disposition = dispositions.get(objectKey);
@@ -109,6 +130,15 @@ export async function uploadRawEvidenceFilesChunked(options) {
                 resolvedEntries.add(entry);
                 continue;
             }
+            if (disposition.raw_evidence_pointer_id !==
+                entry.file.pointer.raw_evidence_pointer_id) {
+                outcomes.push(failedOutcome(entry.file, "begin_disposition_mismatch"));
+                for (const duplicate of entry.duplicates) {
+                    outcomes.push(failedOutcome(duplicate, "begin_disposition_mismatch"));
+                }
+                resolvedEntries.add(entry);
+                continue;
+            }
             const outcome = await uploadOneObject(options, entry, disposition, chunkSizeBytes);
             outcomes.push(outcome);
             for (const duplicate of entry.duplicates) {
@@ -144,41 +174,37 @@ function duplicateOutcome(primary, duplicate) {
 async function uploadOneObject(options, entry, disposition, chunkSizeBytes) {
     const objectKey = entry.file.pointer.object_key ?? "";
     if (disposition.disposition === "already_committed") {
-        return {
-            pointer: entry.file.pointer,
-            object_key: objectKey,
-            codex_session_id: entry.file.codex_session_id ?? null,
-            kind: entry.file.kind ?? "unknown",
-            artifact_metadata: entry.file.artifact_metadata,
-            upload_state: "reused_existing",
-            reason: "already_committed",
-            uploaded_chunk_count: 0,
-        };
+        if (!disposition.upload_id) {
+            return failedOutcome(entry.file, "begin_committed_receipt_unavailable");
+        }
     }
     if (disposition.disposition === "conflict" || !disposition.upload_id) {
         return failedOutcome(entry.file, disposition.reason ?? "upload_conflict");
     }
     const received = new Set(disposition.received_chunk_indexes);
     let uploadedChunks = 0;
-    for (let index = 0; index < entry.chunkCount; index += 1) {
-        if (received.has(index))
-            continue;
-        const chunk = entry.bytes.subarray(index * chunkSizeBytes, Math.min((index + 1) * chunkSizeBytes, entry.bytes.byteLength));
-        const chunkResponse = await requestJson(options, "/api/ambient/evidence/upload/chunk", {
-            schema_version: "ambient-raw-evidence-upload-chunk.v1",
-            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: chunk.toString("base64"),
-        });
-        if (!chunkResponse.ok) {
-            return failedOutcome(entry.file, `chunk_${index}_failed_http_${chunkResponse.status}`, uploadedChunks);
+    if (disposition.disposition !== "already_committed" &&
+        !disposition.commit_ready) {
+        for (let index = 0; index < entry.chunkCount; index += 1) {
+            if (received.has(index))
+                continue;
+            const chunk = entry.bytes.subarray(index * chunkSizeBytes, Math.min((index + 1) * chunkSizeBytes, entry.bytes.byteLength));
+            const chunkResponse = await requestJson(options, "/api/ambient/evidence/upload/chunk", {
+                schema_version: "ambient-raw-evidence-upload-chunk.v1",
+                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: chunk.toString("base64"),
+            });
+            if (!chunkResponse.ok) {
+                return failedOutcome(entry.file, `chunk_${index}_failed_http_${chunkResponse.status}`, uploadedChunks);
+            }
+            uploadedChunks += 1;
         }
-        uploadedChunks += 1;
     }
     const commit = await requestJson(options, "/api/ambient/evidence/upload/commit", {
         schema_version: "ambient-raw-evidence-upload-commit.v1",
@@ -188,17 +214,22 @@ async function uploadOneObject(options, entry, disposition, chunkSizeBytes) {
         object_key: objectKey,
     });
     if (!commit.ok) {
-        return failedOutcome(entry.file, `commit_failed_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.
-    const commitStatus = commit.body && typeof commit.body === "object"
-        ? commit.body.status
-        : undefined;
-    const committedPointer = pointerWithCommitResponse(entry.file.pointer, commit.body);
-    if (commitStatus === "already_committed") {
+    const parsedCommit = RawEvidenceUploadCommitResponseSchema.safeParse(commit.body);
+    if (!parsedCommit.success) {
+        return failedOutcome(entry.file, "commit_invalid_response", uploadedChunks);
+    }
+    if (!chunkCommitReceiptMatchesPointer(entry.file.pointer, parsedCommit.data)) {
+        return failedOutcome(entry.file, "commit_receipt_mismatch", uploadedChunks);
+    }
+    const committedPointer = entry.file.pointer;
+    if (parsedCommit.data.status === "already_committed") {
         return {
             pointer: committedPointer,
             object_key: objectKey,
@@ -244,31 +275,38 @@ async function uploadWithLegacyFallback(options, loaded, outcomes) {
             ],
         });
         if (response.ok) {
-            const pointer = pointerWithLegacyUploadResponse(entry.file.pointer, response.body);
-            outcome = {
-                pointer,
-                object_key: entry.file.pointer.object_key ?? "",
-                codex_session_id: entry.file.codex_session_id ?? null,
-                kind: entry.file.kind ?? "unknown",
-                artifact_metadata: entry.file.artifact_metadata,
-                upload_state: "uploaded",
-                reason: "legacy_single_shot_upload",
-                uploaded_chunk_count: 1,
-            };
+            const parsedLegacy = RawEvidenceLegacyUploadResponseSchema.safeParse(response.body);
+            if (!parsedLegacy.success) {
+                outcome = failedOutcome(entry.file, "legacy_upload_invalid_response");
+            }
+            else {
+                const receipt = parsedLegacy.data.uploaded.find((candidate) => candidate.raw_evidence_pointer_id ===
+                    entry.file.pointer.raw_evidence_pointer_id);
+                if (!receipt ||
+                    parsedLegacy.data.bucket !== entry.file.pointer.storage_bucket ||
+                    !legacyUploadReceiptMatchesPointer(entry.file.pointer, receipt)) {
+                    outcome = failedOutcome(entry.file, "legacy_upload_receipt_mismatch");
+                }
+                else {
+                    const pointer = pointerWithLegacyUploadResponse(entry.file.pointer, parsedLegacy.data);
+                    outcome = {
+                        pointer,
+                        object_key: entry.file.pointer.object_key ?? "",
+                        codex_session_id: entry.file.codex_session_id ?? null,
+                        kind: entry.file.kind ?? "unknown",
+                        artifact_metadata: entry.file.artifact_metadata,
+                        upload_state: "uploaded",
+                        reason: "legacy_single_shot_upload",
+                        uploaded_chunk_count: 1,
+                    };
+                }
+            }
         }
         else if (response.status === 409) {
-            // Content-addressed keys repeat across syncs; the legacy route reports
-            // an existing object as a duplicate, which means the bytes are durable.
-            outcome = {
-                pointer: entry.file.pointer,
-                object_key: entry.file.pointer.object_key ?? "",
-                codex_session_id: entry.file.codex_session_id ?? null,
-                kind: entry.file.kind ?? "unknown",
-                artifact_metadata: entry.file.artifact_metadata,
-                upload_state: "reused_existing",
-                reason: "legacy_already_exists",
-                uploaded_chunk_count: 0,
-            };
+            // The pre-ledger route cannot prove that a conflicting object contains
+            // these exact bytes. Fail closed instead of seeding the cursor with an
+            // unverified pointer.
+            outcome = failedOutcome(entry.file, "legacy_upload_conflict_http_409");
         }
         else {
             outcome = failedOutcome(entry.file, `legacy_upload_failed_http_${response.status}`);
@@ -312,27 +350,16 @@ async function requestJson(options, routePath, body) {
 }
 function readBeginDispositions(body) {
     const map = new Map();
-    if (!body || typeof body !== "object")
-        return map;
-    const objects = body.objects;
-    if (!Array.isArray(objects))
-        return map;
-    for (const entry of objects) {
-        if (!entry || typeof entry !== "object")
-            continue;
-        const record = entry;
-        const objectKey = record["object_key"];
-        const disposition = record["disposition"];
-        if (typeof objectKey !== "string" || typeof disposition !== "string") {
-            continue;
-        }
-        map.set(objectKey, {
-            disposition,
-            upload_id: typeof record["upload_id"] === "string" ? record["upload_id"] : null,
-            received_chunk_indexes: Array.isArray(record["received_chunk_indexes"])
-                ? record["received_chunk_indexes"].filter((value) => typeof value === "number")
-                : [],
-            reason: typeof record["reason"] === "string" ? record["reason"] : null,
+    for (const entry of body.objects) {
+        if (map.has(entry.object_key))
+            return null;
+        map.set(entry.object_key, {
+            disposition: entry.disposition,
+            upload_id: entry.upload_id ?? null,
+            received_chunk_indexes: entry.received_chunk_indexes,
+            commit_ready: entry.commit_ready === true,
+            reason: entry.reason ?? null,
+            raw_evidence_pointer_id: entry.raw_evidence_pointer_id,
         });
     }
     return map;
@@ -349,39 +376,44 @@ function failedOutcome(file, reason, uploadedChunks = 0) {
         uploaded_chunk_count: uploadedChunks,
     };
 }
-function pointerWithCommitResponse(pointer, body) {
-    const parsed = RawEvidenceUploadCommitResponseSchema.safeParse(body);
-    if (!parsed.success)
-        return pointer;
-    return pointerWithUploadedMetadata(pointer, {
-        content_hash_sha256: parsed.data.content_hash_sha256,
-        byte_size: parsed.data.byte_size,
-        redaction: parsed.data.redaction,
-    });
+function safeFailureDetail(body) {
+    if (!body || typeof body !== "object")
+        return null;
+    const reason = body.reason;
+    return typeof reason === "string" && /^[a-z0-9_:-]{1,80}$/i.test(reason)
+        ? reason
+        : null;
 }
 function pointerWithLegacyUploadResponse(pointer, body) {
-    if (!body || typeof body !== "object")
-        return pointer;
-    const uploaded = body.uploaded;
-    if (!Array.isArray(uploaded))
-        return pointer;
-    const entry = uploaded.find((candidate) => {
-        if (!candidate || typeof candidate !== "object")
-            return false;
-        return (candidate
-            .raw_evidence_pointer_id === pointer.raw_evidence_pointer_id);
-    });
-    if (!entry || typeof entry !== "object")
+    const entry = body.uploaded.find((candidate) => candidate.raw_evidence_pointer_id === pointer.raw_evidence_pointer_id);
+    if (!entry)
         return pointer;
-    const record = entry;
     return pointerWithUploadedMetadata(pointer, {
-        content_hash_sha256: typeof record["content_hash_sha256"] === "string"
-            ? record["content_hash_sha256"]
-            : undefined,
-        byte_size: typeof record["byte_size"] === "number" ? record["byte_size"] : undefined,
-        redaction: record["redaction"],
+        content_hash_sha256: entry.content_hash_sha256,
+        byte_size: entry.byte_size,
+        redaction: entry.redaction,
     });
 }
+function chunkCommitReceiptMatchesPointer(pointer, receipt) {
+    return (receipt.object_key === pointer.object_key &&
+        receipt.content_hash_sha256 === pointer.content_hash_sha256 &&
+        receipt.byte_size === pointer.byte_size &&
+        receipt.redaction === undefined);
+}
+function legacyUploadReceiptMatchesPointer(pointer, receipt) {
+    if (receipt.object_key !== pointer.object_key)
+        return false;
+    if (receipt.redaction) {
+        return (receipt.redaction.original_content_hash_sha256 ===
+            pointer.content_hash_sha256 &&
+            receipt.redaction.original_byte_size === pointer.byte_size &&
+            receipt.redaction.sanitized_content_hash_sha256 ===
+                receipt.content_hash_sha256 &&
+            receipt.redaction.sanitized_byte_size === receipt.byte_size);
+    }
+    return (receipt.content_hash_sha256 === pointer.content_hash_sha256 &&
+        receipt.byte_size === pointer.byte_size);
+}
 function pointerWithUploadedMetadata(pointer, metadata) {
     const redaction = RawEvidenceRedactionMetadataSchema.safeParse(metadata.redaction);
     return {