add prompts and agents from awesome copilot

.config/dotnet-tools.json

@@ -3,7 +3,7 @@
   "isRoot": true,
   "tools": {
     "csharpier": {
-      "version": "1.2.5",
+      "version": "1.1.2",
       "commands": [
         "csharpier"
       ],

.copilot-agent.yml

@@ -0,0 +1,7 @@
+enabled: true
+agent:
+  name: copilot-coding-agent
+  allow:
+    - paths: ["src/**/*", "tests/**/*", "README.md", "AGENTS.md"]
+      actions: ["create", "modify"]
+  require_review_before_merge: true

.editorconfig

@@ -307,6 +307,7 @@ dotnet_diagnostic.CS8602.severity = error
 dotnet_diagnostic.CS8604.severity = error
 dotnet_diagnostic.CS8618.severity = error
 dotnet_diagnostic.CS0618.severity = suggestion
+dotnet_diagnostic.CS1998.severity = error
 dotnet_diagnostic.CS4014.severity = error
 dotnet_diagnostic.CS8600.severity = error
 dotnet_diagnostic.CS8603.severity = error
@@ -367,9 +368,6 @@ dotnet_diagnostic.NX0001.severity = error
 dotnet_diagnostic.NX0002.severity = silent
 dotnet_diagnostic.NX0003.severity = silent
 
-dotnet_diagnostic.VSTHRD110.severity = error
-dotnet_diagnostic.VSTHRD107.severity = error
-
 ##########################################
 # Styles
 ##########################################

.github/COPILOT_AGENT_README.md

@@ -0,0 +1,15 @@
+# Copilot Coding Agent Configuration
+
+This repository includes a minimal opt-in configuration and CI workflow to allow the GitHub Copilot coding agent to open and validate PRs.
+
+- .copilot-agent.yml: opt-in config for automated agents
+- .github/agents/copilot-agent.yml: detailed agent policy configuration
+- .github/workflows/dotnetcore.yml: CI runs on PRs touching the solution, source, or tests to validate changes
+- AGENTS.md: general instructions for Copilot coding agent with project-specific guidelines
+
+Maintainers can adjust the allowed paths or disable the agent by editing or removing .copilot-agent.yml.
+
+Notes:
+- The agent can create, modify, and delete files within the allowed paths (src, tests, README.md, AGENTS.md)
+- All changes require review before merge
+- If build/test paths are different, update the workflow accordingly; this workflow targets SharpCompress.sln and the SharpCompress.Test test project.

.github/agents/CSharpExpert.agent.md

@@ -0,0 +1,192 @@
+---
+name: C# Expert
+description: An agent designed to assist with software development tasks for .NET projects.
+# version: 2025-10-27a
+---
+You are an expert C#/.NET developer. You help with .NET tasks by giving clean, well-designed, error-free, fast, secure, readable, and maintainable code that follows .NET conventions. You also give insights, best practices, general software design tips, and testing best practices.
+
+When invoked:
+- Understand the user's .NET task and context
+- Propose clean, organized solutions that follow .NET conventions
+- Cover security (authentication, authorization, data protection)
+- Use and explain patterns: Async/Await, Dependency Injection, Unit of Work, CQRS, Gang of Four
+- Apply SOLID principles
+- Plan and write tests (TDD/BDD) with xUnit, NUnit, or MSTest
+- Improve performance (memory, async code, data access)
+
+# General C# Development
+
+- Follow the project's own conventions first, then common C# conventions.
+- Keep naming, formatting, and project structure consistent.
+
+## Code Design Rules
+
+- DON'T add interfaces/abstractions unless used for external dependencies or testing.
+- Don't wrap existing abstractions.
+- Don't default to `public`. Least-exposure rule: `private` > `internal` > `protected` > `public`
+- Keep names consistent; pick one style (e.g., `WithHostPort` or `WithBrowserPort`) and stick to it.
+- Don't edit auto-generated code (`/api/*.cs`, `*.g.cs`, `// <auto-generated>`). 
+- Comments explain **why**, not what.
+- Don't add unused methods/params.
+- When fixing one method, check siblings for the same issue.
+- Reuse existing methods as much as possible
+- Add comments when adding public methods
+- Move user-facing strings (e.g., AnalyzeAndConfirmNuGetConfigChanges) into resource files. Keep error/help text localizable.
+
+## Error Handling & Edge Cases
+- **Null checks**: use `ArgumentNullException.ThrowIfNull(x)`; for strings use `string.IsNullOrWhiteSpace(x)`; guard early. Avoid blanket `!`.
+- **Exceptions**: choose precise types (e.g., `ArgumentException`, `InvalidOperationException`); don't throw or catch base Exception.
+- **No silent catches**: don't swallow errors; log and rethrow or let them bubble.
+
+
+## Goals for .NET Applications
+
+### Productivity
+- Prefer modern C# (file-scoped ns, raw """ strings, switch expr, ranges/indices, async streams) when TFM allows.
+- Keep diffs small; reuse code; avoid new layers unless needed.
+- Be IDE-friendly (go-to-def, rename, quick fixes work).
+
+### Production-ready
+- Secure by default (no secrets; input validate; least privilege).
+- Resilient I/O (timeouts; retry with backoff when it fits).
+- Structured logging with scopes; useful context; no log spam.
+- Use precise exceptions; don’t swallow; keep cause/context.
+
+### Performance
+- Simple first; optimize hot paths when measured.
+- Stream large payloads; avoid extra allocs.
+- Use Span/Memory/pooling when it matters.
+- Async end-to-end; no sync-over-async.
+
+### Cloud-native / cloud-ready
+- Cross-platform; guard OS-specific APIs.
+- Diagnostics: health/ready when it fits; metrics + traces.
+- Observability: ILogger + OpenTelemetry hooks.
+- 12-factor: config from env; avoid stateful singletons.
+
+# .NET quick checklist
+
+## Do first
+
+* Read TFM + C# version.
+* Check `global.json` SDK.
+
+## Initial check
+
+* App type: web / desktop / console / lib.
+* Packages (and multi-targeting).
+* Nullable on? (`<Nullable>enable</Nullable>` / `#nullable enable`)
+* Repo config: `Directory.Build.*`, `Directory.Packages.props`.
+
+## C# version
+
+* **Don't** set C# newer than TFM default.
+* C# 14 (NET 10+): extension members; `field` accessor; implicit `Span<T>` conv; `?.=`; `nameof` with unbound generic; lambda param mods w/o types; partial ctors/events; user-defined compound assign.
+
+## Build
+
+* .NET 5+: `dotnet build`, `dotnet publish`.
+* .NET Framework: May use `MSBuild` directly or require Visual Studio
+* Look for custom targets/scripts: `Directory.Build.targets`, `build.cmd/.sh`, `Build.ps1`.
+
+## Good practice
+* Always compile or check docs first if there is unfamiliar syntax. Don't try to correct the syntax if code can compile.
+* Don't change TFM, SDK, or `<LangVersion>` unless asked.
+
+
+# Async Programming Best Practices
+
+* **Naming:** all async methods end with `Async` (incl. CLI handlers).
+* **Always await:** no fire-and-forget; if timing out, **cancel the work**.
+* **Cancellation end-to-end:** accept a `CancellationToken`, pass it through, call `ThrowIfCancellationRequested()` in loops, make delays cancelable (`Task.Delay(ms, ct)`).
+* **Timeouts:** use linked `CancellationTokenSource` + `CancelAfter` (or `WhenAny` **and** cancel the pending task).
+* **Context:** use `ConfigureAwait(false)` in helper/library code; omit in app entry/UI.
+* **Stream JSON:** `GetAsync(..., ResponseHeadersRead)` → `ReadAsStreamAsync` → `JsonDocument.ParseAsync`; avoid `ReadAsStringAsync` when large.
+* **Exit code on cancel:** return non-zero (e.g., `130`).
+* **`ValueTask`:** use only when measured to help; default to `Task`.
+* **Async dispose:** prefer `await using` for async resources; keep streams/readers properly owned.
+* **No pointless wrappers:** don’t add `async/await` if you just return the task.
+
+## Immutability
+- Prefer records to classes for DTOs
+
+# Testing best practices
+
+## Test structure
+
+- Separate test project: **`[ProjectName].Tests`**.
+- Mirror classes: `CatDoor` -> `CatDoorTests`.
+- Name tests by behavior: `WhenCatMeowsThenCatDoorOpens`.
+- Follow existing naming conventions.
+- Use **public instance** classes; avoid **static** fields.
+- No branching/conditionals inside tests.
+
+## Unit Tests
+
+- One behavior per test;
+- Avoid Unicode symbols.
+- Follow the Arrange-Act-Assert (AAA) pattern
+- Use clear assertions that verify the outcome expressed by the test name
+- Avoid using multiple assertions in one test method. In this case, prefer multiple tests.
+- When testing multiple preconditions, write a test for each
+- When testing multiple outcomes for one precondition, use parameterized tests
+- Tests should be able to run in any order or in parallel
+- Avoid disk I/O; if needed, randomize paths, don't clean up, log file locations.
+- Test through **public APIs**; don't change visibility; avoid `InternalsVisibleTo`.
+- Require tests for new/changed **public APIs**.
+- Assert specific values and edge cases, not vague outcomes.
+
+## Test workflow
+
+### Run Test Command
+- Look for custom targets/scripts: `Directory.Build.targets`, `test.ps1/.cmd/.sh`
+- .NET Framework: May use `vstest.console.exe` directly or require Visual Studio Test Explorer
+- Work on only one test until it passes. Then run other tests to ensure nothing has been broken.
+
+### Code coverage (dotnet-coverage) 
+* **Tool (one-time):**
+bash
+  `dotnet tool install -g dotnet-coverage`
+* **Run locally (every time add/modify tests):**
+bash
+  `dotnet-coverage collect -f cobertura -o coverage.cobertura.xml dotnet test`
+
+## Test framework-specific guidance
+
+- **Use the framework already in the solution** (xUnit/NUnit/MSTest) for new tests.
+
+### xUnit
+
+* Packages: `Microsoft.NET.Test.Sdk`, `xunit`, `xunit.runner.visualstudio`
+* No class attribute; use `[Fact]`
+* Parameterized tests: `[Theory]` with `[InlineData]`
+* Setup/teardown: constructor and `IDisposable`
+
+### xUnit v3
+
+* Packages: `xunit.v3`, `xunit.runner.visualstudio` 3.x, `Microsoft.NET.Test.Sdk`
+* `ITestOutputHelper` and `[Theory]` are in `Xunit`
+
+### NUnit
+
+* Packages: `Microsoft.NET.Test.Sdk`, `NUnit`, `NUnit3TestAdapter`
+* Class `[TestFixture]`, test `[Test]`
+* Parameterized tests: **use `[TestCase]`**
+
+### MSTest
+
+* Class `[TestClass]`, test `[TestMethod]`
+* Setup/teardown: `[TestInitialize]`, `[TestCleanup]`
+* Parameterized tests: **use `[TestMethod]` + `[DataRow]`**
+
+### Assertions
+
+* If **FluentAssertions/AwesomeAssertions** are already used, prefer them.
+* Otherwise, use the framework’s asserts.
+* Use `Throws/ThrowsAsync` (or MSTest `Assert.ThrowsException`) for exceptions.
+
+## Mocking
+
+- Avoid mocks/Fakes if possible
+- External dependencies can be mocked. Never mock code whose implementation is part of the solution under test.
+- Try to verify that the outputs (e.g. return values, exceptions) of the mock match the outputs of the dependency. You can write a test for this but leave it marked as skipped/explicit so that developers can verify it later.

.github/instructions/csharp.instructions.md

@@ -0,0 +1,114 @@
+---
+description: 'Guidelines for building C# applications'
+applyTo: '**/*.cs'
+---
+
+# C# Development
+
+## C# Instructions
+- Always use the latest version C#, currently C# 14 features.
+- Write clear and concise comments for each function.
+
+## General Instructions
+- Make only high confidence suggestions when reviewing code changes.
+- Write code with good maintainability practices, including comments on why certain design decisions were made.
+- Handle edge cases and write clear exception handling.
+- For libraries or external dependencies, mention their usage and purpose in comments.
+
+## Naming Conventions
+
+- Follow PascalCase for component names, method names, and public members.
+- Use camelCase for private fields and local variables.
+- Prefix interface names with "I" (e.g., IUserService).
+
+## Formatting
+
+- Apply code-formatting style defined in `.editorconfig`.
+- Prefer file-scoped namespace declarations and single-line using directives.
+- Insert a newline before the opening curly brace of any code block (e.g., after `if`, `for`, `while`, `foreach`, `using`, `try`, etc.).
+- Ensure that the final return statement of a method is on its own line.
+- Use pattern matching and switch expressions wherever possible.
+- Use `nameof` instead of string literals when referring to member names.
+- Ensure that XML doc comments are created for any public APIs. When applicable, include `<example>` and `<code>` documentation in the comments.
+
+## Project Setup and Structure
+
+- Guide users through creating a new .NET project with the appropriate templates.
+- Explain the purpose of each generated file and folder to build understanding of the project structure.
+- Demonstrate how to organize code using feature folders or domain-driven design principles.
+- Show proper separation of concerns with models, services, and data access layers.
+- Explain the Program.cs and configuration system in ASP.NET Core 10 including environment-specific settings.
+
+## Nullable Reference Types
+
+- Declare variables non-nullable, and check for `null` at entry points.
+- Always use `is null` or `is not null` instead of `== null` or `!= null`.
+- Trust the C# null annotations and don't add null checks when the type system says a value cannot be null.
+
+## Data Access Patterns
+
+- Guide the implementation of a data access layer using Entity Framework Core.
+- Explain different options (SQL Server, SQLite, In-Memory) for development and production.
+- Demonstrate repository pattern implementation and when it's beneficial.
+- Show how to implement database migrations and data seeding.
+- Explain efficient query patterns to avoid common performance issues.
+
+## Authentication and Authorization
+
+- Guide users through implementing authentication using JWT Bearer tokens.
+- Explain OAuth 2.0 and OpenID Connect concepts as they relate to ASP.NET Core.
+- Show how to implement role-based and policy-based authorization.
+- Demonstrate integration with Microsoft Entra ID (formerly Azure AD).
+- Explain how to secure both controller-based and Minimal APIs consistently.
+
+## Validation and Error Handling
+
+- Guide the implementation of model validation using data annotations and FluentValidation.
+- Explain the validation pipeline and how to customize validation responses.
+- Demonstrate a global exception handling strategy using middleware.
+- Show how to create consistent error responses across the API.
+- Explain problem details (RFC 7807) implementation for standardized error responses.
+
+## API Versioning and Documentation
+
+- Guide users through implementing and explaining API versioning strategies.
+- Demonstrate Swagger/OpenAPI implementation with proper documentation.
+- Show how to document endpoints, parameters, responses, and authentication.
+- Explain versioning in both controller-based and Minimal APIs.
+- Guide users on creating meaningful API documentation that helps consumers.
+
+## Logging and Monitoring
+
+- Guide the implementation of structured logging using Serilog or other providers.
+- Explain the logging levels and when to use each.
+- Demonstrate integration with Application Insights for telemetry collection.
+- Show how to implement custom telemetry and correlation IDs for request tracking.
+- Explain how to monitor API performance, errors, and usage patterns.
+
+## Testing
+
+- Always include test cases for critical paths of the application.
+- Guide users through creating unit tests.
+- Do not emit "Act", "Arrange" or "Assert" comments.
+- Copy existing style in nearby files for test method names and capitalization.
+- Explain integration testing approaches for API endpoints.
+- Demonstrate how to mock dependencies for effective testing.
+- Show how to test authentication and authorization logic.
+- Explain test-driven development principles as applied to API development.
+
+## Performance Optimization
+
+- Guide users on implementing caching strategies (in-memory, distributed, response caching).
+- Explain asynchronous programming patterns and why they matter for API performance.
+- Demonstrate pagination, filtering, and sorting for large data sets.
+- Show how to implement compression and other performance optimizations.
+- Explain how to measure and benchmark API performance.
+
+## Deployment and DevOps
+
+- Guide users through containerizing their API using .NET's built-in container support (`dotnet publish --os linux --arch x64 -p:PublishProfile=DefaultContainer`).
+- Explain the differences between manual Dockerfile creation and .NET's container publishing features.
+- Explain CI/CD pipelines for NET applications.
+- Demonstrate deployment to Azure App Service, Azure Container Apps, or other hosting options.
+- Show how to implement health checks and readiness probes.
+- Explain environment-specific configurations for different deployment stages.

.github/prompts/create-readme.prompt.md

@@ -0,0 +1,21 @@
+---
+mode: 'agent'
+description: 'Create a README.md file for the project'
+---
+
+## Role
+
+You're a senior expert software engineer with extensive experience in open source projects. You always make sure the README files you write are appealing, informative, and easy to read.
+
+## Task
+
+1. Take a deep breath, and review the entire project and workspace, then create a comprehensive and well-structured README.md file for the project.
+2. Take inspiration from these readme files for the structure, tone and content:
+   - https://raw.githubusercontent.com/Azure-Samples/serverless-chat-langchainjs/refs/heads/main/README.md
+   - https://raw.githubusercontent.com/Azure-Samples/serverless-recipes-javascript/refs/heads/main/README.md
+   - https://raw.githubusercontent.com/sinedied/run-on-output/refs/heads/main/README.md
+   - https://raw.githubusercontent.com/sinedied/smoke/refs/heads/main/README.md
+3. Do not overuse emojis, and keep the readme concise and to the point.
+4. Do not include sections like "LICENSE", "CONTRIBUTING", "CHANGELOG", etc. There are dedicated files for those sections.
+5. Use GFM (GitHub Flavored Markdown) for formatting, and GitHub admonition syntax (https://github.com/orgs/community/discussions/16925) where appropriate.
+6. If you find a logo or icon for the project, use it in the readme's header.

.github/prompts/create-specification.prompt.md

@@ -0,0 +1,127 @@
+---
+mode: 'agent'
+description: 'Create a new specification file for the solution, optimized for Generative AI consumption.'
+tools: ['changes', 'search/codebase', 'edit/editFiles', 'extensions', 'fetch', 'githubRepo', 'openSimpleBrowser', 'problems', 'runTasks', 'search', 'search/searchResults', 'runCommands/terminalLastCommand', 'runCommands/terminalSelection', 'testFailure', 'usages', 'vscodeAPI']
+---
+# Create Specification
+
+Your goal is to create a new specification file for `${input:SpecPurpose}`.
+
+The specification file must define the requirements, constraints, and interfaces for the solution components in a manner that is clear, unambiguous, and structured for effective use by Generative AIs. Follow established documentation standards and ensure the content is machine-readable and self-contained.
+
+## Best Practices for AI-Ready Specifications
+
+- Use precise, explicit, and unambiguous language.
+- Clearly distinguish between requirements, constraints, and recommendations.
+- Use structured formatting (headings, lists, tables) for easy parsing.
+- Avoid idioms, metaphors, or context-dependent references.
+- Define all acronyms and domain-specific terms.
+- Include examples and edge cases where applicable.
+- Ensure the document is self-contained and does not rely on external context.
+
+The specification should be saved in the [/spec/](/spec/) directory and named according to the following convention: `spec-[a-z0-9-]+.md`, where the name should be descriptive of the specification's content and starting with the highlevel purpose, which is one of [schema, tool, data, infrastructure, process, architecture, or design].
+
+The specification file must be formatted in well formed Markdown.
+
+Specification files must follow the template below, ensuring that all sections are filled out appropriately. The front matter for the markdown should be structured correctly as per the example following:
+
+```md
+---
+title: [Concise Title Describing the Specification's Focus]
+version: [Optional: e.g., 1.0, Date]
+date_created: [YYYY-MM-DD]
+last_updated: [Optional: YYYY-MM-DD]
+owner: [Optional: Team/Individual responsible for this spec]
+tags: [Optional: List of relevant tags or categories, e.g., `infrastructure`, `process`, `design`, `app` etc]
+---
+
+# Introduction
+
+[A short concise introduction to the specification and the goal it is intended to achieve.]
+
+## 1. Purpose & Scope
+
+[Provide a clear, concise description of the specification's purpose and the scope of its application. State the intended audience and any assumptions.]
+
+## 2. Definitions
+
+[List and define all acronyms, abbreviations, and domain-specific terms used in this specification.]
+
+## 3. Requirements, Constraints & Guidelines
+
+[Explicitly list all requirements, constraints, rules, and guidelines. Use bullet points or tables for clarity.]
+
+- **REQ-001**: Requirement 1
+- **SEC-001**: Security Requirement 1
+- **[3 LETTERS]-001**: Other Requirement 1
+- **CON-001**: Constraint 1
+- **GUD-001**: Guideline 1
+- **PAT-001**: Pattern to follow 1
+
+## 4. Interfaces & Data Contracts
+
+[Describe the interfaces, APIs, data contracts, or integration points. Use tables or code blocks for schemas and examples.]
+
+## 5. Acceptance Criteria
+
+[Define clear, testable acceptance criteria for each requirement using Given-When-Then format where appropriate.]
+
+- **AC-001**: Given [context], When [action], Then [expected outcome]
+- **AC-002**: The system shall [specific behavior] when [condition]
+- **AC-003**: [Additional acceptance criteria as needed]
+
+## 6. Test Automation Strategy
+
+[Define the testing approach, frameworks, and automation requirements.]
+
+- **Test Levels**: Unit, Integration, End-to-End
+- **Frameworks**: MSTest, FluentAssertions, Moq (for .NET applications)
+- **Test Data Management**: [approach for test data creation and cleanup]
+- **CI/CD Integration**: [automated testing in GitHub Actions pipelines]
+- **Coverage Requirements**: [minimum code coverage thresholds]
+- **Performance Testing**: [approach for load and performance testing]
+
+## 7. Rationale & Context
+
+[Explain the reasoning behind the requirements, constraints, and guidelines. Provide context for design decisions.]
+
+## 8. Dependencies & External Integrations
+
+[Define the external systems, services, and architectural dependencies required for this specification. Focus on **what** is needed rather than **how** it's implemented. Avoid specific package or library versions unless they represent architectural constraints.]
+
+### External Systems
+- **EXT-001**: [External system name] - [Purpose and integration type]
+
+### Third-Party Services
+- **SVC-001**: [Service name] - [Required capabilities and SLA requirements]
+
+### Infrastructure Dependencies
+- **INF-001**: [Infrastructure component] - [Requirements and constraints]
+
+### Data Dependencies
+- **DAT-001**: [External data source] - [Format, frequency, and access requirements]
+
+### Technology Platform Dependencies
+- **PLT-001**: [Platform/runtime requirement] - [Version constraints and rationale]
+
+### Compliance Dependencies
+- **COM-001**: [Regulatory or compliance requirement] - [Impact on implementation]
+
+**Note**: This section should focus on architectural and business dependencies, not specific package implementations. For example, specify "OAuth 2.0 authentication library" rather than "Microsoft.AspNetCore.Authentication.JwtBearer v6.0.1".
+
+## 9. Examples & Edge Cases
+
+    ```code
+    // Code snippet or data example demonstrating the correct application of the guidelines, including edge cases
+    ```
+
+## 10. Validation Criteria
+
+[List the criteria or tests that must be satisfied for compliance with this specification.]
+
+## 11. Related Specifications / Further Reading
+
+[Link to related spec 1]
+[Link to relevant external documentation]
+
+```

.github/prompts/csharp-async.prompt.md

@@ -0,0 +1,50 @@
+---
+mode: 'agent'
+tools: ['changes', 'search/codebase', 'edit/editFiles', 'problems']
+description: 'Get best practices for C# async programming'
+---
+
+# C# Async Programming Best Practices
+
+Your goal is to help me follow best practices for asynchronous programming in C#.
+
+## Naming Conventions
+
+- Use the 'Async' suffix for all async methods
+- Match method names with their synchronous counterparts when applicable (e.g., `GetDataAsync()` for `GetData()`)
+
+## Return Types
+
+- Return `Task<T>` when the method returns a value
+- Return `Task` when the method doesn't return a value
+- Consider `ValueTask<T>` for high-performance scenarios to reduce allocations
+- Avoid returning `void` for async methods except for event handlers
+
+## Exception Handling
+
+- Use try/catch blocks around await expressions
+- Avoid swallowing exceptions in async methods
+- Use `ConfigureAwait(false)` when appropriate to prevent deadlocks in library code
+- Propagate exceptions with `Task.FromException()` instead of throwing in async Task returning methods
+
+## Performance
+
+- Use `Task.WhenAll()` for parallel execution of multiple tasks
+- Use `Task.WhenAny()` for implementing timeouts or taking the first completed task
+- Avoid unnecessary async/await when simply passing through task results
+- Consider cancellation tokens for long-running operations
+
+## Common Pitfalls
+
+- Never use `.Wait()`, `.Result`, or `.GetAwaiter().GetResult()` in async code
+- Avoid mixing blocking and async code
+- Don't create async void methods (except for event handlers)
+- Always await Task-returning methods
+
+## Implementation Patterns
+
+- Implement the async command pattern for long-running operations
+- Use async streams (IAsyncEnumerable<T>) for processing sequences asynchronously
+- Consider the task-based asynchronous pattern (TAP) for public APIs
+
+When reviewing my C# code, identify these issues and suggest improvements that follow these best practices.

.github/prompts/csharp-xunit.prompt.md

@@ -0,0 +1,69 @@
+---
+mode: 'agent'
+tools: ['changes', 'search/codebase', 'edit/editFiles', 'problems', 'search']
+description: 'Get best practices for XUnit unit testing, including data-driven tests'
+---
+
+# XUnit Best Practices
+
+Your goal is to help me write effective unit tests with XUnit, covering both standard and data-driven testing approaches.
+
+## Project Setup
+
+- Use a separate test project with naming convention `[ProjectName].Tests`
+- Reference Microsoft.NET.Test.Sdk, xunit, and xunit.runner.visualstudio packages
+- Create test classes that match the classes being tested (e.g., `CalculatorTests` for `Calculator`)
+- Use .NET SDK test commands: `dotnet test` for running tests
+
+## Test Structure
+
+- No test class attributes required (unlike MSTest/NUnit)
+- Use fact-based tests with `[Fact]` attribute for simple tests
+- Follow the Arrange-Act-Assert (AAA) pattern
+- Name tests using the pattern `MethodName_Scenario_ExpectedBehavior`
+- Use constructor for setup and `IDisposable.Dispose()` for teardown
+- Use `IClassFixture<T>` for shared context between tests in a class
+- Use `ICollectionFixture<T>` for shared context between multiple test classes
+
+## Standard Tests
+
+- Keep tests focused on a single behavior
+- Avoid testing multiple behaviors in one test method
+- Use clear assertions that express intent
+- Include only the assertions needed to verify the test case
+- Make tests independent and idempotent (can run in any order)
+- Avoid test interdependencies
+
+## Data-Driven Tests
+
+- Use `[Theory]` combined with data source attributes
+- Use `[InlineData]` for inline test data
+- Use `[MemberData]` for method-based test data
+- Use `[ClassData]` for class-based test data
+- Create custom data attributes by implementing `DataAttribute`
+- Use meaningful parameter names in data-driven tests
+
+## Assertions
+
+- Use `Assert.Equal` for value equality
+- Use `Assert.Same` for reference equality
+- Use `Assert.True`/`Assert.False` for boolean conditions
+- Use `Assert.Contains`/`Assert.DoesNotContain` for collections
+- Use `Assert.Matches`/`Assert.DoesNotMatch` for regex pattern matching
+- Use `Assert.Throws<T>` or `await Assert.ThrowsAsync<T>` to test exceptions
+- Use fluent assertions library for more readable assertions
+
+## Mocking and Isolation
+
+- Consider using Moq or NSubstitute alongside XUnit
+- Mock dependencies to isolate units under test
+- Use interfaces to facilitate mocking
+- Consider using a DI container for complex test setups
+
+## Test Organization
+
+- Group tests by feature or component
+- Use `[Trait("Category", "CategoryName")]` for categorization
+- Use collection fixtures to group tests with shared dependencies
+- Consider output helpers (`ITestOutputHelper`) for test diagnostics
+- Skip tests conditionally with `Skip = "reason"` in fact/theory attributes

.github/prompts/dotnet-best-practices.prompt.md

@@ -0,0 +1,84 @@
+---
+mode: 'agent'
+description: 'Ensure .NET/C# code meets best practices for the solution/project.'
+---
+# .NET/C# Best Practices
+
+Your task is to ensure .NET/C# code in ${selection} meets the best practices specific to this solution/project. This includes:
+
+## Documentation & Structure
+
+- Create comprehensive XML documentation comments for all public classes, interfaces, methods, and properties
+- Include parameter descriptions and return value descriptions in XML comments
+- Follow the established namespace structure: {Core|Console|App|Service}.{Feature}
+
+## Design Patterns & Architecture
+
+- Use primary constructor syntax for dependency injection (e.g., `public class MyClass(IDependency dependency)`)
+- Implement the Command Handler pattern with generic base classes (e.g., `CommandHandler<TOptions>`)
+- Use interface segregation with clear naming conventions (prefix interfaces with 'I')
+- Follow the Factory pattern for complex object creation.
+
+## Dependency Injection & Services
+
+- Use constructor dependency injection with null checks via ArgumentNullException
+- Register services with appropriate lifetimes (Singleton, Scoped, Transient)
+- Use Microsoft.Extensions.DependencyInjection patterns
+- Implement service interfaces for testability
+
+## Resource Management & Localization
+
+- Use ResourceManager for localized messages and error strings
+- Separate LogMessages and ErrorMessages resource files
+- Access resources via `_resourceManager.GetString("MessageKey")`
+
+## Async/Await Patterns
+
+- Use async/await for all I/O operations and long-running tasks
+- Return Task or Task<T> from async methods
+- Use ConfigureAwait(false) where appropriate
+- Handle async exceptions properly
+
+## Testing Standards
+
+- Use MSTest framework with FluentAssertions for assertions
+- Follow AAA pattern (Arrange, Act, Assert)
+- Use Moq for mocking dependencies
+- Test both success and failure scenarios
+- Include null parameter validation tests
+
+## Configuration & Settings
+
+- Use strongly-typed configuration classes with data annotations
+- Implement validation attributes (Required, NotEmptyOrWhitespace)
+- Use IConfiguration binding for settings
+- Support appsettings.json configuration files
+
+## Semantic Kernel & AI Integration
+
+- Use Microsoft.SemanticKernel for AI operations
+- Implement proper kernel configuration and service registration
+- Handle AI model settings (ChatCompletion, Embedding, etc.)
+- Use structured output patterns for reliable AI responses
+
+## Error Handling & Logging
+
+- Use structured logging with Microsoft.Extensions.Logging
+- Include scoped logging with meaningful context
+- Throw specific exceptions with descriptive messages
+- Use try-catch blocks for expected failure scenarios
+
+## Performance & Security
+
+- Use C# 12+ features and .NET 8 optimizations where applicable
+- Implement proper input validation and sanitization
+- Use parameterized queries for database operations
+- Follow secure coding practices for AI/ML operations
+
+## Code Quality
+
+- Ensure SOLID principles compliance
+- Avoid code duplication through base classes and utilities
+- Use meaningful names that reflect domain concepts
+- Keep methods focused and cohesive
+- Implement proper disposal patterns for resources

.github/prompts/dotnet-design-pattern-review.prompt.md

@@ -0,0 +1,41 @@
+---
+mode: 'agent'
+description: 'Review the C#/.NET code for design pattern implementation and suggest improvements.'
+---
+# .NET/C# Design Pattern Review
+
+Review the C#/.NET code in ${selection} for design pattern implementation and suggest improvements for the solution/project. Do not make any changes to the code, just provide a review.
+
+## Required Design Patterns
+
+- **Command Pattern**: Generic base classes (`CommandHandler<TOptions>`), `ICommandHandler<TOptions>` interface, `CommandHandlerOptions` inheritance, static `SetupCommand(IHost host)` methods
+- **Factory Pattern**: Complex object creation service provider integration
+- **Dependency Injection**: Primary constructor syntax, `ArgumentNullException` null checks, interface abstractions, proper service lifetimes
+- **Repository Pattern**: Async data access interfaces provider abstractions for connections
+- **Provider Pattern**: External service abstractions (database, AI), clear contracts, configuration handling
+- **Resource Pattern**: ResourceManager for localized messages, separate .resx files (LogMessages, ErrorMessages)
+
+## Review Checklist
+
+- **Design Patterns**: Identify patterns used. Are Command Handler, Factory, Provider, and Repository patterns correctly implemented? Missing beneficial patterns?
+- **Architecture**: Follow namespace conventions (`{Core|Console|App|Service}.{Feature}`)? Proper separation between Core/Console projects? Modular and readable?
+- **.NET Best Practices**: Primary constructors, async/await with Task returns, ResourceManager usage, structured logging, strongly-typed configuration?
+- **GoF Patterns**: Command, Factory, Template Method, Strategy patterns correctly implemented?
+- **SOLID Principles**: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion violations?
+- **Performance**: Proper async/await, resource disposal, ConfigureAwait(false), parallel processing opportunities?
+- **Maintainability**: Clear separation of concerns, consistent error handling, proper configuration usage?
+- **Testability**: Dependencies abstracted via interfaces, mockable components, async testability, AAA pattern compatibility?
+- **Security**: Input validation, secure credential handling, parameterized queries, safe exception handling?
+- **Documentation**: XML docs for public APIs, parameter/return descriptions, resource file organization?
+- **Code Clarity**: Meaningful names reflecting domain concepts, clear intent through patterns, self-explanatory structure?
+- **Clean Code**: Consistent style, appropriate method/class size, minimal complexity, eliminated duplication?
+
+## Improvement Focus Areas
+
+- **Command Handlers**: Validation in base class, consistent error handling, proper resource management
+- **Factories**: Dependency configuration, service provider integration, disposal patterns
+- **Providers**: Connection management, async patterns, exception handling and logging
+- **Configuration**: Data annotations, validation attributes, secure sensitive value handling
+- **AI/ML Integration**: Semantic Kernel patterns, structured output handling, model configuration
+
+Provide specific, actionable recommendations for improvements aligned with the project's architecture and .NET best practices.

.github/workflows/NUGET_RELEASE.md

@@ -1,155 +0,0 @@
-# NuGet Release Workflow
-
-This document describes the automated NuGet release workflow for SharpCompress.
-
-## Overview
-
-The `nuget-release.yml` workflow automatically builds, tests, and publishes SharpCompress packages to NuGet.org when:
-- Changes are pushed to the `master` or `release` branch
-- A version tag (format: `MAJOR.MINOR.PATCH`) is pushed
-
-The workflow runs on both Windows and Ubuntu, but only the Windows build publishes to NuGet.
-
-## How It Works
-
-### Version Determination
-
-The workflow automatically determines the version based on whether the commit is tagged using C# code in the build project:
-
-1. **Tagged Release (Stable)**:
-   - If the current commit has a version tag (e.g., `0.42.1`)
-   - Uses the tag as the version number
-   - Published as a stable release
-
-2. **Untagged Release (Prerelease)**:
-   - If the current commit is NOT tagged
-   - Creates a prerelease version based on the next minor version
-   - Format: `{NEXT_MINOR_VERSION}-beta.{COMMIT_COUNT}`
-   - Example: `0.43.0-beta.123` (if last tag is 0.42.x)
-   - Published as a prerelease to NuGet.org (Windows build only)
-
-### Workflow Steps
-
-The workflow runs on a matrix of operating systems (Windows and Ubuntu):
-
-1. **Checkout**: Fetches the repository with full history for version detection
-2. **Setup .NET**: Installs .NET 10.0
-3. **Determine Version**: Runs `determine-version` build target to check for tags and determine version
-4. **Update Version**: Runs `update-version` build target to update the version in the project file
-5. **Build and Test**: Runs the full build and test suite on both platforms
-6. **Upload Artifacts**: Uploads the generated `.nupkg` files as workflow artifacts (separate for each OS)
-7. **Push to NuGet**: (Windows only) Runs `push-to-nuget` build target to publish the package to NuGet.org using the API key
-
-All version detection, file updates, and publishing logic is implemented in C# in the `build/Program.cs` file using build targets.
-
-## Setup Requirements
-
-### 1. NuGet API Key Secret
-
-The workflow requires a `NUGET_API_KEY` secret to be configured in the repository settings:
-
-1. Go to https://www.nuget.org/account/apikeys
-2. Create a new API key with "Push" permission for the SharpCompress package
-3. In GitHub, go to: **Settings** → **Secrets and variables** → **Actions**
-4. Create a new secret named `NUGET_API_KEY` with the API key value
-
-### 2. Branch Protection (Recommended)
-
-Consider enabling branch protection rules for the `release` branch to ensure:
-- Code reviews are required before merging
-- Status checks pass before merging
-- Only authorized users can push to the branch
-
-## Usage
-
-### Creating a Stable Release
-
-There are two ways to trigger a stable release:
-
-**Method 1: Push tag to trigger workflow**
-1. Ensure all changes are committed on the `master` or `release` branch
-2. Create and push a version tag:
-   ```bash
-   git checkout master  # or release
-   git tag 0.43.0
-   git push origin 0.43.0
-   ```
-3. The workflow will automatically trigger, build, test, and publish `SharpCompress 0.43.0` to NuGet.org (Windows build)
-
-**Method 2: Tag after pushing to branch**
-1. Ensure all changes are merged and pushed to the `master` or `release` branch
-2. Create and push a version tag on the already-pushed commit:
-   ```bash
-   git checkout master  # or release
-   git tag 0.43.0
-   git push origin 0.43.0
-   ```
-3. The workflow will automatically trigger, build, test, and publish `SharpCompress 0.43.0` to NuGet.org (Windows build)
-
-### Creating a Prerelease
-
-1. Push changes to the `master` or `release` branch without tagging:
-   ```bash
-   git checkout master  # or release
-   git push origin master  # or release
-   ```
-2. The workflow will automatically:
-   - Build and test the project on both Windows and Ubuntu
-   - Publish a prerelease version like `0.43.0-beta.456` to NuGet.org (Windows build)
-
-## Troubleshooting
-
-### Workflow Fails to Push to NuGet
-
-- **Check the API Key**: Ensure `NUGET_API_KEY` is set correctly in repository secrets
-- **Check API Key Permissions**: Verify the API key has "Push" permission for SharpCompress
-- **Check API Key Expiration**: NuGet API keys may expire; create a new one if needed
-
-### Version Conflict
-
-If you see "Package already exists" errors:
-- The workflow uses `--skip-duplicate` flag to handle this gracefully
-- If you need to republish the same version, delete it from NuGet.org first (if allowed)
-
-### Build or Test Failures
-
-- The workflow will not push to NuGet if build or tests fail
-- Check the workflow logs in GitHub Actions for details
-- Fix the issues and push again
-
-## Manual Package Creation
-
-If you need to create a package manually without publishing:
-
-```bash
-dotnet run --project build/build.csproj -- publish
-```
-
-The package will be created in the `artifacts/` directory.
-
-## Build Targets
-
-The workflow uses the following C# build targets defined in `build/Program.cs`:
-
-- **determine-version**: Detects version from git tags and outputs VERSION and PRERELEASE variables
-- **update-version**: Updates VersionPrefix, AssemblyVersion, and FileVersion in the project file
-- **push-to-nuget**: Pushes the generated NuGet packages to NuGet.org (requires NUGET_API_KEY)
-
-These targets can be run manually for testing:
-
-```bash
-# Determine the version
-dotnet run --project build/build.csproj -- determine-version
-
-# Update version in project file
-VERSION=0.43.0 dotnet run --project build/build.csproj -- update-version
-
-# Push to NuGet (requires NUGET_API_KEY environment variable)
-NUGET_API_KEY=your-key dotnet run --project build/build.csproj -- push-to-nuget
-```
-
-## Related Files
-
-- `.github/workflows/nuget-release.yml` - The workflow definition
-- `build/Program.cs` - Build script with version detection and publishing logic
-- `src/SharpCompress/SharpCompress.csproj` - Project file with version information

.github/workflows/TESTING.md

@@ -1,120 +0,0 @@
-# Testing Guide for NuGet Release Workflow
-
-This document describes how to test the NuGet release workflow.
-
-## Testing Strategy
-
-Since this workflow publishes to NuGet.org and requires repository secrets, testing should be done carefully. The workflow runs on both Windows and Ubuntu, but only the Windows build publishes to NuGet.
-
-## Pre-Testing Checklist
-
-- [x] Workflow YAML syntax validated
-- [x] Version determination logic tested locally
-- [x] Version update logic tested locally
-- [x] Build script works (`dotnet run --project build/build.csproj`)
-
-## Manual Testing Steps
-
-### 1. Test Prerelease Publishing (Recommended First Test)
-
-This tests the workflow on untagged commits to the master or release branch.
-
-**Steps:**
-1. Ensure `NUGET_API_KEY` secret is configured in repository settings
-2. Create a test commit on the `master` or `release` branch (e.g., update a comment or README)
-3. Push to the `master` or `release` branch
-4. Monitor the GitHub Actions workflow at: https://github.com/adamhathcock/sharpcompress/actions
-5. Verify:
-   - Workflow triggers and runs successfully on both Windows and Ubuntu
-   - Version is determined correctly (e.g., `0.43.0-beta.XXX` if last tag is 0.42.x)
-   - Build and tests pass on both platforms
-   - Package artifacts are uploaded for both platforms
-   - Package is pushed to NuGet.org as prerelease (Windows build only)
-
-**Expected Outcome:**
-- A new prerelease package appears on NuGet.org: https://www.nuget.org/packages/SharpCompress/
-- Package version follows pattern: `{NEXT_MINOR_VERSION}-beta.{COMMIT_COUNT}`
-
-### 2. Test Tagged Release Publishing
-
-This tests the workflow when a version tag is pushed.
-
-**Steps:**
-1. Prepare the `master` or `release` branch with all desired changes
-2. Create a version tag (must be a pure semantic version like `MAJOR.MINOR.PATCH`):
-   ```bash
-   git checkout master  # or release
-   git tag 0.42.2
-   git push origin 0.42.2
-   ```
-3. Monitor the GitHub Actions workflow
-4. Verify:
-   - Workflow triggers and runs successfully on both Windows and Ubuntu
-   - Version is determined as the tag (e.g., `0.42.2`)
-   - Build and tests pass on both platforms
-   - Package artifacts are uploaded for both platforms
-   - Package is pushed to NuGet.org as stable release (Windows build only)
-
-**Expected Outcome:**
-- A new stable release package appears on NuGet.org
-- Package version matches the tag
-
-### 3. Test Duplicate Package Handling
-
-This tests the `--skip-duplicate` flag behavior.
-
-**Steps:**
-1. Push to the `release` branch without making changes
-2. Monitor the workflow
-3. Verify:
-   - Workflow runs but NuGet push is skipped with "duplicate" message
-   - No errors occur
-
-### 4. Test Build Failure Handling
-
-This tests that failed builds don't publish packages.
-
-**Steps:**
-1. Introduce a breaking change in a test or code
-2. Push to the `release` branch
-3. Verify:
-   - Workflow runs and detects the failure
-   - Build or test step fails
-   - NuGet push step is skipped
-   - No package is published
-
-## Verification
-
-After each test, verify:
-
-1. **GitHub Actions Logs**: Check the workflow logs for any errors or warnings
-2. **NuGet.org**: Verify the package appears with correct version and metadata
-3. **Artifacts**: Download and inspect the uploaded artifacts
-
-## Rollback/Cleanup
-
-If testing produces unwanted packages:
-
-1. **Prerelease packages**: Can be unlisted on NuGet.org (Settings → Unlist)
-2. **Stable packages**: Cannot be deleted, only unlisted (use test versions)
-3. **Tags**: Can be deleted with:
-   ```bash
-   git tag -d 0.42.2
-   git push origin :refs/tags/0.42.2
-   ```
-
-## Known Limitations
-
-- NuGet.org does not allow re-uploading the same version
-- Deleted packages on NuGet.org reserve the version number
-- The workflow requires the `NUGET_API_KEY` secret to be set
-
-## Success Criteria
-
-The workflow is considered successful if:
-
-- ✅ Prerelease versions are published correctly with beta suffix
-- ✅ Tagged versions are published as stable releases
-- ✅ Build and test failures prevent publishing
-- ✅ Duplicate packages are handled gracefully
-- ✅ Workflow logs are clear and informative

.github/workflows/dotnetcore.yml

@@ -0,0 +1,25 @@
+name: SharpCompress
+on:
+  push:
+    branches:
+      - 'master'
+  pull_request:
+    types: [ opened, synchronize, reopened, ready_for_review ]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [windows-latest, ubuntu-latest]
+
+    steps:
+    - uses: actions/checkout@v5
+    - uses: actions/setup-dotnet@v5
+      with:
+        dotnet-version: 8.0.x
+    - run: dotnet run --project build/build.csproj
+    - uses: actions/upload-artifact@v5
+      with:
+        name: ${{ matrix.os }}-sharpcompress.nupkg
+        path: artifacts/*

.github/workflows/nuget-release.yml

@@ -1,61 +0,0 @@
-name: NuGet Release
-
-on:
-  push:
-    branches:
-      - 'master'
-      - 'release'
-    tags:
-      - '[0-9]+.[0-9]+.[0-9]+'
-  pull_request:
-    branches:
-      - 'master'
-      - 'release'
-
-permissions:
-  contents: read
-
-jobs:
-  build-and-publish:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [windows-latest, ubuntu-latest]
-    
-    steps:
-    - uses: actions/checkout@v6
-      with:
-        fetch-depth: 0  # Fetch all history for versioning
-    
-    - uses: actions/setup-dotnet@v5
-      with:
-        dotnet-version: 10.0.x
-    
-    # Determine version using C# build target
-    - name: Determine Version
-      id: version
-      run: dotnet run --project build/build.csproj -- determine-version
-    
-    # Update version in project file using C# build target
-    - name: Update Version in Project
-      run: dotnet run --project build/build.csproj -- update-version
-      env:
-        VERSION: ${{ steps.version.outputs.version }}
-    
-    # Build and test
-    - name: Build and Test
-      run: dotnet run --project build/build.csproj
-    
-    # Upload artifacts for verification
-    - name: Upload NuGet Package
-      uses: actions/upload-artifact@v6
-      with:
-        name: ${{ matrix.os }}-nuget-package
-        path: artifacts/*.nupkg
-    
-    # Push to NuGet.org using C# build target (Windows only, not on PRs)
-    - name: Push to NuGet
-      if: success() && matrix.os == 'windows-latest' && github.event_name != 'pull_request'
-      run: dotnet run --project build/build.csproj -- push-to-nuget
-      env:
-        NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }}

.github/workflows/performance-benchmarks.yml

@@ -1,50 +0,0 @@
-name: Performance Benchmarks
-
-on:
-  push:
-    branches:
-      - 'master'
-      - 'release'
-  pull_request:
-    branches:
-      - 'master'
-      - 'release'
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  benchmark:
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v6
-      with:
-        fetch-depth: 0
-    
-    - uses: actions/setup-dotnet@v5
-      with:
-        dotnet-version: 10.0.x
-    
-    - name: Build Performance Project
-      run: dotnet build tests/SharpCompress.Performance/SharpCompress.Performance.csproj --configuration Release
-    
-    - name: Run Benchmarks
-      run: dotnet run --project tests/SharpCompress.Performance/SharpCompress.Performance.csproj --configuration Release --no-build -- --filter "*" --exporters json markdown --artifacts benchmark-results
-      continue-on-error: true
-    
-    - name: Display Benchmark Results
-      if: always()
-      run: dotnet run --project build/build.csproj -- display-benchmark-results
-    
-    - name: Compare with Baseline
-      if: always()
-      run: dotnet run --project build/build.csproj -- compare-benchmark-results
-    
-    - name: Upload Benchmark Results
-      if: always()
-      uses: actions/upload-artifact@v6
-      with:
-        name: benchmark-results
-        path: benchmark-results/

.gitignore

@@ -4,8 +4,8 @@ _ReSharper.SharpCompress/
 bin/
 *.suo
 *.user
-tests/TestArchives/Scratch/
-tests/TestArchives/Scratch2/
+TestArchives/Scratch/
+TestArchives/Scratch2/
 TestResults/
 *.nupkg
 packages/*/
@@ -15,12 +15,8 @@ tests/TestArchives/*/Scratch
 tests/TestArchives/*/Scratch2
 .vs
 tools
+.vscode
 .idea/
-artifacts/
-BenchmarkDotNet.Artifacts/
-baseline-artifacts/
-profiler-snapshots/
 
 .DS_Store
 *.snupkg
-benchmark-results/

.vscode/extensions.json

@@ -1,9 +0,0 @@
-{
-  "recommendations": [
-    "ms-dotnettools.csdevkit",
-    "ms-dotnettools.csharp",
-    "ms-dotnettools.vscode-dotnet-runtime",
-    "csharpier.csharpier-vscode",
-    "formulahendry.dotnet-test-explorer"
-  ]
-}

.vscode/launch.json

@@ -1,97 +0,0 @@
-{
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "name": "Debug Tests (net10.0)",
-      "type": "coreclr",
-      "request": "launch",
-      "preLaunchTask": "build",
-      "program": "dotnet",
-      "args": [
-        "test",
-        "${workspaceFolder}/tests/SharpCompress.Test/SharpCompress.Test.csproj",
-        "-f",
-        "net10.0",
-        "--no-build",
-        "--verbosity=normal"
-      ],
-      "cwd": "${workspaceFolder}",
-      "console": "internalConsole",
-      "stopAtEntry": false
-    },
-    {
-      "name": "Debug Specific Test (net10.0)",
-      "type": "coreclr",
-      "request": "launch",
-      "preLaunchTask": "build",
-      "program": "dotnet",
-      "args": [
-        "test",
-        "${workspaceFolder}/tests/SharpCompress.Test/SharpCompress.Test.csproj",
-        "-f",
-        "net10.0",
-        "--no-build",
-        "--filter",
-        "FullyQualifiedName~${input:testName}"
-      ],
-      "cwd": "${workspaceFolder}",
-      "console": "internalConsole",
-      "stopAtEntry": false
-    },
-    {
-      "name": "Debug Performance Tests",
-      "type": "coreclr",
-      "request": "launch",
-      "preLaunchTask": "build",
-      "program": "dotnet",
-      "args": [
-        "run",
-        "--project",
-        "${workspaceFolder}/tests/SharpCompress.Performance/SharpCompress.Performance.csproj",
-        "--no-build"
-      ],
-      "cwd": "${workspaceFolder}",
-      "console": "internalConsole",
-      "stopAtEntry": false
-    },
-    {
-      "name": "Debug Build Script",
-      "type": "coreclr",
-      "request": "launch",
-      "program": "dotnet",
-      "args": [
-        "run",
-        "--project",
-        "${workspaceFolder}/build/build.csproj",
-        "--",
-        "${input:buildTarget}"
-      ],
-      "cwd": "${workspaceFolder}",
-      "console": "internalConsole",
-      "stopAtEntry": false
-    }
-  ],
-  "inputs": [
-    {
-      "id": "testName",
-      "type": "promptString",
-      "description": "Enter test name or pattern (e.g., TestMethodName or ClassName)",
-      "default": ""
-    },
-    {
-      "id": "buildTarget",
-      "type": "pickString",
-      "description": "Select build target",
-      "options": [
-        "clean",
-        "restore",
-        "build",
-        "test",
-        "format",
-        "publish",
-        "default"
-      ],
-      "default": "build"
-    }
-  ]
-}

.vscode/settings.json

@@ -1,29 +0,0 @@
-{
-  "dotnet.defaultSolution": "SharpCompress.sln",
-  "files.exclude": {
-    "**/bin": true,
-    "**/obj": true
-  },
-  "files.watcherExclude": {
-    "**/bin/**": true,
-    "**/obj/**": true,
-    "**/artifacts/**": true
-  },
-  "search.exclude": {
-    "**/bin": true,
-    "**/obj": true,
-    "**/artifacts": true
-  },
-  "editor.formatOnSave": false,
-  "[csharp]": {
-    "editor.defaultFormatter": "csharpier.csharpier-vscode",
-    "editor.formatOnSave": true,
-    "editor.codeActionsOnSave": {
-      "source.fixAll": "explicit"
-    }
-  },
-  "csharpier.enableDebugLogs": false,
-  "omnisharp.enableRoslynAnalyzers": true,
-  "omnisharp.enableEditorConfigSupport": true,
-  "dotnet-test-explorer.testProjectPath": "tests/**/*.csproj"
-}

.vscode/tasks.json

@@ -1,178 +0,0 @@
-{
-  "version": "2.0.0",
-  "tasks": [
-    {
-      "label": "build",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "build",
-        "${workspaceFolder}/SharpCompress.sln",
-        "/property:GenerateFullPaths=true",
-        "/consoleloggerparameters:NoSummary;ForceNoAlign"
-      ],
-      "problemMatcher": "$msCompile",
-      "group": {
-        "kind": "build",
-        "isDefault": true
-      }
-    },
-    {
-      "label": "build-release",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "build",
-        "${workspaceFolder}/SharpCompress.sln",
-        "-c",
-        "Release",
-        "/property:GenerateFullPaths=true",
-        "/consoleloggerparameters:NoSummary;ForceNoAlign"
-      ],
-      "problemMatcher": "$msCompile",
-      "group": "build"
-    },
-    {
-      "label": "build-library",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "build",
-        "${workspaceFolder}/src/SharpCompress/SharpCompress.csproj",
-        "/property:GenerateFullPaths=true",
-        "/consoleloggerparameters:NoSummary;ForceNoAlign"
-      ],
-      "problemMatcher": "$msCompile",
-      "group": "build"
-    },
-    {
-      "label": "restore",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "restore",
-        "${workspaceFolder}/SharpCompress.sln"
-      ],
-      "problemMatcher": "$msCompile"
-    },
-    {
-      "label": "clean",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "clean",
-        "${workspaceFolder}/SharpCompress.sln"
-      ],
-      "problemMatcher": "$msCompile"
-    },
-    {
-      "label": "test",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "test",
-        "${workspaceFolder}/tests/SharpCompress.Test/SharpCompress.Test.csproj",
-        "--no-build",
-        "--verbosity=normal"
-      ],
-      "problemMatcher": "$msCompile",
-      "group": {
-        "kind": "test",
-        "isDefault": true
-      },
-      "dependsOn": "build"
-    },
-    {
-      "label": "test-net10",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "test",
-        "${workspaceFolder}/tests/SharpCompress.Test/SharpCompress.Test.csproj",
-        "-f",
-        "net10.0",
-        "--no-build",
-        "--verbosity=normal"
-      ],
-      "problemMatcher": "$msCompile",
-      "group": "test",
-      "dependsOn": "build"
-    },
-    {
-      "label": "test-net48",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "test",
-        "${workspaceFolder}/tests/SharpCompress.Test/SharpCompress.Test.csproj",
-        "-f",
-        "net48",
-        "--no-build",
-        "--verbosity=normal"
-      ],
-      "problemMatcher": "$msCompile",
-      "group": "test",
-      "dependsOn": "build"
-    },
-    {
-      "label": "format",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "csharpier",
-        "."
-      ],
-      "problemMatcher": []
-    },
-    {
-      "label": "format-check",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "csharpier",
-        "check",
-        "."
-      ],
-      "problemMatcher": []
-    },
-    {
-      "label": "run-build-script",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "run",
-        "--project",
-        "${workspaceFolder}/build/build.csproj"
-      ],
-      "problemMatcher": "$msCompile"
-    },
-    {
-      "label": "pack",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "pack",
-        "${workspaceFolder}/src/SharpCompress/SharpCompress.csproj",
-        "-c",
-        "Release",
-        "-o",
-        "${workspaceFolder}/artifacts/"
-      ],
-      "problemMatcher": "$msCompile",
-      "dependsOn": "build-release"
-    },
-    {
-      "label": "performance-tests",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "run",
-        "--project",
-        "${workspaceFolder}/tests/SharpCompress.Performance/SharpCompress.Performance.csproj",
-        "-c",
-        "Release"
-      ],
-      "problemMatcher": "$msCompile"
-    }
-  ]
-}

AGENTS.md

@@ -14,7 +14,6 @@ SharpCompress is a pure C# compression library supporting multiple archive forma
 - Follow the existing code style and patterns in the codebase.
 
 ## General Instructions
-- **Agents should NEVER commit to git** - Agents should stage files and leave committing to the user. Only create commits when the user explicitly requests them.
 - Make only high confidence suggestions when reviewing code changes.
 - Write code with good maintainability practices, including comments on why certain design decisions were made.
 - Handle edge cases and write clear exception handling.
@@ -29,38 +28,14 @@ SharpCompress is a pure C# compression library supporting multiple archive forma
 
 ## Code Formatting
 
-**Copilot agents: You MUST run the `format` task after making code changes to ensure consistency.**
-
 - Use CSharpier for code formatting to ensure consistent style across the project
 - CSharpier is configured as a local tool in `.config/dotnet-tools.json`
-
-### Commands
-
-1. **Restore tools** (first time only):
-   ```bash
-   dotnet tool restore
-   ```
-
-2. **Check if files are formatted correctly** (doesn't modify files):
-   ```bash
-   dotnet csharpier check .
-   ```
-   - Exit code 0: All files are properly formatted
-   - Exit code 1: Some files need formatting (will show which files and differences)
-
-3. **Format files** (modifies files):
-   ```bash
-   dotnet csharpier format .
-   ```
-   - Formats all files in the project to match CSharpier style
-   - Run from project root directory
-
-4. **Configure your IDE** to format on save using CSharpier for the best experience
-
-### Additional Notes
+- Restore tools with: `dotnet tool restore`
+- Format files from the project root with: `dotnet csharpier .`
+- **Run `dotnet csharpier .` from the project root after making code changes before committing**
+- Configure your IDE to format on save using CSharpier for the best experience
 - The project also uses `.editorconfig` for editor settings (indentation, encoding, etc.)
 - Let CSharpier handle code style while `.editorconfig` handles editor behavior
-- Always run `dotnet csharpier check .` before committing to verify formatting
 
 ## Project Setup and Structure
 
@@ -74,30 +49,6 @@ SharpCompress is a pure C# compression library supporting multiple archive forma
 - Use `dotnet test` to run tests
 - Solution file: `SharpCompress.sln`
 
-### Directory Structure
-```
-src/SharpCompress/
-  ├── Archives/        # IArchive implementations (Zip, Tar, Rar, 7Zip, GZip)
-  ├── Readers/         # IReader implementations (forward-only)
-  ├── Writers/         # IWriter implementations (forward-only)
-  ├── Compressors/     # Low-level compression streams (BZip2, Deflate, LZMA, etc.)
-  ├── Factories/       # Format detection and factory pattern
-  ├── Common/          # Shared types (ArchiveType, Entry, Options)
-  ├── Crypto/          # Encryption implementations
-  └── IO/              # Stream utilities and wrappers
-
-tests/SharpCompress.Test/
-  ├── Zip/, Tar/, Rar/, SevenZip/, GZip/, BZip2/  # Format-specific tests
-  ├── TestBase.cs      # Base test class with helper methods
-  └── TestArchives/    # Test data (not checked into main test project)
-```
-
-### Factory Pattern
-All format types implement factory interfaces (`IArchiveFactory`, `IReaderFactory`, `IWriterFactory`) for auto-detection:
-- `ReaderFactory.Open()` - Auto-detects format by probing stream
-- `WriterFactory.Open()` - Creates writer for specified `ArchiveType`
-- Factories located in: `src/SharpCompress/Factories/`
-
 ## Nullable Reference Types
 
 - Declare variables non-nullable, and check for `null` at entry points.
@@ -111,7 +62,7 @@ SharpCompress supports multiple archive and compression formats:
 - **Archive Formats**: Zip, Tar, 7Zip, Rar (read-only)
 - **Compression**: DEFLATE, BZip2, LZMA/LZMA2, PPMd, ZStandard (decompress only), Deflate64 (decompress only)
 - **Combined Formats**: Tar.GZip, Tar.BZip2, Tar.LZip, Tar.XZ, Tar.ZStandard
-- See [docs/FORMATS.md](docs/FORMATS.md) for complete format support matrix
+- See FORMATS.md for complete format support matrix
 
 ### Stream Handling Rules
 - **Disposal**: As of version 0.21, SharpCompress closes wrapped streams by default
@@ -165,72 +116,3 @@ SharpCompress supports multiple archive and compression formats:
 - Use test archives from `tests/TestArchives` directory for consistency.
 - Test stream disposal and `LeaveStreamOpen` behavior.
 - Test edge cases: empty archives, large files, corrupted archives, encrypted archives.
-
-### Test Organization
-- Base class: `TestBase` - Provides `TEST_ARCHIVES_PATH`, `SCRATCH_FILES_PATH`, temp directory management
-- Framework: xUnit with AwesomeAssertions
-- Test archives: `tests/TestArchives/` - Use existing archives, don't create new ones unnecessarily
-- Match naming style of nearby test files
-
-## Common Pitfalls
-
-1. **Don't mix Archive and Reader APIs** - Archive needs seekable stream, Reader doesn't
-2. **Solid archives (Rar, 7Zip)** - Use `ExtractAllEntries()` for best performance, not individual entry extraction
-3. **Stream disposal** - Always set `LeaveStreamOpen` explicitly when needed (default is to close)
-4. **Tar + non-seekable stream** - Must provide file size or it will throw
-6. **Format detection** - Use `ReaderFactory.Open()` for auto-detection, test with actual archive files
-
-### Async Struct-Copy Bug in LZMA RangeCoder
-
-When implementing async methods on mutable `struct` types (like `BitEncoder` and `BitDecoder` in the LZMA RangeCoder), be aware that the async state machine copies the struct when `await` is encountered. This means mutations to struct fields after the `await` point may not persist back to the original struct stored in arrays or fields.
-
-**The Bug:**
-```csharp
-// BAD: async method on mutable struct
-public async ValueTask<uint> DecodeAsync(Decoder decoder, CancellationToken cancellationToken = default)
-{
-    var newBound = (decoder._range >> K_NUM_BIT_MODEL_TOTAL_BITS) * _prob;
-    if (decoder._code < newBound)
-    {
-        decoder._range = newBound;
-        _prob += (K_BIT_MODEL_TOTAL - _prob) >> K_NUM_MOVE_BITS;  // Mutates _prob
-        await decoder.Normalize2Async(cancellationToken).ConfigureAwait(false);  // Struct gets copied here
-        return 0;  // Original _prob update may be lost
-    }
-    // ...
-}
-```
-
-**The Fix:**
-Refactor async methods on mutable structs to perform all struct mutations synchronously before any `await`, or use a helper method to separate the await from the struct mutation:
-
-```csharp
-// GOOD: struct mutations happen synchronously, await is conditional
-public ValueTask<uint> DecodeAsync(Decoder decoder, CancellationToken cancellationToken = default)
-{
-    var newBound = (decoder._range >> K_NUM_BIT_MODEL_TOTAL_BITS) * _prob;
-    if (decoder._code < newBound)
-    {
-        decoder._range = newBound;
-        _prob += (K_BIT_MODEL_TOTAL - _prob) >> K_NUM_MOVE_BITS;  // All mutations complete
-        return DecodeAsyncHelper(decoder.Normalize2Async(cancellationToken), 0);  // Await in helper
-    }
-    decoder._range -= newBound;
-    decoder._code -= newBound;
-    _prob -= (_prob) >> K_NUM_MOVE_BITS;  // All mutations complete
-    return DecodeAsyncHelper(decoder.Normalize2Async(cancellationToken), 1);  // Await in helper
-}
-
-private static async ValueTask<uint> DecodeAsyncHelper(ValueTask normalizeTask, uint result)
-{
-    await normalizeTask.ConfigureAwait(false);
-    return result;
-}
-```
-
-**Why This Matters:**
-In LZMA, the `BitEncoder` and `BitDecoder` structs maintain adaptive probability models in their `_prob` field. When these structs are stored in arrays (e.g., `_models[m]`), the async state machine copy breaks the adaptive model, causing incorrect bit decoding and eventually `DataErrorException` exceptions.
-
-**Related Files:**
-- `src/SharpCompress/Compressors/LZMA/RangeCoder/RangeCoderBit.Async.cs` - Fixed
-- `src/SharpCompress/Compressors/LZMA/RangeCoder/RangeCoderBitTree.Async.cs` - Uses readonly structs, so this pattern doesn't apply

Directory.Build.props

@@ -12,6 +12,5 @@
     <RunAnalyzersDuringBuild>False</RunAnalyzersDuringBuild>
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
     <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
-    <CentralPackageTransitivePinningEnabled>true</CentralPackageTransitivePinningEnabled>
   </PropertyGroup>
 </Project>

Directory.Packages.props

@@ -1,24 +1,21 @@
 <Project>
   <ItemGroup>
-    <PackageVersion Include="BenchmarkDotNet" Version="0.15.8" />
-    <PackageVersion Include="Bullseye" Version="6.1.0" />
-    <PackageVersion Include="AwesomeAssertions" Version="9.3.0" />
+    <PackageVersion Include="Bullseye" Version="6.0.0" />
+    <PackageVersion Include="AwesomeAssertions" Version="9.2.1" />
     <PackageVersion Include="Glob" Version="1.1.9" />
-    <PackageVersion Include="JetBrains.Profiler.SelfApi" Version="2.5.16" />
-    <PackageVersion Include="Microsoft.Bcl.AsyncInterfaces" Version="10.0.0" />
-    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
+    <PackageVersion Include="JetBrains.Profiler.SelfApi" Version="2.5.14" />
+    <PackageVersion Include="Microsoft.Bcl.AsyncInterfaces" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.0" />
     <PackageVersion Include="Mono.Posix.NETStandard" Version="1.0.0" />
-    <PackageVersion Include="SimpleExec" Version="13.0.0" />
-    <PackageVersion Include="System.Text.Encoding.CodePages" Version="10.0.0" />
+    <PackageVersion Include="SimpleExec" Version="12.0.0" />
     <PackageVersion Include="System.Buffers" Version="4.6.1" />
     <PackageVersion Include="System.Memory" Version="4.6.3" />
-    <PackageVersion Include="xunit.v3" Version="3.2.2" />
+    <PackageVersion Include="System.Text.Encoding.CodePages" Version="8.0.0" />
+    <PackageVersion Include="xunit" Version="2.9.3" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
-    <GlobalPackageReference Include="Microsoft.SourceLink.GitHub" Version="10.0.102" />
-    <GlobalPackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" />
-    <GlobalPackageReference
-      Include="Microsoft.VisualStudio.Threading.Analyzers"
-      Version="17.14.15"
-    />
+    <PackageVersion Include="ZstdSharp.Port" Version="0.8.6" />
+    <PackageVersion Include="Microsoft.NET.ILLink.Tasks" Version="8.0.21" />
+    <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" />
   </ItemGroup>
 </Project>

FORMATS.md

@@ -10,10 +10,7 @@
 
 | Archive Format         | Compression Format(s)                             | Compress/Decompress | Archive API     | Reader API | Writer API    |
 | ---------------------- | ------------------------------------------------- | ------------------- | --------------- | ---------- | ------------- |
-| Ace                    | None                                              | Decompress          | N/A             | AceReader  | N/A           |
-| Arc                    | None, Packed, Squeezed, Crunched                  | Decompress          | N/A             | ArcReader  | N/A           |
-| Arj                    | None                                              | Decompress          | N/A             | ArjReader  | N/A           |
-| Rar                    | Rar                                               | Decompress          | RarArchive      | RarReader  | N/A           |
+| Rar                    | Rar                                               | Decompress (1)      | RarArchive      | RarReader  | N/A           |
 | Zip (2)                | None, Shrink, Reduce, Implode, DEFLATE, Deflate64, BZip2, LZMA/LZMA2, PPMd                           | Both                | ZipArchive      | ZipReader  | ZipWriter     | 
 | Tar                    | None                                              | Both                | TarArchive      | TarReader  | TarWriter (3) |
 | Tar.GZip               | DEFLATE                                           | Both                | TarArchive      | TarReader  | TarWriter (3) |
@@ -25,28 +22,11 @@
 | 7Zip (4)               | LZMA, LZMA2, BZip2, PPMd, BCJ, BCJ2, Deflate      | Decompress          | SevenZipArchive | N/A        | N/A           |
 
 1. SOLID Rars are only supported in the RarReader API.
-2. Zip format supports pkware and WinzipAES encryption. However, encrypted LZMA is not supported. Zip64 reading/writing is supported but only with seekable streams as the Zip spec doesn't support Zip64 data in post data descriptors. Deflate64 is only supported for reading. See [Zip Format Notes](#zip-format-notes) for details on multi-volume archives and streaming behavior.
+2. Zip format supports pkware and WinzipAES encryption. However, encrypted LZMA is not supported. Zip64 reading/writing is supported but only with seekable streams as the Zip spec doesn't support Zip64 data in post data descriptors. Deflate64 is only supported for reading.
 3. The Tar format requires a file size in the header. If no size is specified to the TarWriter and the stream is not seekable, then an exception will be thrown.
-4. The 7Zip format doesn't allow for reading as a forward-only stream so 7Zip is only supported through the Archive API. See [7Zip Format Notes](#7zip-format-notes) for details on async extraction behavior.
+4. The 7Zip format doesn't allow for reading as a forward-only stream so 7Zip is only supported through the Archive API
 5. LZip has no support for extra data like the file name or timestamp. There is a default filename used when looking at the entry Key on the archive.
 
-### Zip Format Notes
-
-- Multi-volume/split ZIP archives require ZipArchive (seekable streams) as ZipReader cannot seek across volume files.
-- ZipReader processes entries from LocalEntry headers (which include directory entries ending with `/`) and intentionally skips DirectoryEntry headers from the central directory, as they are redundant in streaming mode - all entry data comes from LocalEntry headers which ZipReader has already processed.
-
-### 7Zip Format Notes
-
-- **Async Extraction Performance**: When using async extraction methods (e.g., `ExtractAllEntries()` with `MoveToNextEntryAsync()`), each file creates its own decompression stream to avoid state corruption in the LZMA decoder. This is less efficient than synchronous extraction, which can reuse a single decompression stream for multiple files in the same folder.
-  
-  **Performance Impact**: For archives with many small files in the same compression folder, async extraction will be slower than synchronous extraction because it must:
-  1. Create a new LZMA decoder for each file
-  2. Skip through the decompressed data to reach each file's starting position
-  
-  **Recommendation**: For best performance with 7Zip archives, use synchronous extraction methods (`MoveToNextEntry()` and `WriteEntryToDirectory()`) when possible. Use async methods only when you need to avoid blocking the thread (e.g., in UI applications or async-only contexts).
-  
-  **Technical Details**: 7Zip archives group files into "folders" (compression units), where all files in a folder share one continuous LZMA-compressed stream. The LZMA decoder maintains internal state (dictionary window, decoder positions) that assumes sequential, non-interruptible processing. Async operations can yield control during awaits, which would corrupt this shared state. To avoid this, async extraction creates a fresh decoder stream for each file.
-
 ## Compression Streams
 
 For those who want to directly compress/decompress bits. The single file formats are represented here as well. However, BZip2, LZip and XZ have no metadata (GZip has a little) so using them without something like a Tar file makes little sense.

README.md

@@ -1,10 +1,10 @@
 # SharpCompress
 
-SharpCompress is a compression library in pure C# for .NET Framework 4.8, .NET 8.0 and .NET 10.0 that can unrar, un7zip, unzip, untar unbzip2, ungzip, unlzip, unzstd, unarc and unarj with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip/lzip are implemented.
+SharpCompress is a compression library in pure C# for .NET Framework 4.62, .NET Standard 2.1, .NET 6.0 and NET 8.0 that can unrar, un7zip, unzip, untar unbzip2, ungzip, unlzip, unzstd, unarc and unarj with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip/lzip are implemented.
 
 The major feature is support for non-seekable streams so large files can be processed on the fly (i.e. download stream).
 
-**NEW:** All I/O operations now support async/await for improved performance and scalability. See the [USAGE.md](docs/USAGE.md#async-examples) for examples.
+**NEW:** All I/O operations now support async/await for improved performance and scalability. See the [Async Usage](#async-usage) section below.
 
 GitHub Actions Build -
 [![SharpCompress](https://github.com/adamhathcock/sharpcompress/actions/workflows/dotnetcore.yml/badge.svg)](https://github.com/adamhathcock/sharpcompress/actions/workflows/dotnetcore.yml)
@@ -14,7 +14,7 @@ GitHub Actions Build -
 
 Post Issues on Github!
 
-Check the [Supported Formats](docs/FORMATS.md) and [Basic Usage.](docs/USAGE.md)
+Check the [Supported Formats](FORMATS.md) and [Basic Usage.](USAGE.md)
 
 ## Recommended Formats
 
@@ -34,11 +34,235 @@ Hi everyone. I hope you're using SharpCompress and finding it useful. Please giv
 
 Please do not email me directly to ask for help. If you think there is a real issue, please report it here.
 
+## Async Usage
+
+SharpCompress now provides full async/await support for all I/O operations, allowing for better performance and scalability in modern applications.
+
+### Async Reading Examples
+
+Extract entries asynchronously:
+```csharp
+using (Stream stream = File.OpenRead("archive.zip"))
+using (var reader = ReaderFactory.Open(stream))
+{
+    while (reader.MoveToNextEntry())
+    {
+        if (!reader.Entry.IsDirectory)
+        {
+            // Async extraction
+            await reader.WriteEntryToDirectoryAsync(
+                @"C:\temp",
+                new ExtractionOptions() { ExtractFullPath = true, Overwrite = true },
+                cancellationToken
+            );
+        }
+    }
+}
+```
+
+Extract all entries to directory asynchronously:
+```csharp
+using (Stream stream = File.OpenRead("archive.tar.gz"))
+using (var reader = ReaderFactory.Open(stream))
+{
+    await reader.WriteAllToDirectoryAsync(
+        @"C:\temp",
+        new ExtractionOptions() { ExtractFullPath = true, Overwrite = true },
+        cancellationToken
+    );
+}
+```
+
+Open entry stream asynchronously:
+```csharp
+using (var archive = ZipArchive.Open("archive.zip"))
+{
+    foreach (var entry in archive.Entries.Where(e => !e.IsDirectory))
+    {
+        using (var entryStream = await entry.OpenEntryStreamAsync(cancellationToken))
+        {
+            // Process stream asynchronously
+            await entryStream.CopyToAsync(outputStream, cancellationToken);
+        }
+    }
+}
+```
+
+### Async Writing Examples
+
+Write files asynchronously:
+```csharp
+using (Stream stream = File.OpenWrite("output.zip"))
+using (var writer = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate))
+{
+    await writer.WriteAsync("file1.txt", fileStream, DateTime.Now, cancellationToken);
+}
+```
+
+Write all files from directory asynchronously:
+```csharp
+using (Stream stream = File.OpenWrite("output.tar.gz"))
+using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)))
+{
+    await writer.WriteAllAsync(@"D:\files", "*", SearchOption.AllDirectories, cancellationToken);
+}
+```
+
+All async methods support `CancellationToken` for graceful cancellation of long-running operations.
+
 ## Want to contribute?
 
 I'm always looking for help or ideas. Please submit code or email with ideas. Unfortunately, just letting me know you'd like to help is not enough because I really have no overall plan of what needs to be done. I'll definitely accept code submissions and add you as a member of the project!
 
-## Notes
+## TODOs (always lots)
+
+* RAR 5 decryption crc check support
+* 7Zip writing
+* Zip64 (Need writing and extend Reading)
+* Multi-volume Zip support.
+* ZStandard writing
+
+## Version Log
+
+* [Releases](https://github.com/adamhathcock/sharpcompress/releases)
+
+### Version 0.18
+
+* [Now on Github releases](https://github.com/adamhathcock/sharpcompress/releases/tag/0.18)
+
+### Version 0.17.1
+
+* Fix - [Bug Fix for .NET Core on Windows](https://github.com/adamhathcock/sharpcompress/pull/257)
+
+### Version 0.17.0
+
+* New - Full LZip support! Can read and write LZip files and Tars inside LZip files. [Make LZip a first class citizen. #241](https://github.com/adamhathcock/sharpcompress/issues/241)
+* New - XZ read support! Can read XZ files and Tars inside XZ files. [XZ in SharpCompress #91](https://github.com/adamhathcock/sharpcompress/issues/94)
+* Fix - [Regression - zip file writing on seekable streams always assumed stream start was 0. Introduced with Zip64 writing.](https://github.com/adamhathcock/sharpcompress/issues/244)
+* Fix - [Zip files with post-data descriptors can be properly skipped via decompression](https://github.com/adamhathcock/sharpcompress/issues/162)
+
+### Version 0.16.2
+
+* Fix [.NET 3.5 should support files and cryptography (was a regression from 0.16.0)](https://github.com/adamhathcock/sharpcompress/pull/251)
+* Fix [Zip per entry compression customization wrote the wrong method into the zip archive](https://github.com/adamhathcock/sharpcompress/pull/249)
+
+### Version 0.16.1
+
+* Fix [Preserve compression method when getting a compressed stream](https://github.com/adamhathcock/sharpcompress/pull/235)
+* Fix [RAR entry key normalization fix](https://github.com/adamhathcock/sharpcompress/issues/201)
+
+### Version 0.16.0
+
+* Breaking - [Progress Event Tracking rethink](https://github.com/adamhathcock/sharpcompress/pull/226)
+* Update to VS2017 - [VS2017](https://github.com/adamhathcock/sharpcompress/pull/231) - Framework targets have been changed.
+* New - [Add Zip64 writing](https://github.com/adamhathcock/sharpcompress/pull/211)
+* [Fix invalid/mismatching Zip version flags.](https://github.com/adamhathcock/sharpcompress/issues/164) - This allows nuget/System.IO.Packaging to read zip files generated by SharpCompress
+* [Fix 7Zip directory hiding](https://github.com/adamhathcock/sharpcompress/pull/215/files)
+* [Verify RAR CRC headers](https://github.com/adamhathcock/sharpcompress/pull/220)
+
+### Version 0.15.2
+
+* [Fix invalid headers](https://github.com/adamhathcock/sharpcompress/pull/210) - fixes an issue creating large-ish zip archives that was introduced with zip64 reading.
+
+### Version 0.15.1
+
+* [Zip64 extending information and ZipReader](https://github.com/adamhathcock/sharpcompress/pull/206)
+
+### Version 0.15.0
+
+* [Add zip64 support for ZipArchive extraction](https://github.com/adamhathcock/sharpcompress/pull/205)
+
+### Version 0.14.1
+
+* [.NET Assemblies aren't strong named](https://github.com/adamhathcock/sharpcompress/issues/158)
+* [Pkware encryption for Zip files didn't allow for multiple reads of an entry](https://github.com/adamhathcock/sharpcompress/issues/197)
+* [GZip Entry couldn't be read multiple times](https://github.com/adamhathcock/sharpcompress/issues/198)
+
+### Version 0.14.0
+
+* [Support for LZip reading in for Tars](https://github.com/adamhathcock/sharpcompress/pull/191)
+
+### Version 0.13.1
+
+* [Fix null password on ReaderFactory. Fix null options on SevenZipArchive](https://github.com/adamhathcock/sharpcompress/pull/188)
+* [Make PpmdProperties lazy to avoid unnecessary allocations.](https://github.com/adamhathcock/sharpcompress/pull/185)
+
+### Version 0.13.0
+
+* Breaking change: Big refactor of Options on API.
+* 7Zip supports Deflate
+
+### Version 0.12.4
+
+* Forward only zip issue fix https://github.com/adamhathcock/sharpcompress/issues/160
+* Try to fix frameworks again by copying targets from JSON.NET
+
+### Version 0.12.3
+
+* 7Zip fixes https://github.com/adamhathcock/sharpcompress/issues/73
+* Maybe all profiles will work with project.json now
+
+### Version 0.12.2
+
+* Support Profile 259 again
+
+### Version 0.12.1
+
+* Support Silverlight 5
+
+### Version 0.12.0
+
+* .NET Core RTM!
+* Bug fix for Tar long paths
+
+### Version 0.11.6
+
+* Bug fix for global header in Tar
+* Writers now have a leaveOpen `bool` overload. They won't close streams if not-requested to.
+
+### Version 0.11.5
+
+* Bug fix in Skip method
+
+### Version 0.11.4
+
+* SharpCompress is now endian neutral (matters for Mono platforms)
+* Fix for Inflate (need to change implementation)
+* Fixes for RAR detection
+
+### Version 0.11.1
+
+* Added Cancel on IReader
+* Removed .NET 2.0 support and LinqBridge dependency
+
+### Version 0.11
+
+* Been over a year, contains mainly fixes from contributors!
+* Possible breaking change: ArchiveEncoding is UTF8 by default now.
+* TAR supports writing long names using longlink
+* RAR Protect Header added
+
+### Version 0.10.3
+
+* Finally fixed Disposal issue when creating a new archive with the Archive API
+
+### Version 0.10.2
+
+* Fixed Rar Header reading for invalid extended time headers.
+* Windows Store assembly is now strong named
+* Known issues with Long Tar names being worked on
+* Updated to VS2013
+* Portable targets SL5 and Windows Phone 8 (up from SL4 and WP7)
+
+### Version 0.10.1
+
+* Fixed 7Zip extraction performance problem
+
+### Version 0.10:
+
+* Added support for RAR Decryption (thanks to https://github.com/hrasyid)
+* Embedded some BouncyCastle crypto classes to allow RAR Decryption and Winzip AES Decryption in Portable and Windows Store DLLs
+* Built in Release (I think)
 
 XZ implementation based on: https://github.com/sambott/XZ.NET by @sambott
 

SharpCompress.sln

@@ -18,11 +18,12 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Config", "Config", "{CDB425
 		Directory.Build.props = Directory.Build.props
 		global.json = global.json
 		.editorconfig = .editorconfig
-		.gitignore = .gitignore
 		Directory.Packages.props = Directory.Packages.props
 		NuGet.config = NuGet.config
-		.github\workflows\nuget-release.yml = .github\workflows\nuget-release.yml
+		.github\workflows\dotnetcore.yml = .github\workflows\dotnetcore.yml
+		USAGE.md = USAGE.md
 		README.md = README.md
+		FORMATS.md = FORMATS.md
 		AGENTS.md = AGENTS.md
 	EndProjectSection
 EndProject

USAGE.md

@@ -1,6 +1,6 @@
 # SharpCompress Usage
 
-## Async/Await Support (Beta)
+## Async/Await Support
 
 SharpCompress now provides full async/await support for all I/O operations. All `Read`, `Write`, and extraction operations have async equivalents ending in `Async` that accept an optional `CancellationToken`. This enables better performance and scalability for I/O-bound operations.
 
@@ -13,7 +13,7 @@ SharpCompress now provides full async/await support for all I/O operations. All
 
 See [Async Examples](#async-examples) section below for usage patterns.
 
-## Stream Rules
+## Stream Rules (changed with 0.21)
 
 When dealing with Streams, the rule should be that you don't close a stream you didn't create. This, in effect, should mean you should always put a Stream in a using block to dispose it. 
 
@@ -48,7 +48,7 @@ Also, look over the tests for more thorough [examples](https://github.com/adamha
 
 ### Create Zip Archive from multiple files
 ```C#
-using(var archive = ZipArchive.CreateArchive())
+using(var archive = ZipArchive.Create())
 {
     archive.AddEntry("file01.txt", "C:\\file01.txt");
     archive.AddEntry("file02.txt", "C:\\file02.txt");
@@ -61,7 +61,7 @@ using(var archive = ZipArchive.CreateArchive())
 ### Create Zip Archive from all files in a directory to a file
 
 ```C#
-using (var archive = ZipArchive.CreateArchive())
+using (var archive = ZipArchive.Create())
 {
     archive.AddAllFromDirectory("D:\\temp");
     archive.SaveTo("C:\\temp.zip", CompressionType.Deflate);
@@ -72,7 +72,7 @@ using (var archive = ZipArchive.CreateArchive())
 
 ```C#
 var memoryStream = new MemoryStream();
-using (var archive = ZipArchive.CreateArchive())
+using (var archive = ZipArchive.Create())
 {
     archive.AddAllFromDirectory("D:\\temp");
     archive.SaveTo(memoryStream, new WriterOptions(CompressionType.Deflate)
@@ -87,24 +87,27 @@ memoryStream.Position = 0;
 ### Extract all files from a rar file to a directory using RarArchive
 
 Note: Extracting a solid rar or 7z file needs to be done in sequential order to get acceptable decompression speed.
-`ExtractAllEntries` is primarily intended for solid archives (like solid Rar) or 7Zip archives, where sequential extraction provides the best performance. For general/simple extraction with any supported archive type, use `archive.WriteToDirectory()` instead.
+It is explicitly recommended to use `ExtractAllEntries` when extracting an entire `IArchive` instead of iterating over all its `Entries`.
+Alternatively, use `IArchive.WriteToDirectory`.
 
 ```C#
-using (var archive = RarArchive.OpenArchive("Test.rar"))
+using (var archive = RarArchive.Open("Test.rar"))
 {
-    // Simple extraction with RarArchive; this WriteToDirectory pattern works for all archive types
-    archive.WriteToDirectory(@"D:\temp", new ExtractionOptions()
+    using (var reader = archive.ExtractAllEntries())
     {
-        ExtractFullPath = true,
-        Overwrite = true
-    });
+        reader.WriteAllToDirectory(@"D:\temp", new ExtractionOptions()
+        {
+            ExtractFullPath = true,
+            Overwrite = true
+        });
+    }
 }
 ```
 
 ### Iterate over all files from a Rar file using RarArchive
 
 ```C#
-using (var archive = RarArchive.OpenArchive("Test.rar"))
+using (var archive = RarArchive.Open("Test.rar"))
 {
     foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
     {
@@ -113,34 +116,11 @@ using (var archive = RarArchive.OpenArchive("Test.rar"))
 }
 ```
 
-### Extract solid Rar or 7Zip archives with progress reporting
-
-`ExtractAllEntries` only works for solid archives (Rar) or 7Zip archives. For optimal performance with these archive types, use this method:
-
-```C#
-using SharpCompress.Common;
-using SharpCompress.Readers;
-
-var progress = new Progress<ProgressReport>(report =>
-{
-    Console.WriteLine($"Extracting {report.EntryPath}: {report.PercentComplete}%");
-});
-
-using (var archive = RarArchive.OpenArchive("archive.rar", new ReaderOptions { Progress = progress })) // Must be solid Rar or 7Zip
-{
-    archive.WriteToDirectory(@"D:\output", new ExtractionOptions()
-    {
-        ExtractFullPath = true,
-        Overwrite = true
-    });
-}
-```
-
 ### Use ReaderFactory to autodetect archive type and Open the entry stream
 
 ```C#
 using (Stream stream = File.OpenRead("Tar.tar.bz2"))
-using (var reader = ReaderFactory.OpenReader(stream))
+using (var reader = ReaderFactory.Open(stream))
 {
     while (reader.MoveToNextEntry())
     {
@@ -161,7 +141,7 @@ using (var reader = ReaderFactory.OpenReader(stream))
 
 ```C#
 using (Stream stream = File.OpenRead("Tar.tar.bz2"))
-using (var reader = ReaderFactory.OpenReader(stream))
+using (var reader = ReaderFactory.Open(stream))
 {
     while (reader.MoveToNextEntry())
     {
@@ -180,7 +160,7 @@ using (var reader = ReaderFactory.OpenReader(stream))
 
 ```C#
 using (Stream stream = File.OpenWrite("C:\\temp.tgz"))
-using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)
+using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)
                                                 {
                                                     LeaveOpenStream = true
                                                 }))
@@ -199,7 +179,7 @@ opts.ArchiveEncoding.CustomDecoder = (data, x, y) =>
 {
     return encoding.GetString(data);
 };
-var tr = SharpCompress.Archives.Zip.ZipArchive.OpenArchive("test.zip", opts);
+var tr = SharpCompress.Archives.Zip.ZipArchive.Open("test.zip", opts);
 foreach(var entry in tr.Entries)
 {
     Console.WriteLine($"{entry.Key}");
@@ -213,7 +193,7 @@ foreach(var entry in tr.Entries)
 **Extract single entry asynchronously:**
 ```C#
 using (Stream stream = File.OpenRead("archive.zip"))
-using (var reader = ReaderFactory.OpenReader(stream))
+using (var reader = ReaderFactory.Open(stream))
 {
     while (reader.MoveToNextEntry())
     {
@@ -234,7 +214,7 @@ using (var reader = ReaderFactory.OpenReader(stream))
 **Extract all entries asynchronously:**
 ```C#
 using (Stream stream = File.OpenRead("archive.tar.gz"))
-using (var reader = ReaderFactory.OpenReader(stream))
+using (var reader = ReaderFactory.Open(stream))
 {
     await reader.WriteAllToDirectoryAsync(
         @"D:\temp",
@@ -250,7 +230,7 @@ using (var reader = ReaderFactory.OpenReader(stream))
 
 **Open and process entry stream asynchronously:**
 ```C#
-using (var archive = ZipArchive.OpenArchive("archive.zip"))
+using (var archive = ZipArchive.Open("archive.zip"))
 {
     foreach (var entry in archive.Entries.Where(e => !e.IsDirectory))
     {
@@ -268,7 +248,7 @@ using (var archive = ZipArchive.OpenArchive("archive.zip"))
 **Write single file asynchronously:**
 ```C#
 using (Stream archiveStream = File.OpenWrite("output.zip"))
-using (var writer = WriterFactory.OpenWriter(archiveStream, ArchiveType.Zip, CompressionType.Deflate))
+using (var writer = WriterFactory.Open(archiveStream, ArchiveType.Zip, CompressionType.Deflate))
 {
     using (Stream fileStream = File.OpenRead("input.txt"))
     {
@@ -280,7 +260,7 @@ using (var writer = WriterFactory.OpenWriter(archiveStream, ArchiveType.Zip, Com
 **Write entire directory asynchronously:**
 ```C#
 using (Stream stream = File.OpenWrite("backup.tar.gz"))
-using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)))
+using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)))
 {
     await writer.WriteAllAsync(
         @"D:\files",
@@ -299,7 +279,7 @@ var cts = new CancellationTokenSource();
 cts.CancelAfter(TimeSpan.FromMinutes(5));
 
 using (Stream stream = File.OpenWrite("archive.zip"))
-using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Zip, CompressionType.Deflate))
+using (var writer = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate))
 {
     try
     {
@@ -316,14 +296,16 @@ using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Zip, Compressio
 
 **Extract from archive asynchronously:**
 ```C#
-using (var archive = ZipArchive.OpenArchive("archive.zip"))
+using (var archive = ZipArchive.Open("archive.zip"))
 {
-    // Simple async extraction - works for all archive types
-    await archive.WriteToDirectoryAsync(
-        @"C:\output",
-        new ExtractionOptions() { ExtractFullPath = true, Overwrite = true },
-        cancellationToken
-    );
+    using (var reader = archive.ExtractAllEntries())
+    {
+        await reader.WriteAllToDirectoryAsync(
+            @"C:\output",
+            new ExtractionOptions() { ExtractFullPath = true, Overwrite = true },
+            cancellationToken
+        );
+    }
 }
 ```
 

build/Program.cs

@@ -1,10 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using System.Runtime.InteropServices;
-using System.Text.RegularExpressions;
-using System.Threading.Tasks;
 using GlobExpressions;
 using static Bullseye.Targets;
 using static SimpleExec.Command;
@@ -14,14 +11,7 @@ const string Restore = "restore";
 const string Build = "build";
 const string Test = "test";
 const string Format = "format";
-const string CheckFormat = "check-format";
 const string Publish = "publish";
-const string DetermineVersion = "determine-version";
-const string UpdateVersion = "update-version";
-const string PushToNuGet = "push-to-nuget";
-const string DisplayBenchmarkResults = "display-benchmark-results";
-const string CompareBenchmarkResults = "compare-benchmark-results";
-const string GenerateBaseline = "generate-baseline";
 
 Target(
     Clean,
@@ -52,20 +42,12 @@ Target(
 Target(
     Format,
     () =>
-    {
-        Run("dotnet", "tool restore");
-        Run("dotnet", "csharpier format .");
-    }
-);
-Target(
-    CheckFormat,
-    () =>
     {
         Run("dotnet", "tool restore");
         Run("dotnet", "csharpier check .");
     }
 );
-Target(Restore, [CheckFormat], () => Run("dotnet", "restore"));
+Target(Restore, [Format], () => Run("dotnet", "restore"));
 
 Target(
     Build,
@@ -79,7 +61,7 @@ Target(
 Target(
     Test,
     [Build],
-    ["net10.0", "net48"],
+    ["net8.0", "net48"],
     framework =>
     {
         IEnumerable<string> GetFiles(string d)
@@ -108,582 +90,6 @@ Target(
     }
 );
 
-Target(
-    DetermineVersion,
-    async () =>
-    {
-        var (version, isPrerelease) = await GetVersion();
-        Console.WriteLine($"VERSION={version}");
-        Console.WriteLine($"PRERELEASE={isPrerelease.ToString().ToLower()}");
-
-        // Write to environment file for GitHub Actions
-        var githubOutput = Environment.GetEnvironmentVariable("GITHUB_OUTPUT");
-        if (!string.IsNullOrEmpty(githubOutput))
-        {
-            File.AppendAllText(githubOutput, $"version={version}\n");
-            File.AppendAllText(githubOutput, $"prerelease={isPrerelease.ToString().ToLower()}\n");
-        }
-    }
-);
-
-Target(
-    UpdateVersion,
-    async () =>
-    {
-        var version = Environment.GetEnvironmentVariable("VERSION");
-        if (string.IsNullOrEmpty(version))
-        {
-            var (detectedVersion, _) = await GetVersion();
-            version = detectedVersion;
-        }
-
-        Console.WriteLine($"Updating project file with version: {version}");
-
-        var projectPath = "src/SharpCompress/SharpCompress.csproj";
-        var content = File.ReadAllText(projectPath);
-
-        // Get base version (without prerelease suffix)
-        var baseVersion = version.Split('-')[0];
-
-        // Update VersionPrefix
-        content = Regex.Replace(
-            content,
-            @"<VersionPrefix>[^<]*</VersionPrefix>",
-            $"<VersionPrefix>{version}</VersionPrefix>"
-        );
-
-        // Update AssemblyVersion
-        content = Regex.Replace(
-            content,
-            @"<AssemblyVersion>[^<]*</AssemblyVersion>",
-            $"<AssemblyVersion>{baseVersion}</AssemblyVersion>"
-        );
-
-        // Update FileVersion
-        content = Regex.Replace(
-            content,
-            @"<FileVersion>[^<]*</FileVersion>",
-            $"<FileVersion>{baseVersion}</FileVersion>"
-        );
-
-        File.WriteAllText(projectPath, content);
-        Console.WriteLine($"Updated VersionPrefix to: {version}");
-        Console.WriteLine($"Updated AssemblyVersion and FileVersion to: {baseVersion}");
-    }
-);
-
-Target(
-    PushToNuGet,
-    () =>
-    {
-        var apiKey = Environment.GetEnvironmentVariable("NUGET_API_KEY");
-        if (string.IsNullOrEmpty(apiKey))
-        {
-            Console.WriteLine(
-                "NUGET_API_KEY environment variable is not set. Skipping NuGet push."
-            );
-            return;
-        }
-
-        var packages = Directory.GetFiles("artifacts", "*.nupkg");
-        if (packages.Length == 0)
-        {
-            Console.WriteLine("No packages found in artifacts directory.");
-            return;
-        }
-
-        foreach (var package in packages)
-        {
-            Console.WriteLine($"Pushing {package} to NuGet.org");
-            try
-            {
-                // Note: API key is passed via command line argument which is standard practice for dotnet nuget push
-                // The key is already in an environment variable and not displayed in normal output
-                Run(
-                    "dotnet",
-                    $"nuget push \"{package}\" --api-key {apiKey} --source https://api.nuget.org/v3/index.json --skip-duplicate"
-                );
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine($"Failed to push {package}: {ex.Message}");
-                throw;
-            }
-        }
-    }
-);
-
-Target(
-    DisplayBenchmarkResults,
-    () =>
-    {
-        var githubStepSummary = Environment.GetEnvironmentVariable("GITHUB_STEP_SUMMARY");
-        var resultsDir = "benchmark-results/results";
-
-        if (!Directory.Exists(resultsDir))
-        {
-            Console.WriteLine("No benchmark results found.");
-            return;
-        }
-
-        var markdownFiles = Directory
-            .GetFiles(resultsDir, "*-report-github.md")
-            .OrderBy(f => f)
-            .ToList();
-
-        if (markdownFiles.Count == 0)
-        {
-            Console.WriteLine("No benchmark markdown reports found.");
-            return;
-        }
-
-        var output = new List<string> { "## Benchmark Results", "" };
-
-        foreach (var file in markdownFiles)
-        {
-            Console.WriteLine($"Processing {Path.GetFileName(file)}");
-            var content = File.ReadAllText(file);
-            output.Add(content);
-            output.Add("");
-        }
-
-        // Write to GitHub Step Summary if available
-        if (!string.IsNullOrEmpty(githubStepSummary))
-        {
-            File.AppendAllLines(githubStepSummary, output);
-            Console.WriteLine($"Benchmark results written to GitHub Step Summary");
-        }
-        else
-        {
-            // Write to console if not in GitHub Actions
-            foreach (var line in output)
-            {
-                Console.WriteLine(line);
-            }
-        }
-    }
-);
-
-Target(
-    CompareBenchmarkResults,
-    () =>
-    {
-        var githubStepSummary = Environment.GetEnvironmentVariable("GITHUB_STEP_SUMMARY");
-        var baselinePath = "tests/SharpCompress.Performance/baseline-results.md";
-        var resultsDir = "benchmark-results/results";
-
-        var output = new List<string> { "## Comparison with Baseline", "" };
-
-        if (!File.Exists(baselinePath))
-        {
-            Console.WriteLine("Baseline file not found");
-            output.Add("⚠️ Baseline file not found. Run `generate-baseline` to create it.");
-            WriteOutput(output, githubStepSummary);
-            return;
-        }
-
-        if (!Directory.Exists(resultsDir))
-        {
-            Console.WriteLine("No current benchmark results found.");
-            output.Add("⚠️ No current benchmark results found. Showing baseline only.");
-            output.Add("");
-            output.Add("### Baseline Results");
-            output.AddRange(File.ReadAllLines(baselinePath));
-            WriteOutput(output, githubStepSummary);
-            return;
-        }
-
-        var markdownFiles = Directory
-            .GetFiles(resultsDir, "*-report-github.md")
-            .OrderBy(f => f)
-            .ToList();
-
-        if (markdownFiles.Count == 0)
-        {
-            Console.WriteLine("No current benchmark markdown reports found.");
-            output.Add("⚠️ No current benchmark results found. Showing baseline only.");
-            output.Add("");
-            output.Add("### Baseline Results");
-            output.AddRange(File.ReadAllLines(baselinePath));
-            WriteOutput(output, githubStepSummary);
-            return;
-        }
-
-        Console.WriteLine("Parsing baseline results...");
-        var baselineMetrics = ParseBenchmarkResults(File.ReadAllText(baselinePath));
-
-        Console.WriteLine("Parsing current results...");
-        var currentText = string.Join("\n", markdownFiles.Select(f => File.ReadAllText(f)));
-        var currentMetrics = ParseBenchmarkResults(currentText);
-
-        Console.WriteLine("Comparing results...");
-        output.Add("### Performance Comparison");
-        output.Add("");
-        output.Add(
-            "| Benchmark | Baseline Mean | Current Mean | Change | Baseline Memory | Current Memory | Change |"
-        );
-        output.Add(
-            "|-----------|---------------|--------------|--------|-----------------|----------------|--------|"
-        );
-
-        var hasRegressions = false;
-        var hasImprovements = false;
-
-        foreach (var method in currentMetrics.Keys.Union(baselineMetrics.Keys).OrderBy(k => k))
-        {
-            var hasCurrent = currentMetrics.TryGetValue(method, out var current);
-            var hasBaseline = baselineMetrics.TryGetValue(method, out var baseline);
-
-            if (!hasCurrent)
-            {
-                output.Add(
-                    $"| {method} | {baseline!.Mean} | ❌ Missing | N/A | {baseline.Memory} | N/A | N/A |"
-                );
-                continue;
-            }
-
-            if (!hasBaseline)
-            {
-                output.Add(
-                    $"| {method} | ❌ New | {current!.Mean} | N/A | N/A | {current.Memory} | N/A |"
-                );
-                continue;
-            }
-
-            var timeChange = CalculateChange(baseline!.MeanValue, current!.MeanValue);
-            var memChange = CalculateChange(baseline.MemoryValue, current.MemoryValue);
-
-            var timeIcon =
-                timeChange > 25 ? "🔴"
-                : timeChange < -25 ? "🟢"
-                : "⚪";
-            var memIcon =
-                memChange > 25 ? "🔴"
-                : memChange < -25 ? "🟢"
-                : "⚪";
-
-            if (timeChange > 25 || memChange > 25)
-                hasRegressions = true;
-            if (timeChange < -25 || memChange < -25)
-                hasImprovements = true;
-
-            output.Add(
-                $"| {method} | {baseline.Mean} | {current.Mean} | {timeIcon} {timeChange:+0.0;-0.0;0}% | {baseline.Memory} | {current.Memory} | {memIcon} {memChange:+0.0;-0.0;0}% |"
-            );
-        }
-
-        output.Add("");
-        output.Add("**Legend:**");
-        output.Add("- 🔴 Regression (>25% slower/more memory)");
-        output.Add("- 🟢 Improvement (>25% faster/less memory)");
-        output.Add("- ⚪ No significant change");
-
-        if (hasRegressions)
-        {
-            output.Add("");
-            output.Add(
-                "⚠️ **Warning**: Performance regressions detected. Review the changes carefully."
-            );
-        }
-        else if (hasImprovements)
-        {
-            output.Add("");
-            output.Add("✅ Performance improvements detected!");
-        }
-        else
-        {
-            output.Add("");
-            output.Add("✅ Performance is stable compared to baseline.");
-        }
-
-        WriteOutput(output, githubStepSummary);
-    }
-);
-
-Target(
-    GenerateBaseline,
-    () =>
-    {
-        var perfProject = "tests/SharpCompress.Performance/SharpCompress.Performance.csproj";
-        var baselinePath = "tests/SharpCompress.Performance/baseline-results.md";
-        var artifactsDir = "baseline-artifacts";
-
-        Console.WriteLine("Building performance project...");
-        Run("dotnet", $"build {perfProject} --configuration Release");
-
-        Console.WriteLine("Running benchmarks to generate baseline...");
-        Run(
-            "dotnet",
-            $"run --project {perfProject} --configuration Release --no-build -- --filter \"*\" --exporters markdown --artifacts {artifactsDir}"
-        );
-
-        var resultsDir = Path.Combine(artifactsDir, "results");
-        if (!Directory.Exists(resultsDir))
-        {
-            Console.WriteLine("ERROR: No benchmark results generated.");
-            return;
-        }
-
-        var markdownFiles = Directory
-            .GetFiles(resultsDir, "*-report-github.md")
-            .OrderBy(f => f)
-            .ToList();
-
-        if (markdownFiles.Count == 0)
-        {
-            Console.WriteLine("ERROR: No markdown reports found.");
-            return;
-        }
-
-        Console.WriteLine($"Combining {markdownFiles.Count} benchmark reports...");
-        var baselineContent = new List<string>();
-
-        foreach (var file in markdownFiles)
-        {
-            var lines = File.ReadAllLines(file);
-            baselineContent.AddRange(lines.Select(l => l.Trim()).Where(l => l.StartsWith('|')));
-        }
-
-        File.WriteAllText(baselinePath, string.Join(Environment.NewLine, baselineContent));
-        Console.WriteLine($"Baseline written to {baselinePath}");
-
-        // Clean up artifacts directory
-        if (Directory.Exists(artifactsDir))
-        {
-            Directory.Delete(artifactsDir, true);
-            Console.WriteLine("Cleaned up artifacts directory.");
-        }
-    }
-);
-
 Target("default", [Publish], () => Console.WriteLine("Done!"));
 
 await RunTargetsAndExitAsync(args);
-
-static async Task<(string version, bool isPrerelease)> GetVersion()
-{
-    // Check if current commit has a version tag
-    var currentTag = (await GetGitOutput("tag", "--points-at HEAD"))
-        .Split('\n', StringSplitOptions.RemoveEmptyEntries)
-        .FirstOrDefault(tag => Regex.IsMatch(tag.Trim(), @"^\d+\.\d+\.\d+$"));
-
-    if (!string.IsNullOrEmpty(currentTag))
-    {
-        // Tagged release - use the tag as version
-        var version = currentTag.Trim();
-        Console.WriteLine($"Building tagged release version: {version}");
-        return (version, false);
-    }
-    else
-    {
-        // Not tagged - create prerelease version
-        var allTags = (await GetGitOutput("tag", "--list"))
-            .Split('\n', StringSplitOptions.RemoveEmptyEntries)
-            .Where(tag => Regex.IsMatch(tag.Trim(), @"^\d+\.\d+\.\d+$"))
-            .Select(tag => tag.Trim())
-            .ToList();
-
-        var lastTag = allTags.OrderBy(tag => Version.Parse(tag)).LastOrDefault() ?? "0.0.0";
-        var lastVersion = Version.Parse(lastTag);
-
-        // Determine version increment based on branch
-        var currentBranch = await GetCurrentBranch();
-        Version nextVersion;
-
-        if (currentBranch == "release")
-        {
-            // Release branch: increment patch version
-            nextVersion = new Version(lastVersion.Major, lastVersion.Minor, lastVersion.Build + 1);
-            Console.WriteLine($"Building prerelease for release branch (patch increment)");
-        }
-        else
-        {
-            // Master or other branches: increment minor version
-            nextVersion = new Version(lastVersion.Major, lastVersion.Minor + 1, 0);
-            Console.WriteLine($"Building prerelease for {currentBranch} branch (minor increment)");
-        }
-
-        // Use commit count since the last version tag if available; otherwise, fall back to total count
-        var revListArgs = allTags.Any() ? $"--count {lastTag}..HEAD" : "--count HEAD";
-        var commitCount = (await GetGitOutput("rev-list", revListArgs)).Trim();
-
-        var version = $"{nextVersion}-beta.{commitCount}";
-        Console.WriteLine($"Building prerelease version: {version}");
-        return (version, true);
-    }
-}
-
-static async Task<string> GetCurrentBranch()
-{
-    // In GitHub Actions, GITHUB_REF_NAME contains the branch name
-    var githubRefName = Environment.GetEnvironmentVariable("GITHUB_REF_NAME");
-    if (!string.IsNullOrEmpty(githubRefName))
-    {
-        return githubRefName;
-    }
-
-    // Fallback to git command for local builds
-    try
-    {
-        var (output, _) = await ReadAsync("git", "branch --show-current");
-        return output.Trim();
-    }
-    catch (Exception ex)
-    {
-        Console.WriteLine($"Warning: Could not determine current branch: {ex.Message}");
-        return "unknown";
-    }
-}
-
-static async Task<string> GetGitOutput(string command, string args)
-{
-    try
-    {
-        // Use SimpleExec's Read to execute git commands in a cross-platform way
-        var (output, _) = await ReadAsync("git", $"{command} {args}");
-        return output;
-    }
-    catch (Exception ex)
-    {
-        throw new Exception($"Git command failed: git {command} {args}\n{ex.Message}", ex);
-    }
-}
-
-static void WriteOutput(List<string> output, string? githubStepSummary)
-{
-    if (!string.IsNullOrEmpty(githubStepSummary))
-    {
-        File.AppendAllLines(githubStepSummary, output);
-        Console.WriteLine("Comparison written to GitHub Step Summary");
-    }
-    else
-    {
-        foreach (var line in output)
-        {
-            Console.WriteLine(line);
-        }
-    }
-}
-
-static Dictionary<string, BenchmarkMetric> ParseBenchmarkResults(string markdown)
-{
-    var metrics = new Dictionary<string, BenchmarkMetric>();
-    var lines = markdown.Split('\n');
-
-    for (int i = 0; i < lines.Length; i++)
-    {
-        var line = lines[i].Trim();
-
-        // Look for table rows with benchmark data
-        if (line.StartsWith("|") && line.Contains("&#39;") && i > 0)
-        {
-            var parts = line.Split('|', StringSplitOptions.TrimEntries);
-            if (parts.Length >= 5)
-            {
-                var method = parts[1].Replace("&#39;", "'");
-                var meanStr = parts[2];
-
-                // Find Allocated column - it's usually the last column or labeled "Allocated"
-                string memoryStr = "N/A";
-                for (int j = parts.Length - 2; j >= 2; j--)
-                {
-                    if (
-                        parts[j].Contains("KB")
-                        || parts[j].Contains("MB")
-                        || parts[j].Contains("GB")
-                        || parts[j].Contains("B")
-                    )
-                    {
-                        memoryStr = parts[j];
-                        break;
-                    }
-                }
-
-                if (
-                    !method.Equals("Method", StringComparison.OrdinalIgnoreCase)
-                    && !string.IsNullOrWhiteSpace(method)
-                )
-                {
-                    var metric = new BenchmarkMetric
-                    {
-                        Method = method,
-                        Mean = meanStr,
-                        MeanValue = ParseTimeValue(meanStr),
-                        Memory = memoryStr,
-                        MemoryValue = ParseMemoryValue(memoryStr),
-                    };
-                    metrics[method] = metric;
-                }
-            }
-        }
-    }
-
-    return metrics;
-}
-
-static double ParseTimeValue(string timeStr)
-{
-    if (string.IsNullOrWhiteSpace(timeStr) || timeStr == "N/A" || timeStr == "NA")
-        return 0;
-
-    // Remove thousands separators and parse
-    timeStr = timeStr.Replace(",", "").Trim();
-
-    var match = Regex.Match(timeStr, @"([\d.]+)\s*(\w+)");
-    if (!match.Success)
-        return 0;
-
-    var value = double.Parse(match.Groups[1].Value);
-    var unit = match.Groups[2].Value.ToLower();
-
-    // Convert to microseconds for comparison
-    return unit switch
-    {
-        "s" => value * 1_000_000,
-        "ms" => value * 1_000,
-        "μs" or "us" => value,
-        "ns" => value / 1_000,
-        _ => value,
-    };
-}
-
-static double ParseMemoryValue(string memStr)
-{
-    if (string.IsNullOrWhiteSpace(memStr) || memStr == "N/A" || memStr == "NA")
-        return 0;
-
-    memStr = memStr.Replace(",", "").Trim();
-
-    var match = Regex.Match(memStr, @"([\d.]+)\s*(\w+)");
-    if (!match.Success)
-        return 0;
-
-    var value = double.Parse(match.Groups[1].Value);
-    var unit = match.Groups[2].Value.ToUpper();
-
-    // Convert to KB for comparison
-    return unit switch
-    {
-        "GB" => value * 1_024 * 1_024,
-        "MB" => value * 1_024,
-        "KB" => value,
-        "B" => value / 1_024,
-        _ => value,
-    };
-}
-
-static double CalculateChange(double baseline, double current)
-{
-    if (baseline == 0)
-        return 0;
-    return ((current - baseline) / baseline) * 100;
-}
-
-record BenchmarkMetric
-{
-    public string Method { get; init; } = "";
-    public string Mean { get; init; } = "";
-    public double MeanValue { get; init; }
-    public string Memory { get; init; } = "";
-    public double MemoryValue { get; init; }
-}

build/build.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net10.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Bullseye" />

build/packages.lock.json

@@ -1,12 +1,12 @@
 {
   "version": 2,
   "dependencies": {
-    "net10.0": {
+    "net8.0": {
       "Bullseye": {
         "type": "Direct",
-        "requested": "[6.1.0, )",
-        "resolved": "6.1.0",
-        "contentHash": "fltnAJDe0BEX5eymXGUq+il2rSUA0pHqUonNDRH2TrvRu8SkU17mYG0IVpdmG2ibtfhdjNrv4CuTCxHOwcozCA=="
+        "requested": "[6.0.0, )",
+        "resolved": "6.0.0",
+        "contentHash": "vgwwXfzs7jJrskWH7saHRMgPzziq/e86QZNWY1MnMxd7e+De7E7EX4K3C7yrvaK9y02SJoLxNxcLG/q5qUAghw=="
       },
       "Glob": {
         "type": "Direct",
@@ -14,51 +14,11 @@
         "resolved": "1.1.9",
         "contentHash": "AfK5+ECWYTP7G3AAdnU8IfVj+QpGjrh9GC2mpdcJzCvtQ4pnerAGwHsxJ9D4/RnhDUz2DSzd951O/lQjQby2Sw=="
       },
-      "Microsoft.NETFramework.ReferenceAssemblies": {
-        "type": "Direct",
-        "requested": "[1.0.3, )",
-        "resolved": "1.0.3",
-        "contentHash": "vUc9Npcs14QsyOD01tnv/m8sQUnGTGOw1BCmKcv77LBJY7OxhJ+zJF7UD/sCL3lYNFuqmQEVlkfS4Quif6FyYg==",
-        "dependencies": {
-          "Microsoft.NETFramework.ReferenceAssemblies.net461": "1.0.3"
-        }
-      },
-      "Microsoft.SourceLink.GitHub": {
-        "type": "Direct",
-        "requested": "[10.0.102, )",
-        "resolved": "10.0.102",
-        "contentHash": "Oxq3RCIJSdtpIU4hLqO7XaDe/Ra3HS9Wi8rJl838SAg6Zu1iQjerA0+xXWBgUFYbgknUGCLOU0T+lzMLkvY9Qg==",
-        "dependencies": {
-          "Microsoft.Build.Tasks.Git": "10.0.102",
-          "Microsoft.SourceLink.Common": "10.0.102"
-        }
-      },
-      "Microsoft.VisualStudio.Threading.Analyzers": {
-        "type": "Direct",
-        "requested": "[17.14.15, )",
-        "resolved": "17.14.15",
-        "contentHash": "mXQPJsbuUD2ydq4/ffd8h8tSOFCXec+2xJOVNCvXjuMOq/+5EKHq3D2m2MC2+nUaXeFMSt66VS/J4HdKBixgcw=="
-      },
       "SimpleExec": {
         "type": "Direct",
-        "requested": "[13.0.0, )",
-        "resolved": "13.0.0",
-        "contentHash": "zcCR1pupa1wI1VqBULRiQKeHKKZOuJhi/K+4V5oO+rHJZlaOD53ViFo1c3PavDoMAfSn/FAXGAWpPoF57rwhYg=="
-      },
-      "Microsoft.Build.Tasks.Git": {
-        "type": "Transitive",
-        "resolved": "10.0.102",
-        "contentHash": "0i81LYX31U6UiXz4NOLbvc++u+/mVDmOt+PskrM/MygpDxkv9THKQyRUmavBpLK6iBV0abNWnn+CQgSRz//Pwg=="
-      },
-      "Microsoft.NETFramework.ReferenceAssemblies.net461": {
-        "type": "Transitive",
-        "resolved": "1.0.3",
-        "contentHash": "AmOJZwCqnOCNp6PPcf9joyogScWLtwy0M1WkqfEQ0M9nYwyDD7EX9ZjscKS5iYnyvteX7kzSKFCKt9I9dXA6mA=="
-      },
-      "Microsoft.SourceLink.Common": {
-        "type": "Transitive",
-        "resolved": "10.0.102",
-        "contentHash": "Mk1IMb9q5tahC2NltxYXFkLBtuBvfBoCQ3pIxYQWfzbCE9o1OB9SsHe0hnNGo7lWgTA/ePbFAJLWu6nLL9K17A=="
+        "requested": "[12.0.0, )",
+        "resolved": "12.0.0",
+        "contentHash": "ptxlWtxC8vM6Y6e3h9ZTxBBkOWnWrm/Sa1HT+2i1xcXY3Hx2hmKDZP5RShPf8Xr9D+ivlrXNy57ktzyH8kyt+Q=="
       }
     }
   }

docs/API.md

@@ -1,512 +0,0 @@
-# API Quick Reference
-
-Quick reference for commonly used SharpCompress APIs.
-
-## Factory Methods
-
-### Opening Archives
-
-```csharp
-// Auto-detect format
-using (var reader = ReaderFactory.OpenReader(stream))
-{
-    // Works with Zip, Tar, GZip, Rar, 7Zip, etc.
-}
-
-// Specific format - Archive API
-using (var archive = ZipArchive.OpenArchive("file.zip"))
-using (var archive = TarArchive.OpenArchive("file.tar"))
-using (var archive = RarArchive.OpenArchive("file.rar"))
-using (var archive = SevenZipArchive.OpenArchive("file.7z"))
-using (var archive = GZipArchive.OpenArchive("file.gz"))
-
-// With options
-var options = new ReaderOptions
-{
-    Password = "password",
-    LeaveStreamOpen = true,
-    ArchiveEncoding = new ArchiveEncoding { Default = Encoding.GetEncoding(932) }
-};
-using (var archive = ZipArchive.OpenArchive("encrypted.zip", options))
-```
-
-### Creating Archives
-
-```csharp
-// Writer Factory
-using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Zip, CompressionType.Deflate))
-{
-    // Write entries
-}
-
-// Specific writer
-using (var archive = ZipArchive.CreateArchive())
-using (var archive = TarArchive.CreateArchive())
-using (var archive = GZipArchive.CreateArchive())
-
-// With options
-var options = new WriterOptions(CompressionType.Deflate)
-{
-    CompressionLevel = 9,
-    LeaveStreamOpen = false
-};
-using (var archive = ZipArchive.CreateArchive())
-{
-    archive.SaveTo("output.zip", options);
-}
-```
-
----
-
-## Archive API Methods
-
-### Reading/Extracting
-
-```csharp
-using (var archive = ZipArchive.OpenArchive("file.zip"))
-{
-    // Get all entries
-    IEnumerable<IArchiveEntry> entries = archive.Entries;
-
-    // Find specific entry
-    var entry = archive.Entries.FirstOrDefault(e => e.Key == "file.txt");
-
-    // Extract all
-    archive.WriteToDirectory(@"C:\output", new ExtractionOptions
-    {
-        ExtractFullPath = true,
-        Overwrite = true
-    });
-
-    // Extract single entry
-    var entry = archive.Entries.First();
-    entry.WriteToFile(@"C:\output\file.txt");
-    entry.WriteToFile(@"C:\output\file.txt", new ExtractionOptions { Overwrite = true });
-
-    // Get entry stream
-    using (var stream = entry.OpenEntryStream())
-    {
-        stream.CopyTo(outputStream);
-    }
-}
-
-// Async extraction (requires IAsyncArchive)
-using (var asyncArchive = await ZipArchive.OpenAsyncArchive("file.zip"))
-{
-    await asyncArchive.WriteToDirectoryAsync(
-        @"C:\output",
-        new ExtractionOptions { ExtractFullPath = true, Overwrite = true },
-        cancellationToken: cancellationToken
-    );
-}
-using (var stream = await entry.OpenEntryStreamAsync(cancellationToken))
-{
-    // ...
-}
-```
-
-### Entry Properties
-
-```csharp
-foreach (var entry in archive.Entries)
-{
-    string name = entry.Key;              // Entry name/path
-    long size = entry.Size;               // Uncompressed size
-    long compressedSize = entry.CompressedSize;
-    bool isDir = entry.IsDirectory;
-    DateTime? modTime = entry.LastModifiedTime;
-    CompressionType compression = entry.CompressionType;
-}
-```
-
-### Creating Archives
-
-```csharp
-using (var archive = ZipArchive.CreateArchive())
-{
-    // Add file
-    archive.AddEntry("file.txt", @"C:\source\file.txt");
-
-    // Add multiple files
-    archive.AddAllFromDirectory(@"C:\source");
-    archive.AddAllFromDirectory(@"C:\source", "*.txt");  // Pattern
-
-    // Save to file
-    archive.SaveTo("output.zip", CompressionType.Deflate);
-
-    // Save to stream
-    archive.SaveTo(outputStream, new WriterOptions(CompressionType.Deflate)
-    {
-        CompressionLevel = 9,
-        LeaveStreamOpen = true
-    });
-}
-```
-
----
-
-## Reader API Methods
-
-### Forward-Only Reading
-
-```csharp
-using (var stream = File.OpenRead("file.zip"))
-using (var reader = ReaderFactory.OpenReader(stream))
-{
-    while (reader.MoveToNextEntry())
-    {
-        IArchiveEntry entry = reader.Entry;
-
-        if (!entry.IsDirectory)
-        {
-            // Extract entry
-            reader.WriteEntryToDirectory(@"C:\output");
-            reader.WriteEntryToFile(@"C:\output\file.txt");
-
-            // Or get stream
-            using (var entryStream = reader.OpenEntryStream())
-            {
-                entryStream.CopyTo(outputStream);
-            }
-        }
-    }
-}
-
-// Async variants (use OpenAsyncReader to get IAsyncReader)
-using (var stream = File.OpenRead("file.zip"))
-using (var reader = await ReaderFactory.OpenAsyncReader(stream))
-{
-    while (await reader.MoveToNextEntryAsync())
-    {
-        await reader.WriteEntryToFileAsync(
-            @"C:\output\" + reader.Entry.Key,
-            cancellationToken: cancellationToken
-        );
-    }
-
-    // Async extraction of all entries
-    await reader.WriteAllToDirectoryAsync(
-        @"C:\output",
-        new ExtractionOptions { ExtractFullPath = true, Overwrite = true },
-        cancellationToken
-    );
-}
-```
-
----
-
-## Writer API Methods
-
-### Creating Archives (Streaming)
-
-```csharp
-using (var stream = File.Create("output.zip"))
-using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Zip, CompressionType.Deflate))
-{
-    // Write single file
-    using (var fileStream = File.OpenRead("source.txt"))
-    {
-        writer.Write("entry.txt", fileStream, DateTime.Now);
-    }
-    
-    // Write directory
-    writer.WriteAll("C:\\source", "*", SearchOption.AllDirectories);
-    writer.WriteAll("C:\\source", "*.txt", SearchOption.TopDirectoryOnly);
-    
-    // Async variants
-    using (var fileStream = File.OpenRead("source.txt"))
-    {
-        await writer.WriteAsync("entry.txt", fileStream, DateTime.Now, cancellationToken);
-    }
-    
-    await writer.WriteAllAsync("C:\\source", "*", SearchOption.AllDirectories, cancellationToken);
-}
-```
-
----
-
-## Common Options
-
-### ReaderOptions
-
-```csharp
-var options = new ReaderOptions
-{
-    Password = "password",                          // For encrypted archives
-    LeaveStreamOpen = true,                         // Don't close wrapped stream
-    ArchiveEncoding = new ArchiveEncoding          // Custom character encoding
-    {
-        Default = Encoding.GetEncoding(932)
-    }
-};
-using (var archive = ZipArchive.OpenArchive("file.zip", options))
-{
-    // ...
-}
-```
-
-### WriterOptions
-
-```csharp
-var options = new WriterOptions(CompressionType.Deflate)
-{
-    CompressionLevel = 9,                           // 0-9 for Deflate
-    LeaveStreamOpen = true,                         // Don't close stream
-};
-archive.SaveTo("output.zip", options);
-```
-
-### ExtractionOptions
-
-```csharp
-var options = new ExtractionOptions
-{
-    ExtractFullPath = true,                         // Recreate directory structure
-    Overwrite = true,                               // Overwrite existing files
-    PreserveFileTime = true                         // Keep original timestamps
-};
-archive.WriteToDirectory(@"C:\output", options);
-```
-
----
-
-## Compression Types
-
-### Available Compressions
-
-```csharp
-// For creating archives
-CompressionType.None       // No compression (store)
-CompressionType.Deflate    // DEFLATE (default for ZIP/GZip)
-CompressionType.Deflate64  // Deflate64
-CompressionType.BZip2      // BZip2
-CompressionType.LZMA       // LZMA (for 7Zip, LZip, XZ)
-CompressionType.PPMd       // PPMd (for ZIP)
-CompressionType.Rar        // RAR compression (read-only)
-CompressionType.ZStandard  // ZStandard
-ArchiveType.Arc
-ArchiveType.Arj
-ArchiveType.Ace
-
-// For Tar archives with compression
-// Use WriterFactory to create compressed tar archives
-using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Tar, CompressionType.GZip))  // Tar.GZip
-using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Tar, CompressionType.BZip2)) // Tar.BZip2
-```
-
-### Archive Types
-
-```csharp
-ArchiveType.Zip
-ArchiveType.Tar
-ArchiveType.GZip
-ArchiveType.BZip2
-ArchiveType.Rar
-ArchiveType.SevenZip
-ArchiveType.XZ
-ArchiveType.ZStandard
-```
-
----
-
-## Patterns & Examples
-
-### Extract with Error Handling
-
-```csharp
-try
-{
-    using (var archive = ZipArchive.Open("archive.zip", 
-        new ReaderOptions { Password = "password" }))
-    {
-        archive.WriteToDirectory(@"C:\output", new ExtractionOptions
-        {
-            ExtractFullPath = true,
-            Overwrite = true
-        });
-    }
-}
-catch (PasswordRequiredException)
-{
-    Console.WriteLine("Password required");
-}
-catch (InvalidArchiveException)
-{
-    Console.WriteLine("Archive is invalid");
-}
-catch (SharpCompressException ex)
-{
-    Console.WriteLine($"Error: {ex.Message}");
-}
-```
-
-### Extract with Progress
-
-```csharp
-var progress = new Progress<ProgressReport>(report =>
-{
-    Console.WriteLine($"Extracting {report.EntryPath}: {report.PercentComplete}%");
-});
-
-var options = new ReaderOptions { Progress = progress };
-using (var archive = ZipArchive.OpenArchive("archive.zip", options))
-{
-    archive.WriteToDirectory(@"C:\output");
-}
-```
-
-### Async Extract with Cancellation
-
-```csharp
-var cts = new CancellationTokenSource();
-cts.CancelAfter(TimeSpan.FromMinutes(5));
-
-try
-{
-    using (var archive = await ZipArchive.OpenAsyncArchive("archive.zip"))
-    {
-        await archive.WriteToDirectoryAsync(
-            @"C:\output",
-            new ExtractionOptions { ExtractFullPath = true, Overwrite = true },
-            cancellationToken: cts.Token
-        );
-    }
-}
-catch (OperationCanceledException)
-{
-    Console.WriteLine("Extraction cancelled");
-}
-```
-
-### Create with Custom Compression
-
-```csharp
-using (var archive = ZipArchive.CreateArchive())
-{
-    archive.AddAllFromDirectory(@"D:\source");
-    
-    // Fastest
-    archive.SaveTo("fast.zip", new WriterOptions(CompressionType.Deflate)
-    {
-        CompressionLevel = 1
-    });
-    
-    // Balanced (default)
-    archive.SaveTo("normal.zip", CompressionType.Deflate);
-    
-    // Best compression
-    archive.SaveTo("best.zip", new WriterOptions(CompressionType.Deflate)
-    {
-        CompressionLevel = 9
-    });
-}
-```
-
-### Stream Processing (No File I/O)
-
-```csharp
-using (var outputStream = new MemoryStream())
-using (var archive = ZipArchive.CreateArchive())
-{
-    // Add content from memory
-    using (var contentStream = new MemoryStream(Encoding.UTF8.GetBytes("Hello")))
-    {
-        archive.AddEntry("file.txt", contentStream);
-    }
-    
-    // Save to memory
-    archive.SaveTo(outputStream, CompressionType.Deflate);
-    
-    // Get bytes
-    byte[] archiveBytes = outputStream.ToArray();
-}
-```
-
-### Extract Specific Files
-
-```csharp
-using (var archive = ZipArchive.OpenArchive("archive.zip"))
-{
-    var filesToExtract = new[] { "file1.txt", "file2.txt" };
-    
-    foreach (var entry in archive.Entries.Where(e => filesToExtract.Contains(e.Key)))
-    {
-        entry.WriteToFile(@"C:\output\" + entry.Key);
-    }
-}
-```
-
-### List Archive Contents
-
-```csharp
-using (var archive = ZipArchive.OpenArchive("archive.zip"))
-{
-    foreach (var entry in archive.Entries)
-    {
-        if (entry.IsDirectory)
-            Console.WriteLine($"[DIR]  {entry.Key}");
-        else
-            Console.WriteLine($"[FILE] {entry.Key} ({entry.Size} bytes)");
-    }
-}
-```
-
----
-
-## Common Mistakes
-
-### ✗ Wrong - Stream not disposed
-
-```csharp
-var stream = File.OpenRead("archive.zip");
-var archive = ZipArchive.OpenArchive(stream);
-archive.WriteToDirectory(@"C:\output");
-// stream not disposed - leaked resource
-```
-
-### ✓ Correct - Using blocks
-
-```csharp
-using (var stream = File.OpenRead("archive.zip"))
-using (var archive = ZipArchive.OpenArchive(stream))
-{
-    archive.WriteToDirectory(@"C:\output");
-}
-// Both properly disposed
-```
-
-### ✗ Wrong - Mixing API styles
-
-```csharp
-// Loading entire archive then iterating
-using (var archive = ZipArchive.OpenArchive("large.zip"))
-{
-    var entries = archive.Entries.ToList();  // Loads all in memory
-    foreach (var e in entries)
-    {
-        e.WriteToFile(...);  // Then extracts each
-    }
-}
-```
-
-### ✓ Correct - Use Reader for large files
-
-```csharp
-// Streaming iteration
-using (var stream = File.OpenRead("large.zip"))
-using (var reader = ReaderFactory.OpenReader(stream))
-{
-    while (reader.MoveToNextEntry())
-    {
-        reader.WriteEntryToDirectory(@"C:\output");
-    }
-}
-```
-
----
-
-## Related Documentation
-
-- [USAGE.md](USAGE.md) - Complete code examples
-- [FORMATS.md](FORMATS.md) - Supported formats
-- [PERFORMANCE.md](PERFORMANCE.md) - API selection guide

docs/ARCHITECTURE.md

@@ -1,659 +0,0 @@
-# SharpCompress Architecture Guide
-
-This guide explains the internal architecture and design patterns of SharpCompress for contributors.
-
-## Overview
-
-SharpCompress is organized into three main layers:
-
-```
-┌─────────────────────────────────────────┐
-│     User-Facing APIs (Top Layer)        │
-│  Archive, Reader, Writer Factories      │
-├─────────────────────────────────────────┤
-│     Format-Specific Implementations     │
-│  ZipArchive, TarReader, GZipWriter,     │
-│  RarArchive, SevenZipArchive, etc.      │
-├─────────────────────────────────────────┤
-│     Compression & Crypto (Bottom Layer) │
-│  Deflate, LZMA, BZip2, AES, CRC32       │
-└─────────────────────────────────────────┘
-```
-
----
-
-## Directory Structure
-
-### `src/SharpCompress/`
-
-#### `Archives/` - Archive Implementations
-Contains `IArchive` implementations for seekable, random-access APIs.
-
-**Key Files:**
-- `AbstractArchive.cs` - Base class for all archives
-- `IArchive.cs` - Archive interface definition
-- `ArchiveFactory.cs` - Factory for opening archives
-- Format-specific: `ZipArchive.cs`, `TarArchive.cs`, `RarArchive.cs`, `SevenZipArchive.cs`, `GZipArchive.cs`
-
-**Use Archive API when:**
-- Stream is seekable (file, memory)
-- Need random access to entries
-- Archive fits in memory
-- Simplicity is important
-
-#### `Readers/` - Reader Implementations
-Contains `IReader` implementations for forward-only, non-seekable APIs.
-
-**Key Files:**
-- `AbstractReader.cs` - Base reader class
-- `IReader.cs` - Reader interface
-- `ReaderFactory.cs` - Auto-detection factory
-- `ReaderOptions.cs` - Configuration for readers
-- Format-specific: `ZipReader.cs`, `TarReader.cs`, `GZipReader.cs`, `RarReader.cs`, etc.
-
-**Use Reader API when:**
-- Stream is non-seekable (network, pipe, compressed)
-- Processing large files
-- Memory is limited
-- Forward-only processing is acceptable
-
-#### `Writers/` - Writer Implementations
-Contains `IWriter` implementations for forward-only writing.
-
-**Key Files:**
-- `AbstractWriter.cs` - Base writer class
-- `IWriter.cs` - Writer interface
-- `WriterFactory.cs` - Factory for creating writers
-- `WriterOptions.cs` - Configuration for writers
-- Format-specific: `ZipWriter.cs`, `TarWriter.cs`, `GZipWriter.cs`
-
-#### `Factories/` - Format Detection
-Factory classes for auto-detecting archive format and creating appropriate readers/writers.
-
-**Key Files:**
-- `Factory.cs` - Base factory class
-- `IFactory.cs` - Factory interface
-- Format-specific: `ZipFactory.cs`, `TarFactory.cs`, `RarFactory.cs`, etc.
-
-**How It Works:**
-1. `ReaderFactory.OpenReader(stream)` probes stream signatures
-2. Identifies format by magic bytes
-3. Creates appropriate reader instance
-4. Returns generic `IReader` interface
-
-#### `Common/` - Shared Types
-Common types, options, and enumerations used across formats.
-
-**Key Files:**
-- `IEntry.cs` - Entry interface (file within archive)
-- `Entry.cs` - Entry implementation
-- `ArchiveType.cs` - Enum for archive formats
-- `CompressionType.cs` - Enum for compression methods
-- `ArchiveEncoding.cs` - Character encoding configuration
-- `ExtractionOptions.cs` - Extraction configuration
-- Format-specific headers: `Zip/Headers/`, `Tar/Headers/`, `Rar/Headers/`, etc.
-
-#### `Compressors/` - Compression Algorithms
-Low-level compression streams implementing specific algorithms.
-
-**Algorithms:**
-- `Deflate/` - DEFLATE compression (Zip default)
-- `BZip2/` - BZip2 compression
-- `LZMA/` - LZMA compression (7Zip, XZ, LZip)
-- `PPMd/` - Prediction by Partial Matching (Zip, 7Zip)
-- `ZStandard/` - ZStandard compression (decompression only)
-- `Xz/` - XZ format (decompression only)
-- `Rar/` - RAR-specific unpacking
-- `Arj/`, `Arc/`, `Ace/` - Legacy format decompression
-- `Filters/` - BCJ/BCJ2 filters for executable compression
-
-**Each Compressor:**
-- Implements a `Stream` subclass
-- Provides both compression and decompression
-- Some are read-only (decompression only)
-
-#### `Crypto/` - Encryption & Hashing
-Cryptographic functions and stream wrappers.
-
-**Key Files:**
-- `Crc32Stream.cs` - CRC32 calculation wrapper
-- `BlockTransformer.cs` - Block cipher transformations
-- AES, PKWare, WinZip encryption implementations
-
-#### `IO/` - Stream Utilities
-Stream wrappers and utilities.
-
-**Key Classes:**
-- `SharpCompressStream` - Base stream class
-- `ProgressReportingStream` - Progress tracking wrapper
-- `MarkingBinaryReader` - Binary reader with position marks
-- `BufferedSubStream` - Buffered read-only substream
-- `ReadOnlySubStream` - Read-only view of parent stream
-- `NonDisposingStream` - Prevents wrapped stream disposal
-
----
-
-## Design Patterns
-
-### 1. Factory Pattern
-
-**Purpose:** Auto-detect format and create appropriate reader/writer.
-
-**Example:**
-```csharp
-// User calls factory
-using (var reader = ReaderFactory.OpenReader(stream))  // Returns IReader
-{
-    while (reader.MoveToNextEntry())
-    {
-        // Process entry
-    }
-}
-
-// Behind the scenes:
-// 1. Factory.Open() probes stream signatures
-// 2. Detects format (Zip, Tar, Rar, etc.)
-// 3. Creates appropriate reader (ZipReader, TarReader, etc.)
-// 4. Returns as generic IReader interface
-```
-
-**Files:**
-- `src/SharpCompress/Factories/ReaderFactory.cs`
-- `src/SharpCompress/Factories/WriterFactory.cs`
-- `src/SharpCompress/Factories/ArchiveFactory.cs`
-
-### 2. Strategy Pattern
-
-**Purpose:** Encapsulate compression algorithms as swappable strategies.
-
-**Example:**
-```csharp
-// Different compression strategies
-CompressionType.Deflate     // DEFLATE
-CompressionType.BZip2       // BZip2
-CompressionType.LZMA        // LZMA
-CompressionType.PPMd        // PPMd
-
-// Writer uses strategy pattern
-var archive = ZipArchive.CreateArchive();
-archive.SaveTo("output.zip", CompressionType.Deflate);   // Use Deflate
-archive.SaveTo("output.bz2", CompressionType.BZip2);    // Use BZip2
-```
-
-**Files:**
-- `src/SharpCompress/Compressors/` - Strategy implementations
-
-### 3. Decorator Pattern
-
-**Purpose:** Wrap streams with additional functionality.
-
-**Example:**
-```csharp
-// Progress reporting decorator
-var progressStream = new ProgressReportingStream(baseStream, progressReporter);
-progressStream.Read(buffer, 0, buffer.Length);  // Reports progress
-
-// Non-disposing decorator
-var nonDisposingStream = new NonDisposingStream(baseStream);
-using (var compressor = new DeflateStream(nonDisposingStream))
-{
-    // baseStream won't be disposed when compressor is disposed
-}
-```
-
-**Files:**
-- `src/SharpCompress/IO/ProgressReportingStream.cs`
-- `src/SharpCompress/IO/NonDisposingStream.cs`
-
-### 4. Template Method Pattern
-
-**Purpose:** Define algorithm skeleton in base class, let subclasses fill details.
-
-**Example:**
-```csharp
-// AbstractArchive defines common archive operations
-public abstract class AbstractArchive : IArchive
-{
-    // Template methods
-    public virtual void WriteToDirectory(string destinationDirectory, ExtractionOptions options)
-    {
-        // Common extraction logic
-        foreach (var entry in Entries)
-        {
-            // Call subclass method
-            entry.WriteToFile(destinationPath, options);
-        }
-    }
-    
-    // Subclasses override format-specific details
-    protected abstract Entry CreateEntry(EntryData data);
-}
-```
-
-**Files:**
-- `src/SharpCompress/Archives/AbstractArchive.cs`
-- `src/SharpCompress/Readers/AbstractReader.cs`
-
-### 5. Iterator Pattern
-
-**Purpose:** Provide sequential access to entries.
-
-**Example:**
-```csharp
-// Archive API - provides collection
-IEnumerable<IEntry> entries = archive.Entries;
-foreach (var entry in entries)
-{
-    // Random access - entries already in memory
-}
-
-// Reader API - provides iterator
-IReader reader = ReaderFactory.OpenReader(stream);
-while (reader.MoveToNextEntry())
-{
-    // Forward-only iteration - one entry at a time
-    var entry = reader.Entry;
-}
-```
-
----
-
-## Key Interfaces
-
-### IArchive - Random Access API
-
-```csharp
-public interface IArchive : IDisposable
-{
-    IEnumerable<IEntry> Entries { get; }
-    
-    void WriteToDirectory(string destinationDirectory, 
-                         ExtractionOptions options = null);
-    
-    IEntry FirstOrDefault(Func<IEntry, bool> predicate);
-    
-    // ... format-specific methods
-}
-```
-
-**Implementations:** `ZipArchive`, `TarArchive`, `RarArchive`, `SevenZipArchive`, `GZipArchive`
-
-### IReader - Forward-Only API
-
-```csharp
-public interface IReader : IDisposable
-{
-    IEntry Entry { get; }
-    
-    bool MoveToNextEntry();
-    
-    void WriteEntryToDirectory(string destinationDirectory,
-                              ExtractionOptions options = null);
-    
-    Stream OpenEntryStream();
-    
-    // ... async variants
-}
-```
-
-**Implementations:** `ZipReader`, `TarReader`, `RarReader`, `GZipReader`, etc.
-
-### IWriter - Writing API
-
-```csharp
-public interface IWriter : IDisposable
-{
-    void Write(string entryPath, Stream source, 
-              DateTime? modificationTime = null);
-    
-    void WriteAll(string sourceDirectory, string searchPattern,
-                 SearchOption searchOption);
-    
-    // ... async variants
-}
-```
-
-**Implementations:** `ZipWriter`, `TarWriter`, `GZipWriter`
-
-### IEntry - Archive Entry
-
-```csharp
-public interface IEntry
-{
-    string Key { get; }
-    uint Size { get; }
-    uint CompressedSize { get; }
-    bool IsDirectory { get; }
-    DateTime? LastModifiedTime { get; }
-    CompressionType CompressionType { get; }
-    
-    void WriteToFile(string fullPath, ExtractionOptions options = null);
-    void WriteToStream(Stream destinationStream);
-    Stream OpenEntryStream();
-    
-    // ... async variants
-}
-```
-
----
-
-## Adding Support for a New Format
-
-### Step 1: Understand the Format
-- Research format specification
-- Understand compression/encryption used
-- Study existing similar formats in codebase
-
-### Step 2: Create Format Structure Classes
-
-**Create:** `src/SharpCompress/Common/NewFormat/`
-
-```csharp
-// Headers and data structures
-public class NewFormatHeader
-{
-    public uint Magic { get; set; }
-    public ushort Version { get; set; }
-    // ... other fields
-    
-    public static NewFormatHeader Read(BinaryReader reader)
-    {
-        // Deserialize from binary
-    }
-}
-
-public class NewFormatEntry
-{
-    public string FileName { get; set; }
-    public uint CompressedSize { get; set; }
-    public uint UncompressedSize { get; set; }
-    // ... other fields
-}
-```
-
-### Step 3: Create Archive Implementation
-
-**Create:** `src/SharpCompress/Archives/NewFormat/NewFormatArchive.cs`
-
-```csharp
-public class NewFormatArchive : AbstractArchive
-{
-    private NewFormatHeader _header;
-    private List<NewFormatEntry> _entries;
-    
-    public static NewFormatArchive OpenArchive(Stream stream)
-    {
-        var archive = new NewFormatArchive();
-        archive._header = NewFormatHeader.Read(stream);
-        archive.LoadEntries(stream);
-        return archive;
-    }
-    
-    public override IEnumerable<IEntry> Entries => _entries.Select(e => new Entry(e));
-    
-    protected override Stream OpenEntryStream(Entry entry)
-    {
-        // Return decompressed stream for entry
-    }
-    
-    // ... other abstract method implementations
-}
-```
-
-### Step 4: Create Reader Implementation
-
-**Create:** `src/SharpCompress/Readers/NewFormat/NewFormatReader.cs`
-
-```csharp
-public class NewFormatReader : AbstractReader
-{
-    private NewFormatHeader _header;
-    private BinaryReader _reader;
-    
-    public NewFormatReader(Stream stream)
-    {
-        _reader = new BinaryReader(stream);
-        _header = NewFormatHeader.Read(_reader);
-    }
-    
-    public override bool MoveToNextEntry()
-    {
-        // Read next entry header
-        if (!_reader.BaseStream.CanRead) return false;
-        
-        var entryData = NewFormatEntry.Read(_reader);
-        // ... set this.Entry
-        return entryData != null;
-    }
-    
-    // ... other abstract method implementations
-}
-```
-
-### Step 5: Create Factory
-
-**Create:** `src/SharpCompress/Factories/NewFormatFactory.cs`
-
-```csharp
-public class NewFormatFactory : Factory, IArchiveFactory, IReaderFactory
-{
-    // Archive format magic bytes (signature)
-    private static readonly byte[] NewFormatSignature = new byte[] { 0x4E, 0x46 };  // "NF"
-    
-    public static NewFormatFactory Instance { get; } = new();
-    
-    public IArchive CreateArchive(Stream stream)
-        => NewFormatArchive.OpenArchive(stream);
-    
-    public IReader CreateReader(Stream stream, ReaderOptions options)
-        => new NewFormatReader(stream) { Options = options };
-    
-    public bool Matches(Stream stream, ReadOnlySpan<byte> signature) 
-        => signature.StartsWith(NewFormatSignature);
-}
-```
-
-### Step 6: Register Factory
-
-**Update:** `src/SharpCompress/Factories/ArchiveFactory.cs`
-
-```csharp
-private static readonly IFactory[] Factories = 
-{
-    ZipFactory.Instance,
-    TarFactory.Instance,
-    RarFactory.Instance,
-    SevenZipFactory.Instance,
-    GZipFactory.Instance,
-    NewFormatFactory.Instance,  // Add here
-    // ... other factories
-};
-```
-
-### Step 7: Add Tests
-
-**Create:** `tests/SharpCompress.Test/NewFormat/NewFormatTests.cs`
-
-```csharp
-public class NewFormatTests : TestBase
-{
-    [Fact]
-    public void NewFormat_Extracts_Successfully()
-    {
-        var archivePath = Path.Combine(TEST_ARCHIVES_PATH, "archive.newformat");
-        using (var archive = NewFormatArchive.OpenArchive(archivePath))
-        {
-            archive.WriteToDirectory(SCRATCH_FILES_PATH);
-            // Assert extraction
-        }
-    }
-    
-    [Fact]
-    public void NewFormat_Reader_Works()
-    {
-        var archivePath = Path.Combine(TEST_ARCHIVES_PATH, "archive.newformat");
-        using (var stream = File.OpenRead(archivePath))
-        using (var reader = new NewFormatReader(stream))
-        {
-            Assert.True(reader.MoveToNextEntry());
-            Assert.NotNull(reader.Entry);
-        }
-    }
-}
-```
-
-### Step 8: Add Test Archives
-
-Place test files in `tests/TestArchives/Archives/NewFormat/` directory.
-
-### Step 9: Document
-
-Update `docs/FORMATS.md` with format support information.
-
----
-
-## Compression Algorithm Implementation
-
-### Creating a New Compression Stream
-
-**Example:** Creating `CustomStream` for a custom compression algorithm
-
-```csharp
-public class CustomStream : Stream
-{
-    private readonly Stream _baseStream;
-    private readonly bool _leaveOpen;
-    
-    public CustomStream(Stream baseStream, bool leaveOpen = false)
-    {
-        _baseStream = baseStream;
-        _leaveOpen = leaveOpen;
-    }
-    
-    public override int Read(byte[] buffer, int offset, int count)
-    {
-        // Decompress data from _baseStream into buffer
-        // Return number of decompressed bytes
-    }
-    
-    public override void Write(byte[] buffer, int offset, int count)
-    {
-        // Compress data from buffer into _baseStream
-    }
-    
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && !_leaveOpen)
-        {
-            _baseStream?.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-}
-```
-
----
-
-## Stream Handling Best Practices
-
-### Disposal Pattern
-
-```csharp
-// Correct: Nested using blocks
-using (var fileStream = File.OpenRead("archive.zip"))
-using (var archive = ZipArchive.OpenArchive(fileStream))
-{
-    archive.WriteToDirectory(@"C:\output");
-}
-// Both archive and fileStream properly disposed
-
-// Correct: Using with options
-var options = new ReaderOptions { LeaveStreamOpen = true };
-var stream = File.OpenRead("archive.zip");
-using (var archive = ZipArchive.OpenArchive(stream, options))
-{
-    archive.WriteToDirectory(@"C:\output");
-}
-stream.Dispose();  // Manually dispose if LeaveStreamOpen = true
-```
-
-### NonDisposingStream Wrapper
-
-```csharp
-// Prevent unwanted stream closure
-var baseStream = File.OpenRead("data.bin");
-var nonDisposing = new NonDisposingStream(baseStream);
-
-using (var compressor = new DeflateStream(nonDisposing))
-{
-    // Compressor won't close baseStream when disposed
-}
-
-// baseStream still usable
-baseStream.Position = 0;  // Works
-baseStream.Dispose();  // Manual disposal
-```
-
----
-
-## Performance Considerations
-
-### Memory Efficiency
-
-1. **Avoid loading entire archive in memory** - Use Reader API for large files
-2. **Process entries sequentially** - Especially for solid archives
-3. **Use appropriate buffer sizes** - Larger buffers for network I/O
-4. **Dispose streams promptly** - Free resources when done
-
-### Algorithm Selection
-
-1. **Archive API** - Fast for small archives with random access
-2. **Reader API** - Efficient for large files or streaming
-3. **Solid archives** - Sequential extraction much faster
-4. **Compression levels** - Trade-off between speed and size
-
----
-
-## Testing Guidelines
-
-### Test Coverage
-
-1. **Happy path** - Normal extraction works
-2. **Edge cases** - Empty archives, single file, many files
-3. **Corrupted data** - Handle gracefully
-4. **Error cases** - Missing passwords, unsupported compression
-5. **Async operations** - Both sync and async code paths
-
-### Test Archives
-
-- Use `tests/TestArchives/` for test data
-- Create format-specific subdirectories
-- Include encrypted, corrupted, and edge case archives
-- Don't recreate existing archives
-
-### Test Patterns
-
-```csharp
-[Fact]
-public void Archive_Extraction_Works()
-{
-    // Arrange
-    var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "test.zip");
-    
-    // Act
-    using (var archive = ZipArchive.OpenArchive(testArchive))
-    {
-        archive.WriteToDirectory(SCRATCH_FILES_PATH);
-    }
-    
-    // Assert
-    Assert.True(File.Exists(Path.Combine(SCRATCH_FILES_PATH, "file.txt")));
-}
-```
-
----
-
-## Related Documentation
-
-- [AGENTS.md](../AGENTS.md) - Development guidelines
-- [FORMATS.md](FORMATS.md) - Supported formats

docs/ENCODING.md

@@ -1,610 +0,0 @@
-# SharpCompress Character Encoding Guide
-
-This guide explains how SharpCompress handles character encoding for archive entries (filenames, comments, etc.).
-
-## Overview
-
-Most archive formats store filenames and metadata as bytes. SharpCompress must convert these bytes to strings using the appropriate character encoding.
-
-**Common Problem:** Archives created on systems with non-UTF8 encodings (especially Japanese, Chinese systems) appear with corrupted filenames when extracted on systems that assume UTF8.
-
----
-
-## ArchiveEncoding Class
-
-### Basic Usage
-
-```csharp
-using SharpCompress.Common;
-using SharpCompress.Readers;
-
-// Configure encoding before opening archive
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.GetEncoding(932)  // cp932 for Japanese
-    }
-};
-
-using (var archive = ZipArchive.OpenArchive("japanese.zip", options))
-{
-    foreach (var entry in archive.Entries)
-    {
-        Console.WriteLine(entry.Key);  // Now shows correct characters
-    }
-}
-```
-
-### ArchiveEncoding Properties
-
-| Property | Purpose |
-|----------|---------|
-| `Default` | Default encoding for filenames (fallback) |
-| `CustomDecoder` | Custom decoding function for special cases |
-
-### Setting for Different APIs
-
-**Archive API:**
-```csharp
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding { Default = Encoding.GetEncoding(932) }
-};
-using (var archive = ZipArchive.OpenArchive("file.zip", options))
-{
-    // Use archive with correct encoding
-}
-```
-
-**Reader API:**
-```csharp
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding { Default = Encoding.GetEncoding(932) }
-};
-using (var stream = File.OpenRead("file.zip"))
-using (var reader = ReaderFactory.OpenReader(stream, options))
-{
-    while (reader.MoveToNextEntry())
-    {
-        // Filenames decoded correctly
-    }
-}
-```
-
----
-
-## Common Encodings
-
-### Asian Encodings
-
-#### cp932 (Japanese)
-```csharp
-// Windows-31J, Shift-JIS variant used on Japanese Windows
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.GetEncoding(932)
-    }
-};
-using (var archive = ZipArchive.OpenArchive("japanese.zip", options))
-{
-    // Correctly decodes Japanese filenames
-}
-```
-
-**When to use:**
-- Archives from Japanese Windows systems
-- Files with Japanese characters in names
-
-#### gb2312 (Simplified Chinese)
-```csharp
-// Simplified Chinese
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.GetEncoding("gb2312")
-    }
-};
-```
-
-#### gbk (Extended Simplified Chinese)
-```csharp
-// Extended Simplified Chinese (more characters than gb2312)
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.GetEncoding("gbk")
-    }
-};
-```
-
-#### big5 (Traditional Chinese)
-```csharp
-// Traditional Chinese (Taiwan, Hong Kong)
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.GetEncoding("big5")
-    }
-};
-```
-
-#### euc-jp (Japanese, Unix)
-```csharp
-// Extended Unix Code for Japanese
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.GetEncoding("eucjp")
-    }
-};
-```
-
-#### euc-kr (Korean)
-```csharp
-// Extended Unix Code for Korean
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.GetEncoding("euc-kr")
-    }
-};
-```
-
-### Western European Encodings
-
-#### iso-8859-1 (Latin-1)
-```csharp
-// Western European (includes accented characters)
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.GetEncoding("iso-8859-1")
-    }
-};
-```
-
-**When to use:**
-- Archives from French, German, Spanish systems
-- Files with accented characters (é, ñ, ü, etc.)
-
-#### cp1252 (Windows-1252)
-```csharp
-// Windows Western European
-// Very similar to iso-8859-1 but with additional printable characters
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.GetEncoding("cp1252")
-    }
-};
-```
-
-**When to use:**
-- Archives from older Western European Windows systems
-- Files with smart quotes and other Windows-specific characters
-
-#### iso-8859-15 (Latin-9)
-```csharp
-// Western European with Euro symbol support
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.GetEncoding("iso-8859-15")
-    }
-};
-```
-
-### Cyrillic Encodings
-
-#### cp1251 (Windows Cyrillic)
-```csharp
-// Russian, Serbian, Bulgarian, etc.
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.GetEncoding("cp1251")
-    }
-};
-```
-
-#### koi8-r (KOI8 Russian)
-```csharp
-// Russian (Unix standard)
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.GetEncoding("koi8-r")
-    }
-};
-```
-
-### UTF Encodings (Modern)
-
-#### UTF-8 (Default)
-```csharp
-// Modern standard - usually correct for new archives
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.UTF8
-    }
-};
-```
-
-#### UTF-16
-```csharp
-// Unicode - rarely used in archives
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.Unicode
-    }
-};
-```
-
----
-
-## Encoding Auto-Detection
-
-SharpCompress attempts to auto-detect encoding, but this isn't always reliable:
-
-```csharp
-// Auto-detection (default)
-using (var archive = ZipArchive.OpenArchive("file.zip"))  // Uses UTF8 by default
-{
-    // May show corrupted characters if archive uses different encoding
-}
-
-// Explicit encoding (more reliable)
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding { Default = Encoding.GetEncoding(932) }
-};
-using (var archive = ZipArchive.OpenArchive("file.zip", options))
-{
-    // Correct characters displayed
-}
-```
-
-### When Manual Override is Needed
-
-| Situation | Solution |
-|-----------|----------|
-| Archive shows corrupted characters | Specify the encoding explicitly |
-| Archives from specific region | Use that region's encoding |
-| Mixed encodings in archive | Use CustomDecoder |
-| Testing with international files | Try different encodings |
-
----
-
-## Custom Decoder
-
-For complex scenarios where a single encoding isn't sufficient:
-
-### Basic Custom Decoder
-
-```csharp
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding
-    {
-        CustomDecoder = (data, offset, length) =>
-        {
-            // Custom decoding logic
-            var bytes = new byte[length];
-            Array.Copy(data, offset, bytes, 0, length);
-            
-            // Try UTF8 first
-            try
-            {
-                return Encoding.UTF8.GetString(bytes);
-            }
-            catch
-            {
-                // Fallback to cp932 if UTF8 fails
-                return Encoding.GetEncoding(932).GetString(bytes);
-            }
-        }
-    }
-};
-
-using (var archive = ZipArchive.OpenArchive("mixed.zip", options))
-{
-    foreach (var entry in archive.Entries)
-    {
-        Console.WriteLine(entry.Key);  // Uses custom decoder
-    }
-}
-```
-
-### Advanced: Detect Encoding by Content
-
-```csharp
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding
-    {
-        CustomDecoder = DetectAndDecode
-    }
-};
-
-private static string DetectAndDecode(byte[] data, int offset, int length)
-{
-    var bytes = new byte[length];
-    Array.Copy(data, offset, bytes, 0, length);
-    
-    // Try UTF8 (most modern archives)
-    try
-    {
-        var str = Encoding.UTF8.GetString(bytes);
-        // Verify it decoded correctly (no replacement characters)
-        if (!str.Contains('\uFFFD'))
-            return str;
-    }
-    catch { }
-    
-    // Try cp932 (Japanese)
-    try
-    {
-        var str = Encoding.GetEncoding(932).GetString(bytes);
-        if (!str.Contains('\uFFFD'))
-            return str;
-    }
-    catch { }
-    
-    // Fallback to iso-8859-1 (always succeeds)
-    return Encoding.GetEncoding("iso-8859-1").GetString(bytes);
-}
-```
-
----
-
-## Code Examples
-
-### Extract Archive with Japanese Filenames
-
-```csharp
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.GetEncoding(932)  // cp932
-    }
-};
-
-using (var archive = ZipArchive.OpenArchive("japanese_files.zip", options))
-{
-    archive.WriteToDirectory(@"C:\output", new ExtractionOptions
-    {
-        ExtractFullPath = true,
-        Overwrite = true
-    });
-}
-// Files extracted with correct Japanese names
-```
-
-### Extract Archive with Western European Filenames
-
-```csharp
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.GetEncoding("iso-8859-1")
-    }
-};
-
-using (var archive = ZipArchive.OpenArchive("french_files.zip", options))
-{
-    archive.WriteToDirectory(@"C:\output");
-}
-// Accented characters (é, è, ê, etc.) display correctly
-```
-
-### Extract Archive with Chinese Filenames
-
-```csharp
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.GetEncoding("gbk")  // Simplified Chinese
-    }
-};
-
-using (var archive = ZipArchive.OpenArchive("chinese_files.zip", options))
-{
-    archive.WriteToDirectory(@"C:\output");
-}
-```
-
-### Extract Archive with Russian Filenames
-
-```csharp
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.GetEncoding("cp1251")  // Windows Cyrillic
-    }
-};
-
-using (var archive = ZipArchive.OpenArchive("russian_files.zip", options))
-{
-    archive.WriteToDirectory(@"C:\output");
-}
-```
-
-### Reader API with Encoding
-
-```csharp
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.GetEncoding(932)
-    }
-};
-
-using (var stream = File.OpenRead("japanese.zip"))
-using (var reader = ReaderFactory.OpenReader(stream, options))
-{
-    while (reader.MoveToNextEntry())
-    {
-        if (!reader.Entry.IsDirectory)
-        {
-            Console.WriteLine(reader.Entry.Key);  // Correct characters
-            reader.WriteEntryToDirectory(@"C:\output");
-        }
-    }
-}
-```
-
----
-
-## Creating Archives with Correct Encoding
-
-When creating archives, SharpCompress uses UTF8 by default (recommended):
-
-```csharp
-// Create with UTF8 (default, recommended)
-using (var archive = ZipArchive.CreateArchive())
-{
-    archive.AddAllFromDirectory(@"D:\my_files");
-    archive.SaveTo("output.zip", CompressionType.Deflate);
-    // Archives created with UTF8 encoding
-}
-```
-
-If you need to create archives for systems that expect specific encodings:
-
-```csharp
-// Note: SharpCompress Writer API uses UTF8 for encoding
-// To create archives with other encodings, consider:
-// 1. Let users on those systems create archives
-// 2. Use system tools (7-Zip, WinRAR) with desired encoding
-// 3. Post-process archives if absolutely necessary
-
-// For now, recommend modern UTF8-based archives
-```
-
----
-
-## Troubleshooting Encoding Issues
-
-### Filenames Show Question Marks (?)
-
-```
-✗ Wrong encoding detected
-test文件.txt → test???.txt
-```
-
-**Solution:** Specify correct encoding explicitly
-
-```csharp
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding 
-    { 
-        Default = Encoding.GetEncoding("gbk")  // Try different encodings
-    }
-};
-```
-
-### Filenames Show Replacement Character (￿)
-
-```
-✗ Invalid bytes for selected encoding
-café.txt → caf￿.txt
-```
-
-**Solution:**
-1. Try a different encoding (see Common Encodings table)
-2. Use CustomDecoder with fallback encoding
-3. Archive might be corrupted
-
-### Mixed Encodings in Single Archive
-
-```csharp
-// Use CustomDecoder to handle mixed encodings
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding
-    {
-        CustomDecoder = (data, offset, length) =>
-        {
-            // Try multiple encodings in priority order
-            var bytes = new byte[length];
-            Array.Copy(data, offset, bytes, 0, length);
-            
-            foreach (var encoding in new[] 
-            {
-                Encoding.UTF8,
-                Encoding.GetEncoding(932),
-                Encoding.GetEncoding("iso-8859-1")
-            })
-            {
-                try
-                {
-                    var str = encoding.GetString(bytes);
-                    if (!str.Contains('\uFFFD'))
-                        return str;
-                }
-                catch { }
-            }
-            
-            // Final fallback
-            return Encoding.GetEncoding("iso-8859-1").GetString(bytes);
-        }
-    }
-};
-```
-
----
-
-## Encoding Reference Table
-
-| Encoding | Code | Use Case |
-|----------|------|----------|
-| UTF-8 | (default) | Modern archives, recommended |
-| cp932 | 932 | Japanese Windows |
-| gb2312 | "gb2312" | Simplified Chinese |
-| gbk | "gbk" | Extended Simplified Chinese |
-| big5 | "big5" | Traditional Chinese |
-| iso-8859-1 | "iso-8859-1" | Western European |
-| cp1252 | "cp1252" | Windows Western European |
-| cp1251 | "cp1251" | Russian/Cyrillic |
-| euc-jp | "euc-jp" | Japanese Unix |
-| euc-kr | "euc-kr" | Korean |
-
----
-
-## Best Practices
-
-1. **Use UTF-8 for new archives** - Most modern systems support it
-2. **Ask the archive creator** - When receiving archives with corrupted names
-3. **Provide encoding options** - If your app handles user archives
-4. **Document your assumption** - Tell users what encoding you're using
-5. **Test with international files** - Before releasing production code
-
----
-
-## Related Documentation
-
-- [USAGE.md](USAGE.md#extract-zip-which-has-non-utf8-encoded-filenamycp932) - Usage examples

docs/OLD_CHANGELOG.md

@@ -1,142 +0,0 @@
-
-# Version Log
-
-* [Releases](https://github.com/adamhathcock/sharpcompress/releases)
-
-## Version 0.18
-
-* [Now on Github releases](https://github.com/adamhathcock/sharpcompress/releases/tag/0.18)
-
-## Version 0.17.1
-
-* Fix - [Bug Fix for .NET Core on Windows](https://github.com/adamhathcock/sharpcompress/pull/257)
-
-## Version 0.17.0
-
-* New - Full LZip support! Can read and write LZip files and Tars inside LZip files. [Make LZip a first class citizen. #241](https://github.com/adamhathcock/sharpcompress/issues/241)
-* New - XZ read support! Can read XZ files and Tars inside XZ files. [XZ in SharpCompress #91](https://github.com/adamhathcock/sharpcompress/issues/94)
-* Fix - [Regression - zip file writing on seekable streams always assumed stream start was 0. Introduced with Zip64 writing.](https://github.com/adamhathcock/sharpcompress/issues/244)
-* Fix - [Zip files with post-data descriptors can be properly skipped via decompression](https://github.com/adamhathcock/sharpcompress/issues/162)
-
-## Version 0.16.2
-
-* Fix [.NET 3.5 should support files and cryptography (was a regression from 0.16.0)](https://github.com/adamhathcock/sharpcompress/pull/251)
-* Fix [Zip per entry compression customization wrote the wrong method into the zip archive](https://github.com/adamhathcock/sharpcompress/pull/249)
-
-## Version 0.16.1
-
-* Fix [Preserve compression method when getting a compressed stream](https://github.com/adamhathcock/sharpcompress/pull/235)
-* Fix [RAR entry key normalization fix](https://github.com/adamhathcock/sharpcompress/issues/201)
-
-## Version 0.16.0
-
-* Breaking - [Progress Event Tracking rethink](https://github.com/adamhathcock/sharpcompress/pull/226)
-* Update to VS2017 - [VS2017](https://github.com/adamhathcock/sharpcompress/pull/231) - Framework targets have been changed.
-* New - [Add Zip64 writing](https://github.com/adamhathcock/sharpcompress/pull/211)
-* [Fix invalid/mismatching Zip version flags.](https://github.com/adamhathcock/sharpcompress/issues/164) - This allows nuget/System.IO.Packaging to read zip files generated by SharpCompress
-* [Fix 7Zip directory hiding](https://github.com/adamhathcock/sharpcompress/pull/215/files)
-* [Verify RAR CRC headers](https://github.com/adamhathcock/sharpcompress/pull/220)
-
-## Version 0.15.2
-
-* [Fix invalid headers](https://github.com/adamhathcock/sharpcompress/pull/210) - fixes an issue creating large-ish zip archives that was introduced with zip64 reading.
-
-## Version 0.15.1
-
-* [Zip64 extending information and ZipReader](https://github.com/adamhathcock/sharpcompress/pull/206)
-
-## Version 0.15.0
-
-* [Add zip64 support for ZipArchive extraction](https://github.com/adamhathcock/sharpcompress/pull/205)
-
-## Version 0.14.1
-
-* [.NET Assemblies aren't strong named](https://github.com/adamhathcock/sharpcompress/issues/158)
-* [Pkware encryption for Zip files didn't allow for multiple reads of an entry](https://github.com/adamhathcock/sharpcompress/issues/197)
-* [GZip Entry couldn't be read multiple times](https://github.com/adamhathcock/sharpcompress/issues/198)
-
-## Version 0.14.0
-
-* [Support for LZip reading in for Tars](https://github.com/adamhathcock/sharpcompress/pull/191)
-
-## Version 0.13.1
-
-* [Fix null password on ReaderFactory. Fix null options on SevenZipArchive](https://github.com/adamhathcock/sharpcompress/pull/188)
-* [Make PpmdProperties lazy to avoid unnecessary allocations.](https://github.com/adamhathcock/sharpcompress/pull/185)
-
-## Version 0.13.0
-
-* Breaking change: Big refactor of Options on API.
-* 7Zip supports Deflate
-
-## Version 0.12.4
-
-* Forward only zip issue fix https://github.com/adamhathcock/sharpcompress/issues/160
-* Try to fix frameworks again by copying targets from JSON.NET
-
-## Version 0.12.3
-
-* 7Zip fixes https://github.com/adamhathcock/sharpcompress/issues/73
-* Maybe all profiles will work with project.json now
-
-## Version 0.12.2
-
-* Support Profile 259 again
-
-## Version 0.12.1
-
-* Support Silverlight 5
-
-## Version 0.12.0
-
-* .NET Core RTM!
-* Bug fix for Tar long paths
-
-## Version 0.11.6
-
-* Bug fix for global header in Tar
-* Writers now have a leaveOpen `bool` overload. They won't close streams if not-requested to.
-
-## Version 0.11.5
-
-* Bug fix in Skip method
-
-## Version 0.11.4
-
-* SharpCompress is now endian neutral (matters for Mono platforms)
-* Fix for Inflate (need to change implementation)
-* Fixes for RAR detection
-
-## Version 0.11.1
-
-* Added Cancel on IReader
-* Removed .NET 2.0 support and LinqBridge dependency
-
-## Version 0.11
-
-* Been over a year, contains mainly fixes from contributors!
-* Possible breaking change: ArchiveEncoding is UTF8 by default now.
-* TAR supports writing long names using longlink
-* RAR Protect Header added
-
-## Version 0.10.3
-
-* Finally fixed Disposal issue when creating a new archive with the Archive API
-
-## Version 0.10.2
-
-* Fixed Rar Header reading for invalid extended time headers.
-* Windows Store assembly is now strong named
-* Known issues with Long Tar names being worked on
-* Updated to VS2013
-* Portable targets SL5 and Windows Phone 8 (up from SL4 and WP7)
-
-## Version 0.10.1
-
-* Fixed 7Zip extraction performance problem
-
-## Version 0.10:
-
-* Added support for RAR Decryption (thanks to https://github.com/hrasyid)
-* Embedded some BouncyCastle crypto classes to allow RAR Decryption and Winzip AES Decryption in Portable and Windows Store DLLs
-* Built in Release (I think)

docs/PERFORMANCE.md

@@ -1,474 +0,0 @@
-# SharpCompress Performance Guide
-
-This guide helps you optimize SharpCompress for performance in various scenarios.
-
-## API Selection Guide
-
-### Archive API vs Reader API
-
-Choose the right API based on your use case:
-
-| Aspect | Archive API | Reader API |
-|--------|------------|-----------|
-| **Stream Type** | Seekable only | Non-seekable OK |
-| **Memory Usage** | All entries in memory | One entry at a time |
-| **Random Access** | ✓ Yes | ✗ No |
-| **Best For** | Small-to-medium archives | Large or streaming data |
-| **Performance** | Fast for random access | Better for large files |
-
-### Archive API (Fast for Random Access)
-
-```csharp
-// Use when:
-// - Archive fits in memory
-// - You need random access to entries
-// - Stream is seekable (file, MemoryStream)
-
-using (var archive = ZipArchive.OpenArchive("archive.zip"))
-{
-    // Random access - all entries available
-    var specific = archive.Entries.FirstOrDefault(e => e.Key == "file.txt");
-    if (specific != null)
-    {
-        specific.WriteToFile(@"C:\output\file.txt");
-    }
-}
-```
-
-**Performance Characteristics:**
-- ✓ Instant entry lookup
-- ✓ Parallel extraction possible
-- ✗ Entire archive in memory
-- ✗ Can't process while downloading
-
-### Reader API (Best for Large Files)
-
-```csharp
-// Use when:
-// - Processing large archives (>100 MB)
-// - Streaming from network/pipe
-// - Memory is constrained
-// - Forward-only processing is acceptable
-
-using (var stream = File.OpenRead("large.zip"))
-using (var reader = ReaderFactory.OpenReader(stream))
-{
-    while (reader.MoveToNextEntry())
-    {
-        // Process one entry at a time
-        reader.WriteEntryToDirectory(@"C:\output");
-    }
-}
-```
-
-**Performance Characteristics:**
-- ✓ Minimal memory footprint
-- ✓ Works with non-seekable streams
-- ✓ Can process while downloading
-- ✗ Forward-only (no random access)
-- ✗ Entry lookup requires iteration
-
----
-
-## Buffer Sizing
-
-### Understanding Buffers
-
-SharpCompress uses internal buffers for reading compressed data. Buffer size affects:
-- **Speed:** Larger buffers = fewer I/O operations = faster
-- **Memory:** Larger buffers = higher memory usage
-
-### Recommended Buffer Sizes
-
-| Scenario | Size | Notes |
-|----------|------|-------|
-| Embedded/IoT devices | 4-8 KB | Minimal memory usage |
-| Memory-constrained | 16-32 KB | Conservative default |
-| Standard use (default) | 64 KB | Recommended default |
-| Large file streaming | 256 KB | Better throughput |
-| High-speed SSD | 512 KB - 1 MB | Maximum throughput |
-
-### How Buffer Size Affects Performance
-
-```csharp
-// SharpCompress manages buffers internally
-// You can't directly set buffer size, but you can:
-
-// 1. Use Stream.CopyTo with explicit buffer size
-using (var entryStream = reader.OpenEntryStream())
-using (var fileStream = File.Create(@"C:\output\file.txt"))
-{
-    // 64 KB buffer (default)
-    entryStream.CopyTo(fileStream);
-    
-    // Or specify larger buffer for faster copy
-    entryStream.CopyTo(fileStream, bufferSize: 262144);  // 256 KB
-}
-
-// 2. Use custom buffer for writing
-using (var entryStream = reader.OpenEntryStream())
-using (var fileStream = File.Create(@"C:\output\file.txt"))
-{
-    byte[] buffer = new byte[262144];  // 256 KB
-    int bytesRead;
-    while ((bytesRead = entryStream.Read(buffer, 0, buffer.Length)) > 0)
-    {
-        fileStream.Write(buffer, 0, bytesRead);
-    }
-}
-```
-
----
-
-## Streaming Large Files
-
-### Non-Seekable Stream Patterns
-
-For processing archives from downloads or pipes:
-
-```csharp
-// Download stream (non-seekable)
-using (var httpStream = await httpClient.GetStreamAsync(url))
-using (var reader = ReaderFactory.OpenReader(httpStream))
-{
-    // Process entries as they arrive
-    while (reader.MoveToNextEntry())
-    {
-        if (!reader.Entry.IsDirectory)
-        {
-            reader.WriteEntryToDirectory(@"C:\output");
-        }
-    }
-}
-```
-
-**Performance Tips:**
-- Don't try to buffer the entire stream
-- Process entries immediately
-- Use async APIs for better responsiveness
-
-### Download-Then-Extract vs Streaming
-
-Choose based on your constraints:
-
-| Approach | When to Use |
-|----------|------------|
-| **Download then extract** | Moderate size, need random access |
-| **Stream during download** | Large files, bandwidth limited, memory constrained |
-
-```csharp
-// Download then extract (requires disk space)
-var archivePath = await DownloadFile(url, @"C:\temp\archive.zip");
-using (var archive = ZipArchive.OpenArchive(archivePath))
-{
-    archive.WriteToDirectory(@"C:\output");
-}
-
-// Stream during download (on-the-fly extraction)
-using (var httpStream = await httpClient.GetStreamAsync(url))
-using (var reader = ReaderFactory.OpenReader(httpStream))
-{
-    while (reader.MoveToNextEntry())
-    {
-        reader.WriteEntryToDirectory(@"C:\output");
-    }
-}
-```
-
----
-
-## Solid Archive Optimization
-
-### Why Solid Archives Are Slow
-
-Solid archives (Rar, 7Zip) group files together in a single compressed stream:
-
-```
-Solid Archive Layout:
-[Header] [Compressed Stream] [Footer]
-         ├─ File1 compressed data
-         ├─ File2 compressed data
-         ├─ File3 compressed data
-         └─ File4 compressed data
-```
-
-Extracting File3 requires decompressing File1 and File2 first.
-
-### Sequential vs Random Extraction
-
-**Random Extraction (Slow):**
-```csharp
-using (var archive = RarArchive.OpenArchive("solid.rar"))
-{
-    foreach (var entry in archive.Entries)
-    {
-        entry.WriteToFile(@"C:\output\" + entry.Key);  // ✗ Slow!
-        // Each entry triggers full decompression from start
-    }
-}
-```
-
-**Sequential Extraction (Fast):**
-```csharp
-using (var archive = RarArchive.OpenArchive("solid.rar"))
-{
-    // Method 1: Use WriteToDirectory (recommended)
-    archive.WriteToDirectory(@"C:\output", new ExtractionOptions
-    {
-        ExtractFullPath = true,
-        Overwrite = true
-    });
-    
-    // Method 2: Use ExtractAllEntries
-    archive.ExtractAllEntries();
-    
-    // Method 3: Use Reader API (also sequential)
-    using (var reader = RarReader.Open(File.OpenRead("solid.rar")))
-    {
-        while (reader.MoveToNextEntry())
-        {
-            reader.WriteEntryToDirectory(@"C:\output");
-        }
-    }
-}
-```
-
-**Performance Impact:**
-- Random extraction: O(n²) - very slow for many files
-- Sequential extraction: O(n) - 10-100x faster
-
-### Best Practices for Solid Archives
-
-1. **Always extract sequentially** when possible
-2. **Use Reader API** for large solid archives
-3. **Process entries in order** from the archive
-4. **Consider using 7Zip command-line** for scripted extractions
-
----
-
-## Compression Level Trade-offs
-
-### Deflate/GZip Levels
-
-```csharp
-// Level 1 = Fastest, largest size
-// Level 6 = Default (balanced)
-// Level 9 = Slowest, best compression
-
-// Write with different compression levels
-using (var archive = ZipArchive.CreateArchive())
-{
-    archive.AddAllFromDirectory(@"D:\data");
-    
-    // Fast compression (level 1)
-    archive.SaveTo("fast.zip", new WriterOptions(CompressionType.Deflate)
-    {
-        CompressionLevel = 1
-    });
-    
-    // Default compression (level 6)
-    archive.SaveTo("default.zip", CompressionType.Deflate);
-    
-    // Best compression (level 9)
-    archive.SaveTo("best.zip", new WriterOptions(CompressionType.Deflate)
-    {
-        CompressionLevel = 9
-    });
-}
-```
-
-**Speed vs Size:**
-| Level | Speed | Size | Use Case |
-|-------|-------|------|----------|
-| 1 | 10x | 90% | Network, streaming |
-| 6 | 1x | 75% | Default (good balance) |
-| 9 | 0.1x | 65% | Archival, static storage |
-
-### BZip2 Block Size
-
-```csharp
-// BZip2 block size affects memory and compression
-// 100K to 900K (default 900K)
-
-// Smaller block size = lower memory, faster
-// Larger block size = better compression, slower
-
-using (var archive = TarArchive.CreateArchive())
-{
-    archive.AddAllFromDirectory(@"D:\data");
-    
-    // These are preset in WriterOptions via CompressionLevel
-    archive.SaveTo("archive.tar.bz2", CompressionType.BZip2);
-}
-```
-
-### LZMA Settings
-
-LZMA compression is very powerful but memory-intensive:
-
-```csharp
-// LZMA (7Zip, .tar.lzma):
-// - Dictionary size: 16 KB to 1 GB (default 32 MB)
-// - Faster preset: smaller dictionary
-// - Better compression: larger dictionary
-
-// Preset via CompressionType
-using (var archive = TarArchive.CreateArchive())
-{
-    archive.AddAllFromDirectory(@"D:\data");
-    archive.SaveTo("archive.tar.xz", CompressionType.LZMA);  // Default settings
-}
-```
-
----
-
-## Async Performance
-
-### When Async Helps
-
-Async is beneficial when:
-- **Long I/O operations** (network, slow disks)
-- **UI responsiveness** needed (Windows Forms, WPF, Blazor)
-- **Server applications** (ASP.NET, multiple concurrent operations)
-
-```csharp
-// Async extraction (non-blocking)
-using (var archive = ZipArchive.OpenArchive("archive.zip"))
-{
-    await archive.WriteToDirectoryAsync(
-        @"C:\output",
-        new ExtractionOptions { ExtractFullPath = true, Overwrite = true },
-        cancellationToken
-    );
-}
-// Thread can handle other work while I/O happens
-```
-
-### When Async Doesn't Help
-
-Async doesn't improve performance for:
-- **CPU-bound operations** (already fast)
-- **Local SSD I/O** (I/O is fast enough)
-- **Single-threaded scenarios** (no parallelism benefit)
-
-```csharp
-// Sync extraction (simpler, same performance on fast I/O)
-using (var archive = ZipArchive.OpenArchive("archive.zip"))
-{
-    archive.WriteToDirectory(
-        @"C:\output",
-        new ExtractionOptions { ExtractFullPath = true, Overwrite = true }
-    );
-}
-// Simple and fast - no async needed
-```
-
-### Cancellation Pattern
-
-```csharp
-var cts = new CancellationTokenSource();
-
-// Cancel after 5 minutes
-cts.CancelAfter(TimeSpan.FromMinutes(5));
-
-try
-{
-    using (var archive = ZipArchive.OpenArchive("archive.zip"))
-    {
-        await archive.WriteToDirectoryAsync(
-            @"C:\output",
-            new ExtractionOptions { ExtractFullPath = true, Overwrite = true },
-            cts.Token
-        );
-    }
-}
-catch (OperationCanceledException)
-{
-    Console.WriteLine("Extraction cancelled");
-    // Clean up partial extraction if needed
-}
-```
-
----
-
-## Practical Performance Tips
-
-### 1. Choose the Right API
-
-| Scenario | API | Why |
-|----------|-----|-----|
-| Small archives | Archive | Faster random access |
-| Large archives | Reader | Lower memory |
-| Streaming | Reader | Works on non-seekable streams |
-| Download streams | Reader | Async extraction while downloading |
-
-### 2. Batch Operations
-
-```csharp
-// ✗ Slow - opens each archive separately
-foreach (var file in files)
-{
-    using (var archive = ZipArchive.OpenArchive("archive.zip"))
-    {
-        archive.WriteToDirectory(@"C:\output");
-    }
-}
-
-// ✓ Better - process multiple entries at once
-using (var archive = ZipArchive.OpenArchive("archive.zip"))
-{
-    archive.WriteToDirectory(@"C:\output");
-}
-```
-
-### 3. Profile Your Code
-
-```csharp
-var sw = Stopwatch.StartNew();
-using (var archive = ZipArchive.OpenArchive("large.zip"))
-{
-    archive.WriteToDirectory(@"C:\output");
-}
-sw.Stop();
-
-Console.WriteLine($"Extraction took {sw.ElapsedMilliseconds}ms");
-
-// Measure memory before/after
-var beforeMem = GC.GetTotalMemory(true);
-// ... do work ...
-var afterMem = GC.GetTotalMemory(true);
-Console.WriteLine($"Memory used: {(afterMem - beforeMem) / 1024 / 1024}MB");
-```
-
----
-
-## Troubleshooting Performance
-
-### Extraction is Slow
-
-1. **Check if solid archive** → Use sequential extraction
-2. **Check API** → Reader API might be faster for large files
-3. **Check compression level** → Higher levels are slower to decompress
-4. **Check I/O** → Network drives are much slower than SSD
-5. **Check buffer size** → May need larger buffers for network
-
-### High Memory Usage
-
-1. **Use Reader API** instead of Archive API
-2. **Process entries immediately** rather than buffering
-3. **Reduce compression level** if writing
-4. **Check for memory leaks** in your code
-
-### CPU Usage at 100%
-
-1. **Normal for compression** - especially with high compression levels
-2. **Consider lower level** for faster processing
-3. **Reduce parallelism** if processing multiple archives
-4. **Check if awaiting properly** in async code
-
----
-
-## Related Documentation
-
-- [PERFORMANCE.md](USAGE.md) - Usage examples with performance considerations
-- [FORMATS.md](FORMATS.md) - Format-specific performance notes

global.json

@@ -1,6 +1,6 @@
 {
   "sdk": {
-    "version": "10.0.100",
+    "version": "8.0.100",
     "rollForward": "latestFeature"
   }
 }

src/SharpCompress/Algorithms/Adler32.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-#if !LEGACY_DOTNET
+#if !NETSTANDARD2_0 && !NETSTANDARD2_1 && !NETFRAMEWORK
 #define SUPPORTS_RUNTIME_INTRINSICS
 #define SUPPORTS_HOTPATH
 #endif

src/SharpCompress/Archives/AbstractArchive.Async.cs

@@ -1,103 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Archives;
-
-public abstract partial class AbstractArchive<TEntry, TVolume>
-    where TEntry : IArchiveEntry
-    where TVolume : IVolume
-{
-    #region Async Support
-
-    // Async properties
-    public virtual IAsyncEnumerable<TEntry> EntriesAsync => _lazyEntriesAsync;
-
-    public IAsyncEnumerable<TVolume> VolumesAsync => _lazyVolumesAsync;
-
-    protected virtual async IAsyncEnumerable<TEntry> LoadEntriesAsync(
-        IAsyncEnumerable<TVolume> volumes
-    )
-    {
-        foreach (var item in LoadEntries(await volumes.ToListAsync()))
-        {
-            yield return item;
-        }
-    }
-
-    public virtual async ValueTask DisposeAsync()
-    {
-        if (!_disposed)
-        {
-            await foreach (var v in _lazyVolumesAsync)
-            {
-                v.Dispose();
-            }
-            foreach (var v in _lazyEntriesAsync.GetLoaded().Cast<Entry>())
-            {
-                v.Close();
-            }
-            _sourceStream?.Dispose();
-
-            _disposed = true;
-        }
-    }
-
-    private async ValueTask EnsureEntriesLoadedAsync()
-    {
-        await _lazyEntriesAsync.EnsureFullyLoaded();
-        await _lazyVolumesAsync.EnsureFullyLoaded();
-    }
-
-    private async IAsyncEnumerable<IArchiveEntry> EntriesAsyncCast()
-    {
-        await foreach (var entry in EntriesAsync)
-        {
-            yield return entry;
-        }
-    }
-
-    IAsyncEnumerable<IArchiveEntry> IAsyncArchive.EntriesAsync => EntriesAsyncCast();
-
-    IAsyncEnumerable<IVolume> IAsyncArchive.VolumesAsync => VolumesAsyncCast();
-
-    private async IAsyncEnumerable<IVolume> VolumesAsyncCast()
-    {
-        await foreach (var volume in _lazyVolumesAsync)
-        {
-            yield return volume;
-        }
-    }
-
-    public async ValueTask<IAsyncReader> ExtractAllEntriesAsync()
-    {
-        if (!await IsSolidAsync() && Type != ArchiveType.SevenZip)
-        {
-            throw new SharpCompressException(
-                "ExtractAllEntries can only be used on solid archives or 7Zip archives (which require random access)."
-            );
-        }
-        await EnsureEntriesLoadedAsync();
-        return await CreateReaderForSolidExtractionAsync();
-    }
-
-    public virtual ValueTask<bool> IsSolidAsync() => new(false);
-
-    public async ValueTask<bool> IsCompleteAsync()
-    {
-        await EnsureEntriesLoadedAsync();
-        return await EntriesAsync.AllAsync(x => x.IsComplete);
-    }
-
-    public async ValueTask<long> TotalSizeAsync() =>
-        await EntriesAsync.AggregateAsync(0L, (total, cf) => total + cf.CompressedSize);
-
-    public async ValueTask<long> TotalUncompressedSizeAsync() =>
-        await EntriesAsync.AggregateAsync(0L, (total, cf) => total + cf.Size);
-
-    public ValueTask<bool> IsEncryptedAsync() => new(IsEncrypted);
-
-    #endregion
-}

src/SharpCompress/Archives/AbstractArchive.cs

@@ -1,13 +1,14 @@
+using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 
 namespace SharpCompress.Archives;
 
-public abstract partial class AbstractArchive<TEntry, TVolume> : IArchive, IAsyncArchive
+public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtractionListener
     where TEntry : IArchiveEntry
     where TVolume : IVolume
 {
@@ -16,10 +17,11 @@ public abstract partial class AbstractArchive<TEntry, TVolume> : IArchive, IAsyn
     private bool _disposed;
     private readonly SourceStream? _sourceStream;
 
-    // Async fields - kept in original file per refactoring rules
-    private readonly LazyAsyncReadOnlyCollection<TVolume> _lazyVolumesAsync;
-    private readonly LazyAsyncReadOnlyCollection<TEntry> _lazyEntriesAsync;
+    public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>>? EntryExtractionBegin;
+    public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>>? EntryExtractionEnd;
 
+    public event EventHandler<CompressedBytesReadEventArgs>? CompressedBytesRead;
+    public event EventHandler<FilePartExtractionBeginEventArgs>? FilePartExtractionBegin;
     protected ReaderOptions ReaderOptions { get; }
 
     internal AbstractArchive(ArchiveType type, SourceStream sourceStream)
@@ -29,12 +31,6 @@ public abstract partial class AbstractArchive<TEntry, TVolume> : IArchive, IAsyn
         _sourceStream = sourceStream;
         _lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(_sourceStream));
         _lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
-        _lazyVolumesAsync = new LazyAsyncReadOnlyCollection<TVolume>(
-            LoadVolumesAsync(_sourceStream)
-        );
-        _lazyEntriesAsync = new LazyAsyncReadOnlyCollection<TEntry>(
-            LoadEntriesAsync(_lazyVolumesAsync)
-        );
     }
 
     internal AbstractArchive(ArchiveType type)
@@ -43,16 +39,25 @@ public abstract partial class AbstractArchive<TEntry, TVolume> : IArchive, IAsyn
         ReaderOptions = new();
         _lazyVolumes = new LazyReadOnlyCollection<TVolume>(Enumerable.Empty<TVolume>());
         _lazyEntries = new LazyReadOnlyCollection<TEntry>(Enumerable.Empty<TEntry>());
-        _lazyVolumesAsync = new LazyAsyncReadOnlyCollection<TVolume>(
-            AsyncEnumerableEx.Empty<TVolume>()
-        );
-        _lazyEntriesAsync = new LazyAsyncReadOnlyCollection<TEntry>(
-            AsyncEnumerableEx.Empty<TEntry>()
-        );
     }
 
     public ArchiveType Type { get; }
 
+    void IArchiveExtractionListener.FireEntryExtractionBegin(IArchiveEntry entry) =>
+        EntryExtractionBegin?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
+
+    void IArchiveExtractionListener.FireEntryExtractionEnd(IArchiveEntry entry) =>
+        EntryExtractionEnd?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
+
+    private static Stream CheckStreams(Stream stream)
+    {
+        if (!stream.CanSeek || !stream.CanRead)
+        {
+            throw new ArchiveException("Archive streams must be Readable and Seekable");
+        }
+        return stream;
+    }
+
     /// <summary>
     /// Returns an ReadOnlyCollection of all the RarArchiveEntries across the one or many parts of the RarArchive.
     /// </summary>
@@ -72,15 +77,12 @@ public abstract partial class AbstractArchive<TEntry, TVolume> : IArchive, IAsyn
     /// <summary>
     /// The total size of the files as uncompressed in the archive.
     /// </summary>
-    public virtual long TotalUncompressedSize =>
+    public virtual long TotalUncompressSize =>
         Entries.Aggregate(0L, (total, cf) => total + cf.Size);
 
     protected abstract IEnumerable<TVolume> LoadVolumes(SourceStream sourceStream);
     protected abstract IEnumerable<TEntry> LoadEntries(IEnumerable<TVolume> volumes);
 
-    protected virtual IAsyncEnumerable<TVolume> LoadVolumesAsync(SourceStream sourceStream) =>
-        LoadVolumes(sourceStream).ToAsyncEnumerable();
-
     IEnumerable<IArchiveEntry> IArchive.Entries => Entries.Cast<IArchiveEntry>();
 
     IEnumerable<IVolume> IArchive.Volumes => _lazyVolumes.Cast<IVolume>();
@@ -97,12 +99,38 @@ public abstract partial class AbstractArchive<TEntry, TVolume> : IArchive, IAsyn
         }
     }
 
-    private void EnsureEntriesLoaded()
+    void IArchiveExtractionListener.EnsureEntriesLoaded()
     {
         _lazyEntries.EnsureFullyLoaded();
         _lazyVolumes.EnsureFullyLoaded();
     }
 
+    void IExtractionListener.FireCompressedBytesRead(
+        long currentPartCompressedBytes,
+        long compressedReadBytes
+    ) =>
+        CompressedBytesRead?.Invoke(
+            this,
+            new CompressedBytesReadEventArgs(
+                currentFilePartCompressedBytesRead: currentPartCompressedBytes,
+                compressedBytesRead: compressedReadBytes
+            )
+        );
+
+    void IExtractionListener.FireFilePartExtractionBegin(
+        string name,
+        long size,
+        long compressedSize
+    ) =>
+        FilePartExtractionBegin?.Invoke(
+            this,
+            new FilePartExtractionBeginEventArgs(
+                compressedSize: compressedSize,
+                size: size,
+                name: name
+            )
+        );
+
     /// <summary>
     /// Use this method to extract all entries in an archive in order.
     /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be
@@ -118,27 +146,21 @@ public abstract partial class AbstractArchive<TEntry, TVolume> : IArchive, IAsyn
     {
         if (!IsSolid && Type != ArchiveType.SevenZip)
         {
-            throw new SharpCompressException(
+            throw new InvalidOperationException(
                 "ExtractAllEntries can only be used on solid archives or 7Zip archives (which require random access)."
             );
         }
-        EnsureEntriesLoaded();
+        ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
         return CreateReaderForSolidExtraction();
     }
 
     protected abstract IReader CreateReaderForSolidExtraction();
-    protected abstract ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync();
 
     /// <summary>
     /// Archive is SOLID (this means the Archive saved bytes by reusing information which helps for archives containing many small files).
     /// </summary>
     public virtual bool IsSolid => false;
 
-    /// <summary>
-    /// Archive is ENCRYPTED (this means the Archive has password-protected files).
-    /// </summary>
-    public virtual bool IsEncrypted => false;
-
     /// <summary>
     /// The archive can find all the parts of the archive needed to fully extract the archive.  This forces the parsing of the entire archive.
     /// </summary>
@@ -146,7 +168,7 @@ public abstract partial class AbstractArchive<TEntry, TVolume> : IArchive, IAsyn
     {
         get
         {
-            EnsureEntriesLoaded();
+            ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
             return Entries.All(x => x.IsComplete);
         }
     }

src/SharpCompress/Archives/AbstractWritableArchive.Async.cs

@@ -1,123 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-using SharpCompress.Writers;
-
-namespace SharpCompress.Archives;
-
-public abstract partial class AbstractWritableArchive<TEntry, TVolume>
-    where TEntry : IArchiveEntry
-    where TVolume : IVolume
-{
-    // Async property moved from main file
-    private IAsyncEnumerable<TEntry> OldEntriesAsync =>
-        base.EntriesAsync.Where(x => !removedEntries.Contains(x));
-
-    private async ValueTask RebuildModifiedCollectionAsync()
-    {
-        if (pauseRebuilding)
-        {
-            return;
-        }
-        hasModifications = true;
-        newEntries.RemoveAll(v => removedEntries.Contains(v));
-        modifiedEntries.Clear();
-        await foreach (var entry in OldEntriesAsync)
-        {
-            modifiedEntries.Add(entry);
-        }
-        modifiedEntries.AddRange(newEntries);
-    }
-
-    public async ValueTask RemoveEntryAsync(TEntry entry)
-    {
-        if (!removedEntries.Contains(entry))
-        {
-            removedEntries.Add(entry);
-            await RebuildModifiedCollectionAsync();
-        }
-    }
-
-    private async ValueTask<bool> DoesKeyMatchExistingAsync(
-        string key,
-        CancellationToken cancellationToken
-    )
-    {
-        await foreach (
-            var entry in EntriesAsync.WithCancellation(cancellationToken).ConfigureAwait(false)
-        )
-        {
-            var path = entry.Key;
-            if (path is null)
-            {
-                continue;
-            }
-            var p = path.Replace('/', '\\');
-            if (p.Length > 0 && p[0] == '\\')
-            {
-                p = p.Substring(1);
-            }
-            return string.Equals(p, key, StringComparison.OrdinalIgnoreCase);
-        }
-        return false;
-    }
-
-    public async ValueTask<TEntry> AddEntryAsync(
-        string key,
-        Stream source,
-        bool closeStream,
-        long size = 0,
-        DateTime? modified = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (key.Length > 0 && key[0] is '/' or '\\')
-        {
-            key = key.Substring(1);
-        }
-        if (await DoesKeyMatchExistingAsync(key, cancellationToken).ConfigureAwait(false))
-        {
-            throw new ArchiveException("Cannot add entry with duplicate key: " + key);
-        }
-        var entry = CreateEntry(key, source, size, modified, closeStream);
-        newEntries.Add(entry);
-        await RebuildModifiedCollectionAsync();
-        return entry;
-    }
-
-    public async ValueTask<TEntry> AddDirectoryEntryAsync(
-        string key,
-        DateTime? modified = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (key.Length > 0 && key[0] is '/' or '\\')
-        {
-            key = key.Substring(1);
-        }
-        if (await DoesKeyMatchExistingAsync(key, cancellationToken).ConfigureAwait(false))
-        {
-            throw new ArchiveException("Cannot add entry with duplicate key: " + key);
-        }
-        var entry = CreateDirectoryEntry(key, modified);
-        newEntries.Add(entry);
-        await RebuildModifiedCollectionAsync();
-        return entry;
-    }
-
-    public async ValueTask SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        CancellationToken cancellationToken = default
-    )
-    {
-        //reset streams of new entries
-        newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
-        await SaveToAsync(stream, options, OldEntriesAsync, newEntries, cancellationToken)
-            .ConfigureAwait(false);
-    }
-}

src/SharpCompress/Archives/AbstractWritableArchive.cs

@@ -10,10 +10,9 @@ using SharpCompress.Writers;
 
 namespace SharpCompress.Archives;
 
-public abstract partial class AbstractWritableArchive<TEntry, TVolume>
+public abstract class AbstractWritableArchive<TEntry, TVolume>
     : AbstractArchive<TEntry, TVolume>,
-        IWritableArchive,
-        IWritableAsyncArchive
+        IWritableArchive
     where TEntry : IArchiveEntry
     where TVolume : IVolume
 {
@@ -140,24 +139,6 @@ public abstract partial class AbstractWritableArchive<TEntry, TVolume>
         return false;
     }
 
-    ValueTask IWritableAsyncArchive.RemoveEntryAsync(IArchiveEntry entry) =>
-        RemoveEntryAsync((TEntry)entry);
-
-    async ValueTask<IArchiveEntry> IWritableAsyncArchive.AddEntryAsync(
-        string key,
-        Stream source,
-        bool closeStream,
-        long size,
-        DateTime? modified,
-        CancellationToken cancellationToken
-    ) => await AddEntryAsync(key, source, closeStream, size, modified, cancellationToken);
-
-    async ValueTask<IArchiveEntry> IWritableAsyncArchive.AddDirectoryEntryAsync(
-        string key,
-        DateTime? modified,
-        CancellationToken cancellationToken
-    ) => await AddDirectoryEntryAsync(key, modified, cancellationToken);
-
     public TEntry AddDirectoryEntry(string key, DateTime? modified = null)
     {
         if (key.Length > 0 && key[0] is '/' or '\\')
@@ -181,6 +162,18 @@ public abstract partial class AbstractWritableArchive<TEntry, TVolume>
         SaveTo(stream, options, OldEntries, newEntries);
     }
 
+    public async Task SaveToAsync(
+        Stream stream,
+        WriterOptions options,
+        CancellationToken cancellationToken = default
+    )
+    {
+        //reset streams of new entries
+        newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
+        await SaveToAsync(stream, options, OldEntries, newEntries, cancellationToken)
+            .ConfigureAwait(false);
+    }
+
     protected TEntry CreateEntry(
         string key,
         Stream source,
@@ -215,10 +208,10 @@ public abstract partial class AbstractWritableArchive<TEntry, TVolume>
         IEnumerable<TEntry> newEntries
     );
 
-    protected abstract ValueTask SaveToAsync(
+    protected abstract Task SaveToAsync(
         Stream stream,
         WriterOptions options,
-        IAsyncEnumerable<TEntry> oldEntries,
+        IEnumerable<TEntry> oldEntries,
         IEnumerable<TEntry> newEntries,
         CancellationToken cancellationToken = default
     );

src/SharpCompress/Archives/ArchiveFactory.Async.cs

@@ -1,157 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-using SharpCompress.Factories;
-using SharpCompress.IO;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Archives;
-
-public static partial class ArchiveFactory
-{
-    public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        readerOptions ??= new ReaderOptions();
-        var factory = await FindFactoryAsync<IArchiveFactory>(stream, cancellationToken);
-        return factory.OpenAsyncArchive(stream, readerOptions);
-    }
-
-    public static ValueTask<IAsyncArchive> OpenAsyncArchive(
-        string filePath,
-        ReaderOptions? options = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        filePath.NotNullOrEmpty(nameof(filePath));
-        return OpenAsyncArchive(new FileInfo(filePath), options, cancellationToken);
-    }
-
-    public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
-        FileInfo fileInfo,
-        ReaderOptions? options = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        options ??= new ReaderOptions { LeaveStreamOpen = false };
-
-        var factory = await FindFactoryAsync<IArchiveFactory>(fileInfo, cancellationToken);
-        return factory.OpenAsyncArchive(fileInfo, options);
-    }
-
-    public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? options = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        fileInfos.NotNull(nameof(fileInfos));
-        var filesArray = fileInfos.ToArray();
-        if (filesArray.Length == 0)
-        {
-            throw new InvalidOperationException("No files to open");
-        }
-
-        var fileInfo = filesArray[0];
-        if (filesArray.Length == 1)
-        {
-            return await OpenAsyncArchive(fileInfo, options, cancellationToken);
-        }
-
-        fileInfo.NotNull(nameof(fileInfo));
-        options ??= new ReaderOptions { LeaveStreamOpen = false };
-
-        var factory = await FindFactoryAsync<IMultiArchiveFactory>(fileInfo, cancellationToken);
-        return factory.OpenAsyncArchive(filesArray, options, cancellationToken);
-    }
-
-    public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
-        IEnumerable<Stream> streams,
-        ReaderOptions? options = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        streams.NotNull(nameof(streams));
-        var streamsArray = streams.ToArray();
-        if (streamsArray.Length == 0)
-        {
-            throw new InvalidOperationException("No streams");
-        }
-
-        var firstStream = streamsArray[0];
-        if (streamsArray.Length == 1)
-        {
-            return await OpenAsyncArchive(firstStream, options, cancellationToken);
-        }
-
-        firstStream.NotNull(nameof(firstStream));
-        options ??= new ReaderOptions();
-
-        var factory = await FindFactoryAsync<IMultiArchiveFactory>(firstStream, cancellationToken);
-        return factory.OpenAsyncArchive(streamsArray, options);
-    }
-
-    public static ValueTask<T> FindFactoryAsync<T>(
-        string path,
-        CancellationToken cancellationToken = default
-    )
-        where T : IFactory
-    {
-        path.NotNullOrEmpty(nameof(path));
-        return FindFactoryAsync<T>(new FileInfo(path), cancellationToken);
-    }
-
-    private static async ValueTask<T> FindFactoryAsync<T>(
-        FileInfo finfo,
-        CancellationToken cancellationToken
-    )
-        where T : IFactory
-    {
-        finfo.NotNull(nameof(finfo));
-        using Stream stream = finfo.OpenRead();
-        return await FindFactoryAsync<T>(stream, cancellationToken);
-    }
-
-    private static async ValueTask<T> FindFactoryAsync<T>(
-        Stream stream,
-        CancellationToken cancellationToken
-    )
-        where T : IFactory
-    {
-        stream.NotNull(nameof(stream));
-        if (!stream.CanRead || !stream.CanSeek)
-        {
-            throw new ArgumentException("Stream should be readable and seekable");
-        }
-
-        var factories = Factory.Factories.OfType<T>();
-
-        var startPosition = stream.Position;
-
-        foreach (var factory in factories)
-        {
-            stream.Seek(startPosition, SeekOrigin.Begin);
-
-            if (await factory.IsArchiveAsync(stream, cancellationToken: cancellationToken))
-            {
-                stream.Seek(startPosition, SeekOrigin.Begin);
-
-                return factory;
-            }
-        }
-
-        var extensions = string.Join(", ", factories.Select(item => item.Name));
-
-        throw new InvalidOperationException(
-            $"Cannot determine compressed stream type. Supported Archive Formats: {extensions}"
-        );
-    }
-}

src/SharpCompress/Archives/ArchiveFactory.cs

@@ -2,8 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Factories;
 using SharpCompress.IO;
@@ -11,15 +9,22 @@ using SharpCompress.Readers;
 
 namespace SharpCompress.Archives;
 
-public static partial class ArchiveFactory
+public static class ArchiveFactory
 {
-    public static IArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null)
+    /// <summary>
+    /// Opens an Archive for random access
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    /// <returns></returns>
+    public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null)
     {
         readerOptions ??= new ReaderOptions();
-        return FindFactory<IArchiveFactory>(stream).OpenArchive(stream, readerOptions);
+        stream = SharpCompressStream.Create(stream, bufferSize: readerOptions.BufferSize);
+        return FindFactory<IArchiveFactory>(stream).Open(stream, readerOptions);
     }
 
-    public static IWritableArchive CreateArchive(ArchiveType type)
+    public static IWritableArchive Create(ArchiveType type)
     {
         var factory = Factory
             .Factories.OfType<IWriteableArchiveFactory>()
@@ -27,29 +32,41 @@ public static partial class ArchiveFactory
 
         if (factory != null)
         {
-            return factory.CreateArchive();
+            return factory.CreateWriteableArchive();
         }
 
         throw new NotSupportedException("Cannot create Archives of type: " + type);
     }
 
-    public static IArchive OpenArchive(string filePath, ReaderOptions? options = null)
+    /// <summary>
+    /// Constructor expects a filepath to an existing file.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="options"></param>
+    public static IArchive Open(string filePath, ReaderOptions? options = null)
     {
         filePath.NotNullOrEmpty(nameof(filePath));
-        return OpenArchive(new FileInfo(filePath), options);
+        return Open(new FileInfo(filePath), options);
     }
 
-    public static IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? options = null)
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="options"></param>
+    public static IArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
     {
         options ??= new ReaderOptions { LeaveStreamOpen = false };
 
-        return FindFactory<IArchiveFactory>(fileInfo).OpenArchive(fileInfo, options);
+        return FindFactory<IArchiveFactory>(fileInfo).Open(fileInfo, options);
     }
 
-    public static IArchive OpenArchive(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? options = null
-    )
+    /// <summary>
+    /// Constructor with IEnumerable FileInfo objects, multi and split support.
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="options"></param>
+    public static IArchive Open(IEnumerable<FileInfo> fileInfos, ReaderOptions? options = null)
     {
         fileInfos.NotNull(nameof(fileInfos));
         var filesArray = fileInfos.ToArray();
@@ -61,16 +78,21 @@ public static partial class ArchiveFactory
         var fileInfo = filesArray[0];
         if (filesArray.Length == 1)
         {
-            return OpenArchive(fileInfo, options);
+            return Open(fileInfo, options);
         }
 
         fileInfo.NotNull(nameof(fileInfo));
         options ??= new ReaderOptions { LeaveStreamOpen = false };
 
-        return FindFactory<IMultiArchiveFactory>(fileInfo).OpenArchive(filesArray, options);
+        return FindFactory<IMultiArchiveFactory>(fileInfo).Open(filesArray, options);
     }
 
-    public static IArchive OpenArchive(IEnumerable<Stream> streams, ReaderOptions? options = null)
+    /// <summary>
+    /// Constructor with IEnumerable FileInfo objects, multi and split support.
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="options"></param>
+    public static IArchive Open(IEnumerable<Stream> streams, ReaderOptions? options = null)
     {
         streams.NotNull(nameof(streams));
         var streamsArray = streams.ToArray();
@@ -82,34 +104,29 @@ public static partial class ArchiveFactory
         var firstStream = streamsArray[0];
         if (streamsArray.Length == 1)
         {
-            return OpenArchive(firstStream, options);
+            return Open(firstStream, options);
         }
 
         firstStream.NotNull(nameof(firstStream));
         options ??= new ReaderOptions();
 
-        return FindFactory<IMultiArchiveFactory>(firstStream).OpenArchive(streamsArray, options);
+        return FindFactory<IMultiArchiveFactory>(firstStream).Open(streamsArray, options);
     }
 
+    /// <summary>
+    /// Extract to specific directory, retaining filename
+    /// </summary>
     public static void WriteToDirectory(
         string sourceArchive,
         string destinationDirectory,
         ExtractionOptions? options = null
     )
     {
-        using var archive = OpenArchive(sourceArchive);
+        using var archive = Open(sourceArchive);
         archive.WriteToDirectory(destinationDirectory, options);
     }
 
-    public static T FindFactory<T>(string path)
-        where T : IFactory
-    {
-        path.NotNullOrEmpty(nameof(path));
-        using Stream stream = File.OpenRead(path);
-        return FindFactory<T>(stream);
-    }
-
-    public static T FindFactory<T>(FileInfo finfo)
+    private static T FindFactory<T>(FileInfo finfo)
         where T : IFactory
     {
         finfo.NotNull(nameof(finfo));
@@ -117,7 +134,7 @@ public static partial class ArchiveFactory
         return FindFactory<T>(stream);
     }
 
-    public static T FindFactory<T>(Stream stream)
+    private static T FindFactory<T>(Stream stream)
         where T : IFactory
     {
         stream.NotNull(nameof(stream));
@@ -149,14 +166,22 @@ public static partial class ArchiveFactory
         );
     }
 
-    public static bool IsArchive(string filePath, out ArchiveType? type)
+    public static bool IsArchive(
+        string filePath,
+        out ArchiveType? type,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
     {
         filePath.NotNullOrEmpty(nameof(filePath));
         using Stream s = File.OpenRead(filePath);
-        return IsArchive(s, out type);
+        return IsArchive(s, out type, bufferSize);
     }
 
-    public static bool IsArchive(Stream stream, out ArchiveType? type)
+    public static bool IsArchive(
+        Stream stream,
+        out ArchiveType? type,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
     {
         type = null;
         stream.NotNull(nameof(stream));
@@ -183,12 +208,22 @@ public static partial class ArchiveFactory
         return false;
     }
 
+    /// <summary>
+    /// From a passed in archive (zip, rar, 7z, 001), return all parts.
+    /// </summary>
+    /// <param name="part1"></param>
+    /// <returns></returns>
     public static IEnumerable<string> GetFileParts(string part1)
     {
         part1.NotNullOrEmpty(nameof(part1));
         return GetFileParts(new FileInfo(part1)).Select(a => a.FullName);
     }
 
+    /// <summary>
+    /// From a passed in archive (zip, rar, 7z, 001), return all parts.
+    /// </summary>
+    /// <param name="part1"></param>
+    /// <returns></returns>
     public static IEnumerable<FileInfo> GetFileParts(FileInfo part1)
     {
         part1.NotNull(nameof(part1));
@@ -202,7 +237,7 @@ public static partial class ArchiveFactory
             if (part != null)
             {
                 yield return part;
-                while ((part = factory.GetFilePart(i++, part1)) != null)
+                while ((part = factory.GetFilePart(i++, part1)) != null) //tests split too
                 {
                     yield return part;
                 }
@@ -211,4 +246,6 @@ public static partial class ArchiveFactory
             }
         }
     }
+
+    public static IArchiveFactory AutoFactory { get; } = new AutoArchiveFactory();
 }

src/SharpCompress/Archives/ArchiveVolumeFactory.cs

@@ -13,7 +13,6 @@ internal abstract class ArchiveVolumeFactory
         //split 001, 002 ...
         var m = Regex.Match(part1.Name, @"^(.*\.)([0-9]+)$", RegexOptions.IgnoreCase);
         if (m.Success)
-        {
             item = new FileInfo(
                 Path.Combine(
                     part1.DirectoryName!,
@@ -23,13 +22,9 @@ internal abstract class ArchiveVolumeFactory
                     )
                 )
             );
-        }
 
         if (item != null && item.Exists)
-        {
             return item;
-        }
-
         return null;
     }
 }

src/SharpCompress/Archives/AutoArchiveFactory.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using SharpCompress.Common;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives;
+
+class AutoArchiveFactory : IArchiveFactory
+{
+    public string Name => nameof(AutoArchiveFactory);
+
+    public ArchiveType? KnownArchiveType => null;
+
+    public IEnumerable<string> GetSupportedExtensions() => throw new NotSupportedException();
+
+    public bool IsArchive(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    ) => throw new NotSupportedException();
+
+    public FileInfo? GetFilePart(int index, FileInfo part1) => throw new NotSupportedException();
+
+    public IArchive Open(Stream stream, ReaderOptions? readerOptions = null) =>
+        ArchiveFactory.Open(stream, readerOptions);
+
+    public IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) =>
+        ArchiveFactory.Open(fileInfo, readerOptions);
+}

src/SharpCompress/Archives/GZip/GZipArchive.Async.cs

@@ -1,86 +0,0 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-using SharpCompress.Common.GZip;
-using SharpCompress.IO;
-using SharpCompress.Readers;
-using SharpCompress.Readers.GZip;
-using SharpCompress.Writers;
-using SharpCompress.Writers.GZip;
-
-namespace SharpCompress.Archives.GZip;
-
-public partial class GZipArchive
-{
-    public ValueTask SaveToAsync(string filePath, CancellationToken cancellationToken = default) =>
-        SaveToAsync(new FileInfo(filePath), cancellationToken);
-
-    public async ValueTask SaveToAsync(
-        FileInfo fileInfo,
-        CancellationToken cancellationToken = default
-    )
-    {
-        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
-        await SaveToAsync(stream, new WriterOptions(CompressionType.GZip), cancellationToken)
-            .ConfigureAwait(false);
-    }
-
-    protected override async ValueTask SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        IAsyncEnumerable<GZipArchiveEntry> oldEntries,
-        IEnumerable<GZipArchiveEntry> newEntries,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (Entries.Count > 1)
-        {
-            throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
-        }
-        using var writer = new GZipWriter(stream, new GZipWriterOptions(options));
-        await foreach (
-            var entry in oldEntries.WithCancellation(cancellationToken).ConfigureAwait(false)
-        )
-        {
-            if (!entry.IsDirectory)
-            {
-                using var entryStream = entry.OpenEntryStream();
-                await writer
-                    .WriteAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entryStream,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-        }
-        foreach (var entry in newEntries.Where(x => !x.IsDirectory))
-        {
-            using var entryStream = entry.OpenEntryStream();
-            await writer
-                .WriteAsync(entry.Key.NotNull("Entry Key is null"), entryStream, cancellationToken)
-                .ConfigureAwait(false);
-        }
-    }
-
-    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
-    {
-        var stream = Volumes.Single().Stream;
-        stream.Position = 0;
-        return new((IAsyncReader)GZipReader.OpenReader(stream));
-    }
-
-    protected override async IAsyncEnumerable<GZipArchiveEntry> LoadEntriesAsync(
-        IAsyncEnumerable<GZipVolume> volumes
-    )
-    {
-        var stream = (await volumes.SingleAsync()).Stream;
-        yield return new GZipArchiveEntry(
-            this,
-            await GZipFilePart.CreateAsync(stream, ReaderOptions.ArchiveEncoding)
-        );
-    }
-}

src/SharpCompress/Archives/GZip/GZipArchive.Factory.cs

@@ -1,201 +0,0 @@
-using System;
-using System.Buffers;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-using SharpCompress.Common.GZip;
-using SharpCompress.IO;
-using SharpCompress.Readers;
-using SharpCompress.Readers.GZip;
-using SharpCompress.Writers;
-using SharpCompress.Writers.GZip;
-
-namespace SharpCompress.Archives.GZip;
-
-public partial class GZipArchive
-#if NET8_0_OR_GREATER
-    : IWritableArchiveOpenable,
-        IMultiArchiveOpenable<IWritableArchive, IWritableAsyncArchive>
-#endif
-{
-    public static IWritableAsyncArchive OpenAsyncArchive(
-        string path,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        path.NotNullOrEmpty(nameof(path));
-        return (IWritableAsyncArchive)OpenArchive(
-            new FileInfo(path),
-            readerOptions ?? new ReaderOptions()
-        );
-    }
-
-    public static IWritableArchive OpenArchive(string filePath, ReaderOptions? readerOptions = null)
-    {
-        filePath.NotNullOrEmpty(nameof(filePath));
-        return OpenArchive(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
-    }
-
-    public static IWritableArchive OpenArchive(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        fileInfo.NotNull(nameof(fileInfo));
-        return new GZipArchive(
-            new SourceStream(
-                fileInfo,
-                i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    public static IWritableArchive OpenArchive(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        fileInfos.NotNull(nameof(fileInfos));
-        var files = fileInfos.ToArray();
-        return new GZipArchive(
-            new SourceStream(
-                files[0],
-                i => i < files.Length ? files[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    public static IWritableArchive OpenArchive(
-        IEnumerable<Stream> streams,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        streams.NotNull(nameof(streams));
-        var strms = streams.ToArray();
-        return new GZipArchive(
-            new SourceStream(
-                strms[0],
-                i => i < strms.Length ? strms[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    public static IWritableArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null)
-    {
-        stream.NotNull(nameof(stream));
-
-        if (stream is not { CanSeek: true })
-        {
-            throw new ArgumentException("Stream must be seekable", nameof(stream));
-        }
-
-        return new GZipArchive(
-            new SourceStream(stream, _ => null, readerOptions ?? new ReaderOptions())
-        );
-    }
-
-    public static IWritableAsyncArchive OpenAsyncArchive(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(stream, readerOptions);
-    }
-
-    public static IWritableAsyncArchive OpenAsyncArchive(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(fileInfo, readerOptions);
-    }
-
-    public static IWritableAsyncArchive OpenAsyncArchive(
-        IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(streams, readerOptions);
-    }
-
-    public static IWritableAsyncArchive OpenAsyncArchive(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(fileInfos, readerOptions);
-    }
-
-    public static IWritableArchive CreateArchive() => new GZipArchive();
-
-    public static IWritableAsyncArchive CreateAsyncArchive() => new GZipArchive();
-
-    public static bool IsGZipFile(string filePath) => IsGZipFile(new FileInfo(filePath));
-
-    public static bool IsGZipFile(FileInfo fileInfo)
-    {
-        if (!fileInfo.Exists)
-        {
-            return false;
-        }
-
-        using Stream stream = fileInfo.OpenRead();
-        return IsGZipFile(stream);
-    }
-
-    public static bool IsGZipFile(Stream stream)
-    {
-        Span<byte> header = stackalloc byte[10];
-
-        if (!stream.ReadFully(header))
-        {
-            return false;
-        }
-
-        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
-        {
-            return false;
-        }
-
-        return true;
-    }
-
-    public static async ValueTask<bool> IsGZipFileAsync(
-        Stream stream,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var header = ArrayPool<byte>.Shared.Rent(10);
-        try
-        {
-            await stream.ReadFullyAsync(header, 0, 10, cancellationToken).ConfigureAwait(false);
-
-            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
-            {
-                return false;
-            }
-
-            return true;
-        }
-        finally
-        {
-            ArrayPool<byte>.Shared.Return(header);
-        }
-    }
-}

src/SharpCompress/Archives/GZip/GZipArchive.cs

@@ -14,20 +14,122 @@ using SharpCompress.Writers.GZip;
 
 namespace SharpCompress.Archives.GZip;
 
-public partial class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
+public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
 {
+    /// <summary>
+    /// Constructor expects a filepath to an existing file.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="readerOptions"></param>
+    public static GZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+    }
+
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="readerOptions"></param>
+    public static GZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
+    {
+        fileInfo.NotNull(nameof(fileInfo));
+        return new GZipArchive(
+            new SourceStream(
+                fileInfo,
+                i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with all file parts passed in
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="readerOptions"></param>
+    public static GZipArchive Open(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        fileInfos.NotNull(nameof(fileInfos));
+        var files = fileInfos.ToArray();
+        return new GZipArchive(
+            new SourceStream(
+                files[0],
+                i => i < files.Length ? files[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with all stream parts passed in
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    public static GZipArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
+    {
+        streams.NotNull(nameof(streams));
+        var strms = streams.ToArray();
+        return new GZipArchive(
+            new SourceStream(
+                strms[0],
+                i => i < strms.Length ? strms[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Takes a seekable Stream as a source
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    public static GZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+    {
+        stream.NotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
+        return new GZipArchive(
+            new SourceStream(stream, _ => null, readerOptions ?? new ReaderOptions())
+        );
+    }
+
+    public static GZipArchive Create() => new();
+
+    /// <summary>
+    /// Constructor with a SourceStream able to handle FileInfo and Streams.
+    /// </summary>
+    /// <param name="sourceStream"></param>
     private GZipArchive(SourceStream sourceStream)
         : base(ArchiveType.GZip, sourceStream) { }
 
-    internal GZipArchive()
-        : base(ArchiveType.GZip) { }
-
     protected override IEnumerable<GZipVolume> LoadVolumes(SourceStream sourceStream)
     {
         sourceStream.LoadAllParts();
         return sourceStream.Streams.Select(a => new GZipVolume(a, ReaderOptions, 0));
     }
 
+    public static bool IsGZipFile(string filePath) => IsGZipFile(new FileInfo(filePath));
+
+    public static bool IsGZipFile(FileInfo fileInfo)
+    {
+        if (!fileInfo.Exists)
+        {
+            return false;
+        }
+
+        using Stream stream = fileInfo.OpenRead();
+        return IsGZipFile(stream);
+    }
+
     public void SaveTo(string filePath) => SaveTo(new FileInfo(filePath));
 
     public void SaveTo(FileInfo fileInfo)
@@ -36,6 +138,38 @@ public partial class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZi
         SaveTo(stream, new WriterOptions(CompressionType.GZip));
     }
 
+    public Task SaveToAsync(string filePath, CancellationToken cancellationToken = default) =>
+        SaveToAsync(new FileInfo(filePath), cancellationToken);
+
+    public async Task SaveToAsync(FileInfo fileInfo, CancellationToken cancellationToken = default)
+    {
+        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
+        await SaveToAsync(stream, new WriterOptions(CompressionType.GZip), cancellationToken)
+            .ConfigureAwait(false);
+    }
+
+    public static bool IsGZipFile(Stream stream)
+    {
+        // read the header on the first read
+        Span<byte> header = stackalloc byte[10];
+
+        // workitem 8501: handle edge case (decompress empty stream)
+        if (!stream.ReadFully(header))
+        {
+            return false;
+        }
+
+        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    internal GZipArchive()
+        : base(ArchiveType.GZip) { }
+
     protected override GZipArchiveEntry CreateEntryInternal(
         string filePath,
         Stream source,
@@ -79,12 +213,34 @@ public partial class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZi
         }
     }
 
+    protected override async Task SaveToAsync(
+        Stream stream,
+        WriterOptions options,
+        IEnumerable<GZipArchiveEntry> oldEntries,
+        IEnumerable<GZipArchiveEntry> newEntries,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (Entries.Count > 1)
+        {
+            throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
+        }
+        using var writer = new GZipWriter(stream, new GZipWriterOptions(options));
+        foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
+        {
+            using var entryStream = entry.OpenEntryStream();
+            await writer
+                .WriteAsync(entry.Key.NotNull("Entry Key is null"), entryStream, cancellationToken)
+                .ConfigureAwait(false);
+        }
+    }
+
     protected override IEnumerable<GZipArchiveEntry> LoadEntries(IEnumerable<GZipVolume> volumes)
     {
         var stream = volumes.Single().Stream;
         yield return new GZipArchiveEntry(
             this,
-            GZipFilePart.Create(stream, ReaderOptions.ArchiveEncoding)
+            new GZipFilePart(stream, ReaderOptions.ArchiveEncoding)
         );
     }
 
@@ -92,6 +248,6 @@ public partial class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZi
     {
         var stream = Volumes.Single().Stream;
         stream.Position = 0;
-        return GZipReader.OpenReader(stream);
+        return GZipReader.Open(stream);
     }
 }

src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs

@@ -23,10 +23,10 @@ public class GZipArchiveEntry : GZipEntry, IArchiveEntry
         return Parts.Single().GetCompressedStream().NotNull();
     }
 
-    public ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
+    public virtual Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
     {
         // GZip synchronous implementation is fast enough, just wrap it
-        return new(OpenEntryStream());
+        return Task.FromResult(OpenEntryStream());
     }
 
     #region IArchiveEntry Members

src/SharpCompress/Archives/GZip/GZipWritableArchiveEntry.cs

@@ -58,7 +58,7 @@ internal sealed class GZipWritableArchiveEntry : GZipArchiveEntry, IWritableArch
     {
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
-        return SharpCompressStream.CreateNonDisposing(stream);
+        return SharpCompressStream.Create(stream, leaveOpen: true);
     }
 
     internal override void Close()

src/SharpCompress/Archives/IArchive.cs

@@ -7,6 +7,12 @@ namespace SharpCompress.Archives;
 
 public interface IArchive : IDisposable
 {
+    event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionBegin;
+    event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionEnd;
+
+    event EventHandler<CompressedBytesReadEventArgs> CompressedBytesRead;
+    event EventHandler<FilePartExtractionBeginEventArgs> FilePartExtractionBegin;
+
     IEnumerable<IArchiveEntry> Entries { get; }
     IEnumerable<IVolume> Volumes { get; }
 
@@ -38,10 +44,5 @@ public interface IArchive : IDisposable
     /// <summary>
     /// The total size of the files as uncompressed in the archive.
     /// </summary>
-    long TotalUncompressedSize { get; }
-
-    /// <summary>
-    /// Returns whether the archive is encrypted.
-    /// </summary>
-    bool IsEncrypted { get; }
+    long TotalUncompressSize { get; }
 }

src/SharpCompress/Archives/IArchiveEntry.cs

@@ -17,7 +17,7 @@ public interface IArchiveEntry : IEntry
     /// Opens the current entry as a stream that will decompress as it is read asynchronously.
     /// Read the entire stream or use SkipEntry on EntryStream.
     /// </summary>
-    ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default);
+    Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default);
 
     /// <summary>
     /// The archive can find all the parts of the archive needed to extract this entry.

src/SharpCompress/Archives/IArchiveEntryExtensions.cs

@@ -1,4 +1,3 @@
-using System;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -9,161 +8,126 @@ namespace SharpCompress.Archives;
 
 public static class IArchiveEntryExtensions
 {
-    /// <param name="archiveEntry">The archive entry to extract.</param>
-    extension(IArchiveEntry archiveEntry)
+    public static void WriteTo(this IArchiveEntry archiveEntry, Stream streamToWriteTo)
     {
-        /// <summary>
-        /// Extract entry to the specified stream.
-        /// </summary>
-        /// <param name="streamToWriteTo">The stream to write the entry content to.</param>
-        /// <param name="progress">Optional progress reporter for tracking extraction progress.</param>
-        public void WriteTo(Stream streamToWriteTo, IProgress<ProgressReport>? progress = null)
+        if (archiveEntry.IsDirectory)
         {
-            if (archiveEntry.IsDirectory)
-            {
-                throw new ExtractionException("Entry is a file directory and cannot be extracted.");
-            }
-
-            using var entryStream = archiveEntry.OpenEntryStream();
-            var sourceStream = WrapWithProgress(entryStream, archiveEntry, progress);
-            sourceStream.CopyTo(streamToWriteTo, Constants.BufferSize);
+            throw new ExtractionException("Entry is a file directory and cannot be extracted.");
         }
 
-        /// <summary>
-        /// Extract entry to the specified stream asynchronously.
-        /// </summary>
-        /// <param name="streamToWriteTo">The stream to write the entry content to.</param>
-        /// <param name="cancellationToken">Cancellation token.</param>
-        /// <param name="progress">Optional progress reporter for tracking extraction progress.</param>
-        public async ValueTask WriteToAsync(
-            Stream streamToWriteTo,
-            IProgress<ProgressReport>? progress = null,
-            CancellationToken cancellationToken = default
-        )
+        var streamListener = (IArchiveExtractionListener)archiveEntry.Archive;
+        streamListener.EnsureEntriesLoaded();
+        streamListener.FireEntryExtractionBegin(archiveEntry);
+        streamListener.FireFilePartExtractionBegin(
+            archiveEntry.Key ?? "Key",
+            archiveEntry.Size,
+            archiveEntry.CompressedSize
+        );
+        var entryStream = archiveEntry.OpenEntryStream();
+        using (entryStream)
         {
-            if (archiveEntry.IsDirectory)
-            {
-                throw new ExtractionException("Entry is a file directory and cannot be extracted.");
-            }
-
-#if LEGACY_DOTNET
-            using var entryStream = await archiveEntry.OpenEntryStreamAsync(cancellationToken);
-#else
-            await using var entryStream = await archiveEntry.OpenEntryStreamAsync(
-                cancellationToken
-            );
-#endif
-            var sourceStream = WrapWithProgress(entryStream, archiveEntry, progress);
-            await sourceStream
-                .CopyToAsync(streamToWriteTo, Constants.BufferSize, cancellationToken)
-                .ConfigureAwait(false);
+            using Stream s = new ListeningStream(streamListener, entryStream);
+            s.CopyTo(streamToWriteTo);
         }
+        streamListener.FireEntryExtractionEnd(archiveEntry);
     }
 
-    private static Stream WrapWithProgress(
-        Stream source,
-        IArchiveEntry entry,
-        IProgress<ProgressReport>? progress
+    public static async Task WriteToAsync(
+        this IArchiveEntry archiveEntry,
+        Stream streamToWriteTo,
+        CancellationToken cancellationToken = default
     )
     {
-        if (progress is null)
+        if (archiveEntry.IsDirectory)
         {
-            return source;
+            throw new ExtractionException("Entry is a file directory and cannot be extracted.");
         }
 
-        var entryPath = entry.Key ?? string.Empty;
-        var totalBytes = GetEntrySizeSafe(entry);
-        return new ProgressReportingStream(
-            source,
-            progress,
-            entryPath,
-            totalBytes,
-            leaveOpen: true
+        var streamListener = (IArchiveExtractionListener)archiveEntry.Archive;
+        streamListener.EnsureEntriesLoaded();
+        streamListener.FireEntryExtractionBegin(archiveEntry);
+        streamListener.FireFilePartExtractionBegin(
+            archiveEntry.Key ?? "Key",
+            archiveEntry.Size,
+            archiveEntry.CompressedSize
         );
-    }
-
-    private static long? GetEntrySizeSafe(IArchiveEntry entry)
-    {
-        try
+        var entryStream = archiveEntry.OpenEntryStream();
+        using (entryStream)
         {
-            var size = entry.Size;
-            return size >= 0 ? size : null;
-        }
-        catch (NotImplementedException)
-        {
-            return null;
+            using Stream s = new ListeningStream(streamListener, entryStream);
+            await s.CopyToAsync(streamToWriteTo, 81920, cancellationToken).ConfigureAwait(false);
         }
+        streamListener.FireEntryExtractionEnd(archiveEntry);
     }
 
-    extension(IArchiveEntry entry)
-    {
-        /// <summary>
-        /// Extract to specific directory, retaining filename
-        /// </summary>
-        public void WriteToDirectory(
-            string destinationDirectory,
-            ExtractionOptions? options = null
-        ) =>
-            ExtractionMethods.WriteEntryToDirectory(
-                entry,
-                destinationDirectory,
-                options,
-                entry.WriteToFile
-            );
+    /// <summary>
+    /// Extract to specific directory, retaining filename
+    /// </summary>
+    public static void WriteToDirectory(
+        this IArchiveEntry entry,
+        string destinationDirectory,
+        ExtractionOptions? options = null
+    ) =>
+        ExtractionMethods.WriteEntryToDirectory(
+            entry,
+            destinationDirectory,
+            options,
+            entry.WriteToFile
+        );
 
-        /// <summary>
-        /// Extract to specific directory asynchronously, retaining filename
-        /// </summary>
-        public async ValueTask WriteToDirectoryAsync(
-            string destinationDirectory,
-            ExtractionOptions? options = null,
-            CancellationToken cancellationToken = default
-        ) =>
-            await ExtractionMethods
-                .WriteEntryToDirectoryAsync(
-                    entry,
-                    destinationDirectory,
-                    options,
-                    entry.WriteToFileAsync,
-                    cancellationToken
-                )
-                .ConfigureAwait(false);
+    /// <summary>
+    /// Extract to specific directory asynchronously, retaining filename
+    /// </summary>
+    public static Task WriteToDirectoryAsync(
+        this IArchiveEntry entry,
+        string destinationDirectory,
+        ExtractionOptions? options = null,
+        CancellationToken cancellationToken = default
+    ) =>
+        ExtractionMethods.WriteEntryToDirectoryAsync(
+            entry,
+            destinationDirectory,
+            options,
+            (x, opt) => entry.WriteToFileAsync(x, opt, cancellationToken),
+            cancellationToken
+        );
 
-        /// <summary>
-        /// Extract to specific file
-        /// </summary>
-        public void WriteToFile(string destinationFileName, ExtractionOptions? options = null) =>
-            ExtractionMethods.WriteEntryToFile(
-                entry,
-                destinationFileName,
-                options,
-                (x, fm) =>
-                {
-                    using var fs = File.Open(destinationFileName, fm);
-                    entry.WriteTo(fs);
-                }
-            );
+    /// <summary>
+    /// Extract to specific file
+    /// </summary>
+    public static void WriteToFile(
+        this IArchiveEntry entry,
+        string destinationFileName,
+        ExtractionOptions? options = null
+    ) =>
+        ExtractionMethods.WriteEntryToFile(
+            entry,
+            destinationFileName,
+            options,
+            (x, fm) =>
+            {
+                using var fs = File.Open(destinationFileName, fm);
+                entry.WriteTo(fs);
+            }
+        );
 
-        /// <summary>
-        /// Extract to specific file asynchronously
-        /// </summary>
-        public async ValueTask WriteToFileAsync(
-            string destinationFileName,
-            ExtractionOptions? options = null,
-            CancellationToken cancellationToken = default
-        ) =>
-            await ExtractionMethods
-                .WriteEntryToFileAsync(
-                    entry,
-                    destinationFileName,
-                    options,
-                    async (x, fm, ct) =>
-                    {
-                        using var fs = File.Open(destinationFileName, fm);
-                        await entry.WriteToAsync(fs, null, ct).ConfigureAwait(false);
-                    },
-                    cancellationToken
-                )
-                .ConfigureAwait(false);
-    }
+    /// <summary>
+    /// Extract to specific file asynchronously
+    /// </summary>
+    public static Task WriteToFileAsync(
+        this IArchiveEntry entry,
+        string destinationFileName,
+        ExtractionOptions? options = null,
+        CancellationToken cancellationToken = default
+    ) =>
+        ExtractionMethods.WriteEntryToFileAsync(
+            entry,
+            destinationFileName,
+            options,
+            async (x, fm) =>
+            {
+                using var fs = File.Open(destinationFileName, fm);
+                await entry.WriteToAsync(fs, cancellationToken).ConfigureAwait(false);
+            }
+        );
 }

src/SharpCompress/Archives/IArchiveExtensions.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
+using System.Threading;
 using SharpCompress.Common;
 using SharpCompress.Readers;
 
@@ -8,66 +10,76 @@ namespace SharpCompress.Archives;
 
 public static class IArchiveExtensions
 {
-    extension(IArchive archive)
+    /// <summary>
+    /// Extract to specific directory, retaining filename
+    /// </summary>
+    public static void WriteToDirectory(
+        this IArchive archive,
+        string destinationDirectory,
+        ExtractionOptions? options = null
+    )
     {
-        /// <summary>
-        /// Extract to specific directory with progress reporting
-        /// </summary>
-        /// <param name="destinationDirectory">The folder to extract into.</param>
-        /// <param name="options">Extraction options.</param>
-        /// <param name="progress">Optional progress reporter for tracking extraction progress.</param>
-        public void WriteToDirectory(
-            string destinationDirectory,
-            ExtractionOptions? options = null,
-            IProgress<ProgressReport>? progress = null
-        )
-        {
-            if (archive.IsSolid || archive.Type == ArchiveType.SevenZip)
-            {
-                using var reader = archive.ExtractAllEntries();
-                reader.WriteAllToDirectory(destinationDirectory, options);
-            }
-            else
-            {
-                archive.WriteToDirectoryInternal(destinationDirectory, options, progress);
-            }
-        }
+        using var reader = archive.ExtractAllEntries();
+        reader.WriteAllToDirectory(destinationDirectory, options);
+    }
 
-        private void WriteToDirectoryInternal(
-            string destinationDirectory,
-            ExtractionOptions? options,
-            IProgress<ProgressReport>? progress
-        )
-        {
-            var totalBytes = archive.TotalUncompressedSize;
-            var bytesRead = 0L;
-            var seenDirectories = new HashSet<string>();
+    /// <summary>
+    /// Extracts the archive to the destination directory. Directories will be created as needed.
+    /// </summary>
+    /// <param name="archive">The archive to extract.</param>
+    /// <param name="destination">The folder to extract into.</param>
+    /// <param name="progressReport">Optional progress report callback.</param>
+    /// <param name="cancellationToken">Optional cancellation token.</param>
+    public static void ExtractToDirectory(
+        this IArchive archive,
+        string destination,
+        Action<double>? progressReport = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        // Prepare for progress reporting
+        var totalBytes = archive.TotalUncompressSize;
+        var bytesRead = 0L;
 
-            foreach (var entry in archive.Entries)
+        // Tracking for created directories.
+        var seenDirectories = new HashSet<string>();
+
+        // Extract
+        foreach (var entry in archive.Entries)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (entry.IsDirectory)
             {
-                if (entry.IsDirectory)
+                var dirPath = Path.Combine(destination, entry.Key.NotNull("Entry Key is null"));
+                if (
+                    Path.GetDirectoryName(dirPath + "/") is { } emptyDirectory
+                    && seenDirectories.Add(dirPath)
+                )
                 {
-                    var dirPath = Path.Combine(
-                        destinationDirectory,
-                        entry.Key.NotNull("Entry Key is null")
-                    );
-                    if (
-                        Path.GetDirectoryName(dirPath + "/") is { } parentDirectory
-                        && seenDirectories.Add(dirPath)
-                    )
-                    {
-                        Directory.CreateDirectory(parentDirectory);
-                    }
-                    continue;
+                    Directory.CreateDirectory(emptyDirectory);
                 }
-
-                entry.WriteToDirectory(destinationDirectory, options);
-
-                bytesRead += entry.Size;
-                progress?.Report(
-                    new ProgressReport(entry.Key ?? string.Empty, bytesRead, totalBytes)
-                );
+                continue;
             }
+
+            // Create each directory if not already created
+            var path = Path.Combine(destination, entry.Key.NotNull("Entry Key is null"));
+            if (Path.GetDirectoryName(path) is { } directory)
+            {
+                if (!Directory.Exists(directory) && !seenDirectories.Contains(directory))
+                {
+                    Directory.CreateDirectory(directory);
+                    seenDirectories.Add(directory);
+                }
+            }
+
+            // Write file
+            using var fs = File.OpenWrite(path);
+            entry.WriteTo(fs);
+
+            // Update progress
+            bytesRead += entry.Size;
+            progressReport?.Invoke(bytesRead / (double)totalBytes);
         }
     }
 }

src/SharpCompress/Archives/IArchiveExtractionListener.cs

@@ -0,0 +1,10 @@
+using SharpCompress.Common;
+
+namespace SharpCompress.Archives;
+
+internal interface IArchiveExtractionListener : IExtractionListener
+{
+    void EnsureEntriesLoaded();
+    void FireEntryExtractionBegin(IArchiveEntry entry);
+    void FireEntryExtractionEnd(IArchiveEntry entry);
+}

src/SharpCompress/Archives/IArchiveFactory.cs

@@ -1,5 +1,4 @@
 using System.IO;
-using System.Threading;
 using SharpCompress.Factories;
 using SharpCompress.Readers;
 
@@ -25,27 +24,12 @@ public interface IArchiveFactory : IFactory
     /// </summary>
     /// <param name="stream">An open, readable and seekable stream.</param>
     /// <param name="readerOptions">reading options.</param>
-    IArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null);
-
-    /// <summary>
-    /// Opens an Archive for random access asynchronously.
-    /// </summary>
-    /// <param name="stream">An open, readable and seekable stream.</param>
-    /// <param name="readerOptions">reading options.</param>
-    IAsyncArchive OpenAsyncArchive(Stream stream, ReaderOptions? readerOptions = null);
+    IArchive Open(Stream stream, ReaderOptions? readerOptions = null);
 
     /// <summary>
     /// Constructor with a FileInfo object to an existing file.
     /// </summary>
     /// <param name="fileInfo">the file to open.</param>
     /// <param name="readerOptions">reading options.</param>
-    IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? readerOptions = null);
-
-    /// <summary>
-    /// Opens an Archive from a FileInfo object asynchronously.
-    /// </summary>
-    /// <param name="fileInfo">the file to open.</param>
-    /// <param name="readerOptions">reading options.</param>
-    /// <param name="cancellationToken">Cancellation token.</param>
-    IAsyncArchive OpenAsyncArchive(FileInfo fileInfo, ReaderOptions? readerOptions = null);
+    IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null);
 }

src/SharpCompress/Archives/IArchiveOpenable.cs

@@ -1,40 +0,0 @@
-#if NET8_0_OR_GREATER
-using System.IO;
-using System.Threading;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Archives;
-
-public interface IArchiveOpenable<TSync, TASync>
-    where TSync : IArchive
-    where TASync : IAsyncArchive
-{
-    public static abstract TSync OpenArchive(string filePath, ReaderOptions? readerOptions = null);
-
-    public static abstract TSync OpenArchive(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null
-    );
-
-    public static abstract TSync OpenArchive(Stream stream, ReaderOptions? readerOptions = null);
-
-    public static abstract TASync OpenAsyncArchive(
-        string path,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    );
-
-    public static abstract TASync OpenAsyncArchive(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    );
-
-    public static abstract TASync OpenAsyncArchive(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    );
-}
-
-#endif

src/SharpCompress/Archives/IAsyncArchive.cs

@@ -1,48 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Archives;
-
-public interface IAsyncArchive : IAsyncDisposable
-{
-    IAsyncEnumerable<IArchiveEntry> EntriesAsync { get; }
-    IAsyncEnumerable<IVolume> VolumesAsync { get; }
-
-    ArchiveType Type { get; }
-
-    /// <summary>
-    /// Use this method to extract all entries in an archive in order.
-    /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be
-    /// extracted sequentially for the best performance.
-    /// </summary>
-    ValueTask<IAsyncReader> ExtractAllEntriesAsync();
-
-    /// <summary>
-    /// Archive is SOLID (this means the Archive saved bytes by reusing information which helps for archives containing many small files).
-    /// Rar Archives can be SOLID while all 7Zip archives are considered SOLID.
-    /// </summary>
-    ValueTask<bool> IsSolidAsync();
-
-    /// <summary>
-    /// This checks to see if all the known entries have IsComplete = true
-    /// </summary>
-    ValueTask<bool> IsCompleteAsync();
-
-    /// <summary>
-    /// The total size of the files compressed in the archive.
-    /// </summary>
-    ValueTask<long> TotalSizeAsync();
-
-    /// <summary>
-    /// The total size of the files as uncompressed in the archive.
-    /// </summary>
-    ValueTask<long> TotalUncompressedSizeAsync();
-
-    /// <summary>
-    /// Returns whether the archive is encrypted.
-    /// </summary>
-    ValueTask<bool> IsEncryptedAsync();
-}

src/SharpCompress/Archives/IAsyncArchiveExtensions.cs

@@ -1,92 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Archives;
-
-public static class IAsyncArchiveExtensions
-{
-    extension(IAsyncArchive archive)
-    {
-        /// <summary>
-        /// Extract to specific directory asynchronously with progress reporting and cancellation support
-        /// </summary>
-        /// <param name="archive">The archive to extract.</param>
-        /// <param name="destinationDirectory">The folder to extract into.</param>
-        /// <param name="options">Extraction options.</param>
-        /// <param name="progress">Optional progress reporter for tracking extraction progress.</param>
-        /// <param name="cancellationToken">Optional cancellation token.</param>
-        public async ValueTask WriteToDirectoryAsync(
-            string destinationDirectory,
-            ExtractionOptions? options = null,
-            IProgress<ProgressReport>? progress = null,
-            CancellationToken cancellationToken = default
-        )
-        {
-            if (await archive.IsSolidAsync() || archive.Type == ArchiveType.SevenZip)
-            {
-                await using var reader = await archive.ExtractAllEntriesAsync();
-                await reader.WriteAllToDirectoryAsync(
-                    destinationDirectory,
-                    options,
-                    cancellationToken
-                );
-            }
-            else
-            {
-                await archive.WriteToDirectoryAsyncInternal(
-                    destinationDirectory,
-                    options,
-                    progress,
-                    cancellationToken
-                );
-            }
-        }
-
-        private async ValueTask WriteToDirectoryAsyncInternal(
-            string destinationDirectory,
-            ExtractionOptions? options,
-            IProgress<ProgressReport>? progress,
-            CancellationToken cancellationToken
-        )
-        {
-            var totalBytes = await archive.TotalUncompressedSizeAsync();
-            var bytesRead = 0L;
-            var seenDirectories = new HashSet<string>();
-
-            await foreach (var entry in archive.EntriesAsync.WithCancellation(cancellationToken))
-            {
-                cancellationToken.ThrowIfCancellationRequested();
-
-                if (entry.IsDirectory)
-                {
-                    var dirPath = Path.Combine(
-                        destinationDirectory,
-                        entry.Key.NotNull("Entry Key is null")
-                    );
-                    if (
-                        Path.GetDirectoryName(dirPath + "/") is { } parentDirectory
-                        && seenDirectories.Add(dirPath)
-                    )
-                    {
-                        Directory.CreateDirectory(parentDirectory);
-                    }
-                    continue;
-                }
-
-                await entry
-                    .WriteToDirectoryAsync(destinationDirectory, options, cancellationToken)
-                    .ConfigureAwait(false);
-
-                bytesRead += entry.Size;
-                progress?.Report(
-                    new ProgressReport(entry.Key ?? string.Empty, bytesRead, totalBytes)
-                );
-            }
-        }
-    }
-}

src/SharpCompress/Archives/IMultiArchiveFactory.cs

@@ -1,6 +1,5 @@
 using System.Collections.Generic;
 using System.IO;
-using System.Threading;
 using SharpCompress.Factories;
 using SharpCompress.Readers;
 
@@ -26,34 +25,12 @@ public interface IMultiArchiveFactory : IFactory
     /// </summary>
     /// <param name="streams"></param>
     /// <param name="readerOptions">reading options.</param>
-    IArchive OpenArchive(IReadOnlyList<Stream> streams, ReaderOptions? readerOptions = null);
-
-    /// <summary>
-    /// Opens a multi-part archive from streams asynchronously.
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions">reading options.</param>
-    IAsyncArchive OpenAsyncArchive(
-        IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null
-    );
+    IArchive Open(IReadOnlyList<Stream> streams, ReaderOptions? readerOptions = null);
 
     /// <summary>
     /// Constructor with IEnumerable Stream objects, multi and split support.
     /// </summary>
     /// <param name="fileInfos"></param>
     /// <param name="readerOptions">reading options.</param>
-    IArchive OpenArchive(IReadOnlyList<FileInfo> fileInfos, ReaderOptions? readerOptions = null);
-
-    /// <summary>
-    /// Opens a multi-part archive from files asynchronously.
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions">reading options.</param>
-    /// <param name="cancellationToken">Cancellation token.</param>
-    IAsyncArchive OpenAsyncArchive(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    );
+    IArchive Open(IReadOnlyList<FileInfo> fileInfos, ReaderOptions? readerOptions = null);
 }

src/SharpCompress/Archives/IMultiArchiveOpenable.cs

@@ -1,35 +0,0 @@
-#if NET8_0_OR_GREATER
-using System.Collections.Generic;
-using System.IO;
-using System.Threading;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Archives;
-
-public interface IMultiArchiveOpenable<TSync, TASync>
-    where TSync : IArchive
-    where TASync : IAsyncArchive
-{
-    public static abstract TSync OpenArchive(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null
-    );
-
-    public static abstract TSync OpenArchive(
-        IEnumerable<Stream> streams,
-        ReaderOptions? readerOptions = null
-    );
-
-    public static abstract TASync OpenAsyncArchive(
-        IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    );
-
-    public static abstract TASync OpenAsyncArchive(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    );
-}
-#endif

src/SharpCompress/Archives/IWritableArchive.cs

@@ -6,17 +6,10 @@ using SharpCompress.Writers;
 
 namespace SharpCompress.Archives;
 
-public interface IWritableArchiveCommon
+public interface IWritableArchive : IArchive
 {
-    /// <summary>
-    /// Use this to pause entry rebuilding when adding large collections of entries.  Dispose when complete.  A  using statement is recommended.
-    /// </summary>
-    /// <returns>IDisposeable to resume entry rebuilding</returns>
-    IDisposable PauseEntryRebuilding();
-}
+    void RemoveEntry(IArchiveEntry entry);
 
-public interface IWritableArchive : IArchive, IWritableArchiveCommon
-{
     IArchiveEntry AddEntry(
         string key,
         Stream source,
@@ -27,51 +20,17 @@ public interface IWritableArchive : IArchive, IWritableArchiveCommon
 
     IArchiveEntry AddDirectoryEntry(string key, DateTime? modified = null);
 
-    /// <summary>
-    /// Saves the archive to the specified stream using the given writer options.
-    /// </summary>
     void SaveTo(Stream stream, WriterOptions options);
 
-    /// <summary>
-    /// Removes the specified entry from the archive.
-    /// </summary>
-    void RemoveEntry(IArchiveEntry entry);
-}
-
-public interface IWritableAsyncArchive : IAsyncArchive, IWritableArchiveCommon
-{
-    /// <summary>
-    /// Asynchronously saves the archive to the specified stream using the given writer options.
-    /// </summary>
-    ValueTask SaveToAsync(
+    Task SaveToAsync(
         Stream stream,
         WriterOptions options,
         CancellationToken cancellationToken = default
     );
 
     /// <summary>
-    /// Asynchronously adds an entry to the archive with the specified key, source stream, and options.
+    /// Use this to pause entry rebuilding when adding large collections of entries.  Dispose when complete.  A  using statement is recommended.
     /// </summary>
-    ValueTask<IArchiveEntry> AddEntryAsync(
-        string key,
-        Stream source,
-        bool closeStream,
-        long size = 0,
-        DateTime? modified = null,
-        CancellationToken cancellationToken = default
-    );
-
-    /// <summary>
-    /// Asynchronously adds a directory entry to the archive with the specified key and modification time.
-    /// </summary>
-    ValueTask<IArchiveEntry> AddDirectoryEntryAsync(
-        string key,
-        DateTime? modified = null,
-        CancellationToken cancellationToken = default
-    );
-
-    /// <summary>
-    /// Removes the specified entry from the archive.
-    /// </summary>
-    ValueTask RemoveEntryAsync(IArchiveEntry entry);
+    /// <returns>IDisposeable to resume entry rebuilding</returns>
+    IDisposable PauseEntryRebuilding();
 }

src/SharpCompress/Archives/IWritableArchiveExtensions.cs

@@ -1,70 +1,106 @@
-using System;
+using System;
 using System.IO;
-using SharpCompress.Common;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Writers;
 
 namespace SharpCompress.Archives;
 
 public static class IWritableArchiveExtensions
 {
-    extension(IWritableArchive writableArchive)
+    public static void AddEntry(
+        this IWritableArchive writableArchive,
+        string entryPath,
+        string filePath
+    )
     {
-        public void AddAllFromDirectory(
-            string filePath,
-            string searchPattern = "*.*",
-            SearchOption searchOption = SearchOption.AllDirectories
-        )
+        var fileInfo = new FileInfo(filePath);
+        if (!fileInfo.Exists)
         {
-            using (writableArchive.PauseEntryRebuilding())
-            {
-                foreach (
-                    var path in Directory.EnumerateFiles(filePath, searchPattern, searchOption)
-                )
-                {
-                    var fileInfo = new FileInfo(path);
-                    writableArchive.AddEntry(
-                        path.Substring(filePath.Length),
-                        fileInfo.OpenRead(),
-                        true,
-                        fileInfo.Length,
-                        fileInfo.LastWriteTime
-                    );
-                }
-            }
+            throw new FileNotFoundException("Could not AddEntry: " + filePath);
         }
+        writableArchive.AddEntry(
+            entryPath,
+            new FileInfo(filePath).OpenRead(),
+            true,
+            fileInfo.Length,
+            fileInfo.LastWriteTime
+        );
+    }
 
-        public IArchiveEntry AddEntry(string key, string file) =>
-            writableArchive.AddEntry(key, new FileInfo(file));
+    public static void SaveTo(
+        this IWritableArchive writableArchive,
+        string filePath,
+        WriterOptions options
+    ) => writableArchive.SaveTo(new FileInfo(filePath), options);
 
-        public IArchiveEntry AddEntry(
-            string key,
-            Stream source,
-            long size = 0,
-            DateTime? modified = null
-        ) => writableArchive.AddEntry(key, source, false, size, modified);
+    public static void SaveTo(
+        this IWritableArchive writableArchive,
+        FileInfo fileInfo,
+        WriterOptions options
+    )
+    {
+        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
+        writableArchive.SaveTo(stream, options);
+    }
 
-        public IArchiveEntry AddEntry(string key, FileInfo fileInfo)
+    public static Task SaveToAsync(
+        this IWritableArchive writableArchive,
+        string filePath,
+        WriterOptions options,
+        CancellationToken cancellationToken = default
+    ) => writableArchive.SaveToAsync(new FileInfo(filePath), options, cancellationToken);
+
+    public static async Task SaveToAsync(
+        this IWritableArchive writableArchive,
+        FileInfo fileInfo,
+        WriterOptions options,
+        CancellationToken cancellationToken = default
+    )
+    {
+        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
+        await writableArchive.SaveToAsync(stream, options, cancellationToken).ConfigureAwait(false);
+    }
+
+    public static void AddAllFromDirectory(
+        this IWritableArchive writableArchive,
+        string filePath,
+        string searchPattern = "*.*",
+        SearchOption searchOption = SearchOption.AllDirectories
+    )
+    {
+        using (writableArchive.PauseEntryRebuilding())
         {
-            if (!fileInfo.Exists)
+            foreach (var path in Directory.EnumerateFiles(filePath, searchPattern, searchOption))
             {
-                throw new ArgumentException("FileInfo does not exist.");
+                var fileInfo = new FileInfo(path);
+                writableArchive.AddEntry(
+                    path.Substring(filePath.Length),
+                    fileInfo.OpenRead(),
+                    true,
+                    fileInfo.Length,
+                    fileInfo.LastWriteTime
+                );
             }
-            return writableArchive.AddEntry(
-                key,
-                fileInfo.OpenRead(),
-                true,
-                fileInfo.Length,
-                fileInfo.LastWriteTime
-            );
-        }
-
-        public void SaveTo(string filePath, WriterOptions? options = null) =>
-            writableArchive.SaveTo(new FileInfo(filePath), options ?? new(CompressionType.Deflate));
-
-        public void SaveTo(FileInfo fileInfo, WriterOptions? options = null)
-        {
-            using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
-            writableArchive.SaveTo(stream, options ?? new(CompressionType.Deflate));
         }
     }
+
+    public static IArchiveEntry AddEntry(
+        this IWritableArchive writableArchive,
+        string key,
+        FileInfo fileInfo
+    )
+    {
+        if (!fileInfo.Exists)
+        {
+            throw new ArgumentException("FileInfo does not exist.");
+        }
+        return writableArchive.AddEntry(
+            key,
+            fileInfo.OpenRead(),
+            true,
+            fileInfo.Length,
+            fileInfo.LastWriteTime
+        );
+    }
 }

src/SharpCompress/Archives/IWritableArchiveOpenable.cs

@@ -1,10 +0,0 @@
-#if NET8_0_OR_GREATER
-namespace SharpCompress.Archives;
-
-public interface IWritableArchiveOpenable
-    : IArchiveOpenable<IWritableArchive, IWritableAsyncArchive>
-{
-    public static abstract IWritableArchive CreateArchive();
-    public static abstract IWritableAsyncArchive CreateAsyncArchive();
-}
-#endif

src/SharpCompress/Archives/IWritableAsyncArchiveExtensions.cs

@@ -1,86 +0,0 @@
-using System;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-using SharpCompress.Writers;
-
-namespace SharpCompress.Archives;
-
-public static class IWritableAsyncArchiveExtensions
-{
-    extension(IWritableAsyncArchive writableArchive)
-    {
-        public async ValueTask AddAllFromDirectoryAsync(
-            string filePath,
-            string searchPattern = "*.*",
-            SearchOption searchOption = SearchOption.AllDirectories
-        )
-        {
-            using (writableArchive.PauseEntryRebuilding())
-            {
-                foreach (
-                    var path in Directory.EnumerateFiles(filePath, searchPattern, searchOption)
-                )
-                {
-                    var fileInfo = new FileInfo(path);
-                    await writableArchive.AddEntryAsync(
-                        path.Substring(filePath.Length),
-                        fileInfo.OpenRead(),
-                        true,
-                        fileInfo.Length,
-                        fileInfo.LastWriteTime
-                    );
-                }
-            }
-        }
-
-        public ValueTask<IArchiveEntry> AddEntryAsync(string key, string file) =>
-            writableArchive.AddEntryAsync(key, new FileInfo(file));
-
-        public ValueTask<IArchiveEntry> AddEntryAsync(
-            string key,
-            Stream source,
-            long size = 0,
-            DateTime? modified = null
-        ) => writableArchive.AddEntryAsync(key, source, false, size, modified);
-
-        public ValueTask<IArchiveEntry> AddEntryAsync(string key, FileInfo fileInfo)
-        {
-            if (!fileInfo.Exists)
-            {
-                throw new ArgumentException("FileInfo does not exist.");
-            }
-            return writableArchive.AddEntryAsync(
-                key,
-                fileInfo.OpenRead(),
-                true,
-                fileInfo.Length,
-                fileInfo.LastWriteTime
-            );
-        }
-
-        public ValueTask SaveToAsync(
-            string filePath,
-            WriterOptions? options = null,
-            CancellationToken cancellationToken = default
-        ) =>
-            writableArchive.SaveToAsync(
-                new FileInfo(filePath),
-                options ?? new(CompressionType.Deflate),
-                cancellationToken
-            );
-
-        public async ValueTask SaveToAsync(
-            FileInfo fileInfo,
-            WriterOptions? options = null,
-            CancellationToken cancellationToken = default
-        )
-        {
-            using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
-            await writableArchive
-                .SaveToAsync(stream, options ?? new(CompressionType.Deflate), cancellationToken)
-                .ConfigureAwait(false);
-        }
-    }
-}

src/SharpCompress/Archives/IWriteableArchiveFactory.cs

@@ -16,5 +16,5 @@ public interface IWriteableArchiveFactory : Factories.IFactory
     /// Creates a new, empty archive, ready to be written.
     /// </summary>
     /// <returns></returns>
-    IWritableArchive CreateArchive();
+    IWritableArchive CreateWriteableArchive();
 }

src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs

@@ -36,7 +36,4 @@ internal class FileInfoRarArchiveVolume : RarVolume
         new FileInfoRarFilePart(this, ReaderOptions.Password, markHeader, fileHeader, FileInfo);
 
     internal override IEnumerable<RarFilePart> ReadFileParts() => FileParts;
-
-    internal override IAsyncEnumerable<RarFilePart> ReadFilePartsAsync() =>
-        FileParts.ToAsyncEnumerable();
 }

src/SharpCompress/Archives/Rar/RarArchive.Async.cs

@@ -1,53 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Archives.Rar;
-using SharpCompress.Common;
-using SharpCompress.Common.Rar;
-using SharpCompress.IO;
-using SharpCompress.Readers;
-using SharpCompress.Readers.Rar;
-
-namespace SharpCompress.Archives.Rar;
-
-public partial class RarArchive
-{
-    public override async ValueTask DisposeAsync()
-    {
-        if (!_disposed)
-        {
-            if (UnpackV1.IsValueCreated && UnpackV1.Value is IDisposable unpackV1)
-            {
-                unpackV1.Dispose();
-            }
-
-            _disposed = true;
-            await base.DisposeAsync();
-        }
-    }
-
-    protected override async ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
-    {
-        if (await this.IsMultipartVolumeAsync())
-        {
-            var streams = await VolumesAsync
-                .Select(volume =>
-                {
-                    volume.Stream.Position = 0;
-                    return volume.Stream;
-                })
-                .ToListAsync();
-            return (RarReader)RarReader.OpenReader(streams, ReaderOptions);
-        }
-
-        var stream = (await VolumesAsync.FirstAsync()).Stream;
-        stream.Position = 0;
-        return (RarReader)RarReader.OpenReader(stream, ReaderOptions);
-    }
-
-    public override async ValueTask<bool> IsSolidAsync() =>
-        await (await VolumesAsync.CastAsync<RarVolume>().FirstAsync()).IsSolidArchiveAsync();
-}

src/SharpCompress/Archives/Rar/RarArchive.Extensions.cs

@@ -1,36 +1,18 @@
-using System.Linq;
-using System.Threading.Tasks;
-using SharpCompress.Common.Rar;
+using System.Linq;
 
 namespace SharpCompress.Archives.Rar;
 
 public static class RarArchiveExtensions
 {
-    extension(IRarArchive archive)
-    {
-        /// <summary>
-        /// RarArchive is the first volume of a multi-part archive.  If MultipartVolume is true and IsFirstVolume is false then the first volume file must be missing.
-        /// </summary>
-        public bool IsFirstVolume() => archive.Volumes.Cast<RarVolume>().First().IsFirstVolume;
+    /// <summary>
+    /// RarArchive is the first volume of a multi-part archive.  If MultipartVolume is true and IsFirstVolume is false then the first volume file must be missing.
+    /// </summary>
+    public static bool IsFirstVolume(this RarArchive archive) =>
+        archive.Volumes.First().IsFirstVolume;
 
-        /// <summary>
-        /// RarArchive is part of a multi-part archive.
-        /// </summary>
-        public bool IsMultipartVolume() => archive.Volumes.Cast<RarVolume>().First().IsMultiVolume;
-    }
-
-    extension(IRarAsyncArchive archive)
-    {
-        /// <summary>
-        /// RarArchive is the first volume of a multi-part archive.  If MultipartVolume is true and IsFirstVolume is false then the first volume file must be missing.
-        /// </summary>
-        public async ValueTask<bool> IsFirstVolumeAsync() =>
-            (await archive.VolumesAsync.CastAsync<RarVolume>().FirstAsync()).IsFirstVolume;
-
-        /// <summary>
-        /// RarArchive is part of a multi-part archive.
-        /// </summary>
-        public async ValueTask<bool> IsMultipartVolumeAsync() =>
-            (await archive.VolumesAsync.CastAsync<RarVolume>().FirstAsync()).IsMultiVolume;
-    }
+    /// <summary>
+    /// RarArchive is part of a multi-part archive.
+    /// </summary>
+    public static bool IsMultipartVolume(this RarArchive archive) =>
+        archive.Volumes.First().IsMultiVolume;
 }

src/SharpCompress/Archives/Rar/RarArchive.Factory.cs

@@ -1,187 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-using SharpCompress.Common.Rar;
-using SharpCompress.Common.Rar.Headers;
-using SharpCompress.Compressors.Rar;
-using SharpCompress.IO;
-using SharpCompress.Readers;
-using SharpCompress.Readers.Rar;
-
-namespace SharpCompress.Archives.Rar;
-
-public partial class RarArchive
-#if NET8_0_OR_GREATER
-    : IArchiveOpenable<IRarArchive, IRarAsyncArchive>,
-        IMultiArchiveOpenable<IRarArchive, IRarAsyncArchive>
-#endif
-{
-    public static IRarAsyncArchive OpenAsyncArchive(
-        string path,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        path.NotNullOrEmpty(nameof(path));
-        return (IRarAsyncArchive)OpenArchive(new FileInfo(path), readerOptions);
-    }
-
-    public static IRarArchive OpenArchive(string filePath, ReaderOptions? options = null)
-    {
-        filePath.NotNullOrEmpty(nameof(filePath));
-        var fileInfo = new FileInfo(filePath);
-        return new RarArchive(
-            new SourceStream(
-                fileInfo,
-                i => RarArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                options ?? new ReaderOptions()
-            )
-        );
-    }
-
-    public static IRarArchive OpenArchive(FileInfo fileInfo, ReaderOptions? options = null)
-    {
-        fileInfo.NotNull(nameof(fileInfo));
-        return new RarArchive(
-            new SourceStream(
-                fileInfo,
-                i => RarArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                options ?? new ReaderOptions()
-            )
-        );
-    }
-
-    public static IRarArchive OpenArchive(Stream stream, ReaderOptions? options = null)
-    {
-        stream.NotNull(nameof(stream));
-
-        if (stream is not { CanSeek: true })
-        {
-            throw new ArgumentException("Stream must be seekable", nameof(stream));
-        }
-
-        return new RarArchive(new SourceStream(stream, _ => null, options ?? new ReaderOptions()));
-    }
-
-    public static IRarArchive OpenArchive(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        fileInfos.NotNull(nameof(fileInfos));
-        var files = fileInfos.ToArray();
-        return new RarArchive(
-            new SourceStream(
-                files[0],
-                i => i < files.Length ? files[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    public static IRarArchive OpenArchive(
-        IEnumerable<Stream> streams,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        streams.NotNull(nameof(streams));
-        var strms = streams.ToArray();
-        return new RarArchive(
-            new SourceStream(
-                strms[0],
-                i => i < strms.Length ? strms[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    public static IRarAsyncArchive OpenAsyncArchive(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IRarAsyncArchive)OpenArchive(stream, readerOptions);
-    }
-
-    public static IRarAsyncArchive OpenAsyncArchive(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IRarAsyncArchive)OpenArchive(fileInfo, readerOptions);
-    }
-
-    public static IRarAsyncArchive OpenAsyncArchive(
-        IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IRarAsyncArchive)OpenArchive(streams, readerOptions);
-    }
-
-    public static IRarAsyncArchive OpenAsyncArchive(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IRarAsyncArchive)OpenArchive(fileInfos, readerOptions);
-    }
-
-    public static bool IsRarFile(string filePath) => IsRarFile(new FileInfo(filePath));
-
-    public static bool IsRarFile(FileInfo fileInfo)
-    {
-        if (!fileInfo.Exists)
-        {
-            return false;
-        }
-        using Stream stream = fileInfo.OpenRead();
-        return IsRarFile(stream);
-    }
-
-    public static bool IsRarFile(Stream stream, ReaderOptions? options = null)
-    {
-        try
-        {
-            MarkHeader.Read(stream, true, false);
-            return true;
-        }
-        catch
-        {
-            return false;
-        }
-    }
-
-    public static async ValueTask<bool> IsRarFileAsync(
-        Stream stream,
-        ReaderOptions? options = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        try
-        {
-            await MarkHeader
-                .ReadAsync(stream, true, false, cancellationToken)
-                .ConfigureAwait(false);
-            return true;
-        }
-        catch
-        {
-            return false;
-        }
-    }
-}

src/SharpCompress/Archives/Rar/RarArchive.cs

@@ -2,8 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
@@ -14,26 +12,17 @@ using SharpCompress.Readers.Rar;
 
 namespace SharpCompress.Archives.Rar;
 
-public interface IRarArchiveCommon
-{
-    int MinVersion { get; }
-    int MaxVersion { get; }
-}
-
-public interface IRarArchive : IArchive, IRarArchiveCommon { }
-
-public interface IRarAsyncArchive : IAsyncArchive, IRarArchiveCommon { }
-
-public partial class RarArchive
-    : AbstractArchive<RarArchiveEntry, RarVolume>,
-        IRarArchive,
-        IRarAsyncArchive
+public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
 {
     private bool _disposed;
     internal Lazy<IRarUnpack> UnpackV2017 { get; } =
         new(() => new Compressors.Rar.UnpackV2017.Unpack());
     internal Lazy<IRarUnpack> UnpackV1 { get; } = new(() => new Compressors.Rar.UnpackV1.Unpack());
 
+    /// <summary>
+    /// Constructor with a SourceStream able to handle FileInfo and Streams.
+    /// </summary>
+    /// <param name="sourceStream"></param>
     private RarArchive(SourceStream sourceStream)
         : base(ArchiveType.Rar, sourceStream) { }
 
@@ -54,17 +43,12 @@ public partial class RarArchive
     protected override IEnumerable<RarArchiveEntry> LoadEntries(IEnumerable<RarVolume> volumes) =>
         RarArchiveEntryFactory.GetEntries(this, volumes, ReaderOptions);
 
-    // Simple async property - kept in original file
-    protected override IAsyncEnumerable<RarArchiveEntry> LoadEntriesAsync(
-        IAsyncEnumerable<RarVolume> volumes
-    ) => RarArchiveEntryFactory.GetEntriesAsync(this, volumes, ReaderOptions);
-
     protected override IEnumerable<RarVolume> LoadVolumes(SourceStream sourceStream)
     {
-        sourceStream.LoadAllParts();
+        sourceStream.LoadAllParts(); //request all streams
         var streams = sourceStream.Streams.ToArray();
         var i = 0;
-        if (streams.Length > 1 && IsRarFile(streams[1], ReaderOptions))
+        if (streams.Length > 1 && IsRarFile(streams[1], ReaderOptions)) //test part 2 - true = multipart not split
         {
             sourceStream.IsVolumes = true;
             streams[1].Position = 0;
@@ -77,6 +61,7 @@ public partial class RarArchive
             ));
         }
 
+        //split mode or single file
         return new StreamRarArchiveVolume(sourceStream, ReaderOptions, i++).AsEnumerable();
     }
 
@@ -89,19 +74,135 @@ public partial class RarArchive
                 volume.Stream.Position = 0;
                 return volume.Stream;
             });
-            return (RarReader)RarReader.OpenReader(streams, ReaderOptions);
+            return RarReader.Open(streams, ReaderOptions);
         }
 
         var stream = Volumes.First().Stream;
         stream.Position = 0;
-        return (RarReader)RarReader.OpenReader(stream, ReaderOptions);
+        return RarReader.Open(stream, ReaderOptions);
     }
 
     public override bool IsSolid => Volumes.First().IsSolidArchive;
 
-    public override bool IsEncrypted => Entries.First(x => !x.IsDirectory).IsEncrypted;
-
     public virtual int MinVersion => Volumes.First().MinVersion;
-
     public virtual int MaxVersion => Volumes.First().MaxVersion;
+
+    #region Creation
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="options"></param>
+    public static RarArchive Open(string filePath, ReaderOptions? options = null)
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        var fileInfo = new FileInfo(filePath);
+        return new RarArchive(
+            new SourceStream(
+                fileInfo,
+                i => RarArchiveVolumeFactory.GetFilePart(i, fileInfo),
+                options ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="options"></param>
+    public static RarArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
+    {
+        fileInfo.NotNull(nameof(fileInfo));
+        return new RarArchive(
+            new SourceStream(
+                fileInfo,
+                i => RarArchiveVolumeFactory.GetFilePart(i, fileInfo),
+                options ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Takes a seekable Stream as a source
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="options"></param>
+    public static RarArchive Open(Stream stream, ReaderOptions? options = null)
+    {
+        stream.NotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
+        return new RarArchive(new SourceStream(stream, _ => null, options ?? new ReaderOptions()));
+    }
+
+    /// <summary>
+    /// Constructor with all file parts passed in
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="readerOptions"></param>
+    public static RarArchive Open(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        fileInfos.NotNull(nameof(fileInfos));
+        var files = fileInfos.ToArray();
+        return new RarArchive(
+            new SourceStream(
+                files[0],
+                i => i < files.Length ? files[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with all stream parts passed in
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    public static RarArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
+    {
+        streams.NotNull(nameof(streams));
+        var strms = streams.ToArray();
+        return new RarArchive(
+            new SourceStream(
+                strms[0],
+                i => i < strms.Length ? strms[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    public static bool IsRarFile(string filePath) => IsRarFile(new FileInfo(filePath));
+
+    public static bool IsRarFile(FileInfo fileInfo)
+    {
+        if (!fileInfo.Exists)
+        {
+            return false;
+        }
+        using Stream stream = fileInfo.OpenRead();
+        return IsRarFile(stream);
+    }
+
+    public static bool IsRarFile(Stream stream, ReaderOptions? options = null)
+    {
+        try
+        {
+            MarkHeader.Read(stream, true, false);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    #endregion
 }

src/SharpCompress/Archives/Rar/RarArchiveEntry.Async.cs

@@ -1,43 +0,0 @@
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-using SharpCompress.Common.Rar;
-using SharpCompress.Common.Rar.Headers;
-using SharpCompress.Compressors.Rar;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Archives.Rar;
-
-public partial class RarArchiveEntry
-{
-    public async ValueTask<Stream> OpenEntryStreamAsync(
-        CancellationToken cancellationToken = default
-    )
-    {
-        RarStream stream;
-        if (IsRarV3)
-        {
-            stream = new RarStream(
-                archive.UnpackV1.Value,
-                FileHeader,
-                await MultiVolumeReadOnlyAsyncStream.Create(
-                    Parts.ToAsyncEnumerable().CastAsync<RarFilePart>()
-                )
-            );
-        }
-        else
-        {
-            stream = new RarStream(
-                archive.UnpackV2017.Value,
-                FileHeader,
-                await MultiVolumeReadOnlyAsyncStream.Create(
-                    Parts.ToAsyncEnumerable().CastAsync<RarFilePart>()
-                )
-            );
-        }
-
-        await stream.InitializeAsync(cancellationToken);
-        return stream;
-    }
-}

src/SharpCompress/Archives/Rar/RarArchiveEntry.cs

@@ -12,7 +12,7 @@ using SharpCompress.Readers;
 
 namespace SharpCompress.Archives.Rar;
 
-public partial class RarArchiveEntry : RarEntry, IArchiveEntry
+public class RarArchiveEntry : RarEntry, IArchiveEntry
 {
     private readonly ICollection<RarFilePart> parts;
     private readonly RarArchive archive;
@@ -76,7 +76,7 @@ public partial class RarArchiveEntry : RarEntry, IArchiveEntry
             stream = new RarStream(
                 archive.UnpackV1.Value,
                 FileHeader,
-                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>())
+                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
             );
         }
         else
@@ -84,7 +84,7 @@ public partial class RarArchiveEntry : RarEntry, IArchiveEntry
             stream = new RarStream(
                 archive.UnpackV2017.Value,
                 FileHeader,
-                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>())
+                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
             );
         }
 
@@ -92,6 +92,30 @@ public partial class RarArchiveEntry : RarEntry, IArchiveEntry
         return stream;
     }
 
+    public async Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
+    {
+        RarStream stream;
+        if (IsRarV3)
+        {
+            stream = new RarStream(
+                archive.UnpackV1.Value,
+                FileHeader,
+                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
+            );
+        }
+        else
+        {
+            stream = new RarStream(
+                archive.UnpackV2017.Value,
+                FileHeader,
+                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
+            );
+        }
+
+        await stream.InitializeAsync(cancellationToken);
+        return stream;
+    }
+
     public bool IsComplete
     {
         get

src/SharpCompress/Archives/Rar/RarArchiveEntryFactory.cs

@@ -17,19 +17,6 @@ internal static class RarArchiveEntryFactory
         }
     }
 
-    private static async IAsyncEnumerable<RarFilePart> GetFilePartsAsync(
-        IAsyncEnumerable<RarVolume> parts
-    )
-    {
-        await foreach (var rarPart in parts)
-        {
-            await foreach (var fp in rarPart.ReadFilePartsAsync())
-            {
-                yield return fp;
-            }
-        }
-    }
-
     private static IEnumerable<IEnumerable<RarFilePart>> GetMatchedFileParts(
         IEnumerable<RarVolume> parts
     )
@@ -51,27 +38,6 @@ internal static class RarArchiveEntryFactory
         }
     }
 
-    private static async IAsyncEnumerable<IEnumerable<RarFilePart>> GetMatchedFilePartsAsync(
-        IAsyncEnumerable<RarVolume> parts
-    )
-    {
-        var groupedParts = new List<RarFilePart>();
-        await foreach (var fp in GetFilePartsAsync(parts))
-        {
-            groupedParts.Add(fp);
-
-            if (!fp.FileHeader.IsSplitAfter)
-            {
-                yield return groupedParts;
-                groupedParts = new List<RarFilePart>();
-            }
-        }
-        if (groupedParts.Count > 0)
-        {
-            yield return groupedParts;
-        }
-    }
-
     internal static IEnumerable<RarArchiveEntry> GetEntries(
         RarArchive archive,
         IEnumerable<RarVolume> rarParts,
@@ -83,16 +49,4 @@ internal static class RarArchiveEntryFactory
             yield return new RarArchiveEntry(archive, groupedParts, readerOptions);
         }
     }
-
-    internal static async IAsyncEnumerable<RarArchiveEntry> GetEntriesAsync(
-        RarArchive archive,
-        IAsyncEnumerable<RarVolume> rarParts,
-        ReaderOptions readerOptions
-    )
-    {
-        await foreach (var groupedParts in GetMatchedFilePartsAsync(rarParts))
-        {
-            yield return new RarArchiveEntry(archive, groupedParts, readerOptions);
-        }
-    }
 }

src/SharpCompress/Archives/Rar/RarArchiveVolumeFactory.cs

@@ -13,7 +13,6 @@ internal static class RarArchiveVolumeFactory
         //new style rar - ..part1 | /part01 | part001 ....
         var m = Regex.Match(part1.Name, @"^(.*\.part)([0-9]+)(\.rar)$", RegexOptions.IgnoreCase);
         if (m.Success)
-        {
             item = new FileInfo(
                 Path.Combine(
                     part1.DirectoryName!,
@@ -24,13 +23,11 @@ internal static class RarArchiveVolumeFactory
                     )
                 )
             );
-        }
         else
         {
             //old style - ...rar, .r00, .r01 ...
             m = Regex.Match(part1.Name, @"^(.*\.)([r-z{])(ar|[0-9]+)$", RegexOptions.IgnoreCase);
             if (m.Success)
-            {
                 item = new FileInfo(
                     Path.Combine(
                         part1.DirectoryName!,
@@ -43,17 +40,12 @@ internal static class RarArchiveVolumeFactory
                         )
                     )
                 );
-            }
             else //split .001, .002 ....
-            {
                 return ArchiveVolumeFactory.GetFilePart(index, part1);
-            }
         }
 
         if (item != null && item.Exists)
-        {
             return item;
-        }
 
         return null; //no more items
     }

src/SharpCompress/Archives/Rar/StreamRarArchiveVolume.cs

@@ -14,9 +14,6 @@ internal class StreamRarArchiveVolume : RarVolume
 
     internal override IEnumerable<RarFilePart> ReadFileParts() => GetVolumeFileParts();
 
-    internal override IAsyncEnumerable<RarFilePart> ReadFilePartsAsync() =>
-        GetVolumeFilePartsAsync();
-
     internal override RarFilePart CreateFilePart(MarkHeader markHeader, FileHeader fileHeader) =>
         new SeekableFilePart(markHeader, fileHeader, Index, Stream, ReaderOptions.Password);
 }

src/SharpCompress/Archives/SevenZip/SevenZipArchive.Async.cs

@@ -1,73 +0,0 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-using SharpCompress.Common.SevenZip;
-using SharpCompress.IO;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Archives.SevenZip;
-
-public partial class SevenZipArchive
-{
-    private async ValueTask LoadFactoryAsync(
-        Stream stream,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (_database is null)
-        {
-            stream.Position = 0;
-            var reader = new ArchiveReader();
-            await reader.OpenAsync(
-                stream,
-                lookForHeader: ReaderOptions.LookForHeader,
-                cancellationToken
-            );
-            _database = await reader.ReadDatabaseAsync(
-                new PasswordProvider(ReaderOptions.Password),
-                cancellationToken
-            );
-        }
-    }
-
-    protected override async IAsyncEnumerable<SevenZipArchiveEntry> LoadEntriesAsync(
-        IAsyncEnumerable<SevenZipVolume> volumes
-    )
-    {
-        var stream = (await volumes.SingleAsync()).Stream;
-        await LoadFactoryAsync(stream);
-        if (_database is null)
-        {
-            yield break;
-        }
-        var entries = new SevenZipArchiveEntry[_database._files.Count];
-        for (var i = 0; i < _database._files.Count; i++)
-        {
-            var file = _database._files[i];
-            entries[i] = new SevenZipArchiveEntry(
-                this,
-                new SevenZipFilePart(stream, _database, i, file, ReaderOptions.ArchiveEncoding)
-            );
-        }
-        foreach (var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder))
-        {
-            var isSolid = false;
-            foreach (var entry in group)
-            {
-                entry.IsSolid = isSolid;
-                isSolid = true;
-            }
-        }
-
-        foreach (var entry in entries)
-        {
-            yield return entry;
-        }
-    }
-
-    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync() =>
-        new(new SevenZipReader(ReaderOptions, this));
-}

src/SharpCompress/Archives/SevenZip/SevenZipArchive.Factory.cs

@@ -1,210 +0,0 @@
-using System;
-using System.Buffers;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.IO;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Archives.SevenZip;
-
-public partial class SevenZipArchive
-#if NET8_0_OR_GREATER
-    : IArchiveOpenable<IArchive, IAsyncArchive>,
-        IMultiArchiveOpenable<IArchive, IAsyncArchive>
-#endif
-{
-    public static IAsyncArchive OpenAsyncArchive(
-        string path,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        path.NotNullOrEmpty("path");
-        return (IAsyncArchive)OpenArchive(new FileInfo(path), readerOptions ?? new ReaderOptions());
-    }
-
-    public static IArchive OpenArchive(string filePath, ReaderOptions? readerOptions = null)
-    {
-        filePath.NotNullOrEmpty("filePath");
-        return OpenArchive(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
-    }
-
-    public static IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? readerOptions = null)
-    {
-        fileInfo.NotNull("fileInfo");
-        return new SevenZipArchive(
-            new SourceStream(
-                fileInfo,
-                i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    public static IArchive OpenArchive(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        fileInfos.NotNull(nameof(fileInfos));
-        var files = fileInfos.ToArray();
-        return new SevenZipArchive(
-            new SourceStream(
-                files[0],
-                i => i < files.Length ? files[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    public static IArchive OpenArchive(
-        IEnumerable<Stream> streams,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        streams.NotNull(nameof(streams));
-        var strms = streams.ToArray();
-        return new SevenZipArchive(
-            new SourceStream(
-                strms[0],
-                i => i < strms.Length ? strms[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    public static IArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null)
-    {
-        stream.NotNull("stream");
-
-        if (stream is not { CanSeek: true })
-        {
-            throw new ArgumentException("Stream must be seekable", nameof(stream));
-        }
-
-        return new SevenZipArchive(
-            new SourceStream(stream, _ => null, readerOptions ?? new ReaderOptions())
-        );
-    }
-
-    public static IAsyncArchive OpenAsyncArchive(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IAsyncArchive)OpenArchive(stream, readerOptions);
-    }
-
-    public static IAsyncArchive OpenAsyncArchive(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IAsyncArchive)OpenArchive(fileInfo, readerOptions);
-    }
-
-    public static IAsyncArchive OpenAsyncArchive(
-        IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IAsyncArchive)OpenArchive(streams, readerOptions);
-    }
-
-    public static IAsyncArchive OpenAsyncArchive(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IAsyncArchive)OpenArchive(fileInfos, readerOptions);
-    }
-
-    public static bool IsSevenZipFile(string filePath) => IsSevenZipFile(new FileInfo(filePath));
-
-    public static bool IsSevenZipFile(FileInfo fileInfo)
-    {
-        if (!fileInfo.Exists)
-        {
-            return false;
-        }
-        using Stream stream = fileInfo.OpenRead();
-        return IsSevenZipFile(stream);
-    }
-
-    public static bool IsSevenZipFile(Stream stream)
-    {
-        try
-        {
-            return SignatureMatch(stream);
-        }
-        catch
-        {
-            return false;
-        }
-    }
-
-    public static async ValueTask<bool> IsSevenZipFileAsync(
-        Stream stream,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        try
-        {
-            return await SignatureMatchAsync(stream, cancellationToken);
-        }
-        catch
-        {
-            return false;
-        }
-    }
-
-    private static ReadOnlySpan<byte> Signature => [(byte)'7', (byte)'z', 0xBC, 0xAF, 0x27, 0x1C];
-
-    private static bool SignatureMatch(Stream stream)
-    {
-        var buffer = ArrayPool<byte>.Shared.Rent(6);
-        try
-        {
-            stream.ReadExact(buffer, 0, 6);
-            return buffer.AsSpan().Slice(0, 6).SequenceEqual(Signature);
-        }
-        finally
-        {
-            ArrayPool<byte>.Shared.Return(buffer);
-        }
-    }
-
-    private static async ValueTask<bool> SignatureMatchAsync(
-        Stream stream,
-        CancellationToken cancellationToken
-    )
-    {
-        var buffer = ArrayPool<byte>.Shared.Rent(6);
-        try
-        {
-            if (!await stream.ReadFullyAsync(buffer, 0, 6, cancellationToken).ConfigureAwait(false))
-            {
-                return false;
-            }
-
-            return buffer.AsSpan().Slice(0, 6).SequenceEqual(Signature);
-        }
-        finally
-        {
-            ArrayPool<byte>.Shared.Return(buffer);
-        }
-    }
-}

src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs

@@ -2,8 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.SevenZip;
 using SharpCompress.Compressors.LZMA.Utilites;
@@ -12,10 +10,99 @@ using SharpCompress.Readers;
 
 namespace SharpCompress.Archives.SevenZip;
 
-public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVolume>
+public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVolume>
 {
     private ArchiveDatabase? _database;
 
+    /// <summary>
+    /// Constructor expects a filepath to an existing file.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="readerOptions"></param>
+    public static SevenZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
+    {
+        filePath.NotNullOrEmpty("filePath");
+        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+    }
+
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="readerOptions"></param>
+    public static SevenZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
+    {
+        fileInfo.NotNull("fileInfo");
+        return new SevenZipArchive(
+            new SourceStream(
+                fileInfo,
+                i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with all file parts passed in
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="readerOptions"></param>
+    public static SevenZipArchive Open(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        fileInfos.NotNull(nameof(fileInfos));
+        var files = fileInfos.ToArray();
+        return new SevenZipArchive(
+            new SourceStream(
+                files[0],
+                i => i < files.Length ? files[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with all stream parts passed in
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    public static SevenZipArchive Open(
+        IEnumerable<Stream> streams,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        streams.NotNull(nameof(streams));
+        var strms = streams.ToArray();
+        return new SevenZipArchive(
+            new SourceStream(
+                strms[0],
+                i => i < strms.Length ? strms[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Takes a seekable Stream as a source
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    public static SevenZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+    {
+        stream.NotNull("stream");
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
+        return new SevenZipArchive(
+            new SourceStream(stream, _ => null, readerOptions ?? new ReaderOptions())
+        );
+    }
+
     /// <summary>
     /// Constructor with a SourceStream able to handle FileInfo and Streams.
     /// </summary>
@@ -29,6 +116,18 @@ public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, Sev
         return new SevenZipVolume(sourceStream, ReaderOptions, 0).AsEnumerable(); //simple single volume or split, multivolume not supported
     }
 
+    public static bool IsSevenZipFile(string filePath) => IsSevenZipFile(new FileInfo(filePath));
+
+    public static bool IsSevenZipFile(FileInfo fileInfo)
+    {
+        if (!fileInfo.Exists)
+        {
+            return false;
+        }
+        using Stream stream = fileInfo.OpenRead();
+        return IsSevenZipFile(stream);
+    }
+
     internal SevenZipArchive()
         : base(ArchiveType.SevenZip) { }
 
@@ -36,45 +135,32 @@ public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, Sev
         IEnumerable<SevenZipVolume> volumes
     )
     {
-        foreach (var volume in volumes)
+        var stream = volumes.Single().Stream;
+        LoadFactory(stream);
+        if (_database is null)
         {
-            LoadFactory(volume.Stream);
-            if (_database is null)
+            return Enumerable.Empty<SevenZipArchiveEntry>();
+        }
+        var entries = new SevenZipArchiveEntry[_database._files.Count];
+        for (var i = 0; i < _database._files.Count; i++)
+        {
+            var file = _database._files[i];
+            entries[i] = new SevenZipArchiveEntry(
+                this,
+                new SevenZipFilePart(stream, _database, i, file, ReaderOptions.ArchiveEncoding)
+            );
+        }
+        foreach (var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder))
+        {
+            var isSolid = false;
+            foreach (var entry in group)
             {
-                yield break;
-            }
-            var entries = new SevenZipArchiveEntry[_database._files.Count];
-            for (var i = 0; i < _database._files.Count; i++)
-            {
-                var file = _database._files[i];
-                entries[i] = new SevenZipArchiveEntry(
-                    this,
-                    new SevenZipFilePart(
-                        volume.Stream,
-                        _database,
-                        i,
-                        file,
-                        ReaderOptions.ArchiveEncoding
-                    )
-                );
-            }
-            foreach (
-                var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder)
-            )
-            {
-                var isSolid = false;
-                foreach (var entry in group)
-                {
-                    entry.IsSolid = isSolid;
-                    isSolid = true;
-                }
-            }
-
-            foreach (var entry in entries)
-            {
-                yield return entry;
+                entry.IsSolid = isSolid;
+                isSolid = true; //mark others in this group as solid - same as rar behaviour.
             }
         }
+
+        return entries;
     }
 
     private void LoadFactory(Stream stream)
@@ -88,6 +174,28 @@ public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, Sev
         }
     }
 
+    public static bool IsSevenZipFile(Stream stream)
+    {
+        try
+        {
+            return SignatureMatch(stream);
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    private static ReadOnlySpan<byte> Signature =>
+        new byte[] { (byte)'7', (byte)'z', 0xBC, 0xAF, 0x27, 0x1C };
+
+    private static bool SignatureMatch(Stream stream)
+    {
+        var reader = new BinaryReader(stream);
+        ReadOnlySpan<byte> signatureBytes = reader.ReadBytes(6);
+        return signatureBytes.SequenceEqual(Signature);
+    }
+
     protected override IReader CreateReaderForSolidExtraction() =>
         new SevenZipReader(ReaderOptions, this);
 
@@ -97,39 +205,18 @@ public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, Sev
             .GroupBy(x => x.FilePart.Folder)
             .Any(folder => folder.Count() > 1);
 
-    public override bool IsEncrypted => Entries.First(x => !x.IsDirectory).IsEncrypted;
-
     public override long TotalSize =>
         _database?._packSizes.Aggregate(0L, (total, packSize) => total + packSize) ?? 0;
 
-    internal sealed class SevenZipReader : AbstractReader<SevenZipEntry, SevenZipVolume>
+    private sealed class SevenZipReader : AbstractReader<SevenZipEntry, SevenZipVolume>
     {
         private readonly SevenZipArchive _archive;
-        private SevenZipEntry? _currentEntry;
-        private Stream? _currentFolderStream;
         private CFolder? _currentFolder;
-
-        /// <summary>
-        /// Enables internal diagnostics for tests.
-        /// When disabled (default), diagnostics properties return null to avoid exposing internal state.
-        /// </summary>
-        internal bool DiagnosticsEnabled { get; set; }
-
-        /// <summary>
-        /// Current folder instance used to decide whether the solid folder stream should be reused.
-        /// Only available when <see cref="DiagnosticsEnabled"/> is true.
-        /// </summary>
-        internal object? DiagnosticsCurrentFolder => DiagnosticsEnabled ? _currentFolder : null;
-
-        /// <summary>
-        /// Current shared folder stream instance.
-        /// Only available when <see cref="DiagnosticsEnabled"/> is true.
-        /// </summary>
-        internal Stream? DiagnosticsCurrentFolderStream =>
-            DiagnosticsEnabled ? _currentFolderStream : null;
+        private Stream? _currentStream;
+        private CFileItem? _currentItem;
 
         internal SevenZipReader(ReaderOptions readerOptions, SevenZipArchive archive)
-            : base(readerOptions, ArchiveType.SevenZip, false) => this._archive = archive;
+            : base(readerOptions, ArchiveType.SevenZip) => this._archive = archive;
 
         public override SevenZipVolume Volume => _archive.Volumes.Single();
 
@@ -139,163 +226,40 @@ public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, Sev
             stream.Position = 0;
             foreach (var dir in entries.Where(x => x.IsDirectory))
             {
-                _currentEntry = dir;
                 yield return dir;
             }
-            // For solid archives (entries in the same folder share a compressed stream),
-            // we must iterate entries sequentially and maintain the folder stream state
-            // across entries in the same folder to avoid recreating the decompression
-            // stream for each file, which breaks contiguous streaming.
-            foreach (var entry in entries.Where(x => !x.IsDirectory))
+            foreach (
+                var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder)
+            )
             {
-                _currentEntry = entry;
-                yield return entry;
+                _currentFolder = group.Key;
+                if (group.Key is null)
+                {
+                    _currentStream = Stream.Null;
+                }
+                else
+                {
+                    _currentStream = _archive._database?.GetFolderStream(
+                        stream,
+                        _currentFolder,
+                        new PasswordProvider(Options.Password)
+                    );
+                }
+                foreach (var entry in group)
+                {
+                    _currentItem = entry.FilePart.Header;
+                    yield return entry;
+                }
             }
         }
 
-        protected override EntryStream GetEntryStream()
-        {
-            var entry = _currentEntry.NotNull("currentEntry is not null");
-            if (entry.IsDirectory)
-            {
-                return CreateEntryStream(Stream.Null);
-            }
-
-            var folder = entry.FilePart.Folder;
-
-            // Check if we're starting a new folder - dispose old folder stream if needed
-            if (folder != _currentFolder)
-            {
-                _currentFolderStream?.Dispose();
-                _currentFolderStream = null;
-                _currentFolder = folder;
-            }
-
-            // Create the folder stream once per folder
-            if (_currentFolderStream is null)
-            {
-                _currentFolderStream = _archive._database!.GetFolderStream(
-                    _archive.Volumes.Single().Stream,
-                    folder!,
-                    _archive._database.PasswordProvider
-                );
-            }
-
-            // Wrap with SyncOnlyStream to work around LZMA async bugs
-            // Return a ReadOnlySubStream that reads from the shared folder stream
-            return CreateEntryStream(
-                new SyncOnlyStream(
-                    new ReadOnlySubStream(_currentFolderStream, entry.Size, leaveOpen: true)
+        protected override EntryStream GetEntryStream() =>
+            CreateEntryStream(
+                new ReadOnlySubStream(
+                    _currentStream.NotNull("currentStream is not null"),
+                    _currentItem?.Size ?? 0
                 )
             );
-        }
-
-        public override void Dispose()
-        {
-            _currentFolderStream?.Dispose();
-            _currentFolderStream = null;
-            base.Dispose();
-        }
-    }
-
-    /// <summary>
-    /// WORKAROUND: Forces async operations to use synchronous equivalents.
-    /// This is necessary because the LZMA decoder has bugs in its async implementation
-    /// that cause state corruption (IndexOutOfRangeException, DataErrorException).
-    ///
-    /// The proper fix would be to repair the LZMA decoder's async methods
-    /// (LzmaStream.ReadAsync, Decoder.CodeAsync, OutWindow async operations),
-    /// but that requires deep changes to the decoder state machine.
-    /// </summary>
-    private sealed class SyncOnlyStream : Stream
-    {
-        private readonly Stream _baseStream;
-
-        public SyncOnlyStream(Stream baseStream) => _baseStream = baseStream;
-
-        public override bool CanRead => _baseStream.CanRead;
-        public override bool CanSeek => _baseStream.CanSeek;
-        public override bool CanWrite => _baseStream.CanWrite;
-        public override long Length => _baseStream.Length;
-        public override long Position
-        {
-            get => _baseStream.Position;
-            set => _baseStream.Position = value;
-        }
-
-        public override void Flush() => _baseStream.Flush();
-
-        public override int Read(byte[] buffer, int offset, int count) =>
-            _baseStream.Read(buffer, offset, count);
-
-        public override long Seek(long offset, SeekOrigin origin) =>
-            _baseStream.Seek(offset, origin);
-
-        public override void SetLength(long value) => _baseStream.SetLength(value);
-
-        public override void Write(byte[] buffer, int offset, int count) =>
-            _baseStream.Write(buffer, offset, count);
-
-        // Force async operations to use sync equivalents to avoid LZMA decoder bugs
-        public override Task<int> ReadAsync(
-            byte[] buffer,
-            int offset,
-            int count,
-            CancellationToken cancellationToken
-        )
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            return Task.FromResult(_baseStream.Read(buffer, offset, count));
-        }
-
-        public override Task WriteAsync(
-            byte[] buffer,
-            int offset,
-            int count,
-            CancellationToken cancellationToken
-        )
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            _baseStream.Write(buffer, offset, count);
-            return Task.CompletedTask;
-        }
-
-        public override Task FlushAsync(CancellationToken cancellationToken)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            _baseStream.Flush();
-            return Task.CompletedTask;
-        }
-
-#if !LEGACY_DOTNET
-        public override ValueTask<int> ReadAsync(
-            Memory<byte> buffer,
-            CancellationToken cancellationToken = default
-        )
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            return new ValueTask<int>(_baseStream.Read(buffer.Span));
-        }
-
-        public override ValueTask WriteAsync(
-            ReadOnlyMemory<byte> buffer,
-            CancellationToken cancellationToken = default
-        )
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            _baseStream.Write(buffer.Span);
-            return ValueTask.CompletedTask;
-        }
-#endif
-
-        protected override void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                _baseStream.Dispose();
-            }
-            base.Dispose(disposing);
-        }
     }
 
     private class PasswordProvider : IPasswordProvider

src/SharpCompress/Archives/SevenZip/SevenZipArchiveEntry.cs

@@ -12,9 +12,8 @@ public class SevenZipArchiveEntry : SevenZipEntry, IArchiveEntry
 
     public Stream OpenEntryStream() => FilePart.GetCompressedStream();
 
-    public async ValueTask<Stream> OpenEntryStreamAsync(
-        CancellationToken cancellationToken = default
-    ) => (await FilePart.GetCompressedStreamAsync(cancellationToken)).NotNull();
+    public Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default) =>
+        Task.FromResult(OpenEntryStream());
 
     public IArchive Archive { get; }
 

src/SharpCompress/Archives/Tar/TarArchive.Async.cs

@@ -1,161 +0,0 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-using SharpCompress.Common.Tar;
-using SharpCompress.Common.Tar.Headers;
-using SharpCompress.IO;
-using SharpCompress.Readers;
-using SharpCompress.Readers.Tar;
-using SharpCompress.Writers;
-using SharpCompress.Writers.Tar;
-
-namespace SharpCompress.Archives.Tar;
-
-public partial class TarArchive
-{
-    protected override async ValueTask SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        IAsyncEnumerable<TarArchiveEntry> oldEntries,
-        IEnumerable<TarArchiveEntry> newEntries,
-        CancellationToken cancellationToken = default
-    )
-    {
-        using var writer = new TarWriter(stream, new TarWriterOptions(options));
-        await foreach (
-            var entry in oldEntries.WithCancellation(cancellationToken).ConfigureAwait(false)
-        )
-        {
-            if (entry.IsDirectory)
-            {
-                await writer
-                    .WriteDirectoryAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entry.LastModifiedTime,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-            else
-            {
-                using var entryStream = entry.OpenEntryStream();
-                await writer
-                    .WriteAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entryStream,
-                        entry.LastModifiedTime,
-                        entry.Size,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-        }
-        foreach (var entry in newEntries)
-        {
-            if (entry.IsDirectory)
-            {
-                await writer
-                    .WriteDirectoryAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entry.LastModifiedTime,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-            else
-            {
-                using var entryStream = entry.OpenEntryStream();
-                await writer
-                    .WriteAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entryStream,
-                        entry.LastModifiedTime,
-                        entry.Size,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-        }
-    }
-
-    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
-    {
-        var stream = Volumes.Single().Stream;
-        stream.Position = 0;
-        return new((IAsyncReader)TarReader.OpenReader(stream));
-    }
-
-    protected override async IAsyncEnumerable<TarArchiveEntry> LoadEntriesAsync(
-        IAsyncEnumerable<TarVolume> volumes
-    )
-    {
-        var stream = (await volumes.SingleAsync()).Stream;
-        if (stream.CanSeek)
-        {
-            stream.Position = 0;
-        }
-
-        // Always use async header reading in LoadEntriesAsync for consistency
-        {
-            // Use async header reading for async-only streams
-            TarHeader? previousHeader = null;
-            await foreach (
-                var header in TarHeaderFactory.ReadHeaderAsync(
-                    StreamingMode.Seekable,
-                    stream,
-                    ReaderOptions.ArchiveEncoding
-                )
-            )
-            {
-                if (header != null)
-                {
-                    if (header.EntryType == EntryType.LongName)
-                    {
-                        previousHeader = header;
-                    }
-                    else
-                    {
-                        if (previousHeader != null)
-                        {
-                            var entry = new TarArchiveEntry(
-                                this,
-                                new TarFilePart(previousHeader, stream),
-                                CompressionType.None
-                            );
-
-                            var oldStreamPos = stream.Position;
-
-                            using (var entryStream = entry.OpenEntryStream())
-                            {
-                                using var memoryStream = new MemoryStream();
-                                await entryStream.CopyToAsync(memoryStream);
-                                memoryStream.Position = 0;
-                                var bytes = memoryStream.ToArray();
-
-                                header.Name = ReaderOptions
-                                    .ArchiveEncoding.Decode(bytes)
-                                    .TrimNulls();
-                            }
-
-                            stream.Position = oldStreamPos;
-
-                            previousHeader = null;
-                        }
-                        yield return new TarArchiveEntry(
-                            this,
-                            new TarFilePart(header, stream),
-                            CompressionType.None
-                        );
-                    }
-                }
-                else
-                {
-                    throw new IncompleteArchiveException("Failed to read TAR header");
-                }
-            }
-        }
-    }
-}

src/SharpCompress/Archives/Tar/TarArchive.Factory.cs

@@ -1,202 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-using SharpCompress.Common.Tar.Headers;
-using SharpCompress.IO;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Archives.Tar;
-
-public partial class TarArchive
-#if NET8_0_OR_GREATER
-    : IWritableArchiveOpenable,
-        IMultiArchiveOpenable<IWritableArchive, IWritableAsyncArchive>
-#endif
-{
-    public static IWritableArchive OpenArchive(string filePath, ReaderOptions? readerOptions = null)
-    {
-        filePath.NotNullOrEmpty(nameof(filePath));
-        return OpenArchive(new FileInfo(filePath), readerOptions);
-    }
-
-    public static IWritableArchive OpenArchive(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        fileInfo.NotNull(nameof(fileInfo));
-        return new TarArchive(
-            new SourceStream(
-                fileInfo,
-                i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                readerOptions ?? new ReaderOptions() { LeaveStreamOpen = false }
-            )
-        );
-    }
-
-    public static IWritableArchive OpenArchive(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        fileInfos.NotNull(nameof(fileInfos));
-        var files = fileInfos.ToArray();
-        return new TarArchive(
-            new SourceStream(
-                files[0],
-                i => i < files.Length ? files[i] : null,
-                readerOptions ?? new ReaderOptions() { LeaveStreamOpen = false }
-            )
-        );
-    }
-
-    public static IWritableArchive OpenArchive(
-        IEnumerable<Stream> streams,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        streams.NotNull(nameof(streams));
-        var strms = streams.ToArray();
-        return new TarArchive(
-            new SourceStream(
-                strms[0],
-                i => i < strms.Length ? strms[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    public static IWritableArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null)
-    {
-        stream.NotNull(nameof(stream));
-
-        if (stream is not { CanSeek: true })
-        {
-            throw new ArgumentException("Stream must be seekable", nameof(stream));
-        }
-
-        return new TarArchive(
-            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
-        );
-    }
-
-    public static IWritableAsyncArchive OpenAsyncArchive(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(stream, readerOptions);
-    }
-
-    public static IWritableAsyncArchive OpenAsyncArchive(
-        string path,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(new FileInfo(path), readerOptions);
-    }
-
-    public static IWritableAsyncArchive OpenAsyncArchive(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(fileInfo, readerOptions);
-    }
-
-    public static IWritableAsyncArchive OpenAsyncArchive(
-        IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(streams, readerOptions);
-    }
-
-    public static IWritableAsyncArchive OpenAsyncArchive(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(fileInfos, readerOptions);
-    }
-
-    public static bool IsTarFile(string filePath) => IsTarFile(new FileInfo(filePath));
-
-    public static bool IsTarFile(FileInfo fileInfo)
-    {
-        if (!fileInfo.Exists)
-        {
-            return false;
-        }
-        using Stream stream = fileInfo.OpenRead();
-        return IsTarFile(stream);
-    }
-
-    public static bool IsTarFile(Stream stream)
-    {
-        try
-        {
-            var tarHeader = new TarHeader(new ArchiveEncoding());
-            var reader = new BinaryReader(stream, Encoding.UTF8, false);
-            var readSucceeded = tarHeader.Read(reader);
-            var isEmptyArchive =
-                tarHeader.Name?.Length == 0
-                && tarHeader.Size == 0
-                && Enum.IsDefined(typeof(EntryType), tarHeader.EntryType);
-            return readSucceeded || isEmptyArchive;
-        }
-        catch (Exception)
-        {
-            // Catch all exceptions during tar header reading to determine if this is a valid tar file
-            // Invalid tar files or corrupted streams will throw various exceptions
-            return false;
-        }
-    }
-
-    public static async ValueTask<bool> IsTarFileAsync(
-        Stream stream,
-        CancellationToken cancellationToken = default
-    )
-    {
-        try
-        {
-            var tarHeader = new TarHeader(new ArchiveEncoding());
-#if NET8_0_OR_GREATER
-            await using var reader = new AsyncBinaryReader(stream, leaveOpen: true);
-#else
-            using var reader = new AsyncBinaryReader(stream, leaveOpen: true);
-#endif
-            var readSucceeded = await tarHeader.ReadAsync(reader);
-            var isEmptyArchive =
-                tarHeader.Name?.Length == 0
-                && tarHeader.Size == 0
-                && Enum.IsDefined(typeof(EntryType), tarHeader.EntryType);
-            return readSucceeded || isEmptyArchive;
-        }
-        catch (Exception)
-        {
-            // Catch all exceptions during tar header reading to determine if this is a valid tar file
-            // Invalid tar files or corrupted streams will throw various exceptions
-            return false;
-        }
-    }
-
-    public static IWritableArchive CreateArchive() => new TarArchive();
-
-    public static IWritableAsyncArchive CreateAsyncArchive() => new TarArchive();
-}

src/SharpCompress/Archives/Tar/TarArchive.cs

@@ -15,14 +15,132 @@ using SharpCompress.Writers.Tar;
 
 namespace SharpCompress.Archives.Tar;
 
-public partial class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
+public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
 {
-    protected override IEnumerable<TarVolume> LoadVolumes(SourceStream sourceStream)
+    /// <summary>
+    /// Constructor expects a filepath to an existing file.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="readerOptions"></param>
+    public static TarArchive Open(string filePath, ReaderOptions? readerOptions = null)
     {
-        sourceStream.NotNull("SourceStream is null").LoadAllParts();
-        return new TarVolume(sourceStream, ReaderOptions, 1).AsEnumerable();
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
     }
 
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="readerOptions"></param>
+    public static TarArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
+    {
+        fileInfo.NotNull(nameof(fileInfo));
+        return new TarArchive(
+            new SourceStream(
+                fileInfo,
+                i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with all file parts passed in
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="readerOptions"></param>
+    public static TarArchive Open(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        fileInfos.NotNull(nameof(fileInfos));
+        var files = fileInfos.ToArray();
+        return new TarArchive(
+            new SourceStream(
+                files[0],
+                i => i < files.Length ? files[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with all stream parts passed in
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    public static TarArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
+    {
+        streams.NotNull(nameof(streams));
+        var strms = streams.ToArray();
+        return new TarArchive(
+            new SourceStream(
+                strms[0],
+                i => i < strms.Length ? strms[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Takes a seekable Stream as a source
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    public static TarArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+    {
+        stream.NotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
+        return new TarArchive(
+            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
+        );
+    }
+
+    public static bool IsTarFile(string filePath) => IsTarFile(new FileInfo(filePath));
+
+    public static bool IsTarFile(FileInfo fileInfo)
+    {
+        if (!fileInfo.Exists)
+        {
+            return false;
+        }
+        using Stream stream = fileInfo.OpenRead();
+        return IsTarFile(stream);
+    }
+
+    public static bool IsTarFile(Stream stream)
+    {
+        try
+        {
+            var tarHeader = new TarHeader(new ArchiveEncoding());
+            var readSucceeded = tarHeader.Read(new BinaryReader(stream));
+            var isEmptyArchive =
+                tarHeader.Name?.Length == 0
+                && tarHeader.Size == 0
+                && Enum.IsDefined(typeof(EntryType), tarHeader.EntryType);
+            return readSucceeded || isEmptyArchive;
+        }
+        catch { }
+        return false;
+    }
+
+    protected override IEnumerable<TarVolume> LoadVolumes(SourceStream sourceStream)
+    {
+        sourceStream.NotNull("SourceStream is null").LoadAllParts(); //request all streams
+        return new TarVolume(sourceStream, ReaderOptions, 1).AsEnumerable(); //simple single volume or split, multivolume not supported
+    }
+
+    /// <summary>
+    /// Constructor with a SourceStream able to handle FileInfo and Streams.
+    /// </summary>
+    /// <param name="sourceStream"></param>
     private TarArchive(SourceStream sourceStream)
         : base(ArchiveType.Tar, sourceStream) { }
 
@@ -32,10 +150,6 @@ public partial class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVo
     protected override IEnumerable<TarArchiveEntry> LoadEntries(IEnumerable<TarVolume> volumes)
     {
         var stream = volumes.Single().Stream;
-        if (stream.CanSeek)
-        {
-            stream.Position = 0;
-        }
         TarHeader? previousHeader = null;
         foreach (
             var header in TarHeaderFactory.ReadHeader(
@@ -66,7 +180,7 @@ public partial class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVo
                         using (var entryStream = entry.OpenEntryStream())
                         {
                             using var memoryStream = new MemoryStream();
-                            entryStream.CopyTo(memoryStream, Constants.BufferSize);
+                            entryStream.CopyTo(memoryStream);
                             memoryStream.Position = 0;
                             var bytes = memoryStream.ToArray();
 
@@ -91,6 +205,8 @@ public partial class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVo
         }
     }
 
+    public static TarArchive Create() => new();
+
     protected override TarArchiveEntry CreateEntryInternal(
         string filePath,
         Stream source,
@@ -143,10 +259,47 @@ public partial class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVo
         }
     }
 
+    protected override async Task SaveToAsync(
+        Stream stream,
+        WriterOptions options,
+        IEnumerable<TarArchiveEntry> oldEntries,
+        IEnumerable<TarArchiveEntry> newEntries,
+        CancellationToken cancellationToken = default
+    )
+    {
+        using var writer = new TarWriter(stream, new TarWriterOptions(options));
+        foreach (var entry in oldEntries.Concat(newEntries))
+        {
+            if (entry.IsDirectory)
+            {
+                await writer
+                    .WriteDirectoryAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entry.LastModifiedTime,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+            else
+            {
+                using var entryStream = entry.OpenEntryStream();
+                await writer
+                    .WriteAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entryStream,
+                        entry.LastModifiedTime,
+                        entry.Size,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+        }
+    }
+
     protected override IReader CreateReaderForSolidExtraction()
     {
         var stream = Volumes.Single().Stream;
         stream.Position = 0;
-        return TarReader.OpenReader(stream);
+        return TarReader.Open(stream);
     }
 }

src/SharpCompress/Archives/Tar/TarArchiveEntry.cs

@@ -14,9 +14,9 @@ public class TarArchiveEntry : TarEntry, IArchiveEntry
 
     public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
 
-    public async ValueTask<Stream> OpenEntryStreamAsync(
+    public virtual Task<Stream> OpenEntryStreamAsync(
         CancellationToken cancellationToken = default
-    ) => (await Parts.Single().GetCompressedStreamAsync(cancellationToken)).NotNull();
+    ) => Task.FromResult(OpenEntryStream());
 
     #region IArchiveEntry Members
 

src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs

@@ -79,7 +79,7 @@ internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiv
         }
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
-        return SharpCompressStream.CreateNonDisposing(stream);
+        return SharpCompressStream.Create(stream, leaveOpen: true);
     }
 
     internal override void Close()

src/SharpCompress/Archives/Zip/ZipArchive.Async.cs

@@ -1,132 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-using SharpCompress.Common.Zip;
-using SharpCompress.Common.Zip.Headers;
-using SharpCompress.IO;
-using SharpCompress.Readers;
-using SharpCompress.Writers;
-using SharpCompress.Writers.Zip;
-
-namespace SharpCompress.Archives.Zip;
-
-public partial class ZipArchive
-{
-    protected override async IAsyncEnumerable<ZipArchiveEntry> LoadEntriesAsync(
-        IAsyncEnumerable<ZipVolume> volumes
-    )
-    {
-        var vols = await volumes.ToListAsync();
-        var volsArray = vols.ToArray();
-
-        await foreach (
-            var h in headerFactory.NotNull().ReadSeekableHeaderAsync(volsArray.Last().Stream)
-        )
-        {
-            if (h != null)
-            {
-                switch (h.ZipHeaderType)
-                {
-                    case ZipHeaderType.DirectoryEntry:
-                        {
-                            var deh = (DirectoryEntryHeader)h;
-                            Stream s;
-                            if (
-                                deh.RelativeOffsetOfEntryHeader + deh.CompressedSize
-                                > volsArray[deh.DiskNumberStart].Stream.Length
-                            )
-                            {
-                                var v = volsArray.Skip(deh.DiskNumberStart).ToArray();
-                                s = new SourceStream(
-                                    v[0].Stream,
-                                    i => i < v.Length ? v[i].Stream : null,
-                                    new ReaderOptions() { LeaveStreamOpen = true }
-                                );
-                            }
-                            else
-                            {
-                                s = volsArray[deh.DiskNumberStart].Stream;
-                            }
-
-                            yield return new ZipArchiveEntry(
-                                this,
-                                new SeekableZipFilePart(headerFactory.NotNull(), deh, s)
-                            );
-                        }
-                        break;
-                    case ZipHeaderType.DirectoryEnd:
-                    {
-                        var bytes = ((DirectoryEndHeader)h).Comment ?? Array.Empty<byte>();
-                        volsArray.Last().Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
-                        yield break;
-                    }
-                }
-            }
-        }
-    }
-
-    protected override async ValueTask SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        IAsyncEnumerable<ZipArchiveEntry> oldEntries,
-        IEnumerable<ZipArchiveEntry> newEntries,
-        CancellationToken cancellationToken = default
-    )
-    {
-        using var writer = new ZipWriter(stream, new ZipWriterOptions(options));
-        await foreach (
-            var entry in oldEntries.WithCancellation(cancellationToken).ConfigureAwait(false)
-        )
-        {
-            if (entry.IsDirectory)
-            {
-                await writer
-                    .WriteDirectoryAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entry.LastModifiedTime,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-            else
-            {
-                using var entryStream = entry.OpenEntryStream();
-                await writer
-                    .WriteAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entryStream,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-        }
-        foreach (var entry in newEntries)
-        {
-            if (entry.IsDirectory)
-            {
-                await writer
-                    .WriteDirectoryAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entry.LastModifiedTime,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-            else
-            {
-                using var entryStream = entry.OpenEntryStream();
-                await writer
-                    .WriteAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entryStream,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-        }
-    }
-}

src/SharpCompress/Archives/Zip/ZipArchive.Factory.cs

@@ -1,287 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-using SharpCompress.Common.Zip;
-using SharpCompress.Common.Zip.Headers;
-using SharpCompress.IO;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Archives.Zip;
-
-public partial class ZipArchive
-#if NET8_0_OR_GREATER
-    : IWritableArchiveOpenable,
-        IMultiArchiveOpenable<IWritableArchive, IWritableAsyncArchive>
-#endif
-{
-    public static IWritableArchive OpenArchive(string filePath, ReaderOptions? readerOptions = null)
-    {
-        filePath.NotNullOrEmpty(nameof(filePath));
-        return OpenArchive(new FileInfo(filePath), readerOptions);
-    }
-
-    public static IWritableArchive OpenArchive(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        fileInfo.NotNull(nameof(fileInfo));
-        return new ZipArchive(
-            new SourceStream(
-                fileInfo,
-                i => ZipArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                readerOptions ?? new ReaderOptions() { LeaveStreamOpen = false }
-            )
-        );
-    }
-
-    public static IWritableArchive OpenArchive(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        fileInfos.NotNull(nameof(fileInfos));
-        var files = fileInfos.ToArray();
-        return new ZipArchive(
-            new SourceStream(
-                files[0],
-                i => i < files.Length ? files[i] : null,
-                readerOptions ?? new ReaderOptions() { LeaveStreamOpen = false }
-            )
-        );
-    }
-
-    public static IWritableArchive OpenArchive(
-        IEnumerable<Stream> streams,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        streams.NotNull(nameof(streams));
-        var strms = streams.ToArray();
-        return new ZipArchive(
-            new SourceStream(
-                strms[0],
-                i => i < strms.Length ? strms[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    public static IWritableArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null)
-    {
-        stream.NotNull(nameof(stream));
-
-        if (stream is not { CanSeek: true })
-        {
-            throw new ArgumentException("Stream must be seekable", nameof(stream));
-        }
-
-        return new ZipArchive(
-            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
-        );
-    }
-
-    public static IWritableAsyncArchive OpenAsyncArchive(
-        string path,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(path, readerOptions);
-    }
-
-    public static IWritableAsyncArchive OpenAsyncArchive(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(stream, readerOptions);
-    }
-
-    public static IWritableAsyncArchive OpenAsyncArchive(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(fileInfo, readerOptions);
-    }
-
-    public static IWritableAsyncArchive OpenAsyncArchive(
-        IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(streams, readerOptions);
-    }
-
-    public static IWritableAsyncArchive OpenAsyncArchive(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(fileInfos, readerOptions);
-    }
-
-    public static bool IsZipFile(string filePath, string? password = null) =>
-        IsZipFile(new FileInfo(filePath), password);
-
-    public static bool IsZipFile(FileInfo fileInfo, string? password = null)
-    {
-        if (!fileInfo.Exists)
-        {
-            return false;
-        }
-        using Stream stream = fileInfo.OpenRead();
-        return IsZipFile(stream, password);
-    }
-
-    public static bool IsZipFile(Stream stream, string? password = null)
-    {
-        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
-        try
-        {
-            var header = headerFactory
-                .ReadStreamHeader(stream)
-                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
-            if (header is null)
-            {
-                return false;
-            }
-            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
-        }
-        catch (CryptographicException)
-        {
-            return true;
-        }
-        catch
-        {
-            return false;
-        }
-    }
-
-    public static bool IsZipMulti(Stream stream, string? password = null)
-    {
-        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
-        try
-        {
-            var header = headerFactory
-                .ReadStreamHeader(stream)
-                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
-            if (header is null)
-            {
-                if (stream.CanSeek)
-                {
-                    var z = new SeekableZipHeaderFactory(password, new ArchiveEncoding());
-                    var x = z.ReadSeekableHeader(stream).FirstOrDefault();
-                    return x?.ZipHeaderType == ZipHeaderType.DirectoryEntry;
-                }
-                else
-                {
-                    return false;
-                }
-            }
-            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
-        }
-        catch (CryptographicException)
-        {
-            return true;
-        }
-        catch
-        {
-            return false;
-        }
-    }
-
-    public static async ValueTask<bool> IsZipFileAsync(
-        Stream stream,
-        string? password = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
-        try
-        {
-            var header = await headerFactory
-                .ReadStreamHeaderAsync(stream)
-                .Where(x => x.ZipHeaderType != ZipHeaderType.Split)
-                .FirstOrDefaultAsync(cancellationToken);
-            if (header is null)
-            {
-                return false;
-            }
-            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
-        }
-        catch (CryptographicException)
-        {
-            return true;
-        }
-        catch
-        {
-            return false;
-        }
-    }
-
-    public static IWritableArchive CreateArchive() => new ZipArchive();
-
-    public static IWritableAsyncArchive CreateAsyncArchive() => new ZipArchive();
-
-    public static async ValueTask<bool> IsZipMultiAsync(
-        Stream stream,
-        string? password = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
-        try
-        {
-            var header = headerFactory
-                .ReadStreamHeader(stream)
-                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
-            if (header is null)
-            {
-                if (stream.CanSeek)
-                {
-                    var z = new SeekableZipHeaderFactory(password, new ArchiveEncoding());
-                    ZipHeader? x = null;
-                    await foreach (
-                        var h in z.ReadSeekableHeaderAsync(stream)
-                            .WithCancellation(cancellationToken)
-                    )
-                    {
-                        x = h;
-                        break;
-                    }
-                    return x?.ZipHeaderType == ZipHeaderType.DirectoryEntry;
-                }
-                else
-                {
-                    return false;
-                }
-            }
-            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
-        }
-        catch (CryptographicException)
-        {
-            return true;
-        }
-        catch
-        {
-            return false;
-        }
-    }
-}

src/SharpCompress/Archives/Zip/ZipArchive.cs

@@ -16,12 +16,21 @@ using SharpCompress.Writers.Zip;
 
 namespace SharpCompress.Archives.Zip;
 
-public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
+public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
 {
     private readonly SeekableZipHeaderFactory? headerFactory;
 
+    /// <summary>
+    /// Gets or sets the compression level applied to files added to the archive,
+    /// if the compression method is set to deflate
+    /// </summary>
     public CompressionLevel DeflateCompressionLevel { get; set; }
 
+    /// <summary>
+    /// Constructor with a SourceStream able to handle FileInfo and Streams.
+    /// </summary>
+    /// <param name="sourceStream"></param>
+    /// <param name="options"></param>
     internal ZipArchive(SourceStream sourceStream)
         : base(ArchiveType.Zip, sourceStream) =>
         headerFactory = new SeekableZipHeaderFactory(
@@ -29,39 +38,219 @@ public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVo
             sourceStream.ReaderOptions.ArchiveEncoding
         );
 
-    internal ZipArchive()
-        : base(ArchiveType.Zip) { }
+    /// <summary>
+    /// Constructor expects a filepath to an existing file.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="readerOptions"></param>
+    public static ZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+    }
+
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="readerOptions"></param>
+    public static ZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
+    {
+        fileInfo.NotNull(nameof(fileInfo));
+        return new ZipArchive(
+            new SourceStream(
+                fileInfo,
+                i => ZipArchiveVolumeFactory.GetFilePart(i, fileInfo),
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with all file parts passed in
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="readerOptions"></param>
+    public static ZipArchive Open(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        fileInfos.NotNull(nameof(fileInfos));
+        var files = fileInfos.ToArray();
+        return new ZipArchive(
+            new SourceStream(
+                files[0],
+                i => i < files.Length ? files[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with all stream parts passed in
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    public static ZipArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
+    {
+        streams.NotNull(nameof(streams));
+        var strms = streams.ToArray();
+        return new ZipArchive(
+            new SourceStream(
+                strms[0],
+                i => i < strms.Length ? strms[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Takes a seekable Stream as a source
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    public static ZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+    {
+        stream.NotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
+        return new ZipArchive(
+            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
+        );
+    }
+
+    public static bool IsZipFile(
+        string filePath,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    ) => IsZipFile(new FileInfo(filePath), password, bufferSize);
+
+    public static bool IsZipFile(
+        FileInfo fileInfo,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
+    {
+        if (!fileInfo.Exists)
+        {
+            return false;
+        }
+        using Stream stream = fileInfo.OpenRead();
+        return IsZipFile(stream, password, bufferSize);
+    }
+
+    public static bool IsZipFile(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
+    {
+        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
+        try
+        {
+            if (stream is not SharpCompressStream)
+            {
+                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
+            }
+
+            var header = headerFactory
+                .ReadStreamHeader(stream)
+                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
+            if (header is null)
+            {
+                return false;
+            }
+            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
+        }
+        catch (CryptographicException)
+        {
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    public static bool IsZipMulti(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
+    {
+        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
+        try
+        {
+            if (stream is not SharpCompressStream)
+            {
+                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
+            }
+
+            var header = headerFactory
+                .ReadStreamHeader(stream)
+                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
+            if (header is null)
+            {
+                if (stream.CanSeek) //could be multipart. Test for central directory - might not be z64 safe
+                {
+                    var z = new SeekableZipHeaderFactory(password, new ArchiveEncoding());
+                    var x = z.ReadSeekableHeader(stream).FirstOrDefault();
+                    return x?.ZipHeaderType == ZipHeaderType.DirectoryEntry;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
+        }
+        catch (CryptographicException)
+        {
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
 
     protected override IEnumerable<ZipVolume> LoadVolumes(SourceStream stream)
     {
-        stream.LoadAllParts();
-        //stream.Position = 0;
+        stream.LoadAllParts(); //request all streams
+        stream.Position = 0;
 
         var streams = stream.Streams.ToList();
         var idx = 0;
-        if (streams.Count() > 1)
+        if (streams.Count() > 1) //test part 2 - true = multipart not split
         {
-            //check if second stream is zip header without changing position
-            var headerProbeStream = streams[1];
-            var startPosition = headerProbeStream.Position;
-            headerProbeStream.Position = startPosition + 4;
-            var isZip = IsZipFile(headerProbeStream, ReaderOptions.Password);
-            headerProbeStream.Position = startPosition;
+            streams[1].Position += 4; //skip the POST_DATA_DESCRIPTOR to prevent an exception
+            var isZip = IsZipFile(streams[1], ReaderOptions.Password, ReaderOptions.BufferSize);
+            streams[1].Position -= 4;
             if (isZip)
             {
                 stream.IsVolumes = true;
 
-                var tmp = streams[0];
+                var tmp = streams[0]; //arcs as zip, z01 ... swap the zip the end
                 streams.RemoveAt(0);
                 streams.Add(tmp);
 
+                //streams[0].Position = 4; //skip the POST_DATA_DESCRIPTOR to prevent an exception
                 return streams.Select(a => new ZipVolume(a, ReaderOptions, idx++));
             }
         }
 
+        //split mode or single file
         return new ZipVolume(stream, ReaderOptions, idx++).AsEnumerable();
     }
 
+    internal ZipArchive()
+        : base(ArchiveType.Zip) { }
+
     protected override IEnumerable<ZipArchiveEntry> LoadEntries(IEnumerable<ZipVolume> volumes)
     {
         var vols = volumes.ToArray();
@@ -140,6 +329,41 @@ public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVo
         }
     }
 
+    protected override async Task SaveToAsync(
+        Stream stream,
+        WriterOptions options,
+        IEnumerable<ZipArchiveEntry> oldEntries,
+        IEnumerable<ZipArchiveEntry> newEntries,
+        CancellationToken cancellationToken = default
+    )
+    {
+        using var writer = new ZipWriter(stream, new ZipWriterOptions(options));
+        foreach (var entry in oldEntries.Concat(newEntries))
+        {
+            if (entry.IsDirectory)
+            {
+                await writer
+                    .WriteDirectoryAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entry.LastModifiedTime,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+            else
+            {
+                using var entryStream = entry.OpenEntryStream();
+                await writer
+                    .WriteAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entryStream,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+        }
+    }
+
     protected override ZipArchiveEntry CreateEntryInternal(
         string filePath,
         Stream source,
@@ -153,17 +377,12 @@ public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVo
         DateTime? modified
     ) => new ZipWritableArchiveEntry(this, directoryPath, modified);
 
+    public static ZipArchive Create() => new();
+
     protected override IReader CreateReaderForSolidExtraction()
     {
         var stream = Volumes.Single().Stream;
-        //stream.Position = 0;
-        return ZipReader.OpenReader(stream, ReaderOptions, Entries);
-    }
-
-    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
-    {
-        var stream = Volumes.Single().Stream;
-        stream.Position = 0;
-        return new((IAsyncReader)ZipReader.OpenReader(stream));
+        ((IStreamStack)stream).StackSeek(0);
+        return ZipReader.Open(stream, ReaderOptions, Entries);
     }
 }

src/SharpCompress/Archives/Zip/ZipArchiveEntry.Async.cs

@@ -1,22 +0,0 @@
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common.Zip;
-
-namespace SharpCompress.Archives.Zip;
-
-public partial class ZipArchiveEntry
-{
-    public async ValueTask<Stream> OpenEntryStreamAsync(
-        CancellationToken cancellationToken = default
-    )
-    {
-        var part = Parts.Single();
-        if (part is SeekableZipFilePart seekablePart)
-        {
-            return (await seekablePart.GetCompressedStreamAsync(cancellationToken)).NotNull();
-        }
-        return OpenEntryStream();
-    }
-}

src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs

@@ -6,13 +6,17 @@ using SharpCompress.Common.Zip;
 
 namespace SharpCompress.Archives.Zip;
 
-public partial class ZipArchiveEntry : ZipEntry, IArchiveEntry
+public class ZipArchiveEntry : ZipEntry, IArchiveEntry
 {
     internal ZipArchiveEntry(ZipArchive archive, SeekableZipFilePart? part)
         : base(part) => Archive = archive;
 
     public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
 
+    public virtual Task<Stream> OpenEntryStreamAsync(
+        CancellationToken cancellationToken = default
+    ) => Task.FromResult(OpenEntryStream());
+
     #region IArchiveEntry Members
 
     public IArchive Archive { get; }

src/SharpCompress/Archives/Zip/ZipArchiveVolumeFactory.cs

@@ -14,7 +14,6 @@ internal static class ZipArchiveVolumeFactory
         //new style .zip, z01.. | .zipx, zx01 - if the numbers go beyond 99 then they use 100 ...1000 etc
         var m = Regex.Match(part1.Name, @"^(.*\.)(zipx?|zx?[0-9]+)$", RegexOptions.IgnoreCase);
         if (m.Success)
-        {
             item = new FileInfo(
                 Path.Combine(
                     part1.DirectoryName!,
@@ -25,16 +24,11 @@ internal static class ZipArchiveVolumeFactory
                     )
                 )
             );
-        }
         else //split - 001, 002 ...
-        {
             return ArchiveVolumeFactory.GetFilePart(index, part1);
-        }
 
         if (item != null && item.Exists)
-        {
             return item;
-        }
 
         return null; //no more items
     }

src/SharpCompress/Archives/Zip/ZipWritableArchiveEntry.cs

@@ -80,7 +80,7 @@ internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
         }
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
-        return SharpCompressStream.CreateNonDisposing(stream);
+        return SharpCompressStream.Create(stream, leaveOpen: true);
     }
 
     internal override void Close()

src/SharpCompress/AssemblyInfo.cs

@@ -1,8 +1,7 @@
 using System;
 using System.Runtime.CompilerServices;
 
-// CLSCompliant(false) is required because ZStandard integration uses unsafe code
-[assembly: CLSCompliant(false)]
+[assembly: CLSCompliant(true)]
 [assembly: InternalsVisibleTo(
     "SharpCompress.Test,PublicKey=0024000004800000940000000602000000240000525341310004000001000100158bebf1433f76dffc356733c138babea7a47536c65ed8009b16372c6f4edbb20554db74a62687f56b97c20a6ce8c4b123280279e33c894e7b3aa93ab3c573656fde4db576cfe07dba09619ead26375b25d2c4a8e43f7be257d712b0dd2eb546f67adb09281338618a58ac834fc038dd7e2740a7ab3591826252e4f4516306dc"
 )]

src/SharpCompress/Common/Ace/AceCrc.cs

@@ -1,64 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace SharpCompress.Common.Ace;
-
-public class AceCrc
-{
-    // CRC-32 lookup table (standard polynomial 0xEDB88320, reflected)
-    private static readonly uint[] Crc32Table = GenerateTable();
-
-    private static uint[] GenerateTable()
-    {
-        var table = new uint[256];
-
-        for (int i = 0; i < 256; i++)
-        {
-            uint crc = (uint)i;
-
-            for (int j = 0; j < 8; j++)
-            {
-                if ((crc & 1) != 0)
-                {
-                    crc = (crc >> 1) ^ 0xEDB88320u;
-                }
-                else
-                {
-                    crc >>= 1;
-                }
-            }
-
-            table[i] = crc;
-        }
-
-        return table;
-    }
-
-    /// <summary>
-    /// Calculate ACE CRC-32 checksum.
-    /// ACE CRC-32 uses standard CRC-32 polynomial (0xEDB88320, reflected)
-    /// with init=0xFFFFFFFF but NO final XOR.
-    /// </summary>
-    public static uint AceCrc32(ReadOnlySpan<byte> data)
-    {
-        uint crc = 0xFFFFFFFFu;
-
-        foreach (byte b in data)
-        {
-            crc = (crc >> 8) ^ Crc32Table[(crc ^ b) & 0xFF];
-        }
-
-        return crc; // No final XOR for ACE
-    }
-
-    /// <summary>
-    /// ACE CRC-16 is the lower 16 bits of the ACE CRC-32.
-    /// </summary>
-    public static ushort AceCrc16(ReadOnlySpan<byte> data)
-    {
-        return (ushort)(AceCrc32(data) & 0xFFFF);
-    }
-}

src/SharpCompress/Common/Ace/AceEntry.cs

@@ -1,67 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using SharpCompress.Common.Ace.Headers;
-
-namespace SharpCompress.Common.Ace;
-
-public class AceEntry : Entry
-{
-    private readonly AceFilePart _filePart;
-
-    internal AceEntry(AceFilePart filePart)
-    {
-        _filePart = filePart;
-    }
-
-    public override long Crc
-    {
-        get
-        {
-            if (_filePart == null)
-            {
-                return 0;
-            }
-            return _filePart.Header.Crc32;
-        }
-    }
-
-    public override string? Key => _filePart?.Header.Filename;
-
-    public override string? LinkTarget => null;
-
-    public override long CompressedSize => _filePart?.Header.PackedSize ?? 0;
-
-    public override CompressionType CompressionType
-    {
-        get
-        {
-            if (_filePart.Header.CompressionType == Headers.CompressionType.Stored)
-            {
-                return CompressionType.None;
-            }
-            return CompressionType.AceLZ77;
-        }
-    }
-
-    public override long Size => _filePart?.Header.OriginalSize ?? 0;
-
-    public override DateTime? LastModifiedTime => _filePart.Header.DateTime;
-
-    public override DateTime? CreatedTime => null;
-
-    public override DateTime? LastAccessedTime => null;
-
-    public override DateTime? ArchivedTime => null;
-
-    public override bool IsEncrypted => _filePart.Header.IsFileEncrypted;
-
-    public override bool IsDirectory => _filePart.Header.IsDirectory;
-
-    public override bool IsSplitAfter => false;
-
-    internal override IEnumerable<FilePart> Parts => _filePart.Empty();
-}

src/SharpCompress/Common/Ace/AceFilePart.cs

@@ -1,51 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using SharpCompress.Common.Ace.Headers;
-using SharpCompress.IO;
-
-namespace SharpCompress.Common.Ace;
-
-public class AceFilePart : FilePart
-{
-    private readonly Stream _stream;
-    internal AceFileHeader Header { get; set; }
-
-    internal AceFilePart(AceFileHeader localAceHeader, Stream seekableStream)
-        : base(localAceHeader.ArchiveEncoding)
-    {
-        _stream = seekableStream;
-        Header = localAceHeader;
-    }
-
-    internal override string? FilePartName => Header.Filename;
-
-    internal override Stream GetCompressedStream()
-    {
-        if (_stream != null)
-        {
-            Stream compressedStream;
-            switch (Header.CompressionType)
-            {
-                case Headers.CompressionType.Stored:
-                    compressedStream = new ReadOnlySubStream(
-                        _stream,
-                        Header.DataStartPosition,
-                        Header.PackedSize
-                    );
-                    break;
-                default:
-                    throw new NotSupportedException(
-                        "CompressionMethod: " + Header.CompressionQuality
-                    );
-            }
-            return compressedStream;
-        }
-        return _stream.NotNull();
-    }
-
-    internal override Stream? GetRawStream() => _stream;
-}

src/SharpCompress/Common/Ace/AceVolume.cs

@@ -1,34 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using SharpCompress.Common.Arj;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Common.Ace;
-
-public class AceVolume : Volume
-{
-    public AceVolume(Stream stream, ReaderOptions readerOptions, int index = 0)
-        : base(stream, readerOptions, index) { }
-
-    public override bool IsFirstVolume
-    {
-        get { return true; }
-    }
-
-    /// <summary>
-    /// ArjArchive is part of a multi-part archive.
-    /// </summary>
-    public override bool IsMultiVolume
-    {
-        get { return false; }
-    }
-
-    internal IEnumerable<AceFilePart> GetVolumeFileParts()
-    {
-        return new List<AceFilePart>();
-    }
-}

src/SharpCompress/Common/Ace/Headers/AceFileHeader.Async.cs

@@ -1,111 +0,0 @@
-using System;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common.Arc;
-
-namespace SharpCompress.Common.Ace.Headers;
-
-public sealed partial class AceFileHeader
-{
-    /// <summary>
-    /// Asynchronously reads the next file entry header from the stream.
-    /// Returns null if no more entries or end of archive.
-    /// Supports both ACE 1.0 and ACE 2.0 formats.
-    /// </summary>
-    public override async ValueTask<AceHeader?> ReadAsync(
-        Stream stream,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var headerData = await ReadHeaderAsync(stream, cancellationToken);
-        if (headerData.Length == 0)
-        {
-            return null;
-        }
-        int offset = 0;
-
-        // Header type (1 byte)
-        HeaderType = headerData[offset++];
-
-        // Skip recovery record headers (ACE 2.0 feature)
-        if (HeaderType == (byte)SharpCompress.Common.Ace.Headers.AceHeaderType.RECOVERY32)
-        {
-            // Skip to next header
-            return null;
-        }
-
-        if (HeaderType != (byte)SharpCompress.Common.Ace.Headers.AceHeaderType.FILE)
-        {
-            // Unknown header type - skip
-            return null;
-        }
-
-        // Header flags (2 bytes)
-        HeaderFlags = BitConverter.ToUInt16(headerData, offset);
-        offset += 2;
-
-        // Packed size (4 bytes)
-        PackedSize = BitConverter.ToUInt32(headerData, offset);
-        offset += 4;
-
-        // Original size (4 bytes)
-        OriginalSize = BitConverter.ToUInt32(headerData, offset);
-        offset += 4;
-
-        // File date/time in DOS format (4 bytes)
-        var dosDateTime = BitConverter.ToUInt32(headerData, offset);
-        DateTime = ConvertDosDateTime(dosDateTime);
-        offset += 4;
-
-        // File attributes (4 bytes)
-        Attributes = (int)BitConverter.ToUInt32(headerData, offset);
-        offset += 4;
-
-        // CRC32 (4 bytes)
-        Crc32 = BitConverter.ToUInt32(headerData, offset);
-        offset += 4;
-
-        // Compression type (1 byte)
-        byte compressionType = headerData[offset++];
-        CompressionType = GetCompressionType(compressionType);
-
-        // Compression quality/parameter (1 byte)
-        byte compressionQuality = headerData[offset++];
-        CompressionQuality = GetCompressionQuality(compressionQuality);
-
-        // Parameters (2 bytes)
-        Parameters = BitConverter.ToUInt16(headerData, offset);
-        offset += 2;
-
-        // Reserved (2 bytes) - skip
-        offset += 2;
-
-        // Filename length (2 bytes)
-        var filenameLength = BitConverter.ToUInt16(headerData, offset);
-        offset += 2;
-
-        // Filename
-        if (offset + filenameLength <= headerData.Length)
-        {
-            Filename = ArchiveEncoding.Decode(headerData, offset, filenameLength);
-            offset += filenameLength;
-        }
-
-        // Handle comment if present
-        if ((HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.COMMENT) != 0)
-        {
-            // Comment length (2 bytes)
-            if (offset + 2 <= headerData.Length)
-            {
-                ushort commentLength = BitConverter.ToUInt16(headerData, offset);
-                offset += 2 + commentLength; // Skip comment
-            }
-        }
-
-        // Store the data start position
-        DataStartPosition = stream.Position;
-
-        return this;
-    }
-}