Walkthrough

This PR threads optional dist hints (unpacked size, file count) from resolvers and pnpr frames into prefetch and download plumbing, computes per-tarball download priority from those hints, replaces the install concurrency semaphore with a priority-aware semaphore, and adds TCP slow-start modeling to integrated benchmarks.

Changes

Download Prioritization and Metadata Propagation

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~60 minutes

Possibly related issues

• perf: port pnpm v11 HTTP/fetch topology and worker-pool sizing pacquet#280: Priority semaphore and priority-aware network concurrency changes touch the same network throttling code paths.

Possibly related PRs

• pnpm/pnpm#12237: Related changes to pnpr streaming install callback and prefetcher invocation.
• pnpm/pnpm#12163: Related upstream packument/trim_dist_fields edits affecting fileCount/unpackedSize.
• pnpm/pnpm#12251: Also touches the pnpr streaming install prefetch call site.

"A rabbit builds a semaphore so neat,
Size and files guide which fetch gets a seat;
Frames carry hints, verifiers keep score,
Prefetch queues smarter than before;
Slow-start hums and benchmarks beat. 🐇"

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

• X
• Mastodon
• Reddit
• LinkedIn

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

Description

With network_concurrency = 1, throughput_reserve becomes 1 (permits.div_ceil(2)), and
next_waiter() will always select a queued throughput waiter on every release when any downloads
are queued. This forces queued metadata requests to wait until the download queue drains, delaying
resolution progress under a supported configuration.

Code

pacquet/crates/network/src/priority_semaphore.rs[R120-192]

