7zip-native 0.0.0-stage → 0.0.1

package/native/addon.cpp

@@ -0,0 +1,2154 @@
+#include <napi.h>
+
+#include <algorithm>
+#include <atomic>
+#include <cctype>
+#include <cmath>
+#include <codecvt>
+#include <condition_variable>
+#include <cstdint>
+#include <cstring>
+#include <cwctype>
+#include <deque>
+#include <filesystem>
+#include <fstream>
+#include <limits>
+#include <locale>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#ifndef _WIN32
+#include <dlfcn.h>
+#endif
+
+#include "Common/MyInitGuid.h"
+#include "Common/MyCom.h"
+#include "Common/StringConvert.h"
+#include "7zip/Archive/IArchive.h"
+#include "7zip/IPassword.h"
+#include "Windows/PropVariant.h"
+
+namespace {
+
+constexpr std::uint64_t kMaxPendingOperations = 128;
+constexpr std::uint32_t kMaxExtractionConcurrency = 128;
+constexpr std::uint64_t kMaxEntries = 1'000'000;
+constexpr std::uint64_t kMaxSingleOutputBytes = 256ULL * 1024 * 1024;
+constexpr std::uint64_t kMaxConcurrentOutputBytes = 512ULL * 1024 * 1024;
+constexpr std::uint64_t kMaxReadBytes = 64ULL * 1024 * 1024;
+constexpr std::size_t kMaxPasswordBytes = 1024 * 1024;
+
+using CreateObjectFunction = HRESULT (STDAPICALLTYPE *)(const GUID *, const GUID *, void **);
+using GetHandlerPropertyFunction = HRESULT (STDAPICALLTYPE *)(UInt32, PROPID, PROPVARIANT *);
+using GetNumberOfFormatsFunction = HRESULT (STDAPICALLTYPE *)(UInt32 *);
+using GetIsArcFunction = HRESULT (STDAPICALLTYPE *)(UInt32, Func_IsArc *);
+
+std::wstring FromUtf8(const std::string& value);
+
+#ifdef _WIN32
+using EngineModule = HMODULE;
+#else
+using EngineModule = void *;
+#endif
+
+std::atomic<std::uint64_t> g_pendingOperations{0};
+std::atomic<std::uint32_t> g_extractionConcurrency{1};
+std::atomic<std::uint64_t> g_nextHandle{1};
+std::atomic<std::uint64_t> g_nextStreamId{1};
+std::mutex g_handlesMutex;
+std::unordered_map<std::uint64_t, std::shared_ptr<class ArchiveEngine>> g_handles;
+std::mutex g_streamsMutex;
+std::unordered_map<std::uint64_t, std::shared_ptr<class NativeStreamState>> g_streams;
+std::mutex g_outputBudgetMutex;
+std::condition_variable g_outputBudgetAvailable;
+std::uint64_t g_reservedOutputBytes = 0;
+std::mutex g_engineMutex;
+EngineModule g_engineModule = nullptr;
+std::string g_enginePath;
+CreateObjectFunction g_createObject = nullptr;
+GetHandlerPropertyFunction g_getHandlerProperty = nullptr;
+GetNumberOfFormatsFunction g_getNumberOfFormats = nullptr;
+GetIsArcFunction g_getIsArc = nullptr;
+class ExtractionPool;
+ExtractionPool *g_extractionPool = nullptr;
+
+template<typename Function>
+Function LoadEngineFunction(const char *name)
+{
+#ifdef _WIN32
+	return reinterpret_cast<Function>(::GetProcAddress(g_engineModule, name));
+#else
+	return reinterpret_cast<Function>(::dlsym(g_engineModule, name));
+#endif
+}
+
+std::uint64_t RegisterStream(std::shared_ptr<class NativeStreamState> stream);
+std::shared_ptr<class NativeStreamState> FindStream(std::uint64_t streamId);
+void RemoveStream(std::uint64_t streamId);
+
+void EnsureEngineLoaded(const std::string& path)
+{
+	std::lock_guard<std::mutex> lock(g_engineMutex);
+	if (g_engineModule != nullptr) {
+		if (g_enginePath != path) {
+			throw std::runtime_error("Only one 7-Zip engine path can be loaded per process");
+		}
+		return;
+	}
+#ifdef _WIN32
+	const auto widePath = FromUtf8(path);
+	g_engineModule = ::LoadLibraryW(widePath.c_str());
+	if (g_engineModule == nullptr) {
+		throw std::runtime_error("Unable to load the bundled 7-Zip engine DLL");
+	}
+#else
+	g_engineModule = ::dlopen(path.c_str(), RTLD_NOW | RTLD_LOCAL);
+	if (g_engineModule == nullptr) {
+		const auto *error = ::dlerror();
+		throw std::runtime_error(
+			std::string("Unable to load the bundled 7-Zip engine: ")
+			+ (error == nullptr ? "unknown loader error" : error));
+	}
+#endif
+	g_createObject = LoadEngineFunction<CreateObjectFunction>("CreateObject");
+	g_getHandlerProperty = LoadEngineFunction<GetHandlerPropertyFunction>("GetHandlerProperty2");
+	g_getNumberOfFormats = LoadEngineFunction<GetNumberOfFormatsFunction>("GetNumberOfFormats");
+	g_getIsArc = LoadEngineFunction<GetIsArcFunction>("GetIsArc");
+	if (g_createObject == nullptr || g_getHandlerProperty == nullptr
+		|| g_getNumberOfFormats == nullptr || g_getIsArc == nullptr) {
+#ifdef _WIN32
+		::FreeLibrary(g_engineModule);
+#else
+		::dlclose(g_engineModule);
+#endif
+		g_engineModule = nullptr;
+		g_createObject = nullptr;
+		g_getHandlerProperty = nullptr;
+		g_getNumberOfFormats = nullptr;
+		g_getIsArc = nullptr;
+		throw std::runtime_error("The bundled 7-Zip engine is missing required exports");
+	}
+	g_enginePath = path;
+}
+
+bool ReserveOperation()
+{
+	auto pending = g_pendingOperations.load(std::memory_order_relaxed);
+	while (pending < kMaxPendingOperations) {
+		if (g_pendingOperations.compare_exchange_weak(
+			pending, pending + 1, std::memory_order_acq_rel, std::memory_order_relaxed)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+std::wstring FromUtf8(const std::string& value)
+{
+#ifdef _WIN32
+	std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
+#else
+	std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
+#endif
+	return converter.from_bytes(value);
+}
+
+template<typename Character>
+void SecureErase(std::basic_string<Character>& value) noexcept
+{
+	volatile Character *characters = value.empty() ? nullptr : value.data();
+	for (std::size_t i = 0; i < value.size(); ++i) {
+		characters[i] = Character{};
+	}
+	value.clear();
+}
+
+std::filesystem::path NativePath(const std::string& path)
+{
+#ifdef _WIN32
+	return std::filesystem::path(FromUtf8(path));
+#else
+	return std::filesystem::path(path);
+#endif
+}
+
+struct FileStamp {
+	std::uintmax_t size;
+	std::filesystem::file_time_type modified;
+};
+
+struct StreamMessage {
+	enum class Kind {
+		Chunk,
+		End,
+		Error
+	};
+
+	Kind kind;
+	std::vector<std::uint8_t> data;
+	std::string error;
+};
+
+void StreamMessageToJs(Napi::Env env, Napi::Function callback, StreamMessage *message);
+
+class NativeStreamState {
+public:
+	void Resume()
+	{
+		{
+			std::lock_guard<std::mutex> lock(mutex_);
+			if (!cancelled_) {
+				demand_ = true;
+			}
+		}
+		available_.notify_one();
+	}
+
+	void Cancel()
+	{
+		{
+			std::lock_guard<std::mutex> lock(mutex_);
+			cancelled_ = true;
+		}
+		available_.notify_all();
+	}
+
+	bool IsCancelled() const
+	{
+		std::lock_guard<std::mutex> lock(mutex_);
+		return cancelled_;
+	}
+
+	bool WaitForDemand()
+	{
+		std::unique_lock<std::mutex> lock(mutex_);
+		available_.wait(lock, [this]() { return cancelled_ || demand_; });
+		if (cancelled_) {
+			return false;
+		}
+		demand_ = false;
+		return true;
+	}
+
+	bool Send(std::unique_ptr<StreamMessage> message)
+	{
+		const auto status = callback.BlockingCall(message.get(), StreamMessageToJs);
+		if (status != napi_ok) {
+			Cancel();
+			return false;
+		}
+		message.release();
+		return true;
+	}
+
+	void ReleaseCallback()
+	{
+		if (!callbackReleased_.exchange(true, std::memory_order_acq_rel)) {
+			callback.Release();
+		}
+	}
+
+	std::uint64_t id = 0;
+	Napi::ThreadSafeFunction callback;
+
+private:
+	mutable std::mutex mutex_;
+	std::condition_variable available_;
+	bool cancelled_ = false;
+	bool demand_ = false;
+	std::atomic<bool> callbackReleased_{false};
+};
+
+std::uint64_t RegisterStream(std::shared_ptr<NativeStreamState> stream)
+{
+	const auto streamId = g_nextStreamId.fetch_add(1, std::memory_order_relaxed);
+	if (streamId == 0) {
+		throw std::overflow_error("Native stream handle space exhausted");
+	}
+	std::lock_guard<std::mutex> lock(g_streamsMutex);
+	stream->id = streamId;
+	g_streams.emplace(streamId, std::move(stream));
+	return streamId;
+}
+
+std::shared_ptr<NativeStreamState> FindStream(std::uint64_t streamId)
+{
+	std::lock_guard<std::mutex> lock(g_streamsMutex);
+	const auto found = g_streams.find(streamId);
+	return found == g_streams.end() ? nullptr : found->second;
+}
+
+void RemoveStream(std::uint64_t streamId)
+{
+	std::lock_guard<std::mutex> lock(g_streamsMutex);
+	g_streams.erase(streamId);
+}
+
+FileStamp GetFileStamp(const std::string& path)
+{
+	std::error_code error;
+	const auto size = std::filesystem::file_size(NativePath(path), error);
+	if (error) {
+		throw std::runtime_error("Unable to read archive file size");
+	}
+	const auto modified = std::filesystem::last_write_time(NativePath(path), error);
+	if (error) {
+		throw std::runtime_error("Unable to read archive modification time");
+	}
+	return {size, modified};
+}
+
+class OutputReservation {
+public:
+	~OutputReservation()
+	{
+		if (reserved_ == 0) {
+			return;
+		}
+		{
+			std::lock_guard<std::mutex> lock(g_outputBudgetMutex);
+			g_reservedOutputBytes -= reserved_;
+		}
+		g_outputBudgetAvailable.notify_all();
+	}
+
+	void Acquire(std::uint64_t bytes)
+	{
+		if (bytes > kMaxConcurrentOutputBytes) {
+			throw std::length_error("Requested output exceeds the concurrent memory limit");
+		}
+		if (bytes == 0) {
+			return;
+		}
+		std::unique_lock<std::mutex> lock(g_outputBudgetMutex);
+		g_outputBudgetAvailable.wait(lock, [bytes]() {
+			return bytes <= kMaxConcurrentOutputBytes - g_reservedOutputBytes;
+		});
+		g_reservedOutputBytes += bytes;
+		reserved_ = bytes;
+	}
+
+private:
+	std::uint64_t reserved_ = 0;
+};
+
+HRESULT GetPasswordBstr(const std::optional<std::string>& password, BSTR *result)
+{
+	if (result == nullptr) {
+		return E_INVALIDARG;
+	}
+	*result = nullptr;
+	if (!password) {
+		return E_ABORT;
+	}
+	std::wstring widePassword;
+	try {
+		widePassword = FromUtf8(*password);
+	} catch (...) {
+		return E_INVALIDARG;
+	}
+	struct WipeOnExit {
+		std::wstring& value;
+		~WipeOnExit() { SecureErase(value); }
+	} wipe{widePassword};
+	if (widePassword.size() > std::numeric_limits<UINT>::max()) {
+		return E_INVALIDARG;
+	}
+	*result = ::SysAllocStringLen(
+		widePassword.data(),
+		static_cast<UINT>(widePassword.size()));
+	return *result == nullptr ? E_OUTOFMEMORY : S_OK;
+}
+
+std::string ToUtf8(const wchar_t *value)
+{
+	if (value == nullptr) {
+		return {};
+	}
+#ifdef _WIN32
+	std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
+#else
+	std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
+#endif
+	return converter.to_bytes(value);
+}
+
+std::string LowerAscii(std::string value)
+{
+	std::transform(value.begin(), value.end(), value.begin(), [](unsigned char ch) {
+		return static_cast<char>(std::tolower(ch));
+	});
+	return value;
+}
+
+std::string Extension(const std::string& path)
+{
+	const auto separator = path.find_last_of("/\\");
+	const auto dot = path.find_last_of('.');
+	if (dot == std::string::npos || (separator != std::string::npos && dot < separator)) {
+		return {};
+	}
+	return LowerAscii(path.substr(dot + 1));
+}
+
+std::vector<std::string> SplitExtensions(const std::wstring& value)
+{
+	std::wstring normalized = value;
+	for (auto& ch : normalized) {
+		if (ch == L';' || ch == L',' || ch == L'*' || ch == L'.') {
+			ch = L' ';
+		}
+	}
+	std::vector<std::string> result;
+	std::wstring token;
+	for (const auto ch : normalized) {
+		if (std::iswspace(ch)) {
+			if (!token.empty()) {
+				result.push_back(LowerAscii(ToUtf8(token.c_str())));
+				token.clear();
+			}
+		} else {
+			token.push_back(ch);
+		}
+	}
+	if (!token.empty()) {
+		result.push_back(LowerAscii(ToUtf8(token.c_str())));
+	}
+	return result;
+}
+
+bool ReadUnsigned(const Napi::Value& value, std::uint64_t& result)
+{
+	if (value.IsBigInt()) {
+		bool lossless = false;
+		result = value.As<Napi::BigInt>().Uint64Value(&lossless);
+		return lossless;
+	}
+	if (!value.IsNumber()) {
+		return false;
+	}
+	const double number = value.As<Napi::Number>().DoubleValue();
+	if (!std::isfinite(number) || number < 0 || std::floor(number) != number
+		|| number > 9007199254740991.0) {
+		return false;
+	}
+	result = static_cast<std::uint64_t>(number);
+	return true;
+}
+
+std::uint64_t GetHandle(const Napi::Value& value)
+{
+	std::uint64_t handle = 0;
+	if (!ReadUnsigned(value, handle) || handle == 0) {
+		throw Napi::TypeError::New(value.Env(), "Invalid archive handle");
+	}
+	return handle;
+}
+
+std::shared_ptr<class ArchiveEngine> FindArchive(std::uint64_t handle)
+{
+	std::lock_guard<std::mutex> lock(g_handlesMutex);
+	const auto found = g_handles.find(handle);
+	if (found == g_handles.end()) {
+		return {};
+	}
+	return found->second;
+}
+
+std::uint64_t RegisterArchive(std::shared_ptr<class ArchiveEngine> archive)
+{
+	const auto handle = g_nextHandle.fetch_add(1, std::memory_order_relaxed);
+	if (handle == 0) {
+		throw std::runtime_error("Archive handle space exhausted");
+	}
+	std::lock_guard<std::mutex> lock(g_handlesMutex);
+	g_handles.emplace(handle, std::move(archive));
+	return handle;
+}
+
+struct Entry {
+	std::uint32_t id = 0;
+	std::string path;
+	std::uint64_t size = 0;
+	std::uint64_t compressedSize = 0;
+	std::uint32_t attributes = 0;
+	std::uint32_t crc = 0;
+	bool hasCrc = false;
+	bool directory = false;
+	bool encrypted = false;
+};
+
+std::uint64_t GetPropUInt64(IInArchive *archive, std::uint32_t index, PROPID propId)
+{
+	NWindows::NCOM::CPropVariant value;
+	if (archive->GetProperty(index, propId, &value) != S_OK) {
+		return 0;
+	}
+	if (value.vt == VT_UI8) {
+		return value.uhVal.QuadPart;
+	}
+	if (value.vt == VT_UI4) {
+		return value.ulVal;
+	}
+	if (value.vt == VT_I8 && value.hVal.QuadPart >= 0) {
+		return static_cast<std::uint64_t>(value.hVal.QuadPart);
+	}
+	if (value.vt == VT_I4 && value.lVal >= 0) {
+		return static_cast<std::uint64_t>(value.lVal);
+	}
+	return 0;
+}
+
+bool GetPropBool(IInArchive *archive, std::uint32_t index, PROPID propId)
+{
+	NWindows::NCOM::CPropVariant value;
+	if (archive->GetProperty(index, propId, &value) != S_OK || value.vt != VT_BOOL) {
+		return false;
+	}
+	return value.boolVal != VARIANT_FALSE;
+}
+
+std::string GetPropString(IInArchive *archive, std::uint32_t index, PROPID propId)
+{
+	NWindows::NCOM::CPropVariant value;
+	if (archive->GetProperty(index, propId, &value) != S_OK || value.vt != VT_BSTR) {
+		return {};
+	}
+	return ToUtf8(value.bstrVal);
+}
+
+struct OutputRequest {
+	std::uint32_t id = 0;
+	std::uint64_t offset = 0;
+	std::uint64_t length = 0;
+	std::uint64_t entrySize = 0;
+	bool encrypted = false;
+	std::vector<std::uint8_t> data;
+	std::int32_t operationResult = NArchive::NExtract::NOperationResult::kUnavailable;
+};
+
+class FileInStream final : public IInStream, public CMyUnknownImp {
+	Z7_COM_QI_BEGIN2(IInStream)
+	Z7_COM_QI_ENTRY(ISequentialInStream)
+	Z7_COM_QI_END
+	Z7_COM_ADDREF_RELEASE
+
+	Z7_IFACE_COM7_IMP(ISequentialInStream)
+	Z7_IFACE_COM7_IMP(IInStream)
+
+public:
+	bool Open(const std::string& path)
+	{
+		file_.open(NativePath(path), std::ios::binary);
+		if (!file_.is_open()) {
+			return false;
+		}
+		file_.seekg(0, std::ios::end);
+		const auto end = file_.tellg();
+		if (end < 0 || static_cast<std::uint64_t>(end) > static_cast<std::uint64_t>(INT64_MAX)) {
+			file_.close();
+			return false;
+		}
+		length_ = static_cast<std::uint64_t>(end);
+		file_.clear();
+		file_.seekg(0, std::ios::beg);
+		return file_.good();
+	}
+
+private:
+	std::mutex mutex_;
+	std::ifstream file_;
+	std::uint64_t length_ = 0;
+};
+
+Z7_COM7F_IMF(FileInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+	std::lock_guard<std::mutex> lock(mutex_);
+	file_.clear();
+	file_.read(static_cast<char *>(data), static_cast<std::streamsize>(size));
+	const auto count = file_.gcount();
+	if (processedSize != nullptr) {
+		*processedSize = static_cast<UInt32>(count);
+	}
+	if (file_.bad()) {
+		return E_FAIL;
+	}
+	return S_OK;
+}
+
+Z7_COM7F_IMF(FileInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+	std::lock_guard<std::mutex> lock(mutex_);
+	std::uint64_t base = 0;
+	switch (seekOrigin) {
+		case 0:
+			break;
+		case 1: {
+			file_.clear();
+			const auto current = file_.tellg();
+			if (current < 0) {
+				return E_FAIL;
+			}
+			base = static_cast<std::uint64_t>(current);
+			break;
+		}
+		case 2:
+			base = length_;
+			break;
+		default:
+			return E_INVALIDARG;
+	}
+	std::uint64_t target = 0;
+	if (offset >= 0) {
+		const auto advance = static_cast<std::uint64_t>(offset);
+		if (advance > static_cast<std::uint64_t>(INT64_MAX) - base) {
+			return E_INVALIDARG;
+		}
+		target = base + advance;
+	} else {
+		const auto retreat = static_cast<std::uint64_t>(-(offset + 1)) + 1;
+		if (retreat > base) {
+			return E_INVALIDARG;
+		}
+		target = base - retreat;
+	}
+	file_.clear();
+	file_.seekg(static_cast<std::streamoff>(target), std::ios::beg);
+	if (!file_.good()) {
+		return E_FAIL;
+	}
+	if (newPosition != nullptr) {
+		*newPosition = target;
+	}
+	return S_OK;
+}
+
+class ArchiveOpenCallback final :
+	public IArchiveOpenCallback,
+	public ICryptoGetTextPassword,
+	public CMyUnknownImp {
+	Z7_COM_QI_BEGIN2(IArchiveOpenCallback)
+	Z7_COM_QI_ENTRY(ICryptoGetTextPassword)
+	Z7_COM_QI_END
+	Z7_COM_ADDREF_RELEASE
+
+	Z7_IFACE_COM7_IMP(IArchiveOpenCallback)
+	Z7_IFACE_COM7_IMP(ICryptoGetTextPassword)
+
+public:
+	explicit ArchiveOpenCallback(const std::optional<std::string>& password)
+		: password_(password), passwordRequested_(false) {}
+
+	bool PasswordRequested() const
+	{
+		return passwordRequested_.load(std::memory_order_acquire);
+	}
+
+private:
+	const std::optional<std::string>& password_;
+	std::atomic<bool> passwordRequested_;
+};
+
+Z7_COM7F_IMF(ArchiveOpenCallback::SetTotal(const UInt64 *, const UInt64 *))
+{
+	return S_OK;
+}
+
+Z7_COM7F_IMF(ArchiveOpenCallback::SetCompleted(const UInt64 *, const UInt64 *))
+{
+	return S_OK;
+}
+
+Z7_COM7F_IMF(ArchiveOpenCallback::CryptoGetTextPassword(BSTR *password))
+{
+	passwordRequested_.store(true, std::memory_order_release);
+	return GetPasswordBstr(password_, password);
+}
+
+class VectorOutStream final : public ISequentialOutStream, public CMyUnknownImp {
+	Z7_COM_UNKNOWN_IMP_1(ISequentialOutStream)
+	Z7_COM7F_IMP(Write(const void *data, UInt32 size, UInt32 *processedSize))
+
+public:
+	explicit VectorOutStream(OutputRequest *request): request_(request), seen_(0) {}
+
+private:
+	OutputRequest *request_;
+	std::uint64_t seen_;
+};
+
+Z7_COM7F_IMF(VectorOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+	const auto start = seen_;
+	const auto end = start + size;
+	if (end < start) {
+		return E_FAIL;
+	}
+	const auto wantedStart = request_->offset;
+	const auto wantedEnd = wantedStart + request_->length;
+	const auto copyStart = std::max(start, wantedStart);
+	const auto copyEnd = std::min(end, wantedEnd);
+	if (copyEnd > copyStart) {
+		const auto count = copyEnd - copyStart;
+		if (count > kMaxSingleOutputBytes - request_->data.size()) {
+			return E_OUTOFMEMORY;
+		}
+		const auto *bytes = static_cast<const std::uint8_t *>(data);
+		request_->data.insert(
+			request_->data.end(),
+			bytes + static_cast<std::size_t>(copyStart - start),
+			bytes + static_cast<std::size_t>(copyEnd - start));
+	}
+	seen_ = end;
+	if (processedSize != nullptr) {
+		*processedSize = size;
+	}
+	return S_OK;
+}
+
+class ExtractCallback final :
+	public IArchiveExtractCallback,
+	public ICryptoGetTextPassword,
+	public CMyUnknownImp {
+	Z7_COM_QI_BEGIN2(IArchiveExtractCallback)
+	Z7_COM_QI_ENTRY(IProgress)
+	Z7_COM_QI_ENTRY(ICryptoGetTextPassword)
+	Z7_COM_QI_END
+	Z7_COM_ADDREF_RELEASE
+
+	Z7_IFACE_COM7_IMP(IProgress)
+	Z7_IFACE_COM7_IMP(IArchiveExtractCallback)
+	Z7_IFACE_COM7_IMP(ICryptoGetTextPassword)
+
+public:
+	ExtractCallback(
+		std::vector<OutputRequest>& requests,
+		const std::unordered_map<std::uint32_t, std::size_t>& requestById,
+		const std::optional<std::string>& password)
+		: requests_(requests),
+			requestById_(requestById),
+			password_(password),
+			currentRequest_(nullptr),
+			passwordRequested_(false) {}
+
+	bool PasswordRequested() const
+	{
+		return passwordRequested_.load(std::memory_order_acquire);
+	}
+
+private:
+	std::vector<OutputRequest>& requests_;
+	const std::unordered_map<std::uint32_t, std::size_t>& requestById_;
+	const std::optional<std::string>& password_;
+	OutputRequest *currentRequest_;
+	std::vector<CMyComPtr<ISequentialOutStream>> streams_;
+	std::atomic<bool> passwordRequested_;
+};
+
+Z7_COM7F_IMF(ExtractCallback::SetTotal(UInt64))
+{
+	return S_OK;
+}
+
+Z7_COM7F_IMF(ExtractCallback::SetCompleted(const UInt64 *))
+{
+	return S_OK;
+}
+
+Z7_COM7F_IMF(ExtractCallback::GetStream(
+	UInt32 index, ISequentialOutStream **outStream, Int32 askExtractMode))
+{
+	*outStream = nullptr;
+	currentRequest_ = nullptr;
+	if (askExtractMode != NArchive::NExtract::NAskMode::kExtract) {
+		return S_OK;
+	}
+	const auto found = requestById_.find(index);
+	if (found == requestById_.end()) {
+		return S_OK;
+	}
+	auto& request = requests_[found->second];
+	currentRequest_ = &request;
+	CMyComPtr<ISequentialOutStream> stream = new VectorOutStream(&request);
+	streams_.push_back(stream);
+	*outStream = stream;
+	(*outStream)->AddRef();
+	return S_OK;
+}
+
+Z7_COM7F_IMF(ExtractCallback::PrepareOperation(Int32))
+{
+	return S_OK;
+}
+
+Z7_COM7F_IMF(ExtractCallback::SetOperationResult(Int32 operationResult))
+{
+	if (currentRequest_ != nullptr) {
+		currentRequest_->operationResult = operationResult;
+	}
+	return S_OK;
+}
+
+Z7_COM7F_IMF(ExtractCallback::CryptoGetTextPassword(BSTR *password))
+{
+	passwordRequested_.store(true, std::memory_order_release);
+	return GetPasswordBstr(password_, password);
+}
+
+class StreamingOutStream final : public ISequentialOutStream, public CMyUnknownImp {
+	Z7_COM_UNKNOWN_IMP_1(ISequentialOutStream)
+	Z7_COM7F_IMP(Write(const void *data, UInt32 size, UInt32 *processedSize))
+
+public:
+	explicit StreamingOutStream(std::shared_ptr<NativeStreamState> stream)
+		: stream_(std::move(stream)) {}
+
+private:
+	std::shared_ptr<NativeStreamState> stream_;
+};
+
+Z7_COM7F_IMF(StreamingOutStream::Write(
+	const void *data, UInt32 size, UInt32 *processedSize))
+{
+	constexpr UInt32 kStreamChunkSize = 64 * 1024;
+	const auto *bytes = static_cast<const std::uint8_t *>(data);
+	UInt32 offset = 0;
+	try {
+		while (offset < size) {
+			if (!stream_->WaitForDemand()) {
+				return E_ABORT;
+			}
+			const auto count = std::min(kStreamChunkSize, size - offset);
+			auto message = std::make_unique<StreamMessage>();
+			message->kind = StreamMessage::Kind::Chunk;
+			message->data.assign(bytes + offset, bytes + offset + count);
+			if (!stream_->Send(std::move(message))) {
+				return E_ABORT;
+			}
+			offset += count;
+		}
+	} catch (...) {
+		return E_OUTOFMEMORY;
+	}
+	if (processedSize != nullptr) {
+		*processedSize = size;
+	}
+	return S_OK;
+}
+
+class StreamingExtractCallback final :
+	public IArchiveExtractCallback,
+	public ICryptoGetTextPassword,
+	public CMyUnknownImp {
+	Z7_COM_QI_BEGIN2(IArchiveExtractCallback)
+	Z7_COM_QI_ENTRY(IProgress)
+	Z7_COM_QI_ENTRY(ICryptoGetTextPassword)
+	Z7_COM_QI_END
+	Z7_COM_ADDREF_RELEASE
+
+	Z7_IFACE_COM7_IMP(IProgress)
+	Z7_IFACE_COM7_IMP(IArchiveExtractCallback)
+	Z7_IFACE_COM7_IMP(ICryptoGetTextPassword)
+
+public:
+	StreamingExtractCallback(
+		std::uint32_t id,
+		std::shared_ptr<NativeStreamState> stream,
+		const std::optional<std::string>& password)
+		: id_(id),
+			stream_(std::move(stream)),
+			password_(password),
+			operationResult_(NArchive::NExtract::NOperationResult::kUnavailable),
+			passwordRequested_(false) {}
+
+	std::int32_t OperationResult() const
+	{
+		return operationResult_;
+	}
+
+	bool PasswordRequested() const
+	{
+		return passwordRequested_.load(std::memory_order_acquire);
+	}
+
+private:
+	std::uint32_t id_;
+	std::shared_ptr<NativeStreamState> stream_;
+	const std::optional<std::string>& password_;
+	std::int32_t operationResult_;
+	std::vector<CMyComPtr<ISequentialOutStream>> streams_;
+	std::atomic<bool> passwordRequested_;
+};
+
+Z7_COM7F_IMF(StreamingExtractCallback::SetTotal(UInt64))
+{
+	return S_OK;
+}
+
+Z7_COM7F_IMF(StreamingExtractCallback::SetCompleted(const UInt64 *))
+{
+	return S_OK;
+}
+
+Z7_COM7F_IMF(StreamingExtractCallback::GetStream(
+	UInt32 index, ISequentialOutStream **outStream, Int32 askExtractMode))
+{
+	*outStream = nullptr;
+	if (askExtractMode != NArchive::NExtract::NAskMode::kExtract || index != id_) {
+		return S_OK;
+	}
+	CMyComPtr<ISequentialOutStream> stream = new StreamingOutStream(stream_);
+	streams_.push_back(stream);
+	*outStream = stream;
+	(*outStream)->AddRef();
+	return S_OK;
+}
+
+Z7_COM7F_IMF(StreamingExtractCallback::PrepareOperation(Int32))
+{
+	return S_OK;
+}
+
+Z7_COM7F_IMF(StreamingExtractCallback::SetOperationResult(Int32 operationResult))
+{
+	operationResult_ = operationResult;
+	return S_OK;
+}
+
+Z7_COM7F_IMF(StreamingExtractCallback::CryptoGetTextPassword(BSTR *password))
+{
+	passwordRequested_.store(true, std::memory_order_release);
+	return GetPasswordBstr(password_, password);
+}
+
+class ArchiveEngine {
+	struct ArchiveContext {
+		CMyComPtr<IInArchive> archive;
+		CMyComPtr<IInStream> stream;
+		bool busy = false;
+
+		~ArchiveContext()
+		{
+			if (archive) {
+				archive->Close();
+				archive.Release();
+			}
+			stream.Release();
+		}
+	};
+
+	struct ContextLease {
+		ArchiveEngine *owner;
+		ArchiveContext *context;
+
+		ContextLease(ArchiveEngine *owner, ArchiveContext *context)
+			: owner(owner), context(context) {}
+
+		ContextLease(const ContextLease&) = delete;
+		ContextLease& operator=(const ContextLease&) = delete;
+
+		ContextLease(ContextLease&& other) noexcept
+			: owner(other.owner), context(other.context)
+		{
+			other.context = nullptr;
+		}
+
+		~ContextLease()
+		{
+			if (context != nullptr) {
+				owner->ReleaseContext(context);
+			}
+		}
+
+		ArchiveContext *operator->() const { return context; }
+	};
+
+public:
+	~ArchiveEngine()
+	{
+		std::lock_guard<std::mutex> lock(contextMutex_);
+		contexts_.clear();
+		if (password_) {
+			SecureErase(*password_);
+			password_.reset();
+		}
+	}
+
+	void Open(
+		const std::string& path,
+		std::optional<std::string> password,
+		const std::string& enginePath)
+	{
+		EnsureEngineLoaded(enginePath);
+		path_ = path;
+		password_ = std::move(password);
+		const auto extension = Extension(path);
+		UInt32 formatCount = 0;
+		if (g_getNumberOfFormats(&formatCount) != S_OK || formatCount == 0) {
+			throw std::runtime_error("The 7-Zip handler bundle contains no formats");
+		}
+
+		struct Format {
+			UInt32 index;
+			GUID classId;
+			std::string name;
+			bool extensionMatch;
+			bool hasSignatureFunction;
+			bool signatureMatch;
+		};
+		std::vector<Format> formats;
+		formats.reserve(formatCount);
+		std::vector<Byte> header(64 * 1024);
+		auto *probeFile = new FileInStream();
+		CMyComPtr<IInStream> probe = probeFile;
+		if (!probeFile->Open(path)) {
+			throw std::runtime_error("Unable to open archive path");
+		}
+		UInt32 headerSize = 0;
+		if (probe->Read(header.data(), static_cast<UInt32>(header.size()), &headerSize) != S_OK) {
+			throw std::runtime_error("Unable to read archive signature");
+		}
+		if (headerSize == 0) {
+			throw std::runtime_error("Archive file is empty");
+		}
+		for (UInt32 i = 0; i < formatCount; ++i) {
+			NWindows::NCOM::CPropVariant classIdValue;
+			if (g_getHandlerProperty(i, NArchive::NHandlerPropID::kClassID, &classIdValue) != S_OK
+				|| classIdValue.vt != VT_BSTR
+				|| ::SysStringByteLen(classIdValue.bstrVal) != sizeof(GUID)) {
+				continue;
+			}
+			GUID classId;
+			std::memcpy(&classId, classIdValue.bstrVal, sizeof(classId));
+			NWindows::NCOM::CPropVariant nameValue;
+			std::string name;
+			if (g_getHandlerProperty(i, NArchive::NHandlerPropID::kName, &nameValue) == S_OK
+				&& nameValue.vt == VT_BSTR) {
+				name = ToUtf8(nameValue.bstrVal);
+			}
+			bool match = false;
+			for (const auto propId : {
+				NArchive::NHandlerPropID::kExtension,
+				NArchive::NHandlerPropID::kAddExtension
+			}) {
+				NWindows::NCOM::CPropVariant extensions;
+				if (g_getHandlerProperty(i, propId, &extensions) == S_OK
+					&& extensions.vt == VT_BSTR && !extension.empty()) {
+					const auto list = SplitExtensions(extensions.bstrVal);
+					match = match || std::find(list.begin(), list.end(), extension) != list.end();
+				}
+			}
+			Func_IsArc isArchive = nullptr;
+			const bool hasSignatureFunction = g_getIsArc(i, &isArchive) == S_OK && isArchive != nullptr;
+			const bool signatureMatch = hasSignatureFunction
+				&& isArchive(header.data(), header.size()) != 0;
+			formats.push_back({i, classId, std::move(name), match, hasSignatureFunction, signatureMatch});
+		}
+		const bool hasSignatureMatch = std::any_of(
+			formats.begin(), formats.end(), [](const Format& format) { return format.signatureMatch; });
+		const bool hasExtensionMatch = std::any_of(
+			formats.begin(), formats.end(), [](const Format& format) { return format.extensionMatch; });
+		if (hasSignatureMatch) {
+			formats.erase(
+				std::remove_if(formats.begin(), formats.end(), [](const Format& format) {
+					return !format.signatureMatch
+						&& !(format.extensionMatch && !format.hasSignatureFunction);
+				}),
+				formats.end());
+		} else if (hasExtensionMatch && std::any_of(
+			formats.begin(), formats.end(), [](const Format& format) {
+				return format.extensionMatch && !format.hasSignatureFunction;
+			})) {
+			formats.erase(
+				std::remove_if(formats.begin(), formats.end(), [](const Format& format) {
+					return !format.extensionMatch || format.hasSignatureFunction;
+				}),
+				formats.end());
+		} else if (hasExtensionMatch) {
+			formats.clear();
+		}
+		if (formats.empty()) {
+			throw std::runtime_error("No registered 7-Zip handler recognizes this archive");
+		}
+		std::stable_sort(formats.begin(), formats.end(), [](const Format& left, const Format& right) {
+			return left.extensionMatch && !right.extensionMatch;
+		});
+
+		bool passwordRequested = false;
+		HRESULT lastOpenResult = E_FAIL;
+		UInt32 lastFormatIndex = 0;
+		std::string lastFormatName;
+		for (const auto& format : formats) {
+			lastFormatIndex = format.index;
+			lastFormatName = format.name;
+			auto *inputFile = new FileInStream();
+			CMyComPtr<IInStream> input = inputFile;
+			if (!inputFile->Open(path)) {
+				throw std::runtime_error("Unable to open archive path");
+			}
+			void *created = nullptr;
+			const auto createResult = g_createObject(&format.classId, &IID_IInArchive, &created);
+			if (createResult != S_OK || created == nullptr) {
+				continue;
+			}
+			CMyComPtr<IInArchive> candidate;
+			candidate.Attach(static_cast<IInArchive *>(created));
+			const UInt64 maxCheckStartPosition = 0;
+			auto *openCallbackObject = new ArchiveOpenCallback(password_);
+			CMyComPtr<IArchiveOpenCallback> openCallback = openCallbackObject;
+			lastOpenResult = candidate->Open(input, &maxCheckStartPosition, openCallback);
+			if (lastOpenResult != S_OK) {
+				passwordRequested = passwordRequested || openCallbackObject->PasswordRequested();
+				candidate->Close();
+				continue;
+			}
+			auto context = std::make_unique<ArchiveContext>();
+			context->archive = candidate;
+			context->stream = input;
+			archiveClassId_ = format.classId;
+			contexts_.push_back(std::move(context));
+			LoadEntries(contexts_.front()->archive);
+			fileStamp_ = GetFileStamp(path_);
+			return;
+		}
+		if (passwordRequested) {
+			throw std::runtime_error("Archive password is missing or incorrect");
+		}
+		throw std::runtime_error(
+			"No 7-Zip archive handler recognized this file (format "
+			+ lastFormatName
+			+ " "
+			+ std::to_string(lastFormatIndex)
+			+ ", HRESULT "
+			+ std::to_string(static_cast<std::uint32_t>(lastOpenResult))
+			+ ")");
+	}
+
+	const std::vector<Entry>& Entries() const
+	{
+		return entries_;
+	}
+
+	std::vector<std::vector<std::uint8_t>> Extract(
+		const std::vector<std::uint32_t>& ids,
+		bool partial,
+		std::uint64_t offset,
+		std::uint64_t length,
+		OutputReservation& outputReservation)
+	{
+		if (contexts_.empty()) {
+			throw std::runtime_error("Archive is closed");
+		}
+		std::unordered_map<std::uint32_t, std::size_t> requestById;
+		requestById.reserve(ids.size());
+		std::uint64_t totalRequested = 0;
+		for (std::size_t requestIndex = 0; requestIndex < ids.size(); ++requestIndex) {
+			const auto id = ids[requestIndex];
+			if (id >= entries_.size()) {
+				throw std::out_of_range("Entry ID is out of range");
+			}
+			const auto& entry = entries_[id];
+			if (entry.directory) {
+				throw std::invalid_argument("Cannot read a directory entry");
+			}
+			const auto start = partial ? std::min(offset, entry.size) : 0;
+			const auto available = entry.size - start;
+			const auto requested = partial ? std::min(length, available) : entry.size;
+			if (!requestById.emplace(id, requestIndex).second) {
+				throw std::invalid_argument("Duplicate entry IDs are not allowed in a batch");
+			}
+			if (requested > kMaxSingleOutputBytes
+				|| requested > kMaxSingleOutputBytes - totalRequested) {
+				throw std::length_error("Entry exceeds the in-memory output limit");
+			}
+			totalRequested += requested;
+		}
+		outputReservation.Acquire(totalRequested);
+		std::vector<OutputRequest> requests;
+		requests.reserve(ids.size());
+		for (const auto id : ids) {
+			const auto& entry = entries_[id];
+			const auto start = partial ? std::min(offset, entry.size) : 0;
+			const auto available = entry.size - start;
+			const auto requested = partial ? std::min(length, available) : entry.size;
+			OutputRequest request;
+			request.id = id;
+			request.offset = start;
+			request.length = requested;
+			request.entrySize = entry.size;
+			request.encrypted = entry.encrypted;
+			request.data.reserve(static_cast<std::size_t>(requested));
+			requests.push_back(std::move(request));
+		}
+		std::vector<UInt32> sortedIds;
+		sortedIds.reserve(requestById.size());
+		for (const auto& item : requestById) {
+			sortedIds.push_back(item.first);
+		}
+		if (std::all_of(requests.begin(), requests.end(), [](const OutputRequest& request) {
+			return request.length == 0;
+		})) {
+			return std::vector<std::vector<std::uint8_t>>(ids.size());
+		}
+		std::sort(sortedIds.begin(), sortedIds.end());
+		auto context = AcquireContext();
+		auto *extractCallbackObject = new ExtractCallback(requests, requestById, password_);
+		CMyComPtr<IArchiveExtractCallback> callback = extractCallbackObject;
+		const auto result = context->archive->Extract(
+			sortedIds.empty() ? nullptr : sortedIds.data(),
+			static_cast<UInt32>(sortedIds.size()),
+			0,
+			callback);
+		if (result != S_OK) {
+			if (extractCallbackObject->PasswordRequested()) {
+				throw std::runtime_error("Archive password is missing or incorrect");
+			}
+			throw std::runtime_error("7-Zip failed to extract the requested entries");
+		}
+		for (const auto& request : requests) {
+			if (request.operationResult != NArchive::NExtract::NOperationResult::kOK) {
+				if (request.encrypted && extractCallbackObject->PasswordRequested()) {
+					throw std::runtime_error("Archive password is incorrect or encrypted data is invalid");
+				}
+				if (request.operationResult == NArchive::NExtract::NOperationResult::kWrongPassword) {
+					throw std::runtime_error("Archive password is incorrect");
+				}
+				throw std::runtime_error("Entry extraction failed (unsupported method, integrity error, or password required)");
+			}
+		}
+		std::vector<std::vector<std::uint8_t>> resultData;
+		resultData.reserve(ids.size());
+		for (const auto id : ids) {
+			resultData.push_back(std::move(requests[requestById.at(id)].data));
+		}
+		return resultData;
+	}
+
+	void ExtractStream(std::uint32_t id, const std::shared_ptr<NativeStreamState>& stream)
+	{
+		if (contexts_.empty()) {
+			throw std::runtime_error("Archive is closed");
+		}
+		if (id >= entries_.size()) {
+			throw std::out_of_range("Entry ID is out of range");
+		}
+		if (entries_[id].directory) {
+			throw std::invalid_argument("Cannot read a directory entry");
+		}
+		auto context = AcquireContext();
+		auto *extractCallbackObject = new StreamingExtractCallback(id, stream, password_);
+		CMyComPtr<IArchiveExtractCallback> callback = extractCallbackObject;
+		const UInt32 itemIndex = id;
+		const auto result = context->archive->Extract(&itemIndex, 1, 0, callback);
+		if (result != S_OK) {
+			if (extractCallbackObject->PasswordRequested()) {
+				throw std::runtime_error("Archive password is missing or incorrect");
+			}
+			throw std::runtime_error("7-Zip failed to stream the requested entry");
+		}
+		if (extractCallbackObject->OperationResult() != NArchive::NExtract::NOperationResult::kOK) {
+			if (extractCallbackObject->PasswordRequested()) {
+				throw std::runtime_error("Archive password is incorrect or encrypted data is invalid");
+			}
+			if (extractCallbackObject->OperationResult()
+				== NArchive::NExtract::NOperationResult::kWrongPassword) {
+				throw std::runtime_error("Archive password is incorrect");
+			}
+			throw std::runtime_error(
+				"Entry streaming failed (unsupported method, integrity error, or password required)");
+		}
+	}
+
+private:
+	ContextLease AcquireContext()
+	{
+		std::unique_lock<std::mutex> lock(contextMutex_);
+		while (true) {
+			for (const auto& context : contexts_) {
+				if (!context->busy) {
+					context->busy = true;
+					return ContextLease(this, context.get());
+				}
+			}
+			const auto contextLimit = std::max<std::uint32_t>(
+				1, g_extractionConcurrency.load(std::memory_order_acquire));
+			if (contexts_.size() + contextsCreating_ < contextLimit) {
+				++contextsCreating_;
+				lock.unlock();
+				std::unique_ptr<ArchiveContext> context;
+				try {
+					context = OpenAdditionalContext();
+				} catch (...) {
+					lock.lock();
+					--contextsCreating_;
+					contextAvailable_.notify_all();
+					throw;
+				}
+				lock.lock();
+				--contextsCreating_;
+				context->busy = true;
+				auto *result = context.get();
+				contexts_.push_back(std::move(context));
+				contextAvailable_.notify_all();
+				return ContextLease(this, result);
+			}
+			contextAvailable_.wait(lock);
+		}
+	}
+
+	void ReleaseContext(ArchiveContext *context)
+	{
+		{
+			std::lock_guard<std::mutex> lock(contextMutex_);
+			context->busy = false;
+		}
+		contextAvailable_.notify_one();
+	}
+
+	std::unique_ptr<ArchiveContext> OpenAdditionalContext()
+	{
+		const auto beforeOpen = GetFileStamp(path_);
+		if (beforeOpen.size != fileStamp_.size
+			|| beforeOpen.modified != fileStamp_.modified) {
+			throw std::runtime_error("Archive file changed since opening; reopen it before extracting");
+		}
+		auto *inputFile = new FileInStream();
+		CMyComPtr<IInStream> input = inputFile;
+		if (!inputFile->Open(path_)) {
+			throw std::runtime_error("Unable to reopen archive path for concurrent extraction");
+		}
+		void *created = nullptr;
+		const auto createResult = g_createObject(&archiveClassId_, &IID_IInArchive, &created);
+		if (createResult != S_OK || created == nullptr) {
+			throw std::runtime_error("Unable to create an independent 7-Zip decoder context");
+		}
+		CMyComPtr<IInArchive> archive;
+		archive.Attach(static_cast<IInArchive *>(created));
+		const UInt64 maxCheckStartPosition = 0;
+		auto *openCallbackObject = new ArchiveOpenCallback(password_);
+		CMyComPtr<IArchiveOpenCallback> openCallback = openCallbackObject;
+		const auto openResult = archive->Open(input, &maxCheckStartPosition, openCallback);
+		if (openResult != S_OK) {
+			const bool passwordRequested = openCallbackObject->PasswordRequested();
+			archive->Close();
+			if (passwordRequested) {
+				throw std::runtime_error("Archive password is missing or incorrect");
+			}
+			throw std::runtime_error("Unable to open an independent 7-Zip decoder context");
+		}
+		const auto stamp = GetFileStamp(path_);
+		if (stamp.size != fileStamp_.size || stamp.modified != fileStamp_.modified) {
+			archive->Close();
+			throw std::runtime_error("Archive file changed during concurrent extraction setup");
+		}
+		auto context = std::make_unique<ArchiveContext>();
+		context->archive = archive;
+		context->stream = input;
+		return context;
+	}
+
+	void LoadEntries(IInArchive *archive)
+	{
+		UInt32 count = 0;
+		if (archive->GetNumberOfItems(&count) != S_OK || count > kMaxEntries) {
+			throw std::runtime_error("Invalid or excessively large archive index");
+		}
+		entries_.reserve(count);
+		for (UInt32 i = 0; i < count; ++i) {
+			Entry entry;
+			entry.id = i;
+			entry.path = GetPropString(archive, i, kpidPath);
+			std::replace(entry.path.begin(), entry.path.end(), '\\', '/');
+			entry.size = GetPropUInt64(archive, i, kpidSize);
+			entry.compressedSize = GetPropUInt64(archive, i, kpidPackSize);
+			entry.attributes = static_cast<std::uint32_t>(GetPropUInt64(archive, i, kpidAttrib));
+			entry.directory = GetPropBool(archive, i, kpidIsDir);
+			entry.encrypted = GetPropBool(archive, i, kpidEncrypted);
+			NWindows::NCOM::CPropVariant crc;
+			if (archive->GetProperty(i, kpidCRC, &crc) == S_OK && crc.vt == VT_UI4) {
+				entry.crc = crc.ulVal;
+				entry.hasCrc = true;
+			}
+			entries_.push_back(std::move(entry));
+		}
+	}
+
+	std::mutex contextMutex_;
+	std::condition_variable contextAvailable_;
+	std::vector<std::unique_ptr<ArchiveContext>> contexts_;
+	std::size_t contextsCreating_ = 0;
+	std::string path_;
+	GUID archiveClassId_{};
+	FileStamp fileStamp_{};
+	std::optional<std::string> password_;
+	std::vector<Entry> entries_;
+};
+
+Napi::Object EntryToJs(Napi::Env env, const Entry& entry)
+{
+	Napi::Object result = Napi::Object::New(env);
+	result.Set("id", Napi::Number::New(env, entry.id));
+	result.Set("path", Napi::String::New(env, entry.path));
+	result.Set("size", Napi::BigInt::New(env, entry.size));
+	result.Set("compressedSize", Napi::BigInt::New(env, entry.compressedSize));
+	result.Set("isDirectory", Napi::Boolean::New(env, entry.directory));
+	result.Set("encrypted", Napi::Boolean::New(env, entry.encrypted));
+	result.Set("attributes", Napi::Number::New(env, entry.attributes));
+	if (entry.hasCrc) {
+		result.Set("crc", Napi::Number::New(env, entry.crc));
+	}
+	return result;
+}
+
+Napi::Buffer<std::uint8_t> TakeBuffer(Napi::Env env, std::vector<std::uint8_t> data)
+{
+	if (data.empty()) {
+		return Napi::Buffer<std::uint8_t>::New(env, 0);
+	}
+	auto *owned = new std::vector<std::uint8_t>(std::move(data));
+	return Napi::Buffer<std::uint8_t>::New(
+		env,
+		owned->data(),
+		owned->size(),
+		[](Napi::Env, std::uint8_t *, std::vector<std::uint8_t> *hint) {
+			delete hint;
+		},
+		owned);
+}
+
+void StreamMessageToJs(Napi::Env env, Napi::Function callback, StreamMessage *message)
+{
+	std::unique_ptr<StreamMessage> owned(message);
+	if (env == nullptr || !callback) {
+		return;
+	}
+	if (message->kind == StreamMessage::Kind::Chunk) {
+		callback.Call({
+			TakeBuffer(env, std::move(message->data)),
+			env.Undefined(),
+			Napi::Boolean::New(env, false)
+		});
+	} else if (message->kind == StreamMessage::Kind::Error) {
+		callback.Call({
+			env.Undefined(),
+			Napi::Error::New(env, message->error).Value(),
+			Napi::Boolean::New(env, false)
+		});
+	} else {
+		callback.Call({
+			env.Undefined(),
+			env.Undefined(),
+			Napi::Boolean::New(env, true)
+		});
+	}
+}
+
+class BoundedAsyncWorker : public Napi::AsyncWorker {
+public:
+	BoundedAsyncWorker(Napi::Env env, Napi::Promise::Deferred deferred)
+		: Napi::AsyncWorker(env), deferred_(deferred) {}
+
+	~BoundedAsyncWorker() override
+	{
+		g_pendingOperations.fetch_sub(1, std::memory_order_acq_rel);
+	}
+
+	void OnError(const Napi::Error& error) override
+	{
+		deferred_.Reject(error.Value());
+	}
+
+protected:
+	Napi::Promise::Deferred deferred_;
+};
+
+class OpenWorker final : public BoundedAsyncWorker {
+public:
+	OpenWorker(
+		Napi::Env env,
+		Napi::Promise::Deferred deferred,
+		std::string path,
+		std::optional<std::string> password,
+		std::string enginePath)
+		: BoundedAsyncWorker(env, deferred),
+			path_(std::move(path)),
+			password_(std::move(password)),
+			enginePath_(std::move(enginePath)) {}
+
+	~OpenWorker() override
+	{
+		if (password_) {
+			SecureErase(*password_);
+		}
+	}
+
+	void Execute() override
+	{
+		try {
+			archive_ = std::make_shared<ArchiveEngine>();
+			archive_->Open(path_, std::move(password_), enginePath_);
+		} catch (const std::exception& error) {
+			SetError(error.what());
+		} catch (...) {
+			SetError("Unknown native archive open failure");
+		}
+	}
+
+	void OnOK() override
+	{
+		try {
+			const auto handle = RegisterArchive(std::move(archive_));
+			deferred_.Resolve(Napi::BigInt::New(Env(), handle));
+		} catch (const std::exception& error) {
+			deferred_.Reject(Napi::Error::New(Env(), error.what()).Value());
+		}
+	}
+
+private:
+	std::string path_;
+	std::optional<std::string> password_;
+	std::string enginePath_;
+	std::shared_ptr<ArchiveEngine> archive_;
+};
+
+class EntriesWorker final : public BoundedAsyncWorker {
+public:
+	EntriesWorker(
+		Napi::Env env,
+		Napi::Promise::Deferred deferred,
+		std::shared_ptr<ArchiveEngine> archive)
+		: BoundedAsyncWorker(env, deferred), archive_(std::move(archive)) {}
+
+	void Execute() override
+	{
+		entries_ = archive_->Entries();
+	}
+
+	void OnOK() override
+	{
+		Napi::Array result = Napi::Array::New(Env(), entries_.size());
+		for (std::size_t i = 0; i < entries_.size(); ++i) {
+			result.Set(i, EntryToJs(Env(), entries_[i]));
+		}
+		deferred_.Resolve(result);
+	}
+
+private:
+	std::shared_ptr<ArchiveEngine> archive_;
+	std::vector<Entry> entries_;
+};
+
+class ExtractionTask {
+public:
+	virtual ~ExtractionTask() = default;
+	virtual void Execute() noexcept = 0;
+	virtual void Complete(Napi::Env env) = 0;
+};
+
+class ExtractWorker final : public ExtractionTask {
+public:
+	ExtractWorker(
+		Napi::Promise::Deferred deferred,
+		std::shared_ptr<ArchiveEngine> archive,
+		std::vector<std::uint32_t> ids,
+		bool partial,
+		std::uint64_t offset,
+		std::uint64_t length)
+		: deferred_(deferred),
+			archive_(std::move(archive)),
+			ids_(std::move(ids)),
+			partial_(partial),
+			offset_(offset),
+			length_(length) {}
+
+	~ExtractWorker() override
+	{
+		g_pendingOperations.fetch_sub(1, std::memory_order_acq_rel);
+	}
+
+	void Execute() noexcept override
+	{
+		try {
+			outputs_ = archive_->Extract(ids_, partial_, offset_, length_, outputReservation_);
+		} catch (const std::exception& error) {
+			error_ = error.what();
+		} catch (...) {
+			error_ = "Unknown native extraction failure";
+		}
+	}
+
+	void Complete(Napi::Env env) override
+	{
+		try {
+			if (!error_.empty()) {
+				deferred_.Reject(Napi::Error::New(env, error_).Value());
+				return;
+			}
+			if (partial_) {
+				deferred_.Resolve(TakeBuffer(env, std::move(outputs_.front())));
+				return;
+			}
+			Napi::Array result = Napi::Array::New(env, outputs_.size());
+			for (std::size_t i = 0; i < outputs_.size(); ++i) {
+				result.Set(i, TakeBuffer(env, std::move(outputs_[i])));
+			}
+			deferred_.Resolve(result);
+		} catch (const Napi::Error& error) {
+			deferred_.Reject(error.Value());
+		} catch (const std::exception& error) {
+			deferred_.Reject(Napi::Error::New(env, error.what()).Value());
+		}
+	}
+
+private:
+	Napi::Promise::Deferred deferred_;
+	OutputReservation outputReservation_;
+	std::shared_ptr<ArchiveEngine> archive_;
+	std::vector<std::uint32_t> ids_;
+	bool partial_;
+	std::uint64_t offset_;
+	std::uint64_t length_;
+	std::vector<std::vector<std::uint8_t>> outputs_;
+	std::string error_;
+};
+
+class StreamWorker final : public ExtractionTask {
+public:
+	StreamWorker(
+		std::shared_ptr<ArchiveEngine> archive,
+		std::uint32_t entryId,
+		std::shared_ptr<NativeStreamState> stream)
+		: archive_(std::move(archive)),
+			entryId_(entryId),
+			stream_(std::move(stream)) {}
+
+	~StreamWorker() override
+	{
+		if (!completed_) {
+			stream_->Cancel();
+			RemoveStream(stream_->id);
+			stream_->ReleaseCallback();
+		}
+		g_pendingOperations.fetch_sub(1, std::memory_order_acq_rel);
+	}
+
+	void Execute() noexcept override
+	{
+		try {
+			archive_->ExtractStream(entryId_, stream_);
+			if (!stream_->IsCancelled()) {
+				SendMessage(StreamMessage::Kind::End, {});
+			}
+		} catch (const std::exception& error) {
+			if (!stream_->IsCancelled()) {
+				SendMessage(StreamMessage::Kind::Error, error.what());
+			}
+		} catch (...) {
+			if (!stream_->IsCancelled()) {
+				SendMessage(StreamMessage::Kind::Error, "Unknown native archive streaming failure");
+			}
+		}
+	}
+
+	void Complete(Napi::Env) override
+	{
+		completed_ = true;
+		RemoveStream(stream_->id);
+		stream_->ReleaseCallback();
+	}
+
+private:
+	void SendMessage(StreamMessage::Kind kind, const std::string& error) noexcept
+	{
+		try {
+			auto message = std::make_unique<StreamMessage>();
+			message->kind = kind;
+			message->error = error;
+			stream_->Send(std::move(message));
+		} catch (...) {
+			stream_->Cancel();
+		}
+	}
+
+	std::shared_ptr<ArchiveEngine> archive_;
+	std::uint32_t entryId_;
+	std::shared_ptr<NativeStreamState> stream_;
+	bool completed_ = false;
+};
+
+class ExtractionPool {
+public:
+	void Initialize(Napi::Env env)
+	{
+		const auto callback = Napi::Function::New(env, [](const Napi::CallbackInfo& info) {
+			return info.Env().Undefined();
+		});
+		completion_ = Napi::ThreadSafeFunction::New(
+			env, callback, "7zip-native extraction completion", 0, 1);
+		completion_.Unref(env);
+		if (napi_add_env_cleanup_hook(env, Cleanup, this) != napi_ok) {
+			completion_.Release();
+			throw std::runtime_error("Unable to register native extraction pool cleanup");
+		}
+		initialized_ = true;
+	}
+
+	~ExtractionPool()
+	{
+		Shutdown();
+	}
+
+	void SetConcurrency(std::uint32_t concurrency)
+	{
+		if (concurrency == 0 || concurrency > kMaxExtractionConcurrency) {
+			throw std::out_of_range("Concurrency must be between 1 and 128");
+		}
+		std::lock_guard<std::mutex> lock(mutex_);
+		if (stopping_) {
+			throw std::runtime_error("Native extraction pool is shutting down");
+		}
+		for (std::size_t i = threads_.size(); i < concurrency; ++i) {
+			threads_.emplace_back([this]() {
+				WorkerLoop();
+			});
+		}
+		concurrency_ = concurrency;
+		g_extractionConcurrency.store(concurrency, std::memory_order_release);
+		available_.notify_all();
+	}
+
+	std::uint32_t Concurrency() const
+	{
+		return g_extractionConcurrency.load(std::memory_order_acquire);
+	}
+
+	void Queue(Napi::Env env, ExtractionTask *task)
+	{
+		std::lock_guard<std::mutex> lock(mutex_);
+		if (stopping_ || concurrency_ == 0) {
+			throw std::runtime_error("Native extraction pool is not available");
+		}
+		const bool wasIdle = pending_ == 0;
+		if (wasIdle) {
+			completion_.Ref(env);
+		}
+		try {
+			tasks_.push_back(task);
+		} catch (...) {
+			if (wasIdle) {
+				completion_.Unref(env);
+			}
+			throw;
+		}
+		++pending_;
+		available_.notify_one();
+	}
+
+	void Finished(Napi::Env env)
+	{
+		std::lock_guard<std::mutex> lock(mutex_);
+		if (pending_ > 0 && --pending_ == 0) {
+			completion_.Unref(env);
+		}
+	}
+
+private:
+	static void Cleanup(void *data)
+	{
+		auto *pool = static_cast<ExtractionPool *>(data);
+		pool->Shutdown();
+		if (g_extractionPool == pool) {
+			g_extractionPool = nullptr;
+		}
+		delete pool;
+	}
+
+	void Shutdown()
+	{
+		{
+			std::lock_guard<std::mutex> lock(mutex_);
+			if (stopping_) {
+				return;
+			}
+			stopping_ = true;
+		}
+		available_.notify_all();
+		for (auto& thread : threads_) {
+			if (thread.joinable()) {
+				thread.join();
+			}
+		}
+		threads_.clear();
+		if (initialized_) {
+			completion_.Release();
+			initialized_ = false;
+		}
+	}
+
+	void WorkerLoop()
+	{
+		while (true) {
+			ExtractionTask *task = nullptr;
+			{
+				std::unique_lock<std::mutex> lock(mutex_);
+				available_.wait(lock, [this]() {
+					return (stopping_ && tasks_.empty())
+						|| (!tasks_.empty() && activeWorkers_ < concurrency_);
+				});
+				if (stopping_ && tasks_.empty()) {
+					return;
+				}
+				task = tasks_.front();
+				tasks_.pop_front();
+				++activeWorkers_;
+			}
+			task->Execute();
+			const auto status = completion_.NonBlockingCall(
+				task,
+				[](Napi::Env env, Napi::Function, ExtractionTask *completed) {
+					std::unique_ptr<ExtractionTask> task(completed);
+					task->Complete(env);
+					if (g_extractionPool != nullptr) {
+						g_extractionPool->Finished(env);
+					}
+				});
+			if (status != napi_ok) {
+				delete task;
+				std::lock_guard<std::mutex> lock(mutex_);
+				if (pending_ > 0) {
+					--pending_;
+				}
+			}
+			{
+				std::lock_guard<std::mutex> lock(mutex_);
+				--activeWorkers_;
+			}
+			available_.notify_one();
+		}
+	}
+
+	Napi::ThreadSafeFunction completion_;
+	std::vector<std::thread> threads_;
+	std::deque<ExtractionTask *> tasks_;
+	std::mutex mutex_;
+	std::condition_variable available_;
+	std::uint32_t concurrency_ = 0;
+	std::size_t activeWorkers_ = 0;
+	std::size_t pending_ = 0;
+	bool stopping_ = false;
+	bool initialized_ = false;
+};
+
+Napi::Value Open(const Napi::CallbackInfo& info)
+{
+	const auto env = info.Env();
+	if (info.Length() != 3 || !info[0].IsString()
+		|| (!info[1].IsUndefined() && !info[1].IsString()) || !info[2].IsString()) {
+		throw Napi::TypeError::New(env, "open(path, password?, enginePath) expects path, optional password, and engine path");
+	}
+	std::optional<std::string> password;
+	if (info[1].IsString()) {
+		password = info[1].As<Napi::String>().Utf8Value();
+		if (password->size() > kMaxPasswordBytes) {
+			throw Napi::RangeError::New(env, "Password exceeds the 1 MiB native password limit");
+		}
+	}
+	if (!ReserveOperation()) {
+		throw Napi::Error::New(env, "Native operation queue is full");
+	}
+	Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+	auto *worker = new OpenWorker(
+		env,
+		deferred,
+		info[0].As<Napi::String>().Utf8Value(),
+		std::move(password),
+		info[2].As<Napi::String>().Utf8Value());
+	worker->Queue();
+	return deferred.Promise();
+}
+
+Napi::Value Entries(const Napi::CallbackInfo& info)
+{
+	const auto env = info.Env();
+	if (info.Length() != 1) {
+		throw Napi::TypeError::New(env, "entries(handle) expects an archive handle");
+	}
+	const auto handle = GetHandle(info[0]);
+	auto archive = FindArchive(handle);
+	if (!archive) {
+		throw Napi::Error::New(env, "Archive is closed");
+	}
+	if (!ReserveOperation()) {
+		throw Napi::Error::New(env, "Native operation queue is full");
+	}
+	auto deferred = Napi::Promise::Deferred::New(env);
+	(new EntriesWorker(env, deferred, std::move(archive)))->Queue();
+	return deferred.Promise();
+}
+
+Napi::Value QueueExtraction(
+	Napi::Env env,
+	Napi::Promise::Deferred deferred,
+	std::shared_ptr<ArchiveEngine> archive,
+	std::vector<std::uint32_t> ids,
+	bool partial,
+	std::uint64_t offset,
+	std::uint64_t length)
+{
+	if (!ReserveOperation()) {
+		throw Napi::Error::New(env, "Native operation queue is full");
+	}
+	ExtractWorker *worker = nullptr;
+	try {
+		if (g_extractionPool == nullptr) {
+			throw std::runtime_error("Native extraction pool is not initialized");
+		}
+		worker = new ExtractWorker(
+			deferred, std::move(archive), std::move(ids), partial, offset, length);
+		g_extractionPool->Queue(env, worker);
+	} catch (const std::exception& error) {
+		if (worker != nullptr) {
+			delete worker;
+		} else {
+			g_pendingOperations.fetch_sub(1, std::memory_order_acq_rel);
+		}
+		throw Napi::Error::New(env, error.what());
+	} catch (...) {
+		if (worker != nullptr) {
+			delete worker;
+		} else {
+			g_pendingOperations.fetch_sub(1, std::memory_order_acq_rel);
+		}
+		throw Napi::Error::New(env, "Unable to queue native extraction");
+	}
+	return deferred.Promise();
+}
+
+Napi::Value Extract(const Napi::CallbackInfo& info)
+{
+	const auto env = info.Env();
+	if (info.Length() != 2 || !info[1].IsArray()) {
+		throw Napi::TypeError::New(env, "extract(handle, ids) expects an array of entry IDs");
+	}
+	const auto handle = GetHandle(info[0]);
+	auto archive = FindArchive(handle);
+	if (!archive) {
+		throw Napi::Error::New(env, "Archive is closed");
+	}
+	std::vector<std::uint32_t> ids;
+	const auto inputIds = info[1].As<Napi::Array>();
+	ids.reserve(inputIds.Length());
+	for (std::uint32_t i = 0; i < inputIds.Length(); ++i) {
+		std::uint64_t id = 0;
+		if (!ReadUnsigned(inputIds.Get(i), id) || id > std::numeric_limits<std::uint32_t>::max()) {
+			throw Napi::TypeError::New(env, "Entry IDs must be non-negative 32-bit integers");
+		}
+		ids.push_back(static_cast<std::uint32_t>(id));
+	}
+	auto deferred = Napi::Promise::Deferred::New(env);
+	return QueueExtraction(
+		env, deferred, std::move(archive), std::move(ids), false, 0, 0);
+}
+
+Napi::Value StartStream(const Napi::CallbackInfo& info)
+{
+	const auto env = info.Env();
+	if (info.Length() != 3 || !info[2].IsFunction()) {
+		throw Napi::TypeError::New(
+			env, "startStream(handle, id, callback) expects an archive handle, entry ID, and callback");
+	}
+	const auto handle = GetHandle(info[0]);
+	auto archive = FindArchive(handle);
+	if (!archive) {
+		throw Napi::Error::New(env, "Archive is closed");
+	}
+	std::uint64_t entryId = 0;
+	if (!ReadUnsigned(info[1], entryId) || entryId > std::numeric_limits<std::uint32_t>::max()) {
+		throw Napi::TypeError::New(env, "Entry ID must be a non-negative 32-bit integer");
+	}
+	if (g_extractionPool == nullptr) {
+		throw Napi::Error::New(env, "Native extraction pool is not initialized");
+	}
+	if (!ReserveOperation()) {
+		throw Napi::Error::New(env, "Native operation queue is full");
+	}
+
+	std::shared_ptr<NativeStreamState> stream;
+	StreamWorker *worker = nullptr;
+	std::uint64_t streamId = 0;
+	bool callbackCreated = false;
+	try {
+		stream = std::make_shared<NativeStreamState>();
+		stream->callback = Napi::ThreadSafeFunction::New(
+			env,
+			info[2].As<Napi::Function>(),
+			"7zip-native archive entry stream",
+			1,
+			1);
+		callbackCreated = true;
+		streamId = RegisterStream(stream);
+		const auto result = Napi::BigInt::New(env, streamId);
+		worker = new StreamWorker(
+			std::move(archive),
+			static_cast<std::uint32_t>(entryId),
+			stream);
+		g_extractionPool->Queue(env, worker);
+		worker = nullptr;
+		return result;
+	} catch (...) {
+		if (worker != nullptr) {
+			delete worker;
+		} else {
+			if (streamId != 0) {
+				RemoveStream(streamId);
+			}
+			if (stream) {
+				stream->Cancel();
+				if (callbackCreated) {
+					stream->ReleaseCallback();
+				}
+			}
+			g_pendingOperations.fetch_sub(1, std::memory_order_acq_rel);
+		}
+		throw;
+	}
+}
+
+Napi::Value ResumeStream(const Napi::CallbackInfo& info)
+{
+	const auto env = info.Env();
+	std::uint64_t streamId = 0;
+	if (info.Length() != 1 || !ReadUnsigned(info[0], streamId) || streamId == 0) {
+		throw Napi::TypeError::New(env, "resumeStream(streamId) expects a positive stream ID");
+	}
+	if (const auto stream = FindStream(streamId)) {
+		stream->Resume();
+	}
+	return env.Undefined();
+}
+
+Napi::Value CancelStream(const Napi::CallbackInfo& info)
+{
+	const auto env = info.Env();
+	std::uint64_t streamId = 0;
+	if (info.Length() != 1 || !ReadUnsigned(info[0], streamId) || streamId == 0) {
+		throw Napi::TypeError::New(env, "cancelStream(streamId) expects a positive stream ID");
+	}
+	if (const auto stream = FindStream(streamId)) {
+		stream->Cancel();
+	}
+	return env.Undefined();
+}
+
+Napi::Value Read(const Napi::CallbackInfo& info)
+{
+	const auto env = info.Env();
+	if (info.Length() != 4) {
+		throw Napi::TypeError::New(env, "read(handle, id, offset, length) expects four arguments");
+	}
+	const auto handle = GetHandle(info[0]);
+	auto archive = FindArchive(handle);
+	if (!archive) {
+		throw Napi::Error::New(env, "Archive is closed");
+	}
+	std::uint64_t id = 0;
+	std::uint64_t offset = 0;
+	std::uint64_t length = 0;
+	if (!ReadUnsigned(info[1], id) || id > std::numeric_limits<std::uint32_t>::max()
+		|| !ReadUnsigned(info[2], offset) || !ReadUnsigned(info[3], length)) {
+		throw Napi::TypeError::New(env, "Entry ID, offset, and length must be non-negative safe integers or bigints");
+	}
+	if (length > kMaxReadBytes || offset > std::numeric_limits<std::uint64_t>::max() - length) {
+		throw Napi::RangeError::New(env, "Requested range exceeds the native read limit");
+	}
+	auto deferred = Napi::Promise::Deferred::New(env);
+	return QueueExtraction(
+		env,
+		deferred,
+		std::move(archive),
+		{static_cast<std::uint32_t>(id)},
+		true,
+		offset,
+		length);
+}
+
+Napi::Value Concurrency(const Napi::CallbackInfo& info)
+{
+	const auto env = info.Env();
+	if (info.Length() > 1) {
+		throw Napi::TypeError::New(env, "concurrency() accepts at most one integer");
+	}
+	if (g_extractionPool == nullptr) {
+		throw Napi::Error::New(env, "Native extraction pool is not initialized");
+	}
+	if (info.Length() == 0) {
+		return Napi::Number::New(env, g_extractionPool->Concurrency());
+	}
+	if (!info[0].IsNumber()) {
+		throw Napi::TypeError::New(env, "Concurrency must be a positive integer");
+	}
+	const double value = info[0].As<Napi::Number>().DoubleValue();
+	if (!std::isfinite(value) || std::floor(value) != value
+		|| value < 1 || value > kMaxExtractionConcurrency) {
+		throw Napi::RangeError::New(env, "Concurrency must be between 1 and 128");
+	}
+	try {
+		g_extractionPool->SetConcurrency(static_cast<std::uint32_t>(value));
+	} catch (const std::exception& error) {
+		throw Napi::Error::New(env, error.what());
+	}
+	return Napi::Number::New(env, value);
+}
+
+Napi::Value Close(const Napi::CallbackInfo& info)
+{
+	const auto env = info.Env();
+	if (info.Length() != 1) {
+		throw Napi::TypeError::New(env, "close(handle) expects an archive handle");
+	}
+	const auto handle = GetHandle(info[0]);
+	{
+		std::lock_guard<std::mutex> lock(g_handlesMutex);
+		if (g_handles.erase(handle) == 0) {
+			throw Napi::Error::New(env, "Archive is already closed");
+		}
+	}
+	return env.Undefined();
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports)
+{
+	if (g_extractionPool != nullptr) {
+		throw Napi::Error::New(env, "The native extraction pool is already initialized");
+	}
+	g_extractionPool = new ExtractionPool();
+	try {
+		g_extractionPool->Initialize(env);
+	} catch (...) {
+		delete g_extractionPool;
+		g_extractionPool = nullptr;
+		throw;
+	}
+	exports.Set("open", Napi::Function::New(env, Open));
+	exports.Set("entries", Napi::Function::New(env, Entries));
+	exports.Set("extract", Napi::Function::New(env, Extract));
+	exports.Set("startStream", Napi::Function::New(env, StartStream));
+	exports.Set("resumeStream", Napi::Function::New(env, ResumeStream));
+	exports.Set("cancelStream", Napi::Function::New(env, CancelStream));
+	exports.Set("read", Napi::Function::New(env, Read));
+	exports.Set("concurrency", Napi::Function::New(env, Concurrency));
+	exports.Set("close", Napi::Function::New(env, Close));
+	return exports;
+}
+
+} // namespace
+
+NODE_API_MODULE(7zip_native, Init)