@vltpkg/registry-client 0.0.0-8 → 1.0.0-rc.1

package/README.md

@@ -52,7 +52,7 @@ If the response is `content-type: application/octet-stream` and starts
 with the gzip header, then we return the raw body as we received it,
 but as a best-effort background job, unzip it and update the cache
 entry to be an unzipped response body. This is done in the
-`@vltpkg/cache-unzip` worker.
+`@vltpkg/cache-unzip` child process.
 
 So,
 

package/dist/esm/cache-entry.d.ts

@@ -1,10 +1,23 @@
-import type { ErrorCauseObject } from '@vltpkg/error-cause';
+import type { ErrorCauseOptions } from '@vltpkg/error-cause';
 import type { Integrity, JSONField } from '@vltpkg/types';
 import ccp from 'cache-control-parser';
 import type { InspectOptions } from 'node:util';
 export type JSONObj = Record<string, JSONField>;
 declare const kCustomInspect: unique symbol;
 export type CacheEntryOptions = {
+    /**
+     * An optional body to use.
+     *
+     * This is used when decoding a cache entry from a buffer, and the body
+     * is already in a ArrayBuffer we can use. When this option is
+     * provided the `addBody` method should not be used.
+     */
+    body?: Uint8Array;
+    /**
+     * An optional content length of the body to use, if undefined the
+     * content-length header will be used.
+     */
+    contentLength?: number;
     /**
      * The expected integrity value for this response body
      */
@@ -37,7 +50,10 @@ export type CacheEntryOptions = {
 };
 export declare class CacheEntry {
     #private;
-    constructor(statusCode: number, headers: Buffer[], { integrity, trustIntegrity, 'stale-while-revalidate-factor': staleWhileRevalidateFactor, }?: CacheEntryOptions);
+    constructor(statusCode: number, headers: Uint8Array[], { body, integrity, trustIntegrity, 'stale-while-revalidate-factor': staleWhileRevalidateFactor, contentLength, }?: CacheEntryOptions);
+    toJSON(): {
+        [k: string]: string | number | boolean | [string, string][] | Date | ccp.CacheControl | undefined;
+    };
     [kCustomInspect](depth: number, options: InspectOptions): string;
     get date(): Date | undefined;
     get maxAge(): number;
@@ -45,9 +61,16 @@ export declare class CacheEntry {
     get staleWhileRevalidate(): boolean;
     get contentType(): string;
     get valid(): boolean;
-    addBody(b: Buffer): void;
+    /**
+     * Add contents to the entry body.
+     */
+    addBody(b: Uint8Array): void;
     get statusCode(): number;
-    get headers(): Buffer<ArrayBufferLike>[];
+    get headers(): Uint8Array[];
+    /**
+     * Returns the body as a single Uint8Array, concatenating parts if needed.
+     */
+    get _body(): Uint8Array;
     /**
      * Check that the sri integrity string that was provided to the ctor
      * matches the body that we actually received. This should only be called
@@ -61,7 +84,7 @@ export declare class CacheEntry {
      *
      * Returns true if anything was actually verified.
      */
-    checkIntegrity(context?: ErrorCauseObject): this is CacheEntry & {
+    checkIntegrity(context?: ErrorCauseOptions): this is CacheEntry & {
         integrity: Integrity;
     };
     get integrityActual(): Integrity;
@@ -71,16 +94,20 @@ export declare class CacheEntry {
     /**
      * Give it a key, and it'll return the buffer of that header value
      */
-    getHeader(h: string): Buffer<ArrayBufferLike> | undefined;
+    getHeader(h: string): Uint8Array | undefined;
+    /**
+     * Give it a key, and it'll return the decoded string of that header value
+     */
+    getHeaderString(h: string): string | undefined;
     /**
      * Set a header to a specific value
      */
-    setHeader(h: string, value: Buffer | string): void;
+    setHeader(h: string, value: Uint8Array | string): void;
     /**
      * Return the body of the entry as a Buffer
      */
     buffer(): Buffer;
-    get body(): Buffer | Record<string, any>;
+    get body(): Uint8Array | Record<string, any>;
     get isJSON(): boolean;
     get isGzip(): boolean;
     /**
@@ -103,8 +130,8 @@ export declare class CacheEntry {
      * and this static method will decode it into a CacheEntry representing
      * the cached response.
      */
-    static decode(buffer: Buffer): CacheEntry;
-    static isGzipEntry(buffer: Buffer): boolean;
+    static decode(buffer: Uint8Array): CacheEntry;
+    static isGzipEntry(buffer: Uint8Array): boolean;
     /**
      * Encode the entry as a single Buffer for writing to the cache
      */

package/dist/esm/cache-entry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache-entry.d.ts","sourceRoot":"","sources":["../../src/cache-entry.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAE3D,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AACzD,OAAO,GAAG,MAAM,sBAAsB,CAAA;AAEtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAK/C,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;AAyB/C,QAAA,MAAM,cAAc,eAA2C,CAAA;AAE/D,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;OAEG;IACH,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;IAExB;;;;;;;;;;;;;;OAcG;IACH,+BAA+B,CAAC,EAAE,MAAM,CAAA;CACzC,CAAA;AAED,qBAAa,UAAU;;gBAYnB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EAAE,EACjB,EACE,SAAS,EACT,cAAsB,EACtB,+BAA+B,EAC7B,0BAA+B,GAClC,GAAE,iBAAsB;IAmB3B,CAAC,cAAc,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM;IA2ChE,IAAI,IAAI,IAAI,IAAI,GAAG,SAAS,CAK3B;IAGD,IAAI,MAAM,IAAI,MAAM,CAQnB;IAGD,IAAI,YAAY,IAAI,GAAG,CAAC,YAAY,CAKnC;IAGD,IAAI,oBAAoB,IAAI,OAAO,CAWlC;IAGD,IAAI,WAAW,WAKd;IAOD,IAAI,KAAK,IAAI,OAAO,CAmBnB;IAED,OAAO,CAAC,CAAC,EAAE,MAAM;IAKjB,IAAI,UAAU,WAEb;IACD,IAAI,OAAO,8BAEV;IAED;;;;;;;;;;;;OAYG;IACH,cAAc,CACZ,OAAO,GAAE,gBAAqB,GAC7B,IAAI,IAAI,UAAU,GAAG;QAAE,SAAS,EAAE,SAAS,CAAA;KAAE;IAchD,IAAI,eAAe,IAAI,SAAS,CAO/B;IAED,IAAI,eAAe,CAAC,CAAC,EAAE,SAAS,EAG/B;IAED,IAAI,SAAS,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,EAKrC;IACD,IAAI,SAAS,IANI,SAAS,GAAG,SAAS,CAQrC;IAED;;OAEG;IACH,SAAS,CAAC,CAAC,EAAE,MAAM;IAInB;;OAEG;IACH,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;IAI3C;;OAEG;IACH,MAAM,IAAI,MAAM;IAWhB,IAAI,IAAI,IAAI,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAEvC;IAGD,IAAI,MAAM,IAAI,OAAO,CAYpB;IAGD,IAAI,MAAM,IAAI,OAAO,CAcpB;IAED;;;;OAIG;IACH,KAAK;IAmBL;;;OAGG;IACH,IAAI;IAKJ;;OAEG;IACH,IAAI,IAAI,OAAO;IAOf;;;;OAIG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU;IAsDzC,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAO3C;;OAEG;IAGH,MAAM,IAAI,MAAM;CAmCjB"}
+{"version":3,"file":"cache-entry.d.ts","sourceRoot":"","sources":["../../src/cache-entry.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAE5D,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AACzD,OAAO,GAAG,MAAM,sBAAsB,CAAA;AAEtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAS/C,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;AAyB/C,QAAA,MAAM,cAAc,eAA2C,CAAA;AAE/D,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,UAAU,CAAA;IAEjB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IAEtB;;OAEG;IACH,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;IAExB;;;;;;;;;;;;;;OAcG;IACH,+BAA+B,CAAC,EAAE,MAAM,CAAA;CACzC,CAAA;AAED,qBAAa,UAAU;;gBAsBnB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,UAAU,EAAE,EACrB,EACE,IAAI,EACJ,SAAS,EACT,cAAsB,EACtB,+BAA+B,EAC7B,0BAA+B,EACjC,aAAa,GACd,GAAE,iBAAsB;IAwC3B,MAAM;;;IAwCN,CAAC,cAAc,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM;IAShE,IAAI,IAAI,IAAI,IAAI,GAAG,SAAS,CAK3B;IAGD,IAAI,MAAM,IAAI,MAAM,CAQnB;IAGD,IAAI,YAAY,IAAI,GAAG,CAAC,YAAY,CAKnC;IAGD,IAAI,oBAAoB,IAAI,OAAO,CAWlC;IAGD,IAAI,WAAW,WAId;IAOD,IAAI,KAAK,IAAI,OAAO,CAmBnB;IAED;;OAEG;IACH,OAAO,CAAC,CAAC,EAAE,UAAU;IAcrB,IAAI,UAAU,WAEb;IACD,IAAI,OAAO,IAAI,UAAU,EAAE,CAE1B;IAED;;OAEG;IACH,IAAI,KAAK,IAAI,UAAU,CAYtB;IAED;;;;;;;;;;;;OAYG;IACH,cAAc,CACZ,OAAO,GAAE,iBAAsB,GAC9B,IAAI,IAAI,UAAU,GAAG;QAAE,SAAS,EAAE,SAAS,CAAA;KAAE;IAchD,IAAI,eAAe,IAAI,SAAS,CAO/B;IAED,IAAI,eAAe,CAAC,CAAC,EAAE,SAAS,EAG/B;IAED,IAAI,SAAS,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,EAKrC;IACD,IAAI,SAAS,IANI,SAAS,GAAG,SAAS,CAQrC;IAED;;OAEG;IACH,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAI5C;;OAEG;IACH,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAO9C;;OAEG;IACH,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM;IAI/C;;OAEG;IACH,MAAM,IAAI,MAAM;IAUhB,IAAI,IAAI,IAAI,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAE3C;IAGD,IAAI,MAAM,IAAI,OAAO,CAYpB;IAGD,IAAI,MAAM,IAAI,OAAO,CAcpB;IAED;;;;OAIG;IACH,KAAK;IAqBL;;;OAGG;IACH,IAAI;IAKJ;;OAEG;IACH,IAAI,IAAI,OAAO;IAQf;;;;OAIG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU;IAuD7C,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO;IAO/C;;OAEG;IACH,MAAM,IAAI,MAAM;CAkDjB"}

package/dist/esm/cache-entry.js

@@ -24,6 +24,7 @@ import { createHash } from 'node:crypto';
 import { inspect } from 'node:util';
 import { gunzipSync } from 'node:zlib';
 import { getRawHeader, setRawHeader } from "./raw-header.js";
+import { getDecodedValue, getEncondedValue, } from "./string-encoding.js";
 const readSize = (buf, offset) => {
     const a = buf[offset];
     const b = buf[offset + 1];
@@ -45,56 +46,87 @@ const readSize = (buf, offset) => {
 const kCustomInspect = Symbol.for('nodejs.util.inspect.custom');
 export class CacheEntry {
     #statusCode;
+    /** The raw headers as an array of buffers */
     #headers;
-    #body = [];
+    /** The body buffer, used if the content length is known. */
+    #body;
+    /**
+     * If the content length is unknown we save the body in multiple parts
+     * in order to only concatenate once at the end and save extra memory copies.
+     */
+    #bodyParts = [];
+    /** Used to track the length of the body while reading chunks */
     #bodyLength = 0;
+    /** The total length of the body, if known */
+    #contentLength;
     #integrity;
     #integrityActual;
     #json;
     #trustIntegrity;
     #staleWhileRevalidateFactor;
-    constructor(statusCode, headers, { integrity, trustIntegrity = false, 'stale-while-revalidate-factor': staleWhileRevalidateFactor = 60, } = {}) {
+    constructor(statusCode, headers, { body, integrity, trustIntegrity = false, 'stale-while-revalidate-factor': staleWhileRevalidateFactor = 60, contentLength, } = {}) {
         this.#headers = headers;
         this.#statusCode = statusCode;
         this.#trustIntegrity = trustIntegrity;
         this.#staleWhileRevalidateFactor = staleWhileRevalidateFactor;
         if (integrity)
             this.integrity = integrity;
+        // if content-legnth is known then we'll only allocate that much memory
+        // and we'll avoid copying memory around when adding new chunks.
+        if (contentLength != null && typeof contentLength === 'number') {
+            this.#contentLength = contentLength;
+        }
+        // if a body is provided then use that, in this case the `addBody`
+        // method should no longer be used.
+        if (body) {
+            const buffer = new ArrayBuffer(body.byteLength);
+            this.#body = new Uint8Array(buffer, 0, body.byteLength);
+            this.#body.set(body, 0);
+            this.#bodyLength = body.byteLength;
+            /* c8 ignore start */
+        }
+        else if (this.#contentLength) {
+            const buffer = new ArrayBuffer(this.#contentLength);
+            this.#body = new Uint8Array(buffer, 0, this.#contentLength);
+            this.#bodyLength = 0;
+        }
+        /* c8 ignore stop */
     }
     get #headersAsObject() {
         const ret = [];
         for (let i = 0; i < this.#headers.length - 1; i += 2) {
-            const key = String(this.#headers[i]);
-            const val = String(this.#headers[i + 1]);
+            const key = getDecodedValue(this.#headers[i]);
+            const val = getDecodedValue(this.#headers[i + 1]);
             ret.push([key, val]);
         }
         return ret;
     }
-    [kCustomInspect](depth, options) {
-        const raw = this.text();
-        const isBinary = raw.includes('\x00');
-        const show = isBinary ? '[binary data]' : raw.substring(0, 512);
-        const text = !isBinary && show.length < raw.length ? raw + '…' : show;
-        const { valid, staleWhileRevalidate, cacheControl, date, contentType, } = this;
+    toJSON() {
+        const { statusCode, valid, staleWhileRevalidate, cacheControl, date, contentType, integrity, maxAge, isGzip, isJSON, } = this;
         /* c8 ignore start */
         const age = date ?
             Math.floor((Date.now() - date.getTime()) / 1000)
             : undefined;
+        const expires = date ? new Date(date.getTime() + this.maxAge * 1000) : undefined;
         /* c8 ignore end */
-        const str = inspect({
-            statusCode: this.statusCode,
+        return Object.fromEntries(Object.entries({
+            statusCode,
             headers: this.#headersAsObject,
-            // we know that gzip and tar data will always include at least
-            // one \x00, and json never will, so this is fine for our purpose,
-            // to avoid dumping bells and whatnot to the terminal.
-            text,
             contentType,
+            integrity,
             date,
+            expires,
             cacheControl,
             valid,
             staleWhileRevalidate,
             age,
-        }, {
+            maxAge,
+            isGzip,
+            isJSON,
+        }).filter(([_, v]) => v !== undefined));
+    }
+    [kCustomInspect](depth, options) {
+        const str = inspect(this.toJSON(), {
             depth,
             ...options,
         });
@@ -104,7 +136,7 @@ export class CacheEntry {
     get date() {
         if (this.#date)
             return this.#date;
-        const dh = this.getHeader('date')?.toString();
+        const dh = this.getHeaderString('date');
         if (dh)
             this.#date = new Date(dh);
         return this.#date;
@@ -124,7 +156,7 @@ export class CacheEntry {
     get cacheControl() {
         if (this.#cacheControl)
             return this.#cacheControl;
-        const cc = this.getHeader('cache-control')?.toString();
+        const cc = this.getHeaderString('cache-control');
         this.#cacheControl = cc ? ccp.parse(cc) : {};
         return this.#cacheControl;
     }
@@ -144,8 +176,7 @@ export class CacheEntry {
     get contentType() {
         if (this.#contentType !== undefined)
             return this.#contentType;
-        this.#contentType =
-            this.getHeader('content-type')?.toString() ?? '';
+        this.#contentType = this.getHeaderString('content-type') ?? '';
         return this.#contentType;
     }
     /**
@@ -174,9 +205,22 @@ export class CacheEntry {
             this.date.getTime() + this.maxAge * 1000 > Date.now();
         return this.#valid;
     }
+    /**
+     * Add contents to the entry body.
+     */
     addBody(b) {
-        this.#body.push(b);
-        this.#bodyLength += b.byteLength;
+        // when the content length is uknown we store each chunk in an array that
+        // later on is concatenate into a single buffer, otherwise we just append
+        // the new chunk of bytes to the already allocated buffer keeping track
+        // of the current offset in the `this.#bodyLength` property.
+        if (!this.#body) {
+            this.#bodyParts.push(b);
+            this.#bodyLength += b.byteLength;
+        }
+        else {
+            this.#body.set(b, this.#bodyLength);
+            this.#bodyLength += b.byteLength;
+        }
     }
     get statusCode() {
         return this.#statusCode;
@@ -184,6 +228,23 @@ export class CacheEntry {
     get headers() {
         return this.#headers;
     }
+    /**
+     * Returns the body as a single Uint8Array, concatenating parts if needed.
+     */
+    get _body() {
+        // if the body is known we'll just use that
+        if (this.#body)
+            return this.#body;
+        // otherwise we concatenate the body parts into a single buffer
+        const buffer = new ArrayBuffer(this.#bodyLength);
+        const b = new Uint8Array(buffer, 0, this.#bodyLength);
+        let off = 0;
+        for (const part of this.#bodyParts) {
+            b.set(part, off);
+            off += part.byteLength;
+        }
+        return b;
+    }
     /**
      * Check that the sri integrity string that was provided to the ctor
      * matches the body that we actually received. This should only be called
@@ -215,8 +276,7 @@ export class CacheEntry {
         if (this.#integrityActual)
             return this.#integrityActual;
         const hash = createHash('sha512');
-        for (const buf of this.#body)
-            hash.update(buf);
+        hash.update(this._body);
         const i = `sha512-${hash.digest('base64')}`;
         this.integrityActual = i;
         return i;
@@ -241,6 +301,15 @@ export class CacheEntry {
     getHeader(h) {
         return getRawHeader(this.#headers, h);
     }
+    /**
+     * Give it a key, and it'll return the decoded string of that header value
+     */
+    getHeaderString(h) {
+        const value = getRawHeader(this.#headers, h);
+        if (value) {
+            return getDecodedValue(value);
+        }
+    }
     /**
      * Set a header to a specific value
      */
@@ -251,14 +320,7 @@ export class CacheEntry {
      * Return the body of the entry as a Buffer
      */
     buffer() {
-        const b = this.#body[0];
-        if (!b)
-            return Buffer.allocUnsafe(0);
-        if (this.#body.length === 1)
-            return b;
-        const cat = Buffer.concat(this.#body, this.#bodyLength);
-        this.#body = [cat];
-        return cat;
+        return Buffer.from(this._body.buffer, this._body.byteOffset, this._body.byteLength);
     }
     // return the buffer if it's a tarball, or the parsed
     // JSON if it's not.
@@ -269,7 +331,7 @@ export class CacheEntry {
     get isJSON() {
         if (this.#isJSON !== undefined)
             return this.#isJSON;
-        const ct = this.getHeader('content-type')?.toString();
+        const ct = this.getHeaderString('content-type');
         // if it says it's json, assume json
         if (ct)
             return (this.#isJSON = /\bjson\b/.test(ct));
@@ -287,10 +349,10 @@ export class CacheEntry {
     get isGzip() {
         if (this.#isGzip !== undefined)
             return this.#isGzip;
-        const ce = this.getHeader('content-encoding')?.toString();
+        const ce = this.getHeaderString('content-encoding');
         if (ce && !/\bgzip\b/.test(ce))
             return (this.#isGzip = false);
-        const buf = this.buffer();
+        const buf = this._body;
         if (buf.length < 2)
             return false;
         this.#isGzip = buf[0] === 0x1f && buf[1] === 0x8b;
@@ -313,14 +375,16 @@ export class CacheEntry {
             // we know that if we know it's gzip, that the body has been
             // flattened to a single buffer, so save the extra call.
             /* c8 ignore start */
-            if (this.#body[0] == null)
+            if (this._body.length === 0)
                 throw error('Invalid buffer, cant unzip');
             /* c8 ignore stop */
-            const b = gunzipSync(this.#body[0]);
+            const b = gunzipSync(this._body);
             this.setHeader('content-encoding', 'identity');
-            this.#body = [b];
-            this.#bodyLength = b.byteLength;
-            this.setHeader('content-length', String(this.#bodyLength));
+            const u8 = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
+            this.#body = u8;
+            this.#bodyLength = u8.byteLength;
+            this.#contentLength = u8.byteLength;
+            this.setHeader('content-length', String(this.#contentLength));
             this.#isGzip = false;
             return true;
         }
@@ -332,7 +396,7 @@ export class CacheEntry {
      */
     text() {
         this.unzip();
-        return this.buffer().toString();
+        return getDecodedValue(this._body);
     }
     /**
      * Parse the entry body as JSON and return the result
@@ -340,7 +404,8 @@ export class CacheEntry {
     json() {
         if (this.#json !== undefined)
             return this.#json;
-        const obj = JSON.parse(this.text());
+        const text = this.text();
+        const obj = JSON.parse(text || '{}');
         this.#json = obj;
         return obj;
     }
@@ -357,9 +422,9 @@ export class CacheEntry {
         if (buffer.length < headSize) {
             return emptyCacheEntry;
         }
-        const statusCode = Number(buffer.subarray(4, 7).toString());
+        const statusCode = Number(getDecodedValue(buffer.subarray(4, 7)));
         const headersBuffer = buffer.subarray(7, headSize);
-        // walk through the headers array, building up the rawHeaders Buffer[]
+        // walk through the headers array, building up the rawHeaders
         const headers = [];
         let i = 0;
         let integrity = undefined;
@@ -367,20 +432,21 @@ export class CacheEntry {
             const size = readSize(headersBuffer, i);
             const val = headersBuffer.subarray(i + 4, i + size);
             // if the last one was the key integrity, then this one is the value
-            if (headers.length % 2 === 1 &&
-                String(headers[headers.length - 1]) === 'integrity') {
-                integrity = String(val);
+            if (headers.length % 2 === 1) {
+                const k = getDecodedValue(headers[headers.length - 1]).toLowerCase();
+                if (k === 'integrity')
+                    integrity = getDecodedValue(val);
             }
             headers.push(val);
             i += size;
         }
         const body = buffer.subarray(headSize);
         const c = new CacheEntry(statusCode, setRawHeader(headers, 'content-length', String(body.byteLength)), {
+            body,
             integrity,
             trustIntegrity: true,
+            contentLength: body.byteLength,
         });
-        c.#body = [body];
-        c.#bodyLength = body.byteLength;
         if (c.isJSON) {
             try {
                 c.json();
@@ -401,37 +467,52 @@ export class CacheEntry {
     /**
      * Encode the entry as a single Buffer for writing to the cache
      */
-    // TODO: should this maybe not concat, and just return Buffer[]?
-    // Then we can writev it to the cache file and save the memory copy
     encode() {
         if (this.isJSON)
             this.json();
-        const sb = Buffer.from(String(this.#statusCode));
-        const chunks = [sb];
-        let headLength = sb.byteLength + 4;
+        const statusStr = String(this.#statusCode);
+        const statusBytes = getEncondedValue(statusStr);
+        // compute headLength = 4 (length field itself) + statusBytes + Σ(4 + headerLen) for each header item
+        let headLength = 4 + statusBytes.byteLength;
+        for (const h of this.#headers)
+            headLength += 4 + h.byteLength;
+        // allocate and fill head length prefix (big-endian)
+        const headLenBytes = new Uint8Array(4);
+        headLenBytes[0] = (headLength >> 24) & 0xff;
+        headLenBytes[1] = (headLength >> 16) & 0xff;
+        headLenBytes[2] = (headLength >> 8) & 0xff;
+        headLenBytes[3] = headLength & 0xff;
+        // header chunks: [len, bytes] for each header item
+        const headerChunks = [];
         for (const h of this.#headers) {
-            const hlBuf = Buffer.allocUnsafe(4);
-            const hl = h.byteLength + 4;
-            headLength += hl;
-            hlBuf.set([
-                (hl >> 24) & 0xff,
-                (hl >> 16) & 0xff,
-                (hl >> 8) & 0xff,
-                hl & 0xff,
-            ], 0);
-            chunks.push(hlBuf, h);
+            const l = headLenBytes.byteLength + h.byteLength;
+            const lb = new Uint8Array(4);
+            lb[0] = (l >> 24) & 0xff;
+            lb[1] = (l >> 16) & 0xff;
+            lb[2] = (l >> 8) & 0xff;
+            lb[3] = l & 0xff;
+            headerChunks.push(lb, h);
+        }
+        // total size
+        const total = headLenBytes.byteLength +
+            statusBytes.byteLength +
+            headerChunks.reduce((n, b) => n + b.byteLength, 0) +
+            this._body.byteLength;
+        // returns the concatenate buffer with all the pieces
+        const outBuffer = new ArrayBuffer(total);
+        const out = Buffer.from(outBuffer, 0, total);
+        let off = 0;
+        out.set(headLenBytes, off);
+        off += headLenBytes.byteLength;
+        out.set(statusBytes, off);
+        off += statusBytes.byteLength;
+        for (const chunk of headerChunks) {
+            out.set(chunk, off);
+            off += chunk.byteLength;
         }
-        const hlBuf = Buffer.allocUnsafe(4);
-        hlBuf.set([
-            (headLength >> 24) & 0xff,
-            (headLength >> 16) & 0xff,
-            (headLength >> 8) & 0xff,
-            headLength & 0xff,
-        ], 0);
-        chunks.unshift(hlBuf);
-        chunks.push(...this.#body);
-        return Buffer.concat(chunks, headLength + this.#bodyLength);
+        out.set(this._body, off);
+        return out;
     }
 }
-const emptyCacheEntry = new CacheEntry(0, []);
+const emptyCacheEntry = new CacheEntry(0, [], { contentLength: 0 });
 //# sourceMappingURL=cache-entry.js.map