7zip-native 0.0.8 → 0.0.12

package/native/addon.cpp

@@ -3,11 +3,14 @@
 #include <algorithm>
 #include <atomic>
 #include <cctype>
+#include <chrono>
 #include <cmath>
 #include <codecvt>
 #include <condition_variable>
 #include <cstdint>
 #include <cstring>
+#include <cstdio>
+#include <cstdlib>
 #include <cwctype>
 #include <deque>
 #include <filesystem>
@@ -27,6 +30,13 @@
 
 #ifndef _WIN32
 #include <dlfcn.h>
+#include <cerrno>
+#include <fcntl.h>
+#include <unistd.h>
+#else
+#include <fcntl.h>
+#include <io.h>
+#include <sys/stat.h>
 #endif
 
 #include "Common/MyInitGuid.h"
@@ -45,11 +55,14 @@ 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;
+constexpr std::uint32_t kMinDeflateBufferSize = 4 * 1024;
+constexpr std::uint32_t kMaxDeflateBufferSize = 2 * 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 *);
+using SetDeflateInputBufferSizeFunction = HRESULT (STDAPICALLTYPE *)(UInt32);
 
 std::wstring FromUtf8(const std::string& value);
 
@@ -63,10 +76,13 @@ 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::atomic<std::uint64_t> g_nextFileTaskId{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_fileTasksMutex;
+std::unordered_map<std::uint64_t, std::shared_ptr<class NativeFileTaskState>> g_fileTasks;
 std::mutex g_outputBudgetMutex;
 std::condition_variable g_outputBudgetAvailable;
 std::uint64_t g_reservedOutputBytes = 0;
@@ -77,6 +93,7 @@ CreateObjectFunction g_createObject = nullptr;
 GetHandlerPropertyFunction g_getHandlerProperty = nullptr;
 GetNumberOfFormatsFunction g_getNumberOfFormats = nullptr;
 GetIsArcFunction g_getIsArc = nullptr;
+SetDeflateInputBufferSizeFunction g_setDeflateInputBufferSize = nullptr;
 class ExtractionPool;
 ExtractionPool *g_extractionPool = nullptr;
 
@@ -93,6 +110,9 @@ Function LoadEngineFunction(const char *name)
 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);
