omnizip 0.3.36 → 0.3.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53eb9dfabf6b8f299e86de445f0b2e487dcb12531ad6c901d35f89b306e53e97
-  data.tar.gz: 2df326cef1acba3e9de77ee349c4714ba3ba20c559beab62637dd70b2d55c1d8
+  metadata.gz: 67142de350c2f3dd29c473268977799ed088cedb0340932cff6db7bc23ac009e
+  data.tar.gz: c35fbc3353ca0c20f2ec4f86fa39fff67e6ed95822702a18c9b545d35406749c
 SHA512:
-  metadata.gz: 182da8c8f1f5ccf84552f1bb7741f00340165d90bf8a19edcb3299dcdff02d99644b98b87fa13969dd62090c70f9973c97950267b816a3cceda988c53df2430b
-  data.tar.gz: e8745b56c4aded2fa04e81d0dd0ec011360f4593d590b4127aa284fac62b42766c39e26ce53f67b9f77e6e7cbe024345465a89af544b4594213e5d8811d297a2
+  metadata.gz: 7f6b4e88bb0a227f7cff47b06e979891e6d5a57288ae141bd15e57a07abe2cef3c915600242bb05406c4b7a13ef9fdd0ab5f11870e41b65f0a95077191741ceb
+  data.tar.gz: 3e8497c8eb222b4a139f965ec84f1672d8b12ae92e55986df95d8057c452bcace18a75c54a0464ca696776a33256d2e11ea53811c7d73e3ecb1c0eece06d04ff

data/CHANGELOG.md