+    pub(crate) fn new(permits: usize) -> Self {
+        PrioritySemaphore {
+            state: Arc::new(Mutex::new(SemState {
+                free: permits,
+                latency_in_flight: 0,
+                throughput_in_flight: 0,
+                throughput_reserve: permits.div_ceil(2),
+                next_seq: 0,
+                latency_waiters: VecDeque::new(),
+                throughput_waiters: BinaryHeap::new(),
+            })),
+        }
+    }
+
+    /// Wait for a permit. Free permits are claimed immediately; when
+    /// the pool is saturated the caller queues in its class and is
+    /// woken per the grant policy in the module docs.
+    pub(crate) async fn acquire(&self, priority: u64) -> Permit {
+        let class = Class::of(priority);
+        let rx = {
+            let mut state = self.state.lock().expect("priority semaphore lock poisoned");
+            if state.free > 0 {
+                state.free -= 1;
+                *state.count_mut(class) += 1;
+                return Permit { state: Arc::clone(&self.state), class, armed: true };
+            }
+            let (tx, rx) = oneshot::channel();
+            let seq = state.next_seq;
+            state.next_seq += 1;
+            let waiter = Waiter { priority, seq, tx };
+            match class {
+                Class::Latency => state.latency_waiters.push_back(waiter),
+                Class::Throughput => state.throughput_waiters.push(waiter),
+            }
+            rx
+        };
+        rx.await.expect("priority semaphore state dropped while a permit was awaited")
+    }
+
+    #[cfg(test)]
+    pub(crate) fn queued_waiters(&self) -> usize {
+        let state = self.state.lock().expect("priority semaphore lock poisoned");
+        state.latency_waiters.len() + state.throughput_waiters.len()
+    }
+
+    #[cfg(test)]
+    pub(crate) fn available_permits(&self) -> usize {
+        self.state.lock().expect("priority semaphore lock poisoned").free
+    }
+}
+
+impl SemState {
+    fn count_mut(&mut self, class: Class) -> &mut usize {
+        match class {
+            Class::Latency => &mut self.latency_in_flight,
+            Class::Throughput => &mut self.throughput_in_flight,
+        }
+    }
+
+    /// Pop the waiter the grant policy picks next, or `None` when both
+    /// queues are empty: throughput work below its reserve goes first,
+    /// then queued latency work, then throughput work above the
+    /// reserve.
+    fn next_waiter(&mut self) -> Option<(Waiter, Class)> {
+        if self.throughput_in_flight < self.throughput_reserve
+            && let Some(waiter) = self.throughput_waiters.pop()
+        {
+            return Some((waiter, Class::Throughput));
+        }
+        if let Some(waiter) = self.latency_waiters.pop_front() {
+            return Some((waiter, Class::Latency));
+        }
+        self.throughput_waiters.pop().map(|waiter| (waiter, Class::Throughput))

Evidence

The semaphore reserves permits.div_ceil(2) for throughput, which equals 1 when permits=1. The
grant policy checks throughput_in_flight < throughput_reserve before considering latency waiters,
and because release decrements in-flight first, each freed permit in a 1-slot pool makes
throughput_in_flight 0 and thus always prefers queued throughput. Since pacquet only rejects
network_concurrency==0, a user-configured value of 1 is valid and exposed.

pacquet/crates/network/src/priority_semaphore.rs[119-193]
pacquet/crates/network/src/lib.rs[538-545]
pacquet/crates/config/src/lib.rs[896-903]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
When `network_concurrency` is configured to 1, the new two-class scheduling policy effectively becomes "downloads always win while any are queued" because the throughput reserve is computed as 1 and the grant rule checks `throughput_in_flight < throughput_reserve` after decrementing in-flight on release. This can delay metadata fetches behind downloads and slow/serialize resolution.
### Issue Context
- `network_concurrency` values >= 1 are allowed (only 0 is rejected).
- For `permits=1`, the current `throughput_reserve` math makes the reserve equal to the whole pool.
### Fix Focus Areas
- Ensure `permits=1` cannot reserve the entire pool for throughput (e.g., set `throughput_reserve = 0` when `permits == 1`, or compute reserve as `permits / 2` for small permit counts).
- Add a focused unit test for the `permits=1` case with both latency and throughput queued.
- file/path[start_line-end_line]
- pacquet/crates/network/src/priority_semaphore.rs[120-193]
- pacquet/crates/network/src/lib.rs[538-545]
- pacquet/crates/config/src/lib.rs[896-903]

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Description

SlowStart::effective_rate() applies the current cwnd-derived rate to the entire chunk and only
then grows cwnd, so a single chunk larger than cwnd is delayed as if it were all sent at the
smaller window. With the pump’s 32KiB read chunks and INITIAL_CWND_BYTES ≈14.6KiB, this skews
--registry-slow-start benchmark timings by adding extra ramp time that the module docs say should
be amortized as cwnd grows per delivered window.

Code

pacquet/tasks/integrated-benchmark/src/latency_proxy.rs[R245-256]

+    /// The rate (bytes/sec) at which the next `len`-byte chunk
+    /// serializes, advancing the window-growth bookkeeping.
+    fn effective_rate(&mut self, cap: f64, len: usize) -> f64 {
+        let rate = (self.cwnd / self.rtt_secs).min(cap);
+        self.bytes_in_round += len as f64;
+        if self.bytes_in_round >= self.cwnd {
+            self.bytes_in_round = 0.0;
+            // Stop growing once the window sustains the cap
+            // (`cap × RTT` is the bandwidth-delay product).
+            self.cwnd = (self.cwnd * 2.0).min((cap * self.rtt_secs).max(INITIAL_CWND_BYTES));
+        }
+        rate

Evidence

The module claims the rate should be cwnd ÷ RTT and cwnd “doubles per delivered window”, but the
writer computes delay for the full 32KiB chunk using a single effective_rate() call and only then
increments cwnd once, meaning bytes beyond the first window are still charged at the earlier
(too-low) rate.

pacquet/tasks/integrated-benchmark/src/latency_proxy.rs[46-54]
pacquet/tasks/integrated-benchmark/src/latency_proxy.rs[170-204]
pacquet/tasks/integrated-benchmark/src/latency_proxy.rs[219-256]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
The slow-start proxy models cwnd growth only after an entire read chunk is accounted for, but serialization delay for that chunk is computed using the pre-growth cwnd-derived rate. When the read chunk exceeds cwnd (default 32KiB > 14.6KiB), the proxy delays the full chunk at the slower initial rate, overstating slow-start cost vs the intended “double per delivered window” behavior.

## Issue Context
This impacts integrated benchmark fidelity (not production networking). The goal is to approximate that transfers ramp up toward the cap over successive windows/RTTs; the current implementation effectively treats each read chunk as a single window regardless of size.

## Fix Focus Areas
- pacquet/tasks/integrated-benchmark/src/latency_proxy.rs[167-258]

Suggested implementation directions:
- In `pump()`, when slow-start is enabled, either:
 - split `bytes` into sub-slices sized to the remaining cwnd in the current round, updating cwnd and accumulating the serialization delay piecewise, or
 - change the reader buffer size to be <= `INITIAL_CWND_BYTES` (or dynamically <= current cwnd) so one chunk never spans multiple windows.
- Update `SlowStart::effective_rate` (or introduce a `serialize_delay(len, cap) -> Duration`) to advance cwnd multiple times when `len` spans multiple windows, rather than a single `if bytes_in_round >= cwnd` step.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Description

The frozen-lockfile fast path builds a Vec<Vec<u8>> of pre-serialized frames and then
ndjson_frames() uses frames.concat(), allocating and copying the entire payload into a second
buffer. For large lockfiles (many package frames plus done), this creates avoidable CPU and
peak-memory overhead on the server.

Code

pnpr/crates/pnpr/src/resolver.rs[R529-537]

+/// A 200 NDJSON response carrying several already-serialized frames in
+/// one fixed body. Used by the frozen fast path, where every frame is
+/// known up front — no channel to stream from.
+fn ndjson_frames(frames: &[Vec<u8>]) -> Response {
+    Response::builder()
+        .status(StatusCode::OK)
+        .header(header::CONTENT_TYPE, NDJSON_CONTENT_TYPE)
+        .body(Body::from(frames.concat()))
+        .expect("binary response is always valid")

Evidence

The frozen fast path explicitly constructs a frames vector (potentially many entries) and then
builds the HTTP body via frames.concat(), which necessarily allocates and copies all bytes into a
new buffer.

pnpr/crates/pnpr/src/resolver.rs[244-257]
pnpr/crates/pnpr/src/resolver.rs[529-537]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`ndjson_frames()` currently materializes the full response body by calling `frames.concat()`, which allocates a new `Vec<u8>` and copies all per-frame bytes into it. Since the frozen path can produce one frame per tarball, this scales peak memory and adds an O(total_bytes) copy.

## Issue Context
The streaming path already uses `Body::from_stream(...)`. The frozen path is “known up front”, but it can still be emitted as a stream/iterator to avoid the extra aggregation copy.

## Fix Focus Areas
- pnpr/crates/pnpr/src/resolver.rs[244-257]
- pnpr/crates/pnpr/src/resolver.rs[529-552]

Suggested implementation directions:
- Replace `ndjson_frames(frames: &[Vec<u8>])` with a streaming body over an iterator (e.g., `stream::iter(frames.iter().cloned().map(Bytes::from))`) and `Body::from_stream`.
- Alternatively, if a fixed body is required, precompute total length and build a single `Vec<u8>` with `Vec::with_capacity(total)` + `extend_from_slice` to avoid `concat()`’s intermediate behavior.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Description

ThrottledClient::acquire_for_url() now always acquires permits at UNPRIORITIZED (latency class),
but the ZIP/binary archive download path still uses acquire_for_url, so those large transfers are
scheduled as latency work instead of throughput work. This can cause binary ZIP downloads to be
preferred over prioritized tarball downloads and to contend with metadata FIFO, reducing the
intended scheduling behavior under pool saturation.

Code

pacquet/crates/network/src/lib.rs[R354-358]

   /// just to satisfy the type signature — the lookup itself works
   /// on the raw string form.
   pub async fn acquire_for_url(&self, url: &str) -> ThrottledClientGuard<'_> {
-        let permit =
-            self.semaphore.acquire().await.expect("semaphore shouldn't have been closed this soon");
+        self.acquire_for_url_with_priority(url, UNPRIORITIZED).await
+    }

Evidence

The network crate documents UNPRIORITIZED as the latency-class marker and makes
acquire_for_url() default to that value; the ZIP/binary archive downloader still calls
acquire_for_url() before performing a full archive GET+extract, so it will be scheduled as
latency-class work under saturation.

pacquet/crates/network/src/lib.rs[42-49]
pacquet/crates/network/src/lib.rs[354-378]
pacquet/crates/tarball/src/lib.rs[2364-2414]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`ThrottledClient::acquire_for_url()` now always queues work at `UNPRIORITIZED` (latency class), but at least one non-metadata *download* path still uses it: the ZIP/binary archive fetch+extract code. This misclassifies those large downloads as latency-class work under the new two-class policy.
## Issue Context
- `UNPRIORITIZED` is explicitly documented as the latency-class sentinel meant for metadata/packument requests.
- The ZIP path does a full-body download and extraction, so it should be treated like throughput-class work (even if its priority is unknown/0).
## Fix Focus Areas
- pacquet/crates/tarball/src/lib.rs[2388-2414]
- pacquet/crates/network/src/lib.rs[42-49]
- pacquet/crates/network/src/lib.rs[354-378]
## Implementation notes
- Switch the ZIP download path to use `acquire_for_url_with_priority(package_url, <priority>)`.
- If you don’t have size/file hints for ZIPs, use `0` to place them in the throughput class without outranking sized tarballs, or derive a priority from `content-length` when available.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

🐞 Bugs (3) 📘 Rule violations (0) 📎 Requirement gaps (0)

🐞 Bugs (2) 📘 Rule violations (0) 📎 Requirement gaps (0)

• Add two-class priority scheduling to the shared network connection pool.
• Thread dist stats end-to-end to rank tarball downloads by pipeline work.
• Extend benchmark proxy with TCP slow-start modeling and fix macOS nonblocking sockets.

The following are alternative approaches to this PR:

Recommendation: The PR’s approach (custom, cancel-safe, class-aware PrioritySemaphore with a throughput reserve and FIFO latency queue) is a good tradeoff: it directly encodes the measured non-starvation requirement, remains work-conserving, and keeps the policy small enough to unit test thoroughly. The main review focus should be on permit release correctness under cancellation and on ensuring all metadata-gating paths consistently use UNPRIORITIZED.

install.rs Pass dist stats from pnpr frames into tarball prefetch +7/-1

Pass dist stats from pnpr frames into tarball prefetch

• Extends pnpr install flow to pass 'unpacked_size' and 'file_count' into the prefetcher so downloads can be prioritized and buffers sized using resolver-provided hints.

pacquet/crates/cli/src/cli_args/install.rs

---

install_config_deps.rs Initialize package file-count hint in materialization options +1/-0

Initialize package file-count hint in materialization options

• Adds 'package_file_count: None' to tarball download options wiring for env-installer materialization.

pacquet/crates/env-installer/src/install_config_deps.rs

---

lib.rs Replace Tokio Semaphore with class-aware PrioritySemaphore in ThrottledClient +48/-13

Replace Tokio Semaphore with class-aware PrioritySemaphore in ThrottledClient

• Introduces 'UNPRIORITIZED' for latency-class requests and swaps the concurrency limiter to a priority-ordered semaphore. Adds 'acquire_for_url_with_priority' for tarball downloads while keeping metadata calls on the latency path.

pacquet/crates/network/src/lib.rs

---

priority_semaphore.rs Add PrioritySemaphore with two-class, non-starving scheduling policy +238/-0

Add PrioritySemaphore with two-class, non-starving scheduling policy

• Implements a cancel-safe semaphore that schedules latency (FIFO) vs throughput (max-priority with FIFO tie-break) with a reserved throughput share. Permit drop hands off to the next waiter and skips cancelled waiters without leaking permits.

pacquet/crates/network/src/priority_semaphore.rs

---

build_resolution_verifiers.rs Plumb optional observed dist-stats sink into verifier construction +8/-1

Plumb optional observed dist-stats sink into verifier construction

• Extends 'build_resolution_verifiers' to accept an 'ObservedDistStats' sink so verifiers can record 'dist' work statistics as a side effect of verification.

pacquet/crates/package-manager/src/build_resolution_verifiers.rs

---

install_package_by_snapshot.rs Expose tarball URL derivation and add file-count field to download options +12/-2

Expose tarball URL derivation and add file-count field to download options

• Adds 'package_file_count: None' where download options are assembled. Makes 'tarball_url_and_integrity' public so the pnpr server can derive byte-identical tarball URLs for client cache key alignment.

pacquet/crates/package-manager/src/install_package_by_snapshot.rs

---

install_package_from_registry.rs Extract dist.fileCount and factor dist-field parsing helper +14/-5

Extract dist.fileCount and factor dist-field parsing helper

• Adds 'manifest_file_count' and a shared 'manifest_dist_field' helper to read 'dist' numeric hints. Threads 'file_count' into tarball download options alongside 'unpacked_size'.

pacquet/crates/package-manager/src/install_package_from_registry.rs

---

prefetching_resolver.rs Prefetch tarballs with both unpackedSize and fileCount hints +3/-1

Prefetch tarballs with both unpackedSize and fileCount hints

• Collects 'dist.fileCount' from resolver manifests and passes both size hints into the tarball download request configuration.

pacquet/crates/package-manager/src/prefetching_resolver.rs

---

resolution_observer.rs Include unpackedSize and fileCount in resolved tarball hints +14/-1

Include unpackedSize and fileCount in resolved tarball hints

• Extends 'ResolvedPackageHint' with optional 'unpacked_size' and 'file_count' parsed from the manifest so the fetch side can prioritize and preallocate accurately.

pacquet/crates/package-manager/src/resolution_observer.rs

---

tarball_prefetch.rs Carry fileCount through TarballPrefetcher and spawned downloads +17/-3

Carry fileCount through TarballPrefetcher and spawned downloads

• Extends 'TarballDownload' and 'TarballPrefetcher::prefetch' to include 'unpacked_size' and 'file_count', ensuring downstream tarball fetching has the inputs for priority and decompression sizing.

pacquet/crates/package-manager/src/tarball_prefetch.rs

---

lib.rs Parse optional unpackedSize/fileCount from pnpr package frames +34/-2

Parse optional unpackedSize/fileCount from pnpr package frames

• Extends the NDJSON 'package' frame schema and 'ResolvedPackage' to carry optional dist stats, defaulting to 'None' for older servers or missing registry fields.

pacquet/crates/pnpr-client/src/lib.rs

---

create_npm_resolution_verifier.rs Record dist stats during verification and preserve them in abbreviated metadata +50/-0

Record dist stats during verification and preserve them in abbreviated metadata

• Adds 'DistStats' and an 'ObservedDistStats' sink collected opportunistically during tarball URL binding checks. Updates abbreviated metadata projection to retain 'unpackedSize' and 'fileCount' per version when present.

pacquet/crates/resolving-npm-resolver/src/create_npm_resolution_verifier.rs

---

lookup_context.rs Extend abbreviated metadata projection with per-version dist stats +9/-0

Extend abbreviated metadata projection with per-version dist stats

• Adds 'version_dist_stats' to the abbreviated metadata projection so the verifier can surface work estimates without additional metadata fetches.

pacquet/crates/resolving-npm-resolver/src/lookup_context.rs

---

lib.rs Prioritize tarball acquires by estimated pipeline work (unpackedSize + K×fileCount) +45/-8

Prioritize tarball acquires by estimated pipeline work (unpackedSize + K×fileCount)

• Adds 'package_file_count', computes 'download_priority', and acquires network permits via 'acquire_for_url_with_priority' to start the most expensive tarballs first. Marks resolver-gating tarball-manifest fetches as 'UNPRIORITIZED' so they don't queue behind downloads.

pacquet/crates/tarball/src/lib.rs

---

latency_proxy.rs Simulate TCP slow start and fix macOS accepted-socket nonblocking inheritance +63/-1

Simulate TCP slow start and fix macOS accepted-socket nonblocking inheritance

• Adds optional slow-start rate ramping per connection to the proxy’s throughput cap logic. Ensures accepted sockets are set back to blocking mode to avoid 'WouldBlock' read failures on macOS/BSD.

pacquet/tasks/integrated-benchmark/src/latency_proxy.rs

---

resolver.rs Stream dist stats in package frames and announce sized tarballs for verified frozen lockfiles +127/-27

Stream dist stats in package frames and announce sized tarballs for verified frozen lockfiles

• Adds 'unpackedSize'/'fileCount' to streamed 'package' frames (omitted when unknown for compatibility). On verified frozen-lockfile fast path, emits deduplicated package frames with sizes derived from verifier-collected dist stats before the final 'done' frame.

pnpr/crates/pnpr/src/resolver.rs

---

upstream.rs Preserve dist.unpackedSize and dist.fileCount in abbreviated packuments +6/-7

Preserve dist.unpackedSize and dist.fileCount in abbreviated packuments

• Stops stripping 'unpackedSize' and 'fileCount' from abbreviated metadata so downstream components (pacquet) can use the hints for buffer sizing and download scheduling.

pnpr/crates/pnpr/src/upstream.rs

---

install.rs Pass no dist-stats sink for non-pnpr install path +1/-0

Pass no dist-stats sink for non-pnpr install path

• Updates the standard install path to pass 'None' for 'observed_dist_stats', limiting collection to call sites that need it (e.g., pnpr verification).

pacquet/crates/package-manager/src/install.rs

---

lib.rs Re-export dist-stats types and sink constructor +2/-1

Re-export dist-stats types and sink constructor

• Exports 'DistStats', 'ObservedDistStats', and 'observed_dist_stats_sink' for upstream consumers (pnpr server and package-manager wiring).

pacquet/crates/resolving-npm-resolver/src/lib.rs

---

tests.rs Unit tests for priority ordering, FIFO ties, cancellation, and reserve policy +148/-0

Unit tests for priority ordering, FIFO ties, cancellation, and reserve policy

• Adds coverage for priority ordering, equal-priority FIFO behavior, cancellation handoff correctness, and the throughput-reserve vs metadata preference rules.

pacquet/crates/network/src/priority_semaphore/tests.rs

---

tests.rs Test pnpr package-frame parsing with and without dist stats +18/-2

Test pnpr package-frame parsing with and without dist stats

• Updates the package-frame parsing test to include the new fields and adds a compatibility test ensuring frames without dist stats still parse cleanly.

pacquet/crates/pnpr-client/src/tests.rs

---

tests.rs Test that verifier binding check records dist stats into sink +58/-1

Test that verifier binding check records dist stats into sink

• Adds a tokio test that mocks a registry response with dist stats and asserts the sink receives the correct '(name, version) -> DistStats' entry after verification.

pacquet/crates/resolving-npm-resolver/src/create_npm_resolution_verifier/tests.rs

---

tests.rs Update tarball tests for fileCount and explicit download priority argument +30/-0

Update tarball tests for fileCount and explicit download priority argument

• Adjusts test struct initializers and helper calls for the new 'package_file_count' field and the additional 'download_priority' parameter in internal fetch helpers.

pacquet/crates/tarball/src/tests.rs

---

tests.rs Extend proxy tests for slow-start behavior and new profile field +57/-3

Extend proxy tests for slow-start behavior and new profile field

• Updates existing tests to include the new 'slow_start' field and adds a test asserting slow start increases transfer time vs a flat-rate cap.

pacquet/tasks/integrated-benchmark/src/latency_proxy/tests.rs

---

tests.rs Test package-frame dist stat omission and frozen lockfile tarball announcements +74/-0

Test package-frame dist stat omission and frozen lockfile tarball announcements

• Adds tests verifying sized vs unsized package frame serialization and that frozen verified lockfile emits tarball frames with sizes and skips non-tarball resolutions.

pnpr/crates/pnpr/src/resolver/tests.rs

---

tests.rs Update abbreviation tests to expect size-hint fields preserved +5/-4

Update abbreviation tests to expect size-hint fields preserved

• Adjusts upstream abbreviation test expectations to keep 'fileCount' and 'unpackedSize' while still dropping legacy 'npm-signature' and 'shasum' when appropriate.

pnpr/crates/pnpr/src/upstream/tests.rs

---

cli_args.rs Add benchmark flag to enable per-connection TCP slow-start simulation +10/-0

Add benchmark flag to enable per-connection TCP slow-start simulation

• Introduces '--registry-slow-start' to model TCP ramp-up behavior when bandwidth caps and latency are configured.

pacquet/tasks/integrated-benchmark/src/cli_args.rs

---

main.rs Wire registry slow-start CLI flag into proxy link profile +3/-0

Wire registry slow-start CLI flag into proxy link profile

• Threads 'registry_slow_start' from CLI args into the registry proxy’s 'LinkProfile' and into the constructed 'WorkEnv'.

pacquet/tasks/integrated-benchmark/src/main.rs

---

work_env.rs Persist slow-start setting and apply it to registry proxy spawning +4/-0

Persist slow-start setting and apply it to registry proxy spawning

• Adds 'registry_slow_start' to 'WorkEnv' and uses it when constructing the registry proxy profile; other proxies explicitly disable slow start.

pacquet/tasks/integrated-benchmark/src/work_env.rs

---

main.rs Update micro-benchmark tarball download options for fileCount +1/-0

Update micro-benchmark tarball download options for fileCount

• Extends benchmark setup to include 'package_file_count: None' in 'DownloadTarballToStore' initialization.

pacquet/tasks/micro-benchmark/src/main.rs

---