@juspay/neurolink 10.12.2 → 10.12.4

package/dist/cli/commands/proxy.d.ts

@@ -11,7 +11,7 @@
  */
 import type { CommandModule } from "yargs";
 import type { Hono } from "hono";
-import type { AccountAllowlist, LoadedProxyConfig, ModelRouterInterface, ProxyGuardArgs, ProxyNeurolinkRuntime, ProxyStartArgs, ProxyStartStrategy, ProxySupervisorState, ProxyStatusArgs, ProxyTelemetryArgs, ProxyReadinessState } from "../../lib/types/index.js";
+import type { AccountAllowlist, LoadedProxyConfig, ModelRouterInterface, ProxyGuardArgs, ProxyHealthProbe, ProxyNeurolinkRuntime, ProxyStartArgs, ProxyStartStrategy, ProxySupervisorState, ProxyStatusArgs, ProxyTelemetryArgs, ProxyReadinessState } from "../../lib/types/index.js";
 import { ProxyRuntimeConfigStore } from "../../lib/proxy/runtimeConfig.js";
 /**
  * Drop a supervisor `version` that is not a string.
@@ -58,6 +58,7 @@ export declare function isRollingHandoffCapable(state: ProxySupervisorState | nu
  *   confirm a mismatch" and falls through to the args-only result.
  */
 export declare function processLooksLikeProxySupervisor(pid: number, expectedStartTimeIso?: string): Promise<boolean>;