+std::uint64_t RegisterFileTask(std::shared_ptr<class NativeFileTaskState> task);
+std::shared_ptr<class NativeFileTaskState> FindFileTask(std::uint64_t taskId);
+void RemoveFileTask(std::uint64_t taskId);
 
 void EnsureEngineLoaded(const std::string& path)
 {
@@ -122,8 +142,11 @@ void EnsureEngineLoaded(const std::string& path)
 	g_getHandlerProperty = LoadEngineFunction<GetHandlerPropertyFunction>("GetHandlerProperty2");
 	g_getNumberOfFormats = LoadEngineFunction<GetNumberOfFormatsFunction>("GetNumberOfFormats");
 	g_getIsArc = LoadEngineFunction<GetIsArcFunction>("GetIsArc");
+	g_setDeflateInputBufferSize =
+		LoadEngineFunction<SetDeflateInputBufferSizeFunction>("SetDeflateInputBufferSize");
 	if (g_createObject == nullptr || g_getHandlerProperty == nullptr
-		|| g_getNumberOfFormats == nullptr || g_getIsArc == nullptr) {
+		|| g_getNumberOfFormats == nullptr || g_getIsArc == nullptr
+		|| g_setDeflateInputBufferSize == nullptr) {
 #ifdef _WIN32
 		::FreeLibrary(g_engineModule);
 #else
@@ -134,6 +157,7 @@ void EnsureEngineLoaded(const std::string& path)
 		g_getHandlerProperty = nullptr;
 		g_getNumberOfFormats = nullptr;
 		g_getIsArc = nullptr;
+		g_setDeflateInputBufferSize = nullptr;
 		throw std::runtime_error("The bundled 7-Zip engine is missing required exports");
 	}
 	g_enginePath = path;
@@ -198,6 +222,40 @@ struct StreamMessage {
 };
 
 void StreamMessageToJs(Napi::Env env, Napi::Function callback, StreamMessage *message);
+class FileCompletionAcknowledgement {
+public:
+	void Acknowledge()
+	{
+		{
+			std::lock_guard<std::mutex> lock(mutex_);
+			acknowledged_ = true;
+		}
+		completed_.notify_one();
+	}
+
+	void Wait()
+	{
+		std::unique_lock<std::mutex> lock(mutex_);
+		completed_.wait(lock, [this] { return acknowledged_; });
+	}
+
+private:
+	std::mutex mutex_;
+	std::condition_variable completed_;
+	bool acknowledged_ = false;
+};
+
+struct FileCompletionMessage {
+	enum class Kind {
+		File,
+		Barrier,
+	};
+
+	Kind kind;
+	std::uint32_t entryId;
+	std::shared_ptr<FileCompletionAcknowledgement> acknowledgement;
+};
+void FileCompletionToJs(Napi::Env env, Napi::Function callback, FileCompletionMessage *message);
 
 class NativeStreamState {
 public:
@@ -267,6 +325,93 @@ private:
 	std::atomic<bool> callbackReleased_{false};
 };
 
+class NativeFileTaskState {
+public:
+	void Cancel()
+	{
+		cancelled_.store(true, std::memory_order_release);
+	}
+
+	bool IsCancelled() const
+	{
+		return cancelled_.load(std::memory_order_acquire);
+	}
+
+	void Fail(std::string error)
+	{
+		{
+			std::lock_guard<std::mutex> lock(failureMutex_);
+			if (failure_.empty()) {
+				failure_ = std::move(error);
+			}
+		}
+		Cancel();
+	}
+
+	std::string Failure() const
+	{
+		std::lock_guard<std::mutex> lock(failureMutex_);
+		return failure_;
+	}
+
+	bool ReportFileCompleted(std::uint32_t entryId)
+	{
+		if (!hasFileCompletionCallback_) {
+			return !IsCancelled();
+		}
+		auto *message = new FileCompletionMessage{
+			FileCompletionMessage::Kind::File,
+			entryId,
+			{},
+		};
+		const auto status = fileCompletionCallback.BlockingCall(message, FileCompletionToJs);
+		if (status != napi_ok) {
+			delete message;
+			Cancel();
+			return false;
+		}
+		return !IsCancelled();
+	}
+
+	bool WaitForFileCompletions()
+	{
+		if (!hasFileCompletionCallback_) {
+			return true;
+		}
+		auto acknowledgement = std::make_shared<FileCompletionAcknowledgement>();
+		auto *message = new FileCompletionMessage{
+			FileCompletionMessage::Kind::Barrier,
+			0,
+			acknowledgement,
+		};
+		const auto status = fileCompletionCallback.BlockingCall(message, FileCompletionToJs);
+		if (status != napi_ok) {
+			delete message;
+			Cancel();
+			return false;
+		}
+		acknowledgement->Wait();
+		return true;
+	}
+
+	void ReleaseCallback()
+	{
+		if (hasFileCompletionCallback_
+			&& !fileCompletionCallbackReleased_.exchange(true, std::memory_order_acq_rel)) {
+			fileCompletionCallback.Release();
+		}
+	}
+	std::uint64_t id = 0;
+	Napi::ThreadSafeFunction fileCompletionCallback;
+	bool hasFileCompletionCallback_ = false;
+
+private:
+	std::atomic<bool> cancelled_{false};
+	std::atomic<bool> fileCompletionCallbackReleased_{false};
+	mutable std::mutex failureMutex_;
+	std::string failure_;
+};
+
 std::uint64_t RegisterStream(std::shared_ptr<NativeStreamState> stream)
 {
 	const auto streamId = g_nextStreamId.fetch_add(1, std::memory_order_relaxed);
@@ -292,6 +437,31 @@ void RemoveStream(std::uint64_t streamId)
 	g_streams.erase(streamId);
 }
 
+std::uint64_t RegisterFileTask(std::shared_ptr<NativeFileTaskState> task)
+{
+	const auto taskId = g_nextFileTaskId.fetch_add(1, std::memory_order_relaxed);
+	if (taskId == 0) {
+		throw std::overflow_error("Native file task handle space exhausted");
+	}
+	std::lock_guard<std::mutex> lock(g_fileTasksMutex);
+	task->id = taskId;
+	g_fileTasks.emplace(taskId, std::move(task));
+	return taskId;
+}
+
+std::shared_ptr<NativeFileTaskState> FindFileTask(std::uint64_t taskId)
+{
+	std::lock_guard<std::mutex> lock(g_fileTasksMutex);
+	const auto found = g_fileTasks.find(taskId);
+	return found == g_fileTasks.end() ? nullptr : found->second;
+}
+
+void RemoveFileTask(std::uint64_t taskId)
+{
+	std::lock_guard<std::mutex> lock(g_fileTasksMutex);
+	g_fileTasks.erase(taskId);
+}
+
 FileStamp GetFileStamp(const std::string& path)
 {
 	std::error_code error;
@@ -489,8 +659,26 @@ struct Entry {
 struct ArchiveCreateItem {
 	std::string sourcePath;
 	std::string path;
+	double mtimeMs = 0;
 };
 
+FILETIME UnixMillisecondsToFileTime(double milliseconds)
+{
+	constexpr long double windowsEpochOffsetMs = 11644473600000.0L;
+	constexpr long double ticksPerMillisecond = 10000.0L;
+	const long double ticks =
+		(static_cast<long double>(milliseconds) + windowsEpochOffsetMs) * ticksPerMillisecond;
+	if (!std::isfinite(milliseconds) || ticks < 0
+		|| ticks > static_cast<long double>(std::numeric_limits<UInt64>::max())) {
+		throw std::out_of_range("Source file modification time is outside the FILETIME range");
+	}
+	const auto value = static_cast<UInt64>(ticks);
+	FILETIME fileTime{};
+	fileTime.dwLowDateTime = static_cast<DWORD>(value);
+	fileTime.dwHighDateTime = static_cast<DWORD>(value >> 32);
+	return fileTime;
+}
+
 std::uint64_t GetPropUInt64(IInArchive *archive, std::uint32_t index, PROPID propId)
 {
 	NWindows::NCOM::CPropVariant value;
@@ -521,6 +709,14 @@ bool GetPropBool(IInArchive *archive, std::uint32_t index, PROPID propId)
 	return value.boolVal != VARIANT_FALSE;
 }
 
+bool IsSolidArchive(IInArchive *archive)
+{
+	NWindows::NCOM::CPropVariant value;
+	return archive->GetArchiveProperty(kpidSolid, &value) == S_OK
+		&& value.vt == VT_BOOL
+		&& value.boolVal != VARIANT_FALSE;
+}
+
 std::string GetPropString(IInArchive *archive, std::uint32_t index, PROPID propId)
 {
 	NWindows::NCOM::CPropVariant value;
@@ -536,10 +732,32 @@ struct OutputRequest {
 	std::uint64_t length = 0;
 	std::uint64_t entrySize = 0;
 	bool encrypted = false;
+	bool abortOnLimit = false;
+	bool limitReached = false;
 	std::vector<std::uint8_t> data;
 	std::int32_t operationResult = NArchive::NExtract::NOperationResult::kUnavailable;
 };
 
+struct ReadRange {
+	std::uint64_t offset;
+	std::uint64_t length;
+};
+
+struct ExtractionProfile {
+	double validationMs = 0;
+	double reservationMs = 0;
+	double requestSetupMs = 0;
+	double contextAcquireMs = 0;
+	double solidCheckMs = 0;
+	double callbackSetupMs = 0;
+	double sevenZipExtractMs = 0;
+	double resultProcessingMs = 0;
+	double minSevenZipCallMs = 0;
+	double maxSevenZipCallMs = 0;
+	std::uint32_t sevenZipCalls = 0;
+	bool abortPerItem = false;
+};
+
 class FileInStream final : public IInStream, public CMyUnknownImp {
 	Z7_COM_QI_BEGIN2(IInStream)
 	Z7_COM_QI_ENTRY(ISequentialInStream)
@@ -891,6 +1109,8 @@ Z7_COM7F_IMF(ArchiveUpdateCallback::GetProperty(
 			property = path.c_str();
 		} else if (propertyId == kpidIsDir) {
 			property = false;
+		} else if (propertyId == kpidMTime) {
+			property = UnixMillisecondsToFileTime(item.mtimeMs);
 		} else if (propertyId == kpidSize) {
 			std::error_code error;
 			const auto size = std::filesystem::file_size(NativePath(item.sourcePath), error);
@@ -1046,6 +1266,13 @@ Z7_COM7F_IMF(VectorOutStream::Write(const void *data, UInt32 size, UInt32 *proce
 			bytes + static_cast<std::size_t>(copyEnd - start));
 	}
 	seen_ = end;
+	if (request_->abortOnLimit && request_->data.size() == request_->length) {
+		request_->limitReached = true;
+		if (processedSize != nullptr) {
+			*processedSize = 0;
+		}
+		return E_ABORT;
+	}
 	if (processedSize != nullptr) {
 		*processedSize = size;
 	}
@@ -1130,7 +1357,9 @@ Z7_COM7F_IMF(ExtractCallback::PrepareOperation(Int32))
 Z7_COM7F_IMF(ExtractCallback::SetOperationResult(Int32 operationResult))
 {
 	if (currentRequest_ != nullptr) {
-		currentRequest_->operationResult = operationResult;
+		currentRequest_->operationResult = currentRequest_->limitReached
+			? NArchive::NExtract::NOperationResult::kOK
+			: operationResult;
 	}
 	return S_OK;
 }
@@ -1201,67 +1430,657 @@ public:
 		std::uint32_t id,
 		std::shared_ptr<NativeStreamState> stream,
 		const std::optional<std::string>& password)
-		: id_(id),
-			stream_(std::move(stream)),
+		: 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 NativeFileOutputState {
+public:
+	NativeFileOutputState(std::uint32_t id, std::string path, std::uint64_t expectedSize, bool overwrite)
+		: id_(id),
+			path_(std::move(path)),
+			expectedSize_(expectedSize),
+			overwrite_(overwrite) {}
+
+	~NativeFileOutputState()
+	{
+		Abort();
+	}
+
+	bool Open()
+	{
+		if (overwrite_ && !RemoveOutputFile()) {
+			return false;
+		}
+#ifdef _WIN32
+		const auto nativePath = NativePath(path_);
+		fileDescriptor_ = ::_wopen(
+			nativePath.c_str(),
+			_O_WRONLY | _O_CREAT | _O_EXCL | _O_BINARY,
+			_S_IREAD | _S_IWRITE);
+#else
+		const auto nativePath = NativePath(path_);
+		int flags = O_WRONLY | O_CREAT | O_EXCL;
+#ifdef O_CLOEXEC
+		flags |= O_CLOEXEC;
+#endif
+#ifdef O_NOFOLLOW
+		flags |= O_NOFOLLOW;
+#endif
+		fileDescriptor_ = ::open(nativePath.c_str(), flags, 0600);
+#endif
+		if (fileDescriptor_ < 0) {
+			SetError("Unable to create extraction output file");
+			return false;
+		}
+		fileCreated_ = true;
+		return true;
+	}
+
+	bool Write(const std::vector<std::uint8_t>& data)
+	{
+		std::size_t offset = 0;
+		while (offset < data.size()) {
+#ifdef _WIN32
+			const auto written = ::_write(
+				fileDescriptor_,
+				data.data() + offset,
+				static_cast<unsigned int>(data.size() - offset));
+#else
+			const auto written = ::write(
+				fileDescriptor_,
+				data.data() + offset,
+				data.size() - offset);
+#endif
+			if (written < 0) {
+#ifndef _WIN32
+				if (errno == EINTR) {
+					continue;
+				}
+#endif
+				SetError("Unable to write extraction output file");
+				return false;
+			}
+			if (written == 0) {
+				SetError("Unable to write extraction output file");
+				return false;
+			}
+			const auto count = static_cast<std::size_t>(written);
+			offset += count;
+			bytesWritten_ += count;
+		}
+		return true;
+	}
+
+	bool Close()
+	{
+		if (fileDescriptor_ < 0) {
+			return error_.empty();
+		}
+#ifdef _WIN32
+		const auto result = ::_close(fileDescriptor_);
+#else
+		const auto result = ::close(fileDescriptor_);
+#endif
+		fileDescriptor_ = -1;
+		if (result != 0) {
+			SetError("Unable to close extraction output file");
+			return false;
+		}
+		return true;
+	}
+
+	void Abort()
+	{
+		Close();
+		if (fileCreated_ && !completed_) {
+			RemoveOutputFile();
+			fileCreated_ = false;
+		}
+	}
+
+	void MarkCompleted()
+	{
+		completed_ = true;
+	}
+
+	void AddQueuedBytes(std::uint64_t bytes)
+	{
+		bytesQueued_ += bytes;
+	}
+
+	void MarkSizeLimitExceeded()
+	{
+		sizeLimitExceeded_ = true;
+	}
+
+	std::uint32_t Id() const { return id_; }
+	std::uint64_t ExpectedSize() const { return expectedSize_; }
+	std::uint64_t BytesQueued() const { return bytesQueued_; }
+	std::uint64_t BytesWritten() const { return bytesWritten_; }
+	bool Completed() const { return completed_; }
+	bool SizeLimitExceeded() const { return sizeLimitExceeded_; }
+	const std::string& Error() const { return error_; }
+
+private:
+	void SetError(const char *message)
+	{
+		if (error_.empty()) {
+			error_ = std::string(message) + ": " + std::strerror(errno);
+		}
+	}
+
+	bool RemoveOutputFile()
+	{
+		const auto nativePath = NativePath(path_);
+#ifdef _WIN32
+		const auto result = ::_wunlink(nativePath.c_str());
+#else
+		const auto result = ::unlink(nativePath.c_str());
+#endif
+		if (result == 0 || errno == ENOENT) {
+			return true;
+		}
+		SetError("Unable to remove extraction output file");
+		return false;
+	}
+
+	std::uint32_t id_;
+	std::string path_;
+	int fileDescriptor_ = -1;
+	std::uint64_t expectedSize_;
+	bool overwrite_;
+	bool fileCreated_ = false;
+	bool completed_ = false;
+	std::uint64_t bytesQueued_ = 0;
+	std::uint64_t bytesWritten_ = 0;
+	bool sizeLimitExceeded_ = false;
+	std::string error_;
+};
+
+class AsyncFileWriter {
+public:
+	explicit AsyncFileWriter(std::shared_ptr<NativeFileTaskState> task)
+		: task_(std::move(task)) {}
+
+	~AsyncFileWriter()
+	{
+		StopAndJoin();
+	}
+
+	void Start()
+	{
+		worker_ = std::thread([this] { Run(); });
+	}
+
+	bool EnqueueWrite(
+		const std::shared_ptr<NativeFileOutputState>& output,
+		const std::uint8_t *data,
+		std::size_t size)
+	{
+		try {
+			std::vector<std::uint8_t> copy(data, data + size);
+			std::unique_lock<std::mutex> lock(mutex_);
+			spaceAvailable_.wait(lock, [this, size] {
+				return stopping_
+					|| task_->IsCancelled()
+					|| (HasQueueSpace() && queuedBytes_ + size <= kMaxQueuedBytes);
+			});
+			if (stopping_ || task_->IsCancelled()) {
+				return false;
+			}
+			queue_.push_back({Job::Kind::Write, output, std::move(copy)});
+			queuedBytes_ += size;
+		} catch (const std::exception& error) {
+			task_->Fail(error.what());
+			return false;
+		} catch (...) {
+			task_->Fail("Unable to queue extraction output data");
+			return false;
+		}
+		workAvailable_.notify_one();
+		return true;
+	}
+
+	bool EnqueueFinish(const std::shared_ptr<NativeFileOutputState>& output)
+	{
+		try {
+			{
+				std::unique_lock<std::mutex> lock(mutex_);
+				spaceAvailable_.wait(lock, [this] {
+					return stopping_ || HasQueueSpace();
+				});
+				if (stopping_) {
+					return false;
+				}
+				queue_.push_back({Job::Kind::Finish, output, {}});
+			}
+			workAvailable_.notify_one();
+			return true;
+		} catch (const std::exception& error) {
+			task_->Fail(error.what());
+			return false;
+		} catch (...) {
+			task_->Fail("Unable to queue extraction output completion");
+			return false;
+		}
+	}
+
+	bool EnqueueAbort(const std::shared_ptr<NativeFileOutputState>& output) noexcept
+	{
+		try {
+			{
+				std::unique_lock<std::mutex> lock(mutex_);
+				spaceAvailable_.wait(lock, [this] {
+					return stopping_ || HasQueueSpace();
+				});
+				if (stopping_) {
+					return false;
+				}
+				queue_.push_back({Job::Kind::Abort, output, {}});
+			}
+			workAvailable_.notify_one();
+			return true;
+		} catch (...) {
+			return false;
+		}
+	}
+
+	void WaitUntilIdle()
+	{
+		std::unique_lock<std::mutex> lock(mutex_);
+		idle_.wait(lock, [this] { return queue_.empty() && !active_; });
+	}
+
+	void StopAndJoin()
+	{
+		{
+			std::lock_guard<std::mutex> lock(mutex_);
+			stopping_ = true;
+		}
+		workAvailable_.notify_all();
+		spaceAvailable_.notify_all();
+		if (worker_.joinable()) {
+			worker_.join();
+		}
+	}
+
+private:
+	struct Job {
+		enum class Kind {
+			Write,
+			Finish,
+			Abort,
+		};
+
+		Kind kind;
+		std::shared_ptr<NativeFileOutputState> output;
+		std::vector<std::uint8_t> data;
+	};
+
+	static constexpr std::size_t kMaxQueuedBytes = 8 * 1024 * 1024;
+	static constexpr std::size_t kMaxQueuedJobs = 1024;
+
+	bool HasQueueSpace() const
+	{
+		return queue_.size() + (active_ ? 1 : 0) < kMaxQueuedJobs;
+	}
+
+	void Run() noexcept
+	{
+		while (true) {
+			Job job;
+			{
+				std::unique_lock<std::mutex> lock(mutex_);
+				workAvailable_.wait(lock, [this] {
+					return stopping_ || !queue_.empty();
+				});
+				if (queue_.empty() && stopping_) {
+					idle_.notify_all();
+					return;
+				}
+				job = std::move(queue_.front());
+				queue_.pop_front();
+				active_ = true;
+			}
+
+			try {
+				Process(job);
+			} catch (const std::exception& error) {
+				task_->Fail(error.what());
+				job.output->Abort();
+			} catch (...) {
+				task_->Fail("Unknown asynchronous extraction output failure");
+				job.output->Abort();
+			}
+
+			{
+				std::lock_guard<std::mutex> lock(mutex_);
+				if (job.kind == Job::Kind::Write) {
+					queuedBytes_ -= job.data.size();
+				}
+				active_ = false;
+				if (queue_.empty()) {
+					idle_.notify_all();
+				}
+			}
+			spaceAvailable_.notify_all();
+		}
+	}
+
+	void Process(const Job& job)
+	{
+		if (job.kind == Job::Kind::Abort) {
+			job.output->Abort();
+			return;
+		}
+		if (job.kind == Job::Kind::Write) {
+			if (task_->IsCancelled()) {
+				return;
+			}
+			if (!job.output->Write(job.data)) {
+				const auto& error = job.output->Error();
+				task_->Fail(error.empty() ? "Unable to write extraction output file" : error);
+				job.output->Abort();
+			}
+			return;
+		}
+		if (task_->IsCancelled()) {
+			job.output->Abort();
+			return;
+		}
+		if (!job.output->Close()) {
+			const auto& error = job.output->Error();
+			task_->Fail(error.empty() ? "Unable to close extraction output file" : error);
+			job.output->Abort();
+			return;
+		}
+		job.output->MarkCompleted();
+		task_->ReportFileCompleted(job.output->Id());
+	}
+
+	std::shared_ptr<NativeFileTaskState> task_;
+	std::mutex mutex_;
+	std::condition_variable workAvailable_;
+	std::condition_variable spaceAvailable_;
+	std::condition_variable idle_;
+	std::deque<Job> queue_;
+	std::size_t queuedBytes_ = 0;
+	bool active_ = false;
+	bool stopping_ = false;
+	std::thread worker_;
+};
+
+class NativeFileOutStream final : public ISequentialOutStream, public CMyUnknownImp {
+	Z7_COM_UNKNOWN_IMP_1(ISequentialOutStream)
+	Z7_COM7F_IMP(Write(const void *data, UInt32 size, UInt32 *processedSize))
+
+public:
+	NativeFileOutStream(
+		std::shared_ptr<NativeFileOutputState> output,
+		AsyncFileWriter& writer,
+		std::shared_ptr<NativeFileTaskState> task)
+		: output_(std::move(output)),
+			writer_(writer),
+			task_(std::move(task)) {}
+
+	~NativeFileOutStream()
+	{
+		if (!terminalQueued_) {
+			writer_.EnqueueAbort(output_);
+		}
+	}
+
+	bool Finish()
+	{
+		if (terminalQueued_) {
+			return true;
+		}
+		terminalQueued_ = writer_.EnqueueFinish(output_);
+		return terminalQueued_;
+	}
+
+	void Abort()
+	{
+		if (!terminalQueued_) {
+			terminalQueued_ = writer_.EnqueueAbort(output_);
+		}
+	}
+
+private:
+	std::shared_ptr<NativeFileOutputState> output_;
+	AsyncFileWriter& writer_;
+	std::shared_ptr<NativeFileTaskState> task_;
+	bool terminalQueued_ = false;
+};
+
+Z7_COM7F_IMF(NativeFileOutStream::Write(
+	const void *data, UInt32 size, UInt32 *processedSize))
+{
+	if (processedSize != nullptr) {
+		*processedSize = 0;
+	}
+	if (task_->IsCancelled()) {
+		return E_ABORT;
+	}
+	if (size > output_->ExpectedSize() - std::min(
+			output_->ExpectedSize(), output_->BytesQueued())) {
+		output_->MarkSizeLimitExceeded();
+		return E_ABORT;
+	}
+
+	const auto *bytes = static_cast<const std::uint8_t *>(data);
+	std::uint32_t offset = 0;
+	while (offset < size) {
+		if (task_->IsCancelled()) {
+			return E_ABORT;
+		}
+		const auto chunkSize = std::min<std::uint32_t>(64 * 1024, size - offset);
+		if (!writer_.EnqueueWrite(output_, bytes + offset, chunkSize)) {
+			return task_->IsCancelled() ? E_ABORT : E_FAIL;
+		}
+		output_->AddQueuedBytes(chunkSize);
+		offset += chunkSize;
+	}
+	if (processedSize != nullptr) {
+		*processedSize = size;
+	}
+	return S_OK;
+}
+
+struct NativeFileOutputSpec {
+	std::uint32_t id = 0;
+	std::string path;
+	bool overwrite = false;
+};
+
+struct FileOutputRequest {
+	std::uint32_t id = 0;
+	std::string path;
+	std::uint64_t expectedSize = 0;
+	bool overwrite = false;
+	std::int32_t operationResult = NArchive::NExtract::NOperationResult::kUnavailable;
+	NativeFileOutStream *stream = nullptr;
+	std::shared_ptr<NativeFileOutputState> output;
+	std::string error;
+};
+
+class BatchFileExtractCallback 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:
+	BatchFileExtractCallback(
+		std::vector<FileOutputRequest>& requests,
+		const std::unordered_map<std::uint32_t, std::size_t>& requestById,
+		std::shared_ptr<NativeFileTaskState> task,
+		AsyncFileWriter& writer,
+		const std::optional<std::string>& password)
+		: requests_(requests),
+			requestById_(requestById),
+			task_(std::move(task)),
+			writer_(writer),
 			password_(password),
-			operationResult_(NArchive::NExtract::NOperationResult::kUnavailable),
+			currentRequest_(nullptr),
 			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_;
+	std::vector<FileOutputRequest>& requests_;
+	const std::unordered_map<std::uint32_t, std::size_t>& requestById_;
+	std::shared_ptr<NativeFileTaskState> task_;
+	AsyncFileWriter& writer_;
 	const std::optional<std::string>& password_;
-	std::int32_t operationResult_;
-	std::vector<CMyComPtr<ISequentialOutStream>> streams_;
+	FileOutputRequest *currentRequest_;
 	std::atomic<bool> passwordRequested_;
+	std::vector<CMyComPtr<ISequentialOutStream>> streams_;
 };
 
-Z7_COM7F_IMF(StreamingExtractCallback::SetTotal(UInt64))
+Z7_COM7F_IMF(BatchFileExtractCallback::SetTotal(UInt64))
 {
 	return S_OK;
 }
 
-Z7_COM7F_IMF(StreamingExtractCallback::SetCompleted(const UInt64 *))
+Z7_COM7F_IMF(BatchFileExtractCallback::SetCompleted(const UInt64 *))
 {
-	return S_OK;
+	return task_->IsCancelled() ? E_ABORT : S_OK;
 }
 
-Z7_COM7F_IMF(StreamingExtractCallback::GetStream(
+Z7_COM7F_IMF(BatchFileExtractCallback::GetStream(
 	UInt32 index, ISequentialOutStream **outStream, Int32 askExtractMode))
 {
 	*outStream = nullptr;
-	if (askExtractMode != NArchive::NExtract::NAskMode::kExtract || index != id_) {
+	currentRequest_ = nullptr;
+	if (task_->IsCancelled()) {
+		return E_ABORT;
+	}
+	if (askExtractMode != NArchive::NExtract::NAskMode::kExtract) {
 		return S_OK;
 	}
-	CMyComPtr<ISequentialOutStream> stream = new StreamingOutStream(stream_);
-	streams_.push_back(stream);
-	*outStream = stream;
+	const auto found = requestById_.find(index);
+	if (found == requestById_.end()) {
+		return S_OK;
+	}
+	auto& request = requests_[found->second];
+	currentRequest_ = &request;
+	request.output = std::make_shared<NativeFileOutputState>(
+		request.id, request.path, request.expectedSize, request.overwrite);
+	if (!request.output->Open()) {
+		request.error = request.output->Error();
+		return E_FAIL;
+	}
+	auto *fileStream = new NativeFileOutStream(
+		request.output, writer_, task_);
+	CMyComPtr<ISequentialOutStream> output = fileStream;
+	request.stream = fileStream;
+	streams_.push_back(output);
+	*outStream = output;
 	(*outStream)->AddRef();
 	return S_OK;
 }
 
-Z7_COM7F_IMF(StreamingExtractCallback::PrepareOperation(Int32))
+Z7_COM7F_IMF(BatchFileExtractCallback::PrepareOperation(Int32))
 {
-	return S_OK;
+	return task_->IsCancelled() ? E_ABORT : S_OK;
 }
 
-Z7_COM7F_IMF(StreamingExtractCallback::SetOperationResult(Int32 operationResult))
+Z7_COM7F_IMF(BatchFileExtractCallback::SetOperationResult(Int32 operationResult))
 {
-	operationResult_ = operationResult;
+	if (currentRequest_ != nullptr) {
+		currentRequest_->operationResult = operationResult;
+		if (operationResult == NArchive::NExtract::NOperationResult::kOK
+			&& currentRequest_->stream != nullptr
+			&& currentRequest_->error.empty()
+			&& currentRequest_->output != nullptr
+			&& !currentRequest_->output->SizeLimitExceeded()) {
+			if (!currentRequest_->stream->Finish()) {
+				currentRequest_->error = task_->Failure();
+				return E_ABORT;
+			}
+		} else if (currentRequest_->stream != nullptr) {
+			currentRequest_->stream->Abort();
+		}
+	}
 	return S_OK;
 }
 
-Z7_COM7F_IMF(StreamingExtractCallback::CryptoGetTextPassword(BSTR *password))
+Z7_COM7F_IMF(BatchFileExtractCallback::CryptoGetTextPassword(BSTR *password))
 {
 	passwordRequested_.store(true, std::memory_order_release);
 	return GetPasswordBstr(password_, password);
@@ -1323,11 +2142,13 @@ public:
 	void Open(
 		const std::string& path,
 		std::optional<std::string> password,
-		const std::string& enginePath)
+		const std::string& enginePath,
+		std::uint32_t deflateBufferSize)
 	{
 		EnsureEngineLoaded(enginePath);
 		path_ = path;
 		password_ = std::move(password);
+		deflateBufferSize_ = deflateBufferSize;
 		const auto extension = Extension(path);
 		UInt32 formatCount = 0;
 		if (g_getNumberOfFormats(&formatCount) != S_OK || formatCount == 0) {
@@ -1477,17 +2298,27 @@ public:
 
 	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)
+		const std::vector<ReadRange>& ranges,
+		OutputReservation& outputReservation,
+		ExtractionProfile *profile = nullptr)
 	{
+		using Clock = std::chrono::steady_clock;
+		const auto elapsedMs = [](Clock::time_point start) {
+			return std::chrono::duration<double, std::milli>(Clock::now() - start).count();
+		};
+		Clock::time_point phaseStart;
 		if (contexts_.empty()) {
 			throw std::runtime_error("Archive is closed");
 		}
+		if (!ranges.empty() && ranges.size() != ids.size()) {
+			throw std::invalid_argument("Read ranges must match the requested entry count");
+		}
 		std::unordered_map<std::uint32_t, std::size_t> requestById;
 		requestById.reserve(ids.size());
 		std::uint64_t totalRequested = 0;
+		if (profile != nullptr) {
+			phaseStart = Clock::now();
+		}
 		for (std::size_t requestIndex = 0; requestIndex < ids.size(); ++requestIndex) {
 			const auto id = ids[requestIndex];
 			if (id >= entries_.size()) {
@@ -1497,9 +2328,10 @@ public:
 			if (entry.directory) {
 				throw std::invalid_argument("Cannot read a directory entry");
 			}
-			const auto start = partial ? std::min(offset, entry.size) : 0;
+			const bool partial = !ranges.empty();
+			const auto start = partial ? std::min(ranges[requestIndex].offset, entry.size) : 0;
 			const auto available = entry.size - start;
-			const auto requested = partial ? std::min(length, available) : entry.size;
+			const auto requested = partial ? std::min(ranges[requestIndex].length, available) : entry.size;
 			if (!requestById.emplace(id, requestIndex).second) {
 				throw std::invalid_argument("Duplicate entry IDs are not allowed in a batch");
 			}
@@ -1509,14 +2341,24 @@ public:
 			}
 			totalRequested += requested;
 		}
+		if (profile != nullptr) {
+			profile->validationMs = elapsedMs(phaseStart);
+			phaseStart = Clock::now();
+		}
 		outputReservation.Acquire(totalRequested);
+		if (profile != nullptr) {
+			profile->reservationMs = elapsedMs(phaseStart);
+			phaseStart = Clock::now();
+		}
 		std::vector<OutputRequest> requests;
 		requests.reserve(ids.size());
-		for (const auto id : ids) {
+		for (std::size_t requestIndex = 0; requestIndex < ids.size(); ++requestIndex) {
+			const auto id = ids[requestIndex];
 			const auto& entry = entries_[id];
-			const auto start = partial ? std::min(offset, entry.size) : 0;
+			const bool partial = !ranges.empty();
+			const auto start = partial ? std::min(ranges[requestIndex].offset, entry.size) : 0;
 			const auto available = entry.size - start;
-			const auto requested = partial ? std::min(length, available) : entry.size;
+			const auto requested = partial ? std::min(ranges[requestIndex].length, available) : entry.size;
 			OutputRequest request;
 			request.id = id;
 			request.offset = start;
@@ -1529,6 +2371,11 @@ public:
 		std::vector<UInt32> sortedIds;
 		sortedIds.reserve(requestById.size());
 		for (const auto& item : requestById) {
+			auto& request = requests[item.second];
+			if (!ranges.empty() && request.length == 0) {
+				request.operationResult = NArchive::NExtract::NOperationResult::kOK;
+				continue;
+			}
 			sortedIds.push_back(item.first);
 		}
 		if (std::all_of(requests.begin(), requests.end(), [](const OutputRequest& request) {
@@ -1537,14 +2384,77 @@ public:
 			return std::vector<std::vector<std::uint8_t>>(ids.size());
 		}
 		std::sort(sortedIds.begin(), sortedIds.end());
+		if (profile != nullptr) {
+			profile->requestSetupMs = elapsedMs(phaseStart);
+			phaseStart = Clock::now();
+		}
 		auto context = AcquireContext();
+		if (profile != nullptr) {
+			profile->contextAcquireMs = elapsedMs(phaseStart);
+			phaseStart = Clock::now();
+		}
+		const bool abortPerItem = !ranges.empty() && !IsSolidArchive(context->archive);
+		if (profile != nullptr) {
+			profile->solidCheckMs = elapsedMs(phaseStart);
+			profile->abortPerItem = abortPerItem;
+			phaseStart = Clock::now();
+		}
+		if (abortPerItem) {
+			for (auto& request : requests) {
+				request.abortOnLimit = request.offset + request.length < request.entrySize;
+			}
+		}
 		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 (profile != nullptr) {
+			profile->callbackSetupMs = elapsedMs(phaseStart);
+			phaseStart = Clock::now();
+		}
+		HRESULT result = S_OK;
+		if (g_setDeflateInputBufferSize(deflateBufferSize_) != S_OK) {
+			throw std::runtime_error("Unable to configure the Deflate input buffer");
+		}
+		if (abortPerItem) {
+			for (const auto id : sortedIds) {
+				const auto requestIndex = requestById.at(id);
+				const UInt32 itemId = id;
+				const auto callStart = profile != nullptr ? Clock::now() : Clock::time_point{};
+				const auto itemResult = context->archive->Extract(&itemId, 1, 0, callback);
+				if (profile != nullptr) {
+					const double callMs = elapsedMs(callStart);
+					if (profile->sevenZipCalls == 0 || callMs < profile->minSevenZipCallMs) {
+						profile->minSevenZipCallMs = callMs;
+					}
+					profile->maxSevenZipCallMs = std::max(profile->maxSevenZipCallMs, callMs);
+					++profile->sevenZipCalls;
+				}
+				if (itemResult == E_ABORT && requests[requestIndex].limitReached) {
+					requests[requestIndex].operationResult = NArchive::NExtract::NOperationResult::kOK;
+					continue;
+				}
+				if (itemResult != S_OK) {
+					result = itemResult;
+					break;
+				}
+			}
+		} else {
+			const auto callStart = profile != nullptr ? Clock::now() : Clock::time_point{};
+			result = context->archive->Extract(
+				sortedIds.empty() ? nullptr : sortedIds.data(),
+				static_cast<UInt32>(sortedIds.size()),
+				0,
+				callback);
+			if (profile != nullptr) {
+				const double callMs = elapsedMs(callStart);
+				profile->sevenZipCalls = 1;
+				profile->minSevenZipCallMs = callMs;
+				profile->maxSevenZipCallMs = callMs;
+			}
+		}
+		if (profile != nullptr) {
+			profile->sevenZipExtractMs = elapsedMs(phaseStart);
+			phaseStart = Clock::now();
+		}
 		if (result != S_OK) {
 			if (extractCallbackObject->PasswordRequested()) {
 				throw std::runtime_error("Archive password is missing or incorrect");
@@ -1567,6 +2477,9 @@ public:
 		for (const auto id : ids) {
 			resultData.push_back(std::move(requests[requestById.at(id)].data));
 		}
+		if (profile != nullptr) {
+			profile->resultProcessingMs = elapsedMs(phaseStart);
+		}
 		return resultData;
 	}
 
@@ -1585,6 +2498,9 @@ public:
 		auto *extractCallbackObject = new StreamingExtractCallback(id, stream, password_);
 		CMyComPtr<IArchiveExtractCallback> callback = extractCallbackObject;
 		const UInt32 itemIndex = id;
+		if (g_setDeflateInputBufferSize(deflateBufferSize_) != S_OK) {
+			throw std::runtime_error("Unable to configure the Deflate input buffer");
+		}
 		const auto result = context->archive->Extract(&itemIndex, 1, 0, callback);
 		if (result != S_OK) {
 			if (extractCallbackObject->PasswordRequested()) {
@@ -1605,6 +2521,120 @@ public:
 		}
 	}
 
+	void ExtractToFiles(
+		const std::vector<NativeFileOutputSpec>& outputs,
+		const std::shared_ptr<NativeFileTaskState>& task,
+		AsyncFileWriter& writer)
+	{
+		if (contexts_.empty()) {
+			throw std::runtime_error("Archive is closed");
+		}
+		if (task->IsCancelled()) {
+			const auto failure = task->Failure();
+			throw std::runtime_error(failure.empty()
+				? "Native folder extraction was cancelled"
+				: failure);
+		}
+		if (outputs.empty()) {
+			return;
+		}
+
+		std::vector<FileOutputRequest> requests;
+		requests.reserve(outputs.size());
+		std::unordered_map<std::uint32_t, std::size_t> requestById;
+		requestById.reserve(outputs.size());
+		std::vector<UInt32> sortedIds;
+		sortedIds.reserve(outputs.size());
+		for (const auto& output : outputs) {
+			const auto id = output.id;
+			const auto& path = output.path;
+			if (id >= entries_.size()) {
+				throw std::out_of_range("Entry ID is out of range");
+			}
+			if (entries_[id].directory) {
+				throw std::invalid_argument("Cannot extract a directory entry to a file");
+			}
+			if (path.empty() || path.find('\0') != std::string::npos) {
+				throw std::invalid_argument("Extraction output paths must be non-empty and contain no null bytes");
+			}
+			if (!requestById.emplace(id, requests.size()).second) {
+				throw std::invalid_argument("Duplicate entry IDs are not allowed in a folder extraction batch");
+			}
+			requests.push_back({
+				id,
+				path,
+				entries_[id].size,
+				output.overwrite,
+				NArchive::NExtract::NOperationResult::kUnavailable,
+				nullptr,
+				nullptr,
+				{},
+			});
+			sortedIds.push_back(id);
+		}
+		std::sort(sortedIds.begin(), sortedIds.end());
+
+		HRESULT result = E_FAIL;
+		bool passwordRequested = false;
+		{
+			auto context = AcquireContext();
+			auto *extractCallbackObject = new BatchFileExtractCallback(
+				requests, requestById, task, writer, password_);
+			CMyComPtr<IArchiveExtractCallback> callback = extractCallbackObject;
+			if (g_setDeflateInputBufferSize(deflateBufferSize_) != S_OK) {
+				throw std::runtime_error("Unable to configure the Deflate input buffer");
+			}
+			result = context->archive->Extract(
+				sortedIds.data(),
+				static_cast<UInt32>(sortedIds.size()),
+				0,
+				callback);
+			passwordRequested = extractCallbackObject->PasswordRequested();
+		}
+		writer.WaitUntilIdle();
+		const auto writerFailure = task->Failure();
+		if (!writerFailure.empty()) {
+			throw std::runtime_error(writerFailure);
+		}
+		if (task->IsCancelled()) {
+			throw std::runtime_error("Native folder extraction was cancelled");
+		}
+		for (const auto& request : requests) {
+			if (!request.error.empty()) {
+				throw std::runtime_error(request.error);
+			}
+			if (request.output != nullptr && request.output->SizeLimitExceeded()) {
+				throw std::runtime_error(
+					"Extracted entry exceeds its declared size: " + request.path);
+			}
+		}
+		if (result != S_OK) {
+			if (passwordRequested) {
+				throw std::runtime_error("Archive password is missing or incorrect");
+			}
+			throw std::runtime_error("7-Zip failed to extract the requested files");
+		}
+		for (const auto& request : requests) {
+			if (request.operationResult != NArchive::NExtract::NOperationResult::kOK) {
+				if (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): "
+					+ request.path);
+			}
+			if (request.output == nullptr || !request.output->Completed()) {
+				throw std::runtime_error("Entry output did not finish writing: " + request.path);
+			}
+			if (request.output->BytesWritten() != request.output->BytesQueued()) {
+				throw std::runtime_error("Entry output write count is inconsistent: " + request.path);
+			}
+		}
+	}
+
 private:
 	ContextLease AcquireContext()
 	{
@@ -1728,6 +2758,7 @@ private:
 	FileStamp fileStamp_{};
 	std::optional<std::string> password_;
 	std::vector<Entry> entries_;
+	std::uint32_t deflateBufferSize_ = 32 * 1024;
 };
 
 Napi::Object EntryToJs(Napi::Env env, const Entry& entry)
@@ -1752,7 +2783,7 @@ Napi::Buffer<std::uint8_t> TakeBuffer(Napi::Env env, std::vector<std::uint8_t> d
 		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(
+	return Napi::Buffer<std::uint8_t>::NewOrCopy(
 		env,
 		owned->data(),
 		owned->size(),
@@ -1789,6 +2820,21 @@ void StreamMessageToJs(Napi::Env env, Napi::Function callback, StreamMessage *me
 	}
 }
 
+void FileCompletionToJs(
+	Napi::Env env,
+	Napi::Function callback,
+	FileCompletionMessage *message)
+{
+	std::unique_ptr<FileCompletionMessage> owned(message);
+	if (message->kind == FileCompletionMessage::Kind::Barrier) {
+		message->acknowledgement->Acknowledge();
+		return;
+	}
+	if (env != nullptr && callback) {
+		callback.Call({Napi::Number::New(env, message->entryId)});
+	}
+}
+
 class BoundedAsyncWorker : public Napi::AsyncWorker {
 public:
 	BoundedAsyncWorker(Napi::Env env, Napi::Promise::Deferred deferred)
@@ -1815,11 +2861,13 @@ public:
 		Napi::Promise::Deferred deferred,
 		std::string path,
 		std::optional<std::string> password,
-		std::string enginePath)
+		std::string enginePath,
+		std::uint32_t deflateBufferSize)
 		: BoundedAsyncWorker(env, deferred),
 			path_(std::move(path)),
 			password_(std::move(password)),
-			enginePath_(std::move(enginePath)) {}
+			enginePath_(std::move(enginePath)),
+			deflateBufferSize_(deflateBufferSize) {}
 
 	~OpenWorker() override
 	{
@@ -1832,7 +2880,7 @@ public:
 	{
 		try {
 			archive_ = std::make_shared<ArchiveEngine>();
-			archive_->Open(path_, std::move(password_), enginePath_);
+			archive_->Open(path_, std::move(password_), enginePath_, deflateBufferSize_);
 		} catch (const std::exception& error) {
 			SetError(error.what());
 		} catch (...) {
@@ -1854,6 +2902,7 @@ private:
 	std::string path_;
 	std::optional<std::string> password_;
 	std::string enginePath_;
+	std::uint32_t deflateBufferSize_;
 	std::shared_ptr<ArchiveEngine> archive_;
 };
 
@@ -1897,15 +2946,14 @@ public:
 		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)
+		std::vector<ReadRange> ranges,
+		bool singleOutput)
 		: deferred_(deferred),
 			archive_(std::move(archive)),
 			ids_(std::move(ids)),
-			partial_(partial),
-			offset_(offset),
-			length_(length) {}
+			ranges_(std::move(ranges)),
+			singleOutput_(singleOutput),
+			profileEnabled_(std::getenv("ZIP_NATIVE_PROFILE_READ") != nullptr) {}
 
 	~ExtractWorker() override
 	{
@@ -1914,23 +2962,58 @@ public:
 
 	void Execute() noexcept override
 	{
+		std::chrono::steady_clock::time_point started;
+		if (profileEnabled_) {
+			started = std::chrono::steady_clock::now();
+		}
 		try {
-			outputs_ = archive_->Extract(ids_, partial_, offset_, length_, outputReservation_);
+			outputs_ = archive_->Extract(
+				ids_,
+				ranges_,
+				outputReservation_,
+				profileEnabled_ ? &profile_ : nullptr);
 		} catch (const std::exception& error) {
 			error_ = error.what();
 		} catch (...) {
 			error_ = "Unknown native extraction failure";
 		}
+		if (profileEnabled_) {
+			executionMs_ = std::chrono::duration<double, std::milli>(
+				std::chrono::steady_clock::now() - started).count();
+		}
 	}
 
 	void Complete(Napi::Env env) override
 	{
+		if (profileEnabled_) {
+			std::fprintf(
+				stderr,
+				"[7zip-native profile] worker=%.3f ms, validation=%.3f, reservation=%.3f, "
+				"requestSetup=%.3f, contextAcquire=%.3f, solidCheck=%.3f, callbackSetup=%.3f, "
+				"sevenZipExtract=%.3f (%u calls; perItem=%d; callMin=%.3f; callMax=%.3f), "
+				"resultProcessing=%.3f, entries=%zu\n",
+				executionMs_,
+				profile_.validationMs,
+				profile_.reservationMs,
+				profile_.requestSetupMs,
+				profile_.contextAcquireMs,
+				profile_.solidCheckMs,
+				profile_.callbackSetupMs,
+				profile_.sevenZipExtractMs,
+				profile_.sevenZipCalls,
+				profile_.abortPerItem,
+				profile_.minSevenZipCallMs,
+				profile_.maxSevenZipCallMs,
+				profile_.resultProcessingMs,
+				ids_.size());
+			std::fflush(stderr);
+		}
 		try {
 			if (!error_.empty()) {
 				deferred_.Reject(Napi::Error::New(env, error_).Value());
 				return;
 			}
-			if (partial_) {
+			if (singleOutput_) {
 				deferred_.Resolve(TakeBuffer(env, std::move(outputs_.front())));
 				return;
 			}
@@ -1951,9 +3034,11 @@ private:
 	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<ReadRange> ranges_;
+	bool singleOutput_;
+	bool profileEnabled_;
+	double executionMs_ = 0;
+	ExtractionProfile profile_;
 	std::vector<std::vector<std::uint8_t>> outputs_;
 	std::string error_;
 };
@@ -2078,6 +3163,65 @@ private:
 	bool completed_ = false;
 };
 
+class ExtractToFilesWorker final : public ExtractionTask {
+public:
+	ExtractToFilesWorker(
+		Napi::Promise::Deferred deferred,
+		std::shared_ptr<ArchiveEngine> archive,
+		std::vector<NativeFileOutputSpec> outputs,
+		std::shared_ptr<NativeFileTaskState> task)
+		: deferred_(deferred),
+			archive_(std::move(archive)),
+			outputs_(std::move(outputs)),
+			task_(std::move(task)) {}
+
+	~ExtractToFilesWorker() override
+	{
+		RemoveFileTask(task_->id);
+		task_->ReleaseCallback();
+		g_pendingOperations.fetch_sub(1, std::memory_order_acq_rel);
+	}
+
+	void Execute() noexcept override
+	{
+		AsyncFileWriter writer(task_);
+		try {
+			writer.Start();
+			archive_->ExtractToFiles(outputs_, task_, writer);
+		} catch (const std::exception& error) {
+			error_ = error.what();
+		} catch (...) {
+			error_ = "Unknown native file extraction failure";
+		}
+		writer.StopAndJoin();
+		if (error_.empty()) {
+			error_ = task_->Failure();
+			if (error_.empty() && task_->IsCancelled()) {
+				error_ = "Native folder extraction was cancelled";
+			}
+		}
+		if (!task_->WaitForFileCompletions() && error_.empty()) {
+			error_ = "Unable to deliver native file completion events";
+		}
+	}
+
+	void Complete(Napi::Env env) override
+	{
+		if (!error_.empty()) {
+			deferred_.Reject(Napi::Error::New(env, error_).Value());
+			return;
+		}
+		deferred_.Resolve(env.Undefined());
+	}
+
+private:
+	Napi::Promise::Deferred deferred_;
+	std::shared_ptr<ArchiveEngine> archive_;
+	std::vector<NativeFileOutputSpec> outputs_;
+	std::shared_ptr<NativeFileTaskState> task_;
+	std::string error_;
+};
+
 class ExtractionPool {
 public:
 	void Initialize(Napi::Env env)
@@ -2244,9 +3388,19 @@ private:
 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");
+	if (info.Length() != 4 || !info[0].IsString()
+		|| (!info[1].IsUndefined() && !info[1].IsString())
+		|| !info[2].IsString() || !info[3].IsNumber()) {
+		throw Napi::TypeError::New(
+			env, "open(path, password?, enginePath, deflateBufferSize) expects a path, optional password, engine path, and buffer size");
+	}
+	const double deflateBufferSizeValue = info[3].As<Napi::Number>().DoubleValue();
+	if (!std::isfinite(deflateBufferSizeValue)
+		|| std::floor(deflateBufferSizeValue) != deflateBufferSizeValue
+		|| deflateBufferSizeValue < kMinDeflateBufferSize
+		|| deflateBufferSizeValue > kMaxDeflateBufferSize) {
+		throw Napi::RangeError::New(
+			env, "Deflate buffer size must be an integer between 4096 and 2097152 bytes");
 	}
 	std::optional<std::string> password;
 	if (info[1].IsString()) {
@@ -2264,7 +3418,8 @@ Napi::Value Open(const Napi::CallbackInfo& info)
 		deferred,
 		info[0].As<Napi::String>().Utf8Value(),
 		std::move(password),
-		info[2].As<Napi::String>().Utf8Value());
+		info[2].As<Napi::String>().Utf8Value(),
+		static_cast<std::uint32_t>(deflateBufferSizeValue));
 	worker->Queue();
 	return deferred.Promise();
 }
@@ -2300,13 +3455,19 @@ Napi::Value CreateArchive(const Napi::CallbackInfo& info)
 		const auto item = value.As<Napi::Object>();
 		const auto sourcePath = item.Get("sourcePath");
 		const auto archivePath = item.Get("path");
-		if (!sourcePath.IsString() || !archivePath.IsString()) {
+		const auto mtimeMs = item.Get("mtimeMs");
+		if (!sourcePath.IsString() || !archivePath.IsString() || !mtimeMs.IsNumber()) {
 			throw Napi::TypeError::New(
-				env, "Archive creation entries require string sourcePath and path values");
+				env, "Archive creation entries require string sourcePath, path, and numeric mtimeMs values");
+		}
+		const double sourceMtimeMs = mtimeMs.As<Napi::Number>().DoubleValue();
+		if (!std::isfinite(sourceMtimeMs)) {
+			throw Napi::TypeError::New(env, "Archive creation entry mtimeMs must be finite");
 		}
 		entries.push_back({
 			sourcePath.As<Napi::String>().Utf8Value(),
 			archivePath.As<Napi::String>().Utf8Value(),
+			sourceMtimeMs,
 		});
 	}
 	if (!ReserveOperation()) {
@@ -2368,9 +3529,8 @@ Napi::Value QueueExtraction(
 	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)
+	std::vector<ReadRange> ranges,
+	bool singleOutput)
 {
 	if (!ReserveOperation()) {
 		throw Napi::Error::New(env, "Native operation queue is full");
@@ -2381,7 +3541,7 @@ Napi::Value QueueExtraction(
 			throw std::runtime_error("Native extraction pool is not initialized");
 		}
 		worker = new ExtractWorker(
-			deferred, std::move(archive), std::move(ids), partial, offset, length);
+			deferred, std::move(archive), std::move(ids), std::move(ranges), singleOutput);
 		g_extractionPool->Queue(env, worker);
 	} catch (const std::exception& error) {
 		if (worker != nullptr) {
@@ -2424,7 +3584,7 @@ Napi::Value Extract(const Napi::CallbackInfo& info)
 	}
 	auto deferred = Napi::Promise::Deferred::New(env);
 	return QueueExtraction(
-		env, deferred, std::move(archive), std::move(ids), false, 0, 0);
+		env, deferred, std::move(archive), std::move(ids), {}, false);
 }
 
 Napi::Value StartStream(const Napi::CallbackInfo& info)
@@ -2491,6 +3651,128 @@ Napi::Value StartStream(const Napi::CallbackInfo& info)
 	}
 }
 
+Napi::Value StartExtractToFiles(const Napi::CallbackInfo& info)
+{
+	const auto env = info.Env();
+	if (info.Length() < 2
+		|| info.Length() > 3
+		|| !info[1].IsArray()
+		|| (info.Length() == 3 && !info[2].IsUndefined() && !info[2].IsFunction())) {
+		throw Napi::TypeError::New(
+			env, "startExtractToFiles(handle, files, fileCompleteCallback?) expects a handle, file list, and an optional file-completion callback");
+	}
+	const auto handle = GetHandle(info[0]);
+	auto archive = FindArchive(handle);
+	if (!archive) {
+		throw Napi::Error::New(env, "Archive is closed");
+	}
+	const auto inputFiles = info[1].As<Napi::Array>();
+	if (inputFiles.Length() > kMaxEntries) {
+		throw Napi::RangeError::New(env, "Folder extraction batch exceeds the native entry limit");
+	}
+	std::vector<NativeFileOutputSpec> outputs;
+	outputs.reserve(inputFiles.Length());
+	for (std::uint32_t index = 0; index < inputFiles.Length(); ++index) {
+		const auto value = inputFiles.Get(index);
+		if (!value.IsObject() || value.IsNull()) {
+			throw Napi::TypeError::New(env, "Folder extraction files must be objects");
+		}
+		const auto file = value.As<Napi::Object>();
+		std::uint64_t id = 0;
+		const auto path = file.Get("path");
+		const auto overwrite = file.Get("overwrite");
+		if (!ReadUnsigned(file.Get("id"), id)
+			|| id > std::numeric_limits<std::uint32_t>::max()
+			|| !path.IsString()
+			|| !overwrite.IsBoolean()) {
+			throw Napi::TypeError::New(
+				env, "Folder extraction files require a valid entry ID, output path, and overwrite flag");
+		}
+		outputs.push_back({
+			static_cast<std::uint32_t>(id),
+			path.As<Napi::String>().Utf8Value(),
+			overwrite.As<Napi::Boolean>().Value(),
+		});
+	}
+	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<NativeFileTaskState> task;
+	ExtractToFilesWorker *worker = nullptr;
+	std::uint64_t taskId = 0;
+	try {
+		task = std::make_shared<NativeFileTaskState>();
+		if (info.Length() == 3 && info[2].IsFunction()) {
+			task->fileCompletionCallback = Napi::ThreadSafeFunction::New(
+				env,
+				info[2].As<Napi::Function>(),
+				"7zip-native folder file completion",
+				1,
+				1);
+			task->hasFileCompletionCallback_ = true;
+		}
+		taskId = RegisterFileTask(task);
+		auto deferred = Napi::Promise::Deferred::New(env);
+		auto result = Napi::Object::New(env);
+		result.Set("taskId", Napi::BigInt::New(env, taskId));
+		result.Set("promise", deferred.Promise());
+		worker = new ExtractToFilesWorker(
+			deferred,
+			std::move(archive),
+			std::move(outputs),
+			task);
+		g_extractionPool->Queue(env, worker);
+		worker = nullptr;
+		return result;
+	} catch (const std::exception& error) {
+		if (worker != nullptr) {
+			delete worker;
+		} else {
+			if (taskId != 0) {
+				RemoveFileTask(taskId);
+			}
+			if (task) {
+				task->Cancel();
+				task->ReleaseCallback();
+			}
+			g_pendingOperations.fetch_sub(1, std::memory_order_acq_rel);
+		}
+		throw Napi::Error::New(env, error.what());
+	} catch (...) {
+		if (worker != nullptr) {
+			delete worker;
+		} else {
+			if (taskId != 0) {
+				RemoveFileTask(taskId);
+			}
+			if (task) {
+				task->Cancel();
+				task->ReleaseCallback();
+			}
+			g_pendingOperations.fetch_sub(1, std::memory_order_acq_rel);
+		}
+		throw Napi::Error::New(env, "Unable to queue native folder extraction");
+	}
+}
+
+Napi::Value CancelExtractToFiles(const Napi::CallbackInfo& info)
+{
+	const auto env = info.Env();
+	std::uint64_t taskId = 0;
+	if (info.Length() != 1 || !ReadUnsigned(info[0], taskId) || taskId == 0) {
+		throw Napi::TypeError::New(
+			env, "cancelExtractToFiles(taskId) expects a positive task ID");
+	}
+	if (const auto task = FindFileTask(taskId)) {
+		task->Cancel();
+	}
+	return env.Undefined();
+}
+
 Napi::Value ResumeStream(const Napi::CallbackInfo& info)
 {
 	const auto env = info.Env();
@@ -2544,9 +3826,52 @@ Napi::Value Read(const Napi::CallbackInfo& info)
 		deferred,
 		std::move(archive),
 		{static_cast<std::uint32_t>(id)},
-		true,
-		offset,
-		length);
+		{{offset, length}},
+		true);
+}
+
+Napi::Value ReadMany(const Napi::CallbackInfo& info)
+{
+	const auto env = info.Env();
+	if (info.Length() != 2 || !info[1].IsArray()) {
+		throw Napi::TypeError::New(env, "readMany(handle, requests) expects an array of read requests");
+	}
+	const auto handle = GetHandle(info[0]);
+	auto archive = FindArchive(handle);
+	if (!archive) {
+		throw Napi::Error::New(env, "Archive is closed");
+	}
+	const auto inputRequests = info[1].As<Napi::Array>();
+	if (inputRequests.Length() > kMaxEntries) {
+		throw Napi::RangeError::New(env, "Batch read exceeds the native entry limit");
+	}
+	std::vector<std::uint32_t> ids;
+	std::vector<ReadRange> ranges;
+	ids.reserve(inputRequests.Length());
+	ranges.reserve(inputRequests.Length());
+	for (std::uint32_t i = 0; i < inputRequests.Length(); ++i) {
+		const auto value = inputRequests.Get(i);
+		if (!value.IsObject() || value.IsNull()) {
+			throw Napi::TypeError::New(env, "Batch read requests must be objects");
+		}
+		const auto request = value.As<Napi::Object>();
+		std::uint64_t id = 0;
+		std::uint64_t offset = 0;
+		std::uint64_t length = 0;
+		if (!ReadUnsigned(request.Get("id"), id) || id > std::numeric_limits<std::uint32_t>::max()
+			|| !ReadUnsigned(request.Get("offset"), offset) || !ReadUnsigned(request.Get("length"), length)) {
+			throw Napi::TypeError::New(
+				env, "Batch read requests require a valid entry ID, offset, and length");
+		}
+		if (length > kMaxReadBytes || offset > std::numeric_limits<std::uint64_t>::max() - length) {
+			throw Napi::RangeError::New(env, "Requested range exceeds the native read limit");
+		}
+		ids.push_back(static_cast<std::uint32_t>(id));
+		ranges.push_back({offset, length});
+	}
+	auto deferred = Napi::Promise::Deferred::New(env);
+	return QueueExtraction(
+		env, deferred, std::move(archive), std::move(ids), std::move(ranges), false);
 }
 
 Napi::Value Concurrency(const Napi::CallbackInfo& info)
@@ -2610,7 +3935,10 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
 	exports.Set("create", Napi::Function::New(env, CreateArchive));
 	exports.Set("entries", Napi::Function::New(env, Entries));
 	exports.Set("extract", Napi::Function::New(env, Extract));
+	exports.Set("readMany", Napi::Function::New(env, ReadMany));
 	exports.Set("startStream", Napi::Function::New(env, StartStream));
+	exports.Set("startExtractToFiles", Napi::Function::New(env, StartExtractToFiles));
+	exports.Set("cancelExtractToFiles", Napi::Function::New(env, CancelExtractToFiles));
 	exports.Set("resumeStream", Napi::Function::New(env, ResumeStream));
 	exports.Set("cancelStream", Napi::Function::New(env, CancelStream));
 	exports.Set("read", Napi::Function::New(env, Read));