pubm 0.1.5 → 0.1.7

package/dist/index.js

@@ -4821,9 +4821,71 @@ function createListr(...args) {
 }
 
 // src/utils/package.ts
+import { readFile as readFile2, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
+import path3 from "node:path";
+import process7 from "node:process";
+
+// src/ecosystem/rust.ts
 import { readFile, stat as stat2, writeFile } from "node:fs/promises";
 import path2 from "node:path";
-import process7 from "node:process";
+import { parse, stringify } from "smol-toml";
+
+// src/ecosystem/ecosystem.ts
+var Ecosystem = class {
+  constructor(packagePath) {
+    this.packagePath = packagePath;
+  }
+};
+
+// src/ecosystem/rust.ts
+var RustEcosystem = class extends Ecosystem {
+  static async detect(packagePath) {
+    try {
+      return (await stat2(path2.join(packagePath, "Cargo.toml"))).isFile();
+    } catch {
+      return false;
+    }
+  }
+  async readCargoToml() {
+    const raw = await readFile(
+      path2.join(this.packagePath, "Cargo.toml"),
+      "utf-8"
+    );
+    return parse(raw);
+  }
+  async packageName() {
+    const cargo = await this.readCargoToml();
+    const pkg = cargo.package;
+    return pkg.name;
+  }
+  async readVersion() {
+    const cargo = await this.readCargoToml();
+    const pkg = cargo.package;
+    return pkg.version;
+  }
+  async writeVersion(newVersion) {
+    const filePath = path2.join(this.packagePath, "Cargo.toml");
+    const raw = await readFile(filePath, "utf-8");
+    const cargo = parse(raw);
+    const pkg = cargo.package;
+    pkg.version = newVersion;
+    await writeFile(filePath, stringify(cargo));
+  }
+  manifestFiles() {
+    return ["Cargo.toml"];
+  }
+  defaultTestCommand() {
+    return "cargo test";
+  }
+  defaultBuildCommand() {
+    return "cargo build --release";
+  }
+  supportedRegistries() {
+    return ["crates"];
+  }
+};
+
+// src/utils/package.ts
 var cachedPackageJson = {};
 var cachedJsrJson = {};
 function patchCachedJsrJson(contents, { cwd = process7.cwd() } = {}) {
@@ -4832,16 +4894,16 @@ function patchCachedJsrJson(contents, { cwd = process7.cwd() } = {}) {
 async function findOutFile(file, { cwd = process7.cwd() } = {}) {
   let directory = cwd;
   let filePath = "";
-  const { root } = path2.parse(cwd);
+  const { root } = path3.parse(cwd);
   while (directory) {
-    filePath = path2.join(directory, file);
+    filePath = path3.join(directory, file);
     try {
-      if ((await stat2(filePath)).isFile()) {
+      if ((await stat3(filePath)).isFile()) {
         break;
       }
     } catch {
     }
-    directory = path2.dirname(directory);
+    directory = path3.dirname(directory);
     if (directory === root) return null;
   }
   return filePath;
@@ -4853,7 +4915,7 @@ async function getPackageJson({
   if (cachedPackageJson[cwd]) return cachedPackageJson[cwd];
   try {
     const packageJsonPath = await findOutFile("package.json");
-    const raw = packageJsonPath && (await readFile(packageJsonPath)).toString();
+    const raw = packageJsonPath && (await readFile2(packageJsonPath)).toString();
     if (!raw) {
       if (!fallbackJsr) {
         throw new Error(
@@ -4886,7 +4948,7 @@ async function getJsrJson({
   if (cachedJsrJson[cwd]) return cachedJsrJson[cwd];
   try {
     const jsrJsonPath = await findOutFile("jsr.json");
-    const raw = jsrJsonPath && (await readFile(jsrJsonPath)).toString();
+    const raw = jsrJsonPath && (await readFile2(jsrJsonPath)).toString();
     if (!raw) {
       if (!fallbackPackage) {
         throw new Error(
@@ -4970,14 +5032,14 @@ async function version({ cwd = process7.cwd() } = {}) {
   return version2;
 }
 var versionRegex = /("version"\s*:\s*")[^"]*(")/;
-async function replaceVersion(version2) {
+async function replaceVersion(version2, packages) {
   const results = await Promise.all([
     (async () => {
       const packageJsonPath = await findOutFile("package.json");
       if (!packageJsonPath) return void 0;
-      const packageJson = (await readFile(packageJsonPath)).toString();
+      const packageJson = (await readFile2(packageJsonPath)).toString();
       try {
-        await writeFile(
+        await writeFile2(
           packageJsonPath,
           packageJson.replace(versionRegex, `$1${version2}$2`)
         );
@@ -4992,9 +5054,9 @@ async function replaceVersion(version2) {
     (async () => {
       const jsrJsonPath = await findOutFile("jsr.json");
       if (!jsrJsonPath) return void 0;
-      const jsrJson = (await readFile(jsrJsonPath)).toString();
+      const jsrJson = (await readFile2(jsrJsonPath)).toString();
       try {
-        await writeFile(
+        await writeFile2(
           jsrJsonPath,
           jsrJson.replace(versionRegex, `$1${version2}$2`)
         );
@@ -5005,7 +5067,19 @@ async function replaceVersion(version2) {
         );
       }
       return "jsr.json";
-    })()
+    })(),
+    ...(packages ?? []).filter((pkg) => pkg.registries.includes("crates")).map(async (pkg) => {
+      const eco = new RustEcosystem(path3.resolve(pkg.path));
+      try {
+        await eco.writeVersion(version2);
+      } catch (error) {
+        throw new AbstractError(
+          `Failed to write version to Cargo.toml at ${pkg.path}: ${error instanceof Error ? error.message : error}`,
+          { cause: error }
+        );
+      }
+      return path3.join(pkg.path, "Cargo.toml");
+    })
   ]);
   return results.filter((v) => v);
 }
@@ -5026,67 +5100,26 @@ async function getPackageManager() {
   return "npm";
 }
 
-// src/ecosystem/rust.ts
-import { readFile as readFile2, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
-import path3 from "node:path";
-import { parse, stringify } from "smol-toml";
-
-// src/ecosystem/ecosystem.ts
-var Ecosystem = class {
-  constructor(packagePath) {
-    this.packagePath = packagePath;
-  }
-};
-
-// src/ecosystem/rust.ts
-var RustEcosystem = class extends Ecosystem {
-  static async detect(packagePath) {
-    try {
-      return (await stat3(path3.join(packagePath, "Cargo.toml"))).isFile();
-    } catch {
-      return false;
+// src/utils/registries.ts
+function collectRegistries(ctx) {
+  if (ctx.packages?.length) {
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const pkg of ctx.packages) {
+      for (const reg of pkg.registries) {
+        if (!seen.has(reg)) {
+          seen.add(reg);
+          result.push(reg);
+        }
+      }
     }
+    return result;
   }
-  async readCargoToml() {
-    const raw = await readFile2(
-      path3.join(this.packagePath, "Cargo.toml"),
-      "utf-8"
-    );
-    return parse(raw);
-  }
-  async packageName() {
-    const cargo = await this.readCargoToml();
-    const pkg = cargo.package;
-    return pkg.name;
-  }
-  async readVersion() {
-    const cargo = await this.readCargoToml();
-    const pkg = cargo.package;
-    return pkg.version;
-  }
-  async writeVersion(newVersion) {
-    const filePath = path3.join(this.packagePath, "Cargo.toml");
-    const raw = await readFile2(filePath, "utf-8");
-    const cargo = parse(raw);
-    const pkg = cargo.package;
-    pkg.version = newVersion;
-    await writeFile2(filePath, stringify(cargo));
-  }
-  manifestFiles() {
-    return ["Cargo.toml"];
-  }
-  defaultTestCommand() {
-    return "cargo test";
-  }
-  defaultBuildCommand() {
-    return "cargo build --release";
-  }
-  supportedRegistries() {
-    return ["crates"];
-  }
-};
+  return ctx.registries;
+}
 
 // src/registry/crates.ts
+import path4 from "node:path";
 import { exec as exec3 } from "tinyexec";
 
 // src/registry/registry.ts
@@ -5160,9 +5193,13 @@ var CratesRegistry = class extends Registry {
       );
     }
   }
-  async publish() {
+  async publish(manifestDir) {
     try {
-      await exec3("cargo", ["publish"], { throwOnError: true });
+      const args = ["publish"];
+      if (manifestDir) {
+        args.push("--manifest-path", path4.join(manifestDir, "Cargo.toml"));
+      }
+      await exec3("cargo", args, { throwOnError: true });
       return true;
     } catch (error) {
       throw new CratesError("Failed to run `cargo publish`", {
@@ -5218,35 +5255,43 @@ var CratesError2 = class extends AbstractError {
     this.stack = "";
   }
 };
-async function getCrateName() {
-  const eco = new RustEcosystem(process.cwd());
+async function getCrateName(packagePath) {
+  const eco = new RustEcosystem(packagePath ?? process.cwd());
   return await eco.packageName();
 }
-var cratesAvailableCheckTasks = {
-  title: "Checking crates.io availability",
-  task: async () => {
-    const packageName = await getCrateName();
-    const registry = new CratesRegistry(packageName);
-    if (!await registry.isInstalled()) {
-      throw new CratesError2(
-        "cargo is not installed. Please install Rust toolchain to proceed."
-      );
+function createCratesAvailableCheckTask(packagePath) {
+  const label = packagePath ? ` (${packagePath})` : "";
+  return {
+    title: `Checking crates.io availability${label}`,
+    task: async () => {
+      const packageName = await getCrateName(packagePath);
+      const registry = new CratesRegistry(packageName);
+      if (!await registry.isInstalled()) {
+        throw new CratesError2(
+          "cargo is not installed. Please install Rust toolchain to proceed."
+        );
+      }
+      if (!await registry.hasPermission()) {
+        throw new CratesError2(
+          "No crates.io credentials found. Run `cargo login` or set CARGO_REGISTRY_TOKEN."
+        );
+      }
     }
-    if (!await registry.hasPermission()) {
-      throw new CratesError2(
-        "No crates.io credentials found. Run `cargo login` or set CARGO_REGISTRY_TOKEN."
-      );
+  };
+}
+function createCratesPublishTask(packagePath) {
+  const label = packagePath ? ` (${packagePath})` : "";
+  return {
+    title: `Publishing to crates.io${label}`,
+    task: async () => {
+      const packageName = await getCrateName(packagePath);
+      const registry = new CratesRegistry(packageName);
+      await registry.publish(packagePath);
     }
-  }
-};
-var cratesPublishTasks = {
-  title: "Publishing to crates.io",
-  task: async () => {
-    const packageName = await getCrateName();
-    const registry = new CratesRegistry(packageName);
-    await registry.publish();
-  }
-};
+  };
+}
+var cratesAvailableCheckTasks = createCratesAvailableCheckTask();
+var cratesPublishTasks = createCratesPublishTask();
 
 // src/tasks/jsr.ts
 import process8 from "node:process";
@@ -5259,7 +5304,7 @@ import { exec as exec4, NonZeroExitError } from "tinyexec";
 // src/utils/db.ts
 import { createCipheriv, createDecipheriv, createHash } from "node:crypto";
 import { mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import path4 from "node:path";
+import path5 from "node:path";
 var a = "aes-256-cbc";
 var n = statSync(import.meta.dirname);
 var k = `${n.rdev}${n.birthtimeMs}${n.nlink}${n.gid}`;
@@ -5274,7 +5319,7 @@ function d(g, h) {
 }
 var Db = class {
   constructor() {
-    __publicField(this, "path", path4.resolve(import.meta.dirname, ".pubm"));
+    __publicField(this, "path", path5.resolve(import.meta.dirname, ".pubm"));
     try {
       if (!statSync(this.path).isDirectory()) {
         mkdirSync(this.path);
@@ -5292,7 +5337,7 @@ var Db = class {
   set(field, value) {
     try {
       writeFileSync(
-        path4.resolve(
+        path5.resolve(
           this.path,
           Buffer.from(e(field, field)).toString("base64")
         ),
@@ -5306,7 +5351,7 @@ var Db = class {
     }
   }
   get(field) {
-    const filePath = path4.resolve(
+    const filePath = path5.resolve(
       this.path,
       Buffer.from(e(field, field)).toString("base64")
     );
@@ -6143,9 +6188,7 @@ var npmAvailableCheckTasks = {
             child.stderr?.on("data", onData);
             child.on(
               "close",
-              (code) => code === 0 ? resolve() : reject(
-                new Error(`npm login exited with code ${code}`)
-              )
+              (code) => code === 0 ? resolve() : reject(new Error(`npm login exited with code ${code}`))
             );
             child.on("error", reject);
           });
@@ -6448,7 +6491,7 @@ var requiredConditionsCheckTask = (options) => createListr({
       {
         title: "Ping registries",
         task: (ctx, parentTask2) => parentTask2.newListr(
-          ctx.registries.map((registryKey) => ({
+          collectRegistries(ctx).map((registryKey) => ({
             title: `Ping to ${registryKey}`,
             task: async () => {
               const registry = await getRegistry(registryKey);
@@ -6465,8 +6508,8 @@ var requiredConditionsCheckTask = (options) => createListr({
         task: async (_2, parentTask2) => parentTask2.newListr(
           [
             {
-              enabled: (ctx) => ctx.registries.some((registry) => registry !== "jsr"),
-              title: "Verifying if npm are installed",
+              enabled: (ctx) => collectRegistries(ctx).includes("npm"),
+              title: "Verifying if npm is installed",
               task: async () => {
                 const npm = await npmRegistry();
                 if (!await npm.isInstalled()) {
@@ -6477,7 +6520,9 @@ var requiredConditionsCheckTask = (options) => createListr({
               }
             },
             {
-              enabled: (ctx) => ctx.registries.some((registry) => registry === "jsr"),
+              enabled: (ctx) => collectRegistries(ctx).some(
+                (registry) => registry === "jsr"
+              ),
               title: "Verifying if jsr are installed",
               task: async (_3, task) => {
                 const jsr = await jsrRegistry();
@@ -6508,7 +6553,7 @@ var requiredConditionsCheckTask = (options) => createListr({
       },
       {
         title: "Checking if test and build scripts exist",
-        skip: (ctx) => !needsPackageScripts(ctx.registries),
+        skip: (ctx) => !needsPackageScripts(collectRegistries(ctx)),
         task: async (ctx) => {
           const { scripts } = await getPackageJson();
           const errors = [];
@@ -6536,23 +6581,42 @@ var requiredConditionsCheckTask = (options) => createListr({
       },
       {
         title: "Checking available registries for publishing",
-        task: (ctx, parentTask2) => parentTask2.newListr(
-          ctx.registries.map((registryKey) => {
-            switch (registryKey) {
-              case "npm":
-                return npmAvailableCheckTasks;
-              case "jsr":
-                return jsrAvailableCheckTasks;
-              case "crates":
-                return cratesAvailableCheckTasks;
-              default:
-                return npmAvailableCheckTasks;
-            }
-          }),
-          {
-            concurrent: true
+        task: (ctx, parentTask2) => {
+          if (ctx.packages?.length) {
+            const tasks = ctx.packages.flatMap(
+              (pkg) => pkg.registries.map((registryKey) => {
+                switch (registryKey) {
+                  case "npm":
+                    return npmAvailableCheckTasks;
+                  case "jsr":
+                    return jsrAvailableCheckTasks;
+                  case "crates":
+                    return createCratesAvailableCheckTask(pkg.path);
+                  default:
+                    return npmAvailableCheckTasks;
+                }
+              })
+            );
+            return parentTask2.newListr(tasks, { concurrent: true });
           }
-        )
+          return parentTask2.newListr(
+            collectRegistries(ctx).map((registryKey) => {
+              switch (registryKey) {
+                case "npm":
+                  return npmAvailableCheckTasks;
+                case "jsr":
+                  return jsrAvailableCheckTasks;
+                case "crates":
+                  return cratesAvailableCheckTasks;
+                default:
+                  return npmAvailableCheckTasks;
+              }
+            }),
+            {
+              concurrent: true
+            }
+          );
+        }
       }
     ],
     {
@@ -6564,21 +6628,27 @@ var requiredConditionsCheckTask = (options) => createListr({
 // src/tasks/runner.ts
 var { open: open3 } = npmCli3;
 var { prerelease } = SemVer;
-function collectRegistries(ctx) {
+function registryTask(registry) {
+  switch (registry) {
+    case "npm":
+      return npmPublishTasks;
+    case "jsr":
+      return jsrPublishTasks;
+    case "crates":
+      return cratesPublishTasks;
+    default:
+      return npmPublishTasks;
+  }
+}
+function collectPublishTasks(ctx) {
   if (ctx.packages?.length) {
-    const seen = /* @__PURE__ */ new Set();
-    const result = [];
-    for (const pkg of ctx.packages) {
-      for (const reg of pkg.registries) {
-        if (!seen.has(reg)) {
-          seen.add(reg);
-          result.push(reg);
-        }
-      }
-    }
-    return result;
+    return ctx.packages.flatMap(
+      (pkg) => pkg.registries.map(
+        (reg) => reg === "crates" ? createCratesPublishTask(pkg.path) : registryTask(reg)
+      )
+    );
   }
-  return ctx.registries;
+  return collectRegistries(ctx).map(registryTask);
 }
 async function run(options) {
   const ctx = {
@@ -6598,21 +6668,9 @@ async function run(options) {
     await createListr(
       options.publishOnly ? {
         title: "Publishing",
-        task: (ctx2, parentTask) => parentTask.newListr(
-          collectRegistries(ctx2).map((registry) => {
-            switch (registry) {
-              case "npm":
-                return npmPublishTasks;
-              case "jsr":
-                return jsrPublishTasks;
-              case "crates":
-                return cratesPublishTasks;
-              default:
-                return npmPublishTasks;
-            }
-          }),
-          { concurrent: true }
-        )
+        task: (ctx2, parentTask) => parentTask.newListr(collectPublishTasks(ctx2), {
+          concurrent: true
+        })
       } : [
         {
           skip: options.skipTests,
@@ -6681,7 +6739,10 @@ async function run(options) {
               }
             }, ctx2);
             await git.reset();
-            const replaced = await replaceVersion(ctx2.version);
+            const replaced = await replaceVersion(
+              ctx2.version,
+              ctx2.packages
+            );
             for (const replacedFile of replaced) {
               await git.stage(replacedFile);
             }
@@ -6696,21 +6757,9 @@ async function run(options) {
         {
           skip: (ctx2) => options.skipPublish || !!ctx2.preview,
           title: "Publishing",
-          task: (ctx2, parentTask) => parentTask.newListr(
-            collectRegistries(ctx2).map((registry) => {
-              switch (registry) {
-                case "npm":
-                  return npmPublishTasks;
-                case "jsr":
-                  return jsrPublishTasks;
-                case "crates":
-                  return cratesPublishTasks;
-                default:
-                  return npmPublishTasks;
-              }
-            }),
-            { concurrent: true }
-          )
+          task: (ctx2, parentTask) => parentTask.newListr(collectPublishTasks(ctx2), {
+            concurrent: true
+          })
         },
         {
           title: "Pushing tags to GitHub",
@@ -6755,12 +6804,26 @@ ${repositoryUrl}/compare/${lastRev}...${latestTag}`;
         }
       ]
     ).run(ctx);
-    const npmPackageName = (await getPackageJson()).name;
-    const jsrPackageName = (await getJsrJson()).name;
+    const registries = collectRegistries(ctx);
+    const parts = [];
+    if (registries.includes("npm")) {
+      const npmPackageName = (await getPackageJson()).name;
+      parts.push(`${color.bold(npmPackageName)} on ${color.green("npm")}`);
+    }
+    if (registries.includes("jsr")) {
+      const jsrPackageName = (await getJsrJson()).name;
+      parts.push(`${color.bold(jsrPackageName)} on ${color.yellow("jsr")}`);
+    }
+    if (registries.includes("crates")) {
+      const crateNames = ctx.packages?.filter((pkg) => pkg.registries.includes("crates")).map((pkg) => pkg.path) ?? ["crate"];
+      for (const name of crateNames) {
+        parts.push(`${color.bold(name)} on ${color.red("crates.io")}`);
+      }
+    }
     console.log(
       `
 
-\u{1F680} Successfully published ${color.bold(npmPackageName)} on ${color.green("npm")} and ${color.bold(jsrPackageName)} on ${color.yellow("jsr")} ${color.blueBright(`v${ctx.version}`)} \u{1F680}
+\u{1F680} Successfully published ${parts.join(", ")} ${color.blueBright(`v${ctx.version}`)} \u{1F680}
 `
     );
   } catch (e2) {
@@ -6812,11 +6875,11 @@ function generateChangelog(version2, entries, depUpdates) {
 
 // src/changeset/migrate.ts
 import { copyFileSync, existsSync, mkdirSync as mkdirSync2, readdirSync } from "node:fs";
-import path5 from "node:path";
+import path6 from "node:path";
 import process11 from "node:process";
 var SKIPPED_FILES = /* @__PURE__ */ new Set(["config.json", "README.md"]);
 function migrateFromChangesets(cwd = process11.cwd()) {
-  const changesetDir = path5.join(cwd, ".changeset");
+  const changesetDir = path6.join(cwd, ".changeset");
   if (!existsSync(changesetDir)) {
     return {
       success: false,
@@ -6825,7 +6888,7 @@ function migrateFromChangesets(cwd = process11.cwd()) {
       configMigrated: false
     };
   }
-  const pubmDir = path5.join(cwd, ".pubm", "changesets");
+  const pubmDir = path6.join(cwd, ".pubm", "changesets");
   mkdirSync2(pubmDir, { recursive: true });
   const files = readdirSync(changesetDir);
   const migratedFiles = [];
@@ -6840,15 +6903,15 @@ function migrateFromChangesets(cwd = process11.cwd()) {
     }
     if (file === "pre.json") {
       copyFileSync(
-        path5.join(changesetDir, file),
-        path5.resolve(cwd, ".pubm", "pre.json")
+        path6.join(changesetDir, file),
+        path6.resolve(cwd, ".pubm", "pre.json")
       );
       migratedFiles.push(file);
       continue;
     }
     if (file.endsWith(".md")) {
-      const src = path5.join(changesetDir, file);
-      const dest = path5.join(pubmDir, file);
+      const src = path6.join(changesetDir, file);
+      const dest = path6.join(pubmDir, file);
       copyFileSync(src, dest);
       migratedFiles.push(file);
     }
@@ -6895,10 +6958,10 @@ function parseChangeset(content, fileName) {
 
 // src/changeset/reader.ts
 import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "node:fs";
-import path6 from "node:path";
+import path7 from "node:path";
 import process12 from "node:process";
 function readChangesets(cwd = process12.cwd()) {
-  const changesetsDir = path6.join(cwd, ".pubm", "changesets");
+  const changesetsDir = path7.join(cwd, ".pubm", "changesets");
   if (!existsSync2(changesetsDir)) {
     return [];
   }
@@ -6908,7 +6971,7 @@ function readChangesets(cwd = process12.cwd()) {
     if (!file.endsWith(".md") || file === "README.md") {
       continue;
     }
-    const filePath = path6.join(changesetsDir, file);
+    const filePath = path7.join(changesetsDir, file);
     const content = readFileSync2(filePath, "utf-8");
     changesets.push(parseChangeset(content, file));
   }
@@ -6978,7 +7041,7 @@ function calculateVersionBumps(currentVersions, cwd = process14.cwd()) {
 
 // src/changeset/writer.ts
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import path7 from "node:path";
+import path8 from "node:path";
 import process15 from "node:process";
 import { stringify as stringifyYaml } from "yaml";
 var adjectives = [
@@ -7073,11 +7136,11 @@ ${summary}
   return content;
 }
 function writeChangeset(releases, summary, cwd = process15.cwd()) {
-  const changesetsDir = path7.join(cwd, ".pubm", "changesets");
+  const changesetsDir = path8.join(cwd, ".pubm", "changesets");
   mkdirSync3(changesetsDir, { recursive: true });
   const id = generateChangesetId();
   const fileName = `${id}.md`;
-  const filePath = path7.join(changesetsDir, fileName);
+  const filePath = path8.join(changesetsDir, fileName);
   const content = generateChangesetContent(releases, summary);
   writeFileSync2(filePath, content, "utf-8");
   return filePath;
@@ -7136,7 +7199,7 @@ function topologicalSort(graph) {
 
 // src/monorepo/discover.ts
 import { existsSync as existsSync4, readdirSync as readdirSync3, statSync as statSync2 } from "node:fs";
-import path8 from "node:path";
+import path9 from "node:path";
 import micromatch from "micromatch";
 
 // src/monorepo/workspace.ts
@@ -7219,9 +7282,9 @@ import {
   rmSync,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import path9 from "node:path";
+import path10 from "node:path";
 function getPreStatePath(cwd) {
-  return path9.resolve(cwd ?? process.cwd(), ".pubm", "pre.json");
+  return path10.resolve(cwd ?? process.cwd(), ".pubm", "pre.json");
 }
 function readPreState(cwd) {
   const filePath = getPreStatePath(cwd);
@@ -7238,7 +7301,7 @@ function enterPreMode(tag, cwd) {
       "Already in pre mode. Exit pre mode first before entering a new one."
     );
   }
-  const dir = path9.dirname(filePath);
+  const dir = path10.dirname(filePath);
   if (!existsSync5(dir)) {
     mkdirSync4(dir, { recursive: true });
   }
@@ -7280,10 +7343,10 @@ function generateSnapshotVersion(options) {
 
 // src/validate/entry-points.ts
 import { existsSync as existsSync6 } from "node:fs";
-import path10 from "node:path";
+import path11 from "node:path";
 var SIMPLE_FIELDS = ["main", "module", "types", "typings"];
 function checkPath(filePath, cwd) {
-  return existsSync6(path10.resolve(cwd, filePath));
+  return existsSync6(path11.resolve(cwd, filePath));
 }
 function validateExports(exports, cwd, prefix = "exports") {
   const errors = [];