+export declare function probeProxyHealth(host: string, port: number, timeoutMs: number): Promise<ProxyHealthProbe>;
 export declare function mapClaudeErrorTypeToStatus(errorType?: string): number;
 export declare function createProxyStartApp(params: {
     neurolink: ProxyNeurolinkRuntime["neurolink"];

package/dist/cli/commands/proxy.js

@@ -41,6 +41,7 @@ import packageJson from "../../../package.json" with { type: "json" };
 const _require = createRequire(import.meta.url);
 const PROXY_VERSION = packageJson.version;
 const PROXY_INTERNAL_ACCOUNT_LABEL = "proxy/internal";
+const PROXY_INTERNAL_ACCOUNT_TYPE = "internal";
 const PROXY_TELEMETRY_SCRIPT_PATH = fileURLToPath(new URL("../../../scripts/observability/manage-local-openobserve.sh", import.meta.url));
 const PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS = 5_000;
 const LEGACY_STATUS_ACCOUNT_CACHE_TTL_MS = 5_000;
@@ -623,17 +624,51 @@ async function clearOpenCodeProxySettings(expectedBaseUrl) {
     fs.writeFileSync(OPENCODE_CONFIG_PATH, JSON.stringify(config, null, 2));
     return hadNeurolink;
 }
-async function isProxyHealthy(host, port, timeoutMs) {
+export async function probeProxyHealth(host, port, timeoutMs) {
+    const startedAt = Date.now();
     try {
         const response = await fetch(`http://${host}:${port}/health`, {
             signal: AbortSignal.timeout(timeoutMs),
         });
-        return response.ok;
+        return {
+            healthy: response.ok,
+            durationMs: Date.now() - startedAt,
+            failure: response.ok ? null : "http_status",
+            statusCode: response.status,
+            errorCode: null,
+        };
     }
-    catch {
-        return false;
+    catch (error) {
+        const candidate = error;
+        const cause = candidate?.cause;
+        const errorCode = typeof candidate?.code === "string"
+            ? candidate.code
+            : typeof cause?.code === "string"
+                ? cause.code
+                : typeof candidate?.name === "string"
+                    ? candidate.name
+                    : null;
+        const isTimeout = candidate?.name === "TimeoutError" || candidate?.name === "AbortError";
+        return {
+            healthy: false,
+            durationMs: Date.now() - startedAt,
+            failure: isTimeout ? "timeout" : "network",
+            statusCode: null,
+            errorCode,
+        };
     }
 }
+function formatProxyHealthProbe(probe) {
+    const details = [
+        `reason=${probe.failure ?? "none"}`,
+        `durationMs=${probe.durationMs}`,
+        probe.statusCode === null ? null : `status=${probe.statusCode}`,
+        probe.errorCode === null
+            ? null
+            : `errorCode=${sanitizeForLog(probe.errorCode)}`,
+    ].filter((detail) => detail !== null);
+    return details.join(" ");
+}
 async function getProxyRuntimeActivity(host, port, timeoutMs = 3_000) {
     try {
         const response = await fetch(`http://${host}:${port}/status`, {
@@ -1312,7 +1347,7 @@ export async function createProxyStartApp(params) {
     const recordRuntimeError = async (metadata, status, errorType, errorMessage, options) => {
         const clientMessage = options?.clientMessage ?? errorMessage;
         const clientErrorType = options?.clientErrorType ?? errorType;
-        recordFinalError(status, undefined, undefined, {
+        recordFinalError(status, PROXY_INTERNAL_ACCOUNT_LABEL, PROXY_INTERNAL_ACCOUNT_TYPE, {
             requestId: metadata.requestId,
             errorType,
             errorCode: options?.errorCode,
@@ -3730,19 +3765,23 @@ export const proxyGuardCommand = {
         const startedAt = Date.now();
         let parentStatus = getProcessStatus(parentPid);
         let consecutiveUnhealthy = 0;
+        let lastUnhealthyProbe = null;
         // Keep monitoring for as long as the parent can affect Claude settings.
         while (true) {
-            const healthy = await isProxyHealthy(host, port, 1_500);
+            const healthProbe = await probeProxyHealth(host, port, 1_500);
+            const healthy = healthProbe.healthy;
             if (healthy) {
                 if (updaterOnly && consecutiveUnhealthy >= failureThreshold) {
-                    logger.always(`[updater] proxy health recovered after ${consecutiveUnhealthy} failed checks`);
+                    logger.always(`[updater] proxy health recovered after ${consecutiveUnhealthy} failed checks; ${formatProxyHealthProbe(lastUnhealthyProbe ?? healthProbe)}`);
                 }
                 consecutiveUnhealthy = 0;
+                lastUnhealthyProbe = null;
             }
             else {
                 consecutiveUnhealthy += 1;
+                lastUnhealthyProbe = healthProbe;
                 if (updaterOnly && consecutiveUnhealthy === failureThreshold) {
-                    logger.always(`[updater] proxy health unavailable after ${consecutiveUnhealthy} checks; worker remains active`);
+                    logger.always(`[updater] proxy health unavailable after ${consecutiveUnhealthy} checks; worker remains active; ${formatProxyHealthProbe(healthProbe)}`);
                 }
             }
             if (parentStatus === "not_running" && !updateRestartInProgress) {

package/dist/lib/processors/archive/ArchiveProcessor.js

@@ -40,9 +40,6 @@ import { BaseFileProcessor } from "../base/BaseFileProcessor.js";
 import { SIZE_LIMITS_MB } from "../config/index.js";
 import { FileErrorCode } from "../errors/index.js";
 // =============================================================================
-// TYPES
-// =============================================================================
-// =============================================================================
 // SECURITY CONFIGURATION
 // =============================================================================
 /**
@@ -162,6 +159,60 @@ const SINGLE_STREAM_TOOLS = {
     xz: "xz",
     zst: "zstd",
 };
+/**
+ * Read one ZIP entry's bytes without trusting the size it declares.
+ *
+ * `entry.getData()` cannot be used for this. It sizes its output buffer from
+ * the central-directory `size` field, which the archive author chooses, and
+ * adm-zip only arms its own guard when that field is positive:
+ *
+ *   const option = version >= 15 && expectedLength > 0
+ *     ? { maxOutputLength: expectedLength } : {};
+ *
+ * So an entry declaring 0 disables the bound and the caller's `size > maxSize`
+ * check in one move — `0 > 5MB` is false, and the inflate then runs uncapped.
+ * The declared size is the attack, so nothing here may depend on it: the cap
+ * comes from our own limit and is handed to the decoder.
+ *
+ * CRC is verified on both paths rather than dropped, so bypassing `getData()`
+ * does not also quietly lose its corruption check — a STORED entry is copied
+ * out rather than decoded, but it can be damaged just the same. It detects
+ * damage, not malice — the CRC field is attacker-controlled too.
+ */
+function readZipEntryWithinLimit(entry, maxBytes, zlibModule) {
+    const compressed = entry.getCompressedData();
+    const matchesCrc = (data) => (zlibModule.crc32(data) >>> 0) === (entry.header.crc >>> 0);
+    // STORED: the bytes are already the payload, so its own length is the bound.
+    if (entry.header.method === ZIP_METHOD_STORED) {
+        if (compressed.length > maxBytes) {
+            return { status: "too-large" };
+        }
+        return matchesCrc(compressed)
+            ? { status: "ok", buffer: compressed }
+            : { status: "corrupt" };
+    }
+    if (entry.header.method !== ZIP_METHOD_DEFLATED) {
+        return { status: "unsupported-method" };
+    }
+    let inflated;
+    try {
+        inflated = zlibModule.inflateRawSync(compressed, {
+            maxOutputLength: maxBytes,
+        });
+    }
+    catch (error) {
+        if (isDecompressionBoundExceeded(error)) {
+            return { status: "too-large" };
+        }
+        return { status: "corrupt" };
+    }
+    return matchesCrc(inflated)
+        ? { status: "ok", buffer: inflated }
+        : { status: "corrupt" };
+}
+/** ZIP compression methods this reader handles (APPNOTE 4.4.5). */
+const ZIP_METHOD_STORED = 0;
+const ZIP_METHOD_DEFLATED = 8;
 /**
  * Whether a zlib rejection is the output bound firing rather than bad input.
  *
@@ -1552,12 +1603,29 @@ export class ArchiveProcessor extends BaseFileProcessor {
             if (targetEntry.isDirectory) {
                 return `"${entryPath}" is a directory, not a file.`;
             }
-            // Security: size check
+            // Security: size check.
+            //
+            // The declared size is a hint, not the bound — it is chosen by whoever
+            // built the archive, and an entry claiming 0 passes this comparison while
+            // switching off adm-zip's own cap (see readZipEntryWithinLimit). It is
+            // still worth checking, because an honestly-declared oversized entry is
+            // refused here without decompressing anything at all.
             const maxSize = 5 * 1024 * 1024; // 5 MB
             if (targetEntry.header.size > maxSize) {
                 return `Entry "${entryPath}" is too large (${this.formatHumanReadableSize(targetEntry.header.size)}). Maximum extraction size is 5 MB.`;
             }
-            const data = targetEntry.getData();
+            const zlibModule = await import("zlib");
+            const read = readZipEntryWithinLimit(targetEntry, maxSize, zlibModule);
+            if (read.status === "too-large") {
+                return `Entry "${entryPath}" is too large. Maximum extraction size is 5 MB.`;
+            }
+            if (read.status === "unsupported-method") {
+                return `Entry "${entryPath}" uses an unsupported compression method.`;
+            }
+            if (read.status === "corrupt") {
+                return `Entry "${entryPath}" could not be read — the archive entry is corrupt.`;
+            }
+            const data = read.buffer;
             // Check if it looks like text
             const sampleSize = Math.min(data.length, 512);
             let printable = 0;

package/dist/lib/processors/base/BaseFileProcessor.d.ts

@@ -181,6 +181,25 @@ export declare abstract class BaseFileProcessor<T extends ProcessedFileBase> {
      * @throws Error if download fails
      */
     protected downloadFile(url: string, authHeaders?: Record<string, string>, timeout?: number): Promise<Buffer>;
+    /**
+     * Read a response body, refusing it the moment it passes `maxBytes`.
+     *
+     * `response.arrayBuffer()` buffers whatever the server sends before anyone
+     * can object, so the size check further up only ever ran against a body that
+     * had already been paid for in full. Metering the stream makes the ceiling
+     * the configured limit instead of the server's choice, and cancelling the
+     * reader stops the transfer rather than merely stopping our interest in it.
+     *
+     * Content-Length is deliberately not trusted as the bound — it is a hint that
+     * can be absent or a lie — but it is worth honouring when present, because it
+     * refuses the honest oversized case without reading a byte.
+     *
+     * @param response - Fetch response whose body should be read
+     * @param maxBytes - Ceiling for the body, in bytes
+     * @returns The body as a Buffer
+     * @throws When the body exceeds `maxBytes`
+     */
+    private readBodyWithinLimit;
     /**
      * Download file with retry logic for transient failures.
      *

package/dist/lib/processors/base/BaseFileProcessor.js

@@ -52,6 +52,30 @@ import { tracers } from "../../telemetry/tracers.js";
 import { createFileError, extractHttpStatus, FileErrorCode, isRetryableError, } from "../errors/index.js";
 import { DEFAULT_RETRY_CONFIG } from "../../types/index.js";
 const gunzipAsync = promisify(gunzip);
+/**
+ * Marker on the error raised when a download is refused for exceeding the
+ * processor's size limit.
+ *
+ * A code rather than a message match, for two reasons. `classifyDownloadError`
+ * can then report FILE_TOO_LARGE — the same verdict the post-download check
+ * gave, so refusing earlier does not quietly downgrade the error a caller
+ * sees to DOWNLOAD_FAILED. And `isRetryableError` decides from text; a bound
+ * that fires is not a transient fault, and re-fetching a file that will be
+ * exactly as oversized next time is the one thing worth not doing three times.
+ */
+const DOWNLOAD_TOO_LARGE_CODE = "DOWNLOAD_TOO_LARGE";
+function downloadTooLargeError(maxSizeMB, typeName) {
+    const error = new Error(`Download exceeds the maximum size of ${maxSizeMB} MB for ${typeName}`);
+    error.code = DOWNLOAD_TOO_LARGE_CODE;
+    return error;
+}
+function isDownloadTooLarge(error) {
+    return (error?.code === DOWNLOAD_TOO_LARGE_CODE);
+}
+/** Node's signal that a zlib output bound was reached. */
+function isBufferTooLargeError(error) {
+    return (error?.code === "ERR_BUFFER_TOO_LARGE");
+}
 /**
  * Abstract base class for file processors.
  * Provides common download, validation, and error handling functionality.
@@ -389,8 +413,8 @@ export class BaseFileProcessor {
             if (contentType && contentType.includes("text/html")) {
                 throw new Error(`Received HTML response instead of file content (Content-Type: ${contentType}). This usually means the download URL returned an error page.`);
             }
-            const arrayBuffer = await response.arrayBuffer();
-            let buffer = Buffer.from(arrayBuffer);
+            const maxBytes = this.config.maxSizeMB * 1024 * 1024;
+            let buffer = await this.readBodyWithinLimit(response, maxBytes);
             // Check for gzip encoding and decompress if needed
             // Only decompress if the data actually starts with gzip magic bytes (0x1f 0x8b)
             const contentEncoding = response.headers.get("Content-Encoding");
@@ -398,9 +422,16 @@ export class BaseFileProcessor {
             if (contentEncoding?.toLowerCase().includes("gzip") &&
                 isActuallyGzipped) {
                 try {
-                    buffer = Buffer.from(await gunzipAsync(buffer));
+                    // Bounded at the decoder. The size check that runs after the download
+                    // only ever sees what already fits in memory, so a few KB of gzip
+                    // declaring gigabytes was inflated in full before anything objected —
+                    // the response passed the "is it small" test on its way in.
+                    buffer = Buffer.from(await gunzipAsync(buffer, { maxOutputLength: maxBytes }));
                 }
                 catch (gzipError) {
+                    if (isBufferTooLargeError(gzipError)) {
+                        throw downloadTooLargeError(this.config.maxSizeMB, this.config.fileTypeName);
+                    }
                     throw new Error(`Failed to decompress gzip response: ${gzipError instanceof Error ? gzipError.message : String(gzipError)}`, { cause: gzipError });
                 }
             }
@@ -408,7 +439,68 @@ export class BaseFileProcessor {
         }
         finally {
             clearTimeout(timeoutId);
+            // Release the connection on every early exit. Rejecting a response for
+            // its status or its Content-Type leaves the body unread, which keeps the
+            // socket out of the pool until the response is garbage-collected. After
+            // a successful read there is nothing left in flight, so this is a no-op.
+            controller.abort();
+        }
+    }
+    /**
+     * Read a response body, refusing it the moment it passes `maxBytes`.
+     *
+     * `response.arrayBuffer()` buffers whatever the server sends before anyone
+     * can object, so the size check further up only ever ran against a body that
+     * had already been paid for in full. Metering the stream makes the ceiling
+     * the configured limit instead of the server's choice, and cancelling the
+     * reader stops the transfer rather than merely stopping our interest in it.
+     *
+     * Content-Length is deliberately not trusted as the bound — it is a hint that
+     * can be absent or a lie — but it is worth honouring when present, because it
+     * refuses the honest oversized case without reading a byte.
+     *
+     * @param response - Fetch response whose body should be read
+     * @param maxBytes - Ceiling for the body, in bytes
+     * @returns The body as a Buffer
+     * @throws When the body exceeds `maxBytes`
+     */
+    async readBodyWithinLimit(response, maxBytes) {
+        const declared = Number(response.headers.get("Content-Length"));
+        if (Number.isFinite(declared) && declared > maxBytes) {
+            // Release the socket. An unread body keeps the connection out of the
+            // pool until the response is collected, so a run of oversized downloads
+            // would hold one socket open each.
+            await response.body?.cancel();
+            throw downloadTooLargeError(this.config.maxSizeMB, this.config.fileTypeName);
+        }
+        // Some responses carry no readable stream (mocked fetch, polyfills). The
+        // buffered read is the fallback, still checked — just after the fact.
+        if (!response.body) {
+            const buffered = Buffer.from(await response.arrayBuffer());
+            if (buffered.length > maxBytes) {
+                throw downloadTooLargeError(this.config.maxSizeMB, this.config.fileTypeName);
+            }
+            return buffered;
+        }
+        const reader = response.body.getReader();
+        const chunks = [];
+        let total = 0;
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            if (!value) {
+                continue;
+            }
+            total += value.byteLength;
+            if (total > maxBytes) {
+                await reader.cancel();
+                throw downloadTooLargeError(this.config.maxSizeMB, this.config.fileTypeName);
+            }
+            chunks.push(Buffer.from(value));
         }
+        return Buffer.concat(chunks, total);
     }
     /**
      * Download file with retry logic for transient failures.
@@ -559,6 +651,15 @@ export class BaseFileProcessor {
      * @returns Structured file processing error
      */
     classifyDownloadError(error) {
+        // Refusing an oversized body mid-stream is the same verdict the old
+        // post-download check gave, so it must carry the same code — otherwise
+        // bounding the read earlier would silently reclassify a familiar error.
+        if (isDownloadTooLarge(error)) {
+            return this.createError(FileErrorCode.FILE_TOO_LARGE, {
+                maxMB: this.config.maxSizeMB,
+                type: this.config.fileTypeName,
+            }, error);
+        }
         if (isAbortError(error)) {
             return this.createError(FileErrorCode.DOWNLOAD_TIMEOUT, { timeoutMs: this.config.timeoutMs }, error);
         }

package/dist/lib/types/processor.d.ts

@@ -761,6 +761,29 @@ export type ArchiveDecompressionResult = {
 } | {
     readonly status: "failed";
 };
+/**
+ * Outcome of reading one ZIP entry under an explicit output bound.
+ *
+ * Separate from {@link ArchiveDecompressionResult} because the failures differ:
+ * a single-stream archive can fail for want of an external tool, while a ZIP
+ * entry can instead use a compression method this reader does not implement.
+ * Collapsing them would force one caller to handle a state it can never see.
+ *
+ * `too-large` is a distinct outcome rather than a corrupt-file error because it
+ * is a verdict about our limit, not about the archive: the entry may be
+ * perfectly well-formed, and telling the user it is damaged would send them to
+ * re-create a file that was never broken.
+ */
+export type ArchiveEntryReadResult = {
+    readonly status: "ok";
+    readonly buffer: Buffer;
+} | {
+    readonly status: "too-large";
+} | {
+    readonly status: "unsupported-method";
+} | {
+    readonly status: "corrupt";
+};
 /**
  * Metadata about an individual entry within an archive.
  */

package/dist/lib/types/proxy.d.ts

@@ -1861,6 +1861,14 @@ export type UpdateCheckResult = {
     latestVersion: string;
     updateAvailable: boolean;
 };
+/** Result of one local proxy health probe by the updater or fail-open guard. */
+export type ProxyHealthProbe = {
+    healthy: boolean;
+    durationMs: number;
+    failure: "http_status" | "network" | "timeout" | null;
+    statusCode: number | null;
+    errorCode: string | null;
+};
 /** Parsed major.minor.patch components of a semver string. */
 export type SemVer = {
     major: number;

package/dist/processors/archive/ArchiveProcessor.js

@@ -40,9 +40,6 @@ import { BaseFileProcessor } from "../base/BaseFileProcessor.js";
 import { SIZE_LIMITS_MB } from "../config/index.js";
 import { FileErrorCode } from "../errors/index.js";
 // =============================================================================
-// TYPES
-// =============================================================================
-// =============================================================================
 // SECURITY CONFIGURATION
 // =============================================================================
 /**
@@ -162,6 +159,60 @@ const SINGLE_STREAM_TOOLS = {
     xz: "xz",
     zst: "zstd",
 };
+/**
+ * Read one ZIP entry's bytes without trusting the size it declares.
+ *
+ * `entry.getData()` cannot be used for this. It sizes its output buffer from
+ * the central-directory `size` field, which the archive author chooses, and
+ * adm-zip only arms its own guard when that field is positive:
+ *
+ *   const option = version >= 15 && expectedLength > 0
+ *     ? { maxOutputLength: expectedLength } : {};
+ *
+ * So an entry declaring 0 disables the bound and the caller's `size > maxSize`
+ * check in one move — `0 > 5MB` is false, and the inflate then runs uncapped.
+ * The declared size is the attack, so nothing here may depend on it: the cap
+ * comes from our own limit and is handed to the decoder.
+ *
+ * CRC is verified on both paths rather than dropped, so bypassing `getData()`
+ * does not also quietly lose its corruption check — a STORED entry is copied
+ * out rather than decoded, but it can be damaged just the same. It detects
+ * damage, not malice — the CRC field is attacker-controlled too.
+ */
+function readZipEntryWithinLimit(entry, maxBytes, zlibModule) {
+    const compressed = entry.getCompressedData();
+    const matchesCrc = (data) => (zlibModule.crc32(data) >>> 0) === (entry.header.crc >>> 0);
+    // STORED: the bytes are already the payload, so its own length is the bound.
+    if (entry.header.method === ZIP_METHOD_STORED) {
+        if (compressed.length > maxBytes) {
+            return { status: "too-large" };
+        }
+        return matchesCrc(compressed)
+            ? { status: "ok", buffer: compressed }
+            : { status: "corrupt" };
+    }
+    if (entry.header.method !== ZIP_METHOD_DEFLATED) {
+        return { status: "unsupported-method" };
+    }
+    let inflated;
+    try {
+        inflated = zlibModule.inflateRawSync(compressed, {
+            maxOutputLength: maxBytes,
+        });
+    }
+    catch (error) {
+        if (isDecompressionBoundExceeded(error)) {
+            return { status: "too-large" };
+        }
+        return { status: "corrupt" };
+    }
+    return matchesCrc(inflated)
+        ? { status: "ok", buffer: inflated }
+        : { status: "corrupt" };
+}
+/** ZIP compression methods this reader handles (APPNOTE 4.4.5). */
+const ZIP_METHOD_STORED = 0;
+const ZIP_METHOD_DEFLATED = 8;
 /**
  * Whether a zlib rejection is the output bound firing rather than bad input.
  *
@@ -1552,12 +1603,29 @@ export class ArchiveProcessor extends BaseFileProcessor {
             if (targetEntry.isDirectory) {
                 return `"${entryPath}" is a directory, not a file.`;
             }
-            // Security: size check
+            // Security: size check.
+            //
+            // The declared size is a hint, not the bound — it is chosen by whoever
+            // built the archive, and an entry claiming 0 passes this comparison while
+            // switching off adm-zip's own cap (see readZipEntryWithinLimit). It is
+            // still worth checking, because an honestly-declared oversized entry is
+            // refused here without decompressing anything at all.
             const maxSize = 5 * 1024 * 1024; // 5 MB
             if (targetEntry.header.size > maxSize) {
                 return `Entry "${entryPath}" is too large (${this.formatHumanReadableSize(targetEntry.header.size)}). Maximum extraction size is 5 MB.`;
             }
-            const data = targetEntry.getData();
+            const zlibModule = await import("zlib");
+            const read = readZipEntryWithinLimit(targetEntry, maxSize, zlibModule);
+            if (read.status === "too-large") {
+                return `Entry "${entryPath}" is too large. Maximum extraction size is 5 MB.`;
+            }
+            if (read.status === "unsupported-method") {
+                return `Entry "${entryPath}" uses an unsupported compression method.`;
+            }
+            if (read.status === "corrupt") {
+                return `Entry "${entryPath}" could not be read — the archive entry is corrupt.`;
+            }
+            const data = read.buffer;
             // Check if it looks like text
             const sampleSize = Math.min(data.length, 512);
             let printable = 0;

package/dist/processors/base/BaseFileProcessor.d.ts

@@ -181,6 +181,25 @@ export declare abstract class BaseFileProcessor<T extends ProcessedFileBase> {
      * @throws Error if download fails
      */
     protected downloadFile(url: string, authHeaders?: Record<string, string>, timeout?: number): Promise<Buffer>;
+    /**
+     * Read a response body, refusing it the moment it passes `maxBytes`.
+     *
+     * `response.arrayBuffer()` buffers whatever the server sends before anyone
+     * can object, so the size check further up only ever ran against a body that
+     * had already been paid for in full. Metering the stream makes the ceiling
+     * the configured limit instead of the server's choice, and cancelling the
+     * reader stops the transfer rather than merely stopping our interest in it.
+     *
+     * Content-Length is deliberately not trusted as the bound — it is a hint that
+     * can be absent or a lie — but it is worth honouring when present, because it
+     * refuses the honest oversized case without reading a byte.
+     *
+     * @param response - Fetch response whose body should be read
+     * @param maxBytes - Ceiling for the body, in bytes
+     * @returns The body as a Buffer
+     * @throws When the body exceeds `maxBytes`
+     */
+    private readBodyWithinLimit;
     /**
      * Download file with retry logic for transient failures.
      *