@@ -7,6 +7,136 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+- `.cpio` and `.iso` read routing: `extract_archive`/`list_archive`/
+  `read_from_archive`/`Archive.open` operate on CPIO archives and ISO
+  9660 images through new read-only handlers, mirroring the RAR
+  routing (creation keeps raising truthfully).
+
+### Fixed
+- 7z archives with explicit directory entries (or zero-byte
+  entries) were structurally invalid: the writer never emitted the
+  kEmptyStream/kEmptyFile properties, hardcoded 0x20 attributes
+  over each entry's real attributes, and its kSubStreamsInfo
+  digest/size arrays counted directory entries as substreams. 7-Zip
+  rejects such archives with "Headers Error" (and our own reader
+  crashed extracting directory entries). Verified against 7zz
+  ground truth (`-mhc=off` dumps): kEmptyStream/kEmptyFile carry
+  RAW bit vectors with no all-defined marker — the parser expected
+  that marker everywhere, so it now reads both layouts correctly
+  (which also fixes reading 7-Zip-created archives containing empty
+  files).
+- RAR5 vint encoding was not the spec encoding: multi-byte values
+  (any size >= 128, extra-area sizes, dictionary sizes) were written
+  in a byte-swapped form no reader decodes — archives with more
+  than ~127 bytes of content were corrupt for unrar AND for our own
+  spec-conformant parser. All round-trips now verified against
+  unrar, including encrypted STORE, multi-file, and multi-volume
+  archives (volume flags were the previously documented "no
+  write-side reference" gap: Main archive flags 0x0001/0x0002 and
+  end-of-archive 0x0001 are written per the RAR 5.0 specification).
+- RAR5 file headers: a "mystery vint" not in the spec shifted every
+  field; the compression method was written into the version bits;
+  the file-attribute value chmods extracted files unreadable. Now:
+  spec field order, method in bits 8-10 with dictionary bits
+  11-15, Unix attribute 0o100644.
+- RAR5 encrypted writing now persists the salt/IV as the file
+  encryption extra record (spec type 0x01) — archives it wrote
+  before could not be decrypted by anything (unrar reported "All
+  OK" only because no CRC was stored).
+- RAR5 `:lzma`/`:lzss` compression advertised method bits for a
+  stream that nothing can decode (the encoder is not
+  official-RAR-compatible; `unrar` extracts empty files silently).
+  `Lzss.available?` is now honest, so writers fall back to STORE
+  with a warning; solid mode falls back to independent STORE
+  entries.
+- ISO writing: directory records pointed every file at sector 0
+  (allocated extents were never copied onto the tree nodes); the
+  volume descriptor declared 100 sectors regardless of actual
+  size; `add_directory` entries were not marked as directories;
+  Rock Ridge and Joliet were advertised by default without being
+  implemented (the cloned SVD made 7-Zip read ASCII names as
+  UCS-2); `Reader#extract_all` looked entries up by bare name
+  instead of full path; `Formats::Iso.list` returned the Reader
+  instead of entries. Images now extract byte-identically through
+  7zz, including nested directories.
+- CLI: `omnizip <command> --help` failed with an arity error on
+  every command (Thor does not route `--help` on subcommands by
+  itself). A dispatch hook now prints per-command help.
+- `Omnizip::Formats::Rar::Rar5::MainHeader/FileHeader` were
+  unreferenceable unless another file happened to load header.rb
+  first (missing autoload entries); three Rar5 autoloads pointed at
+  files that never existed.
+
+### Changed
+- Docs: the OLE, RPM, GZIP, RAR5 and API-overview guides now use
+  the real APIs (`Formats::Ole.list/read/info`, `Formats::Rpm.*`,
+  `Gzip.compress_stream`, `Formats::Zip::Reader#read`, correct
+  error class names); fictional methods (`open_stream`, `root`,
+  `extract_to`, `extract_files`, `extract_payload`,
+  `Rar::Rar5::Reader`, scriptlets/signature accessors) removed.
+
+## [0.3.37] - 2026-08-28
+
+### Added
+- `Omnizip::Archive` — the block-style facade the guides have
+  documented since the docs were written (it never existed; ~50
+  examples across 17 files were dead). `Archive.create(path,
+  format:, **options)` yields a Builder with `add_file(path,
+  archive_path:)`, `add_directory(dir)` (tree stored under its own
+  name), and `add_data(name, content)`; `Archive.open(path,
+  password:)` yields (or returns) a session with `entries`
+  (name/size/directory?/mtime), `each_entry`, `read`, `extract`,
+  `extract_all`, `extract_matching`. 7z options (`level:`,
+  `password:`, `encrypt_headers:`, `algorithm:`, `filters:`,
+  `solid:`, `dict_size:`) pass through to the writer;
+  `ENV['OMNIZIP_PASSWORD']` backs `open`. Passwords are refused
+  loudly for zip/tar (no encryption support) instead of silently
+  producing unprotected archives.
+- `.zst` routing in the convenience API: `compress_file` to `.zst`
+  previously wrote a mislabeled ZIP; it now writes a real Zstandard
+  frame (validated against the system zstd CLI in both directions),
+  and `decompress_file` reads them.
+- Read-only RAR routing: `extract_archive`/`list_archive`/
+  `read_from_archive`/`Archive.open` operate on `.rar` files through
+  a new read-only `ArchiveHandlers::RarHandler`; creation keeps
+  raising truthfully. `resolve_archive_format` is now
+  operation-aware (`writing:`), so read operations no longer fail
+  with "cannot be written" errors.
+- `compress_file`/`compress_directory` forward compression options
+  (`algorithm:`, `level:`, ...) to the format writer instead of
+  silently dropping them (7z honors them; zip absorbs them —
+  per-entry ZIP compression is set through `Zip::OutputStream`).
+
+### Fixed
+- RAR5 metadata parsing: the file-header parser ignored the
+  optional ExtraAreaSize/DataSize vints, misaligning every field —
+  all RAR5 entries listed with size 0 (and one fixture failed to
+  parse at all). Field order now matches the RAR 5.0 specification
+  (verified against RARLAB fixtures); `compressed_size` is populated
+  from DataSize and the directory flag is the correct FileFlags bit
+  (0x0001). The main-header parser also reads the ArchiveFlags vint
+  it was skipping, so volume/solid detection works. Listing now
+  prefers the native parser (full metadata) over the external
+  `unrar vb` listing (names only, sizes hardcoded to 0).
+- `compress_directory` to a single-file stream extension (`.gz`,
+  `.lzma`, ...) silently wrote a ZIP under the foreign name; it now
+  raises `UnsupportedFormatError` explaining the mismatch.
+
+### Changed
+- Docs: every example across the guides now runs verbatim against
+  the real API. Fictional APIs removed or replaced
+  (`Omnizip::OutputStream`/`InputStream`, `compress_files`,
+  `train_dictionary`, `Archive#compression=` setters, `tar_bzip2`,
+  ZIP password attributes, `CorruptArchiveError`,
+  `UnsupportedEncryptionError`); fabricated parallel-processing and
+  benchmark sections rewritten as truthful process-level
+  parallelism; the zstandard guide now centers on the real
+  `.zst`/ZIP-entry/dictionary APIs (and no longer claims a native
+  zstd binding).
+
+## [0.3.36] - 2026-08-28
+
 ### Fixed
 - `add_to_archive`/`remove_from_archive` errors name the resolved
   format (`Format :seven_zip does not support adding entries`)
@@ -84,15 +214,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   been pinned to :copy) and replaced the match-encoding TODO with a
   wire-level round-trip verification of the distance-8/length
   pattern through the LZMA2 decoder. No code under lib/ changes.
