7zip-native 0.0.5 → 0.0.6

package/README.md

@@ -3,6 +3,9 @@
 
 # 7zip-native
 
+### Current version `26.05`
+Upstream 7-Zip archive engine from https://github.com/ip7z/7zip/
+
 Native Node-API bindings for the 7-Zip archive engine. Use a typed, Promise-based Node.js API to inspect archives, read entry data, stream large files, or extract entries without launching `7z`, `7zz`, or another archive executable.
 
 The package includes the native addon and the matching 7-Zip engine for each supported target. Compression and decompression are provided by the upstream 7-Zip implementation.
@@ -13,7 +16,7 @@ The package includes the native addon and the matching 7-Zip engine for each sup
 npm install 7zip-native
 ```
 
-The package requires Node.js 18 or newer. The release workflow builds and tests with Node.js 22.
+The package requires Node.js 18 or newer.
 
 ## Quick start
 
@@ -141,12 +144,16 @@ This respects backpressure and ends the destination when extraction succeeds. A
 ```ts
 await archive.extractToFolder('./unpacked', {
 	paths: ['chapter/page1.jpg', 'chapter/page2.jpg'], // alternatively, use ids
+	overwrite: true,
+	onProgress: ({filesExtracted, totalFiles, bytesProcessed, totalBytes, percent}) => {
+		console.log(`${filesExtracted}/${totalFiles} files, ${percent}% (${bytesProcessed}/${totalBytes} bytes)`);
+	},
 	maxBytes: 2n * 1024n * 1024n * 1024n,
 	signal: abortController.signal,
 });
 ```
 
-Folder extraction accepts either `ids` or exact `paths`; omit both to extract every entry, and do not provide both together. Paths use archive-internal `/` separators. Extraction is sequential and uses bounded memory. Its default total output limit is 4 GiB; `maxBytes: null` disables that limit. Existing files are never overwritten. Unsafe paths, path collisions, and symlinked destination components are rejected. Archive links are written as regular file data; the API does not create symbolic or hard links. If extraction fails partway through, files already written (or partially written) may remain in the destination.
+Folder extraction accepts either `ids` or exact `paths`; omit both to extract every entry, and do not provide both together. Paths use archive-internal `/` separators. Extraction is sequential and uses bounded memory. Its default total output limit is 4 GiB; `maxBytes: null` disables that limit. Set `onProgress` to receive the number of regular files selected and fully extracted, the bytes emitted so far, the total uncompressed bytes, and the calculated percentage. It is called before extraction, as data chunks are processed, and after each file completes. By default, existing files are not overwritten; set `overwrite: true` to replace existing regular files. Replacement is committed only after that entry has been fully extracted, using a temporary file alongside the destination so a failure does not truncate the existing file. This can temporarily require extra disk space up to the size of the entry being replaced. Symlink or non-file targets are rejected. Unsafe archive paths, path collisions, and symlinked destination components are also rejected. Archive links are written as regular file data; the API does not create symbolic or hard links. If extraction fails partway through, files already written (or partially written) may remain in the destination.
 
 ### Concurrency
 
@@ -200,16 +207,15 @@ See [THIRD_PARTY_NOTICES.md](./THIRD_PARTY_NOTICES.md) for third-party redistrib
 
 ## Platform support
 
-The release workflow builds eight targets:
+The package includes prebuilt binaries for:
 
-| Platform | Architecture | CI verification |
-| --- | --- | --- |
-| Linux | x64, ARM64 | Build and runtime tests |
-| Linux | x86 (ia32), ARM32 | Cross-compile and verify binary architecture; not runtime-tested in CI |
-| macOS | x64, ARM64 | Build and runtime tests |
-| Windows | x64, ARM64 | Build and runtime tests |
+| Platform | Architectures |
+| --- | --- |
+| Linux | x64, x86 (ia32), ARM32, ARM64 |
+| macOS | x64, ARM64 |
+| Windows | x64, ARM64 |
 
-The published binaries must match the target operating system and architecture. Windows x86 (ia32) prebuilds are not published. The package declares Node.js `>=18`; the workflow currently builds and tests with Node.js 26. This checkout has been verified locally on Linux x64. Do not treat cross-compiled Linux 32-bit artifacts as runtime-tested.
+Windows x86 (ia32) is not supported by the published prebuilt binaries.
 
 ## Electron
 

package/dist/index.cjs

@@ -2,6 +2,7 @@
 
 var node_fs = require('node:fs');
 var promises$1 = require('node:fs/promises');
+var node_crypto = require('node:crypto');
 var node_module = require('node:module');
 var node_os = require('node:os');
 var node_path = require('node:path');
@@ -124,6 +125,19 @@ async function ensureDirectory(directoryPath) {
         throw new ArchiveError('ERR_ARCHIVE_PATH', `Destination path is not a real directory: ${directoryPath}`);
     }
 }
+async function assertReplaceableOutput(filePath) {
+    try {
+        const details = await promises$1.lstat(filePath);
+        if (!details.isFile()) {
+            throw new ArchiveError('ERR_ARCHIVE_PATH', `Cannot replace a non-file extraction target: ${filePath}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof ArchiveError || error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+}
 async function ensureExtractionRoot(root) {
     try {
         const details = await promises$1.lstat(root);
@@ -365,6 +379,12 @@ class Archive {
         if (!options || typeof options !== 'object') {
             throw new TypeError('Folder extraction options must be an object');
         }
+        if (options.overwrite !== undefined && typeof options.overwrite !== 'boolean') {
+            throw new TypeError('Folder extraction overwrite option must be a boolean');
+        }
+        if (options.onProgress !== undefined && typeof options.onProgress !== 'function') {
+            throw new TypeError('Folder extraction onProgress option must be a function');
+        }
         options.signal?.throwIfAborted();
         const maxBytes = normalizeMaxBytes(options.maxBytes, 'maxBytes');
         const entries = await this.entries();
@@ -410,6 +430,26 @@ class Archive {
         options.signal?.throwIfAborted();
         await ensureExtractionRoot(root);
         let extractedBytes = 0n;
+        let filesExtracted = 0;
+        const totalFiles = plans.filter(plan => !plan.isDirectory).length;
+        const reportProgress = () => {
+            let percent = 0;
+            if (expectedBytes > 0n) {
+                const scaledPercent = extractedBytes * 10000n / expectedBytes;
+                percent = Number(scaledPercent > 9900n ? 9900n : scaledPercent) / 100;
+            }
+            if (filesExtracted === totalFiles) {
+                percent = 100;
+            }
+            options.onProgress?.({
+                filesExtracted,
+                totalFiles,
+                bytesProcessed: extractedBytes,
+                totalBytes: expectedBytes,
+                percent,
+            });
+        };
+        reportProgress();
         for (const plan of plans) {
             options.signal?.throwIfAborted();
             if (plan.isDirectory) {
@@ -417,7 +457,6 @@ class Archive {
                 continue;
             }
             await ensureOutputParents(root, plan.targetPath);
-            const output = node_fs.createWriteStream(plan.targetPath, { flags: 'wx', mode: 0o600 });
             const limit = new node_stream.Transform({
                 transform(chunk, _encoding, callback) {
                     const size = BigInt(chunk.length);
@@ -426,13 +465,40 @@ class Archive {
                         return;
                     }
                     extractedBytes += size;
+                    try {
+                        reportProgress();
+                    }
+                    catch (error) {
+                        callback(error instanceof Error ? error : new Error(String(error)));
+                        return;
+                    }
                     callback(null, chunk);
                 },
             });
-            await promises.pipeline(this.createReadStream(plan.entry.id, {
-                signal: options.signal,
-                maxBytes: null,
-            }), limit, output, { signal: options.signal });
+            if (options.overwrite) {
+                await assertReplaceableOutput(plan.targetPath);
+                const temporaryPath = node_path.join(node_path.dirname(plan.targetPath), `.7zip-native-${node_crypto.randomUUID()}.tmp`);
+                try {
+                    await promises.pipeline(this.createReadStream(plan.entry.id, {
+                        signal: options.signal,
+                        maxBytes: null,
+                    }), limit, node_fs.createWriteStream(temporaryPath, { flags: 'wx', mode: 0o600 }), { signal: options.signal });
+                    await assertReplaceableOutput(plan.targetPath);
+                    await promises$1.rename(temporaryPath, plan.targetPath);
+                }
+                catch (error) {
+                    await promises$1.rm(temporaryPath, { force: true });
+                    throw error;
+                }
+            }
+            else {
+                await promises.pipeline(this.createReadStream(plan.entry.id, {
+                    signal: options.signal,
+                    maxBytes: null,
+                }), limit, node_fs.createWriteStream(plan.targetPath, { flags: 'wx', mode: 0o600 }), { signal: options.signal });
+            }
+            filesExtracted++;
+            reportProgress();
         }
     }
     async read(idOrPath, options) {

package/dist/index.d.cts

@@ -19,6 +19,13 @@ interface ReadOptions {
 interface OpenOptions {
     readonly password?: string;
 }
+interface ExtractToFolderProgress {
+    readonly filesExtracted: number;
+    readonly totalFiles: number;
+    readonly bytesProcessed: bigint;
+    readonly totalBytes: bigint;
+    readonly percent: number;
+}
 interface ReadStreamOptions {
     readonly highWaterMark?: number;
     readonly maxBytes?: number | bigint | null;
@@ -27,6 +34,8 @@ interface ReadStreamOptions {
 interface ExtractToFolderOptions {
     readonly ids?: readonly EntryId[];
     readonly paths?: readonly string[];
+    readonly overwrite?: boolean;
+    readonly onProgress?: (progress: ExtractToFolderProgress) => void;
     readonly maxBytes?: number | bigint | null;
     readonly signal?: AbortSignal;
 }
@@ -60,4 +69,4 @@ declare class Archive {
 }
 
 export { Archive, ArchiveError };
-export type { ArchiveEntry, ArchiveErrorCode, EntryId, EntrySelector, ExtractToFolderOptions, OpenOptions, ReadOptions, ReadStreamOptions };
+export type { ArchiveEntry, ArchiveErrorCode, EntryId, EntrySelector, ExtractToFolderOptions, ExtractToFolderProgress, OpenOptions, ReadOptions, ReadStreamOptions };

package/dist/index.d.mts

@@ -19,6 +19,13 @@ interface ReadOptions {
 interface OpenOptions {
     readonly password?: string;
 }
+interface ExtractToFolderProgress {
+    readonly filesExtracted: number;
+    readonly totalFiles: number;
+    readonly bytesProcessed: bigint;
+    readonly totalBytes: bigint;
+    readonly percent: number;
+}
 interface ReadStreamOptions {
     readonly highWaterMark?: number;
     readonly maxBytes?: number | bigint | null;
@@ -27,6 +34,8 @@ interface ReadStreamOptions {
 interface ExtractToFolderOptions {
     readonly ids?: readonly EntryId[];
     readonly paths?: readonly string[];
+    readonly overwrite?: boolean;
+    readonly onProgress?: (progress: ExtractToFolderProgress) => void;
     readonly maxBytes?: number | bigint | null;
     readonly signal?: AbortSignal;
 }
@@ -60,4 +69,4 @@ declare class Archive {
 }
 
 export { Archive, ArchiveError };
-export type { ArchiveEntry, ArchiveErrorCode, EntryId, EntrySelector, ExtractToFolderOptions, OpenOptions, ReadOptions, ReadStreamOptions };
+export type { ArchiveEntry, ArchiveErrorCode, EntryId, EntrySelector, ExtractToFolderOptions, ExtractToFolderProgress, OpenOptions, ReadOptions, ReadStreamOptions };

package/dist/index.d.ts

@@ -19,6 +19,13 @@ interface ReadOptions {
 interface OpenOptions {
     readonly password?: string;
 }
+interface ExtractToFolderProgress {
+    readonly filesExtracted: number;
+    readonly totalFiles: number;
+    readonly bytesProcessed: bigint;
+    readonly totalBytes: bigint;
+    readonly percent: number;
+}
 interface ReadStreamOptions {
     readonly highWaterMark?: number;
     readonly maxBytes?: number | bigint | null;
@@ -27,6 +34,8 @@ interface ReadStreamOptions {
 interface ExtractToFolderOptions {
     readonly ids?: readonly EntryId[];
     readonly paths?: readonly string[];
+    readonly overwrite?: boolean;
+    readonly onProgress?: (progress: ExtractToFolderProgress) => void;
     readonly maxBytes?: number | bigint | null;
     readonly signal?: AbortSignal;
 }
@@ -60,4 +69,4 @@ declare class Archive {
 }
 
 export { Archive, ArchiveError };
-export type { ArchiveEntry, ArchiveErrorCode, EntryId, EntrySelector, ExtractToFolderOptions, OpenOptions, ReadOptions, ReadStreamOptions };
+export type { ArchiveEntry, ArchiveErrorCode, EntryId, EntrySelector, ExtractToFolderOptions, ExtractToFolderProgress, OpenOptions, ReadOptions, ReadStreamOptions };

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import { existsSync, createWriteStream } from 'node:fs';
-import { lstat, mkdir } from 'node:fs/promises';
+import { rename, rm, lstat, mkdir } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { availableParallelism } from 'node:os';
 import { dirname, resolve, join, relative, sep } from 'node:path';
@@ -121,6 +122,19 @@ async function ensureDirectory(directoryPath) {
         throw new ArchiveError('ERR_ARCHIVE_PATH', `Destination path is not a real directory: ${directoryPath}`);
     }
 }
+async function assertReplaceableOutput(filePath) {
+    try {
+        const details = await lstat(filePath);
+        if (!details.isFile()) {
+            throw new ArchiveError('ERR_ARCHIVE_PATH', `Cannot replace a non-file extraction target: ${filePath}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof ArchiveError || error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+}
 async function ensureExtractionRoot(root) {
     try {
         const details = await lstat(root);
@@ -362,6 +376,12 @@ class Archive {
         if (!options || typeof options !== 'object') {
             throw new TypeError('Folder extraction options must be an object');
         }
+        if (options.overwrite !== undefined && typeof options.overwrite !== 'boolean') {
+            throw new TypeError('Folder extraction overwrite option must be a boolean');
+        }
+        if (options.onProgress !== undefined && typeof options.onProgress !== 'function') {
+            throw new TypeError('Folder extraction onProgress option must be a function');
+        }
         options.signal?.throwIfAborted();
         const maxBytes = normalizeMaxBytes(options.maxBytes, 'maxBytes');
         const entries = await this.entries();
@@ -407,6 +427,26 @@ class Archive {
         options.signal?.throwIfAborted();
         await ensureExtractionRoot(root);
         let extractedBytes = 0n;
+        let filesExtracted = 0;
+        const totalFiles = plans.filter(plan => !plan.isDirectory).length;
+        const reportProgress = () => {
+            let percent = 0;
+            if (expectedBytes > 0n) {
+                const scaledPercent = extractedBytes * 10000n / expectedBytes;
+                percent = Number(scaledPercent > 9900n ? 9900n : scaledPercent) / 100;
+            }
+            if (filesExtracted === totalFiles) {
+                percent = 100;
+            }
+            options.onProgress?.({
+                filesExtracted,
+                totalFiles,
+                bytesProcessed: extractedBytes,
+                totalBytes: expectedBytes,
+                percent,
+            });
+        };
+        reportProgress();
         for (const plan of plans) {
             options.signal?.throwIfAborted();
             if (plan.isDirectory) {
@@ -414,7 +454,6 @@ class Archive {
                 continue;
             }
             await ensureOutputParents(root, plan.targetPath);
-            const output = createWriteStream(plan.targetPath, { flags: 'wx', mode: 0o600 });
             const limit = new Transform({
                 transform(chunk, _encoding, callback) {
                     const size = BigInt(chunk.length);
@@ -423,13 +462,40 @@ class Archive {
                         return;
                     }
                     extractedBytes += size;
+                    try {
+                        reportProgress();
+                    }
+                    catch (error) {
+                        callback(error instanceof Error ? error : new Error(String(error)));
+                        return;
+                    }
                     callback(null, chunk);
                 },
             });
-            await pipeline(this.createReadStream(plan.entry.id, {
-                signal: options.signal,
-                maxBytes: null,
-            }), limit, output, { signal: options.signal });
+            if (options.overwrite) {
+                await assertReplaceableOutput(plan.targetPath);
+                const temporaryPath = join(dirname(plan.targetPath), `.7zip-native-${randomUUID()}.tmp`);
+                try {
+                    await pipeline(this.createReadStream(plan.entry.id, {
+                        signal: options.signal,
+                        maxBytes: null,
+                    }), limit, createWriteStream(temporaryPath, { flags: 'wx', mode: 0o600 }), { signal: options.signal });
+                    await assertReplaceableOutput(plan.targetPath);
+                    await rename(temporaryPath, plan.targetPath);
+                }
+                catch (error) {
+                    await rm(temporaryPath, { force: true });
+                    throw error;
+                }
+            }
+            else {
+                await pipeline(this.createReadStream(plan.entry.id, {
+                    signal: options.signal,
+                    maxBytes: null,
+                }), limit, createWriteStream(plan.targetPath, { flags: 'wx', mode: 0o600 }), { signal: options.signal });
+            }
+            filesExtracted++;
+            reportProgress();
         }
     }
     async read(idOrPath, options) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "7zip-native",
-	"version": "0.0.5",
+	"version": "0.0.6",
 	"description": "Native 7zip bindings for Node.js",
 	"main": "./dist/index.cjs",
 	"type": "module",
@@ -30,6 +30,7 @@
 		"dist/",
 		"prebuilds/",
 		"native/",
+		"scripts/",
 		"vendor/7zip/",
 		"binding.gyp",
 		"README.md",
@@ -48,6 +49,7 @@
 		"url": "https://github.com/sponsors/ollm"
 	},
 	"scripts": {
+		"install": "node scripts/verify-prebuild.mjs",
 		"prepare": "npm run build && node scripts/clean-upstream-build.mjs",
 		"build": "npm run build:native && npm run eslint && npx rollup -c && npm run typecheck",
 		"build:native": "node scripts/build-native.mjs",

package/scripts/build-native.mjs

@@ -0,0 +1,119 @@
+import {spawn} from 'node:child_process';
+import { copyFile, mkdir, rm } from 'node:fs/promises';
+import {createRequire} from 'node:module';
+import {availableParallelism} from 'node:os';
+import { join, resolve } from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const root = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const bundleDirectory = join(root, 'vendor', '7zip', 'CPP', '7zip', 'Bundles', 'Format7zF');
+const releaseDirectory = join(root, 'build', 'Release');
+const targetArch = process.env.BUILD_ARCH || process.arch;
+const target = `${process.platform}-${targetArch}`;
+const engineName = process.platform === 'win32'
+	? '7z.dll'
+	: process.platform === 'darwin' ? 'lib7z.dylib' : '7z.so';
+const require = createRequire(import.meta.url);
+
+function run(command, args, cwd, env = process.env)
+{
+	return new Promise((resolvePromise, rejectPromise) => {
+		const child = spawn(command, args, {cwd, env, stdio: 'inherit'});
+		child.once('error', rejectPromise);
+		child.once('close', (code, signal) => {
+			if(code === 0)
+			{
+				resolvePromise();
+			}
+			else
+			{
+				rejectPromise(new Error(`${command} exited with ${signal ?? code}`));
+			}
+		});
+	});
+}
+
+if(process.platform === 'win32')
+{
+	const upstreamArch = targetArch === 'ia32' ? 'x86' : targetArch;
+	await run('nmake', ['/f', 'makefile', `PLATFORM=${upstreamArch}`], bundleDirectory);
+}
+else
+{
+	const args = [
+		'-C',
+		bundleDirectory,
+		'-f',
+		'makefile.gcc',
+		`-j${process.env.BUILD_JOBS ?? Math.min(availableParallelism(), 2)}`,
+	];
+	const buildEnv = {...process.env};
+	if(targetArch === 'ia32')
+	{
+		args.push('MY_ARCH=-m32', 'CC=gcc', 'CXX=g++');
+		buildEnv.CXXFLAGS = `${buildEnv.CXXFLAGS ?? ''} -m32`.trim();
+		buildEnv.LDFLAGS = `${buildEnv.LDFLAGS ?? ''} -m32`.trim();
+	}
+	else if(targetArch === 'arm')
+	{
+		const compilerPrefix = 'arm-linux-gnueabihf-';
+		args.push(
+			`CC=${compilerPrefix}gcc`,
+			`CXX=${compilerPrefix}g++`,
+			'MY_ARCH=-march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=hard',
+		);
+		buildEnv.CC = `${compilerPrefix}gcc`;
+		buildEnv.CXX = `${compilerPrefix}g++`;
+		buildEnv.CXXFLAGS = `${buildEnv.CXXFLAGS ?? ''} -march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=hard`.trim();
+		buildEnv.LDFLAGS = `${buildEnv.LDFLAGS ?? ''} -march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=hard`.trim();
+	}
+	if(process.platform === 'darwin')
+	{
+		args.push(
+			'LIB2=-lpthread',
+			'PROG=lib7z',
+			'SHARED_EXT=.dylib',
+			'LDFLAGS=-shared -fPIC -Wl,-install_name,@rpath/lib7z.dylib',
+		);
+	}
+	await run('make', args, root, buildEnv);
+}
+
+const upstreamEnginePath = process.platform === 'win32'
+	? join(bundleDirectory, targetArch === 'ia32' ? 'x86' : targetArch, engineName)
+	: join(bundleDirectory, '_o', engineName);
+const nodeGypArgs = [
+	require.resolve('node-gyp/bin/node-gyp.js'),
+	'rebuild',
+];
+const nodeGypEnv = {...process.env};
+if(targetArch !== process.arch)
+{
+	nodeGypArgs.push(`--arch=${targetArch}`);
+	if(targetArch === 'ia32')
+	{
+		nodeGypEnv.CC = 'gcc';
+		nodeGypEnv.CXX = 'g++';
+		nodeGypEnv.CXXFLAGS = `${nodeGypEnv.CXXFLAGS ?? ''} -m32`.trim();
+		nodeGypEnv.LDFLAGS = `${nodeGypEnv.LDFLAGS ?? ''} -m32`.trim();
+	}
+	else if(targetArch === 'arm')
+	{
+		nodeGypEnv.CC = 'arm-linux-gnueabihf-gcc';
+		nodeGypEnv.CXX = 'arm-linux-gnueabihf-g++';
+		nodeGypEnv.CXXFLAGS = `${nodeGypEnv.CXXFLAGS ?? ''} -march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=hard`.trim();
+		nodeGypEnv.LDFLAGS = `${nodeGypEnv.LDFLAGS ?? ''} -march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=hard`.trim();
+	}
+}
+await run(process.execPath, nodeGypArgs, root, nodeGypEnv);
+
+await mkdir(releaseDirectory, {recursive: true});
+const releaseEnginePath = join(releaseDirectory, engineName);
+await copyFile(upstreamEnginePath, releaseEnginePath);
+const prebuildDirectory = join(root, 'prebuilds', target);
+await rm(prebuildDirectory, {recursive: true, force: true});
+await mkdir(prebuildDirectory, {recursive: true});
+await Promise.all([
+	copyFile(join(releaseDirectory, '7zip_native.node'), join(prebuildDirectory, '7zip_native.node')),
+	copyFile(releaseEnginePath, join(prebuildDirectory, engineName)),
+]);

package/scripts/clean-upstream-build.mjs

@@ -0,0 +1,9 @@
+import {rm} from 'node:fs/promises';
+import {fileURLToPath} from 'node:url';
+
+const upstreamBuildDirectory = new URL(
+	'../vendor/7zip/CPP/7zip/Bundles/Format7zF/_o/',
+	import.meta.url,
+);
+
+await rm(fileURLToPath(upstreamBuildDirectory), {recursive: true, force: true});

package/scripts/verify-prebuild.mjs

@@ -0,0 +1,29 @@
+import {existsSync} from 'node:fs';
+import {dirname, join} from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const packageDirectory = dirname(fileURLToPath(import.meta.url));
+const target = `${process.platform}-${process.arch}`;
+const engineName = process.platform === 'win32'
+	? '7z.dll'
+	: process.platform === 'darwin' ? 'lib7z.dylib' : '7z.so';
+const runtimeDirectories = [
+	join(packageDirectory, `../prebuilds/${target}`),
+	join(packageDirectory, '../build/Release'),
+];
+
+if(runtimeDirectories.some(directory =>
+	existsSync(join(directory, '7zip_native.node')) && existsSync(join(directory, engineName))))
+{
+	process.exit(0);
+}
+
+if(existsSync(join(packageDirectory, '../.git')))
+{
+	process.exit(0);
+}
+
+throw new Error(
+	`No prebuilt 7zip-native binaries are available for ${target}. `
+	+ 'Check the supported platforms in the package README.',
+);