@bli-cockpit/telemetry-core 0.1.11 → 0.1.13

package/dist/evidence-upload.d.ts

@@ -13,6 +13,48 @@ export declare const RAW_EVIDENCE_UPLOAD_MAX_CHUNK_COUNT = 192;
 export declare const RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES: number;
 export declare const RAW_EVIDENCE_UPLOAD_MAX_OBJECTS_PER_BEGIN = 25;
 export declare const CODEX_SESSION_REPORT_MAX_SESSIONS = 200;
+/**
+ * Receipt returned by the pre-ledger single-shot upload route. Older
+ * dashboards still use this path, so the collector must prove that a 2xx
+ * response names the exact durable object it requested.
+ */
+export declare const RawEvidenceLegacyUploadResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    bucket: z.ZodString;
+    uploaded: z.ZodArray<z.ZodObject<{
+        raw_evidence_pointer_id: z.ZodString;
+        object_key: z.ZodString;
+        content_hash_sha256: z.ZodString;
+        byte_size: z.ZodNumber;
+        redaction: z.ZodOptional<z.ZodObject<{
+            schema_version: z.ZodLiteral<"raw-evidence-redaction.v1">;
+            status: z.ZodLiteral<"sanitized">;
+            mode: z.ZodLiteral<"deterministic_text_replacement">;
+            applied_by: z.ZodArray<z.ZodEnum<{
+                local_collector: "local_collector";
+                server_commit: "server_commit";
+                legacy_upload: "legacy_upload";
+            }>>;
+            rule_counts: z.ZodArray<z.ZodObject<{
+                rule_id: z.ZodString;
+                match_count: z.ZodNumber;
+                redacted_char_count: z.ZodNumber;
+            }, z.core.$strict>>;
+            secret_like_match_count: z.ZodNumber;
+            redacted_fields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            redacted_ranges: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                start: z.ZodNumber;
+                end: z.ZodNumber;
+                rule_id: z.ZodString;
+            }, z.core.$strict>>>;
+            original_content_hash_sha256: z.ZodOptional<z.ZodString>;
+            sanitized_content_hash_sha256: z.ZodOptional<z.ZodString>;
+            original_byte_size: z.ZodOptional<z.ZodNumber>;
+            sanitized_byte_size: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RawEvidenceLegacyUploadResponse = z.infer<typeof RawEvidenceLegacyUploadResponseSchema>;
 export declare const RawEvidenceUploadBeginObjectSchema: z.ZodObject<{
     pointer: z.ZodObject<{
         raw_evidence_pointer_id: z.ZodString;
@@ -192,6 +234,7 @@ export declare const RawEvidenceUploadBeginResponseObjectSchema: z.ZodObject<{
     }>;
     upload_id: z.ZodOptional<z.ZodString>;
     received_chunk_indexes: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    commit_ready: z.ZodOptional<z.ZodBoolean>;
     reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type RawEvidenceUploadBeginResponseObject = z.infer<typeof RawEvidenceUploadBeginResponseObjectSchema>;
@@ -208,6 +251,7 @@ export declare const RawEvidenceUploadBeginResponseSchema: z.ZodObject<{
         }>;
         upload_id: z.ZodOptional<z.ZodString>;
         received_chunk_indexes: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        commit_ready: z.ZodOptional<z.ZodBoolean>;
         reason: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
 }, z.core.$strict>;

package/dist/evidence-upload.js

@@ -11,16 +11,19 @@ import { RawEvidenceRedactionMetadataSchema } from "./secret-guards.js";
  * re-sending bytes, and identical content is acknowledged without re-upload.
  */
 export const RAW_EVIDENCE_UPLOAD_MAX_CHUNK_BYTES = 3 * 1024 * 1024;
-export const RAW_EVIDENCE_UPLOAD_DEFAULT_CHUNK_BYTES = 2 * 1024 * 1024;
+// The normal collector does not override this value. Keep the default large
+// enough that the advertised file cap fits within the maximum chunk count,
+// while the base64 JSON request remains below Vercel's 4.5 MB body limit.
+export const RAW_EVIDENCE_UPLOAD_DEFAULT_CHUNK_BYTES = RAW_EVIDENCE_UPLOAD_MAX_CHUNK_BYTES;
 // Chunk COUNT is the safe axis for growing the file cap: chunk SIZE is pinned
 // by Vercel's ~4.5MB request-body limit (see header comment). 192 chunks
-// * 3 MiB gives a 576 MiB protocol ceiling above the 512 MiB file cap.
+// * 3 MiB gives a 576 MiB protocol ceiling above the current file cap.
 export const RAW_EVIDENCE_UPLOAD_MAX_CHUNK_COUNT = 192;
-// Final-object cap. 512 MiB captures everything the fleet has ever produced
-// with ~4x headroom over the largest observed session (118 MiB). Watch point:
-// the commit route assembles and redaction-scans the whole object in memory,
-// so objects near this cap are the thing to profile before raising it again.
-export const RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES = 512 * 1024 * 1024;
+// Final-object cap. The commit route still assembles and redaction-scans text
+// in memory, so keep this below V8's string ceiling with practical headroom for
+// buffers and redaction copies. 256 MiB covers the largest observed fleet
+// session (118 MiB) with >2x headroom. Raising it requires a streaming commit.
+export const RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES = 256 * 1024 * 1024;
 export const RAW_EVIDENCE_UPLOAD_MAX_OBJECTS_PER_BEGIN = 25;
 export const CODEX_SESSION_REPORT_MAX_SESSIONS = 200;
 const SafeLabelSchema = z
@@ -35,6 +38,26 @@ const BasenameSchema = z
     .min(1)
     .max(160)
     .regex(/^[^/\\]+$/);
+/**
+ * Receipt returned by the pre-ledger single-shot upload route. Older
+ * dashboards still use this path, so the collector must prove that a 2xx
+ * response names the exact durable object it requested.
+ */
+export const RawEvidenceLegacyUploadResponseSchema = z
+    .object({
+    ok: z.literal(true),
+    bucket: NonEmptyStringSchema,
+    uploaded: z.array(z
+        .object({
+        raw_evidence_pointer_id: NonEmptyStringSchema,
+        object_key: NonEmptyStringSchema,
+        content_hash_sha256: Sha256Schema,
+        byte_size: z.number().int().nonnegative(),
+        redaction: RawEvidenceRedactionMetadataSchema.optional(),
+    })
+        .strict()),
+})
+    .strict();
 export const RawEvidenceUploadBeginObjectSchema = z
     .object({
     pointer: RawEvidencePointerSchema,
@@ -74,6 +97,9 @@ export const RawEvidenceUploadBeginResponseObjectSchema = z
     disposition: RawEvidenceUploadDispositionSchema,
     upload_id: NonEmptyStringSchema.optional(),
     received_chunk_indexes: z.array(z.number().int().nonnegative()).default([]),
+    // A completed staged plan may use a chunk layout from an older collector.
+    // The client must commit it directly instead of mixing in its current plan.
+    commit_ready: z.boolean().optional(),
     reason: SafeLabelSchema.optional(),
 })
     .strict();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/telemetry-core",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",