-
-## [0.3.30] - 2026-08-27
-
-### Verified
-- LZIP interop with the real `lzip` CLI (1.26): our members pass
-  `lzip -t`/`-dc` and the CLI's members decode through
-  `Formats::Lzip` (spec skips where the CLI is absent).
-
-### Changed
 - The remaining lib/ TODO markers are resolved as documented design
   decisions rather than dangling work: RAR5 volume extras and
   EndHeader volume flags (no write-side reference exists;
@@ -106,6 +227,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   the salt/IV header, so archives it writes cannot be decrypted;
   encryption stays read-verified only.
 
+### Verified
+- LZIP interop with the real `lzip` CLI (1.26): our members pass
+  `lzip -t`/`-dc` and the CLI's members decode through
+  `Formats::Lzip` (spec skips where the CLI is absent).
+
 ## [0.3.28] - 2026-08-26
 
 ### Added

data/docs/getting-started/basic-usage.adoc

@@ -53,12 +53,8 @@ Omnizip.compress_directory('my_folder/', 'backup.zip')
 # Create 7z archive
 Omnizip.compress_directory('my_folder/', 'backup.7z', format: :seven_zip)
 
-# Add individual files
-Omnizip::Archive.create('custom.zip') do |archive|
-  archive.add_file('file1.txt')
-  archive.add_file('file2.txt')
-  archive.add_directory('folder/')
-end
+# Add individual files: compress one file per call
+Omnizip.compress_file('file1.txt', 'custom.zip')
 ----
 
 === Extracting Archives
@@ -70,10 +66,9 @@ require 'omnizip'
 # Extract entire archive
 Omnizip.extract_archive('backup.zip', 'output/')
 
-# Extract with pattern matching
-Omnizip::Archive.open('backup.zip') do |archive|
-  archive.extract_matching('*.txt', 'output/')
-end
+# Extract a single entry without a full extraction
+content = Omnizip.read_from_archive('backup.zip', 'notes.txt')
+File.write('output/notes.txt', content)
 ----
 
 === Reading Archive Contents
@@ -82,10 +77,10 @@ end
 ----
 require 'omnizip'
 
-# List all entries
-entries = Omnizip.list_archive('backup.zip')
-entries.each do |entry|
-  puts "#{entry.name}: #{entry.size} bytes"
+# List all entries (names); pass details: true for sizes
+Omnizip.list_archive('backup.zip').each { |name| puts name }
+Omnizip.list_archive('backup.zip', details: true).each do |entry|
+  puts "#{entry[:name]}: #{entry[:size]} bytes"
 end
 
 # Read specific file without extraction
@@ -187,13 +182,12 @@ end
 ----
 require 'omnizip'
 
-# Verify archive integrity
+# Verify archive integrity: reading the archive's central
+# directory raises FormatError when the archive is damaged.
 begin
-  Omnizip::Archive.open('archive.zip') do |archive|
-    archive.verify
-  end
+  Omnizip.list_archive('archive.zip')
   puts "Archive is valid"
-rescue Omnizip::CorruptArchiveError => e
+rescue Omnizip::FormatError => e
   puts "Archive is corrupted: #{e.message}"
 end
 ----
@@ -253,9 +247,7 @@ require 'tempfile'
 
 # Create temporary archive
 Tempfile.create(['backup', '.zip']) do |tmpfile|
-  Omnizip::Archive.create(tmpfile.path) do |archive|
-    archive.add_directory('data/')
-  end
+  Omnizip.compress_directory('data', tmpfile.path)
 
   # Use archive...
   puts "Temporary archive: #{tmpfile.path}"

data/docs/guides/advanced-features/encryption.adoc

@@ -12,7 +12,7 @@ Protect sensitive data in your archives with industry-standard AES-256 encryptio
 == Benefits
 
 * **Strong Security**: AES-256 encryption with secure key derivation
-* **Format Flexibility**: Encryption available in both ZIP and 7z formats
+* **Format**: Encryption available for 7z archives (ZIP encryption is unsupported)
 * **Header Protection**: Encrypt filenames and metadata (7z format)
 * **Password Validation**: Built-in password strength checking
 * **Compatibility**: Works with archives from other tools
@@ -44,40 +44,20 @@ end
 * Optional header encryption (hides filenames)
 * HMAC-SHA-256 authentication
 
-=== WinZip AES (ZIP Format)
+=== ZIP Encryption: not supported
 
-Industry-standard AES encryption for ZIP archives:
+Omnizip can neither create nor decrypt encrypted ZIP archives —
+neither WinZip AES nor traditional ZipCrypto. Encrypted 7z is the
+supported path; extract encrypted ZIPs with 7-Zip/unzip.
 
-[source,ruby]
-----
-# Create AES-encrypted ZIP
-Omnizip::Zip::File.open('secure.zip', create: true) do |zip|
-  zip.password = 'SecurePassword123'
-  zip.encryption = :winzip_aes  # AES-256
-  zip.add('private.doc', 'files/private.doc')
-end
-----
-
-**Features**:
-
-* AES-256, AES-192, or AES-128
-* Compatible with WinZip, 7-Zip, PeaZip
-* HMAC-SHA-1 authentication
-* Standard ZIP format
-
-=== Traditional ZIP Encryption
-
-[WARNING]
-Traditional ZIP encryption (ZipCrypto) is weak and should only be used for compatibility with legacy systems.
+The convenience API raises rather than silently ignoring a
+password for zip:
 
 [source,ruby]
 ----
-# Only for compatibility - NOT RECOMMENDED
-Omnizip::Zip::File.open('legacy.zip', create: true) do |zip|
-  zip.password = 'password'
-  zip.encryption = :traditional  # Weak encryption
-  zip.add('file.txt', 'data.txt')
-end
+Omnizip::Archive.create('secure.zip', password: 'x')
+# => Omnizip::UnsupportedFormatError:
+#    password is only supported for seven_zip; :zip has no encryption support
 ----
 
 == Decrypting Archives
@@ -91,10 +71,8 @@ Omnizip::Archive.open('secure.7z', password: 'MyStr0ngP@ssw0rd') do |archive|
   archive.extract_all('decrypted/')
 end
 
-# Decrypt ZIP archive
-Omnizip::Zip::File.open('secure.zip', password: 'SecurePassword123') do |zip|
-  zip.extract_all('output/')
-end
+# ZIP encryption: Omnizip can neither create nor decrypt
+# password-protected ZIP archives; extract them with 7-Zip/unzip
 ----
 
 === Password via Environment Variable
@@ -286,12 +264,11 @@ Some older archives may use unsupported encryption:
 [source,ruby]
 ----
 begin
-  Omnizip::Archive.open('old-archive.zip') do |archive|
-    # ...
+  Omnizip::Archive.open('old-archive.7z', password: 'wrong') do |archive|
+    archive.read('secret.txt')
   end
-rescue Omnizip::UnsupportedEncryptionError => e
-  puts "Encryption method not supported: #{e.message}"
-  puts "Try opening with 7-Zip or WinZip first"
+rescue Omnizip::FormatError => e
+  puts "Archive damaged or password wrong: #{e.message}"
 end
 ----
 

data/docs/guides/advanced-features/index.adoc

@@ -34,12 +34,22 @@ These features can be combined for maximum efficiency:
 
 [source,ruby]
 ----
-# Combine streaming + parallel + progress
-Omnizip.compress_directory('large_data/', 'backup.7z',
-  parallel: true,
-  threads: 8
-) do |progress|
-  puts "#{progress.percentage}% - #{progress.throughput_mb_s} MB/s"
+# Streaming writes + a progress tracker
+require 'omnizip/zip/output_stream'
+
+files = Dir.glob('large_data/**/*').select { |f| File.file?(f) }
+tracker = Omnizip::Progress.track(
+  total_files: files.size,
+  total_bytes: files.sum { |f| File.size(f) },
+  reporter: :console
+)
+
+Omnizip::Zip::OutputStream.open('backup.zip') do |stream|
+  files.each do |file|
+    stream.put_next_entry(file.delete_prefix('large_data/'))
+    stream.write(File.binread(file))
+    tracker.update(files: 1, bytes: File.size(file))
+  end
 end
 ----
 

data/docs/guides/advanced-features/parallel-processing.adoc

@@ -7,176 +7,94 @@ grand_parent: Guides
 
 == Purpose
 
-Parallel processing leverages multiple CPU cores to significantly speed up compression and extraction operations. This feature allows you to process large archives or multiple files simultaneously, reducing overall processing time.
+Omnizip's codecs are pure Ruby and single-threaded: a single archive
+is always compressed or extracted by one CPU core. To use multiple
+cores, run independent archive operations in parallel — across
+processes for CPU-bound compression, or across threads for
+I/O-bound extraction of separate archives.
 
-== Benefits
-
-* **2-3x Faster**: Achieve 2-3x speedup on multi-core systems
-* **Better Resource Utilization**: Use all available CPU cores effectively
-* **Reduced Wait Time**: Process large batches of files quickly
-* **Scalable**: Performance improves with more CPU cores
-
-== When to Use Parallel Processing
+== When It Helps
 
 [cols="1,3"]
 |===
-|Scenario |Parallel Benefit
-
-|Large Archives (>100 files)
-|Distribute file processing across cores
+|Scenario |Approach
 
-|Batch Operations
-|Process multiple archives simultaneously
+|Many archives to compress
+|One process per archive
 
-|Multi-core Servers
-|Maximize server resource utilization
+|Many archives to extract
+|One thread per archive (I/O releases the GVL)
 
-|Time-Critical Tasks
-|Reduce processing time for urgent operations
+|One large archive
+|No parallelism available; pick an appropriate +level:+
 |===
 
-== Parallel Compression
+== Parallel Compression (Processes)
 
-=== Compress Directory in Parallel
-
-Automatically distribute files across available cores:
+Compression is CPU-bound, so use processes — MRI's GVL prevents
+in-thread parallelism:
 
 [source,ruby]
 ----
-# Compress using all available cores
-Omnizip.compress_directory(
-  'large_project/',
-  'backup.zip',
-  parallel: true,
-  threads: 4  # Or omit to use all cores
-)
-----
-
-=== Custom Thread Count
+# Compress each directory in its own process
+dirs = %w[project_a project_b project_c]
 
-Control the number of parallel workers:
-
-[source,ruby]
-----
-# Use specific number of threads
-Omnizip::Archive.create('archive.7z', format: :seven_zip) do |archive|
-  archive.add_directory(
-    'data/',
-    parallel: true,
-    threads: 8,  # Use 8 worker threads
-    chunk_size: 1.megabyte  # Process 1MB chunks
-  )
+pids = dirs.map do |dir|
+  Process.fork do
+    Omnizip.compress_directory(dir, "#{dir}.7z", format: :seven_zip)
+  end
 end
+pids.each { |pid| Process.wait(pid) }
 ----
 
-== Parallel Extraction
-
-=== Extract Multiple Files Simultaneously
-
-Extract files in parallel for faster extraction:
-
-[source,ruby]
-----
-# Extract with parallel processing
-Omnizip.extract_archive(
-  'large-archive.zip',
-  'output/',
-  parallel: true,
-  threads: 4
-)
-----
-
-=== With Progress Tracking
-
-Combine parallel processing with progress monitoring:
+Or drive the CLI from your shell or job scheduler:
 
-[source,ruby]
+[source,bash]
 ----
-Omnizip.extract_archive('backup.zip', 'restored/') do |progress|
-  puts "Extracted #{progress.files_processed}/#{progress.total_files} files"
-  puts "Using #{progress.active_threads} parallel threads"
-  puts "Speed: #{progress.throughput_mb_s} MB/s"
-end
+ls -d project_*/ | xargs -P 8 -I{} omnizip archive create {}.7z {}
 ----
 
-== Performance Characteristics
-
-[cols="2,1,1,1,1"]
-|===
-|Workload |1 Thread |2 Threads |4 Threads |8 Threads
-
-|100 small files
-|10s
-|6s
-|4s
-|3s
-
-|10 large files
-|60s
-|35s
-|20s
-|15s
-
-|Mixed workload
-|30s
-|18s
-|12s
-|10s
-|===
-
-*Note: Performance varies based on CPU, disk speed, and file characteristics.*
+== Parallel Extraction (Threads)
 
-== Configuration Options
-
-=== Thread Count
-
-Control parallelism level:
+Extracting separate archives is I/O-bound, so threads work:
 
 [source,ruby]
 ----
-# Auto-detect (recommended)
-parallel: true
-
-# Specific thread count
-parallel: true, threads: 4
-
-# Match CPU cores
-parallel: true, threads: Etc.nprocessors
-----
-
-=== Chunk Size
+archives = Dir.glob('downloads/*.zip')
 
-Configure work distribution:
+threads = archives.map do |archive|
+  Thread.new do
+    Omnizip.extract_archive(
+      archive,
+      "extracted/#{File.basename(archive, '.zip')}/"
+    )
+  end
+end
 
-[source,ruby]
+threads.each(&:join)
 ----
-# Smaller chunks = better distribution, more overhead
-chunk_size: 512.kilobytes
-
-# Larger chunks = less overhead, less parallel benefit
-chunk_size: 10.megabytes
 
-# Default: 1MB (good balance)
-chunk_size: 1.megabyte
-----
+Note: a single archive's extraction still uses one thread.
 
 == Use Cases
 
 === Server Deployments
 
-Maximize server hardware utilization:
-
 [source,ruby]
 ----
-# Backup server with 16 cores
-Omnizip.compress_directory(
-  '/var/www/',
-  '/backups/www-backup.7z',
-  format: :seven_zip,
-  compression: :lzma2,
-  parallel: true,
-  threads: 16
-)
+# One process per site on a multi-core backup server
+sites = Dir.children('/var/www')
+
+pids = sites.map do |site|
+  Process.fork do
+    Omnizip.compress_directory(
+      File.join('/var/www', site),
+      "/backups/#{site}.7z",
+      format: :seven_zip, algorithm: :lzma2, level: 9
+    )
+  end
+end
+pids.each { |pid| Process.wait(pid) }
 ----
 
 === Batch Processing
@@ -204,43 +122,23 @@ end
 
 == Best Practices
 
-. **Match Thread Count to Cores**: Use `Etc.nprocessors` for optimal performance
-. **Consider Disk I/O**: More threads may not help with slow disks
-. **Monitor Memory**: Each thread uses additional memory
-. **Test Your Workload**: Measure actual speedup for your use case
-. **Combine with Streaming**: Use both for maximum efficiency
+. **One process per archive** for compression; threads only help I/O
+. **Consider disk I/O**: more parallelism may not help on slow disks
+. **Monitor memory**: each process/thread adds overhead
+. **Test your workload**: measure the real speedup
 
 == Limitations
 
-* Ruby GIL limits true parallelism (use JRuby for better results)
-* Memory usage increases with thread count
-* I/O-bound operations see less benefit
-* Very small files have overhead from thread management
+* No intra-archive parallelism: a single archive uses one core
+* MRI's GVL blocks in-thread CPU parallelism — use processes
+* Memory usage grows with process/thread count
 
 == Platform Considerations
 
-[cols="1,3"]
-|===
-|Platform |Notes
-
-|MRI Ruby
-|Limited by GIL, 2-3x speedup typical
-
-|JRuby
-|No GIL, better parallel scalability
-
-|TruffleRuby
-|Excellent parallel performance
-
-|Windows
-|Similar performance to Unix systems
-
-|Linux/macOS
-|Full parallel processing support
-|===
+`Process.fork` is unavailable on Windows — use `Process.spawn` with
+the +omnizip+ CLI there, or a job scheduler.
 
 == See Also
 
-* link:streaming.html[Streaming] - Combine for memory efficiency
-* link:progress-tracking.html[Progress Tracking] - Monitor parallel operations
-* link:../../compatibility.html[Compatibility] - Format support for parallel processing
+* link:streaming.html[Streaming] - Memory efficiency
+* link:../compression-algorithms/lzma2.html[LZMA2] - Default 7z algorithm