@williamthorsen/nmr 0.55.0 → 1.0.0

package/.readyup/kits/default.js

@@ -117,17 +117,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path7) {
-      const ctrl = callVisitor(key, node, visitor, path7);
+    function visit_(key, node, visitor, path9) {
+      const ctrl = callVisitor(key, node, visitor, path9);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path7, ctrl);
-        return visit_(key, ctrl, visitor, path7);
+        replaceNode(key, path9, ctrl);
+        return visit_(key, ctrl, visitor, path9);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path7 = Object.freeze(path7.concat(node));
+          path9 = Object.freeze(path9.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path7);
+            const ci = visit_(i, node.items[i], visitor, path9);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -138,13 +138,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path7 = Object.freeze(path7.concat(node));
-          const ck = visit_("key", node.key, visitor, path7);
+          path9 = Object.freeze(path9.concat(node));
+          const ck = visit_("key", node.key, visitor, path9);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path7);
+          const cv = visit_("value", node.value, visitor, path9);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -165,17 +165,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path7) {
-      const ctrl = await callVisitor(key, node, visitor, path7);
+    async function visitAsync_(key, node, visitor, path9) {
+      const ctrl = await callVisitor(key, node, visitor, path9);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path7, ctrl);
-        return visitAsync_(key, ctrl, visitor, path7);
+        replaceNode(key, path9, ctrl);
+        return visitAsync_(key, ctrl, visitor, path9);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path7 = Object.freeze(path7.concat(node));
+          path9 = Object.freeze(path9.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path7);
+            const ci = await visitAsync_(i, node.items[i], visitor, path9);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -186,13 +186,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path7 = Object.freeze(path7.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path7);
+          path9 = Object.freeze(path9.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path9);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path7);
+          const cv = await visitAsync_("value", node.value, visitor, path9);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -219,23 +219,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path7) {
+    function callVisitor(key, node, visitor, path9) {
       if (typeof visitor === "function")
-        return visitor(key, node, path7);
+        return visitor(key, node, path9);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path7);
+        return visitor.Map?.(key, node, path9);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path7);
+        return visitor.Seq?.(key, node, path9);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path7);
+        return visitor.Pair?.(key, node, path9);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path7);
+        return visitor.Scalar?.(key, node, path9);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path7);
+        return visitor.Alias?.(key, node, path9);
       return void 0;
     }
