Copy PNPM patches to isolated directory

.claude/CLAUDE.md

@@ -64,12 +64,18 @@ by name.
 - `unpack-dependencies.ts` - Extracts packed tarballs to isolate directory
 - `process-build-output-files.ts` - Copies target package build output
 
+**patches/** - Handles PNPM patched dependencies:
+
+- `copy-patches.ts` - Copies relevant patch files from workspace root to isolate
+  directory, filtering based on target package dependencies
+
 ### Key Types (`src/lib/types.ts`)
 
 - `PackageManifest` - Extended pnpm package manifest type
 - `PackagesRegistry` - Maps package names to their paths and manifests
 - `WorkspacePackageInfo` - Package metadata (absoluteDir, rootRelativeDir,
   manifest)
+- `PatchFile` - Represents a patch file entry with path and hash
 
 ### Process Flow
 
@@ -79,8 +85,9 @@ by name.
 4. Recursively find all internal dependencies
 5. Pack and unpack internal dependencies to isolate directory
 6. Adapt manifests to use `file:` references
-7. Generate pruned lockfile for the isolated package
-8. Copy workspace config files (.npmrc, pnpm-workspace.yaml)
+7. Copy PNPM patched dependencies (if any exist)
+8. Generate pruned lockfile for the isolated package
+9. Copy workspace config files (.npmrc, pnpm-workspace.yaml)
 
 ## Path Alias
 
@@ -89,3 +96,8 @@ The codebase uses `~/` as path alias for `src/` (configured in tsconfig.json).
 ## Testing
 
 Tests use Vitest and are co-located with source files (`*.test.ts`).
+
+## Code Style
+
+- Use JSDoc style comments (`/** ... */`) for all comments, including
+  single-line comments

README.md

@@ -7,6 +7,7 @@
 - [Troubleshooting](#troubleshooting)
 - [Prerequisites](#prerequisites)
 - [Configuration Options](#configuration-options)
+- [PNPM Patched Dependencies](#pnpm-patched-dependencies)
 - [API](#api)
 - [The internal packages strategy](#the-internal-packages-strategy)
 - [Firebase](#firebase)
@@ -34,6 +35,7 @@ integrated, check out [mono-ts](https://github.com/0x80/mono-ts)
 - Optionally force output to use NPM with matching versions
 - Optionally include devDependencies in the isolated output
 - Optionally pick or omit scripts from the manifest
+- Automatically copies PNPM patched dependencies to the isolated output
 - Compatible with the Firebase tools CLI, including 1st and 2nd generation
   Firebase Functions. For more information see
   [the Firebase instructions](./docs/firebase.md).
@@ -325,6 +327,23 @@ services
 
 When you use the `targetPackagePath` option, this setting will be ignored.
 
+## PNPM Patched Dependencies
+
+If your workspace uses PNPM's [patched dependencies](https://pnpm.io/cli/patch)
+feature, `isolate` will automatically copy the relevant patch files to the
+isolated output.
+
+Patches are filtered based on the target package's dependencies:
+
+- Patches for production dependencies are always included
+- Patches for dev dependencies are only included when `includeDevDependencies`
+  is enabled
+- Patches for packages not in the target's dependency tree are excluded
+
+The patch files are copied to the isolated output, preserving their original
+directory structure. Both the `package.json` and `pnpm-lock.yaml` are updated
+with the correct paths.
+
 ## API
 
 Alternatively, `isolate` can be integrated in other programs by importing it as

package.json

@@ -1,6 +1,6 @@
 {
   "name": "isolate-package",
-  "version": "1.26.1",
+  "version": "1.27.0-2",
   "description": "Isolate a monorepo package with its shared dependencies to form a self-contained directory, compatible with Firebase deploy",
   "author": "Thijs Koerselman",
   "license": "MIT",

src/isolate.ts

@@ -22,6 +22,7 @@ import {
 } from "./lib/output";
 import { detectPackageManager, shouldUsePnpmPack } from "./lib/package-manager";
 import { getVersion } from "./lib/package-manager/helpers/infer-from-files";
+import { copyPatches } from "./lib/patches/copy-patches";
 import { createPackagesRegistry, listInternalPackages } from "./lib/registry";
 import type { PackageManifest } from "./lib/types";
 import {
@@ -199,6 +200,23 @@ export function createIsolator(config?: IsolateConfig) {
 
     await writeManifest(isolateDir, outputManifest);
 
+    /**
+     * Copy patch files before generating lockfile so the lockfile contains the
+     * correct paths. Only copy patches when output uses pnpm, since patched
+     * dependencies are a pnpm-specific feature.
+     */
+    const shouldCopyPatches =
+      packageManager.name === "pnpm" && !config.forceNpm;
+
+    const copiedPatches = shouldCopyPatches
+      ? await copyPatches({
+          workspaceRootDir,
+          targetPackageManifest: outputManifest,
+          isolateDir,
+          includeDevDependencies: config.includeDevDependencies,
+        })
+      : {};
+
     /** Generate an isolated lockfile based on the original one */
     const usedFallbackToNpm = await processLockfile({
       workspaceRootDir,
@@ -208,18 +226,44 @@ export function createIsolator(config?: IsolateConfig) {
       targetPackageDir,
       targetPackageName: targetPackageManifest.name,
       targetPackageManifest: outputManifest,
+      patchedDependencies:
+        Object.keys(copiedPatches).length > 0 ? copiedPatches : undefined,
       config,
     });
 
-    if (usedFallbackToNpm) {
-      /**
-       * When we fall back to NPM, we set the manifest package manager to the
-       * available NPM version.
-       */
+    const hasCopiedPatches = Object.keys(copiedPatches).length > 0;
+
+    /** Update manifest if patches were copied or npm fallback is needed */
+    if (hasCopiedPatches || usedFallbackToNpm) {
       const manifest = await readManifest(isolateDir);
 
-      const npmVersion = getVersion("npm");
-      manifest.packageManager = `npm@${npmVersion}`;
+      if (hasCopiedPatches) {
+        if (!manifest.pnpm) {
+          manifest.pnpm = {};
+        }
+        /**
+         * Extract just the paths for the manifest (lockfile needs full
+         * PatchFile)
+         */
+        manifest.pnpm.patchedDependencies = Object.fromEntries(
+          Object.entries(copiedPatches).map(([spec, patchFile]) => [
+            spec,
+            patchFile.path,
+          ])
+        );
+        log.debug(
+          `Added ${Object.keys(copiedPatches).length} patches to isolated package.json`
+        );
+      }
+
+      if (usedFallbackToNpm) {
+        /**
+         * When we fall back to NPM, we set the manifest package manager to the
+         * available NPM version.
+         */
+        const npmVersion = getVersion("npm");
+        manifest.packageManager = `npm@${npmVersion}`;
+      }
 
       await writeManifest(isolateDir, manifest);
     }
@@ -286,7 +330,7 @@ export function createIsolator(config?: IsolateConfig) {
   };
 }
 
-// Keep the original function for backward compatibility
+/** Keep the original function for backward compatibility */
 export async function isolate(config?: IsolateConfig): Promise<string> {
   return createIsolator(config)();
 }

src/lib/config.ts

@@ -7,7 +7,6 @@ import { inspectValue, readTypedJsonSync } from "./utils";
 export type IsolateConfigResolved = {
   buildDirName?: string;
   includeDevDependencies: boolean;
-  includePatchedDependencies: boolean;
   isolateDirName: string;
   logLevel: LogLevel;
   targetPackagePath?: string;
@@ -25,7 +24,6 @@ export type IsolateConfig = Partial<IsolateConfigResolved>;
 const configDefaults: IsolateConfigResolved = {
   buildDirName: undefined,
   includeDevDependencies: false,
-  includePatchedDependencies: false,
   isolateDirName: "isolate",
   logLevel: "info",
   targetPackagePath: undefined,

src/lib/lockfile/helpers/generate-pnpm-lockfile.ts

@@ -14,7 +14,7 @@ import { pruneLockfile as pruneLockfile_v8 } from "pnpm_prune_lockfile_v8";
 import { pruneLockfile as pruneLockfile_v9 } from "pnpm_prune_lockfile_v9";
 import { pick } from "remeda";
 import { useLogger } from "~/lib/logger";
-import type { PackageManifest, PackagesRegistry } from "~/lib/types";
+import type { PackageManifest, PackagesRegistry, PatchFile } from "~/lib/types";
 import { getErrorMessage, isRushWorkspace } from "~/lib/utils";
 import { pnpmMapImporter } from "./pnpm-map-importer";
 
@@ -27,7 +27,7 @@ export async function generatePnpmLockfile({
   targetPackageManifest,
   majorVersion,
   includeDevDependencies,
-  includePatchedDependencies,
+  patchedDependencies,
 }: {
   workspaceRootDir: string;
   targetPackageDir: string;
@@ -37,7 +37,8 @@ export async function generatePnpmLockfile({
   targetPackageManifest: PackageManifest;
   majorVersion: number;
   includeDevDependencies: boolean;
-  includePatchedDependencies: boolean;
+  /** Pre-computed patched dependencies with transformed paths from copyPatches */
+  patchedDependencies?: Record<string, PatchFile>;
 }) {
   /**
    * For now we will assume that the lockfile format might not change in the
@@ -132,7 +133,6 @@ export async function generatePnpmLockfile({
             ".",
             pnpmMapImporter(".", importer!, {
               includeDevDependencies,
-              includePatchedDependencies,
               directoryByPackageName,
             }),
           ];
@@ -143,8 +143,7 @@ export async function generatePnpmLockfile({
         return [
           importerId,
           pnpmMapImporter(importerId, importer!, {
-            includeDevDependencies: false, // Only include dev deps for target package
-            includePatchedDependencies,
+            includeDevDependencies: false,
             directoryByPackageName,
           }),
         ];
@@ -163,15 +162,10 @@ export async function generatePnpmLockfile({
     }
 
     /**
-     * Don't know how to map the patched dependencies yet, so we just include
-     * them but I don't think it would work like this. The important thing for
-     * now is that they are omitted by default, because that is the most common
-     * use case.
+     * Use pre-computed patched dependencies with transformed paths. The paths
+     * are already adapted by copyPatches to match the isolated directory
+     * structure (flattened to patches/ with collision avoidance).
      */
-    const patchedDependencies = includePatchedDependencies
-      ? lockfile.patchedDependencies
-      : undefined;
-
     if (useVersion9) {
       await writeWantedLockfile_v9(isolateDir, {
         ...prunedLockfile,

src/lib/lockfile/helpers/pnpm-map-importer.ts

@@ -16,7 +16,6 @@ export function pnpmMapImporter(
     directoryByPackageName,
   }: {
     includeDevDependencies: boolean;
-    includePatchedDependencies: boolean;
     directoryByPackageName: { [packageName: string]: string };
   }
 ): ProjectSnapshot {
@@ -50,7 +49,7 @@ function pnpmMapDependenciesLinks(
       return value;
     }
 
-    // Replace backslashes with forward slashes to support Windows Git Bash
+    /** Replace backslashes with forward slashes to support Windows Git Bash */
     const relativePath = path
       .relative(importerPath, got(directoryByPackageName, key))
       .replace(path.sep, path.posix.sep);

src/lib/lockfile/process-lockfile.ts

@@ -1,7 +1,7 @@
 import type { IsolateConfigResolved } from "../config";
 import { useLogger } from "../logger";
 import { usePackageManager } from "../package-manager";
-import type { PackageManifest, PackagesRegistry } from "../types";
+import type { PackageManifest, PackagesRegistry, PatchFile } from "../types";
 import {
   generateNpmLockfile,
   generatePnpmLockfile,
@@ -22,6 +22,7 @@ export async function processLockfile({
   internalDepPackageNames,
   targetPackageDir,
   targetPackageManifest,
+  patchedDependencies,
   config,
 }: {
   workspaceRootDir: string;
@@ -31,6 +32,8 @@ export async function processLockfile({
   targetPackageDir: string;
   targetPackageName: string;
   targetPackageManifest: PackageManifest;
+  /** Pre-computed patched dependencies with transformed paths from copyPatches */
+  patchedDependencies?: Record<string, PatchFile>;
   config: IsolateConfigResolved;
 }) {
   const log = useLogger();
@@ -89,7 +92,7 @@ export async function processLockfile({
         targetPackageManifest,
         majorVersion,
         includeDevDependencies: config.includeDevDependencies,
-        includePatchedDependencies: config.includePatchedDependencies,
+        patchedDependencies,
       });
       break;
     }