@bli-cockpit/telemetry-core 0.1.43 → 0.1.44

package/dist/evidence-storage-encoding.d.ts

@@ -0,0 +1,8 @@
+/** In-object manifest. Legacy objects without this exact prefix remain raw. */
+export declare const EVIDENCE_ENCODING_MANIFEST: Buffer<ArrayBuffer>;
+export declare const MAX_DECODED_EVIDENCE_BYTES: number;
+export declare function encodeEvidenceBytes(bytes: Uint8Array): Buffer;
+export declare function decodeEvidenceBytes(bytes: Uint8Array): Buffer;
+export declare function encodeEvidenceBody(body: Buffer | ReadableStream<Uint8Array>): Buffer | ReadableStream<Uint8Array>;
+/** Lazy opening keeps read failures inside the caller's normal stream cleanup. */
+export declare function decodeEvidenceStream(body: ReadableStream<Uint8Array>): ReadableStream<Uint8Array>;

package/dist/evidence-storage-encoding.js

@@ -0,0 +1,97 @@
+import { gzipSync, gunzipSync } from "node:zlib";
+/** In-object manifest. Legacy objects without this exact prefix remain raw. */
+export const EVIDENCE_ENCODING_MANIFEST = Buffer.from('TOWER-EVIDENCE\n{"version":1,"encoding":"gzip"}\n');
+export const MAX_DECODED_EVIDENCE_BYTES = 512 * 1024 * 1024;
+export function encodeEvidenceBytes(bytes) {
+    return Buffer.concat([EVIDENCE_ENCODING_MANIFEST, gzipSync(bytes)]);
+}
+export function decodeEvidenceBytes(bytes) {
+    const buffer = Buffer.from(bytes);
+    return buffer.subarray(0, EVIDENCE_ENCODING_MANIFEST.length).equals(EVIDENCE_ENCODING_MANIFEST)
+        ? gunzipSync(buffer.subarray(EVIDENCE_ENCODING_MANIFEST.length), { maxOutputLength: MAX_DECODED_EVIDENCE_BYTES })
+        : buffer;
+}
+export function encodeEvidenceBody(body) {
+    if (Buffer.isBuffer(body))
+        return encodeEvidenceBytes(body);
+    const reader = body.pipeThrough(new CompressionStream("gzip")).getReader();
+    let prefixSent = false;
+    return new ReadableStream({
+        async pull(controller) {
+            if (!prefixSent) {
+                prefixSent = true;
+                controller.enqueue(EVIDENCE_ENCODING_MANIFEST);
+                return;
+            }
+            const next = await reader.read();
+            if (next.done)
+                controller.close();
+            else
+                controller.enqueue(next.value);
+        },
+        cancel(reason) { return reader.cancel(reason); },
+    });
+}
+/** Look ahead only as far as the manifest, then decode with bounded residency. */
+async function openDecodedStream(reader) {
+    let head = Buffer.alloc(0);
+    while (head.length < EVIDENCE_ENCODING_MANIFEST.length) {
+        const next = await reader.read();
+        if (next.done)
+            break;
+        head = Buffer.concat([head, next.value]);
+        const prefixLength = Math.min(head.length, EVIDENCE_ENCODING_MANIFEST.length);
+        if (!head.subarray(0, prefixLength).equals(EVIDENCE_ENCODING_MANIFEST.subarray(0, prefixLength)))
+            break;
+    }
+    const encoded = head.subarray(0, EVIDENCE_ENCODING_MANIFEST.length).equals(EVIDENCE_ENCODING_MANIFEST);
+    let first = encoded ? head.subarray(EVIDENCE_ENCODING_MANIFEST.length) : head;
+    const remainder = new ReadableStream({
+        async pull(controller) {
+            if (first !== null) {
+                const bytes = first;
+                first = null;
+                controller.enqueue(bytes);
+                return;
+            }
+            const next = await reader.read();
+            if (next.done)
+                controller.close();
+            else
+                controller.enqueue(next.value);
+        },
+        cancel(reason) { return reader.cancel(reason); },
+    });
+    if (!encoded)
+        return remainder;
+    let decodedBytes = 0;
+    return remainder.pipeThrough(new DecompressionStream("gzip")).pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            decodedBytes += chunk.byteLength;
+            if (decodedBytes > MAX_DECODED_EVIDENCE_BYTES)
+                throw new Error("evidence_decoded_size_exceeded");
+            controller.enqueue(chunk);
+        },
+    }));
+}
+/** Lazy opening keeps read failures inside the caller's normal stream cleanup. */
+export function decodeEvidenceStream(body) {
+    const sourceReader = body.getReader();
+    let reader;
+    return new ReadableStream({
+        async pull(controller) {
+            reader ??= (await openDecodedStream(sourceReader)).getReader();
+            const next = await reader.read();
+            if (next.done)
+                controller.close();
+            else
+                controller.enqueue(next.value);
+        },
+        async cancel(reason) {
+            if (reader)
+                await reader.cancel(reason);
+            else
+                await sourceReader.cancel(reason);
+        },
+    });
+}

package/dist/evidence-upload.d.ts

@@ -269,7 +269,11 @@ export declare const RawEvidenceUploadBeginResponseSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type RawEvidenceUploadBeginResponse = z.infer<typeof RawEvidenceUploadBeginResponseSchema>;
 export declare const RawEvidenceUploadChunkRequestSchema: z.ZodObject<{
-    schema_version: z.ZodLiteral<"ambient-raw-evidence-upload-chunk.v1">;
+    schema_version: z.ZodEnum<{
+        "ambient-raw-evidence-upload-chunk.v1": "ambient-raw-evidence-upload-chunk.v1";
+        "ambient-raw-evidence-upload-chunk.v2": "ambient-raw-evidence-upload-chunk.v2";
+    }>;
+    encoding: z.ZodOptional<z.ZodLiteral<"gzip">>;
     generated_at: z.ZodString;
     provenance: z.ZodObject<{
         capture_source: z.ZodEnum<{

package/dist/evidence-upload.js

@@ -122,7 +122,8 @@ export const RawEvidenceUploadBeginResponseSchema = z
     .strict();
 export const RawEvidenceUploadChunkRequestSchema = z
     .object({
-    schema_version: z.literal("ambient-raw-evidence-upload-chunk.v1"),
+    schema_version: z.enum(["ambient-raw-evidence-upload-chunk.v1", "ambient-raw-evidence-upload-chunk.v2"]),
+    encoding: z.literal("gzip").optional(),
     generated_at: IsoDateTimeSchema,
     provenance: CaptureProvenanceSchema,
     upload_id: NonEmptyStringSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/telemetry-core",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -18,6 +18,10 @@
     "./memory-experience": {
       "types": "./dist/memory-experience.d.ts",
       "import": "./dist/memory-experience.js"
+    },
+    "./evidence-storage-encoding": {
+      "types": "./dist/evidence-storage-encoding.d.ts",
+      "import": "./dist/evidence-storage-encoding.js"
     }
   },
   "publishConfig": {