-    function replaceNode(key, path7, node) {
-      const parent = path7[path7.length - 1];
+    function replaceNode(key, path9, node) {
+      const parent = path9[path9.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -847,10 +847,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path7, value) {
+    function collectionFromPath(schema, path9, value) {
       let v = value;
-      for (let i = path7.length - 1; i >= 0; --i) {
-        const k = path7[i];
+      for (let i = path9.length - 1; i >= 0; --i) {
+        const k = path9[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -869,7 +869,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path7) => path7 == null || typeof path7 === "object" && !!path7[Symbol.iterator]().next().done;
+    var isEmptyPath = (path9) => path9 == null || typeof path9 === "object" && !!path9[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -899,11 +899,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path7, value) {
-        if (isEmptyPath(path7))
+      addIn(path9, value) {
+        if (isEmptyPath(path9))
           this.add(value);
         else {
-          const [key, ...rest] = path7;
+          const [key, ...rest] = path9;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -917,8 +917,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path7) {
-        const [key, ...rest] = path7;
+      deleteIn(path9) {
+        const [key, ...rest] = path9;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -932,8 +932,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path7, keepScalar) {
-        const [key, ...rest] = path7;
+      getIn(path9, keepScalar) {
+        const [key, ...rest] = path9;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -951,8 +951,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path7) {
-        const [key, ...rest] = path7;
+      hasIn(path9) {
+        const [key, ...rest] = path9;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -962,8 +962,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path7, value) {
-        const [key, ...rest] = path7;
+      setIn(path9, value) {
+        const [key, ...rest] = path9;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -3478,9 +3478,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path7, value) {
+      addIn(path9, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path7, value);
+          this.contents.addIn(path9, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -3555,14 +3555,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path7) {
-        if (Collection.isEmptyPath(path7)) {
+      deleteIn(path9) {
+        if (Collection.isEmptyPath(path9)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path7) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path9) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -3577,10 +3577,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path7, keepScalar) {
-        if (Collection.isEmptyPath(path7))
+      getIn(path9, keepScalar) {
+        if (Collection.isEmptyPath(path9))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path7, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path9, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -3591,10 +3591,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path7) {
-        if (Collection.isEmptyPath(path7))
+      hasIn(path9) {
+        if (Collection.isEmptyPath(path9))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path7) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path9) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -3611,13 +3611,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path7, value) {
-        if (Collection.isEmptyPath(path7)) {
+      setIn(path9, value) {
+        if (Collection.isEmptyPath(path9)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path7), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path9), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path7, value);
+          this.contents.setIn(path9, value);
         }
       }
       /**
@@ -5578,9 +5578,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path7) => {
+    visit.itemAtPath = (cst, path9) => {
       let item = cst;
-      for (const [field, index] of path7) {
+      for (const [field, index] of path9) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -5589,23 +5589,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path7) => {
-      const parent = visit.itemAtPath(cst, path7.slice(0, -1));
-      const field = path7[path7.length - 1][0];
+    visit.parentCollection = (cst, path9) => {
+      const parent = visit.itemAtPath(cst, path9.slice(0, -1));
+      const field = path9[path9.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path7, item, visitor) {
-      let ctrl = visitor(item, path7);
+    function _visit(path9, item, visitor) {
+      let ctrl = visitor(item, path9);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path7.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path9.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5616,10 +5616,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path7);
+            ctrl = ctrl(item, path9);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path7) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path9) : ctrl;
     }
     exports.visit = visit;
   }
@@ -7416,11 +7416,11 @@ function discoverWorkspacesOrFailure(filter) {
   }
 }
 function findFiles(patterns, cwd) {
-  return globSync(patterns, { cwd, exclude: (path7) => SCAN_EXCLUDE_DIRS.has(basename(path7)) }).map((path7) => path7.split(sep).join("/")).toSorted();
+  return globSync(patterns, { cwd, exclude: (path9) => SCAN_EXCLUDE_DIRS.has(basename(path9)) }).map((path9) => path9.split(sep).join("/")).toSorted();
 }
 function formatPaths(paths) {
   return `${paths.length} found:
-${paths.map((path7) => `      ${path7}`).join("\n")}`;
+${paths.map((path9) => `      ${path9}`).join("\n")}`;
 }
 function importsSharedExport(content, exportName, moduleSpecifier) {
   if (content === void 0) return false;
@@ -7518,7 +7518,7 @@ function readWrapperTarget(cwd, workspace, entry) {
 // .readyup/lib/root-scripts.ts
 import { existsSync as existsSync2, readdirSync } from "node:fs";
 import { join as join2 } from "node:path";
-import { fileExists, isRecord as isRecord2, readFile as readFile2, readPackageJson } from "readyup/check-utils";
+import { fileExists, isRecord as isRecord3, readFile as readFile2, readPackageJson } from "readyup/check-utils";
 
 // src/shell-syntax.ts
 var ENV_ASSIGNMENT = /^\w+=/;
@@ -7725,12 +7725,17 @@ function buildRootScripts(workspaceGlobs) {
   };
 }
 
-// ../nmr-core/dist/esm/workspace.js
+// ../nmr-core/dist/esm/workspace/workspace.js
 import { existsSync, readFileSync } from "node:fs";
 import path2 from "node:path";
 var import_yaml = __toESM(require_dist(), 1);
 
-// ../nmr-core/dist/esm/helpers/workspace-patterns.js
+// ../nmr-core/dist/esm/portable/isRecord.js
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../nmr-core/dist/esm/workspace/workspace-patterns.js
 import { globSync as globSync2 } from "node:fs";
 import path from "node:path";
 var MANIFEST_FILENAME = "package.json";
@@ -7768,7 +7773,7 @@ function buildManifestPattern(pattern) {
   return `${pattern.replace(/\/?$/, "")}/${MANIFEST_FILENAME}`;
 }
 
-// ../nmr-core/dist/esm/workspace.js
+// ../nmr-core/dist/esm/workspace/workspace.js
 var WORKSPACE_MANIFEST_FILENAME = "pnpm-workspace.yaml";
 function isMonorepoRoot(dir) {
   return existsSync(path2.join(dir, WORKSPACE_MANIFEST_FILENAME));
@@ -7804,7 +7809,7 @@ function diagnoseEmptyCause(monorepoRoot, patterns) {
   return "no-package";
 }
 function readDeclaredPackages(parsedManifest) {
-  if (!isObject(parsedManifest))
+  if (!isRecord2(parsedManifest))
     return { kind: "absent" };
   const packages = parsedManifest["packages"];
   if (packages === void 0 || packages === null)
@@ -7815,9 +7820,6 @@ function readDeclaredPackages(parsedManifest) {
     return { kind: "unreadable" };
   return packages.length === 0 ? { kind: "absent" } : { kind: "patterns", patterns: packages };
 }
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function readWorkspaceManifest(monorepoRoot) {
   const workspaceManifestPath = path2.join(monorepoRoot, WORKSPACE_MANIFEST_FILENAME);
   if (!existsSync(workspaceManifestPath)) {
@@ -7830,12 +7832,12 @@ function readWorkspaceManifest(monorepoRoot) {
   }
 }
 
-// ../nmr-core/dist/esm/hasErrnoCode.js
+// ../nmr-core/dist/esm/errors/hasErrnoCode.js
 function hasErrnoCode(error, code) {
   return isError(error) && "code" in error && error.code === code;
 }
 
-// ../nmr-core/dist/esm/UserError.js
+// ../nmr-core/dist/esm/errors/UserError.js
 var UserError = class extends Error {
   constructor(message, options) {
     super(message, options);
@@ -7843,6 +7845,32 @@ var UserError = class extends Error {
   }
 };
 
+// ../nmr-core/dist/esm/git/gitOutputLimit.js
+var GIT_OUTPUT_LIMIT_BYTES = 64 * 1024 * 1024;
+
+// ../nmr-core/dist/esm/git/runGit.js
+import { spawnSync } from "node:child_process";
+function runGit(args, cwd, input, env) {
+  const result = runGitForBytes(args, cwd, input === void 0 ? void 0 : Buffer.from(input, "utf8"), env);
+  return result.ok ? { ok: true, stdout: result.stdout.toString("utf8") } : result;
+}
+function runGitForBytes(args, cwd, input, env) {
+  const result = spawnSync("git", args, {
+    cwd,
+    env: { ...env ?? process.env, GIT_OPTIONAL_LOCKS: "0" },
+    input,
+    maxBuffer: GIT_OUTPUT_LIMIT_BYTES
+  });
+  if (result.error) {
+    return { ok: false, error: result.error.message };
+  }
+  if (result.status !== 0) {
+    const stderr = result.stderr.toString("utf8").trim();
+    return { ok: false, error: stderr || `\`git ${args.join(" ")}\` failed with exit code ${result.status}.` };
+  }
+  return { ok: true, stdout: result.stdout };
+}
+
 // src/workspace.ts
 var WORKSPACE_MANIFEST = "pnpm-workspace.yaml";
 function getWorkspacePackageDirs(monorepoRoot) {
@@ -7944,7 +7972,7 @@ function noRedundantRootScripts() {
   const pkg = readPackageJson();
   if (!pkg) return true;
   const scripts = pkg["scripts"];
-  if (!isRecord2(scripts)) return true;
+  if (!isRecord3(scripts)) return true;
   const builtInNames = Object.keys(getDefaultRootScripts(process.cwd()));
   const redundantNames = Object.keys(scripts).filter((name) => builtInNames.includes(name));
   if (redundantNames.length === 0) return true;
@@ -7981,13 +8009,13 @@ function readRootScripts(cwd) {
   } catch {
     return {};
   }
-  if (!isRecord2(parsedManifest)) return {};
+  if (!isRecord3(parsedManifest)) return {};
   const scripts = parsedManifest["scripts"];
-  return isRecord2(scripts) ? scripts : {};
+  return isRecord3(scripts) ? scripts : {};
 }
 
 // .readyup/lib/self-hosted-runner.ts
-import { isRecord as isRecord4 } from "readyup/check-utils";
+import { isRecord as isRecord5 } from "readyup/check-utils";
 
 // src/config.ts
 import { existsSync as existsSync3 } from "node:fs";
@@ -8044,9 +8072,10 @@ function isHookName(key) {
 }
 
 // src/resolver.ts
-import { readFileSync as readFileSync2 } from "node:fs";
+import { readFileSync as readFileSync3 } from "node:fs";
 
 // src/helpers/package-json.ts
+import { readFileSync as readFileSync2 } from "node:fs";
 import path5 from "node:path";
 
 // src/helpers/config-path.ts
@@ -8058,15 +8087,52 @@ function resolveConfigPath(baseDir) {
   return path4.join(baseDir, CONFIG_DIR, CONFIG_FILENAME);
 }
 
-// src/helpers/type-guards.ts
-function isObject2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isStringRecord(value) {
-  return isObject2(value) && Object.values(value).every((entry) => typeof entry === "string");
+// src/helpers/readStringValues.ts
+function readStringValues(record) {
+  const result = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (typeof value === "string") result[key] = value;
+  }
+  return result;
 }
 
 // src/helpers/package-json.ts
+var DEPENDENCY_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies",
+  "peerDependencies"
+];
+function readPackageJson2(dir) {
+  const file = resolvePackageJsonPath(dir);
+  const parsedManifest = parsePackageJson(readFileSync2(file, "utf8"), file);
+  if (!isRecord2(parsedManifest)) {
+    throw new UserError(`Invalid package.json in ${dir}: expected an object`);
+  }
+  const packageJson = {};
+  if (typeof parsedManifest["name"] === "string") packageJson.name = parsedManifest["name"];
+  if (parsedManifest["private"] === true) packageJson.private = true;
+  if (typeof parsedManifest["version"] === "string") packageJson.version = parsedManifest["version"];
+  if (typeof parsedManifest["packageManager"] === "string") {
+    packageJson.packageManager = parsedManifest["packageManager"];
+  }
+  if (isRecord2(parsedManifest["scripts"])) {
+    packageJson.scripts = readScriptRecord(dir, parsedManifest["scripts"]);
+  }
+  if (isRecord2(parsedManifest["pnpm"])) {
+    const pnpm = parsedManifest["pnpm"];
+    if (isRecord2(pnpm["overrides"])) {
+      packageJson.pnpm = { overrides: pnpm["overrides"] };
+    }
+  }
+  for (const field of DEPENDENCY_FIELDS) {
+    const declaredDependencies = parsedManifest[field];
+    if (isRecord2(declaredDependencies)) {
+      packageJson[field] = readStringValues(declaredDependencies);
+    }
+  }
+  return packageJson;
+}
 function parsePackageJson(rawText, file) {
   try {
     return JSON.parse(rawText);
@@ -8096,6 +8162,370 @@ function formatMalformedScript(dir, key, value) {
   return `${rejection} A step list belongs in \`${CONFIG_RELATIVE_PATH}\` under \`${field}\`.`;
 }
 
+// ../../node_modules/.pnpm/@williamthorsen+toolbelt.cli@0.8.0/node_modules/@williamthorsen/toolbelt.cli/dist/esm/3-candidate/parseArgs.js
+import path6 from "node:path";
+import process2 from "node:process";
+
+// ../../node_modules/.pnpm/@williamthorsen+toolbelt.cli@0.8.0/node_modules/@williamthorsen/toolbelt.cli/dist/esm/3-candidate/UsageError.js
+var UsageError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "UsageError";
+  }
+};
+
+// ../../node_modules/.pnpm/@williamthorsen+toolbelt.cli@0.8.0/node_modules/@williamthorsen/toolbelt.cli/dist/esm/3-candidate/ParseError.js
+var ParseError = class extends UsageError {
+  kind;
+  token;
+  constructor(kind, token, message, options) {
+    super(message, options);
+    this.name = "ParseError";
+    this.kind = kind;
+    this.token = token;
+  }
+};
+
+// ../../node_modules/.pnpm/@williamthorsen+toolbelt.cli@0.8.0/node_modules/@williamthorsen/toolbelt.cli/dist/esm/3-candidate/resolveLongName.js
+function resolveLongName(key, definition) {
+  return definition.long ?? key.replaceAll(/[A-Z]/g, (capital) => `-${capital.toLowerCase()}`);
+}
+
+// ../../node_modules/.pnpm/@williamthorsen+toolbelt.cli@0.8.0/node_modules/@williamthorsen/toolbelt.cli/dist/esm/3-candidate/tokenizeArgs.js
+import { parseArgs as nodeParseArgs } from "node:util";
+function tokenizeArgs(argv, schema, extraBooleans = []) {
+  const nodeOptions = {};
+  const flagsByName = /* @__PURE__ */ new Map();
+  for (const [key, definition] of Object.entries(schema)) {
+    const name = resolveLongName(key, definition);
+    const type = definition.type === "boolean" ? "boolean" : "string";
+    nodeOptions[name] = definition.short === void 0 ? { type } : { type, short: definition.short };
+    flagsByName.set(name, { key, definition });
+  }
+  for (const { long, short } of extraBooleans) {
+    nodeOptions[long] = { type: "boolean", short };
+  }
+  const { tokens } = nodeParseArgs({
+    args: [...argv],
+    options: nodeOptions,
+    strict: false,
+    allowPositionals: true,
+    tokens: true
+  });
+  return { tokens, flagsByName };
+}
+function findFlagEntry(flagsByName, token) {
+  const entry = flagsByName.get(token.name);
+  if (entry === void 0 || token.rawName.startsWith("--"))
+    return entry;
+  return entry.definition.short === token.rawName.slice(1) ? entry : void 0;
+}
+
+// ../../node_modules/.pnpm/@williamthorsen+toolbelt.cli@0.8.0/node_modules/@williamthorsen/toolbelt.cli/dist/esm/3-candidate/validateSpec.js
+var CAMEL_CASE_KEY = /^[a-z][a-z0-9]*(?:[A-Z][a-z0-9]+)*$/;
+function validateSpec(spec) {
+  validateFlags(spec.flags ?? {});
+  validateOperands(spec.operands ?? []);
+}
+function validateFlags(flags) {
+  const longNames = /* @__PURE__ */ new Set(["help"]);
+  const shortNames = /* @__PURE__ */ new Set(["h"]);
+  for (const [key, definition] of Object.entries(flags)) {
+    if (definition.long === void 0 && !CAMEL_CASE_KEY.test(key)) {
+      throw new Error(`Flag key '${key}' must be camelCase or declare 'long'.`);
+    }
+    if (definition.long !== void 0 && (definition.long === "" || definition.long.startsWith("-"))) {
+      throw new Error(`Flag '${key}' declares a long name that is empty or starts with a dash: '${definition.long}'.`);
+    }
+    const longName = resolveLongName(key, definition);
+    if (longNames.has(longName)) {
+      throw new Error(`Flag '${key}' reuses the long name --${longName}, which is reserved or already declared.`);
+    }
+    longNames.add(longName);
+    if (definition.short !== void 0) {
+      if (definition.short.length !== 1 || definition.short === "-") {
+        throw new Error(`Flag '${key}' must declare 'short' as one character other than a dash.`);
+      }
+      if (shortNames.has(definition.short)) {
+        throw new Error(`Flag '${key}' reuses the short name -${definition.short}, which is reserved or already declared.`);
+      }
+      shortNames.add(definition.short);
+    }
+    validateFlagFields(key, definition);
+  }
+}
+function validateFlagFields(key, definition) {
+  if (definition.type === "boolean") {
+    if (definition.valueHint !== void 0)
+      throw new Error(`Boolean flag '${key}' cannot declare 'valueHint'.`);
+    if (definition.parse !== void 0)
+      throw new Error(`Boolean flag '${key}' cannot declare 'parse'.`);
+    if ("default" in definition && typeof definition.default !== "boolean") {
+      throw new Error(`Boolean flag '${key}' must declare a boolean 'default'.`);
+    }
+    if (definition.multiple === true)
+      throw new Error(`Boolean flag '${key}' cannot declare 'multiple'.`);
+  }
+  if (definition.multiple === true && "default" in definition) {
+    throw new Error(`Flag '${key}' declares 'multiple', which does not take a 'default'.`);
+  }
+  const { choices } = definition;
+  if (choices === void 0)
+    return;
+  if (definition.type !== "string")
+    throw new Error(`Flag '${key}' declares 'choices', which only a string flag takes.`);
+  if (choices.length === 0)
+    throw new Error(`Flag '${key}' declares empty 'choices'.`);
+  if ("default" in definition && (typeof definition.default !== "string" || !choices.includes(definition.default))) {
+    throw new Error(`Flag '${key}' declares a 'default' that is not one of its 'choices'.`);
+  }
+}
+function validateOperands(operands) {
+  const names = /* @__PURE__ */ new Set();
+  let hasOptional = false;
+  for (const [index, operand] of operands.entries()) {
+    if (operand.name === "")
+      throw new Error(`Operand ${index + 1} has an empty name.`);
+    if (names.has(operand.name))
+      throw new Error(`Operand name '${operand.name}' is declared twice.`);
+    names.add(operand.name);
+    if (operand.optional === true) {
+      hasOptional = true;
+    } else if (hasOptional) {
+      throw new Error(`Required operand '${operand.name}' follows an optional one.`);
+    }
+    if (operand.variadic === true && index !== operands.length - 1) {
+      throw new Error(`Variadic operand '${operand.name}' must be the last operand.`);
+    }
+    if (operand.choices?.length === 0)
+      throw new Error(`Operand '${operand.name}' declares empty 'choices'.`);
+  }
+}
+
+// ../../node_modules/.pnpm/@williamthorsen+toolbelt.cli@0.8.0/node_modules/@williamthorsen/toolbelt.cli/dist/esm/3-candidate/parseArgs.js
+function parseArgs(argv, spec, options = {}) {
+  validateSpec(spec);
+  return parseValidatedArgs(argv, spec, options);
+}
+function parseValidatedArgs(argv, spec, options = {}) {
+  const schema = spec.flags ?? {};
+  const operandDefinitions = spec.operands ?? [];
+  const baseDir = options.baseDir ?? process2.cwd();
+  const stopAtPositional = options.stopAtPositional === true || options.stopAtUnclaimedFlag === true;
+  const { tokens, flagsByName } = tokenizeArgs(argv, schema);
+  const flags = {};
+  for (const [key, definition] of Object.entries(schema)) {
+    flags[key] = "default" in definition ? definition.default : initialValue(definition);
+  }
+  const positionals = [];
+  let rest = [];
+  let previousIndex = -1;
+  let precedingInArgument = 0;
+  for (const token of tokens) {
+    if (token.kind === "option") {
+      precedingInArgument = token.index === previousIndex ? precedingInArgument + 1 : 0;
+      previousIndex = token.index;
+    }
+    if (stopAtPositional && token.kind !== "option") {
+      rest = argv.slice(token.index);
+      break;
+    }
+    if (token.kind === "option-terminator")
+      continue;
+    if (token.kind === "positional") {
+      acceptPositional(token.value, positionals, operandDefinitions);
+      continue;
+    }
+    const entry = findFlagEntry(flagsByName, token);
+    if (entry === void 0) {
+      if (options.stopAtUnclaimedFlag === true) {
+        rest = splitAtOption(argv, token.index, precedingInArgument);
+        break;
+      }
+      throw new ParseError("unknown-flag", token.rawName, `Unknown option: ${token.rawName}`);
+    }
+    const value = readFlagValue(token, entry.key, entry.definition, baseDir);
+    const collected = flags[entry.key];
+    if (entry.definition.multiple === true && Array.isArray(collected)) {
+      collected.push(value);
+    } else {
+      flags[entry.key] = value;
+    }
+  }
+  const operands = assignOperands(positionals, operandDefinitions);
+  return { flags, operands, rest };
+}
+function acceptPositional(value, positionals, definitions) {
+  const last = definitions.at(-1);
+  const overflow = last?.variadic === true ? last : void 0;
+  const definition = positionals.length < definitions.length ? definitions[positionals.length] : overflow;
+  if (definition === void 0) {
+    throw new ParseError("unexpected-positional", value, `Unexpected positional argument: ${value}`);
+  }
+  checkChoice(value, definition.choices, `<${definition.name}>`);
+  positionals.push(value);
+}
+function assignOperands(positionals, definitions) {
+  const operands = {};
+  for (const [index, definition] of definitions.entries()) {
+    const value = definition.variadic === true ? positionals.slice(index) : positionals[index];
+    const isAbsent = value === void 0 || Array.isArray(value) && value.length === 0;
+    if (isAbsent && definition.optional !== true) {
+      const label = `<${definition.name}>`;
+      throw new ParseError("missing-operand", label, `Missing argument: ${label}`);
+    }
+    operands[definition.name] = value;
+  }
+  return operands;
+}
+function initialValue(definition) {
+  if (definition.multiple === true)
+    return [];
+  return definition.type === "boolean" ? false : void 0;
+}
+function checkChoice(value, choices, label) {
+  if (choices === void 0 || choices.includes(value))
+    return;
+  throw new ParseError("invalid-choice", value, `Invalid value for ${label}: ${value}. Expected one of: ${choices.join(", ")}`);
+}
+function readFlagValue(token, key, definition, baseDir) {
+  if (definition.type === "boolean") {
+    if (token.value !== void 0) {
+      throw new ParseError("unexpected-value", token.rawName, `Option does not accept a value: ${token.rawName}`);
+    }
+    return true;
+  }
+  const { value } = token;
+  if (value === void 0 || value === "" || token.inlineValue !== true && value.startsWith("-") && value !== "-") {
+    throw new ParseError("missing-value", token.rawName, `Missing value for option: ${token.rawName}`);
+  }
+  const label = `--${resolveLongName(key, definition)}`;
+  checkChoice(value, definition.choices, label);
+  const raw = definition.type === "path" ? path6.resolve(baseDir, value) : value;
+  if (definition.parse === void 0)
+    return raw;
+  try {
+    return definition.parse(raw);
+  } catch (error) {
+    const reason = describeError(error);
+    throw new ParseError("invalid-value", value, `Invalid value for ${label}: ${value}. ${reason}`, { cause: error });
+  }
+}
+function splitAtOption(argv, index, precedingInArgument) {
+  const argument = argv[index];
+  if (argument === void 0 || precedingInArgument === 0)
+    return argv.slice(index);
+  return [`-${argument.slice(1 + precedingInArgument)}`, ...argv.slice(index + 1)];
+}
+
+// src/nmr-flags.ts
+var NMR_FLAGS = {
+  delegate: {
+    type: "boolean",
+    description: "Run over SSH on the first free host that NMR_DELEGATE or the user config names"
+  },
+  delegateTo: {
+    type: "string",
+    description: "Run over SSH on the first free of <hosts>, comma-separated",
+    valueHint: "hosts"
+  },
+  filter: {
+    type: "string",
+    description: "Run command in packages whose manifest name matches",
+    short: "F",
+    valueHint: "pattern"
+  },
+  json: { type: "boolean", description: "Report one JSON object per command, withholding command output" },
+  log: { type: "boolean", description: "Print the recorded run instead of running (up to 256 KiB)" },
+  noCache: { type: "boolean", description: "Run even if this tree already passed; record the result" },
+  noDelegate: { type: "boolean", description: "Run here, whatever NMR_DELEGATE or the user config says" },
+  noLock: { type: "boolean", description: "Run without waiting for another heavy command on this machine" },
+  outputStyle: {
+    type: "string",
+    description: "Output style: auto (default), plain, or rich",
+    valueHint: "auto|plain|rich"
+  },
+  quiet: { type: "boolean", description: "Suppress command output, keeping nmr's verdicts", short: "q" },
+  recursive: { type: "boolean", description: "Run command in all packages", short: "R" },
+  workspaceRoot: { type: "boolean", description: "Use root scripts, running at the monorepo root", short: "w" }
+};
+function readInvocationFlags(args) {
+  const remaining = [...args];
+  let shouldShowHelp = false;
+  for (; ; ) {
+    try {
+      const parsed = parseArgs(remaining, { flags: READER_FLAGS }, { stopAtPositional: true });
+      return { ok: true, parsedArgs: { ...toParsedArgs(parsed.flags, parsed.rest), shouldShowHelp } };
+    } catch (error) {
+      if (!(error instanceof ParseError)) {
+        throw error;
+      }
+      if (error.kind !== "unknown-flag" || !HELP_SPELLINGS.has(error.token) || !removeHelpFlag(remaining, error.token)) {
+        return { ok: false };
+      }
+      shouldShowHelp = true;
+    }
+  }
+}
+function toParsedArgs(flags, rest) {
+  const [first, ...remaining] = rest;
+  const hasCommand = first !== void 0 && first !== "--";
+  return {
+    ...flags.delegateTo !== void 0 && { delegateHosts: flags.delegateTo },
+    ...flags.filter !== void 0 && { filter: flags.filter },
+    isWorkspaceRoot: flags.workspaceRoot,
+    ...flags.outputStyle !== void 0 && { outputStyle: flags.outputStyle },
+    quiet: flags.quiet,
+    recursive: flags.recursive,
+    shouldBypassCache: flags.noCache,
+    shouldBypassLock: flags.noLock,
+    shouldDelegate: flags.delegate,
+    shouldEmitJson: flags.json,
+    shouldPrintLog: flags.log,
+    shouldRunLocally: flags.noDelegate,
+    shouldShowHelp: false,
+    shouldShowVersion: flags.version ?? false,
+    ...hasCommand && { command: first },
+    passthrough: hasCommand ? remaining : []
+  };
+}
+var HELP_SPELLINGS = /* @__PURE__ */ new Set(["--help", "-h"]);
+var READER_FLAGS = {
+  ...NMR_FLAGS,
+  version: { type: "boolean", description: "Print the version", short: "V" }
+};
+function isBooleanCluster(arg) {
+  if (!/^-[^-]./.test(arg)) {
+    return false;
+  }
+  const booleanShorts = /* @__PURE__ */ new Set(["h", "V"]);
+  for (const definition of Object.values(NMR_FLAGS)) {
+    if (definition.type === "boolean" && "short" in definition) {
+      booleanShorts.add(definition.short);
+    }
+  }
+  for (const letter of arg.slice(1)) {
+    if (!booleanShorts.has(letter)) {
+      return false;
+    }
+  }
+  return true;
+}
+function removeHelpFlag(args, token) {
+  const index = args.indexOf(token);
+  if (index !== -1) {
+    args.splice(index, 1);
+    return true;
+  }
+  const clusterIndex = args.findIndex((arg) => isBooleanCluster(arg) && arg.includes("h"));
+  const cluster = args[clusterIndex];
+  if (cluster === void 0) {
+    return false;
+  }
+  args[clusterIndex] = cluster.replace("h", "");
+  return true;
+}
+
 // src/steps.ts
 var LAUNCHERS = /* @__PURE__ */ new Map([
   ["bun", /* @__PURE__ */ new Set(["x"])],
@@ -8191,39 +8621,12 @@ function readNmrTail(segment) {
   return rest[nmrIndex] === "nmr" ? { launcher: head, launcherArgs: rest.slice(0, nmrIndex), tail: rest.slice(nmrIndex + 1) } : void 0;
 }
 function readNmrTarget(tokens) {
-  let isDelegate = false;
-  let isRecursive = false;
-  let isWorkspaceRoot = false;
-  let index = 0;
-  while (index < tokens.length) {
-    const token = tokens[index] ?? "";
-    switch (token) {
-      // The pattern is the flag's value, and reading it as a command name would name whichever package it
-      // selects rather than the command that every selected scope runs.
-      case "-F":
-      case "--filter":
-        isDelegate = true;
-        index += 2;
-        break;
-      case "-R":
-      case "--recursive":
-        isDelegate = true;
-        isRecursive = true;
-        index += 1;
-        break;
-      case "-w":
-      case "--workspace-root":
-        isWorkspaceRoot = true;
-        index += 1;
-        break;
-      default:
-        if (!token.startsWith("-")) {
-          return { command: token, isDelegate, isRecursive, isWorkspaceRoot };
-        }
-        index += 1;
-    }
+  const reading = readInvocationFlags(tokens);
+  if (!reading.ok || reading.parsedArgs.command === void 0) {
+    return void 0;
   }
-  return void 0;
+  const { command, filter, isWorkspaceRoot, recursive } = reading.parsedArgs;
+  return { command, isDelegate: filter !== void 0 || recursive, isRecursive: recursive, isWorkspaceRoot };
 }
 
 // src/resolver.ts
@@ -8244,7 +8647,7 @@ function readPackageJsonScripts(packageDir) {
   const file = resolvePackageJsonPath(packageDir);
   let rawText;
   try {
-    rawText = readFileSync2(file, "utf8");
+    rawText = readFileSync3(file, "utf8");
   } catch (error) {
     if (hasErrnoCode(error, "ENOENT")) {
       return void 0;
@@ -8252,9 +8655,9 @@ function readPackageJsonScripts(packageDir) {
     throw error;
   }
   const parsedManifest = parsePackageJson(rawText, file);
-  if (!isObject2(parsedManifest)) return void 0;
+  if (!isRecord2(parsedManifest)) return void 0;
   const scripts = parsedManifest["scripts"];
-  if (!isObject2(scripts)) return void 0;
+  if (!isRecord2(scripts)) return void 0;
   return readScriptRecord(packageDir, scripts);
 }
 function buildWorkspaceRegistry(config) {
@@ -8330,6 +8733,11 @@ function readPackageScripts(packageDir) {
   }
 }
 
+// src/helpers/type-guards.ts
+function isStringRecord(value) {
+  return isRecord2(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+
 // src/verbosity.ts
 var COMMAND_VERBOSITIES = ["full", "quiet"];
 function formatVerbosityRejection(source, value) {
@@ -8370,7 +8778,7 @@ function assertRecognizedKeys(value, recognizedKeys, configPath, prefix = "") {
   );
 }
 function validateConfig(value, configPath, baseDir) {
-  if (!isObject2(value)) {
+  if (!isRecord2(value)) {
     throw new UserError(`Invalid nmr config at ${configPath}: expected an object, got ${typeof value}`);
   }
   assertRecognizedKeys(value, RECOGNIZED_KEYS, configPath);
@@ -8426,7 +8834,7 @@ function isOptionalBoolean(value) {
   return value === void 0 || typeof value === "boolean";
 }
 function isScriptRecord(value) {
-  if (!isObject2(value)) return false;
+  if (!isRecord2(value)) return false;
   for (const v of Object.values(value)) {
     if (typeof v === "string") continue;
     if (!Array.isArray(v) || !v.every(isScriptElement)) return false;
@@ -8435,7 +8843,7 @@ function isScriptRecord(value) {
 }
 function isScriptElement(value) {
   if (typeof value === "string") return true;
-  if (!isObject2(value) || typeof value["run"] !== "string") return false;
+  if (!isRecord2(value) || typeof value["run"] !== "string") return false;
   return isOptionalBoolean(value["shouldDeclineArguments"]) && isOptionalBoolean(value["shouldRunInBackground"]);
 }
 function isStringArray(value) {
@@ -8446,7 +8854,7 @@ function validateBuildField(value, configPath) {
   if (build === void 0) {
     return void 0;
   }
-  if (!isObject2(build)) {
+  if (!isRecord2(build)) {
     throw new UserError(`Invalid nmr config at ${configPath}: \`build\` must be an object`);
   }
   assertRecognizedKeys(build, RECOGNIZED_BUILD_KEYS, configPath, "build.");
@@ -8461,7 +8869,7 @@ function validateCheckCacheField(value, configPath) {
   if (checkCache === void 0) {
     return void 0;
   }
-  if (!isObject2(checkCache)) {
+  if (!isRecord2(checkCache)) {
     throw new UserError(`Invalid nmr config at ${configPath}: \`checkCache\` must be an object`);
   }
   assertRecognizedKeys(checkCache, RECOGNIZED_CHECK_CACHE_KEYS, configPath, "checkCache.");
@@ -8498,7 +8906,7 @@ function validateOutputField(value, configPath) {
   if (output === void 0) {
     return void 0;
   }
-  if (!isObject2(output)) {
+  if (!isRecord2(output)) {
     throw new UserError(`Invalid nmr config at ${configPath}: \`output\` must be an object`);
   }
   assertRecognizedKeys(output, RECOGNIZED_OUTPUT_KEYS, configPath, "output.");
@@ -8527,7 +8935,7 @@ function validateSelfHostedRunnerField(value, configPath) {
   if (selfHostedRunner === void 0) {
     return void 0;
   }
-  if (!isObject2(selfHostedRunner)) {
+  if (!isRecord2(selfHostedRunner)) {
     throw new UserError(`Invalid nmr config at ${configPath}: \`selfHostedRunner\` must be an object`);
   }
   assertRecognizedKeys(selfHostedRunner, RECOGNIZED_SELF_HOSTED_RUNNER_KEYS, configPath, "selfHostedRunner.");
@@ -8587,7 +8995,7 @@ async function loadConfig(baseDir) {
     return {};
   }
   const importedModule = await import(pathToFileURL(configPath).href);
-  const loadedConfig = isObject2(importedModule) ? importedModule["default"] : void 0;
+  const loadedConfig = isRecord2(importedModule) ? importedModule["default"] : void 0;
   return validateConfig(loadedConfig, configPath, baseDir);
 }
 async function loadRootConfig(monorepoRoot) {
@@ -8638,17 +9046,15 @@ function formatSelfReferenceRemedy(options) {
 
 // src/tiers.ts
 import { readdirSync as readdirSync2 } from "node:fs";
-import path6 from "node:path";
+import path7 from "node:path";
 
 // src/git-ignored-paths.ts
-import { spawnSync } from "node:child_process";
 function listGitIgnoredPaths(dir) {
-  const result = spawnSync(
-    "git",
+  const result = runGit(
     ["ls-files", "-z", "--others", "--ignored", "--exclude-standard", "--directory", "--no-empty-directory"],
-    { cwd: dir, encoding: "utf8" }
+    dir
   );
-  if (result.error !== void 0 || result.status !== 0) return [];
+  if (!result.ok) return [];
   return result.stdout.split("\0").filter((entry) => entry !== "").toSorted();
 }
 
@@ -8669,7 +9075,7 @@ function findUntieredTestFiles(rootDir, options = {}) {
 }
 function hasTierInfix(filePath) {
   const tiers = TIER_NAMES;
-  return tiers.includes(path6.basename(filePath).split(".").at(-3) ?? "");
+  return tiers.includes(path7.basename(filePath).split(".").at(-3) ?? "");
 }
 var TEST_COLLECTION_EXCLUDE = [".git", "coverage", "dist", "node_modules"];
 var TIER_NAMES = ["unit", "tool", "localhost", "remote"];
@@ -8679,7 +9085,7 @@ function collectTestFiles(dir, relativeDir, isInTestDir, context) {
     const relativePath = relativeDir === "" ? entry.name : `${relativeDir}/${entry.name}`;
     if (entry.isDirectory()) {
       if (context.pruned.has(entry.name) || context.ignoredPaths.has(`${relativePath}/`)) continue;
-      collectTestFiles(path6.join(dir, entry.name), relativePath, isInTestDir || entry.name === TEST_DIR, context);
+      collectTestFiles(path7.join(dir, entry.name), relativePath, isInTestDir || entry.name === TEST_DIR, context);
     } else if (isInTestDir !== context.misplaced && TEST_FILE_PATTERN.test(entry.name) && !context.ignoredPaths.has(relativePath)) {
       context.foundPaths.push(relativePath);
     }
@@ -8701,16 +9107,16 @@ var import_yaml2 = __toESM(require_dist(), 1);
 import { execFile } from "node:child_process";
 import { existsSync as existsSync4, readdirSync as readdirSync3 } from "node:fs";
 import { join as join3, posix as posix2 } from "node:path";
-import { isRecord as isRecord3, readFile as readFile3 } from "readyup/check-utils";
+import { isRecord as isRecord4, readFile as readFile3 } from "readyup/check-utils";
 var CODE_QUALITY_WORKFLOW = "williamthorsen/.github/.github/workflows/code-quality-pnpm-workflow.yaml";
 var MIN_CODE_QUALITY_MAJOR = 8;
 var GH_TIMEOUT_MS = 15e3;
 var IMAGE_ABSENT_PROGRAM_PATTERN = /(?:^|[\s;&|(])(corepack|gh|node|npm|npx|pnpm)(?=\s|$)/gm;
 var NEVER_INSTALLED_PROGRAMS = /* @__PURE__ */ new Set(["corepack", "gh"]);
 function countOnlineSelfHostedRunners(response) {
-  if (!isRecord3(response) || !Array.isArray(response["runners"])) return 0;
+  if (!isRecord4(response) || !Array.isArray(response["runners"])) return 0;
   return response["runners"].filter(
-    (runner) => isRecord3(runner) && runner["status"] === "online" && Array.isArray(runner["labels"]) && runner["labels"].some((label) => isRecord3(label) && label["name"] === "self-hosted")
+    (runner) => isRecord4(runner) && runner["status"] === "online" && Array.isArray(runner["labels"]) && runner["labels"].some((label) => isRecord4(label) && label["name"] === "self-hosted")
   ).length;
 }
 function describeGhFailure(result, context) {
@@ -8737,7 +9143,7 @@ function findCodeQualityCallerDefects(workflows) {
         );
       }
       const inputs = job["with"];
-      if (isRecord3(inputs) && inputs["runs-on"] !== void 0) {
+      if (isRecord4(inputs) && inputs["runs-on"] !== void 0) {
         defects.push(`${file} job ${jobName} passes runs-on, which overrides CI_RUNS_ON`);
       }
     }
@@ -8753,7 +9159,7 @@ function findImageIncompatibleSteps(workflows) {
       if (!Array.isArray(steps)) continue;
       const installed = /* @__PURE__ */ new Set();
       for (const [index, step] of steps.entries()) {
-        if (!isRecord3(step)) continue;
+        if (!isRecord4(step)) continue;
         const stepLabel = typeof step["name"] === "string" ? step["name"] : `step ${index + 1}`;
         const run = step["run"];
         if (typeof run === "string") {
@@ -8784,14 +9190,14 @@ async function readOrganizationValue(nameWithOwner, cwd, runGh) {
   const result = await runGh(["api", `repos/${nameWithOwner}/actions/organization-variables`], cwd);
   if (!result.ok) return void 0;
   const response = parseJson(result.stdout);
-  if (!isRecord3(response) || !Array.isArray(response["variables"])) return void 0;
+  if (!isRecord4(response) || !Array.isArray(response["variables"])) return void 0;
   const variable = response["variables"].find(
-    (entry) => isRecord3(entry) && entry["name"] === "CI_RUNS_ON"
+    (entry) => isRecord4(entry) && entry["name"] === "CI_RUNS_ON"
   );
   return readVariableValue(variable);
 }
 function readVariableValue(variable) {
-  return isRecord3(variable) && typeof variable["value"] === "string" ? variable["value"] : void 0;
+  return isRecord4(variable) && typeof variable["value"] === "string" ? variable["value"] : void 0;
 }
 function readWorkflows(cwd) {
   const dir = join3(cwd, ".github", "workflows");
@@ -8805,9 +9211,9 @@ function readWorkflows(cwd) {
     } catch {
       continue;
     }
-    if (!isRecord3(document) || !isRecord3(document["jobs"])) continue;
+    if (!isRecord4(document) || !isRecord4(document["jobs"])) continue;
     const jobs = Object.entries(document["jobs"]).filter(
-      (entry) => isRecord3(entry[1])
+      (entry) => isRecord4(entry[1])
     );
     workflows.push({ file: posix2.join(".github/workflows", file), jobs });
   }
@@ -8841,7 +9247,7 @@ function readInstalledPrograms(step) {
   if (action === "actions/setup-node") return ["node"];
   if (action === "pnpm/action-setup") return ["pnpm"];
   if (action !== "pnpm/setup") return [];
-  const inputs = isRecord3(step["with"]) ? step["with"] : {};
+  const inputs = isRecord4(step["with"]) ? step["with"] : {};
   const runtime = inputs["runtime"];
   const installsNode = typeof runtime === "string" ? /^node\b/.test(runtime) : String(inputs["node-version-file"]) !== "false";
   return installsNode ? ["pnpm", "node"] : ["pnpm"];
@@ -8919,7 +9325,7 @@ async function readGitHubFacts(cwd, runGh = runGhCommand) {
   const repo = await runGh(["repo", "view", "--json", "nameWithOwner,visibility"], cwd);
   if (!repo.ok) return { skip: describeGhFailure(repo, "cannot resolve this repo on GitHub") };
   const repoView = parseJson(repo.stdout);
-  if (!isRecord4(repoView) || typeof repoView["nameWithOwner"] !== "string") {
+  if (!isRecord5(repoView) || typeof repoView["nameWithOwner"] !== "string") {
     return { skip: "gh repo view returned an unexpected shape" };
   }
   const nameWithOwner = repoView["nameWithOwner"];
@@ -9018,7 +9424,7 @@ import {
 // .readyup/lib/catalog.ts
 import { posix as posix3 } from "node:path";
 var import_yaml3 = __toESM(require_dist(), 1);
-import { isRecord as isRecord5 } from "readyup/check-utils";
+import { isRecord as isRecord6 } from "readyup/check-utils";
 var CATALOGUE_CHECKED_FIELDS = ["dependencies", "devDependencies", "optionalDependencies"];
 var PROTOCOL_PATTERN = /^[a-z][a-z0-9+.-]*:/i;
 function cataloguedDependenciesUseCatalog() {
@@ -9036,7 +9442,7 @@ function findLiteralCataloguedSpecifiers(workspace, names) {
   const manifestPath = posix3.join(workspace.dir, "package.json");
   return CATALOGUE_CHECKED_FIELDS.flatMap((field) => {
     const declared = workspace.packageJson[field];
-    if (!isRecord5(declared)) return [];
+    if (!isRecord6(declared)) return [];
     return Object.entries(declared).flatMap(
       ([name, specifier]) => names.has(name) && typeof specifier === "string" && !PROTOCOL_PATTERN.test(specifier) ? { manifestPath, name, specifier } : []
     );
@@ -9051,14 +9457,14 @@ function readCataloguedNames(cwd) {
   } catch (error) {
     return { ok: false, detail: `cannot parse pnpm-workspace.yaml: ${describeError(error)}` };
   }
-  if (!isRecord5(workspaceManifest)) return { ok: true, names: /* @__PURE__ */ new Set() };
+  if (!isRecord6(workspaceManifest)) return { ok: true, names: /* @__PURE__ */ new Set() };
   const namedCatalogs = workspaceManifest["catalogs"];
-  const catalogs = [workspaceManifest["catalog"], ...isRecord5(namedCatalogs) ? Object.values(namedCatalogs) : []];
-  return { ok: true, names: new Set(catalogs.filter(isRecord5).flatMap((catalog) => Object.keys(catalog))) };
+  const catalogs = [workspaceManifest["catalog"], ...isRecord6(namedCatalogs) ? Object.values(namedCatalogs) : []];
+  return { ok: true, names: new Set(catalogs.filter(isRecord6).flatMap((catalog) => Object.keys(catalog))) };
 }
 
 // .readyup/lib/manifest-fields.ts
-import { isRecord as isRecord6 } from "readyup/check-utils";
+import { isRecord as isRecord7 } from "readyup/check-utils";
 function noPnpmFieldInPackageJson(cwd = process.cwd()) {
   const declaringFiles = findFiles(["**/package.json"], cwd).flatMap((relativePath) => {
     const keys = readPnpmFieldKeys(readFileIn(cwd, relativePath));
@@ -9079,7 +9485,7 @@ function declaresWorkspacesField(content) {
   if (content === void 0) return false;
   try {
     const parsedManifest = JSON.parse(content);
-    return isRecord6(parsedManifest) && "workspaces" in parsedManifest;
+    return isRecord7(parsedManifest) && "workspaces" in parsedManifest;
   } catch {
     return false;
   }
@@ -9092,9 +9498,9 @@ function readPnpmFieldKeys(content) {
   } catch {
     return void 0;
   }
-  if (!isRecord6(parsedManifest)) return void 0;
+  if (!isRecord7(parsedManifest)) return void 0;
   const pnpm = parsedManifest["pnpm"];
-  return isRecord6(pnpm) ? Object.keys(pnpm).toSorted() : void 0;
+  return isRecord7(pnpm) ? Object.keys(pnpm).toSorted() : void 0;
 }
 
 // .readyup/lib/setup.ts
@@ -9205,7 +9611,7 @@ function hasSupportedStrictLintVersion() {
   });
 }
 function getMinVersion() {
-  const pickedFields = { "version": "0.55.0" };
+  const pickedFields = { "version": "1.0.0" };
   if (typeof pickedFields["version"] !== "string") {
     throw new TypeError("nmr/package.json: 'version' must be a string");
   }
@@ -9221,7 +9627,7 @@ function toolVersionsHasNoPnpm() {
 }
 
 // .readyup/lib/shared-configs.ts
-import { isRecord as isRecord7 } from "readyup/check-utils";
+import { isRecord as isRecord8 } from "readyup/check-utils";
 var SHARED_PRETTIER_MODULE = "@williamthorsen/nmr/prettier";
 var INERT_PRETTIER_CONFIGS = [".prettierrc", ".prettierrc.{json,json5,yaml,yml,toml}"];
 var SHARED_TAZE_MODULE = "@williamthorsen/nmr/taze";
@@ -9315,7 +9721,7 @@ function hasPrettierConfigKey(cwd) {
   if (manifest === void 0) return false;
   try {
     const parsedManifest = JSON.parse(manifest);
-    return isRecord7(parsedManifest) && parsedManifest["prettier"] !== void 0;
+    return isRecord8(parsedManifest) && parsedManifest["prettier"] !== void 0;
   } catch {
     return false;
   }
@@ -9404,8 +9810,8 @@ function everyViteConfigHasVitestConfig() {
   return { ok: false, detail: formatPaths(unpairedConfigs) };
 }
 function noReExportOnlyVitestConfigs(cwd = process.cwd()) {
-  const nonRootConfigs = findFiles([`**/${VITEST_CONFIG_PATTERN}`], cwd).filter((path7) => path7.includes("/"));
-  const reExports = nonRootConfigs.filter((path7) => isOwnedByReExportCheck(cwd, path7));
+  const nonRootConfigs = findFiles([`**/${VITEST_CONFIG_PATTERN}`], cwd).filter((path9) => path9.includes("/"));
+  const reExports = nonRootConfigs.filter((path9) => isOwnedByReExportCheck(cwd, path9));
   if (reExports.length === 0) return true;
   return { ok: false, detail: formatPaths(reExports) };
 }
@@ -9480,14 +9886,108 @@ function isReExportOnly(content) {
 import { existsSync as existsSync5, readdirSync as readdirSync4 } from "node:fs";
 import { join as join5 } from "node:path";
 import { fileExists as fileExists3, readFile as readFile5 } from "readyup/check-utils";
+
+// src/commands/ensure-prepublish-hooks.ts
+import { readFileSync as readFileSync4, writeFileSync } from "node:fs";
+import path8 from "node:path";
+var DEFAULT_HOOK = "nmr build";
+function ensurePrepublishHooks(monorepoRoot, options) {
+  const hookCommand = options.command ?? DEFAULT_HOOK;
+  const packageDirs = getWorkspacePackageDirs(monorepoRoot);
+  const packages = [];
+  for (const packageDir of packageDirs) {
+    const packageJson = readPackageJson2(packageDir);
+    const packageName = packageJson.name ?? path8.basename(packageDir);
+    const isPrivate = packageJson.private === true;
+    if (isPrivate) {
+      packages.push({
+        packageName,
+        packageDir,
+        isPrivate: true,
+        prepublishOnly: packageJson.scripts?.["prepublishOnly"],
+        action: "ok"
+      });
+      continue;
+    }
+    const existingHook = packageJson.scripts?.["prepublishOnly"];
+    if (existingHook) {
+      packages.push({
+        packageName,
+        packageDir,
+        isPrivate: false,
+        prepublishOnly: existingHook,
+        action: "ok"
+      });
+      continue;
+    }
+    if (options.shouldFix) {
+      const action = options.isDryRun ? "would-fix" : "fixed";
+      if (!options.isDryRun) {
+        addPrepublishOnly(packageDir, hookCommand);
+      }
+      packages.push({
+        packageName,
+        packageDir,
+        isPrivate: false,
+        prepublishOnly: void 0,
+        action
+      });
+    } else {
+      packages.push({
+        packageName,
+        packageDir,
+        isPrivate: false,
+        prepublishOnly: void 0,
+        action: "missing"
+      });
+    }
+  }
+  const hasFailures = packages.some((p) => p.action === "missing");
+  return { packages, hasFailures };
+}
+function addPrepublishOnly(packageDir, command) {
+  const filePath = path8.join(packageDir, "package.json");
+  const rawText = readFileSync4(filePath, "utf8");
+  let parsedManifest;
+  try {
+    parsedManifest = JSON.parse(rawText);
+  } catch (error) {
+    throw new UserError(`Invalid package.json in ${packageDir}: ${describeError(error)}`, { cause: error });
+  }
+  if (!isRecord2(parsedManifest)) {
+    throw new UserError(`Invalid package.json in ${packageDir}: expected an object`);
+  }
+  const scripts = isRecord2(parsedManifest["scripts"]) ? parsedManifest["scripts"] : {};
+  scripts["prepublishOnly"] = command;
+  parsedManifest["scripts"] = scripts;
+  writeFileSync(filePath, JSON.stringify(parsedManifest, null, 2) + "\n", "utf8");
+}
+
+// .readyup/lib/workspace-build.ts
 var buildReadinessChecks = [
   {
     name: "all workspace packages can build",
     severity: "warn",
     check: allWorkspacePackagesCanBuild,
     fix: `Add "build": ":" to packages that don't need a build, or ensure packages that use the default nmr build have a tsconfig.json and a src/ directory`
+  },
+  {
+    name: "every publishable package declares prepublishOnly",
+    severity: "warn",
+    check: everyPublishablePackageDeclaresPrepublishOnly,
+    fix: 'Add "prepublishOnly": "nmr build" to the scripts of each listed package, or run ensure-prepublish-hooks --fix. A package without it publishes without its build output'
   }
 ];
+function everyPublishablePackageDeclaresPrepublishOnly() {
+  try {
+    const { packages } = ensurePrepublishHooks(process.cwd(), { shouldFix: false, isDryRun: false });
+    const offenders = packages.filter((packageStatus) => packageStatus.action === "missing").map((packageStatus) => packageStatus.packageName);
+    if (offenders.length === 0) return true;
+    return { ok: false, detail: formatPaths(offenders) };
+  } catch (error) {
+    return { ok: false, detail: describeError(error) };
+  }
+}
 function allWorkspacePackagesCanBuild() {
   const packagesDir = join5(process.cwd(), "packages");
   if (!existsSync5(packagesDir)) return true;