@forzalabs/remora 2.2.0 → 2.2.1

package/CHANGELOG.md

@@ -6,6 +6,14 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 
 ## Unreleased
 
+## V 2.2.1 - 2026-10-15
+
+### Fixed
+
+- **A compressed source file that could not be read failed the run with `unexpected end of file` and nothing else.** zlib reports WHAT went wrong and never WHICH file it was reading, and nothing between it and the CLI added the name back, so a producer staging hundreds of files through a `%` fileKey died with a six-word string that named no file, no producer and no consumer stage — the one thing needed to go and look at it. Worse, that one string covers three different mistakes: a truncated archive, a **zero-byte** file, and (as `incorrect header check`) a file that is not compressed at all. The first two are what a drop folder produces constantly, since a file being written into one exists at zero bytes before it holds anything. Every decompression failure is now re-thrown naming the file and the declared format — `Failed to decompress "/data/claims/claimline_2026_03.csv.gz" as GZ: unexpected end of file. The archive ends mid-stream, so it is truncated...` — and the two cases that are decidable before any decompressor runs are refused ahead of it by their own name: an empty file says it is empty and says that a writer should stage under a temporary name and rename into place, and a file whose first bytes are not the declared format's signature (`1f 8b` for GZ, `50 4b` for ZIP) says it is not that archive whatever its name says. TAR has no signature at offset 0, so it is left to the extractor. ZIP and TAR failures gain the same naming, since yauzl and tar are no more forthcoming than zlib. An unsupported `compressionType` is also now refused as a precondition, naming the three that exist, instead of from inside the switch
+
+- **The file log sink could be ended while the records it had accepted were still in flight.** A winston logger is a Transform piped into its transports, and `Logger._final` ends every transport the moment the logger's writable side closes — while records already accepted sit in its readable buffer waiting for the transport to have room. The transport then drains, the pipe resumes on that drain, and the next record is written into a stream that has ended: `ERR_STREAM_WRITE_AFTER_END`, raised from a stream with no line of remora's in its stack. Re-pointing the sink and closing it now drain the in-flight records into the transports first, and a re-point releases the old logger only after the new one is serving, so nothing can be routed to a logger on its way out. `flush()` also writes ONE sentinel record rather than one per transport — every transport sees every record, so a sentinel each only wrote N blank lines into the same file
+
 ## V 2.2.0 - 2026-10-15
 
 **Upgrading from 2.1.** Three changes can alter what an existing project does, despite the minor version. `nullable` on a producer dimension is no longer documentation: it defaults to `true` and keeps a missing value as `null` as before, but a dimension that declares `"nullable": false` now gets the type's own empty value (`""`, `0`, `false`) where it used to get `null`. A `NULL` in a `number` column now stages as `null` rather than as `0`, so a consumer that was summing or filtering over those zeros sees different figures — the fix is in the staging of every CSV-staged source (SQL, Delta Share, local and S3 CSV). And `settings.sql` on a producer is gone from the schema, so a producer still carrying it fails `compile` — the property never did anything; delete it. Also worth a glance: `remora package` writes `./remora.zip` instead of `./remora-config.zip` when no `-o` is given, and the resource folder lists in `project.json` (`sources`, `producers`, `consumers`, `schemas`, `codeSets`) are ignored — the folders are fixed. They still validate, so nothing breaks, but a project pointing them somewhere else was already not being read that way.

package/index.js

