@monorepolint/rules 0.6.0-alpha.4 → 0.6.0-alpha.6

package/build/js/index.js

@@ -83,13 +83,12 @@ var alphabeticalScripts = createRuleFactory({
 });
 
 // src/bannedDependencies.ts
-import { matchesAnyGlob } from "@monorepolint/utils";
-import { AggregateTiming } from "@monorepolint/utils";
-import * as path2 from "node:path";
-import * as r from "runtypes";
+import { AggregateTiming, matchesAnyGlob } from "@monorepolint/utils";
+import * as path2 from "path";
+import { z } from "zod";
 
 // src/util/packageDependencyGraphService.ts
-import * as path from "node:path";
+import * as path from "path";
 import resolvePackagePath from "resolve-package-path";
 var PackageDependencyGraphService = class {
   /** Construct a graph of package dependencies and return the root node. */
@@ -154,27 +153,17 @@ var PackageDependencyGraphService = class {
 };
 
 // src/bannedDependencies.ts
-var bannedDepGlobsField = r.Union(
-  r.Array(r.String),
-  r.Record({
-    glob: r.Array(r.String).optional(),
-    exact: r.Array(r.String).optional()
+var bannedDepGlobsField = z.union([
+  z.array(z.string()),
+  z.object({
+    glob: z.array(z.string()).optional(),
+    exact: z.array(z.string()).optional()
   })
-);
-var Options = r.Union(
-  r.Record({
-    bannedDependencies: bannedDepGlobsField,
-    bannedTransitiveDependencies: r.Undefined.optional()
-  }),
-  r.Record({
-    bannedDependencies: bannedDepGlobsField.optional(),
-    bannedTransitiveDependencies: r.Array(r.String)
-  }),
-  r.Record({
-    bannedDependencies: bannedDepGlobsField.optional(),
-    bannedTransitiveDependencies: r.Array(r.String).optional()
-  })
-);
+]);
+var Options = z.object({
+  bannedDependencies: bannedDepGlobsField.optional(),
+  bannedTransitiveDependencies: z.array(z.string()).optional()
+});
 var setCache = /* @__PURE__ */ new Map();
 var aggregateTiming = new AggregateTiming(":bannedDependencies stats");
 var bannedDependencies = createRuleFactory({
@@ -225,7 +214,7 @@ var bannedDependencies = createRuleFactory({
     }
     aggregateTiming.stop();
   },
-  validateOptions: Options.check,
+  validateOptions: Options.parse,
   printStats: () => {
     aggregateTiming.printResults();
   }
@@ -272,10 +261,13 @@ function nameOrPackageJsonPath(node) {
 
 // src/consistentDependencies.ts
 import { diff as diff2 } from "jest-diff";
-import * as r2 from "runtypes";
-var Options2 = r2.Record({
-  ignoredDependencies: r2.Array(r2.String).Or(r2.Undefined)
-}).Or(r2.Undefined);
+import { z as z2 } from "zod";
+var Options2 = z2.union([
+  z2.undefined(),
+  z2.object({
+    ignoredDependencies: z2.array(z2.string())
+  })
+]);
 var skippedVersions = ["*", "latest"];
 var consistentDependencies = createRuleFactory({
   name: "consistentDependencies",
@@ -283,7 +275,7 @@ var consistentDependencies = createRuleFactory({
     checkDeps(context, args, "dependencies");
     checkDeps(context, args, "devDependencies");
   },
-  validateOptions: Options2.check
+  validateOptions: Options2.parse
 });
 function checkDeps(context, args, block) {
   const packageJson = context.getPackageJson();
@@ -333,15 +325,15 @@ function omit(obj, keysToOmit) {
 
 // src/consistentVersions.ts
 import { mutateJson } from "@monorepolint/utils";
-import * as r3 from "runtypes";
 import { coerce } from "semver";
-var Options3 = r3.Record({
-  matchDependencyVersions: r3.Dictionary(r3.Union(r3.String, r3.Array(r3.String)))
+import { z as z3 } from "zod";
+var Options3 = z3.object({
+  matchDependencyVersions: z3.record(z3.string(), z3.union([z3.string(), z3.array(z3.string())]))
 });
 var consistentVersions = createRuleFactory({
   name: "consistentVersions",
   check: checkConsistentVersions,
-  validateOptions: Options3.check
+  validateOptions: Options3.parse
 });
 function checkConsistentVersions(context, options) {
   for (const [dependencyPackageName, expectedPackageDependencyValue] of Object.entries(
@@ -362,48 +354,83 @@ function checkConsistentVersions(context, options) {
     }
   }
 }
+var shouldUpdateVersion = (actualValue, expectedValue, isProtocolVersionString, expectedSemVer) => {
+  if (isProtocolVersionString) {
+    return actualValue !== expectedValue;
+  }
+  const actualSemVer = coerce(actualValue);
+  return actualSemVer != null && actualSemVer.raw !== expectedSemVer.raw;
+};
+var matchesAnyVersion = (actualValue, protocolVersions, acceptedSemVerVersions) => {
+  if (protocolVersions.includes(actualValue)) {
+    return true;
+  }
+  const actualSemVer = coerce(actualValue);
+  if (actualSemVer == null) {
+    return false;
+  }
+  return acceptedSemVerVersions.some(
+    (acceptedSemVer) => actualSemVer.raw === acceptedSemVer.raw
+  );
+};
 var ensurePackageIsCorrectVersion = (context, dependencyPackageName, expectedPackageDependencyValue) => {
   const packageJson = context.getPackageJson();
   const packageJsonPath = context.getPackageJsonPath();
-  const expectedPackageDependencyVersion = coerce(
-    expectedPackageDependencyValue
-  );
-  if (expectedPackageDependencyVersion == null) {
-    throw new Error(
-      `Malformed expected package dependency version defined in monorepolint configuration: ${dependencyPackageName} @ '${expectedPackageDependencyValue}'`
-    );
+  const isProtocolVersion = expectedPackageDependencyValue.endsWith(":");
+  let expectedPackageDependencyVersion = null;
+  if (!isProtocolVersion) {
+    expectedPackageDependencyVersion = coerce(expectedPackageDependencyValue);
+    if (expectedPackageDependencyVersion == null) {
+      throw new Error(
+        `Malformed expected package dependency version defined in monorepolint configuration: ${dependencyPackageName} @ '${expectedPackageDependencyValue}'`
+      );
+    }
   }
   const actualPackageDependencyValue = packageJson.dependencies && packageJson.dependencies[dependencyPackageName];
-  const actualPackageDependencyVersion = coerce(actualPackageDependencyValue);
-  if (actualPackageDependencyVersion != null && actualPackageDependencyVersion.raw !== expectedPackageDependencyVersion.raw) {
-    context.addError({
-      file: packageJsonPath,
-      message: `Expected dependency on ${dependencyPackageName} to match version defined in monorepolint configuration '${expectedPackageDependencyValue}', got '${actualPackageDependencyValue}' instead.`,
-      fixer: () => mutateJson(packageJsonPath, context.host, (input) => {
-        input.dependencies[dependencyPackageName] = expectedPackageDependencyValue;
-        return input;
-      })
-    });
+  if (actualPackageDependencyValue != null) {
+    const shouldUpdate = shouldUpdateVersion(
+      actualPackageDependencyValue,
+      expectedPackageDependencyValue,
+      isProtocolVersion,
+      expectedPackageDependencyVersion
+    );
+    if (shouldUpdate) {
+      context.addError({
+        file: packageJsonPath,
+        message: `Expected dependency on ${dependencyPackageName} to match version defined in monorepolint configuration '${expectedPackageDependencyValue}', got '${actualPackageDependencyValue}' instead.`,
+        fixer: () => mutateJson(packageJsonPath, context.host, (input) => {
+          input.dependencies[dependencyPackageName] = expectedPackageDependencyValue;
+          return input;
+        })
+      });
+    }
   }
   const actualPackageDevDependencyValue = packageJson.devDependencies && packageJson.devDependencies[dependencyPackageName];
-  const actualPackageDevDependencyVersion = coerce(
-    actualPackageDevDependencyValue
-  );
-  if (actualPackageDevDependencyVersion != null && actualPackageDevDependencyVersion.raw !== expectedPackageDependencyVersion.raw) {
-    context.addError({
-      file: packageJsonPath,
-      message: `Expected devDependency on ${dependencyPackageName} to match version defined in monorepolint configuration '${expectedPackageDependencyValue}', got '${actualPackageDevDependencyValue}' instead`,
-      fixer: () => mutateJson(packageJsonPath, context.host, (input) => {
-        input.devDependencies[dependencyPackageName] = expectedPackageDependencyValue;
-        return input;
-      })
-    });
+  if (actualPackageDevDependencyValue != null) {
+    const shouldUpdateDev = shouldUpdateVersion(
+      actualPackageDevDependencyValue,
+      expectedPackageDependencyValue,
+      isProtocolVersion,
+      expectedPackageDependencyVersion
+    );
+    if (shouldUpdateDev) {
+      context.addError({
+        file: packageJsonPath,
+        message: `Expected devDependency on ${dependencyPackageName} to match version defined in monorepolint configuration '${expectedPackageDependencyValue}', got '${actualPackageDevDependencyValue}' instead`,
+        fixer: () => mutateJson(packageJsonPath, context.host, (input) => {
+          input.devDependencies[dependencyPackageName] = expectedPackageDependencyValue;
+          return input;
+        })
+      });
+    }
   }
 };
 var ensurePackageMatchesSomeVersion = (context, dependencyPackageName, acceptedPackageDependencyValues) => {
   const packageJson = context.getPackageJson();
   const packageJsonPath = context.getPackageJsonPath();
-  const acceptedPackageDependencyVersions = acceptedPackageDependencyValues.map(
+  const protocolVersions = acceptedPackageDependencyValues.filter((val) => val.endsWith(":"));
+  const regularVersions = acceptedPackageDependencyValues.filter((val) => !val.endsWith(":"));
+  const acceptedPackageDependencyVersions = regularVersions.map(
     (acceptedPackageDependencyValue) => {
       const acceptedPackageDependencyVersion = coerce(
         acceptedPackageDependencyValue
@@ -417,75 +444,101 @@ var ensurePackageMatchesSomeVersion = (context, dependencyPackageName, acceptedP
     }
   );
   const actualPackageDependencyValue = packageJson.dependencies && packageJson.dependencies[dependencyPackageName];
-  const actualPackageDependencyVersion = coerce(actualPackageDependencyValue);
-  if (actualPackageDependencyVersion != null && acceptedPackageDependencyVersions.every(
-    (acceptedPackageDependencyVersion) => actualPackageDependencyVersion.raw !== acceptedPackageDependencyVersion.raw
-  )) {
-    context.addError({
-      file: packageJsonPath,
-      message: `Expected dependency on ${dependencyPackageName} to match one of '${JSON.stringify(
-        acceptedPackageDependencyValues
-      )}', got '${actualPackageDependencyValue}' instead.`
-    });
+  if (actualPackageDependencyValue != null) {
+    const matches = matchesAnyVersion(
+      actualPackageDependencyValue,
+      protocolVersions,
+      acceptedPackageDependencyVersions
+    );
+    if (!matches) {
+      context.addError({
+        file: packageJsonPath,
+        message: `Expected dependency on ${dependencyPackageName} to match one of '${JSON.stringify(
+          acceptedPackageDependencyValues
+        )}', got '${actualPackageDependencyValue}' instead.`
+      });
+    }
   }
   const actualPackageDevDependencyValue = packageJson.devDependencies && packageJson.devDependencies[dependencyPackageName];
-  const actualPackageDevDependencyVersion = coerce(
-    actualPackageDevDependencyValue
-  );
-  if (actualPackageDevDependencyVersion != null && acceptedPackageDependencyVersions.every(
-    (acceptedPackageDependencyVersion) => actualPackageDevDependencyVersion.raw !== acceptedPackageDependencyVersion.raw
-  )) {
-    context.addError({
-      file: packageJsonPath,
-      message: `Expected devDependency on ${dependencyPackageName} to match one of '${JSON.stringify(
-        acceptedPackageDependencyValues
-      )}', got '${actualPackageDevDependencyValue}' instead.`
-    });
+  if (actualPackageDevDependencyValue != null) {
+    const matches = matchesAnyVersion(
+      actualPackageDevDependencyValue,
+      protocolVersions,
+      acceptedPackageDependencyVersions
+    );
+    if (!matches) {
+      context.addError({
+        file: packageJsonPath,
+        message: `Expected devDependency on ${dependencyPackageName} to match one of '${JSON.stringify(
+          acceptedPackageDependencyValues
+        )}', got '${actualPackageDevDependencyValue}' instead.`
+      });
+    }
   }
 };
 
 // src/fileContents.ts
 import { diff as diff3 } from "jest-diff";
 import * as path3 from "path";
-import * as r4 from "runtypes";
-var Options4 = r4.Union(
-  r4.Record({
-    file: r4.String,
-    generator: r4.Function.withGuard((x) => x != void 0),
-    template: r4.Undefined.optional(),
-    templateFile: r4.Undefined.optional()
+import { z as z5 } from "zod";
+
+// src/REMOVE.ts
+var REMOVE = Symbol.for("monorepolint/REMOVE");
+
+// src/util/zodSchemas.ts
+import { z as z4 } from "zod";
+var ZodRemove = z4.custom((x) => x === REMOVE);
+
+// src/fileContents.ts
+var Options4 = z5.union([
+  z5.object({
+    file: z5.string(),
+    generator: z5.custom((val) => {
+      return typeof val === "function";
+    }),
+    template: z5.undefined().optional(),
+    templateFile: z5.undefined().optional()
   }),
-  r4.Record({
-    file: r4.String,
-    generator: r4.Undefined.optional(),
-    template: r4.String.Or(r4.Undefined),
-    templateFile: r4.Undefined.optional()
+  z5.object({
+    file: z5.string(),
+    generator: z5.undefined().optional(),
+    template: z5.union([
+      z5.string(),
+      ZodRemove
+    ]),
+    templateFile: z5.undefined().optional()
   }),
-  r4.Record({
-    file: r4.String,
-    generator: r4.Undefined.optional(),
-    template: r4.Undefined.optional(),
-    templateFile: r4.String
+  z5.object({
+    file: z5.string(),
+    generator: z5.undefined().optional(),
+    template: z5.undefined().optional(),
+    templateFile: z5.string()
   })
-);
+]);
 var fileContents = createRuleFactory({
   name: "fileContents",
   check: async (context, opts) => {
     const fullPath = path3.join(context.packageDir, opts.file);
+    if (fullPath.includes("\0")) {
+      throw new Error(`Invalid file path: path contains null bytes`);
+    }
     const expectedContent = await getExpectedContents(context, opts);
+    if (expectedContent === Symbol.for("GENERATOR_ERROR")) {
+      return;
+    }
     const pathExists = context.host.exists(fullPath);
-    const actualContent = pathExists ? context.host.readFile(fullPath, { encoding: "utf-8" }) : void 0;
+    const actualContent = pathExists ? context.host.readFile(fullPath, { encoding: "utf-8" }) : REMOVE;
     if (actualContent !== expectedContent) {
-      const longMessage = pathExists && expectedContent == void 0 ? void 0 : diff3(expectedContent, actualContent, { expand: true });
-      const message = pathExists && expectedContent == void 0 ? "File should not exist" : "Expect file contents to match";
+      const longMessage = pathExists && (expectedContent === void 0 || expectedContent === REMOVE) ? void 0 : diff3(expectedContent, actualContent, { expand: true });
+      const message = pathExists && (expectedContent === void 0 || expectedContent === REMOVE) ? "File should not exist" : "Expect file contents to match";
       context.addError({
         file: fullPath,
         message,
         longMessage,
         fixer: () => {
-          if (expectedContent === void 0) {
+          if (expectedContent === REMOVE) {
             if (pathExists) context.host.deleteFile(fullPath);
-          } else {
+          } else if (expectedContent !== void 0 && typeof expectedContent === "string") {
             context.host.mkdir(path3.dirname(fullPath), { recursive: true });
             context.host.writeFile(fullPath, expectedContent, {
               encoding: "utf-8"
@@ -495,7 +548,7 @@ var fileContents = createRuleFactory({
       });
     }
   },
-  validateOptions: Options4.check
+  validateOptions: Options4.parse
 });
 var optionsCache = /* @__PURE__ */ new Map();
 async function getExpectedContents(context, opts) {
@@ -508,16 +561,35 @@ async function getExpectedContents(context, opts) {
   }
   if (opts.generator) {
     optionsCache.set(opts, opts.generator);
-    return opts.generator(context);
+    try {
+      const result = await opts.generator(context);
+      if (typeof result !== "string" && result !== REMOVE) {
+        throw new Error(`Generator function must return a string or REMOVE, got ${typeof result}`);
+      }
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const fullPath = path3.join(context.packageDir, opts.file);
+      context.addError({
+        file: fullPath,
+        message: `Generator function failed: ${errorMessage}`,
+        longMessage: `The generator function for file "${opts.file}" threw an error:
+
+${errorMessage}`
+      });
+      return Symbol.for("GENERATOR_ERROR");
+    }
   } else if (opts.templateFile) {
     const { packageDir: workspacePackageDir } = context.getWorkspaceContext();
     const fullPath = path3.resolve(workspacePackageDir, opts.templateFile);
     const template = context.host.readFile(fullPath, { encoding: "utf-8" });
     optionsCache.set(opts, template);
     return template;
-  } else {
+  } else if (opts.template !== void 0) {
     optionsCache.set(opts, opts.template);
     return opts.template;
+  } else {
+    throw new Error("Unable to get expected contents");
   }
 }
 
@@ -548,154 +620,20 @@ var forceError = createRuleFactory({
 
 // src/mustSatisfyPeerDependencies.ts
 import { mutateJson as mutateJson2 } from "@monorepolint/utils";
-import * as path4 from "node:path";
+import * as path4 from "path";
 import resolvePackagePath2 from "resolve-package-path";
-import * as r5 from "runtypes";
 import { coerce as coerce2 } from "semver";
-var Options5 = r5.Union(
-  r5.Partial({
-    skipUnparseableRanges: r5.Undefined,
-    dependencyWhitelist: r5.Undefined,
-    dependencyBlacklist: r5.Undefined,
-    enforceForDevDependencies: r5.Undefined
-  }),
-  r5.Record({
-    skipUnparseableRanges: r5.Boolean
-  }).And(
-    r5.Partial({
-      dependencyWhitelist: r5.Undefined,
-      dependencyBlacklist: r5.Undefined,
-      enforceForDevDependencies: r5.Undefined
-    })
-  ),
-  r5.Record({
-    dependencyWhitelist: r5.Array(r5.String)
-  }).And(
-    r5.Partial({
-      skipUnparseableRanges: r5.Undefined,
-      dependencyBlacklist: r5.Undefined,
-      enforceForDevDependencies: r5.Undefined
-    })
-  ),
-  r5.Record({
-    dependencyBlacklist: r5.Array(r5.String)
-  }).And(
-    r5.Partial({
-      skipUnparseableRanges: r5.Undefined,
-      dependencyWhitelist: r5.Undefined,
-      enforceForDevDependencies: r5.Undefined
-    })
-  ),
-  r5.Record({
-    enforceForDevDependencies: r5.Boolean
-  }).And(
-    r5.Partial({
-      skipUnparseableRanges: r5.Undefined,
-      dependencyWhitelist: r5.Undefined,
-      dependencyBlacklist: r5.Undefined
-    })
-  ),
-  r5.Record({
-    skipUnparseableRanges: r5.Boolean,
-    dependencyWhitelist: r5.Array(r5.String)
-  }).And(
-    r5.Partial({
-      dependencyBlacklist: r5.Undefined,
-      enforceForDevDependencies: r5.Undefined
-    })
-  ),
-  r5.Record({
-    skipUnparseableRanges: r5.Boolean,
-    dependencyBlacklist: r5.Array(r5.String)
-  }).And(
-    r5.Partial({
-      dependencyWhitelist: r5.Undefined,
-      enforceForDevDependencies: r5.Undefined
-    })
-  ),
-  r5.Record({
-    skipUnparseableRanges: r5.Boolean,
-    enforceForDevDependencies: r5.Boolean
-  }).And(
-    r5.Partial({
-      dependencyWhitelist: r5.Undefined,
-      dependencyBlacklist: r5.Undefined
-    })
-  ),
-  r5.Record({
-    dependencyWhitelist: r5.Array(r5.String),
-    dependencyBlacklist: r5.Array(r5.String)
-  }).And(
-    r5.Partial({
-      skipUnparseableRanges: r5.Undefined,
-      enforceForDevDependencies: r5.Undefined
-    })
-  ),
-  r5.Record({
-    dependencyWhitelist: r5.Array(r5.String),
-    enforceForDevDependencies: r5.Boolean
-  }).And(
-    r5.Partial({
-      skipUnparseableRanges: r5.Undefined,
-      dependencyBlacklist: r5.Undefined
-    })
-  ),
-  r5.Record({
-    dependencyBlacklist: r5.Array(r5.String),
-    enforceForDevDependencies: r5.Boolean
-  }).And(
-    r5.Partial({
-      skipUnparseableRanges: r5.Undefined,
-      dependencyWhitelist: r5.Undefined
-    })
-  ),
-  r5.Record({
-    skipUnparseableRanges: r5.Boolean,
-    dependencyWhitelist: r5.Array(r5.String),
-    dependencyBlacklist: r5.Array(r5.String)
-  }).And(
-    r5.Partial({
-      enforceForDevDependencies: r5.Undefined
-    })
-  ),
-  r5.Record({
-    skipUnparseableRanges: r5.Boolean,
-    dependencyWhitelist: r5.Array(r5.String),
-    enforceForDevDependencies: r5.Boolean
-  }).And(
-    r5.Partial({
-      dependencyBlacklist: r5.Undefined
-    })
-  ),
-  r5.Record({
-    skipUnparseableRanges: r5.Boolean,
-    dependencyBlacklist: r5.Array(r5.String),
-    enforceForDevDependencies: r5.Boolean
-  }).And(
-    r5.Partial({
-      dependencyWhitelist: r5.Undefined
-    })
-  ),
-  r5.Record({
-    dependencyWhitelist: r5.Array(r5.String),
-    dependencyBlacklist: r5.Array(r5.String),
-    enforceForDevDependencies: r5.Boolean
-  }).And(
-    r5.Partial({
-      skipUnparseableRanges: r5.Undefined
-    })
-  ),
-  r5.Record({
-    skipUnparseableRanges: r5.Boolean,
-    dependencyWhitelist: r5.Array(r5.String),
-    dependencyBlacklist: r5.Array(r5.String),
-    enforceForDevDependencies: r5.Boolean
-  })
-);
+import { z as z6 } from "zod";
+var Options5 = z6.object({
+  skipUnparseableRanges: z6.boolean().optional(),
+  dependencyWhitelist: z6.array(z6.string()).optional(),
+  dependencyBlacklist: z6.array(z6.string()).optional(),
+  enforceForDevDependencies: z6.boolean().optional()
+});
 var mustSatisfyPeerDependencies = createRuleFactory({
   name: "mustSatisfyPeerDependencies",
   check: checkSatisfyPeerDependencies,
-  validateOptions: Options5.check
+  validateOptions: Options5.parse
 });
 var MATCH_ANY_VERSION_RANGE = /^(\*|x)$/;
 var MATCH_GREATER_OR_EQUAL_VERSION_RANGE = /^>= ?\d+(?:\.\d+|\.\d+\.\d+(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?)?$/;
@@ -1051,9 +989,9 @@ function getAddDependencyTypeFixer({
 
 // src/nestedWorkspaces.ts
 import * as globby from "globby";
-import * as path5 from "node:path";
-import * as r6 from "runtypes";
-var Options6 = r6.Undefined;
+import * as path5 from "path";
+import { z as z7 } from "zod";
+var Options6 = z7.undefined();
 var nestedWorkspaces = createRuleFactory({
   name: "nestedWorkspaces",
   check: (context) => {
@@ -1086,14 +1024,14 @@ var nestedWorkspaces = createRuleFactory({
       });
     }
   },
-  validateOptions: Options6.check
+  validateOptions: Options6.parse
 });
 
 // src/oncePerPackage.ts
-import * as r7 from "runtypes";
-var Options7 = r7.Record({
-  singletonKey: r7.String.Or(r7.Symbol),
-  customMessage: r7.String.optional()
+import { z as z8 } from "zod";
+var Options7 = z8.object({
+  singletonKey: z8.union([z8.string(), z8.symbol()]),
+  customMessage: z8.string().optional()
 });
 var visitedMap = /* @__PURE__ */ new Map();
 var oncePerPackage = createRuleFactory({
@@ -1110,35 +1048,21 @@ var oncePerPackage = createRuleFactory({
       visited.add(context.getName());
     }
   },
-  validateOptions: Options7.assert
+  validateOptions: Options7.parse
 });
 
 // src/packageEntry.ts
 import { mutateJson as mutateJson3 } from "@monorepolint/utils";
 import { diff as diff4 } from "jest-diff";
-import * as r8 from "runtypes";
-var Options8 = r8.Union(
-  r8.Record({
-    entries: r8.Dictionary(r8.Unknown)
-    // string => unknown, enforces existence of keys and their values
-  }).And(
-    r8.Partial({
-      entriesExist: r8.Undefined
-    })
-  ),
-  r8.Record({
-    entriesExist: r8.Array(r8.String)
-    // enforces existence of keys, but not values
-  }).And(
-    r8.Partial({
-      entries: r8.Undefined
-    })
-  ),
-  r8.Record({
-    entries: r8.Dictionary(r8.Unknown),
-    // string => unknown, enforces existence of keys and their values
-    entriesExist: r8.Array(r8.String)
-  })
+import { z as z9 } from "zod";
+var Options8 = z9.object({
+  entries: z9.record(z9.string(), z9.union([z9.unknown(), ZodRemove])).optional(),
+  // string => unknown | REMOVE, enforces existence of keys and their values or removal
+  entriesExist: z9.array(z9.string()).optional()
+  // enforces existence of keys, but not values
+}).refine(
+  (data) => data.entries !== void 0 || data.entriesExist !== void 0,
+  { message: "At least one of 'entries' or 'entriesExist' must be provided" }
 );
 var packageEntry = createRuleFactory({
   name: "packageEntry",
@@ -1147,26 +1071,45 @@ var packageEntry = createRuleFactory({
     if (options.entries) {
       for (const key of Object.keys(options.entries)) {
         const value = options.entries[key];
-        const entryDiff = diff4(
-          JSON.stringify(value) + "\n",
-          (JSON.stringify(packageJson[key]) || "") + "\n"
-        );
-        if (typeof value !== "object" && value !== packageJson[key] || entryDiff == null || !entryDiff.includes("Compared values have no visual difference")) {
-          context.addError({
-            file: context.getPackageJsonPath(),
-            message: createStandardizedEntryErrorMessage(key),
-            longMessage: entryDiff,
-            fixer: () => {
-              mutateJson3(
-                context.getPackageJsonPath(),
-                context.host,
-                (input) => {
-                  input[key] = value;
-                  return input;
-                }
-              );
-            }
-          });
+        if (value === REMOVE) {
+          if (packageJson[key] !== void 0) {
+            context.addError({
+              file: context.getPackageJsonPath(),
+              message: createRemovalEntryErrorMessage(key),
+              fixer: () => {
+                mutateJson3(
+                  context.getPackageJsonPath(),
+                  context.host,
+                  (input) => {
+                    delete input[key];
+                    return input;
+                  }
+                );
+              }
+            });
+          }
+        } else {
+          const entryDiff = diff4(
+            JSON.stringify(value) + "\n",
+            (JSON.stringify(packageJson[key]) || "") + "\n"
+          );
+          if (typeof value !== "object" && value !== packageJson[key] || entryDiff == null || !entryDiff.includes("Compared values have no visual difference")) {
+            context.addError({
+              file: context.getPackageJsonPath(),
+              message: createStandardizedEntryErrorMessage(key),
+              longMessage: entryDiff,
+              fixer: () => {
+                mutateJson3(
+                  context.getPackageJsonPath(),
+                  context.host,
+                  (input) => {
+                    input[key] = value;
+                    return input;
+                  }
+                );
+              }
+            });
+          }
         }
       }
     }
@@ -1181,7 +1124,7 @@ var packageEntry = createRuleFactory({
       }
     }
   },
-  validateOptions: Options8.check
+  validateOptions: Options8.parse
 });
 function createStandardizedEntryErrorMessage(key) {
   return `Expected standardized entry for '${key}'`;
@@ -1189,13 +1132,28 @@ function createStandardizedEntryErrorMessage(key) {
 function createExpectedEntryErrorMessage(key) {
   return `Expected entry for '${key}' to exist`;
 }
+function createRemovalEntryErrorMessage(key) {
+  return `Entry '${key}' should be removed`;
+}
 
 // src/packageOrder.ts
 import { diff as diff5 } from "jest-diff";
-import * as r9 from "runtypes";
-var Options9 = r9.Record({
-  order: r9.Union(r9.Array(r9.String), r9.Function)
-}).Or(r9.Undefined);
+import { z as z10 } from "zod";
+var Options9 = z10.union([
+  z10.undefined(),
+  z10.object({
+    order: z10.union([
+      z10.array(z10.string()),
+      z10.function({
+        input: [z10.any()],
+        output: z10.function({
+          input: [z10.string(), z10.string()],
+          output: z10.number()
+        })
+      })
+    ])
+  })
+]);
 var defaultKeyOrder = [
   "name",
   "version",
@@ -1251,7 +1209,7 @@ var packageOrder = createRuleFactory({
       });
     }
   },
-  validateOptions: Options9.check
+  validateOptions: Options9.parse
 });
 function arrayOrderCompare2(a, b) {
   for (let index = 0; index < a.length; index++) {
@@ -1285,18 +1243,30 @@ function isOrderFunction(order) {
 // src/packageScript.ts
 import { mutateJson as mutateJson4 } from "@monorepolint/utils";
 import { diff as diff6 } from "jest-diff";
-import * as r10 from "runtypes";
-var Options10 = r10.Record({
-  scripts: r10.Dictionary(
-    r10.Union(
-      r10.String,
-      r10.Record({
-        options: r10.Array(r10.String.Or(r10.Undefined)),
-        fixValue: r10.Union(r10.String, r10.Undefined, r10.Literal(false)).optional()
+import { z as z11 } from "zod";
+var Options10 = z11.object({
+  scripts: z11.record(
+    z11.string(),
+    z11.union([
+      z11.string(),
+      ZodRemove,
+      // Allow direct REMOVE values like { "build": REMOVE }
+      z11.object({
+        options: z11.array(z11.union([
+          z11.string(),
+          z11.undefined(),
+          ZodRemove
+        ])),
+        fixValue: z11.union([
+          z11.string(),
+          z11.undefined(),
+          z11.literal(false),
+          ZodRemove
+        ]).optional()
       })
-    )
+    ])
   )
-  // string => string
+  // string => string | REMOVE | object
 });
 var MSG_NO_SCRIPTS_BLOCK = "No scripts block in package.json";
 var packageScript = createRuleFactory({
@@ -1325,30 +1295,58 @@ var packageScript = createRuleFactory({
       let fixValue;
       let allowEmpty = false;
       let fixToEmpty = false;
+      let fixToRemove = false;
       if (typeof value === "string") {
         allowedValues.add(value);
         fixValue = value;
+      } else if (value === REMOVE) {
+        allowedValues.add(REMOVE);
+        fixValue = REMOVE;
+        fixToRemove = true;
       } else {
         for (const q of value.options) {
           if (q === void 0) {
             allowEmpty = true;
+          } else if (q === REMOVE) {
+            allowEmpty = true;
           }
           allowedValues.add(q);
         }
         fixToEmpty = Object.prototype.hasOwnProperty.call(value, "fixValue") && value.fixValue === void 0;
+        fixToRemove = Object.prototype.hasOwnProperty.call(value, "fixValue") && value.fixValue === REMOVE;
         fixValue = value.fixValue;
       }
       const actualValue = packageJson.scripts[name];
+      if (value === REMOVE) {
+        if (actualValue !== void 0) {
+          const fixer = () => {
+            mutateJson4(
+              context.getPackageJsonPath(),
+              context.host,
+              (input) => {
+                delete input.scripts[name];
+                return input;
+              }
+            );
+          };
+          context.addError({
+            file: context.getPackageJsonPath(),
+            message: `Script '${name}' should be removed`,
+            fixer
+          });
+        }
+        continue;
+      }
       if (!allowedValues.has(actualValue) && !(allowEmpty === true && actualValue === void 0)) {
         let fixer;
-        if (fixValue !== false && (fixValue !== void 0 || fixToEmpty === true)) {
+        if (fixValue !== false && (fixValue !== void 0 || fixToEmpty === true || fixToRemove === true)) {
           const q = fixValue;
           fixer = () => {
             mutateJson4(
               context.getPackageJsonPath(),
               context.host,
               (input) => {
-                if (fixToEmpty && q === void 0) {
+                if (fixToEmpty && q === void 0 || fixToRemove && q === REMOVE) {
                   delete input.scripts[name];
                 } else {
                   input.scripts[name] = q;
@@ -1358,7 +1356,7 @@ var packageScript = createRuleFactory({
             );
           };
         }
-        const validOptionsString = Array.from(allowedValues.values()).map((a) => a === void 0 ? "(empty)" : `'${a}'`).join(", ");
+        const validOptionsString = Array.from(allowedValues.values()).map((a) => a === void 0 || a === REMOVE ? "(empty)" : `'${a}'`).join(", ");
         context.addError({
           file: context.getPackageJsonPath(),
           message: `Expected standardized script entry for '${name}'. Valid options: ${validOptionsString}`,
@@ -1371,19 +1369,43 @@ var packageScript = createRuleFactory({
       }
     }
   },
-  validateOptions: Options10.check
+  validateOptions: Options10.parse
 });
 
 // src/requireDependency.ts
 import { mutateJson as mutateJson5 } from "@monorepolint/utils";
 import { diff as diff7 } from "jest-diff";
-import * as r11 from "runtypes";
-var Options11 = r11.Partial({
-  dependencies: r11.Dictionary(r11.String.optional()),
-  devDependencies: r11.Dictionary(r11.String.optional()),
-  peerDependencies: r11.Dictionary(r11.String.optional()),
-  optionalDependencies: r11.Dictionary(r11.String.optional())
-});
+import { z as z12 } from "zod";
+var Options11 = z12.object({
+  dependencies: z12.record(
+    z12.string(),
+    z12.union([
+      z12.string(),
+      ZodRemove
+    ]).optional()
+  ).optional(),
+  devDependencies: z12.record(
+    z12.string(),
+    z12.union([
+      z12.string(),
+      ZodRemove
+    ]).optional()
+  ).optional(),
+  peerDependencies: z12.record(
+    z12.string(),
+    z12.union([
+      z12.string(),
+      ZodRemove
+    ]).optional()
+  ).optional(),
+  optionalDependencies: z12.record(
+    z12.string(),
+    z12.union([
+      z12.string(),
+      ZodRemove
+    ]).optional()
+  ).optional()
+}).partial();
 var requireDependency = createRuleFactory({
   name: "requireDependency",
   check: function expectPackageEntry(context, options) {
@@ -1395,27 +1417,33 @@ var requireDependency = createRuleFactory({
       "peerDependencies",
       "optionalDependencies"
     ].forEach((type) => {
-      var _a;
+      var _a, _b;
       const expectedEntries = options[type];
       if (!expectedEntries) {
         return;
       }
+      const dependenciesToAdd = Object.entries(expectedEntries).filter(
+        ([, version]) => version !== REMOVE && version !== void 0
+      );
+      const dependenciesToRemove = Object.entries(expectedEntries).filter(
+        ([, version]) => version === REMOVE
+      );
       if (packageJson[type] === void 0) {
-        context.addError({
-          file: packageJsonPath,
-          message: `No ${type} block, cannot add required ${type}.`,
-          fixer: () => {
-            mutateJson5(packageJsonPath, context.host, (input) => {
-              input[type] = Object.fromEntries(
-                Object.entries(expectedEntries).filter(([, v]) => v !== void 0)
-              );
-              return input;
-            });
-          }
-        });
+        if (dependenciesToAdd.length > 0) {
+          context.addError({
+            file: packageJsonPath,
+            message: `No ${type} block, cannot add required ${type}.`,
+            fixer: () => {
+              mutateJson5(packageJsonPath, context.host, (input) => {
+                input[type] = Object.fromEntries(dependenciesToAdd);
+                return input;
+              });
+            }
+          });
+        }
         return;
       }
-      for (const [dep, version] of Object.entries(options[type])) {
+      for (const [dep, version] of dependenciesToAdd) {
         if (((_a = packageJson[type]) == null ? void 0 : _a[dep]) !== version) {
           context.addError({
             file: packageJsonPath,
@@ -1431,12 +1459,26 @@ var requireDependency = createRuleFactory({
                 packageJsonPath,
                 context.host,
                 (input) => {
-                  if (version === void 0) {
-                    input[type] = { ...input[type] };
-                    delete input[type][dep];
-                  } else {
-                    input[type] = { ...input[type], [dep]: version };
-                  }
+                  input[type] = { ...input[type], [dep]: version };
+                  return input;
+                }
+              );
+            }
+          });
+        }
+      }
+      for (const [dep] of dependenciesToRemove) {
+        if (((_b = packageJson[type]) == null ? void 0 : _b[dep]) !== void 0) {
+          context.addError({
+            file: packageJsonPath,
+            message: `Dependency ${dep} should be removed`,
+            fixer: () => {
+              mutateJson5(
+                packageJsonPath,
+                context.host,
+                (input) => {
+                  input[type] = { ...input[type] };
+                  delete input[type][dep];
                   return input;
                 }
               );
@@ -1446,24 +1488,24 @@ var requireDependency = createRuleFactory({
       }
     });
   },
-  validateOptions: Options11.check
+  validateOptions: Options11.parse
 });
 
 // src/standardTsconfig.ts
 import { matchesAnyGlob as matchesAnyGlob2 } from "@monorepolint/utils";
 import { diff as diff8 } from "jest-diff";
 import * as path6 from "path";
-import * as r12 from "runtypes";
+import { z as z13 } from "zod";
 var DEFAULT_TSCONFIG_FILENAME = "tsconfig.json";
-var Options12 = r12.Partial({
-  file: r12.String,
-  generator: r12.Function,
-  tsconfigReferenceFile: r12.String,
-  template: r12.Record({}).Or(r12.String),
-  templateFile: r12.String,
-  excludedReferences: r12.Array(r12.String).Or(r12.Undefined),
-  additionalReferences: r12.Array(r12.String).Or(r12.Undefined)
-}).withConstraint(({ generator, template, templateFile }) => {
+var Options12 = z13.object({
+  file: z13.string().optional(),
+  generator: z13.custom().optional(),
+  tsconfigReferenceFile: z13.string().optional(),
+  template: z13.record(z13.string(), z13.unknown()).optional(),
+  templateFile: z13.string().optional(),
+  excludedReferences: z13.array(z13.string()).optional(),
+  additionalReferences: z13.array(z13.string()).optional()
+}).partial().refine(({ generator, template, templateFile }) => {
   let count = 0;
   if (generator) {
     count++;
@@ -1474,7 +1516,9 @@ var Options12 = r12.Partial({
   if (templateFile) {
     count++;
   }
-  return count === 1 || "Expect one of { generator, template, templateFile }";
+  return count === 1;
+}, {
+  message: "Expect one of { generator, template, templateFile }"
 });
 var standardTsconfig = createRuleFactory({
   name: "standardTsconfig",
@@ -1504,7 +1548,7 @@ var standardTsconfig = createRuleFactory({
       });
     }
   },
-  validateOptions: Options12.check
+  validateOptions: Options12.parse
 });
 function getGenerator(context, opts) {
   if (opts.generator) {
@@ -1564,6 +1608,7 @@ function makeGenerator(template, excludedReferences, additionalReferences, tscon
   };
 }
 export {
+  REMOVE,
   alphabeticalDependencies,
   alphabeticalScripts,
   bannedDependencies,