@@ -11114,8 +11114,7 @@ var init_FileLogService = __esm({
             return;
           if (!(0, import_fs.existsSync)(folder))
             (0, import_fs.mkdirSync)(folder, { recursive: true });
-          if (this._logger)
-            this._logger.end();
+          const previous = this._logger;
           this._folder = folder;
           this._file = file;
           this._logger = import_winston.default.createLogger({
@@ -11143,6 +11142,7 @@ ${stack}` : base;
           });
           this._logger.on("error", (error) => console.error(`File logger error: ${error?.message ?? String(error)}`));
           this._enabled = true;
+          if (previous) void this._endSafely(previous);
         };
         /**
          * Where the file sink writes, whether or not it is currently enabled.
@@ -11168,19 +11168,31 @@ ${stack}` : base;
         };
         this.flush = () => {
           if (!this._enabled || !this._logger) return Promise.resolve();
+          return this.drain(this._logger);
+        };
+        /**
+         * Resolves once every record already handed to `target` has reached its transports.
+         *
+         * A winston logger is a Transform piped into each transport, so a record accepted by `log()` is
+         * not a record that has been written: it sits in the logger's readable buffer until the transport
+         * has room. Writing one sentinel and waiting for every transport to report it `logged` is what
+         * establishes that the queue ahead of it has gone — records travel the pipe in order, so the
+         * sentinel landing means everything before it landed.
+         */
+        this.drain = (target) => {
           return new Promise((resolve) => {
-            let pending = this._logger.transports.length;
+            let pending = target.transports.length;
             if (pending === 0) return resolve();
-            for (const transport of this._logger.transports) {
-              if (typeof transport.on === "function") {
-                transport.once("logged", () => {
-                  if (--pending === 0) resolve();
-                });
-                this._logger.info("");
-              } else {
+            for (const transport of target.transports) {
+              if (typeof transport.on !== "function") {
                 if (--pending === 0) resolve();
+                continue;
               }
+              transport.once("logged", () => {
+                if (--pending === 0) resolve();
+              });
             }
+            target.info("");
           });
         };
         /**
@@ -11191,15 +11203,37 @@ ${stack}` : base;
          * listening to. Leaving `_enabled` true after a close is what turned "someone logged after
          * close" into "the process died". Use `flush()` when the sink is still needed afterwards.
          */
-        this.close = () => {
-          if (!this._enabled || !this._logger) return Promise.resolve();
+        this.close = async () => {
+          if (!this._enabled || !this._logger) return;
           const closing = this._logger;
           this._enabled = false;
           this._logger = null;
-          return new Promise((resolve) => {
-            closing.on("finish", resolve);
-            closing.end();
-          });
+          await this._endSafely(closing);
+        };
+        /**
+         * Ends a winston logger without the race its own `end()` carries.
+         *
+         * `Logger._final` ends EVERY TRANSPORT the moment the logger's writable side closes — while the
+         * records it already accepted are still travelling down the pipe from its readable side. The
+         * transport drains, the pipe resumes on that drain, and the next record is written into a stream
+         * that has ended: ERR_STREAM_WRITE_AFTER_END, raised from a stream no line of ours is standing
+         * next to. In an executor thread under a debug run, where the pipe is never empty, that is an
+         * error per rotation and a stack with nothing of remora's in it. Draining the in-flight records
+         * into the transports first is what removes the race rather than hiding it.
+         *
+         * A failure here is swallowed on purpose: this logger is on its way out, it carries its own
+         * `error` handler, and a sink that cannot close must not take the caller's shutdown with it.
+         */
+        this._endSafely = async (target) => {
+          try {
+            await this.drain(target);
+            await new Promise((resolve) => {
+              target.once("finish", resolve);
+              target.end();
+            });
+          } catch (error) {
+            console.error(`File logger failed to close: ${error?.message ?? String(error)}`);
+          }
         };
       }
     };
@@ -11727,7 +11761,7 @@ var CONSTANTS, Constants_default;
 var init_Constants = __esm({
   "../../packages/constants/src/Constants.ts"() {
     CONSTANTS = {
-      cliVersion: "2.2.0",
+      cliVersion: "2.2.1",
       backendVersion: 1,
       backendPort: 5088,
       workerVersion: 2,
@@ -37732,7 +37766,7 @@ var init_index_min = __esm({
 });
 
 // ../../packages/parsing/src/ParseCompression.ts
-var fs10, import_zlib2, import_path9, import_yauzl, import_promises6, ParseCompressionClass, ParseCompression, ParseCompression_default;
+var fs10, import_zlib2, import_path9, import_yauzl, import_promises6, SUPPORTED_FORMATS, FORMAT_SIGNATURES, TRUNCATED_INPUT_CODE, ParseCompressionClass, ParseCompression, ParseCompression_default;
 var init_ParseCompression = __esm({
   "../../packages/parsing/src/ParseCompression.ts"() {
     fs10 = __toESM(require("fs"), 1);
@@ -37744,6 +37778,12 @@ var init_ParseCompression = __esm({
     init_src();
     init_src2();
     init_src3();
+    SUPPORTED_FORMATS = ["ZIP", "TAR", "GZ"];
+    FORMAT_SIGNATURES = {
+      GZ: { bytes: [31, 139], label: "1f 8b" },
+      ZIP: { bytes: [80, 75], label: '50 4b ("PK")' }
+    };
+    TRUNCATED_INPUT_CODE = "Z_BUF_ERROR";
     ParseCompressionClass = class {
       constructor() {
         /**
@@ -37762,31 +37802,76 @@ var init_ParseCompression = __esm({
           Affirm_default(standardPath, "Missing required parameter standardPath");
           Affirm_default(executionPath, "Missing required parameter executionPath");
           const archivePath = import_path9.default.join(standardPath, fileKey);
-          switch (compressionType?.toUpperCase()) {
-            case "ZIP": {
-              this._warningPossibleConvertionError(compressionType, fileKey);
-              return this._extractZip(archivePath, this._prepareTargetDir(executionPath));
-            }
-            case "TAR": {
-              this._warningPossibleConvertionError(compressionType, fileKey);
-              return this._extractTar(archivePath, this._prepareTargetDir(executionPath));
-            }
-            case "GZ": {
-              this._warningPossibleConvertionError(compressionType, fileKey);
-              fs10.mkdirSync(import_path9.default.dirname(executionPath), { recursive: true });
-              await this._gunzipFile(archivePath, executionPath);
-              return [executionPath];
-            }
-            case null:
-            case void 0: {
-              if ([".zip", ".tar", ".gz"].some((extension) => fileKey.includes(extension)))
-                Logger_default.warn(`The file ${fileKey} looks compressed while its producer declares no compressionType`);
-              return [archivePath];
-            }
-            default: {
-              throw new Error(`this compression type it has not been implemented ${compressionType}`);
+          const format4 = compressionType?.toUpperCase();
+          if (!format4) {
+            if ([".zip", ".tar", ".gz"].some((extension) => fileKey.includes(extension)))
+              Logger_default.warn(`The file ${fileKey} looks compressed while its producer declares no compressionType`);
+            return [archivePath];
+          }
+          Affirm_default(SUPPORTED_FORMATS.includes(format4), `Compression type "${compressionType}" has not been implemented. Declare one of ${SUPPORTED_FORMATS.join(", ")} on the producer, or no compressionType at all`);
+          this._warningPossibleConvertionError(compressionType, fileKey);
+          this._affirmArchive(archivePath, format4);
+          try {
+            switch (format4) {
+              case "ZIP":
+                return await this._extractZip(archivePath, this._prepareTargetDir(executionPath));
+              case "TAR":
+                return await this._extractTar(archivePath, this._prepareTargetDir(executionPath));
+              // GZ, the only format the affirm above leaves
+              default: {
+                fs10.mkdirSync(import_path9.default.dirname(executionPath), { recursive: true });
+                await this._gunzipFile(archivePath, executionPath);
+                return [executionPath];
+              }
             }
+          } catch (error) {
+            throw this._asNamedFailure(error, format4, archivePath);
+          }
+        };
+        /**
+         * What has to be true of a file before a decompressor is pointed at it.
+         *
+         * Both checks exist because of what zlib says when they fail: a zero-byte file and a half-written
+         * one are each reported as the bare string "unexpected end of file", and a file that is not
+         * compressed at all as "incorrect header check" — three different configuration mistakes, none of
+         * them named, none of them naming the file. A drop folder produces the first two constantly,
+         * since a file being written into one exists at zero bytes before it holds anything.
+         */
+        this._affirmArchive = (archivePath, format4) => {
+          Affirm_default(fs10.existsSync(archivePath), `Source file does not exist: ${archivePath}`);
+          const { size } = fs10.statSync(archivePath);
+          Affirm_default(size > 0, `Source file "${archivePath}" is empty (0 bytes), so there is no ${format4} archive in it to read. A file still being written into the source folder looks exactly like this \u2014 have the writer stage it under a temporary name and rename it into place, which is atomic, so a run never sees a partial file`);
+          const signature = FORMAT_SIGNATURES[format4];
+          if (!signature) return;
+          Affirm_default(this._startsWith(archivePath, signature.bytes), `Source file "${archivePath}" is declared as ${format4} but does not start with the ${format4} signature ${signature.label}, so it is not a ${format4} archive whatever its name says. Check the producer's compressionType against what actually lands in the folder`);
+        };
+        /** Whether a file's first bytes are exactly `expected`. Reads only those bytes, never the file. */
+        this._startsWith = (filePath, expected) => {
+          const head = Buffer.alloc(expected.length);
+          const handle = fs10.openSync(filePath, "r");
+          try {
+            fs10.readSync(handle, head, 0, head.length, 0);
+          } finally {
+            fs10.closeSync(handle);
           }
+          return head.equals(Buffer.from(expected));
+        };
+        /**
+         * A decompression failure that names the file it happened on.
+         *
+         * Every decompression library reports WHAT went wrong and none of them report WHICH file they
+         * were reading — zlib hands back "unexpected end of file" and nothing else. A producer whose
+         * fileKey carries a `%` stages hundreds of files in one pass, so that bare string was the entire
+         * cause of death of a run: no file, no producer, no way to tell which of the hundreds to go and
+         * look at. Our own failures already name the archive and are passed through untouched.
+         */
+        this._asNamedFailure = (error, format4, archivePath) => {
+          const reason = error instanceof Error ? error : new Error(String(error));
+          if (reason.message.includes(archivePath)) return reason;
+          const truncated = reason.code === TRUNCATED_INPUT_CODE;
+          const hint = truncated ? " The archive ends mid-stream, so it is truncated: the transfer that wrote it did not finish, or it was read while it was still being written" : "";
+          const message = reason.message.replace(/\s*\.\s*$/, "");
+          return new Error(`Failed to decompress "${archivePath}" as ${format4}: ${message}.${hint}`, { cause: reason });
         };
         this._warningPossibleConvertionError = (compression, fileKey) => {
           if (!fileKey.split(".").includes(compression.toLowerCase()) && compression) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@forzalabs/remora",
-    "version": "2.2.0",
+    "version": "2.2.1",
     "description": "A powerful CLI tool for seamless data translation.",
     "main": "index.js",
     "private": false,

package/workers/ExecutorWorker.js

@@ -11162,8 +11162,7 @@ var init_FileLogService = __esm({
             return;
           if (!(0, import_fs.existsSync)(folder))
             (0, import_fs.mkdirSync)(folder, { recursive: true });
-          if (this._logger)
-            this._logger.end();
+          const previous = this._logger;
           this._folder = folder;
           this._file = file;
           this._logger = import_winston.default.createLogger({
@@ -11191,6 +11190,7 @@ ${stack}` : base;
           });
           this._logger.on("error", (error) => console.error(`File logger error: ${error?.message ?? String(error)}`));
           this._enabled = true;
+          if (previous) void this._endSafely(previous);
         };
         /**
          * Where the file sink writes, whether or not it is currently enabled.
@@ -11216,19 +11216,31 @@ ${stack}` : base;
         };
         this.flush = () => {
           if (!this._enabled || !this._logger) return Promise.resolve();
+          return this.drain(this._logger);
+        };
+        /**
+         * Resolves once every record already handed to `target` has reached its transports.
+         *
+         * A winston logger is a Transform piped into each transport, so a record accepted by `log()` is
+         * not a record that has been written: it sits in the logger's readable buffer until the transport
+         * has room. Writing one sentinel and waiting for every transport to report it `logged` is what
+         * establishes that the queue ahead of it has gone — records travel the pipe in order, so the
+         * sentinel landing means everything before it landed.
+         */
+        this.drain = (target) => {
           return new Promise((resolve) => {
-            let pending = this._logger.transports.length;
+            let pending = target.transports.length;
             if (pending === 0) return resolve();
-            for (const transport of this._logger.transports) {
-              if (typeof transport.on === "function") {
-                transport.once("logged", () => {
-                  if (--pending === 0) resolve();
-                });
-                this._logger.info("");
-              } else {
+            for (const transport of target.transports) {
+              if (typeof transport.on !== "function") {
                 if (--pending === 0) resolve();
+                continue;
               }
+              transport.once("logged", () => {
+                if (--pending === 0) resolve();
+              });
             }
+            target.info("");
           });
         };
         /**
@@ -11239,15 +11251,37 @@ ${stack}` : base;
          * listening to. Leaving `_enabled` true after a close is what turned "someone logged after
          * close" into "the process died". Use `flush()` when the sink is still needed afterwards.
          */
-        this.close = () => {
-          if (!this._enabled || !this._logger) return Promise.resolve();
+        this.close = async () => {
+          if (!this._enabled || !this._logger) return;
           const closing = this._logger;
           this._enabled = false;
           this._logger = null;
-          return new Promise((resolve) => {
-            closing.on("finish", resolve);
-            closing.end();
-          });
+          await this._endSafely(closing);
+        };
+        /**
+         * Ends a winston logger without the race its own `end()` carries.
+         *
+         * `Logger._final` ends EVERY TRANSPORT the moment the logger's writable side closes — while the
+         * records it already accepted are still travelling down the pipe from its readable side. The
+         * transport drains, the pipe resumes on that drain, and the next record is written into a stream
+         * that has ended: ERR_STREAM_WRITE_AFTER_END, raised from a stream no line of ours is standing
+         * next to. In an executor thread under a debug run, where the pipe is never empty, that is an
+         * error per rotation and a stack with nothing of remora's in it. Draining the in-flight records
+         * into the transports first is what removes the race rather than hiding it.
+         *
+         * A failure here is swallowed on purpose: this logger is on its way out, it carries its own
+         * `error` handler, and a sink that cannot close must not take the caller's shutdown with it.
+         */
+        this._endSafely = async (target) => {
+          try {
+            await this.drain(target);
+            await new Promise((resolve) => {
+              target.once("finish", resolve);
+              target.end();
+            });
+          } catch (error) {
+            console.error(`File logger failed to close: ${error?.message ?? String(error)}`);
+          }
         };
       }
     };
@@ -11775,7 +11809,7 @@ var CONSTANTS, Constants_default;
 var init_Constants = __esm({
   "../../packages/constants/src/Constants.ts"() {
     CONSTANTS = {
-      cliVersion: "2.2.0",
+      cliVersion: "2.2.1",
       backendVersion: 1,
       backendPort: 5088,
       workerVersion: 2,
@@ -37899,7 +37933,7 @@ var init_index_min = __esm({
 });
 
 // ../../packages/parsing/src/ParseCompression.ts
-var fs8, import_zlib2, import_path8, import_yauzl, import_promises6, ParseCompressionClass, ParseCompression, ParseCompression_default;
+var fs8, import_zlib2, import_path8, import_yauzl, import_promises6, SUPPORTED_FORMATS, FORMAT_SIGNATURES, TRUNCATED_INPUT_CODE, ParseCompressionClass, ParseCompression, ParseCompression_default;
 var init_ParseCompression = __esm({
   "../../packages/parsing/src/ParseCompression.ts"() {
     fs8 = __toESM(require("fs"), 1);
@@ -37911,6 +37945,12 @@ var init_ParseCompression = __esm({
     init_src();
     init_src2();
     init_src3();
+    SUPPORTED_FORMATS = ["ZIP", "TAR", "GZ"];
+    FORMAT_SIGNATURES = {
+      GZ: { bytes: [31, 139], label: "1f 8b" },
+      ZIP: { bytes: [80, 75], label: '50 4b ("PK")' }
+    };
+    TRUNCATED_INPUT_CODE = "Z_BUF_ERROR";
     ParseCompressionClass = class {
       constructor() {
         /**
@@ -37929,31 +37969,76 @@ var init_ParseCompression = __esm({
           Affirm_default(standardPath, "Missing required parameter standardPath");
           Affirm_default(executionPath, "Missing required parameter executionPath");
           const archivePath = import_path8.default.join(standardPath, fileKey);
-          switch (compressionType?.toUpperCase()) {
-            case "ZIP": {
-              this._warningPossibleConvertionError(compressionType, fileKey);
-              return this._extractZip(archivePath, this._prepareTargetDir(executionPath));
-            }
-            case "TAR": {
-              this._warningPossibleConvertionError(compressionType, fileKey);
-              return this._extractTar(archivePath, this._prepareTargetDir(executionPath));
-            }
-            case "GZ": {
-              this._warningPossibleConvertionError(compressionType, fileKey);
-              fs8.mkdirSync(import_path8.default.dirname(executionPath), { recursive: true });
-              await this._gunzipFile(archivePath, executionPath);
-              return [executionPath];
-            }
-            case null:
-            case void 0: {
-              if ([".zip", ".tar", ".gz"].some((extension) => fileKey.includes(extension)))
-                Logger_default.warn(`The file ${fileKey} looks compressed while its producer declares no compressionType`);
-              return [archivePath];
-            }
-            default: {
-              throw new Error(`this compression type it has not been implemented ${compressionType}`);
+          const format4 = compressionType?.toUpperCase();
+          if (!format4) {
+            if ([".zip", ".tar", ".gz"].some((extension) => fileKey.includes(extension)))
+              Logger_default.warn(`The file ${fileKey} looks compressed while its producer declares no compressionType`);
+            return [archivePath];
+          }
+          Affirm_default(SUPPORTED_FORMATS.includes(format4), `Compression type "${compressionType}" has not been implemented. Declare one of ${SUPPORTED_FORMATS.join(", ")} on the producer, or no compressionType at all`);
+          this._warningPossibleConvertionError(compressionType, fileKey);
+          this._affirmArchive(archivePath, format4);
+          try {
+            switch (format4) {
+              case "ZIP":
+                return await this._extractZip(archivePath, this._prepareTargetDir(executionPath));
+              case "TAR":
+                return await this._extractTar(archivePath, this._prepareTargetDir(executionPath));
+              // GZ, the only format the affirm above leaves
+              default: {
+                fs8.mkdirSync(import_path8.default.dirname(executionPath), { recursive: true });
+                await this._gunzipFile(archivePath, executionPath);
+                return [executionPath];
+              }
             }
+          } catch (error) {
+            throw this._asNamedFailure(error, format4, archivePath);
+          }
+        };
+        /**
+         * What has to be true of a file before a decompressor is pointed at it.
+         *
+         * Both checks exist because of what zlib says when they fail: a zero-byte file and a half-written
+         * one are each reported as the bare string "unexpected end of file", and a file that is not
+         * compressed at all as "incorrect header check" — three different configuration mistakes, none of
+         * them named, none of them naming the file. A drop folder produces the first two constantly,
+         * since a file being written into one exists at zero bytes before it holds anything.
+         */
+        this._affirmArchive = (archivePath, format4) => {
+          Affirm_default(fs8.existsSync(archivePath), `Source file does not exist: ${archivePath}`);
+          const { size } = fs8.statSync(archivePath);
+          Affirm_default(size > 0, `Source file "${archivePath}" is empty (0 bytes), so there is no ${format4} archive in it to read. A file still being written into the source folder looks exactly like this \u2014 have the writer stage it under a temporary name and rename it into place, which is atomic, so a run never sees a partial file`);
+          const signature = FORMAT_SIGNATURES[format4];
+          if (!signature) return;
+          Affirm_default(this._startsWith(archivePath, signature.bytes), `Source file "${archivePath}" is declared as ${format4} but does not start with the ${format4} signature ${signature.label}, so it is not a ${format4} archive whatever its name says. Check the producer's compressionType against what actually lands in the folder`);
+        };
+        /** Whether a file's first bytes are exactly `expected`. Reads only those bytes, never the file. */
+        this._startsWith = (filePath, expected) => {
+          const head = Buffer.alloc(expected.length);
+          const handle = fs8.openSync(filePath, "r");
+          try {
+            fs8.readSync(handle, head, 0, head.length, 0);
+          } finally {
+            fs8.closeSync(handle);
           }
+          return head.equals(Buffer.from(expected));
+        };
+        /**
+         * A decompression failure that names the file it happened on.
+         *
+         * Every decompression library reports WHAT went wrong and none of them report WHICH file they
+         * were reading — zlib hands back "unexpected end of file" and nothing else. A producer whose
+         * fileKey carries a `%` stages hundreds of files in one pass, so that bare string was the entire
+         * cause of death of a run: no file, no producer, no way to tell which of the hundreds to go and
+         * look at. Our own failures already name the archive and are passed through untouched.
+         */
+        this._asNamedFailure = (error, format4, archivePath) => {
+          const reason = error instanceof Error ? error : new Error(String(error));
+          if (reason.message.includes(archivePath)) return reason;
+          const truncated = reason.code === TRUNCATED_INPUT_CODE;
+          const hint = truncated ? " The archive ends mid-stream, so it is truncated: the transfer that wrote it did not finish, or it was read while it was still being written" : "";
+          const message = reason.message.replace(/\s*\.\s*$/, "");
+          return new Error(`Failed to decompress "${archivePath}" as ${format4}: ${message}.${hint}`, { cause: reason });
         };
         this._warningPossibleConvertionError = (compression, fileKey) => {
           if (!fileKey.split(".").includes(compression.toLowerCase()) && compression) {